From 343842aff9bef2da9624edf0aacc1790753da05e Mon Sep 17 00:00:00 2001 From: Sanjay Kholiya Date: Mon, 16 Nov 2026 23:09:17 +0530 Subject: [PATCH 01/48] Walk the note once for its semantics, not once for every widget in it The field works out its semantics information, an entry for every run of the note's text, each time its semantics are marked dirty, and it marks them for every widget it takes in. Opening a note walked the whole of it once for each picture in it, whenever the semantics tree is on, and in the macOS app it always is: AccessibilityTree.swift switches it on at launch so that dictation tools can write into the editor. The span the controller builds now works the information out once and keeps it. Formulas, drawn as widgets in the text by the commits that follow, are where it shows: in a debug build, a 5,000-line note with 350 of them opened in 16.1 s without this and in 4.8 s with it. --- lib/ui/editor/highlighting_controller.dart | 20 +++++++++++++++++++- test/note_editor_test.dart | 18 ++++++++++++++++++ 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/lib/ui/editor/highlighting_controller.dart b/lib/ui/editor/highlighting_controller.dart index e9e074a..b6a58d0 100644 --- a/lib/ui/editor/highlighting_controller.dart +++ b/lib/ui/editor/highlighting_controller.dart @@ -502,7 +502,7 @@ class HighlightingController extends TextEditingController { ); } - return TextSpan(style: base, children: children); + return _NoteSpan(style: base, children: children); } /// The room a list marker takes — a bullet, a box or a number, with the @@ -783,3 +783,21 @@ class HighlightingController extends TextEditingController { /// Letter spacing over [start, end): see /// [HighlightingController._listStretches]. typedef _Stretch = ({int start, int end, double spacing}); + +/// The text the field draws, which works out its semantics information once +/// and keeps it. +/// +/// The field works that information out afresh, over every run in the note, +/// each time its semantics are marked dirty, and taking in a widget marks +/// them. So without this, opening a note with hundreds of formulas walked the +/// whole note that many times over whenever the semantics tree was on, and on +/// macOS it always is, for dictation: see `AccessibilityTree.swift`. +class _NoteSpan extends TextSpan { + _NoteSpan({super.style, super.children}); + + late final List _semantics = + List.unmodifiable(super.getSemanticsInformation()); + + @override + List getSemanticsInformation() => _semantics; +} diff --git a/test/note_editor_test.dart b/test/note_editor_test.dart index a0aef98..4523a17 100644 --- a/test/note_editor_test.dart +++ b/test/note_editor_test.dart @@ -222,6 +222,24 @@ void main() { expect(decoration.focusedErrorBorder, InputBorder.none); }); + testWidgets('works out what the note says to the semantics tree once', ( + tester, + ) async { + const body = 'Bread 4\nMilk 2\n\n# Shopping'; + await tester.pumpWidget(harness(body, autofocus: true)); + await tester.pumpAndSettle(); + + // The field asks again whenever its semantics are marked dirty, which it + // does for every widget it takes in, and each answer walks the note. + final text = tester + .state(find.byType(EditableText)) + .renderEditable + .text!; + final semantics = text.getSemanticsInformation(); + expect(semantics.map((info) => info.text).join(), body); + expect(text.getSemanticsInformation(), same(semantics)); + }); + testWidgets('ticking a box celebrates, unticking it does not', ( tester, ) async { From 378345700bac429e279fabc8baa1189bf1ecea15 Mon Sep 17 00:00:00 2001 From: Sanjay Kholiya Date: Mon, 16 Nov 2026 23:09:18 +0530 Subject: [PATCH 02/48] Read TeX between dollar signs as math, by pandoc's rules MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A note pasted from ChatGPT, Gemini or Wikipedia writes its maths as $…$ among words and $$…$$ set apart. Both are now read as formulas, by the rules pandoc reads them by, so that a note about money keeps its prices: the opening $ of $…$ has no space after it, and the closing one no space before it and no digit after it, which keeps "$5 and $10" two prices rather than one formula. A $$ starting a line opens a block that runs to the $$ ending one, with no blank line between, so the lines of an aligned equation stay TeX rather than becoming a list. A formula is literal, the way code is: its TeX is shown in code's face with its dollar signs quiet, the calculator reads none of it, and spelling leaves it alone. In a table's cell it stays its TeX. dart_markdown reads plain words in runs until it is given an inline syntax of its own, and then a word at a time, in case that syntax starts at a space or a letter. The dollar sign's never does, so a syntax for runs of words keeps the reading of a long note as quick as it was: otherwise every word becomes a text node of its own, and the parse of a 5,000-line note takes more than twice as long. --- lib/ui/editor/highlighting_controller.dart | 5 +- lib/ui/editor/markdown_syntax.dart | 287 ++++++++++++++++++++- lib/ui/editor/note_editor.dart | 6 +- test/markdown_syntax_test.dart | 78 ++++++ 4 files changed, 372 insertions(+), 4 deletions(-) diff --git a/lib/ui/editor/highlighting_controller.dart b/lib/ui/editor/highlighting_controller.dart index b6a58d0..46dbe18 100644 --- a/lib/ui/editor/highlighting_controller.dart +++ b/lib/ui/editor/highlighting_controller.dart @@ -649,9 +649,12 @@ class HighlightingController extends TextEditingController { if (marked(MarkdownStyle.quote)) { result = result.copyWith(color: _palette.textSecondary); } - if (marked(MarkdownStyle.codeBlock) || marked(MarkdownStyle.code)) { + if (marked(MarkdownStyle.codeBlock) || + marked(MarkdownStyle.code) || + marked(MarkdownStyle.math)) { // The panel under a code block and the pill under inline code are drawn // behind the field, where the selection highlight still shows over them. + // A formula's TeX, shown as written, is code too. result = _codeStyle(result); } return result; diff --git a/lib/ui/editor/markdown_syntax.dart b/lib/ui/editor/markdown_syntax.dart index cd848cb..0c3392a 100644 --- a/lib/ui/editor/markdown_syntax.dart +++ b/lib/ui/editor/markdown_syntax.dart @@ -25,6 +25,10 @@ enum MarkdownStyle { /// A fenced or indented code block, fences included. codeBlock, + /// A formula in TeX, its dollar signs included, shown as its TeX in code's + /// face; see [MarkdownMath]. + math, + /// Everything inside a block quote. quote, @@ -133,6 +137,42 @@ class MarkdownTask { int get hashCode => Object.hash(box, checked); } +/// A formula written in TeX between dollar signs: `$…$` among words, or +/// `$$…$$` set apart on lines of its own. +/// +/// [start] to [end] takes the dollar signs in, and [tex] is what they hold, +/// trimmed. A formula is literal, the way code is: the calculator does not read +/// it and spelling leaves it alone. +@immutable +class MarkdownMath { + const MarkdownMath(this.start, this.end, this.tex, {required this.display}); + + final int start; + final int end; + final String tex; + + /// Set apart on lines of its own rather than written among words. + final bool display; + + MarkdownMath _shifted(int by) => + MarkdownMath(start + by, end + by, tex, display: display); + + @override + bool operator ==(Object other) => + other is MarkdownMath && + other.start == start && + other.end == end && + other.tex == tex && + other.display == display; + + @override + int get hashCode => Object.hash(start, end, tex, display); + + @override + String toString() => + 'MarkdownMath($start, $end, ${display ? 'display' : 'inline'}: $tex)'; +} + enum MarkdownBlockKind { code, quote, rule } /// A block that is drawn behind the text as well as in it: the panel under a @@ -564,6 +604,10 @@ class MarkdownAnalysis { /// Fenced and indented code blocks, which the calculator does not read. List get codeBlocks => _parts.codeBlocks; + /// Every formula outside a table, in order. One in a table's cell is drawn + /// as its TeX, in the grid. + List get maths => _parts.maths; + /// The rest of what the calculator does not read: struck-through text, and /// the `*` and `_` around emphasis — the markers only, not the words. List get unread => _parts.unread; @@ -601,6 +645,9 @@ class MarkdownAnalysis { /// this far: the parser is not shown it as emphasis in the first place. /// * Struck-through text is blanked, words and all: crossed out is not /// counted, and `Total ~~12~~ 14` is 14. + /// * Formulas are blanked, dollar signs and all. `$x^2 + 1$` is written to + /// be read, not worked out, and a price never gets this far: `$5 and $10` + /// is not a formula, by the rules [MarkdownMath] is read by. /// * A table's rows are blanked. `| 2+2 | 4 |` is a row of a grid rather than /// a sum, and a result chip beside a tall wrapped row reads as a mistake. late final String calculatorText = _neutralise(); @@ -701,6 +748,7 @@ class MarkdownAnalysis { MarkdownStyle.emphasis, MarkdownStyle.strikethrough, MarkdownStyle.code, + MarkdownStyle.math, MarkdownStyle.link, MarkdownStyle.html, }; @@ -848,6 +896,7 @@ class MarkdownAnalysis { String _neutralise() { if (codeBlocks.isEmpty && unread.isEmpty && + maths.isEmpty && containerMarkers.isEmpty && tables.isEmpty) { return text; @@ -861,7 +910,11 @@ class MarkdownAnalysis { if (unit != 0x0A && unit != 0x0D) units[i] = 0x20; } } - for (final range in [...codeBlocks, ...unread]) { + for (final range in [ + ...codeBlocks, + ...unread, + for (final math in maths) TextRange(start: math.start, end: math.end), + ]) { for (var i = range.start; i < range.end && i < units.length; i++) { final unit = units[i]; if (unit != 0x0A && unit != 0x0D) units[i] = 0x20; @@ -1044,6 +1097,7 @@ class _Parts { required this.listItems, required this.atomicPrefixes, required this.codeBlocks, + required this.maths, required this.unread, required this.literals, required this.addresses, @@ -1064,6 +1118,7 @@ class _Parts { listItems: [], atomicPrefixes: [], codeBlocks: [], + maths: [], unread: [], literals: [], addresses: [], @@ -1081,6 +1136,7 @@ class _Parts { final List listItems; final List atomicPrefixes; final List codeBlocks; + final List maths; final List unread; final List literals; final List addresses; @@ -1107,6 +1163,7 @@ class _Parts { listItems: all((p) => p.listItems, (i, by) => i._shifted(by)), atomicPrefixes: all((p) => p.atomicPrefixes, _shift), codeBlocks: all((p) => p.codeBlocks, _shift), + maths: all((p) => p.maths, (m, by) => m._shifted(by)), unread: all((p) => p.unread, _shift), literals: all((p) => p.literals, _shift), addresses: all((p) => p.addresses, _shift), @@ -1146,6 +1203,7 @@ class _Parts { listItems: const [], atomicPrefixes: const [], codeBlocks: const [], + maths: const [], unread: const [], literals: const [], addresses: const [], @@ -1332,6 +1390,7 @@ _Parts _parse(String source) { // `>>>` quote fence nothing else reads. enableEmoji: false, enableFencedBlockquote: false, + extensions: [const _DisplayMathSyntax(), _InlineMathSyntax(), _WordRun()], ); final List nodes; try { @@ -1372,6 +1431,199 @@ _Tail _tailOf(List nodes) { }; } +const _dollar = 0x24; +const _backslash = 0x5C; + +bool _isWhitespace(int unit) => + unit == 0x20 || unit == 0x09 || unit == 0x0A || unit == 0x0D; + +/// Math among words, by pandoc's rules: `$…$`, and `$$…$$`. +/// +/// The opening `$` of `$…$` has something other than a space after it, and +/// the closing one something other than a space before it and no digit after +/// it, which is what keeps `$5 and $10` two prices rather than one formula. +/// A backslash keeps the character after it, so `\$` inside a formula is a +/// dollar sign rather than its end, and `\text{…}` may hold dollar signs of +/// its own. `$$…$$` ends at the next `$$`. +class _InlineMathSyntax extends md.InlineSyntax { + _InlineMathSyntax() : super(RegExp(r'\$'), startCharacter: _dollar); + + @override + md.InlineObject? parse(md.InlineParser parser, Match match) { + final start = parser.position; + final doubled = + start + 1 < parser.length && parser.charAt(start + 1) == _dollar; + final marker = doubled ? 2 : 1; + final close = doubled + ? _doubledClose(parser, start + 2) + : _close(parser, start + 1); + // Left where it was, the parser goes on to read the `$` as text. + if (close == null) return null; + final markers = parser.consumeBy(marker); + final content = parser.consumeBy(close - start - marker); + markers.addAll(parser.consumeBy(marker)); + return md.InlineElement( + 'math', + markers: markers, + children: [for (final span in content) md.Text.fromSpan(span)], + start: markers.first.start, + end: markers.last.end, + ); + } + + static int? _close(md.InlineParser parser, int from) { + final length = parser.length; + if (from >= length || _isWhitespace(parser.charAt(from))) return null; + var i = from; + while (i < length) { + final unit = parser.charAt(i); + if (unit == _dollar) { + if (i + 1 < length && _isDigit(parser.charAt(i + 1))) return null; + return i; + } + if (unit == _backslash) { + i = _afterEscape(parser, i); + } else if (_isWhitespace(unit)) { + while (i < length && _isWhitespace(parser.charAt(i))) { + i++; + } + if (i < length && parser.charAt(i) == _dollar) return null; + } else { + i++; + } + } + return null; + } + + static int? _doubledClose(md.InlineParser parser, int from) { + final length = parser.length; + var blank = true; + var i = from; + while (i + 1 < length) { + final unit = parser.charAt(i); + if (unit == _dollar && parser.charAt(i + 1) == _dollar) { + return blank ? null : i; + } + if (!_isWhitespace(unit)) blank = false; + i = unit == _backslash ? i + 2 : i + 1; + } + return null; + } + + /// Past the escape at [at]: the backslash and the character after it, or + /// a whole `\text{…}` with its braces balanced. + static int _afterEscape(md.InlineParser parser, int at) { + const text = r'\text{'; + final length = parser.length; + if (at + text.length <= length && + parser.substring(at, at + text.length) == text) { + var depth = 0; + for (var i = at + text.length - 1; i < length; i++) { + final unit = parser.charAt(i); + if (unit == _backslash) { + i++; + } else if (unit == 0x7B) { + depth++; + } else if (unit == 0x7D && --depth == 0) { + return i + 1; + } + } + } + return at + 2 < length ? at + 2 : length; + } + + static bool _isDigit(int unit) => unit >= 0x30 && unit <= 0x39; +} + +/// Words and the spaces between them, passed over as one run of text. +/// +/// The parser does this itself until it is given a syntax of its own, and +/// then goes a word at a time, in case that syntax starts at a space or a +/// letter, which [_InlineMathSyntax] never does. A word at a time, each word +/// of a note is cut out as text of its own, placed by counting from the start +/// of its line, and reading a long note takes more than twice as long. +class _WordRun extends md.InlineSyntax { + _WordRun() : super(RegExp(r'[ \tA-Za-z0-9]*[A-Za-z0-9](?=\s)')); + + @override + md.InlineObject? parse(md.InlineParser parser, Match match) { + parser.advanceBy(match[0]!.length); + return null; + } +} + +/// Display math: `$$` at the start of a line, and the TeX up to the `$$` +/// that closes it at the end of one, the same line or a later one. +/// +/// Pandoc reads `$$…$$` wherever it is written. Read as a block, the lines +/// between are TeX rather than markdown, so the `- b` of an aligned equation +/// stays a line of it rather than starting a list. As in pandoc there is no +/// blank line inside one. A `$$` closed anywhere but the end of a line, as in +/// `$$x$$ and more`, is math among words, and left to [_InlineMathSyntax]. +class _DisplayMathSyntax extends md.BlockSyntax { + const _DisplayMathSyntax(); + + static final _opening = RegExp(r'^ {0,3}\$\$'); + + @override + RegExp get pattern => _opening; + + @override + bool canParse(md.BlockParser parser) => _close(parser) != null; + + @override + md.BlockElement? parse(md.BlockParser parser) { + final close = _close(parser); + if (close == null) return null; + final (last, column) = close; + final open = _opening.matchAsPrefix(parser.current.content.text)!; + final markers = [ + md.Text.fromSpan(parser.current.content).subText(open.end - 2, open.end), + ]; + final children = []; + for (var line = 0; line <= last; line++) { + final content = md.Text.fromSpan(parser.current.content); + final from = line == 0 ? open.end : 0; + final to = line == last ? column : content.length; + if (to > from) children.add(content.subText(from, to)); + if (line == last) markers.add(content.subText(column, column + 2)); + parser.advance(); + } + return md.BlockElement( + 'displayMath', + markers: markers, + children: children, + start: markers.first.start, + end: markers.last.end, + ); + } + + /// The line, counted from the current one, and the column of the `$$` that + /// closes the formula the current line opens, if it opens one. + static (int, int)? _close(md.BlockParser parser) { + final open = _opening.matchAsPrefix(parser.current.content.text); + if (open == null) return null; + var blank = true; + for (var ahead = 0; ; ahead++) { + final line = parser.peek(ahead); + if (line == null || (ahead > 0 && line.isBlankLine)) return null; + final text = line.content.text; + var i = ahead == 0 ? open.end : 0; + while (i < text.length) { + final unit = text.codeUnitAt(i); + if (unit == _dollar && + i + 1 < text.length && + text.codeUnitAt(i + 1) == _dollar) { + if (blank || text.substring(i + 2).trim().isNotEmpty) return null; + return (ahead, i); + } + if (!_isWhitespace(unit)) blank = false; + i = unit == _backslash ? i + 2 : i + 1; + } + } + } +} + /// Walks the parser's tree and flattens it into what the editor draws. class _Collector { _Collector(this.source); @@ -1386,6 +1638,7 @@ class _Collector { final _tables = []; final _listItems = []; final _codeBlocks = []; + final _maths = []; final _unread = []; final _literals = []; final _addresses = []; @@ -1405,6 +1658,7 @@ class _Collector { _ornaments.sort((a, b) => a.start.compareTo(b.start)); _tables.sort((a, b) => a.start.compareTo(b.start)); _listItems.sort((a, b) => a.markerStart.compareTo(b.markerStart)); + _maths.sort((a, b) => a.start.compareTo(b.start)); for (final ranges in [ _codeBlocks, _unread, @@ -1426,6 +1680,7 @@ class _Collector { listItems: List.unmodifiable(_listItems), atomicPrefixes: List.unmodifiable(_atomicPrefixes()), codeBlocks: List.unmodifiable(_codeBlocks), + maths: List.unmodifiable(_maths), unread: List.unmodifiable(_unread), literals: List.unmodifiable(_literals), addresses: List.unmodifiable(_addresses), @@ -1713,6 +1968,8 @@ class _Collector { case 'htmlBlock' || 'rawHtml': _style(start, end, MarkdownStyle.html); _record(_literals, start, end); + case 'math' || 'displayMath': + _math(node, claimed); case 'linkReferenceDefinition': // Bookkeeping, not writing: GitHub shows none of it, and neither does // this until the caret is on it. @@ -1849,6 +2106,34 @@ class _Collector { } } + /// Whether [offset] is in the table being read: a cell's words are drawn by + /// its grid, which shows a formula as its TeX. + bool _inTable(int offset) => + _tables.isNotEmpty && + offset >= _tables.last.start && + offset < _tables.last.end; + + /// A formula: its TeX shown as code with its dollar signs quiet, and + /// outside a table one of [MarkdownAnalysis.maths]. + void _math(md.Element node, Set claimed) { + final start = node.start.offset; + final end = node.end.offset; + _style(start, end, MarkdownStyle.math); + _record(_literals, start, end); + for (final marker in node.markers) { + claimed.add(marker.start.offset); + _style(marker.start.offset, marker.end.offset, MarkdownStyle.syntax); + } + final range = _range(start, end); + if (range == null || _inTable(start)) return; + final display = node.type == 'displayMath'; + final tex = _unmask( + node.children.map((piece) => piece.textContent).join(display ? '\n' : ''), + ).trim(); + if (tex.isEmpty) return; + _maths.add(MarkdownMath(range.start, range.end, tex, display: display)); + } + void _listItem( md.Element node, Set claimed, { diff --git a/lib/ui/editor/note_editor.dart b/lib/ui/editor/note_editor.dart index 396fe30..eb2af74 100644 --- a/lib/ui/editor/note_editor.dart +++ b/lib/ui/editor/note_editor.dart @@ -5527,8 +5527,10 @@ class NoteEditorState extends State with WidgetsBindingObserver { ); // The pill inline code has in the text can be a plain // background in a grid painted behind it: there is no - // selection to show over it there. - return styles.contains(MarkdownStyle.code) + // selection to show over it there. A formula in a cell + // is drawn as its TeX, which is code too. + return styles.contains(MarkdownStyle.code) || + styles.contains(MarkdownStyle.math) ? drawn.copyWith( backgroundColor: palette.controlBackground, ) diff --git a/test/markdown_syntax_test.dart b/test/markdown_syntax_test.dart index c106650..9caec34 100644 --- a/test/markdown_syntax_test.dart +++ b/test/markdown_syntax_test.dart @@ -482,6 +482,83 @@ void main() { }); }); + group('math', () { + List formulas(String note) => [ + for (final math in read(note).maths) + '${math.display ? 'display' : 'inline'} ${math.start}-${math.end} ' + '${math.tex}', + ]; + + test('is never a price', () { + for (final note in [ + r'$5 and $10', + r'$4.50 + $3', + r'costs $5, total $10', + r'between $5-$10', + r'a $x$5 b', + r'paid \$5 and \$10', + ]) { + expect(formulas(note), isEmpty, reason: note); + } + const prices = r'$5 and $10'; + expect(identical(read(prices).calculatorText, prices), isTrue); + }); + + test('is read among words by pandoc\'s rules', () { + expect(formulas(r'The area is $\pi r^2$ here'), [ + r'inline 12-21 \pi r^2', + ]); + // A backslash keeps a dollar sign inside, and \text{} may hold some. + expect(formulas(r'$a \$ b$'), [r'inline 0-8 a \$ b']); + expect(formulas(r'$\text{costs $5}$ ok'), [ + r'inline 0-17 \text{costs $5}', + ]); + expect(formulas(r'\$5 and \$10 and $y$'), ['inline 17-20 y']); + expect(formulas('a \$b +\nc\$ d'), ['inline 2-9 b +\nc']); + expect(formulas(r'`code $x$` and $y$'), ['inline 15-18 y']); + // Among words, $$ is a formula among words too. + expect(formulas(r'math $$x^2$$ among words'), ['inline 5-12 x^2']); + }); + + test('set apart is TeX up to its closing \$\$', () { + const note = '\$\$\nx^2\n- y\n\$\$\n\nafter'; + expect(formulas(note), ['display 0-13 x^2\n- y']); + expect(read(note).listItems, isEmpty, reason: '- y is TeX'); + expect(formulas(r'$$x = 1$$'), ['display 0-9 x = 1']); + expect(formulas('para\n\$\$\nz\n\$\$\nmore'), ['display 5-12 z']); + expect(formulas('> \$\$\n> a\n> \$\$'), ['display 2-13 a']); + expect(formulas('- item\n\n \$\$\n a + b\n \$\$'), [ + 'display 10-25 a + b', + ]); + }); + + test('set apart needs its closing \$\$ before a blank line', () { + expect(formulas('\$\$\nunclosed\n\nnext'), isEmpty); + expect(formulas(r'$$'), isEmpty); + }); + + test('is literal, and the calculator reads none of it', () { + const note = r'5 + 3 and $1 + 1$'; + final analysis = read(note); + expect(stylesOf(analysis, r'$1 + 1$'), contains(MarkdownStyle.math)); + expect(analysis.isLiteral(10, 17), isTrue); + expect(analysis.calculatorText, '5 + 3 and '.padRight(note.length)); + }); + + test('in a table is left to the grid, which shows its TeX', () { + final analysis = read('| a |\n|---|\n| \$x\$ |'); + expect(analysis.maths, isEmpty); + final cell = analysis.tables.single.rows[1].cells.single; + expect( + [ + for (final run in analysis.runsIn(cell.start, cell.end)) + '${run.text}:${run.styles.map((style) => style.name).join('+')}', + ], + [r'$x$:math'], + ); + }); + }); + group('reading in pieces', () { const vocabulary = [ '', '', '', ' ', '\t', // @@ -540,6 +617,7 @@ void main() { ]}', ], ranges(analysis.atomicPrefixes), + [for (final math in analysis.maths) math.toString()], analysis.calculatorText, ]; } From 245c8f6886f642183325522f43eab116958bf46d Mon Sep 17 00:00:00 2001 From: Sanjay Kholiya Date: Mon, 16 Nov 2026 23:09:18 +0530 Subject: [PATCH 03/48] Draw TeX formulas in place of their source A formula outside a table is now drawn by flutter_math_fork where its TeX was, a tenth bigger than the words around it and in their colour: among words on their baseline, and set apart in the middle of a line of its own, centred across the writing column. With the caret in it, it shows its TeX again. TeX it cannot read stays written out in code's face, never an error box, and a formula wider than the column is drawn smaller rather than cut off. A text engine has to be told how big every placeholder is before it breaks lines, and everything that measures the note apart from the field has only the numbers, so each formula is laid out once in a widget tree of its own that is never shown, and its size kept. Its widget is kept too, one for every formula in the note: flutter_math_fork keys what it builds with a GlobalKey held in the parsed TeX, so one widget in two places would take its lines from the first. What pandoc and Wikipedia write that flutter_math_fork does not read is read as what it has: align, alignat and split become aligned and alignedat, an equation's environment goes, \sgn is the sign function, and a phantom of a sized delimiter written without braces gets them. A formula's glyphs stay out of the semantics tree, where the note's text already gives its TeX. A note with a formula gives up the forced one-line strut, as one with a picture or a table does, so that moving the caret onto a formula never moves every line. flutter_math_fork is Apache-2.0. The KaTeX fonts it bundles, about 660 KB, are MIT, and their notice now ships with the app. --- assets/fonts/README.md | 10 + lib/ui/editor/highlighting_controller.dart | 214 +++++++++++++++++-- lib/ui/editor/markdown_syntax.dart | 64 +++++- lib/ui/editor/note_editor.dart | 14 +- lib/ui/editor/note_math.dart | 234 +++++++++++++++++++++ pubspec.lock | 32 +++ pubspec.yaml | 9 + test/markdown_syntax_test.dart | 29 +++ test/note_editor_markdown_test.dart | 125 +++++++++++ test/note_math_test.dart | 99 +++++++++ test/test_fonts.dart | 15 ++ 11 files changed, 822 insertions(+), 23 deletions(-) create mode 100644 lib/ui/editor/note_math.dart create mode 100644 test/note_math_test.dart diff --git a/assets/fonts/README.md b/assets/fonts/README.md index fecfa8a..52b027c 100644 --- a/assets/fonts/README.md +++ b/assets/fonts/README.md @@ -31,6 +31,16 @@ with the new ones, from the upstream files, or the change will not show. License: [`ShantellSans-OFL.txt`](ShantellSans-OFL.txt) +## Formula fonts + +Formulas written in TeX are drawn in KaTeX's fonts, which come with +flutter_math_fork rather than living here: twenty files, about 660 KB in +every install. They are MIT licensed by Khan Academy, and that notice ships +as `packages/flutter_math_fork/katex_fonts/LICENSE`, listed in +`pubspec.yaml`, since the package's own LICENSE does not carry it. + +Source: + ## Brand font The `Kapy Notes` wordmark uses Odin Rounded Bold by Frank Hemmekam. diff --git a/lib/ui/editor/highlighting_controller.dart b/lib/ui/editor/highlighting_controller.dart index 46dbe18..cf96e32 100644 --- a/lib/ui/editor/highlighting_controller.dart +++ b/lib/ui/editor/highlighting_controller.dart @@ -11,6 +11,7 @@ import '../../core/theme.dart'; import '../../data/note_format.dart'; import 'editor_formatting.dart'; import 'markdown_syntax.dart'; +import 'note_math.dart'; /// One image, already sized and built, ready to be dropped into the span tree /// at its placeholder. @@ -47,6 +48,9 @@ class HighlightingController extends TextEditingController { bool _markdown; final MarkdownAnalyzer _markdownAnalyzer = MarkdownAnalyzer(); Map _imageSpans = const {}; + final NoteMath _math = NoteMath(); + double _mathWidth = 0; + List<(int, PlaceholderDimensions)> _formulaPlaceholders = const []; /// Native spelling results currently painted by this rich text controller. /// @@ -139,6 +143,7 @@ class HighlightingController extends TextEditingController { selection, revealBlocks: markdownReveal.blocks, revealEdges: markdownReveal.edges, + drawable: (math) => _math.draws(math.tex), ); _concealment = concealment; _concealedFor = analysis; @@ -163,17 +168,30 @@ class HighlightingController extends TextEditingController { _imageSpans = value; } + /// Deliberately silent, for the same reason as [setImageSpansDuringLayout]. + /// + /// The width of the writing column a formula is drawn in: display math is + /// centred across it, and any formula wider than it is drawn smaller. + void setMathWidthDuringLayout(double value) { + _mathWidth = value; + } + /// The placeholder boxes [TextPainter] must be told about before it can lay - /// out a span containing [WidgetSpan]s, in the order they appear. + /// out a span containing [WidgetSpan]s, in the order they appear: pictures, + /// table rows, and the formulas the last [buildTextSpan] drew. List placeholderDimensions() { - final offsets = _imageSpans.keys.toList()..sort(); - return [ - for (final offset in offsets) - PlaceholderDimensions( - size: Size(_imageSpans[offset]!.width, _imageSpans[offset]!.height), - alignment: PlaceholderAlignment.top, + final placeholders = [ + for (final MapEntry(key: offset, value: image) in _imageSpans.entries) + ( + offset, + PlaceholderDimensions( + size: Size(image.width, image.height), + alignment: PlaceholderAlignment.top, + ), ), - ]; + ..._formulaPlaceholders, + ]..sort((a, b) => a.$1.compareTo(b.$1)); + return [for (final (_, dimensions) in placeholders) dimensions]; } void _invalidate() { @@ -235,11 +253,10 @@ class HighlightingController extends TextEditingController { final concealment = markdownConcealment(); final hidden = concealment.hidden; final transparent = concealment.transparent; - final stretches = _listStretches( - analysis, - base, - MediaQuery.maybeTextScalerOf(context) ?? TextScaler.noScaling, - ); + final scaler = + MediaQuery.maybeTextScalerOf(context) ?? TextScaler.noScaling; + final stretches = _listStretches(analysis, base, scaler); + final formulas = concealment.formulas; final composing = withComposing && value.isComposingRangeValid ? value.composing : null; @@ -285,6 +302,9 @@ class HighlightingController extends TextEditingController { boundaries.add(stretch.start); boundaries.add(stretch.end); } + for (final formula in formulas) { + boundaries.add(formula.start + 1); + } if (composing != null) { boundaries.add(composing.start.clamp(0, source.length)); boundaries.add(composing.end.clamp(0, source.length)); @@ -306,6 +326,9 @@ class HighlightingController extends TextEditingController { var hiddenIndex = 0; var transparentIndex = 0; var stretchIndex = 0; + var formulaIndex = 0; + final formulaCopies = {}; + final placeholders = <(int, PlaceholderDimensions)>[]; for (var i = 0; i < cuts.length - 1; i++) { final start = cuts[i]; @@ -356,6 +379,41 @@ class HighlightingController extends TextEditingController { continue; } + // A formula drawn as itself stands in the place of its first character, + // the way a picture does, with the rest of its TeX hidden after it. + while (formulaIndex < formulas.length && + formulas[formulaIndex].end <= start) { + formulaIndex++; + } + final formula = + formulaIndex < formulas.length && + formulas[formulaIndex].start <= start + ? formulas[formulaIndex] + : null; + if (formula != null && start == formula.start) { + final (span, placeholder) = _formulaSpan( + formula, + copy: formulaCopies.update( + formula.tex, + (copy) => copy + 1, + ifAbsent: () => 0, + ), + words: _markdownBlockStyle( + base, + base, + (style) => style != MarkdownStyle.math && marked(style), + ), + base: base, + scaler: scaler, + indent: formula.display + ? _indent(formula.start, hidden, stretches, base, scaler) + : 0, + ); + children.add(span); + placeholders.add((formula.start, placeholder)); + continue; + } + while (spanIndex < spans.length && spans[spanIndex].end <= start) { spanIndex++; } @@ -497,14 +555,142 @@ class HighlightingController extends TextEditingController { } } + // A line break inside a formula drawn as itself would still break the + // line, hidden or not, and leave an empty line under the formula for + // each one; the span the field draws is not the note's text, so here it + // is a space. + final words = source.substring(start, end); children.add( - TextSpan(text: source.substring(start, end), style: segmentStyle), + TextSpan( + text: formula == null ? words : words.replaceAll(_lineEnd, ' '), + style: segmentStyle, + ), ); } + _formulaPlaceholders = placeholders; return _NoteSpan(style: base, children: children); } + static final _lineEnd = RegExp('[\r\n]'); + + /// How much bigger a formula is set than the words around it. KaTeX's own + /// face runs small beside a sans serif at the same size. + static const double _mathScale = 1.1; + + /// [formula] as a placeholder, and the box [placeholderDimensions] reports + /// for it. + /// + /// Among words a formula sits on their baseline. Set apart, it is centred + /// across what is left of the writing column after [indent], in the middle + /// of a line of its own. Both are drawn in the size and colour of the words + /// they stand among, in [words]. + /// + /// A placeholder's widget is scaled with the text by the field, so it is + /// built at the size the text is before scaling, and the box is reported + /// at the size it comes out at. [copy] is which of the formulas drawn with + /// the same TeX this one is: see [NoteMath.formula]. + (WidgetSpan, PlaceholderDimensions) _formulaSpan( + MarkdownMath formula, { + required int copy, + required TextStyle words, + required TextStyle base, + required TextScaler scaler, + required double indent, + }) { + final size = base.fontSize ?? kDefaultFontSize; + final scale = scaler.scale(size) / size; + final room = math.max(0.0, _mathWidth - indent) / scale; + final drawn = _math.formula( + formula.tex, + display: formula.display, + fontSize: (words.fontSize ?? size) * _mathScale, + color: words.color ?? _palette.textPrimary, + maxWidth: room, + copy: copy, + ); + if (!formula.display) { + return ( + WidgetSpan( + alignment: PlaceholderAlignment.baseline, + baseline: TextBaseline.alphabetic, + child: drawn.child, + ), + PlaceholderDimensions( + size: Size(drawn.width * scale, drawn.height * scale), + alignment: PlaceholderAlignment.baseline, + baseline: TextBaseline.alphabetic, + baselineOffset: drawn.baseline * scale, + ), + ); + } + final width = math.max(room, drawn.width); + return ( + WidgetSpan( + alignment: PlaceholderAlignment.middle, + child: SizedBox( + width: width, + height: drawn.height, + child: Center(child: drawn.child), + ), + ), + PlaceholderDimensions( + size: Size(width * scale, drawn.height * scale), + alignment: PlaceholderAlignment.middle, + ), + ); + } + + /// How far into its line [offset] is drawn: the advance of what is shown + /// before it, with the room any list marker there is spaced out to. + double _indent( + int offset, + List hidden, + List<_Stretch> stretches, + TextStyle base, + TextScaler scaler, + ) { + final source = text; + final lineStart = offset == 0 + ? 0 + : source.lastIndexOf('\n', offset - 1) + 1; + if (lineStart >= offset) return 0; + final painter = TextPainter( + text: TextSpan( + style: base, + children: [ + for (var i = lineStart; i < offset; i++) + if (!hidden.any((range) => range.start <= i && i < range.end)) + TextSpan( + text: source[i], + style: TextStyle( + letterSpacing: stretches + .where((stretch) => stretch.start <= i && i < stretch.end) + .firstOrNull + ?.spacing, + ), + ), + ], + ), + textDirection: TextDirection.ltr, + textScaler: scaler, + )..layout(); + final width = painter + .getOffsetForCaret( + TextPosition(offset: painter.plainText.length), + Rect.zero, + ) + .dx; + painter.dispose(); + return width; + } + + @override + void dispose() { + _math.dispose(); + super.dispose(); + } + /// The room a list marker takes — a bullet, a box or a number, with the /// space after it — so that every item's words start in one column and /// each level of nesting is one more room in, the way GitHub and Craft lay diff --git a/lib/ui/editor/markdown_syntax.dart b/lib/ui/editor/markdown_syntax.dart index 0c3392a..9e75668 100644 --- a/lib/ui/editor/markdown_syntax.dart +++ b/lib/ui/editor/markdown_syntax.dart @@ -25,8 +25,9 @@ enum MarkdownStyle { /// A fenced or indented code block, fences included. codeBlock, - /// A formula in TeX, its dollar signs included, shown as its TeX in code's - /// face; see [MarkdownMath]. + /// A formula in TeX, its dollar signs included. Drawn as the formula it + /// writes, and as its TeX in code's face while the caret is at it; see + /// [MarkdownMath]. math, /// Everything inside a block quote. @@ -157,6 +158,31 @@ class MarkdownMath { MarkdownMath _shifted(int by) => MarkdownMath(start + by, end + by, tex, display: display); + /// Whether the formula shows its TeX rather than itself, with the selection + /// at [selection]. + /// + /// Only in a note being edited, which is what [revealBlocks] says. A caret + /// or a selection's end anywhere inside always shows it: that is where the + /// TeX is typed. Against its edges, display math shows, as a block's syntax + /// does; inline math as inline markers do, so only with [revealEdges] — and + /// a formula whose closing `$` has just been typed is drawn at once. A + /// selection reaching over the whole of one leaves it drawn. + bool revealedAt( + TextSelection? selection, { + required bool revealBlocks, + required bool revealEdges, + }) { + if (!revealBlocks || selection == null || !selection.isValid) return false; + bool inside(int offset) => offset > start && offset < end; + if (inside(selection.baseOffset) || inside(selection.extentOffset)) { + return true; + } + if (!selection.isCollapsed) return false; + final caret = selection.baseOffset; + if (caret != start && caret != end) return false; + return display || revealEdges; + } + @override bool operator ==(Object other) => other is MarkdownMath && @@ -544,12 +570,14 @@ class MarkdownConcealment { const MarkdownConcealment._({ required this.hidden, required this.transparent, + required this.formulas, required this.key, }); static const none = MarkdownConcealment._( hidden: [], transparent: [], + formulas: [], key: 0, ); @@ -560,6 +588,11 @@ class MarkdownConcealment { /// place: a bullet, a checkbox, a table's grid. Sorted, never overlapping. final List transparent; + /// The formulas drawn as formulas rather than as their TeX. Each is in + /// [hidden] whole; the editor draws the formula in the place of its first + /// character. Sorted. + final List formulas; + /// Changes whenever what is shown does, for anything that caches a layout. final int key; } @@ -770,10 +803,15 @@ class MarkdownAnalysis { /// [revealEdges] is false in the same cases and also while the writer is /// typing, so markers they have just completed disappear as they complete /// them rather than lingering beside the caret. + /// + /// A formula is drawn as itself unless [MarkdownMath.revealedAt] says + /// otherwise, or [drawable] says it cannot be: TeX the editor cannot draw + /// stays in sight as written. MarkdownConcealment concealFor( TextSelection? selection, { required bool revealBlocks, required bool revealEdges, + bool Function(MarkdownMath math)? drawable, }) { final valid = selection != null && selection.isValid; final caret = valid && selection.isCollapsed ? selection.baseOffset : null; @@ -830,6 +868,24 @@ class MarkdownAnalysis { } } + final formulas = []; + for (var i = 0; i < maths.length; i++) { + final math = maths[i]; + final drawn = + (drawable?.call(math) ?? true) && + !math.revealedAt( + selection, + revealBlocks: revealBlocks, + revealEdges: revealEdges, + ); + if (drawn) { + formulas.add(math); + hidden.add(TextRange(start: math.start, end: math.end)); + } else { + key = Object.hash(key, conceals.length + i); + } + } + final transparent = [ for (final ornament in ornaments) if (ornament.kind != MarkdownOrnamentKind.codeSpan) @@ -856,6 +912,7 @@ class MarkdownAnalysis { return MarkdownConcealment._( hidden: _merged(hidden), transparent: _merged(transparent), + formulas: List.unmodifiable(formulas), key: key, ); } @@ -2114,7 +2171,8 @@ class _Collector { offset < _tables.last.end; /// A formula: its TeX shown as code with its dollar signs quiet, and - /// outside a table one of [MarkdownAnalysis.maths]. + /// outside a table the formula itself, which the editor draws in place of + /// all of it. void _math(md.Element node, Set claimed) { final start = node.start.offset; final end = node.end.offset; diff --git a/lib/ui/editor/note_editor.dart b/lib/ui/editor/note_editor.dart index eb2af74..d93ba2d 100644 --- a/lib/ui/editor/note_editor.dart +++ b/lib/ui/editor/note_editor.dart @@ -5423,15 +5423,16 @@ class NoteEditorState extends State with WidgetsBindingObserver { editorScale: widget.editorTextScale, ); // Only a note that needs a row taller than one line gives up the forced - // one: a picture, or a table whose cells wrap onto more lines than that. - final holdsTable = _controller - .markdownFor(_controller.text) - .tables - .isNotEmpty; + // one: a picture, a table whose cells wrap onto more lines than that, or a + // formula, which is as tall as what it writes. Any formula, drawn or shown + // as its TeX, so that moving the caret onto one never moves every line. + final analysis = _controller.markdownFor(_controller.text); final strut = EditorMetrics.strut( widget.writingFont, allowTallRows: - (_attachments.isNotEmpty && widget.images != null) || holdsTable, + (_attachments.isNotEmpty && widget.images != null) || + analysis.tables.isNotEmpty || + analysis.maths.isNotEmpty, editorScale: widget.editorTextScale, ); final textScaler = MediaQuery.textScalerOf(context); @@ -5539,6 +5540,7 @@ class NoteEditorState extends State with WidgetsBindingObserver { ), }; + _controller.setMathWidthDuringLayout(attachmentWidth); // A table's rows reserve their room the same way a picture // does, through a placeholder apiece. A real attachment wins any // offset they might share. diff --git a/lib/ui/editor/note_math.dart b/lib/ui/editor/note_math.dart new file mode 100644 index 0000000..5a8b823 --- /dev/null +++ b/lib/ui/editor/note_math.dart @@ -0,0 +1,234 @@ +import 'package:flutter/rendering.dart'; +import 'package:flutter/widgets.dart'; +import 'package:flutter_math_fork/flutter_math.dart'; +import 'package:flutter_math_fork/tex.dart'; + +/// One formula, ready for a line of the note: the widget that draws it and +/// the room it takes, with how far down that room its baseline sits. +typedef NoteFormula = ({ + Widget child, + double width, + double height, + double baseline, +}); + +/// One formula as it is drawn: its TeX, set apart or not, at a size, in a +/// colour. +typedef _Drawn = (String tex, bool display, double fontSize, Color color); + +/// Formulas in TeX, drawn by flutter_math_fork and sized before the text +/// around them is laid out. +/// +/// A formula stands in its line as a placeholder, and a text engine has to be +/// told how big every placeholder is before it can break lines: the field asks +/// the widget, and everything that measures the note apart from the field has +/// only the numbers. So each formula is laid out once, in a widget tree of its +/// own that is never shown, and its size kept. +/// +/// The widgets handed to the field are kept as well, so that a formula nobody +/// touched is never built twice — one for every formula in the note, never +/// one for two. flutter_math_fork keys each line it builds with a [GlobalKey] +/// kept in the formula's parsed TeX, so a widget shown in two places is one +/// key in two places, and the second takes the line away from the first. +class NoteMath { + final Map _drawable = {}; + final Map<_Drawn, ({double width, double height, double baseline})> _boxes = + {}; + final Map<(_Drawn, int), Widget> _widgets = {}; + _Offscreen? _offscreen; + + /// Whether [tex] is TeX flutter_math_fork reads. One it cannot is shown as + /// written instead. + bool draws(String tex) { + final known = _drawable[tex]; + if (known != null) return known; + if (_drawable.length > 512) _drawable.clear(); + return _drawable[tex] = + Math.tex(_readable(tex), settings: _settings).parseError == null; + } + + /// [tex] with what pandoc and Wikipedia write and flutter_math_fork does + /// not read, as what it does. The environments of a LaTeX document become + /// the ones it has: `align` is drawn as `aligned` is, `alignat` as + /// `alignedat`, a `split` as `aligned`, and an `equation` is only the + /// number a note has no use for. A phantom of a sized delimiter written + /// without braces, `\vphantom\bigg)`, which Wikipedia's TeX reads as one + /// argument, gets its braces. + static String _readable(String tex) => tex + .replaceAllMapped( + _environment, + (match) => switch (match[2]) { + 'equation' => '', + 'alignat' => '\\${match[1]}{alignedat}', + _ => '\\${match[1]}{aligned}', + }, + ) + .replaceAllMapped( + _phantomDelimiter, + (match) => '\\${match[1]}{${match[2]}}', + ); + + static final _environment = RegExp( + r'\\(begin|end)\{(align|alignat|equation|split)\*?\}', + ); + + static final _phantomDelimiter = RegExp( + r'\\([vh]?phantom)\s*(\\[Bb]igg?[lmr]?\s*(?:\\[A-Za-z]+|\\.|[^\s\\{}]))', + ); + + /// The commands Wikipedia's TeX has that flutter_math_fork lacks: `\sgn`, + /// the sign function. + static final _settings = TexParserSettings( + macros: {r'\sgn': MacroDefinition.fromString(r'\operatorname{sgn}')}, + ); + + /// [tex] drawn at [fontSize] in [color], set apart from the words around it + /// when [display], and no wider than [maxWidth]: a formula wider than the + /// writing column is drawn smaller rather than cut off. + /// + /// [copy] says which of the note's formulas with this TeX it is, counting + /// from 0 in the order they are written, and each gets a widget of its own. + NoteFormula formula( + String tex, { + required bool display, + required double fontSize, + required Color color, + required double maxWidth, + required int copy, + }) { + var drawn = (tex, display, fontSize, color); + var box = _box(drawn); + if (box.width > maxWidth && maxWidth > 0) { + // Rules and spacing scale with the size, so this is close to exact; what + // little is not is taken up by asking for a touch less. + final fitted = + (fontSize * maxWidth / box.width * 0.98 * 10).floorToDouble() / 10; + drawn = (tex, display, fitted, color); + box = _box(drawn); + } + if (_widgets.length > 1024) _widgets.clear(); + return ( + child: _widgets[(drawn, copy)] ??= _math(drawn), + width: box.width, + height: box.height, + baseline: box.baseline, + ); + } + + /// How big [drawn] is, measured with a widget of its own that is never + /// shown. + ({double width, double height, double baseline}) _box(_Drawn drawn) { + final known = _boxes[drawn]; + if (known != null) return known; + if (_boxes.length > 512) _boxes.clear(); + return _boxes[drawn] = (_offscreen ??= _Offscreen()).measure(_math(drawn)); + } + + /// [drawn] as a widget, with nothing of it in the semantics tree. A screen + /// reader reads the note's text, where a formula is its TeX, and + /// flutter_math_fork gives every glyph a node of its own, which in a note + /// with hundreds of formulas is most of the tree. + Widget _math(_Drawn drawn) { + final (tex, display, fontSize, color) = drawn; + return ExcludeSemantics( + child: Math.tex( + _readable(tex), + settings: _settings, + options: MathOptions( + style: display ? MathStyle.display : MathStyle.text, + fontSize: fontSize, + color: color, + ), + // Only what TeX parses and still cannot build gets here: shown as its + // TeX, which is what a formula that does not parse is shown as too. + onErrorFallback: (_) => Text( + tex, + style: TextStyle(fontSize: fontSize, color: color), + textDirection: TextDirection.ltr, + ), + ), + ); + } + + void dispose() { + _offscreen?.dispose(); + _offscreen = null; + _boxes.clear(); + _widgets.clear(); + } +} + +/// A widget tree of its own, laid out and never painted, for knowing how big +/// a widget is before it is shown. +class _Offscreen { + _Offscreen() { + _pipeline.rootNode = _root; + _root.scheduleInitialLayout(); + _element = RenderObjectToWidgetAdapter( + container: _root, + child: const SizedBox.shrink(), + ).attachToRenderTree(_owner); + } + + final _pipeline = PipelineOwner(); + final _owner = BuildOwner(focusManager: FocusManager()); + final _root = _Measure(); + late final RenderObjectToWidgetElement _element; + + ({double width, double height, double baseline}) measure(Widget widget) { + RenderObjectToWidgetAdapter( + container: _root, + child: Directionality(textDirection: TextDirection.ltr, child: widget), + ).attachToRenderTree(_owner, _element); + _owner.buildScope(_element); + _pipeline.flushLayout(); + // The formula measured before this one is done with. + _owner.finalizeTree(); + return ( + width: _root.size.width, + height: _root.size.height, + baseline: _root.baseline, + ); + } + + void dispose() { + RenderObjectToWidgetAdapter( + container: _root, + ).attachToRenderTree(_owner, _element); + _owner.buildScope(_element); + _owner.finalizeTree(); + _owner.focusManager.dispose(); + _pipeline.rootNode = null; + _pipeline.dispose(); + } +} + +/// The root of [_Offscreen]: lays its one child out at the size it wants, and +/// asks it for its baseline, which only a parent laying it out may do. +class _Measure extends RenderObject with RenderObjectWithChildMixin { + Size size = Size.zero; + double baseline = 0; + + @override + void performLayout() { + final child = this.child; + if (child == null) return; + child.layout(const BoxConstraints(), parentUsesSize: true); + size = child.size; + baseline = + child.getDistanceToBaseline(TextBaseline.alphabetic, onlyReal: true) ?? + size.height; + } + + @override + void performResize() {} + + @override + void debugAssertDoesMeetConstraints() {} + + @override + Rect get paintBounds => Offset.zero & size; + + @override + Rect get semanticBounds => paintBounds; +} diff --git a/pubspec.lock b/pubspec.lock index c1a002b..dc1f9cc 100644 --- a/pubspec.lock +++ b/pubspec.lock @@ -416,6 +416,14 @@ packages: description: flutter source: sdk version: "0.0.0" + flutter_math_fork: + dependency: "direct main" + description: + name: flutter_math_fork + sha256: "6d5f2f1aa57ae539ffb0a04bb39d2da67af74601d685a161aff7ce5bda5fa407" + url: "https://pub.dev" + source: hosted + version: "0.7.4" flutter_plugin_android_lifecycle: dependency: transitive description: @@ -892,6 +900,14 @@ packages: url: "https://pub.dev" source: hosted version: "3.1.0" + nested: + dependency: transitive + description: + name: nested + sha256: "03bac4c528c64c95c722ec99280375a6f2fc708eec17c7b3f07253b626cd2a20" + url: "https://pub.dev" + source: hosted + version: "1.0.0" nm: dependency: transitive description: @@ -1044,6 +1060,14 @@ packages: url: "https://pub.dev" source: hosted version: "5.0.6" + provider: + dependency: transitive + description: + name: provider + sha256: "4e82183fa20e5ca25703ead7e05de9e4cceed1fbd1eadc1ac3cb6f565a09f272" + url: "https://pub.dev" + source: hosted + version: "6.1.5+1" pub_semver: dependency: transitive description: @@ -1423,6 +1447,14 @@ packages: url: "https://pub.dev" source: hosted version: "0.5.3" + tuple: + dependency: transitive + description: + name: tuple + sha256: a97ce2013f240b2f3807bcbaf218765b6f301c3eff91092bcfa23a039e7dd151 + url: "https://pub.dev" + source: hosted + version: "2.0.2" typed_data: dependency: transitive description: diff --git a/pubspec.yaml b/pubspec.yaml index 0365a0a..8f3e488 100644 --- a/pubspec.yaml +++ b/pubspec.yaml @@ -154,6 +154,12 @@ dependencies: # passes the CommonMark and GFM spec suites, and it is pure Dart, so it runs # the same on every platform and inside a widget test. dart_markdown: ^3.1.7 + # Drawing a note's `$…$` and `$$…$$` as the formulas they write. Pure Dart + # and Flutter's own text engine, with KaTeX's fonts bundled (about 660 KB), + # so it lays a formula out offline, the same on every platform and inside a + # widget test, and reports the baseline a formula among words sits on. + # Apache-2.0. + flutter_math_fork: ^0.7.4 # One quiet, consistent line-icon language across every app surface. # Hugeicons' free stroke-rounded set is MIT licensed and tree-shaken. hugeicons: ^1.1.7 @@ -211,6 +217,9 @@ flutter: - assets/branding/kapynotes_tray_windows.ico - assets/branding/kapynotes_tray_macos.png - assets/fonts/ShantellSans-OFL.txt + # The notice KaTeX's fonts come with, which flutter_math_fork bundles + # without: its own LICENSE is the package's, not the fonts'. + - packages/flutter_math_fork/katex_fonts/LICENSE fonts: - family: Shantell Sans fonts: diff --git a/test/markdown_syntax_test.dart b/test/markdown_syntax_test.dart index 9caec34..a40c735 100644 --- a/test/markdown_syntax_test.dart +++ b/test/markdown_syntax_test.dart @@ -557,6 +557,35 @@ void main() { [r'$x$:math'], ); }); + + test('drawn, is hidden whole; with the caret in it, shown as written', () { + expect(visible(r'a $x$ b|'), 'a b'); + expect(visible(r'a $x|$ b'), r'a $x$ b'); + expect(visible(r'a $x|$ b', typing: true), r'a $x$ b'); + // Against an edge it shows as any inline marker does: not while typing. + expect(visible(r'a $x$| b'), r'a $x$ b'); + expect(visible(r'a $x$| b', typing: true), 'a b'); + expect(visible(r'a $x|$ b', editing: false), 'a b'); + // Set apart, it shows with the caret against it, as a block's syntax. + expect(visible('\$\$\nx\n\$\$|', typing: true), '\$\$\nx\n\$\$'); + expect(visible('\$\$\nx\n\$\$\n|'), '\n'); + }); + + test('drawn, is named for the editor to draw', () { + const note = r'a $x$ and $$y$$'; + final drawn = read( + note, + ).concealFor(null, revealBlocks: false, revealEdges: false); + expect([for (final math in drawn.formulas) math.tex], ['x', 'y']); + final undrawable = read(note).concealFor( + null, + revealBlocks: false, + revealEdges: false, + drawable: (math) => math.tex != 'x', + ); + expect([for (final math in undrawable.formulas) math.tex], ['y']); + expect(undrawable.hidden, [const TextRange(start: 10, end: 15)]); + }); }); group('reading in pieces', () { diff --git a/test/note_editor_markdown_test.dart b/test/note_editor_markdown_test.dart index 75f7649..e5f4b2a 100644 --- a/test/note_editor_markdown_test.dart +++ b/test/note_editor_markdown_test.dart @@ -2,6 +2,7 @@ import 'package:flutter/foundation.dart'; import 'package:flutter/gestures.dart' show PointerDeviceKind, PointerScrollEvent, kSecondaryButton; import 'package:flutter/services.dart'; +import 'package:flutter_math_fork/flutter_math.dart'; import 'package:flutter_test/flutter_test.dart'; import 'package:kapy_notes/calc/engine.dart'; import 'package:kapy_notes/calc/highlight.dart'; @@ -1643,4 +1644,128 @@ void main() { expect(controllerOf(tester).text, 'say **hi** x'); }); }); + group('formulas', () { + /// Where the first box [needle] is drawn in sits on screen. + Rect rectOf(WidgetTester tester, String needle) { + final start = controllerOf(tester).text.indexOf(needle); + final editable = tester + .state(find.byType(EditableText)) + .renderEditable; + final box = editable + .getBoxesForSelection( + TextSelection( + baseOffset: start, + extentOffset: start + needle.length, + ), + ) + .first; + return Rect.fromPoints( + editable.localToGlobal(Offset(box.left, box.top)), + editable.localToGlobal(Offset(box.right, box.bottom)), + ); + } + + testWidgets('a formula is drawn in place of its TeX, shown with the caret ' + 'in it', (tester) async { + const body = r'Area $\pi r^2$ here'; + await tester.pumpWidget(harness(body, autofocus: true)); + await tester.pumpAndSettle(); + controllerOf(tester).selection = const TextSelection.collapsed(offset: 0); + await tester.pump(); + expect(find.byType(Math), findsOneWidget); + expect(isHidden(tester, r'\pi'), isTrue); + + // The caret inside: the TeX as written, as code, where the formula was. + controllerOf(tester).selection = TextSelection.collapsed( + offset: body.indexOf('r^2'), + ); + await tester.pump(); + expect(find.byType(Math), findsNothing); + expect(isHidden(tester, r'\pi'), isFalse); + expect( + styleOf(tester, r'\pi').fontFamily, + WritingFont.monospace.fontFamily, + ); + + // Typed in, it stays as written. + await typeAtCaret(tester, '2'); + expect(controllerOf(tester).text, r'Area $\pi 2r^2$ here'); + expect(isHidden(tester, r'\pi'), isFalse); + + // Away from it, drawn again. + controllerOf(tester).selection = const TextSelection.collapsed(offset: 0); + await tester.pump(); + expect(find.byType(Math), findsOneWidget); + }); + + testWidgets('arrow keys walk through a formula\'s TeX, and it is drawn ' + 'again past it', (tester) async { + await tester.pumpWidget(harness(r'a $x$ b', autofocus: true)); + await tester.pumpAndSettle(); + controllerOf(tester).selection = const TextSelection.collapsed(offset: 1); + await tester.pump(); + expect(find.byType(Math), findsOneWidget); + + // Against it and inside it, the caret is never somewhere unseen. + for (var offset = 2; offset <= 5; offset++) { + await tester.sendKeyEvent(LogicalKeyboardKey.arrowRight); + await tester.pump(); + expect(controllerOf(tester).selection.baseOffset, offset); + expect(find.byType(Math), findsNothing, reason: 'at $offset'); + } + await tester.sendKeyEvent(LogicalKeyboardKey.arrowRight); + await tester.pump(); + expect(controllerOf(tester).selection.baseOffset, 6); + expect(find.byType(Math), findsOneWidget); + }); + + testWidgets('the same formula twice is drawn twice', (tester) async { + // flutter_math_fork keys each line it builds with a GlobalKey, so one + // widget shown in two places is a key in two places. + await tester.pumpWidget(harness(r'$x^2$ and again $x^2$')); + await tester.pumpAndSettle(); + expect(tester.takeException(), isNull); + expect(find.byType(Math), findsNWidgets(2)); + }); + + testWidgets('TeX it cannot draw stays as written, as code', (tester) async { + await tester.pumpWidget(harness(r'bad $\frac{a$ here')); + await tester.pumpAndSettle(); + expect(find.byType(Math), findsNothing); + expect(isHidden(tester, r'\frac'), isFalse); + expect( + styleOf(tester, r'\frac').fontFamily, + WritingFont.monospace.fontFamily, + ); + }); + + testWidgets('dollar amounts stay words', (tester) async { + await tester.pumpWidget(harness(r'Lunch $5 and coffee $10')); + await tester.pumpAndSettle(); + expect(find.byType(Math), findsNothing); + expect(isHidden(tester, r'$5'), isFalse); + expect( + styleOf(tester, r'$5').fontFamily, + isNot(WritingFont.monospace.fontFamily), + ); + }); + + testWidgets('set apart, a formula takes a line of its own and results ' + 'keep to theirs', (tester) async { + const body = '1 + 1\n\$\$\n\\frac{a}{b}\n\$\$\n2 + 2'; + await tester.pumpWidget(harness(body)); + await tester.pumpAndSettle(); + final formula = tester.getRect(find.byType(Math)); + final above = rectOf(tester, '1 + 1'); + final below = rectOf(tester, '2 + 2'); + expect(formula.top, greaterThanOrEqualTo(above.bottom)); + expect(formula.bottom, lessThanOrEqualTo(below.top)); + expect(formula.left, greaterThan(above.right), reason: 'it is centred'); + expect( + tester.getCenter(chipWithText('4')).dy, + closeTo(below.center.dy, 2), + reason: 'the result is beside the line it belongs to', + ); + }); + }); } diff --git a/test/note_math_test.dart b/test/note_math_test.dart new file mode 100644 index 0000000..79b23b0 --- /dev/null +++ b/test/note_math_test.dart @@ -0,0 +1,99 @@ +import 'package:flutter/widgets.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:kapy_notes/ui/editor/note_math.dart'; + +import 'test_fonts.dart'; + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + setUpAll(loadTestFonts); + + late NoteMath math; + setUp(() => math = NoteMath()); + tearDown(() => math.dispose()); + + NoteFormula draw( + String tex, { + bool display = false, + double maxWidth = 1000, + int copy = 0, + }) => math.formula( + tex, + display: display, + fontSize: 16, + color: const Color(0xFF000000), + maxWidth: maxWidth, + copy: copy, + ); + + test('draws the TeX it reads, and says which it cannot', () { + expect(math.draws(r'\frac{a}{b}'), isTrue); + expect(math.draws(r'\frac{a'), isFalse); + expect(math.draws(r'\nosuchcommand'), isFalse); + }); + + test('reads a LaTeX document\'s environments as the ones it has', () { + expect(math.draws(r'\begin{align} a &= b \\ c &= d \end{align}'), isTrue); + expect(math.draws(r'\begin{align*} a &= b \end{align*}'), isTrue); + expect( + math.draws(r'\begin{alignat}{2} a &= b &&= c \end{alignat}'), + isTrue, + ); + expect( + math.draws( + r'\begin{equation}\begin{split} a &= b \\ &= c \end{split}\end{equation}', + ), + isTrue, + ); + }); + + test('measures a formula, with its baseline inside it', () { + final inline = draw(r'\frac{a}{b}'); + expect(inline.width, greaterThan(0)); + expect(inline.baseline, inInclusiveRange(0, inline.height)); + expect( + draw(r'\frac{a}{b}', display: true).height, + greaterThan(inline.height), + reason: 'set apart, a fraction is set larger', + ); + }); + + test('draws a formula too wide for the column smaller', () { + const long = 'a + b + c + d + e + f + g + h + i + j + k + l + m + n + o'; + final natural = draw(long); + final fitted = draw(long, maxWidth: natural.width / 2); + expect(fitted.width, lessThanOrEqualTo(natural.width / 2)); + expect(fitted.width, greaterThan(natural.width / 3)); + }); + + test('gives each copy of a formula a widget of its own, and keeps it', () { + final first = draw('x^2'); + final second = draw('x^2', copy: 1); + expect(identical(first.child, second.child), isFalse); + expect(second.width, first.width); + expect(identical(draw('x^2').child, first.child), isTrue); + }); + + test( + 'reads Wikipedia\'s \\sgn, and a phantom\'s delimiter without braces', + () { + expect(math.draws(r'x = -\sgn(b)\sqrt{\vert c\vert}'), isTrue); + expect( + math.draws(r'x = \dfrac{-b\pm\sqrt{b^2 - 4ac}}{2a}. \vphantom\bigg)'), + isTrue, + ); + }, + ); + + testWidgets('leaves a formula\'s glyphs out of the semantics tree', ( + tester, + ) async { + await tester.pumpWidget( + Directionality( + textDirection: TextDirection.ltr, + child: Center(child: draw(r'x^2 + y').child), + ), + ); + expect(find.bySemanticsLabel(RegExp('[xy2+]')), findsNothing); + }); +} diff --git a/test/test_fonts.dart b/test/test_fonts.dart index 399a20e..082cd8b 100644 --- a/test/test_fonts.dart +++ b/test/test_fonts.dart @@ -1,3 +1,4 @@ +import 'dart:convert'; import 'dart:io'; import 'package:flutter/services.dart'; @@ -30,6 +31,20 @@ Future loadTestFonts() async { 'assets/fonts/ShantellSans-Variable.ttf', 'assets/fonts/ShantellSans-Italic-Variable.ttf', ]); + // KaTeX's faces, which flutter_math_fork draws formulas in. They are in the + // test's asset bundle like every package font, and like every one of them + // are only drawn once they are loaded. + final manifest = + jsonDecode(await rootBundle.loadString('FontManifest.json')) as List; + for (final entry in manifest.cast>()) { + final family = entry['family']! as String; + if (!family.startsWith('packages/flutter_math_fork/')) continue; + final loader = FontLoader(family); + for (final font in (entry['fonts']! as List).cast>()) { + loader.addFont(rootBundle.load(font['asset']! as String)); + } + await loader.load(); + } } Future _load(String family, List candidates) async { From bfc127db94b2a468e65fd6f961672fe8a821d964 Mon Sep 17 00:00:00 2001 From: Sanjay Kholiya Date: Mon, 16 Nov 2026 23:09:19 +0530 Subject: [PATCH 04/48] Colour fenced code in the language its info string names A fenced code block whose info string names one of 35 languages, or one of highlight.js's names for them (py, ts, sh, yml and the like), is coloured by re_highlight, highlight.js's grammars ported to Dart. Its keywords, strings, numbers, comments, titles, types and punctuation take their colours from the note's own palette, so code reads the same in light and dark rather than in some editor's theme. A block is coloured once for as long as its language and its code stay the same, so typing in one block leaves the rest alone. A block with no language, or one it does not know, stays plain code. --- lib/ui/editor/code_highlighting.dart | 237 +++++++++++++++++++++ lib/ui/editor/highlighting_controller.dart | 45 ++++ lib/ui/editor/markdown_syntax.dart | 50 +++++ pubspec.lock | 8 + pubspec.yaml | 4 + test/markdown_syntax_test.dart | 24 +++ test/note_editor_markdown_test.dart | 19 +- 7 files changed, 386 insertions(+), 1 deletion(-) create mode 100644 lib/ui/editor/code_highlighting.dart diff --git a/lib/ui/editor/code_highlighting.dart b/lib/ui/editor/code_highlighting.dart new file mode 100644 index 0000000..b2fc3d1 --- /dev/null +++ b/lib/ui/editor/code_highlighting.dart @@ -0,0 +1,237 @@ +import 'package:flutter/foundation.dart'; +import 'package:re_highlight/languages/bash.dart'; +import 'package:re_highlight/languages/c.dart'; +import 'package:re_highlight/languages/cpp.dart'; +import 'package:re_highlight/languages/csharp.dart'; +import 'package:re_highlight/languages/css.dart'; +import 'package:re_highlight/languages/dart.dart'; +import 'package:re_highlight/languages/diff.dart'; +import 'package:re_highlight/languages/dockerfile.dart'; +import 'package:re_highlight/languages/go.dart'; +import 'package:re_highlight/languages/graphql.dart'; +import 'package:re_highlight/languages/ini.dart'; +import 'package:re_highlight/languages/java.dart'; +import 'package:re_highlight/languages/javascript.dart'; +import 'package:re_highlight/languages/json.dart'; +import 'package:re_highlight/languages/kotlin.dart'; +import 'package:re_highlight/languages/latex.dart'; +import 'package:re_highlight/languages/lua.dart'; +import 'package:re_highlight/languages/makefile.dart'; +import 'package:re_highlight/languages/markdown.dart'; +import 'package:re_highlight/languages/objectivec.dart'; +import 'package:re_highlight/languages/perl.dart'; +import 'package:re_highlight/languages/php.dart'; +import 'package:re_highlight/languages/plaintext.dart'; +import 'package:re_highlight/languages/powershell.dart'; +import 'package:re_highlight/languages/python.dart'; +import 'package:re_highlight/languages/r.dart'; +import 'package:re_highlight/languages/ruby.dart'; +import 'package:re_highlight/languages/rust.dart'; +import 'package:re_highlight/languages/scala.dart'; +import 'package:re_highlight/languages/scss.dart'; +import 'package:re_highlight/languages/sql.dart'; +import 'package:re_highlight/languages/swift.dart'; +import 'package:re_highlight/languages/typescript.dart'; +import 'package:re_highlight/languages/xml.dart'; +import 'package:re_highlight/languages/yaml.dart'; +import 'package:re_highlight/re_highlight.dart'; + +import 'markdown_syntax.dart'; + +/// What a stretch of code is, as far as colouring it goes. +enum CodeTokenKind { + keyword, + string, + number, + comment, + title, + type, + attribute, + variable, + punctuation, +} + +/// [start, end) of the note, coloured as [kind]. +typedef CodeToken = ({int start, int end, CodeTokenKind kind}); + +/// Fenced code coloured the way the language its info string names reads, +/// by highlight.js's grammars. +/// +/// The languages a note is likely to hold, under the names and aliases +/// highlight.js gives them. A block in any other language, or in none, stays +/// plain code. Each block is coloured once for as long as its language and +/// its code stay the same, so typing in one block leaves the rest alone. +class CodeHighlighter { + static final Highlight _grammars = Highlight() + ..registerLanguage('bash', langBash) + ..registerLanguage('c', langC) + ..registerLanguage('cpp', langCpp) + ..registerLanguage('csharp', langCsharp) + ..registerLanguage('css', langCss) + ..registerLanguage('dart', langDart) + ..registerLanguage('diff', langDiff) + ..registerLanguage('dockerfile', langDockerfile) + ..registerLanguage('go', langGo) + ..registerLanguage('graphql', langGraphql) + ..registerLanguage('ini', langIni) + ..registerLanguage('java', langJava) + ..registerLanguage('javascript', langJavascript) + ..registerLanguage('json', langJson) + ..registerLanguage('kotlin', langKotlin) + ..registerLanguage('latex', langLatex) + ..registerLanguage('lua', langLua) + ..registerLanguage('makefile', langMakefile) + ..registerLanguage('markdown', langMarkdown) + ..registerLanguage('objectivec', langObjectivec) + ..registerLanguage('perl', langPerl) + ..registerLanguage('php', langPhp) + ..registerLanguage('plaintext', langPlaintext) + ..registerLanguage('powershell', langPowershell) + ..registerLanguage('python', langPython) + ..registerLanguage('r', langR) + ..registerLanguage('ruby', langRuby) + ..registerLanguage('rust', langRust) + ..registerLanguage('scala', langScala) + ..registerLanguage('scss', langScss) + ..registerLanguage('sql', langSql) + ..registerLanguage('swift', langSwift) + ..registerLanguage('typescript', langTypescript) + ..registerLanguage('xml', langXml) + ..registerLanguage('yaml', langYaml) + ..registerAliases(['zsh', 'shell'], 'bash'); + + Map<(String, String), List> _coloured = const {}; + + /// Every token of every block in [blocks], in order, in [text]'s offsets. + List tokensIn(String text, List blocks) { + final coloured = <(String, String), List>{}; + final tokens = []; + for (final block in blocks) { + final language = block.language.toLowerCase(); + if (_grammars.getLanguage(language) == null) continue; + final code = block.code + .map((range) => text.substring(range.start, range.end)) + .join(); + final key = (language, code); + final relative = coloured[key] ??= + _coloured[key] ?? _highlight(language, code); + // The code of a quoted or indented block is in pieces, and a token can + // run from one into the next. + var piece = 0; + var pieceStart = 0; + for (final token in relative) { + var from = token.start; + while (from < token.end && piece < block.code.length) { + final range = block.code[piece]; + final pieceEnd = pieceStart + range.end - range.start; + if (from >= pieceEnd) { + piece++; + pieceStart = pieceEnd; + continue; + } + final to = token.end < pieceEnd ? token.end : pieceEnd; + tokens.add(( + start: range.start + from - pieceStart, + end: range.start + to - pieceStart, + kind: token.kind, + )); + from = to; + } + } + } + _coloured = coloured; + return tokens; + } + + static List _highlight(String language, String code) { + final tokens = _Tokens(); + try { + _grammars.highlight(code: code, language: language).render(tokens); + } catch (error, stack) { + // A grammar that trips over some code costs that block its colours, + // never the note its text. + FlutterError.reportError( + FlutterErrorDetails( + exception: error, + stack: stack, + library: 'Kapy Notes editor', + context: ErrorDescription('while colouring $language code'), + ), + ); + return const []; + } + return tokens.length == code.length ? tokens.tokens : const []; + } +} + +/// Reads highlight.js's tree of scopes into flat tokens, each coloured by the +/// innermost scope around it that has a colour. +class _Tokens implements HighlightRenderer { + final tokens = []; + final _open = []; + var length = 0; + + @override + void addText(String text) { + final kind = _open.lastWhere((kind) => kind != null, orElse: () => null); + if (kind != null && text.isNotEmpty) { + final last = tokens.lastOrNull; + if (last != null && last.end == length && last.kind == kind) { + tokens.last = ( + start: last.start, + end: length + text.length, + kind: kind, + ); + } else { + tokens.add((start: length, end: length + text.length, kind: kind)); + } + } + length += text.length; + } + + @override + void openNode(DataNode node) => _open.add(_kindOf(node.scope)); + + @override + void closeNode(DataNode node) => _open.removeLast(); + + static CodeTokenKind? _kindOf(String? scope) { + if (scope == null) return null; + if (scope.startsWith('title.class')) return CodeTokenKind.type; + return switch (scope.split('.').first) { + 'keyword' || + 'built_in' || + 'literal' || + 'name' || + 'selector-tag' || + 'section' || + 'doctag' || + 'deletion' => CodeTokenKind.keyword, + 'string' || + 'regexp' || + 'symbol' || + 'char' || + 'addition' || + 'code' || + 'link' => CodeTokenKind.string, + 'number' => CodeTokenKind.number, + 'comment' || 'quote' => CodeTokenKind.comment, + 'title' || 'function' => CodeTokenKind.title, + 'type' || 'class' => CodeTokenKind.type, + 'attr' || + 'attribute' || + 'property' || + 'selector-attr' || + 'selector-class' || + 'selector-id' || + 'selector-pseudo' => CodeTokenKind.attribute, + 'variable' || 'template-variable' => CodeTokenKind.variable, + 'operator' || + 'punctuation' || + 'meta' || + 'tag' || + 'bullet' => CodeTokenKind.punctuation, + _ => null, + }; + } +} diff --git a/lib/ui/editor/highlighting_controller.dart b/lib/ui/editor/highlighting_controller.dart index cf96e32..b5f8838 100644 --- a/lib/ui/editor/highlighting_controller.dart +++ b/lib/ui/editor/highlighting_controller.dart @@ -9,6 +9,7 @@ import '../../core/editor_font.dart'; import '../../core/note_link.dart'; import '../../core/theme.dart'; import '../../data/note_format.dart'; +import 'code_highlighting.dart'; import 'editor_formatting.dart'; import 'markdown_syntax.dart'; import 'note_math.dart'; @@ -49,6 +50,7 @@ class HighlightingController extends TextEditingController { final MarkdownAnalyzer _markdownAnalyzer = MarkdownAnalyzer(); Map _imageSpans = const {}; final NoteMath _math = NoteMath(); + final CodeHighlighter _codeHighlighter = CodeHighlighter(); double _mathWidth = 0; List<(int, PlaceholderDimensions)> _formulaPlaceholders = const []; @@ -257,6 +259,7 @@ class HighlightingController extends TextEditingController { MediaQuery.maybeTextScalerOf(context) ?? TextScaler.noScaling; final stretches = _listStretches(analysis, base, scaler); final formulas = concealment.formulas; + final code = _codeTokens(analysis); final composing = withComposing && value.isComposingRangeValid ? value.composing : null; @@ -305,6 +308,10 @@ class HighlightingController extends TextEditingController { for (final formula in formulas) { boundaries.add(formula.start + 1); } + for (final token in code) { + boundaries.add(token.start); + boundaries.add(token.end); + } if (composing != null) { boundaries.add(composing.start.clamp(0, source.length)); boundaries.add(composing.end.clamp(0, source.length)); @@ -328,6 +335,7 @@ class HighlightingController extends TextEditingController { var stretchIndex = 0; var formulaIndex = 0; final formulaCopies = {}; + var codeIndex = 0; final placeholders = <(int, PlaceholderDimensions)>[]; for (var i = 0; i < cuts.length - 1; i++) { @@ -457,6 +465,14 @@ class HighlightingController extends TextEditingController { if (markdown != 0) { segmentStyle = _markdownBlockStyle(segmentStyle, base, marked); } + while (codeIndex < code.length && code[codeIndex].end <= start) { + codeIndex++; + } + if (codeIndex < code.length && code[codeIndex].start <= start) { + segmentStyle = segmentStyle.merge( + _codeTokenStyle(code[codeIndex].kind), + ); + } final matchingFormats = _formats.where( (format) => format.start <= start && format.end >= end, ); @@ -685,6 +701,35 @@ class HighlightingController extends TextEditingController { return width; } + MarkdownAnalysis? _colouredFor; + List _colouredCode = const []; + + /// The colours of [analysis]'s fenced code, worked out once per analysis. + List _codeTokens(MarkdownAnalysis analysis) { + if (identical(analysis, _colouredFor)) return _colouredCode; + _colouredFor = analysis; + return _colouredCode = analysis.fencedCode.isEmpty + ? const [] + : _codeHighlighter.tokensIn(analysis.text, analysis.fencedCode); + } + + /// Code coloured from the note's own palette, so that it sits in the note + /// in light and in dark alike rather than in some editor's theme. + TextStyle _codeTokenStyle(CodeTokenKind kind) => switch (kind) { + CodeTokenKind.keyword => TextStyle(color: _palette.keyword), + CodeTokenKind.string => TextStyle(color: _palette.chipCurrency), + CodeTokenKind.number => TextStyle(color: _palette.number), + CodeTokenKind.comment => TextStyle( + color: _palette.comment, + fontStyle: FontStyle.italic, + ), + CodeTokenKind.title => TextStyle(color: _palette.function), + CodeTokenKind.type || + CodeTokenKind.attribute => TextStyle(color: _palette.unit), + CodeTokenKind.variable => TextStyle(color: _palette.variable), + CodeTokenKind.punctuation => TextStyle(color: _palette.operator), + }; + @override void dispose() { _math.dispose(); diff --git a/lib/ui/editor/markdown_syntax.dart b/lib/ui/editor/markdown_syntax.dart index 9e75668..7814732 100644 --- a/lib/ui/editor/markdown_syntax.dart +++ b/lib/ui/editor/markdown_syntax.dart @@ -199,6 +199,34 @@ class MarkdownMath { 'MarkdownMath($start, $end, ${display ? 'display' : 'inline'}: $tex)'; } +/// A fenced code block whose info string names a language, for colouring the +/// code the way that language reads. +@immutable +class MarkdownCodeBlock { + const MarkdownCodeBlock(this.language, this.code); + + /// The info string's first word, as written: `python`, `ts`, `C++`. + final String language; + + /// Where the code sits, fences left out. In more than one piece when the + /// block is indented or quoted, since a line's indentation or `>` is not + /// code. + final List code; + + MarkdownCodeBlock _shifted(int by) => MarkdownCodeBlock(language, [ + for (final range in code) _shift(range, by), + ]); + + @override + bool operator ==(Object other) => + other is MarkdownCodeBlock && + other.language == language && + listEquals(other.code, code); + + @override + int get hashCode => Object.hash(language, Object.hashAll(code)); +} + enum MarkdownBlockKind { code, quote, rule } /// A block that is drawn behind the text as well as in it: the panel under a @@ -637,6 +665,9 @@ class MarkdownAnalysis { /// Fenced and indented code blocks, which the calculator does not read. List get codeBlocks => _parts.codeBlocks; + /// The fenced code blocks that name a language, for colouring their code. + List get fencedCode => _parts.fencedCode; + /// Every formula outside a table, in order. One in a table's cell is drawn /// as its TeX, in the grid. List get maths => _parts.maths; @@ -1154,6 +1185,7 @@ class _Parts { required this.listItems, required this.atomicPrefixes, required this.codeBlocks, + required this.fencedCode, required this.maths, required this.unread, required this.literals, @@ -1175,6 +1207,7 @@ class _Parts { listItems: [], atomicPrefixes: [], codeBlocks: [], + fencedCode: [], maths: [], unread: [], literals: [], @@ -1193,6 +1226,7 @@ class _Parts { final List listItems; final List atomicPrefixes; final List codeBlocks; + final List fencedCode; final List maths; final List unread; final List literals; @@ -1220,6 +1254,7 @@ class _Parts { listItems: all((p) => p.listItems, (i, by) => i._shifted(by)), atomicPrefixes: all((p) => p.atomicPrefixes, _shift), codeBlocks: all((p) => p.codeBlocks, _shift), + fencedCode: all((p) => p.fencedCode, (c, by) => c._shifted(by)), maths: all((p) => p.maths, (m, by) => m._shifted(by)), unread: all((p) => p.unread, _shift), literals: all((p) => p.literals, _shift), @@ -1260,6 +1295,7 @@ class _Parts { listItems: const [], atomicPrefixes: const [], codeBlocks: const [], + fencedCode: const [], maths: const [], unread: const [], literals: const [], @@ -1695,6 +1731,7 @@ class _Collector { final _tables = []; final _listItems = []; final _codeBlocks = []; + final _fencedCode = []; final _maths = []; final _unread = []; final _literals = []; @@ -1737,6 +1774,7 @@ class _Collector { listItems: List.unmodifiable(_listItems), atomicPrefixes: List.unmodifiable(_atomicPrefixes()), codeBlocks: List.unmodifiable(_codeBlocks), + fencedCode: List.unmodifiable(_fencedCode), maths: List.unmodifiable(_maths), unread: List.unmodifiable(_unread), literals: List.unmodifiable(_literals), @@ -1989,6 +2027,18 @@ class _Collector { _style(start, end, MarkdownStyle.codeBlock); _record(_codeBlocks, start, end); _record(_literals, start, end); + final language = node.attributes['language']; + if (language != null && language.isNotEmpty) { + final code = [ + for (final line in node.children) + ?_range(line.start.offset, line.end.offset), + ]; + if (code.isNotEmpty) { + _fencedCode.add( + MarkdownCodeBlock(_unmask(language), List.unmodifiable(code)), + ); + } + } _blocks.add( MarkdownBlock(MarkdownBlockKind.code, _clamp(start), _clamp(end)), ); diff --git a/pubspec.lock b/pubspec.lock index dc1f9cc..db5ba9f 100644 --- a/pubspec.lock +++ b/pubspec.lock @@ -1092,6 +1092,14 @@ packages: url: "https://pub.dev" source: hosted version: "2.2.3" + re_highlight: + dependency: "direct main" + description: + name: re_highlight + sha256: "6c4ac3f76f939fb7ca9df013df98526634e17d8f7460e028bd23a035870024f2" + url: "https://pub.dev" + source: hosted + version: "0.0.3" record: dependency: "direct main" description: diff --git a/pubspec.yaml b/pubspec.yaml index 8f3e488..805c1bf 100644 --- a/pubspec.yaml +++ b/pubspec.yaml @@ -160,6 +160,10 @@ dependencies: # widget test, and reports the baseline a formula among words sits on. # Apache-2.0. flutter_math_fork: ^0.7.4 + # Colouring a fenced code block in the language its info string names: the + # highlight.js grammars ported to Dart, MIT. Each grammar is a value of its + # own that the app names, so only the languages it registers are compiled in. + re_highlight: ^0.0.3 # One quiet, consistent line-icon language across every app surface. # Hugeicons' free stroke-rounded set is MIT licensed and tree-shaken. hugeicons: ^1.1.7 diff --git a/test/markdown_syntax_test.dart b/test/markdown_syntax_test.dart index a40c735..4127ef4 100644 --- a/test/markdown_syntax_test.dart +++ b/test/markdown_syntax_test.dart @@ -588,6 +588,26 @@ void main() { }); }); + group('fenced code', () { + test('that names a language is kept, with where its code is', () { + const note = + '```python\nprint(1)\n```\n\n' + '- ```ts\n let x = 1;\n ```\n\n' + '```\nplain\n```'; + final blocks = read(note).fencedCode; + expect([for (final block in blocks) block.language], ['python', 'ts']); + String code(MarkdownCodeBlock block) => [ + for (final range in block.code) note.substring(range.start, range.end), + ].join(); + expect(code(blocks.first), 'print(1)\n'); + expect( + code(blocks.last), + 'let x = 1;\n', + reason: 'the item\'s indentation is not code', + ); + }); + }); + group('reading in pieces', () { const vocabulary = [ '', '', '', ' ', '\t', // @@ -647,6 +667,10 @@ void main() { ], ranges(analysis.atomicPrefixes), [for (final math in analysis.maths) math.toString()], + [ + for (final block in analysis.fencedCode) + '${block.language}-${ranges(block.code)}', + ], analysis.calculatorText, ]; } diff --git a/test/note_editor_markdown_test.dart b/test/note_editor_markdown_test.dart index e5f4b2a..7068cd0 100644 --- a/test/note_editor_markdown_test.dart +++ b/test/note_editor_markdown_test.dart @@ -1644,7 +1644,7 @@ void main() { expect(controllerOf(tester).text, 'say **hi** x'); }); }); - group('formulas', () { + group('formulas and code', () { /// Where the first box [needle] is drawn in sits on screen. Rect rectOf(WidgetTester tester, String needle) { final start = controllerOf(tester).text.indexOf(needle); @@ -1767,5 +1767,22 @@ void main() { reason: 'the result is beside the line it belongs to', ); }); + + testWidgets('fenced code is coloured by its language, from the palette', ( + tester, + ) async { + const body = + '```python\ndef total(xs):\n return sum(xs) # all\n```\n\n' + '```nosuchlanguage\ndefine it\n```'; + await tester.pumpWidget(harness(body)); + await tester.pumpAndSettle(); + const palette = KapyTheme.darkPalette; + expect(styleOf(tester, 'def').color, palette.keyword); + expect(styleOf(tester, 'return').color, palette.keyword); + expect(styleOf(tester, 'total').color, palette.function); + expect(styleOf(tester, '# all').color, palette.comment); + expect(styleOf(tester, '# all').fontStyle, FontStyle.italic); + expect(styleOf(tester, 'define').color, isNot(palette.keyword)); + }); }); } From 86a3ab85c932fd905ba6b07a18e6e44375e9344e Mon Sep 17 00:00:00 2001 From: Sanjay Kholiya Date: Mon, 16 Nov 2026 23:09:19 +0530 Subject: [PATCH 05/48] Underline, raise and lower the words in , , and A or closed among the same words underlines them, and and raise and lower them. The tags hide like any inline marker, showing again with the caret against them, and the calculator reads the words without them. A tag that is never closed, or that crosses another, stays the HTML it is written as, and other inline HTML looks as it did. A text engine cannot move words off their baseline, so a superscript uses the face's own raised glyphs where it has one for every character: digits in Shantell Sans, and digits, small letters and +=() in the system face on Apple's platforms. Anything else is drawn smaller on the baseline. Either way the line keeps its height. A table's grid draws them too, so its run style is now told the words it styles. --- lib/ui/editor/highlighting_controller.dart | 80 ++++++++++++++++++++-- lib/ui/editor/markdown_syntax.dart | 75 +++++++++++++++++++- lib/ui/editor/note_editor.dart | 3 +- lib/ui/editor/table_geometry.dart | 4 +- test/markdown_syntax_test.dart | 38 ++++++++++ test/note_editor_markdown_test.dart | 28 +++++++- test/table_geometry_test.dart | 4 +- 7 files changed, 218 insertions(+), 14 deletions(-) diff --git a/lib/ui/editor/highlighting_controller.dart b/lib/ui/editor/highlighting_controller.dart index b5f8838..2f73af8 100644 --- a/lib/ui/editor/highlighting_controller.dart +++ b/lib/ui/editor/highlighting_controller.dart @@ -501,10 +501,18 @@ class HighlightingController extends TextEditingController { }; } if (markdown != 0) { + final script = openMarkdown + .where( + (span) => + span.style == MarkdownStyle.superscript || + span.style == MarkdownStyle.subscript, + ) + .lastOrNull; segmentStyle = _markdownInlineStyle( segmentStyle, marked, segmentLinkColor, + script == null ? '' : source.substring(script.start, script.end), ); } final done = checked || marked(MarkdownStyle.doneTask); @@ -916,26 +924,30 @@ class HighlightingController extends TextEditingController { ); } - /// How words under [styles] are drawn somewhere other than the field — in - /// a table drawn as a grid — in the faces and colours they have in it. + /// How [words] under [styles] are drawn somewhere other than the field — + /// in a table drawn as a grid — in the faces and colours they have in it. TextStyle markdownRunStyle( TextStyle base, Set styles, - Color linkColor, - ) { + Color linkColor, { + String words = '', + }) { bool marked(MarkdownStyle style) => styles.contains(style); return _markdownInlineStyle( _markdownBlockStyle(base, base, marked), marked, linkColor, + words, ); } - /// The markdown that changes a word rather than a block. + /// The markdown that changes a word rather than a block. [script] is all + /// of the superscript or subscript the words are part of, if they are. TextStyle _markdownInlineStyle( TextStyle style, bool Function(MarkdownStyle) marked, Color linkColor, + String script, ) { var result = style; if (marked(MarkdownStyle.strong) || marked(MarkdownStyle.tableHeader)) { @@ -944,12 +956,23 @@ class HighlightingController extends TextEditingController { if (marked(MarkdownStyle.emphasis)) { result = result.copyWith(fontStyle: FontStyle.italic); } - if (marked(MarkdownStyle.strikethrough)) { + final lines = [ + if (marked(MarkdownStyle.underline)) TextDecoration.underline, + if (marked(MarkdownStyle.strikethrough)) TextDecoration.lineThrough, + ]; + if (lines.isNotEmpty) { result = result.copyWith( - decoration: TextDecoration.lineThrough, + decoration: TextDecoration.combine(lines), decorationColor: result.color, ); } + if (marked(MarkdownStyle.superscript) || marked(MarkdownStyle.subscript)) { + result = _scripted( + result, + script, + superscript: marked(MarkdownStyle.superscript), + ); + } if (marked(MarkdownStyle.link)) { result = result.copyWith(color: linkColor); } @@ -962,6 +985,49 @@ class HighlightingController extends TextEditingController { return result; } + /// Superscript or subscript: the face's own raised or lowered glyphs where + /// it has one for every character of [script], and otherwise the same words + /// smaller. A text engine cannot move words off their baseline, and the + /// line keeps its height either way. + /// + /// Which characters a face has these for is known for the faces a note is + /// written in: Shantell Sans for digits, the system face on Apple's + /// platforms for digits, small letters and `+=()`. Anywhere else the words + /// are drawn smaller. + TextStyle _scripted( + TextStyle style, + String script, { + required bool superscript, + }) { + final (feature, drawn) = switch (style.fontFamily) { + 'Shantell Sans' => (superscript ? 'sups' : 'sinf', _digits), + '.AppleSystemUIFont' => ( + superscript ? 'sups' : 'subs', + _appleScriptCharacters, + ), + _ => (null, const {}), + }; + if (feature != null && + script.trim().isNotEmpty && + script.runes.every((rune) => rune == 0x20 || drawn.contains(rune))) { + return style.copyWith( + fontFeatures: [...?style.fontFeatures, FontFeature.enable(feature)], + ); + } + final size = style.fontSize; + final height = style.height; + if (size == null) return style; + return style.copyWith( + fontSize: size * _scriptScale, + height: height == null ? null : height / _scriptScale, + ); + } + + static const double _scriptScale = 0.75; + static final _digits = '0123456789'.runes.toSet(); + static final _appleScriptCharacters = + '0123456789abcdefghijklmnopqrstuvwxyz+=()'.runes.toSet(); + static List _checkedTextRanges(String source) { final ranges = []; var lineStart = 0; diff --git a/lib/ui/editor/markdown_syntax.dart b/lib/ui/editor/markdown_syntax.dart index 7814732..824e16a 100644 --- a/lib/ui/editor/markdown_syntax.dart +++ b/lib/ui/editor/markdown_syntax.dart @@ -19,6 +19,15 @@ enum MarkdownStyle { emphasis, strikethrough, + /// Words between `` and ``, or `` and ``. + underline, + + /// Words between `` and ``. + superscript, + + /// Words between `` and ``. + subscript, + /// Inline code, its backticks included. code, @@ -811,6 +820,9 @@ class MarkdownAnalysis { MarkdownStyle.strong, MarkdownStyle.emphasis, MarkdownStyle.strikethrough, + MarkdownStyle.underline, + MarkdownStyle.superscript, + MarkdownStyle.subscript, MarkdownStyle.code, MarkdownStyle.math, MarkdownStyle.link, @@ -1743,6 +1755,9 @@ class _Collector { /// over like any other line prefix. final _numbers = []; + /// Where each ``, `` and the like that is one of a pair starts. + final _pairedTags = {}; + _Parts finish({required _Tail tail, required bool hasReferences}) { _spans.sort((a, b) => a.start.compareTo(b.start)); _links.sort((a, b) => a.start.compareTo(b.start)); @@ -2073,7 +2088,13 @@ class _Collector { case 'tableHeadCell': _style(start, end, MarkdownStyle.tableHeader); case 'htmlBlock' || 'rawHtml': - _style(start, end, MarkdownStyle.html); + _style( + start, + end, + _pairedTags.contains(start) + ? MarkdownStyle.syntax + : MarkdownStyle.html, + ); _record(_literals, start, end); case 'math' || 'displayMath': _math(node, claimed); @@ -2208,6 +2229,7 @@ class _Collector { ); } } + _pairTags(node.children); for (final child in node.children) { visit(child, quoteDepth: childQuoteDepth, listDepth: childListDepth); } @@ -2242,6 +2264,57 @@ class _Collector { _maths.add(MarkdownMath(range.start, range.end, tex, display: display)); } + /// ``, ``, `` and ``, opening and closing among the + /// same words. Their words are drawn the way the tags ask, and the tags are + /// hidden like any other inline marker. One that crosses another, or is + /// never closed, stays the HTML it is written as. + void _pairTags(List nodes) { + final open = <(String, md.Element)>[]; + for (final node in nodes) { + if (node is! md.Element || node.type != 'rawHtml') continue; + final tag = _pairedTag.firstMatch( + source.substring(_clamp(node.start.offset), _clamp(node.end.offset)), + ); + if (tag == null) continue; + final name = tag[2]!.toLowerCase(); + if (tag[1]!.isEmpty) { + open.add((name, node)); + continue; + } + final at = open.lastIndexWhere((opening) => opening.$1 == name); + if (at < 0) continue; + final opening = open[at].$2; + open.removeRange(at, open.length); + final scopeStart = opening.start.offset; + final scopeEnd = node.end.offset; + final innerStart = opening.end.offset; + final innerEnd = node.start.offset; + _style(innerStart, innerEnd, switch (name) { + 'sup' => MarkdownStyle.superscript, + 'sub' => MarkdownStyle.subscript, + _ => MarkdownStyle.underline, + }); + for (final marker in [opening, node]) { + _pairedTags.add(marker.start.offset); + _record(_unread, marker.start.offset, marker.end.offset); + _conceal( + marker.start.offset, + marker.end.offset, + MarkdownReveal.edges, + scopeStart: scopeStart, + scopeEnd: scopeEnd, + innerStart: innerStart, + innerEnd: innerEnd, + ); + } + } + } + + static final _pairedTag = RegExp( + r'^<(/?)(u|ins|sup|sub)>$', + caseSensitive: false, + ); + void _listItem( md.Element node, Set claimed, { diff --git a/lib/ui/editor/note_editor.dart b/lib/ui/editor/note_editor.dart index d93ba2d..121131e 100644 --- a/lib/ui/editor/note_editor.dart +++ b/lib/ui/editor/note_editor.dart @@ -5520,11 +5520,12 @@ class NoteEditorState extends State with WidgetsBindingObserver { scaler: textScaler, fitToWidth: attachmentWidth, minRowHeight: rowHeight, - runStyle: (base, styles) { + runStyle: (base, styles, words) { final drawn = _controller.markdownRunStyle( base, styles, Theme.of(context).colorScheme.primary, + words: words, ); // The pill inline code has in the text can be a plain // background in a grid painted behind it: there is no diff --git a/lib/ui/editor/table_geometry.dart b/lib/ui/editor/table_geometry.dart index 71b3203..7098c44 100644 --- a/lib/ui/editor/table_geometry.dart +++ b/lib/ui/editor/table_geometry.dart @@ -6,7 +6,7 @@ import 'markdown_syntax.dart'; /// How a run of a cell's words is drawn, given the markdown over them. typedef MarkdownRunStyle = - TextStyle Function(TextStyle base, Set styles); + TextStyle Function(TextStyle base, Set styles, String words); /// The grid one table is drawn as: how wide each column is, how tall each row /// is, and the words of each cell laid out ready to paint. @@ -62,7 +62,7 @@ class TableGeometry { style: runStyle(base, { ...run.styles, if (row.header) MarkdownStyle.tableHeader, - }), + }, run.text), ), ], ), diff --git a/test/markdown_syntax_test.dart b/test/markdown_syntax_test.dart index 4127ef4..5a3f48c 100644 --- a/test/markdown_syntax_test.dart +++ b/test/markdown_syntax_test.dart @@ -588,6 +588,44 @@ void main() { }); }); + group('HTML among words', () { + test(', , and style what they hold', () { + final analysis = read( + 'under inserted x2 H3O', + ); + expect(stylesOf(analysis, 'under'), contains(MarkdownStyle.underline)); + expect(stylesOf(analysis, 'inserted'), contains(MarkdownStyle.underline)); + expect(stylesOf(analysis, '2'), contains(MarkdownStyle.superscript)); + expect(stylesOf(analysis, '3'), contains(MarkdownStyle.subscript)); + expect(stylesOf(analysis, ''), contains(MarkdownStyle.syntax)); + expect(stylesOf(analysis, ''), isNot(contains(MarkdownStyle.html))); + }); + + test('their tags hide like any inline marker', () { + expect(visible('a word b|'), 'a word b'); + expect(visible('a word| b'), 'a word b'); + expect(visible('a word| b', typing: true), 'a word b'); + }); + + test('the calculator reads their words without them', () { + expect(read('5 + 3').calculatorText, ' 5 + 3 '); + }); + + test('one never closed, or crossing another, stays the HTML it is', () { + final open = read('open'); + expect(stylesOf(open, ''), contains(MarkdownStyle.html)); + expect(stylesOf(open, 'open'), isNot(contains(MarkdownStyle.underline))); + + final crossed = read('x'); + expect(stylesOf(crossed, 'x'), contains(MarkdownStyle.underline)); + expect( + stylesOf(crossed, 'x'), + isNot(contains(MarkdownStyle.superscript)), + ); + expect(stylesOf(crossed, ''), contains(MarkdownStyle.html)); + }); + }); + group('fenced code', () { test('that names a language is kept, with where its code is', () { const note = diff --git a/test/note_editor_markdown_test.dart b/test/note_editor_markdown_test.dart index 7068cd0..a2fe998 100644 --- a/test/note_editor_markdown_test.dart +++ b/test/note_editor_markdown_test.dart @@ -1644,7 +1644,7 @@ void main() { expect(controllerOf(tester).text, 'say **hi** x'); }); }); - group('formulas and code', () { + group('formulas, code and HTML', () { /// Where the first box [needle] is drawn in sits on screen. Rect rectOf(WidgetTester tester, String needle) { final start = controllerOf(tester).text.indexOf(needle); @@ -1784,5 +1784,31 @@ void main() { expect(styleOf(tester, '# all').fontStyle, FontStyle.italic); expect(styleOf(tester, 'define').color, isNot(palette.keyword)); }); + + testWidgets('underline, superscript and subscript, their tags hidden', ( + tester, + ) async { + const body = + 'a under E = mc2 and H3O xn'; + await tester.pumpWidget(harness(body)); + await tester.pumpAndSettle(); + expect(isHidden(tester, ''), isTrue); + expect(isHidden(tester, ''), isTrue); + expect(styleOf(tester, 'under').decoration, TextDecoration.underline); + // The handwritten face has raised and lowered figures of its own. + expect( + styleOf(tester, '2<').fontFeatures, + contains(const FontFeature.enable('sups')), + ); + expect( + styleOf(tester, '3<').fontFeatures, + contains(const FontFeature.enable('sinf')), + ); + // But not letters, which are drawn smaller instead. + expect( + styleOf(tester, 'n<').fontSize, + lessThan(styleOf(tester, 'x<').fontSize!), + ); + }); }); } diff --git a/test/table_geometry_test.dart b/test/table_geometry_test.dart index db7f635..045f891 100644 --- a/test/table_geometry_test.dart +++ b/test/table_geometry_test.dart @@ -21,7 +21,7 @@ TableGeometry geometryFor( analysis: analysis, base: _base, scaler: TextScaler.noScaling, - runStyle: (base, styles) => base, + runStyle: (base, styles, words) => base, fitToWidth: fitToWidth, minRowHeight: minRowHeight, ); @@ -301,7 +301,7 @@ void main() { analysis: analysis, base: base, scaler: TextScaler.noScaling, - runStyle: (base, styles) => base, + runStyle: (base, styles, words) => base, fitToWidth: fitToWidth, ); From ec81adce0f570f602858bb42d90681c8e25afa00 Mon Sep 17 00:00:00 2001 From: Sanjay Kholiya Date: Mon, 16 Nov 2026 23:09:20 +0530 Subject: [PATCH 06/48] Break a table cell's line at

,
and
in a GFM table's cell start a new line of it, whether the grid fits its columns to the page or keeps their natural widths, and the room the note keeps for each row is measured from the same lines, so the two agree. At natural widths, where a cell is otherwise cut to one line, each of its lines is cut short with an ellipsis of its own, since a painter only shortens the last line it may draw. Outside a table a
is shown as written, as before. A random test now checks that a note mixing formulas, HTML, tables and fenced code is read the same in pieces as whole. --- lib/ui/editor/markdown_syntax.dart | 56 +++++++++++++-- lib/ui/editor/table_geometry.dart | 107 ++++++++++++++++++++++++---- test/markdown_syntax_test.dart | 36 ++++++++++ test/note_editor_markdown_test.dart | 17 +++++ test/table_geometry_test.dart | 32 +++++++++ 5 files changed, 232 insertions(+), 16 deletions(-) diff --git a/lib/ui/editor/markdown_syntax.dart b/lib/ui/editor/markdown_syntax.dart index 824e16a..5f91754 100644 --- a/lib/ui/editor/markdown_syntax.dart +++ b/lib/ui/editor/markdown_syntax.dart @@ -681,6 +681,10 @@ class MarkdownAnalysis { /// as its TeX, in the grid. List get maths => _parts.maths; + /// `
` tags, which a table's cell draws as the line break they ask for. + /// Anywhere else a tag is shown as written, as any other inline HTML is. + List get lineBreaks => _parts.lineBreaks; + /// The rest of what the calculator does not read: struck-through text, and /// the `*` and `_` around emphasis — the markers only, not the words. List get unread => _parts.unread; @@ -755,6 +759,9 @@ class MarkdownAnalysis { /// The words of [start, end) with every marker in it hidden, trimmed, and /// cut wherever their inline markdown changes: what a table's cell shows /// when the table is drawn as a grid rather than as its text. + /// + /// A `
` becomes the line break it asks for, the spaces either side of + /// it dropped, since a cell has nowhere else to put one. List runsIn(int start, int end) { final hidden = [ for (final conceal in conceals) @@ -767,6 +774,10 @@ class MarkdownAnalysis { _runStyles.contains(span.style)) span, ]; + final breaks = [ + for (final tag in lineBreaks) + if (tag.start >= start && tag.end <= end) tag, + ]; final cuts = {start, end}; for (final conceal in hidden) { cuts @@ -778,6 +789,11 @@ class MarkdownAnalysis { ..add(span.start.clamp(start, end)) ..add(span.end.clamp(start, end)); } + for (final tag in breaks) { + cuts + ..add(tag.start) + ..add(tag.end); + } final sorted = cuts.toList()..sort(); final runs = []; @@ -788,11 +804,15 @@ class MarkdownAnalysis { hidden.any((conceal) => conceal.start <= from && to <= conceal.end)) { continue; } + final lineBreak = breaks.any((tag) => tag.start <= from && to <= tag.end); final styles = { for (final span in styled) - if (span.start <= from && to <= span.end) span.style, + if (span.start <= from && + to <= span.end && + !(lineBreak && span.style == MarkdownStyle.html)) + span.style, }; - final words = text.substring(from, to); + final words = lineBreak ? '\n' : text.substring(from, to); if (runs.isNotEmpty && setEquals(runs.last.styles, styles)) { final last = runs.removeLast(); runs.add((text: last.text + words, styles: styles)); @@ -800,6 +820,15 @@ class MarkdownAnalysis { runs.add((text: words, styles: styles)); } } + if (breaks.isNotEmpty) { + for (var i = 0; i < runs.length; i++) { + final run = runs[i]; + runs[i] = ( + text: run.text.replaceAll(_spacedBreak, '\n'), + styles: run.styles, + ); + } + } while (runs.isNotEmpty && runs.first.text.trimLeft().isEmpty) { runs.removeAt(0); @@ -815,6 +844,8 @@ class MarkdownAnalysis { return runs; } + static final _spacedBreak = RegExp(r'[ \t]*\n[ \t]*'); + /// The markdown that styles words wherever they are drawn. static const _runStyles = { MarkdownStyle.strong, @@ -1199,6 +1230,7 @@ class _Parts { required this.codeBlocks, required this.fencedCode, required this.maths, + required this.lineBreaks, required this.unread, required this.literals, required this.addresses, @@ -1221,6 +1253,7 @@ class _Parts { codeBlocks: [], fencedCode: [], maths: [], + lineBreaks: [], unread: [], literals: [], addresses: [], @@ -1240,6 +1273,7 @@ class _Parts { final List codeBlocks; final List fencedCode; final List maths; + final List lineBreaks; final List unread; final List literals; final List addresses; @@ -1268,6 +1302,7 @@ class _Parts { codeBlocks: all((p) => p.codeBlocks, _shift), fencedCode: all((p) => p.fencedCode, (c, by) => c._shifted(by)), maths: all((p) => p.maths, (m, by) => m._shifted(by)), + lineBreaks: all((p) => p.lineBreaks, _shift), unread: all((p) => p.unread, _shift), literals: all((p) => p.literals, _shift), addresses: all((p) => p.addresses, _shift), @@ -1277,7 +1312,8 @@ class _Parts { } /// Just the tables, and only what [MarkdownAnalysis.runsIn] needs to draw - /// their cells: the inline styles inside them, and the markers those hide. + /// their cells: the inline styles inside them, the markers those hide, and + /// the `
` tags that break their lines. /// /// Everything else is dropped rather than emptied by its reader, so that one /// answer covers every part of the editor at once — nothing can quietly read @@ -1309,6 +1345,7 @@ class _Parts { codeBlocks: const [], fencedCode: const [], maths: const [], + lineBreaks: lineBreaks, unread: const [], literals: const [], addresses: const [], @@ -1745,6 +1782,7 @@ class _Collector { final _codeBlocks = []; final _fencedCode = []; final _maths = []; + final _lineBreaks = []; final _unread = []; final _literals = []; final _addresses = []; @@ -1770,6 +1808,7 @@ class _Collector { _maths.sort((a, b) => a.start.compareTo(b.start)); for (final ranges in [ _codeBlocks, + _lineBreaks, _unread, _literals, _addresses, @@ -1791,6 +1830,7 @@ class _Collector { codeBlocks: List.unmodifiable(_codeBlocks), fencedCode: List.unmodifiable(_fencedCode), maths: List.unmodifiable(_maths), + lineBreaks: List.unmodifiable(_lineBreaks), unread: List.unmodifiable(_unread), literals: List.unmodifiable(_literals), addresses: List.unmodifiable(_addresses), @@ -2096,6 +2136,12 @@ class _Collector { : MarkdownStyle.html, ); _record(_literals, start, end); + if (_inTable(start) && + _lineBreakTag.hasMatch( + source.substring(_clamp(start), _clamp(end)), + )) { + _record(_lineBreaks, start, end); + } case 'math' || 'displayMath': _math(node, claimed); case 'linkReferenceDefinition': @@ -2236,7 +2282,7 @@ class _Collector { } /// Whether [offset] is in the table being read: a cell's words are drawn by - /// its grid, which shows a formula as its TeX. + /// its grid, which shows a formula as its TeX and a `
` as a line break. bool _inTable(int offset) => _tables.isNotEmpty && offset >= _tables.last.start && @@ -2315,6 +2361,8 @@ class _Collector { caseSensitive: false, ); + static final _lineBreakTag = RegExp(r'^$', caseSensitive: false); + void _listItem( md.Element node, Set claimed, { diff --git a/lib/ui/editor/table_geometry.dart b/lib/ui/editor/table_geometry.dart index 7098c44..0ab93b1 100644 --- a/lib/ui/editor/table_geometry.dart +++ b/lib/ui/editor/table_geometry.dart @@ -28,6 +28,10 @@ typedef MarkdownRunStyle = /// onto as many lines as they need. A phone's writing column is narrower than /// most tables, and hiding half a cell behind an ellipsis is no way to edit /// one. +/// +/// Either way a `
` in a cell starts a new line of it, so a cell has as +/// many lines as it was written with at the least: one each, cut short one by +/// one, when the table is its natural size. class TableGeometry { TableGeometry({ required this.table, @@ -52,24 +56,28 @@ class TableGeometry { final painters = []; for (var c = 0; c < row.cells.length; c++) { final cell = row.cells[c]; + final words = [ + for (final run in analysis.runsIn(cell.start, cell.end)) + TextSpan( + text: run.text, + style: runStyle(base, { + ...run.styles, + if (row.header) MarkdownStyle.tableHeader, + }, run.text), + ), + ]; + final broken = words.any((span) => span.text!.contains('\n')); final painter = TextPainter( text: TextSpan( style: base, - children: [ - for (final run in analysis.runsIn(cell.start, cell.end)) - TextSpan( - text: run.text, - style: runStyle(base, { - ...run.styles, - if (row.header) MarkdownStyle.tableHeader, - }, run.text), - ), - ], + children: fitting || !broken + ? words + : _cutShort(words, base, scaler, maxCellWidth), ), textDirection: TextDirection.ltr, textScaler: scaler, - maxLines: fitting ? null : 1, - ellipsis: fitting ? null : '…', + maxLines: fitting || broken ? null : 1, + ellipsis: fitting || broken ? null : '…', )..layout(maxWidth: maxCellWidth); natural[c] = math.max(natural[c], painter.width); longestWord[c] = math.max(longestWord[c], painter.minIntrinsicWidth); @@ -217,6 +225,81 @@ class TableGeometry { return null; } + /// [words] with each of its lines that is wider than [width] cut short, an + /// ellipsis in place of the rest: what a single-line cell gets from its + /// painter, done line by line, since a painter only shortens the last line + /// it is allowed and wraps every one before it. + static List _cutShort( + List words, + TextStyle base, + TextScaler scaler, + double width, + ) { + final lines = >[[]]; + for (final span in words) { + final pieces = span.text!.split('\n'); + for (var i = 0; i < pieces.length; i++) { + if (i > 0) lines.add([]); + if (pieces[i].isNotEmpty) { + lines.last.add(TextSpan(text: pieces[i], style: span.style)); + } + } + } + double widthOf(List line) { + final painter = TextPainter( + text: TextSpan(style: base, children: line), + textDirection: TextDirection.ltr, + textScaler: scaler, + maxLines: 1, + )..layout(); + final width = painter.width; + painter.dispose(); + return width; + } + + List ellipsized(List line, int length) { + final kept = []; + var left = length; + for (final span in line) { + final text = span.text!; + if (left < text.length) { + var end = left; + if (end > 0 && _isLeadSurrogate(text.codeUnitAt(end - 1))) end--; + kept.add( + TextSpan(text: '${text.substring(0, end)}…', style: span.style), + ); + return kept; + } + kept.add(span); + left -= text.length; + } + return kept; + } + + final result = []; + for (var l = 0; l < lines.length; l++) { + var line = lines[l]; + if (widthOf(line) > width) { + var low = 0; + var high = line.fold(0, (sum, span) => sum + span.text!.length); + while (low < high) { + final middle = (low + high + 1) ~/ 2; + if (widthOf(ellipsized(line, middle)) <= width) { + low = middle; + } else { + high = middle - 1; + } + } + line = ellipsized(line, low); + } + if (l > 0) result.add(const TextSpan(text: '\n')); + result.addAll(line); + } + return result; + } + + static bool _isLeadSurrogate(int unit) => unit >= 0xD800 && unit <= 0xDBFF; + /// [natural] shrunk to fit [available]. /// /// Wide columns give way before narrow ones: the widest are capped at one diff --git a/test/markdown_syntax_test.dart b/test/markdown_syntax_test.dart index 5a3f48c..99d72c8 100644 --- a/test/markdown_syntax_test.dart +++ b/test/markdown_syntax_test.dart @@ -624,6 +624,19 @@ void main() { ); expect(stylesOf(crossed, ''), contains(MarkdownStyle.html)); }); + + test('
breaks the line of a table\'s cell, and nothing else', () { + final analysis = read( + '| a |\n|---|\n| one
two
three
four |', + ); + final cell = analysis.tables.single.rows[1].cells.single; + expect( + [for (final run in analysis.runsIn(cell.start, cell.end)) run.text], + ['one\ntwo\nthree\nfour'], + ); + expect(analysis.lineBreaks, hasLength(3)); + expect(read('one
two').lineBreaks, isEmpty); + }); }); group('fenced code', () { @@ -709,6 +722,7 @@ void main() { for (final block in analysis.fencedCode) '${block.language}-${ranges(block.code)}', ], + ranges(analysis.lineBreaks), analysis.calculatorText, ]; } @@ -725,6 +739,28 @@ void main() { } }); + test('gives the same with math and HTML in the note', () { + const markup = [ + r'$$', r'$$x$$', r'$x$', r'$\frac{a}{b}$', r'$5 and $10', // + r'a \$5', r'$ $', r'a $x', r'y$ b', r'> $$', r'- $$', r' $$', + r'$$ $$', r'$\text{$}$', 'u', '2', '', '', + '
', '| a
b |', r'| $x$ | y |', '|---|---|', '```py', + '```', + ]; + final random = Random(41); + for (var i = 0; i < 800; i++) { + final note = List.generate(random.nextInt(24), (_) { + final pool = random.nextBool() ? markup : vocabulary; + return pool[random.nextInt(pool.length)]; + }).join('\n'); + expect( + everything(MarkdownAnalyzer().analyze(note)), + everything(MarkdownAnalyzer.analyzeWhole(note)), + reason: note, + ); + } + }); + test('and keeps doing so edit after edit', () { final random = Random(11); const typed = ['*', '`', '\n', ' ', '#', '-', '>', 'x', '[', ']', '~']; diff --git a/test/note_editor_markdown_test.dart b/test/note_editor_markdown_test.dart index a2fe998..0fb7376 100644 --- a/test/note_editor_markdown_test.dart +++ b/test/note_editor_markdown_test.dart @@ -1810,5 +1810,22 @@ void main() { lessThan(styleOf(tester, 'x<').fontSize!), ); }); + + testWidgets('a
in a cell gives its row another line', (tester) async { + Future afterWith(String cell) async { + await tester.pumpWidget(const SizedBox.shrink()); + await tester.pumpAndSettle(); + await tester.pumpWidget(harness('| a |\n| --- |\n| $cell |\n\nafter')); + await tester.pumpAndSettle(); + return centerOf(tester, 'after').dy; + } + + final one = await afterWith('one two'); + final two = await afterWith('one
two'); + final three = await afterWith('one
two
three'); + expect(two, greaterThan(one)); + expect(three - two, greaterThan(0)); + expect(three - two, closeTo(two - one, 1), reason: 'a line apiece'); + }); }); } diff --git a/test/table_geometry_test.dart b/test/table_geometry_test.dart index 045f891..2bf41e3 100644 --- a/test/table_geometry_test.dart +++ b/test/table_geometry_test.dart @@ -396,4 +396,36 @@ void main() { expect(fitted.width, closeTo(120, 0.5)); }); }); + + group('a
in a cell', () { + test('starts a line of its own, at the natural size and fitted alike', () { + for (final fitToWidth in [null, 400.0]) { + final geometry = geometryFor( + '| a |\n| --- |\n| one
two |', + fitToWidth: fitToWidth, + ); + final [header, row] = geometry.table.rows; + final cell = geometry.cell(row, 0)!; + expect(cell.plainText, 'one\ntwo', reason: '$fitToWidth'); + expect(cell.computeLineMetrics(), hasLength(2), reason: '$fitToWidth'); + expect( + geometry.rowHeight(row), + greaterThan(geometry.rowHeight(header)), + reason: '$fitToWidth', + ); + } + }); + + test('at the natural size, cuts each of its lines short on its own', () { + final long = List.filled(40, 'word').join(' '); + final geometry = geometryFor('| a |\n| --- |\n| $long
short |'); + final cell = geometry.cell(geometry.table.rows[1], 0)!; + final lines = cell.plainText.split('\n'); + expect(lines, hasLength(2)); + expect(lines.first, endsWith('…')); + expect(lines.last, 'short'); + expect(cell.computeLineMetrics(), hasLength(2)); + expect(cell.width, lessThanOrEqualTo(TableGeometry.maxCellWidth)); + }); + }); } From 8dd95bfa0e6a9684592eb40f929ee64d29bb5c62 Mon Sep 17 00:00:00 2001 From: Sanjay Kholiya Date: Mon, 16 Nov 2026 23:09:20 +0530 Subject: [PATCH 07/48] Add light and dark goldens of formulas, code and underline One note with formulas among words and set apart, TeX that does not parse, prices, , and , a Python block, and a table with a
and a formula in its cells: drawn in dark, in light, and in dark with the caret in the display formula, which then shows its TeX. --- test/goldens/markdown_rendering_dark.png | Bin 0 -> 68685 bytes test/goldens/markdown_rendering_light.png | Bin 0 -> 71657 bytes .../markdown_rendering_revealed_dark.png | Bin 0 -> 71086 bytes test/note_editor_markdown_test.dart | 78 +++++++++++++++++- 4 files changed, 77 insertions(+), 1 deletion(-) create mode 100644 test/goldens/markdown_rendering_dark.png create mode 100644 test/goldens/markdown_rendering_light.png create mode 100644 test/goldens/markdown_rendering_revealed_dark.png diff --git a/test/goldens/markdown_rendering_dark.png b/test/goldens/markdown_rendering_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..d15b1c93d15d5539d55617fc0dd4126795ec0af2 GIT binary patch literal 68685 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�XU2w4K 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 R!ti{Q>NU-)xylco{TufVNw5F_ literal 0 HcmV?d00001 diff --git a/test/goldens/markdown_rendering_light.png b/test/goldens/markdown_rendering_light.png new file mode 100644 index 0000000000000000000000000000000000000000..1310795c70cb20dd136d934a3b9922e0ae6cb4bd GIT binary patch literal 71657 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 QOQ7WLDBjM#rSJRS01iR=j{pDw literal 0 HcmV?d00001 diff --git a/test/goldens/markdown_rendering_revealed_dark.png b/test/goldens/markdown_rendering_revealed_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..0f38faf117569833b52f10f3a2bb3dcf257a0921 GIT binary patch literal 71086 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 Fe*uhB!O#Ez literal 0 HcmV?d00001 diff --git a/test/note_editor_markdown_test.dart b/test/note_editor_markdown_test.dart index 0fb7376..961f1dd 100644 --- a/test/note_editor_markdown_test.dart +++ b/test/note_editor_markdown_test.dart @@ -41,6 +41,7 @@ Widget harness( bool markdown = true, bool autofocus = false, bool readOnly = false, + bool light = false, double? width, List initialFormats = const [], ValueChanged? onBodyChanged, @@ -57,7 +58,7 @@ Widget harness( ); return MaterialApp( - theme: KapyTheme.dark(), + theme: light ? KapyTheme.light() : KapyTheme.dark(), home: Scaffold( body: bound( NoteEditor( @@ -1827,5 +1828,80 @@ void main() { expect(three - two, greaterThan(0)); expect(three - two, closeTo(two - one, 1), reason: 'a line apiece'); }); + + group('as a golden', () { + const note = + '# Formulas, code and underline\n' + '\n' + r'The area of a circle is $\pi r^2$, and lunch was $5 or $10.' + '\n' + '\n' + '\$\$\n' + r'x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}' + '\n' + '\$\$\n' + '\n' + r'TeX that does not parse stays as written: $\frac{a$' + '\n' + '\n' + 'Underlined, E = mc2, H2O and ' + '2n\n' + '\n' + '```python\n' + 'def area(r):\n' + ' # a circle\n' + ' return 3.14159 * r ** 2 # "pi r squared"\n' + '```\n' + '\n' + '| Constant | Value |\n' + '| --- | --- |\n' + '| Speed of light | 299 792 458
metres a second |\n' + r'| $c^2$ | squared |' + '\n' + '\n' + '5 + 3'; + + Future pumpNote( + WidgetTester tester, { + bool light = false, + bool focused = false, + }) async { + tester.view.physicalSize = const Size(900, 1000); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.reset); + await tester.pumpWidget( + harness(note, light: light, autofocus: focused), + ); + await tester.pumpAndSettle(); + } + + testWidgets('dark', (tester) async { + await pumpNote(tester); + await expectLater( + find.byType(NoteEditor), + matchesGoldenFile('goldens/markdown_rendering_dark.png'), + ); + }); + + testWidgets('light', (tester) async { + await pumpNote(tester, light: true); + await expectLater( + find.byType(NoteEditor), + matchesGoldenFile('goldens/markdown_rendering_light.png'), + ); + }); + + testWidgets('dark, the caret in a formula set apart', (tester) async { + await pumpNote(tester, focused: true); + controllerOf(tester).selection = TextSelection.collapsed( + offset: note.indexOf(r'\frac{-b'), + ); + await tester.pumpAndSettle(); + await expectLater( + find.byType(NoteEditor), + matchesGoldenFile('goldens/markdown_rendering_revealed_dark.png'), + ); + }); + }); }); } From e4609b06406618a9147b895d2e61847da72983cb Mon Sep 17 00:00:00 2001 From: Sanjay Kholiya Date: Mon, 16 Nov 2026 23:09:21 +0530 Subject: [PATCH 08/48] Add a profile benchmark for a long note with formulas and code benchmark/markdown_rendering.dart opens a 5,000-line note with 350 formulas and 30 fenced code blocks three times, then types into it a key every 33 ms in prose, in a code block and after a formula, and prints how long each opening took to its first frame and how long the typing frames took to build and to draw. It is an app rather than a test, because only profile mode says anything about frame times, and its header says how to run it under a bundle id of its own. On an M3 Pro, with the semantics tree on as it always is in the app, main opened the note in 1.6 to 1.8 s after its first opening and this branch in 2.0 to 2.2 s, and a key in it took about 2 s to draw on both. --- benchmark/markdown_rendering.dart | 365 ++++++++++++++++++++++++++++++ 1 file changed, 365 insertions(+) create mode 100644 benchmark/markdown_rendering.dart diff --git a/benchmark/markdown_rendering.dart b/benchmark/markdown_rendering.dart new file mode 100644 index 0000000..c25f563 --- /dev/null +++ b/benchmark/markdown_rendering.dart @@ -0,0 +1,365 @@ +// How long does a long note with formulas and code take to open, and how fast +// does typing in it stay? +// +// Five thousand lines with markdown on: 30 code blocks in Python, TypeScript +// and SQL, 300 formulas among words and 50 set apart, and prose and sums +// between them. The note is opened three times, then typed into the way a +// keyboard types, one editing-value update a key about thirty times a +// second for a second at a time: in prose, in a code block and right after a +// formula. The semantics tree is on throughout, as it always is in the macOS +// app, which switches it on at launch so that dictation tools can write into +// the editor (see AccessibilityTree.swift). Prints how long each opening took +// to its first frame, and how long the typing frames took to build and to +// draw, and quits. +// +// A plain app rather than an integration test, because only profile mode +// says anything about frame times. It keeps the app's `main` reachable without +// calling it, so that it is compiled together with the app's own code. Run it +// under a bundle id of its own, never the real app's: +// +// FLUTTER_XCODE_PRODUCT_BUNDLE_IDENTIFIER=com.kapybara.kapynotes.renderperf \ +// flutter run --profile -d macos -t benchmark/markdown_rendering.dart +// +// The figures are the line starting MARKDOWN_RENDERING_PERF in the log, also +// written to markdown_rendering_perf.json in the app's temporary directory. +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; + +import 'package:flutter/rendering.dart'; +import 'package:flutter/scheduler.dart'; +import 'package:kapy_notes/calc/engine.dart'; +import 'package:kapy_notes/calc/highlight.dart'; +import 'package:kapy_notes/core/editor_font.dart'; +import 'package:kapy_notes/core/theme.dart'; +import 'package:kapy_notes/data/local_store.dart'; +import 'package:kapy_notes/data/shortcut_prefs.dart'; +import 'package:kapy_notes/main.dart' as app; +import 'package:kapy_notes/ui/editor/note_editor.dart'; +import 'package:material_ui/material_ui.dart'; +import 'package:window_manager/window_manager.dart'; + +class _MemoryStore extends LocalStore { + _MemoryStore() : super(fileName: 'markdown-rendering-benchmark.json'); + + @override + Future load() async {} + + @override + Future flush() async {} + + @override + void put(String key, Object? value) => data[key] = value; +} + +const _python = [ + 'import math', + 'from dataclasses import dataclass', + '', + '@dataclass', + 'class Point:', + ' x: float', + ' y: float', + '', + ' def norm(self) -> float:', + ' # Euclidean length of the vector', + ' return math.sqrt(self.x ** 2 + self.y ** 2)', + '', + 'def mean(values: list[float]) -> float:', + ' """The arithmetic mean, or zero for nothing."""', + ' if not values:', + ' return 0.0', + ' return sum(values) / len(values)', + '', + 'for i in range(10):', + ' print(f"step {i}: {mean([i, i * 2, 3.5])}")', +]; + +const _typescript = [ + "import { readFile } from 'node:fs/promises';", + '', + 'interface Invoice {', + ' id: string;', + ' total: number;', + ' paid?: boolean;', + '}', + '', + 'export async function load(path: string): Promise {', + " const raw = await readFile(path, 'utf8');", + ' // One invoice per line, as JSON.', + ' return raw.split("\\n").filter(Boolean).map((line) => JSON.parse(line));', + '}', + '', + 'const unpaid = (all: Invoice[]) => all.filter((i) => !i.paid);', + 'let sum = 0;', + 'for (const invoice of unpaid([])) {', + ' sum += invoice.total * 1.2;', + '}', + r'console.log(`owed: ${sum.toFixed(2)}`);', +]; + +const _sql = [ + '-- Monthly revenue by customer', + 'SELECT c.name,', + " date_trunc('month', o.created_at) AS month,", + ' SUM(o.total) AS revenue,', + ' COUNT(*) AS orders', + 'FROM customers c', + 'JOIN orders o ON o.customer_id = c.id', + "WHERE o.status = 'paid'", + ' AND o.created_at >= NOW() - INTERVAL 1 YEAR', + 'GROUP BY c.name, month', + 'HAVING SUM(o.total) > 1000', + 'ORDER BY revenue DESC', + 'LIMIT 50;', + '', + 'UPDATE orders SET status = NULL WHERE id IN (1, 2, 3);', + 'CREATE INDEX orders_customer ON orders (customer_id);', + "INSERT INTO audit (event, at) VALUES ('refresh', NOW());", + 'DELETE FROM sessions WHERE expires_at < NOW();', + "SELECT * FROM customers WHERE email LIKE '%@example.com';", + 'DROP TABLE IF EXISTS scratch;', +]; + +/// The note: 5,000 lines in 30 sections, each with five lines of two +/// formulas among words, one or two formulas set apart, a sum and a code +/// block, and prose after them. +String longNote() { + final lines = []; + const languages = ['python', 'typescript', 'sql']; + const bodies = [_python, _typescript, _sql]; + for (var section = 0; section < 30; section++) { + final start = lines.length; + lines + ..add('## Section $section') + ..add(''); + for (var i = 0; i < 5; i++) { + lines.add( + 'Line $i of $section says \$x_{$i}^{2} + \\frac{a}{b}\$ grows ' + 'faster than \$\\sqrt{n}\$ here.', + ); + } + lines.add(''); + final displays = section < 20 ? 2 : 1; + for (var d = 0; d < displays; d++) { + lines + ..add('\$\$') + ..add('\\sum_{k=1}^{$section} k^$d = \\int_0^1 f(t)\\,dt') + ..add('\$\$') + ..add(''); + } + lines + ..add('price = ${section + 3} usd') + ..add('price * 3') + ..add('') + ..add('```${languages[section % 3]}'); + final body = bodies[section % 3]; + lines + ..addAll(body) + ..addAll(body) + ..add('```') + ..add(''); + while (lines.length - start < 166) { + lines.add( + 'Plain prose for section $section, line ${lines.length - start}, ' + 'with a total of 4 + 5 in it.', + ); + } + } + while (lines.length < 5000) { + lines.add('closing line ${lines.length}'); + } + return lines.take(5000).join('\n'); +} + +/// [values] at the [p]th percentile, by nearest rank. +double percentile(List values, double p) { + final sorted = [...values]..sort(); + final rank = (p / 100 * sorted.length).ceil().clamp(1, sorted.length); + return sorted[rank - 1]; +} + +double _ms(Duration duration) => duration.inMicroseconds / 1000; + +Map summary(List timings) { + const budget = 1000 / 60; + final build = [for (final t in timings) _ms(t.buildDuration)]; + final raster = [for (final t in timings) _ms(t.rasterDuration)]; + Map stats(List values) => { + 'p50': percentile(values, 50), + 'p90': percentile(values, 90), + 'max': percentile(values, 100), + }; + return { + 'frames': timings.length, + 'build_ms': stats(build), + 'raster_ms': stats(raster), + 'frames_over_16_7ms': [ + for (var i = 0; i < timings.length; i++) + if (build[i] > budget || raster[i] > budget) i, + ].length, + }; +} + +void main() { + WidgetsFlutterBinding.ensureInitialized(); + unawaited(_runAll()); +} + +Future _runAll() async { + // The app's window waits hidden for the app's main to show it, and a + // hidden window draws no frames. + await windowManager.ensureInitialized(); + await windowManager.setSize(const Size(1280, 900)); + await windowManager.show(); + final report = await _run(); + final line = jsonEncode(report); + File( + '${Directory.systemTemp.path}/markdown_rendering_perf.json', + ).writeAsStringSync(line); + _say('MARKDOWN_RENDERING_PERF $line'); + if (report.isEmpty) await app.main(); + exit(0); +} + +/// Prints [line] to the log, which is where a run that is taking its time +/// shows how far it has got. +void _say(String line) { + // ignore: avoid_print + print(line); +} + +void _show(Widget home) { + runApp(MaterialApp(key: UniqueKey(), theme: KapyTheme.dark(), home: home)); +} + +Widget _editor(String body) { + final engine = CalcEngine(); + return Scaffold( + body: NoteEditor( + noteId: 'benchmark', + initialBody: body, + engine: engine, + highlighter: Highlighter(engine.registry), + gutterWidth: 200, + resultsVisible: true, + markdownEnabled: true, + autofocus: true, + onDocumentChanged: (_, _, _) {}, + onGutterWidthChanged: (_) {}, + onResultsVisibilityChanged: (_) {}, + onGutterWidthReset: () {}, + onSettingsPressed: () {}, + writingFont: WritingFont.handwritten, + shortcuts: ShortcutPrefs(_MemoryStore())..load(), + ), + ); +} + +EditableTextState _field() { + EditableTextState? found; + void visit(Element element) { + if (found != null) return; + if (element is StatefulElement && element.state is EditableTextState) { + found = element.state as EditableTextState; + return; + } + element.visitChildElements(visit); + } + + WidgetsBinding.instance.rootElement!.visitChildElements(visit); + return found!; +} + +double _slowest(Iterable values) => + values.fold(0, (a, b) => a > b ? a : b); + +/// How long [body] takes to open in an empty window: from showing the +/// editor to the end of its first frame, which builds the note, lays it out +/// and paints it; and the slowest build and raster of the frames it takes. +Future> _open(String body) async { + _show(const SizedBox.shrink()); + await WidgetsBinding.instance.endOfFrame; + await Future.delayed(const Duration(seconds: 1)); + final timings = []; + void record(List batch) => timings.addAll(batch); + SchedulerBinding.instance.addTimingsCallback(record); + final stopwatch = Stopwatch()..start(); + _show(_editor(body)); + await WidgetsBinding.instance.endOfFrame; + final firstFrame = stopwatch.elapsedMicroseconds / 1000; + await Future.delayed(const Duration(seconds: 2)); + SchedulerBinding.instance.removeTimingsCallback(record); + return { + 'first_frame_ms': firstFrame, + 'slowest_build_ms': _slowest([ + for (final t in timings) _ms(t.buildDuration), + ]), + 'slowest_raster_ms': _slowest([ + for (final t in timings) _ms(t.rasterDuration), + ]), + }; +} + +Future> _run() async { + final body = longNote(); + final opens = >[]; + for (var i = 1; i <= 3; i++) { + opens.add(await _open(body)); + _say( + 'opened $i of 3: ${opens.last['first_frame_ms']} ms to the first frame', + ); + } + await Future.delayed(const Duration(seconds: 1)); + final field = _field(); + const keys = 30; + + Future> typeAt(int caret) async { + field.userUpdateTextEditingValue( + field.textEditingValue.copyWith( + selection: TextSelection.collapsed(offset: caret), + ), + SelectionChangedCause.tap, + ); + await Future.delayed(const Duration(seconds: 1)); + final timings = []; + void record(List batch) => timings.addAll(batch); + SchedulerBinding.instance.addTimingsCallback(record); + for (var i = 0; i < keys; i++) { + final value = field.textEditingValue; + final at = value.selection.start; + // What the platform's text input sends for a key. + field.updateEditingValue( + TextEditingValue( + text: value.text.replaceRange(at, at, 'a'), + selection: TextSelection.collapsed(offset: at + 1), + ), + ); + await Future.delayed(const Duration(milliseconds: 33)); + } + // Timings arrive in batches, about once a second in profile mode. + await Future.delayed(const Duration(seconds: 2)); + SchedulerBinding.instance.removeTimingsCallback(record); + _say('typed $keys keys at $caret'); + return summary(timings); + } + + int after(String needle, String from) { + final text = field.textEditingValue.text; + return text.indexOf(needle, text.indexOf(from)); + } + + final prose = await typeAt( + after('Plain prose for section 15, line 100', '## Section 15'), + ); + final code = await typeAt(after('return sum(values)', '## Section 15')); + final formula = await typeAt(after(' grows', 'Line 2 of 15')); + return { + 'semantics': SemanticsBinding.instance.semanticsEnabled, + 'characters': body.length, + 'open': opens, + 'typing_in_prose': prose, + 'typing_in_code': code, + 'typing_after_a_formula': formula, + }; +} From b67f7ea3b738f4f249a9c3cbcbe7bfa84be76838 Mon Sep 17 00:00:00 2001 From: Sanjay Kholiya Date: Mon, 16 Nov 2026 13:34:43 +0530 Subject: [PATCH 09/48] Read clipboard HTML into a paste tree --- lib/paste/clipboard_snapshot.dart | 193 ++++ lib/paste/html_reader.dart | 1516 +++++++++++++++++++++++++++++ lib/paste/paste_tree.dart | 180 ++++ pubspec.lock | 2 +- pubspec.yaml | 4 + 5 files changed, 1894 insertions(+), 1 deletion(-) create mode 100644 lib/paste/clipboard_snapshot.dart create mode 100644 lib/paste/html_reader.dart create mode 100644 lib/paste/paste_tree.dart diff --git a/lib/paste/clipboard_snapshot.dart b/lib/paste/clipboard_snapshot.dart new file mode 100644 index 0000000..ad9ce1a --- /dev/null +++ b/lib/paste/clipboard_snapshot.dart @@ -0,0 +1,193 @@ +import 'dart:convert'; + +import 'package:flutter/foundation.dart'; +import 'package:flutter/services.dart'; + +import 'html_reader.dart' show PasteResources; + +/// Everything the clipboard held at one moment. +/// +/// Read in one native call, so its representations agree with each other +/// (a dictation app can't swap the text out between two reads) and iOS asks +/// for permission at most once. +class ClipboardSnapshot { + const ClipboardSnapshot({ + this.types = const [], + this.text, + this.html, + this.sourceUrl, + this.rtfHtml, + this.resources = const {}, + this.vscode, + this.kapy, + this.files = const [], + this.image, + this.imageMime, + }); + + /// The platform's own names for what was there. + final List types; + final String? text; + final String? html; + + /// The page the copy came from, for resolving its relative links. + final String? sourceUrl; + + /// Rich text (RTF, RTFD) converted to HTML by the platform. + final String? rtfHtml; + + /// Picture bytes the clipboard carried beside its markup, by the name or + /// URL the markup refers to them by. + final PasteResources resources; + + /// VS Code's description of a copy, as JSON. + final String? vscode; + + /// Kapy Notes' own fragment, from its private clipboard type. + final String? kapy; + + /// Paths of copied files. + final List files; + final Uint8List? image; + final String? imageMime; + + /// The language VS Code says the copied code is in. + String? get vscodeMode { + final raw = vscode; + if (raw == null) return null; + try { + final decoded = jsonDecode(raw); + if (decoded is Map && decoded['mode'] is String) { + final mode = (decoded['mode'] as String).trim(); + return mode.isEmpty || mode == 'plaintext' ? null : mode; + } + } on FormatException { + return null; + } + return null; + } + + static const _channel = MethodChannel('kapynotes/rich_clipboard'); + + /// Reads the clipboard, or the private pasteboard named [pasteboard] on + /// Apple platforms, which is how tests avoid the user's own clipboard. + static Future read({String? pasteboard}) async { + try { + final raw = await _channel.invokeMethod('read', { + 'pasteboard': ?pasteboard, + }); + return fromChannel(raw); + } on MissingPluginException { + return _readLegacy(); + } on PlatformException catch (error) { + debugPrint('KapyNotes: could not read the clipboard: $error'); + return _readLegacy(); + } + } + + /// What an older native side offers: the text and the HTML, read apart. + static Future _readLegacy() async { + String? html; + try { + html = await _channel.invokeMethod('readHtml'); + } on Object { + html = null; + } + final text = (await Clipboard.getData(Clipboard.kTextPlain))?.text; + return fromChannel({'text': text, 'html': html}); + } + + @visibleForTesting + static ClipboardSnapshot fromChannel(Object? raw) { + if (raw is! Map) return const ClipboardSnapshot(); + String? string(String key) { + final value = raw[key]; + return value is String && value.isNotEmpty ? value : null; + } + + var html = string('html'); + var sourceUrl = string('sourceUrl'); + if (html != null && html.startsWith('Version:')) { + final parsed = _parseWindowsHtml(html); + html = parsed.html; + sourceUrl ??= parsed.sourceUrl; + } + final resources = {}; + final rawResources = raw['resources']; + if (rawResources is List) { + for (final entry in rawResources) { + if (entry is! Map) continue; + final name = entry['name']; + final data = entry['data']; + final mime = entry['mime']; + if (name is String && data is Uint8List && data.isNotEmpty) { + resources[name] = ( + bytes: data, + mime: mime is String && mime.isNotEmpty + ? mime.toLowerCase() + : 'application/octet-stream', + ); + } + } + } + final types = raw['types']; + final files = raw['files']; + final image = raw['image']; + return ClipboardSnapshot( + types: types is List ? [...types.whereType()] : const [], + text: string('text')?.replaceAll('\r\n', '\n'), + html: html, + sourceUrl: sourceUrl, + rtfHtml: string('rtfHtml'), + resources: resources, + vscode: string('vscode'), + kapy: string('kapy'), + files: files is List ? [...files.whereType()] : const [], + image: image is Uint8List && image.isNotEmpty ? image : null, + imageMime: string('imageMime'), + ); + } + + /// Windows' "HTML Format": a header of byte offsets and the page's + /// address, then the markup. + static ({String html, String? sourceUrl}) _parseWindowsHtml(String raw) { + String? sourceUrl; + int? startHtml; + int? endHtml; + final markup = raw.indexOf('<'); + for (final line in const LineSplitter().convert( + markup < 0 ? raw : raw.substring(0, markup), + )) { + final colon = line.indexOf(':'); + if (colon <= 0) continue; + final name = line.substring(0, colon); + final value = line.substring(colon + 1).trim(); + switch (name) { + case 'StartHTML': + startHtml = int.tryParse(value); + case 'EndHTML': + endHtml = int.tryParse(value); + case 'SourceURL': + if (value.isNotEmpty) sourceUrl = value; + } + } + final bytes = utf8.encode(raw); + if (startHtml != null && + endHtml != null && + startHtml >= 0 && + startHtml < endHtml && + endHtml <= bytes.length) { + return ( + html: utf8.decode( + bytes.sublist(startHtml, endHtml), + allowMalformed: true, + ), + sourceUrl: sourceUrl, + ); + } + return ( + html: markup < 0 ? '' : raw.substring(markup), + sourceUrl: sourceUrl, + ); + } +} diff --git a/lib/paste/html_reader.dart b/lib/paste/html_reader.dart new file mode 100644 index 0000000..c4021f8 --- /dev/null +++ b/lib/paste/html_reader.dart @@ -0,0 +1,1516 @@ +import 'dart:convert'; +import 'dart:typed_data'; + +import 'package:html/dom.dart' as dom; +import 'package:html/parser.dart' as html_parser; + +import 'paste_tree.dart'; + +/// Image bytes a clipboard carried alongside its markup, by the URL or file +/// name the markup refers to them by: Safari's web archive, an RTFD's +/// attachments. +typedef PasteResources = Map; + +/// Reads clipboard HTML into [PasteBlock]s. +/// +/// HTML on a clipboard is whatever the source app thought would survive a +/// trip into another app: a browser's serialization of the selection with +/// computed styles inlined, Google Docs' spans with weights in their style +/// attributes, Word's paragraphs pretending to be lists, KaTeX's three copies +/// of every formula. This keeps what was meant — structure, emphasis, links, +/// math, code, pictures — and throws away how it was drawn. +class HtmlPasteReader { + HtmlPasteReader({this.baseUrl, this.resources = const {}}); + + /// The page the selection came from, for its relative links and pictures. + final Uri? baseUrl; + final PasteResources resources; + + final _CssSheet _css = _CssSheet(); + + List read(String html) { + final document = html_parser.parse(_withoutDownlevelConditionals(html)); + for (final style in document.querySelectorAll('style')) { + _css.add(style.text); + } + final root = document.body ?? document.documentElement; + if (root == null) return const []; + _rewriteWordLists(root); + final out = _Builder(); + _walkChildren(root, const _Context(), out); + out.flush(); + return _mergeAdjacentCode(out.blocks); + } + + // --------------------------------------------------------------------- + // Walking + + void _walkChildren(dom.Node parent, _Context context, _Builder out) { + for (final node in parent.nodes) { + _walk(node, context, out); + } + } + + void _walk(dom.Node node, _Context context, _Builder out) { + if (node is dom.Text) { + out.line.addText(node.data, context); + return; + } + if (node is! dom.Element) return; + final element = node; + final tag = element.localName ?? ''; + if (_dropped.contains(tag) || _droppedClass(element)) return; + final declarations = _css.declarationsFor(element); + if (_isHidden(element, declarations) && !_isMath(element)) return; + + if (_isMath(element)) { + final math = _readMath(element); + if (math != null) { + if (math.display) { + out.flush(); + out.blocks.add(PasteMathBlock(math.tex)); + } else { + out.line.add(PasteMath(math.tex)); + } + return; + } + } + + final inner = _styled(element, declarations, context); + + final wordTitle = tag == 'p' ? _wordTitleLevel(element) : null; + if (wordTitle != null) { + out.flush(); + final inlines = _inlinesOf(element, inner); + if (_hasWords(inlines)) out.blocks.add(PasteHeading(wordTitle, inlines)); + return; + } + + switch (tag) { + case 'h1' || 'h2' || 'h3' || 'h4' || 'h5' || 'h6': + out.flush(); + final inlines = _inlinesOf(element, inner); + if (_hasWords(inlines)) { + out.blocks.add(PasteHeading(int.parse(tag.substring(1)), inlines)); + } + return; + case 'ul' || 'ol' || 'menu' || 'dir': + out.flush(); + final list = _readList(element, inner); + if (list.items.isNotEmpty) out.blocks.add(list); + return; + case 'li': + // An item with no list around it: what a selection that starts + // inside a list serialises as. + out.flush(); + out.blocks.add( + PasteList(ordered: false, items: [_readItem(element, inner)]), + ); + return; + case 'blockquote': + out.flush(); + final blocks = _blocksOf(element, inner); + if (blocks.isNotEmpty) out.blocks.add(PasteQuote(blocks)); + return; + case 'pre': + out.flush(); + final code = _readPre(element); + if (code != null) out.blocks.add(code); + return; + case 'code' || 'kbd' || 'samp' || 'tt': + final text = _codeText(element); + if (text.contains('\n') && text.trim().isNotEmpty) { + out.flush(); + out.blocks.add( + PasteCode(_trimCode(text), language: _languageOf(element)), + ); + } else if (text.isNotEmpty) { + out.line.add(PasteCodeSpan(text, href: inner.href)); + } + return; + case 'table': + out.flush(); + _readTable(element, inner, out); + return; + case 'hr': + out.flush(); + out.blocks.add(const PasteRule()); + return; + case 'br': + out.line.addBreak(inner); + return; + case 'img': + _readImage(element, inner, out); + return; + case 'input': + final type = element.attributes['type']?.toLowerCase(); + if (type == 'checkbox') { + final checked = element.attributes.containsKey('checked'); + out.line.addText(checked ? '☑ ' : '☐ ', inner); + } + return; + case 'rt': + out.line.addText('(', inner); + _walkChildren(element, inner, out); + out.line.addText(')', inner); + return; + case 'dt' || 'summary': + out.flush(); + _walkChildren(element, inner.withStyle(PasteStyle.bold), out); + out.flush(); + return; + } + + if (_isBlock(tag, declarations)) { + out.flush(); + _walkChildren(element, inner, out); + out.flush(); + return; + } + _walkChildren(element, inner, out); + } + + List _blocksOf(dom.Element element, _Context context) { + final out = _Builder(); + _walkChildren(element, context, out); + out.flush(); + return out.blocks; + } + + /// A heading's or a cell's words: its blocks flattened into one run, each + /// block after the first on a line of its own. + List _inlinesOf(dom.Element element, _Context context) { + final out = _Builder(); + _walkChildren(element, context, out); + out.flush(); + return _flatten(out.blocks); + } + + List _flatten(List blocks, {String bullet = ''}) { + final result = []; + void lineBreak() { + if (result.isNotEmpty && result.last is! PasteBreak) { + result.add(const PasteBreak()); + } + } + + for (final block in blocks) { + switch (block) { + case PasteParagraph(:final inlines) || PasteHeading(:final inlines): + lineBreak(); + if (bullet.isNotEmpty) result.add(PasteText(bullet)); + result.addAll(inlines); + case PasteList(:final items, :final ordered, :final start): + for (var i = 0; i < items.length; i++) { + final item = items[i]; + final marker = item.checked != null + ? (item.checked! ? '☑ ' : '☐ ') + : ordered + ? '${start + i}. ' + : '• '; + lineBreak(); + result.addAll(_flatten(item.blocks, bullet: marker)); + } + case PasteQuote(:final blocks): + lineBreak(); + result.addAll(_flatten(blocks)); + case PasteCode(:final text): + lineBreak(); + result.add(PasteCodeSpan(text.replaceAll('\n', ' '))); + case PasteMathBlock(:final tex): + lineBreak(); + result.add(PasteMath(tex)); + case PasteTable(:final rows): + for (final row in rows) { + lineBreak(); + for (var c = 0; c < row.length; c++) { + if (c > 0) result.add(const PasteText(' · ')); + result.addAll(row[c]); + } + } + case PasteRule(): + lineBreak(); + } + } + while (result.isNotEmpty && result.last is PasteBreak) { + result.removeLast(); + } + return result; + } + + // --------------------------------------------------------------------- + // Styles + + _Context _styled( + dom.Element element, + Map declarations, + _Context context, + ) { + final styles = {...context.styles}; + switch (element.localName) { + case 'b' || 'strong': + styles.add(PasteStyle.bold); + case 'i' || 'em' || 'cite' || 'var' || 'dfn': + styles.add(PasteStyle.italic); + case 'u' || 'ins': + styles.add(PasteStyle.underline); + case 's' || 'strike' || 'del': + styles.add(PasteStyle.strike); + case 'sup': + styles.add(PasteStyle.superscript); + case 'sub': + styles.add(PasteStyle.subscript); + case 'th': + styles.add(PasteStyle.bold); + } + final weight = declarations['font-weight']; + if (weight != null) { + final numeric = int.tryParse(weight); + if (weight == 'bold' || + weight == 'bolder' || + (numeric != null && numeric >= 600)) { + styles.add(PasteStyle.bold); + } else if (weight == 'normal' || + weight == 'lighter' || + (numeric != null && numeric < 600)) { + styles.remove(PasteStyle.bold); + } + } + final fontStyle = declarations['font-style']; + if (fontStyle == 'italic' || fontStyle == 'oblique') { + styles.add(PasteStyle.italic); + } else if (fontStyle == 'normal') { + styles.remove(PasteStyle.italic); + } + final decoration = + '${declarations['text-decoration'] ?? ''} ' + '${declarations['text-decoration-line'] ?? ''}'; + if (decoration.contains('underline')) styles.add(PasteStyle.underline); + if (decoration.contains('line-through')) styles.add(PasteStyle.strike); + final vertical = declarations['vertical-align']; + if (vertical == 'super') styles.add(PasteStyle.superscript); + if (vertical == 'sub') styles.add(PasteStyle.subscript); + + var href = context.href; + if (element.localName == 'a') { + href = _resolveLink(element.attributes['href']); + } + // A link says it is one by being a link; the underline a page draws under + // it is not emphasis the writer chose. + if (href != null) styles.remove(PasteStyle.underline); + + final whiteSpace = declarations['white-space']; + var pre = context.pre; + if (whiteSpace != null) { + pre = + whiteSpace.startsWith('pre') && whiteSpace != 'pre-line' || + whiteSpace == 'break-spaces'; + } + return _Context(styles: styles, href: href, pre: pre); + } + + bool _isHidden(dom.Element element, Map declarations) { + if (element.attributes.containsKey('hidden')) return true; + if (element.attributes['aria-hidden'] == 'true') return true; + if (declarations['display'] == 'none') return true; + if (declarations['visibility'] == 'hidden') return true; + for (final name in element.classes) { + if (_screenReaderOnly.contains(name)) return true; + } + return false; + } + + static bool _isBlock(String tag, Map declarations) { + final display = declarations['display']; + if (display != null) { + if (display.startsWith('inline')) return false; + if (display == 'block' || + display == 'flex' || + display == 'grid' || + display == 'list-item' || + display.startsWith('table') || + display == 'flow-root') { + return true; + } + } + return _blockTags.contains(tag); + } + + // --------------------------------------------------------------------- + // Lists + + PasteList _readList(dom.Element list, _Context context) { + final ordered = list.localName == 'ol'; + final start = int.tryParse(list.attributes['start'] ?? '') ?? 1; + final items = []; + final levels = []; + for (final child in list.nodes) { + if (child is dom.Text) { + if (child.data.trim().isEmpty) continue; + items.add( + PasteListItem([ + PasteParagraph([PasteText(child.data.trim())]), + ]), + ); + levels.add(null); + continue; + } + if (child is! dom.Element) continue; + final declarations = _css.declarationsFor(child); + if (_isHidden(child, declarations)) continue; + final tag = child.localName; + if (tag == 'ul' || tag == 'ol') { + // A list straight inside a list — Google Docs and hand-written HTML + // both do it — belongs to the item before it. + final nested = _readList(child, _styled(child, declarations, context)); + if (nested.items.isEmpty) continue; + if (items.isEmpty) { + items.add(PasteListItem([nested])); + levels.add(null); + } else { + final last = items.removeLast(); + items.add( + PasteListItem([...last.blocks, nested], checked: last.checked), + ); + } + continue; + } + items.add(_readItem(child, _styled(child, declarations, context))); + levels.add(int.tryParse(child.attributes['aria-level'] ?? '')); + } + final nestedByLevel = _nestByLevel(items, levels, ordered); + return PasteList( + ordered: ordered, + start: start, + items: nestedByLevel ?? items, + ); + } + + /// Google Docs writes one flat list and says each item's depth in + /// `aria-level`. Rebuilds the nesting it means, or returns null when the + /// levels say nothing. + List? _nestByLevel( + List items, + List levels, + bool ordered, + ) { + final known = levels.whereType().toSet(); + if (known.length < 2 || levels.contains(null)) return null; + final base = known.reduce((a, b) => a < b ? a : b); + List build(int from, int to, int level) { + final result = []; + var i = from; + while (i < to) { + final item = items[i]; + var j = i + 1; + while (j < to && levels[j]! > level) { + j++; + } + if (j > i + 1) { + final children = build(i + 1, j, levels[i + 1]!); + result.add( + PasteListItem([ + ...item.blocks, + PasteList(ordered: ordered, items: children), + ], checked: item.checked), + ); + } else { + result.add(item); + } + i = j; + } + return result; + } + + return build(0, items.length, base); + } + + PasteListItem _readItem(dom.Element item, _Context context) { + bool? checked; + final role = item.attributes['role']; + if (role == 'checkbox') { + checked = item.attributes['aria-checked'] == 'true'; + } + final box = item.querySelector( + 'input[type=checkbox], input[type="checkbox"]', + ); + if (box != null && _belongsToItem(box, item)) { + checked = box.attributes.containsKey('checked'); + box.remove(); + } + final notionBox = item.querySelector('.checkbox'); + if (checked == null && notionBox != null) { + checked = notionBox.classes.contains('checkbox-on'); + notionBox.remove(); + } + var blocks = _blocksOf(item, context); + if (checked == null && blocks.isNotEmpty) { + final (marker, rest) = _leadingTaskMarker(blocks.first); + if (marker != null) { + checked = marker; + blocks = [?rest, ...blocks.skip(1)]; + } + } + return PasteListItem(blocks, checked: checked); + } + + /// Whether a checkbox is this item's own rather than one in a list nested + /// inside it. + static bool _belongsToItem(dom.Element box, dom.Element item) { + for (var parent = box.parent; parent != null; parent = parent.parent) { + if (identical(parent, item)) return true; + if (parent.localName == 'li') return false; + } + return false; + } + + /// An item whose words open with a box drawn as a character — `☐`, `☑`, + /// `[ ]`, `[x]` — which is how many apps export a checklist. + static (bool?, PasteBlock?) _leadingTaskMarker(PasteBlock block) { + if (block is! PasteParagraph || block.inlines.isEmpty) return (null, block); + final first = block.inlines.first; + if (first is! PasteText) return (null, block); + final match = RegExp( + r'^\s*(☐|☑|☒|✅|\[ \]|\[[xX]\])\s+', + ).firstMatch(first.text); + if (match == null) return (null, block); + final marker = match.group(1)!; + final checked = marker != '☐' && marker != '[ ]'; + final remaining = first.text.substring(match.end); + return ( + checked, + PasteParagraph([ + if (remaining.isNotEmpty) + PasteText(remaining, styles: first.styles, href: first.href), + ...block.inlines.skip(1), + ]), + ); + } + + // --------------------------------------------------------------------- + // Code + + PasteCode? _readPre(dom.Element pre) { + final codes = pre.querySelectorAll('code'); + final code = codes.length == 1 ? codes.single : null; + final text = _codeText(code ?? pre); + if (text.trim().isEmpty) return null; + return PasteCode( + _trimCode(text), + language: + (code == null ? null : _languageOf(code)) ?? + _languageOf(pre) ?? + _languageOfAncestors(pre) ?? + _toolbarLanguage(pre, code), + ); + } + + /// The text of a code element as it reads: line breaks kept, toolbars and + /// line numbers left out. + String _codeText(dom.Element element) { + final buffer = StringBuffer(); + void visit(dom.Node node) { + if (node is dom.Text) { + buffer.write(node.data); + return; + } + if (node is! dom.Element) return; + final tag = node.localName; + if (tag == 'br') { + buffer.write('\n'); + return; + } + if (_dropped.contains(tag) || _droppedClass(node)) return; + if (_isHidden(node, _css.declarationsFor(node))) return; + if (_lineNumberClass(node)) return; + final block = + _isBlock(tag ?? '', _css.declarationsFor(node)) && tag != 'code'; + if (block && buffer.isNotEmpty && !_endsWithNewline(buffer)) { + buffer.write('\n'); + } + for (final child in node.nodes) { + visit(child); + } + if (block && !_endsWithNewline(buffer)) buffer.write('\n'); + } + + for (final child in element.nodes) { + visit(child); + } + return buffer.toString().replaceAll('\r\n', '\n').replaceAll('\u00a0', ' '); + } + + static bool _endsWithNewline(StringBuffer buffer) => + buffer.isNotEmpty && buffer.toString().endsWith('\n'); + + static String _trimCode(String text) { + var result = text; + while (result.startsWith('\n')) { + result = result.substring(1); + } + return result.trimRight(); + } + + static final _languageClass = RegExp( + r'(?:^|\s)(?:language|lang|highlight-source|brush:?)-?([A-Za-z0-9_+#.-]+)', + ); + + String? _languageOf(dom.Element element) { + final declared = + element.attributes['data-language'] ?? + element.attributes['data-lang'] ?? + element.attributes['lang']; + if (declared != null && _plausibleLanguage(declared)) { + return declared.toLowerCase(); + } + final match = _languageClass.firstMatch(element.className); + final language = match?.group(1); + if (language == null) return null; + return _normalizedLanguage(language); + } + + String? _languageOfAncestors(dom.Element element) { + var parent = element.parent; + for (var depth = 0; parent != null && depth < 3; depth++) { + final language = _languageOf(parent); + if (language != null) return language; + parent = parent.parent; + } + return null; + } + + /// The label above a code block in ChatGPT, Claude and Gemini: a short + /// word on its own in the block's header, outside the code itself. + String? _toolbarLanguage(dom.Element pre, dom.Element? code) { + final container = code == null ? pre : _blockContainerOf(pre); + for (final candidate in container.querySelectorAll('div, span')) { + if (code != null && _contains(candidate, code)) continue; + if (code != null && _contains(code, candidate)) continue; + if (candidate.children.isNotEmpty) continue; + final text = candidate.text.trim(); + if (_plausibleLanguage(text)) return _normalizedLanguage(text); + } + return null; + } + + static dom.Element _blockContainerOf(dom.Element pre) { + final parent = pre.parent; + if (parent != null && parent.localName != 'body') { + final label = parent.querySelectorAll('pre'); + if (label.length == 1) return parent; + } + return pre; + } + + static bool _contains(dom.Element outer, dom.Element inner) { + for (dom.Node? node = inner; node != null; node = node.parent) { + if (identical(node, outer)) return true; + } + return false; + } + + static bool _plausibleLanguage(String text) => + text.isNotEmpty && + text.length <= 24 && + RegExp(r'^[A-Za-z][A-Za-z0-9_+#.\- ]*$').hasMatch(text) && + !_notLanguages.contains(text.toLowerCase()); + + static String _normalizedLanguage(String raw) { + final lower = raw.trim().toLowerCase(); + return switch (lower) { + 'c++' => 'cpp', + 'c#' => 'csharp', + 'f#' => 'fsharp', + 'objective-c' => 'objectivec', + 'shell' || 'bash' || 'sh' || 'zsh' || 'console' => lower, + _ => lower.replaceAll(' ', '-'), + }; + } + + static bool _lineNumberClass(dom.Element element) { + for (final name in element.classes) { + if (name == 'linenumber' || + name == 'line-number' || + name == 'lineno' || + name == 'gutter' || + name == 'react-syntax-highlighter-line-number') { + return true; + } + } + return false; + } + + /// Code a source splits into one `pre` per line — Notion, some + /// highlighters — read back as one block. + static List _mergeAdjacentCode(List blocks) { + final merged = []; + for (final block in blocks) { + final last = merged.isEmpty ? null : merged.last; + if (block is PasteCode && + last is PasteCode && + last.language == block.language && + !last.text.contains('\n') && + !block.text.contains('\n') && + last.language == null) { + merged.removeLast(); + merged.add(PasteCode('${last.text}\n${block.text}')); + continue; + } + merged.add(block); + } + return merged; + } + + // --------------------------------------------------------------------- + // Tables + + void _readTable(dom.Element table, _Context context, _Builder out) { + final rows = _ownRows(table); + if (_isLayoutTable(table, rows)) { + for (final row in rows) { + for (final cell in row.children) { + if (cell.localName != 'td' && cell.localName != 'th') continue; + out.flush(); + _walkChildren(cell, context, out); + out.flush(); + } + } + return; + } + + final grid = >>[]; + final aligns = []; + final pending = value})>{}; + for (var r = 0; r < rows.length; r++) { + final cells = >[]; + var column = 0; + void fillSpans() { + while (pending.containsKey(column)) { + final span = pending[column]!; + cells.add(const []); + if (span.rows <= 1) { + pending.remove(column); + } else { + pending[column] = (rows: span.rows - 1, value: span.value); + } + column++; + } + } + + for (final cell in rows[r].children) { + if (cell.localName != 'td' && cell.localName != 'th') continue; + final declarations = _css.declarationsFor(cell); + if (_isHidden(cell, declarations)) continue; + fillSpans(); + final inlines = _inlinesOf(cell, _styled(cell, declarations, context)); + final colspan = (int.tryParse(cell.attributes['colspan'] ?? '') ?? 1) + .clamp(1, 64); + final rowspan = (int.tryParse(cell.attributes['rowspan'] ?? '') ?? 1) + .clamp(1, 512); + while (aligns.length <= column + colspan - 1) { + aligns.add(PasteAlign.none); + } + if (r == 0 || aligns[column] == PasteAlign.none) { + final align = _alignOf(cell, declarations); + if (align != PasteAlign.none) aligns[column] = align; + } + for (var c = 0; c < colspan; c++) { + cells.add(c == 0 ? inlines : const []); + if (rowspan > 1) { + pending[column] = (rows: rowspan - 1, value: inlines); + } + column++; + } + } + fillSpans(); + grid.add(cells); + } + while (grid.isNotEmpty && grid.last.every((cell) => !_hasWords(cell))) { + grid.removeLast(); + } + if (grid.isEmpty) return; + final width = grid.fold( + 0, + (most, row) => row.length > most ? row.length : most, + ); + if (width == 0) return; + for (final row in grid) { + while (row.length < width) { + row.add(const []); + } + } + while (aligns.length < width) { + aligns.add(PasteAlign.none); + } + final caption = table.querySelector('caption'); + if (caption != null) { + final words = _inlinesOf(caption, context.withStyle(PasteStyle.bold)); + if (_hasWords(words)) out.blocks.add(PasteParagraph(words)); + } + out.blocks.add(PasteTable(grid, aligns.sublist(0, width))); + } + + /// Rows that belong to this table, not to one nested in it. + static List _ownRows(dom.Element table) { + final rows = []; + void collect(dom.Element parent) { + for (final child in parent.children) { + switch (child.localName) { + case 'tr': + rows.add(child); + case 'thead' || 'tbody' || 'tfoot': + collect(child); + } + } + } + + collect(table); + return rows; + } + + /// A table used to lay a page out — an email's columns, a site's sidebar — + /// rather than to hold data. Its cells are read as the blocks they hold. + bool _isLayoutTable(dom.Element table, List rows) { + final role = table.attributes['role']; + if (role == 'presentation' || role == 'none') return true; + if (rows.isEmpty) return true; + if (table.querySelector('table') != null) return true; + var widest = 0; + for (final row in rows) { + final count = row.children + .where((cell) => cell.localName == 'td' || cell.localName == 'th') + .length; + if (count > widest) widest = count; + } + if (widest <= 1) return true; + // A cell holding headings or several paragraphs of prose is a column of + // a page, not a value. + for (final cell in table.querySelectorAll('td')) { + if (cell.querySelector('h1, h2, h3, h4, blockquote, pre') != null) { + return true; + } + } + return false; + } + + static PasteAlign _alignOf( + dom.Element cell, + Map declarations, + ) { + final value = (declarations['text-align'] ?? cell.attributes['align'] ?? '') + .toLowerCase(); + return switch (value) { + 'center' => PasteAlign.center, + 'right' || 'end' => PasteAlign.right, + 'left' || 'start' => PasteAlign.left, + _ => PasteAlign.none, + }; + } + + // --------------------------------------------------------------------- + // Images + + void _readImage(dom.Element image, _Context context, _Builder out) { + final alt = (image.attributes['alt'] ?? '').trim(); + if (_isEmojiImage(image, alt)) { + out.line.addText(alt, context); + return; + } + final declarations = _css.declarationsFor(image); + final width = + _pixels(image.attributes['width']) ?? _pixels(declarations['width']); + final height = + _pixels(image.attributes['height']) ?? _pixels(declarations['height']); + // Tracking pixels, spacers, favicons and the little icons beside a + // citation: furniture, not content. + if ((width != null && width <= 24) || (height != null && height <= 24)) { + return; + } + final source = _imageSource(image); + if (source == null) { + if (alt.isNotEmpty) out.line.addText(alt, context); + return; + } + if (source.contains('favicon')) return; + PasteImage picture; + if (source.startsWith('data:')) { + final decoded = _decodeDataUri(source); + if (decoded == null) { + if (alt.isNotEmpty) out.line.addText(alt, context); + return; + } + picture = PasteImage( + bytes: decoded.bytes, + mime: decoded.mime, + alt: alt, + width: width, + height: height, + ); + } else { + final resolved = _resolve(source); + final carried = + resources[source] ?? (resolved == null ? null : resources[resolved]); + if (carried != null) { + picture = PasteImage( + src: resolved, + bytes: carried.bytes, + mime: carried.mime, + alt: alt, + width: width, + height: height, + ); + } else if (resolved != null) { + picture = PasteImage( + src: resolved, + alt: alt, + width: width, + height: height, + ); + } else { + if (alt.isNotEmpty) out.line.addText(alt, context); + return; + } + } + out.line.add(PasteImageInline(picture, href: context.href)); + } + + String? _imageSource(dom.Element image) { + final attributes = image.attributes; + final src = attributes['src']; + // A lazy-loaded picture keeps a 1x1 stand-in in src and the real one in + // a data attribute until it scrolls into view. + final lazy = + attributes['data-src'] ?? + attributes['data-original'] ?? + attributes['data-lazy-src']; + if (lazy != null && + (src == null || src.startsWith('data:image/gif') || src.isEmpty)) { + return lazy; + } + if (src != null && src.isNotEmpty) return src; + final srcset = attributes['srcset']; + if (srcset != null && srcset.isNotEmpty) { + return srcset.split(',').last.trim().split(RegExp(r'\s+')).first; + } + return null; + } + + static bool _isEmojiImage(dom.Element image, String alt) { + final classes = image.className.toLowerCase(); + if (classes.contains('emoji') || + image.attributes.containsKey('data-stringify-emoji')) { + return alt.isNotEmpty; + } + // A picture whose alt text is a single emoji, or a :shortcode:, is an + // emoji drawn as a picture. + if (RegExp(r'^:[a-z0-9_+\-]+:$').hasMatch(alt)) return true; + return alt.isNotEmpty && + alt.runes.length <= 2 && + alt.runes.every((rune) => rune >= 0x2190); + } + + static ({Uint8List bytes, String mime})? _decodeDataUri(String uri) { + final comma = uri.indexOf(','); + if (comma < 0) return null; + final header = uri.substring(5, comma); + final mime = header.split(';').first.toLowerCase(); + if (!mime.startsWith('image/')) return null; + try { + final payload = uri.substring(comma + 1); + final bytes = header.contains(';base64') + ? base64.decode(payload.replaceAll(RegExp(r'\s'), '')) + : Uint8List.fromList(utf8.encode(Uri.decodeComponent(payload))); + if (bytes.isEmpty) return null; + return (bytes: bytes, mime: mime); + } on FormatException { + return null; + } + } + + static double? _pixels(String? value) { + if (value == null) return null; + final match = RegExp(r'^\s*([0-9.]+)\s*(px)?\s*$').firstMatch(value); + return match == null ? null : double.tryParse(match.group(1)!); + } + + // --------------------------------------------------------------------- + // Links + + String? _resolveLink(String? raw) { + if (raw == null) return null; + final href = raw.trim(); + if (href.isEmpty || href.startsWith('#')) return null; + final lower = href.toLowerCase(); + if (lower.startsWith('javascript:') || + lower.startsWith('data:') || + lower.startsWith('vbscript:')) { + return null; + } + final resolved = _resolve(href); + if (resolved == null) return null; + final uri = Uri.tryParse(resolved); + // Google wraps every link in a document in a redirect through itself. + if (uri != null && + (uri.host == 'www.google.com' || uri.host == 'google.com') && + uri.path == '/url') { + final target = uri.queryParameters['q'] ?? uri.queryParameters['url']; + if (target != null && target.startsWith('http')) return target; + } + return resolved; + } + + /// An absolute address for [raw], or null when it is relative and there is + /// nothing to resolve it against. + String? _resolve(String raw) { + final uri = Uri.tryParse(raw.trim()); + if (uri == null) return null; + if (uri.hasScheme) { + const allowed = {'http', 'https', 'mailto', 'tel', 'file', 'ftp'}; + return allowed.contains(uri.scheme.toLowerCase()) ? uri.toString() : null; + } + final base = baseUrl; + if (base == null) return null; + return base.resolveUri(uri).toString(); + } + + // --------------------------------------------------------------------- + // Math + + static bool _isMath(dom.Element element) { + final tag = element.localName; + if (tag == 'math' || tag == 'mjx-container') return true; + if (tag == 'script') { + final type = element.attributes['type'] ?? ''; + return type.startsWith('math/tex'); + } + final classes = element.classes; + return classes.contains('katex') || + classes.contains('katex-display') || + classes.contains('mwe-math-element') || + classes.contains('MathJax_Display') || + classes.contains('math-display') && + element.attributes.containsKey('data-latex') || + classes.contains('math-inline') && + element.attributes.containsKey('data-latex'); + } + + ({String tex, bool display})? _readMath(dom.Element element) { + final tag = element.localName; + final classes = element.classes; + if (tag == 'script') { + final tex = element.text.trim(); + if (tex.isEmpty) return null; + return ( + tex: tex, + display: (element.attributes['type'] ?? '').contains('display'), + ); + } + final latex = element.attributes['data-latex']; + if (latex != null && latex.trim().isNotEmpty) { + return (tex: latex.trim(), display: classes.contains('math-display')); + } + final annotation = element.querySelector( + 'annotation[encoding="application/x-tex"], annotation[encoding="TeX"]', + ); + final display = + classes.contains('katex-display') || + element.querySelector('.katex-display') != null || + element.attributes['display'] == 'true' || + element.attributes['display'] == 'block' || + element.querySelector('math[display="block"]') != null || + element.querySelector('.mwe-math-fallback-image-display') != null || + classes.contains('MathJax_Display'); + if (annotation != null && annotation.text.trim().isNotEmpty) { + return (tex: _cleanTex(annotation.text), display: display); + } + final math = tag == 'math' ? element : element.querySelector('math'); + final alttext = math?.attributes['alttext']; + if (alttext != null && alttext.trim().isNotEmpty) { + return (tex: _cleanTex(alttext), display: display); + } + final fallback = element.querySelector('img[alt]'); + final alt = fallback?.attributes['alt']; + if (alt != null && alt.trim().isNotEmpty) { + return (tex: _cleanTex(alt), display: display); + } + // MathML with no TeX anywhere: its text is the nearest honest thing. + final text = (math ?? element).text.replaceAll(RegExp(r'\s+'), ' ').trim(); + if (text.isEmpty) return null; + return (tex: text, display: display); + } + + static String _cleanTex(String raw) { + var tex = raw.trim(); + final wrapper = RegExp( + r'^\{\\(?:displaystyle|textstyle)\s*(.*)\}$', + dotAll: true, + ).firstMatch(tex); + if (wrapper != null) tex = wrapper.group(1)!.trim(); + return tex; + } + + // --------------------------------------------------------------------- + // Word + + /// Word writes a list as paragraphs, each saying in its style which list + /// and level it is on and carrying its bullet as text. Turns runs of them + /// into real lists before the walk, so the rest of the reader never has to + /// know. + void _rewriteWordLists(dom.Element root) { + final paragraphs = root + .querySelectorAll('p, h1, h2, h3, h4, h5, h6, div') + .where((p) => _msoListLevel(p) != null) + .toList(); + if (paragraphs.isEmpty) return; + var index = 0; + while (index < paragraphs.length) { + final first = paragraphs[index]; + final run = [first]; + var next = index + 1; + while (next < paragraphs.length && + identical(_nextElementSibling(run.last), paragraphs[next])) { + run.add(paragraphs[next]); + next++; + } + _replaceWithList(run); + index = next; + } + } + + static dom.Element? _nextElementSibling(dom.Element element) { + final parent = element.parent; + if (parent == null) return null; + final siblings = parent.children; + final at = siblings.indexOf(element); + return at >= 0 && at + 1 < siblings.length ? siblings[at + 1] : null; + } + + static int? _msoListLevel(dom.Element element) { + final style = element.attributes['style'] ?? ''; + final match = RegExp(r'mso-list:\s*l\d+\s+level(\d+)').firstMatch(style); + if (match == null) return null; + return int.tryParse(match.group(1)!); + } + + void _replaceWithList(List paragraphs) { + final parent = paragraphs.first.parent; + if (parent == null) return; + // (list element, level) from the outermost in. + final stack = <(dom.Element, int)>[]; + dom.Element? outermost; + for (final paragraph in paragraphs) { + final level = _msoListLevel(paragraph) ?? 1; + final marker = _takeWordMarker(paragraph); + final ordered = + marker != null && RegExp(r'^[0-9A-Za-z]{1,4}[.)]$').hasMatch(marker); + while (stack.isNotEmpty && stack.last.$2 > level) { + stack.removeLast(); + } + if (stack.isEmpty || stack.last.$2 < level) { + final list = dom.Element.tag(ordered ? 'ol' : 'ul'); + if (ordered) { + final number = int.tryParse(marker.substring(0, marker.length - 1)); + if (number != null && number != 1) { + list.attributes['start'] = '$number'; + } + } + if (stack.isEmpty) { + outermost = list; + } else { + final parentList = stack.last.$1; + final lastItem = parentList.children.isEmpty + ? null + : parentList.children.last; + (lastItem ?? parentList).append(list); + } + stack.add((list, level)); + } + final item = dom.Element.tag('li'); + for (final node in [...paragraph.nodes]) { + item.append(node); + } + stack.last.$1.append(item); + } + parent.insertBefore(outermost!, paragraphs.first); + for (final paragraph in paragraphs) { + paragraph.remove(); + } + } + + /// Removes the bullet or number Word wrote as text in front of an item, and + /// returns it. + static String? _takeWordMarker(dom.Element paragraph) { + for (final span in paragraph.querySelectorAll('span')) { + final style = span.attributes['style'] ?? ''; + if (style.contains('mso-list:Ignore') || + style.contains('mso-list: Ignore')) { + final text = span.text.replaceAll('\u00a0', ' ').trim(); + // The span that holds the marker can sit inside one that styles it. + var outer = span; + while (outer.parent != null && + !identical(outer.parent, paragraph) && + outer.parent!.text.replaceAll('\u00a0', ' ').trim() == text) { + outer = outer.parent!; + } + outer.remove(); + return text; + } + } + return null; + } + + /// A Word title or subtitle paragraph, which Word does not write as a + /// heading element. + static int? _wordTitleLevel(dom.Element paragraph) { + for (final name in paragraph.classes) { + if (name == 'MsoTitle') return 1; + if (name == 'MsoSubtitle') return 2; + final match = RegExp(r'^MsoHeading([1-6])$').firstMatch(name); + if (match != null) return int.parse(match.group(1)!); + } + return null; + } + + /// `` and its kind are not comments to an HTML5 + /// parser, which keeps the text between them; that text is the marker the + /// list rewrite reads, so only the conditional markers themselves go. + static String _withoutDownlevelConditionals(String html) => + html.replaceAll(RegExp(r''), ''); + + // --------------------------------------------------------------------- + + bool _droppedClass(dom.Element element) { + for (final name in element.classes) { + if (_droppedClasses.contains(name)) return true; + } + final testId = element.attributes['data-testid'] ?? ''; + if (testId.contains('copy') || testId.contains('citation-pill')) { + return element.localName == 'button' || testId.contains('copy'); + } + return false; + } + + static bool _hasWords(List inlines) => inlines.any( + (inline) => switch (inline) { + PasteText(:final text) => text.trim().isNotEmpty, + PasteBreak() => false, + _ => true, + }, + ); +} + +const _dropped = { + 'script', + 'style', + 'noscript', + 'template', + 'iframe', + 'object', + 'embed', + 'canvas', + 'video', + 'audio', + 'button', + 'select', + 'option', + 'textarea', + 'svg', + 'head', + 'title', + 'meta', + 'link', + 'base', + 'map', + 'area', + 'track', + 'source', + 'rp', + 'wbr', + 'clipboard-copy', + 'tool-tip', + 'o:p', + 'xml', + 'v:shape', + 'v:imagedata', +}; + +const _droppedClasses = { + // Wikipedia: section edit links, footnote marks, jump links. + 'mw-editsection', + 'reference', + 'mw-cite-backlink', + 'mw-jump-link', + 'noprint', + // GitHub: the link icon beside every heading, copy buttons. + 'anchor', + 'octicon', + 'zeroclipboard-container', + // Copy buttons and code-block toolbars of AI chats and docs sites. + 'copy-button', + 'copy-code-button', + 'code-block-decoration', +}; + +const _screenReaderOnly = { + 'sr-only', + 'visually-hidden', + 'visuallyhidden', + 'screen-reader-text', + 'screenreader-only', + 'a11y-hidden', + 'assistive-text', +}; + +const _blockTags = { + 'address', + 'article', + 'aside', + 'blockquote', + 'body', + 'caption', + 'center', + 'dd', + 'details', + 'dialog', + 'div', + 'dl', + 'dt', + 'fieldset', + 'figcaption', + 'figure', + 'footer', + 'form', + 'h1', + 'h2', + 'h3', + 'h4', + 'h5', + 'h6', + 'header', + 'hgroup', + 'hr', + 'html', + 'legend', + 'li', + 'main', + 'nav', + 'ol', + 'p', + 'pre', + 'section', + 'summary', + 'table', + 'tbody', + 'td', + 'tfoot', + 'th', + 'thead', + 'tr', + 'ul', +}; + +const _notLanguages = { + 'copy', + 'copy code', + 'copied', + 'copied!', + 'code', + 'edit', + 'run', + 'download', + 'wrap', + 'expand', + 'collapse', + 'preview', +}; + +/// What the walk carries down the tree: the emphasis in force, the link the +/// words are inside, and whether white space is kept as written. +class _Context { + const _Context({this.styles = const {}, this.href, this.pre = false}); + + final Set styles; + final String? href; + final bool pre; + + _Context withStyle(PasteStyle style) => + _Context(styles: {...styles, style}, href: href, pre: pre); +} + +class _Builder { + final List blocks = []; + final _Line line = _Line(); + + void flush() { + final inlines = line.take(); + if (inlines.isNotEmpty) blocks.add(PasteParagraph(inlines)); + } +} + +/// The words of the block being read, with HTML's white space rules applied +/// as they arrive: runs of spaces and line breaks in the markup are one +/// space, and none at all at the start of a line. +class _Line { + final List _inlines = []; + + bool get _atLineStart => + _inlines.isEmpty || + _inlines.last is PasteBreak || + (_inlines.last is PasteText && + (_inlines.last as PasteText).text.endsWith(' ')); + + void addText(String raw, _Context context) { + var text = raw.replaceAll('\r\n', '\n').replaceAll('\r', '\n'); + text = text.replaceAll(RegExp('[\u200b\ufeff\u00ad\ufffc]'), ''); + if (context.pre) { + final lines = text.split('\n'); + for (var i = 0; i < lines.length; i++) { + if (i > 0) _inlines.add(const PasteBreak()); + _append(lines[i].replaceAll('\u00a0', ' '), context); + } + return; + } + text = text.replaceAll(RegExp(r'[ \t\n\f]+'), ' '); + if (text.startsWith(' ') && _atLineStart) text = text.substring(1); + text = text.replaceAll('\u00a0', ' '); + if (text.isEmpty) return; + _append(text, context); + } + + void _append(String text, _Context context) { + if (text.isEmpty) return; + final last = _inlines.isEmpty ? null : _inlines.last; + if (last is PasteText && + last.href == context.href && + _sameStyles(last.styles, context.styles)) { + _inlines[_inlines.length - 1] = PasteText( + last.text + text, + styles: last.styles, + href: last.href, + ); + return; + } + _inlines.add(PasteText(text, styles: context.styles, href: context.href)); + } + + void addBreak(_Context context) { + _trimTrailingSpace(); + _inlines.add(const PasteBreak()); + } + + void add(PasteInline inline) => _inlines.add(inline); + + void _trimTrailingSpace() { + if (_inlines.isEmpty) return; + final last = _inlines.last; + if (last is PasteText && last.text.endsWith(' ')) { + final trimmed = last.text.trimRight(); + if (trimmed.isEmpty) { + _inlines.removeLast(); + } else { + _inlines[_inlines.length - 1] = PasteText( + trimmed, + styles: last.styles, + href: last.href, + ); + } + } + } + + List take() { + _trimTrailingSpace(); + while (_inlines.isNotEmpty && _inlines.last is PasteBreak) { + _inlines.removeLast(); + _trimTrailingSpace(); + } + while (_inlines.isNotEmpty && _inlines.first is PasteBreak) { + _inlines.removeAt(0); + } + if (_inlines.isNotEmpty && _inlines.first is PasteText) { + final first = _inlines.first as PasteText; + final trimmed = first.text.trimLeft(); + if (trimmed.isEmpty) { + _inlines.removeAt(0); + } else if (trimmed.length != first.text.length) { + _inlines[0] = PasteText( + trimmed, + styles: first.styles, + href: first.href, + ); + } + } + final hasContent = _inlines.any( + (inline) => + inline is! PasteBreak && + (inline is! PasteText || inline.text.trim().isNotEmpty), + ); + final result = hasContent + ? List.of(_inlines) + : const []; + _inlines.clear(); + return result; + } + + static bool _sameStyles(Set a, Set b) => + a.length == b.length && a.containsAll(b); +} + +/// The few CSS rules clipboard HTML relies on: Apple's RTF conversion, Excel +/// and Word put bold and italic in classes defined in a style block. +class _CssSheet { + final Map> _byClass = {}; + final Map> _byTagClass = {}; + final Map> _cache = {}; + + static final _rule = RegExp(r'([^{}]+)\{([^}]*)\}'); + + void add(String css) { + final source = css.replaceAll(RegExp(r'/\*.*?\*/', dotAll: true), ''); + for (final match in _rule.allMatches(source)) { + final declarations = parseDeclarations(match.group(2)!); + if (declarations.isEmpty) continue; + for (final raw in match.group(1)!.split(',')) { + final selector = raw.trim(); + final simple = RegExp( + r'^([a-zA-Z0-9]*)\.([A-Za-z0-9_-]+)$', + ).firstMatch(selector); + if (simple == null) continue; + final tag = simple.group(1)!.toLowerCase(); + final name = simple.group(2)!; + final target = tag.isEmpty + ? _byClass.putIfAbsent(name, () => {}) + : _byTagClass.putIfAbsent('$tag.$name', () => {}); + target.addAll(declarations); + } + } + } + + Map declarationsFor(dom.Element element) { + final cached = _cache[element]; + if (cached != null) return cached; + final result = {}; + if (_byClass.isNotEmpty || _byTagClass.isNotEmpty) { + for (final name in element.classes) { + result.addAll(_byClass[name] ?? const {}); + result.addAll(_byTagClass['${element.localName}.$name'] ?? const {}); + } + } + final inline = element.attributes['style']; + if (inline != null) result.addAll(parseDeclarations(inline)); + return _cache[element] = result; + } + + static Map parseDeclarations(String block) { + final result = {}; + for (final part in block.split(';')) { + final colon = part.indexOf(':'); + if (colon <= 0) continue; + final name = part.substring(0, colon).trim().toLowerCase(); + var value = part.substring(colon + 1).trim().toLowerCase(); + value = value.replaceAll('!important', '').trim(); + if (name.isEmpty || value.isEmpty) continue; + result[name] = value; + } + return result; + } +} diff --git a/lib/paste/paste_tree.dart b/lib/paste/paste_tree.dart new file mode 100644 index 0000000..3cc6f7f --- /dev/null +++ b/lib/paste/paste_tree.dart @@ -0,0 +1,180 @@ +import 'dart:typed_data'; + +/// What a paste reads as, between the clipboard's markup and the note. +/// +/// Every source — a page's HTML, the HTML Apple builds from RTF, the +/// markdown an AI's copy button writes — is read into this one shape, and +/// the note's text is written from it: as markdown in a markdown note, as +/// the editor's own plain format in one that is not. Keeping the reading and +/// the writing apart is what lets the two writers agree on what a paste +/// contains while disagreeing about how to say it. +sealed class PasteBlock { + const PasteBlock(); +} + +final class PasteParagraph extends PasteBlock { + const PasteParagraph(this.inlines); + + final List inlines; +} + +final class PasteHeading extends PasteBlock { + const PasteHeading(this.level, this.inlines); + + /// 1 to 6. + final int level; + final List inlines; +} + +final class PasteList extends PasteBlock { + const PasteList({required this.ordered, required this.items, this.start = 1}); + + final bool ordered; + + /// The first item's number, for an ordered list. + final int start; + final List items; +} + +final class PasteListItem { + const PasteListItem(this.blocks, {this.checked}); + + final List blocks; + + /// Null for an ordinary item; true or false for a to-do. + final bool? checked; +} + +final class PasteQuote extends PasteBlock { + const PasteQuote(this.blocks); + + final List blocks; +} + +final class PasteCode extends PasteBlock { + const PasteCode(this.text, {this.language}); + + final String text; + + /// The info string a fence carries: `python`, `ts`. Null when the source + /// did not say. + final String? language; +} + +enum PasteAlign { none, left, center, right } + +final class PasteTable extends PasteBlock { + const PasteTable(this.rows, this.aligns); + + /// The first row is the header. Every row has [aligns].length cells; a + /// merged cell's value is in its first cell and the rest are empty. + final List>> rows; + final List aligns; +} + +final class PasteRule extends PasteBlock { + const PasteRule(); +} + +final class PasteMathBlock extends PasteBlock { + const PasteMathBlock(this.tex); + + final String tex; +} + +/// One run of a block's words. +sealed class PasteInline { + const PasteInline(); +} + +enum PasteStyle { bold, italic, underline, strike, superscript, subscript } + +final class PasteText extends PasteInline { + const PasteText(this.text, {this.styles = const {}, this.href}); + + final String text; + final Set styles; + + /// Where the words link to, already resolved against the page. + final String? href; +} + +final class PasteCodeSpan extends PasteInline { + const PasteCodeSpan(this.code, {this.href}); + + final String code; + final String? href; +} + +final class PasteMath extends PasteInline { + const PasteMath(this.tex); + + final String tex; +} + +/// A line break inside a block. +final class PasteBreak extends PasteInline { + const PasteBreak(); +} + +final class PasteImageInline extends PasteInline { + const PasteImageInline(this.image, {this.href}); + + final PasteImage image; + final String? href; +} + +/// A picture the paste carries, before it is anything in the note. +/// +/// Either its bytes came with the clipboard — a data URI, an RTFD attachment, +/// a Safari web archive's resource — or [src] says where to fetch them. +class PasteImage { + const PasteImage({ + this.src, + this.bytes, + this.mime, + this.alt = '', + this.width, + this.height, + }); + + /// An absolute http(s) or file URL, or null when [bytes] are here. + final String? src; + final Uint8List? bytes; + final String? mime; + final String alt; + + /// The size the source displayed it at, in CSS pixels, when it said. + final double? width; + final double? height; + + bool get hasBytes => bytes != null && bytes!.isNotEmpty; + + /// How much of the writing column the picture takes: its displayed width + /// against a 720px column, so a logo stays a logo and a figure stays wide. + double get widthFactor { + final shown = width; + if (shown == null || shown <= 0) return 1; + return (shown / referenceColumnWidth).clamp(0.25, 1.0); + } + + static const double referenceColumnWidth = 720; + + Map toMessage() => { + 'src': src, + 'bytes': bytes, + 'mime': mime, + 'alt': alt, + 'width': width, + 'height': height, + }; + + static PasteImage fromMessage(Map raw) => PasteImage( + src: raw['src'] as String?, + bytes: raw['bytes'] as Uint8List?, + mime: raw['mime'] as String?, + alt: raw['alt'] as String? ?? '', + width: (raw['width'] as num?)?.toDouble(), + height: (raw['height'] as num?)?.toDouble(), + ); +} diff --git a/pubspec.lock b/pubspec.lock index db5ba9f..7f70e61 100644 --- a/pubspec.lock +++ b/pubspec.lock @@ -568,7 +568,7 @@ packages: source: hosted version: "0.2.0" html: - dependency: transitive + dependency: "direct main" description: name: html sha256: "43b67b8f43321ab066817dfac5619596c98bb1b61624e77203bb4351785f9699" diff --git a/pubspec.yaml b/pubspec.yaml index 805c1bf..c70c2ce 100644 --- a/pubspec.yaml +++ b/pubspec.yaml @@ -52,6 +52,10 @@ dependencies: # user hand-edited from one it wrote itself. Already present transitively; # named here because this is a direct use. crypto: ^3.0.7 + # Reading the HTML other apps put on the clipboard, so a paste keeps its + # headings, lists, tables, links and pictures. Already present + # transitively; named here because this is a direct use. + html: ^0.15.7 # The save and open dialogs export and import need. Flutter-team federated # plugin; `getSaveLocation` is desktop-only, and the mobile path writes into # the app's own documents directory instead. From 9d53d0b28276081de5c86585e30d8b8a92616eaa Mon Sep 17 00:00:00 2001 From: Sanjay Kholiya Date: Mon, 16 Nov 2026 14:02:22 +0530 Subject: [PATCH 10/48] Add paste fixture corpus and capture tooling Real headless-Chrome captures (Wikipedia, ChatGPT, Gemini, Perplexity, GitHub, Google Docs/Sheets, MDN, Ask Ubuntu, emoji), synthesized native-app payloads (Word, Outlook, Excel, Numbers, Apple Notes, Pages, Safari, Slack, Gmail, VS Code, Finder, images), and the scripts that produced them, including a read-only macOS pasteboard capture script. --- test/fixtures/paste/INDEX.md | 66 + .../com.apple.flat-rtfd.rtfd | Bin 0 -> 4312 bytes .../fixture.json | 31 + .../public.html.html | 43 + .../public.rtf.rtf | 38 + .../public.utf8-plain-text.txt | 12 + .../code-c-spanish-copy-button/fixture.json | 24 + .../public.html.html | 224 ++ .../public.utf8-plain-text.txt | 296 +++ .../code-c-spanish-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../code-c-spanish-selection/public.html.html | 224 ++ .../public.utf8-plain-text.txt | 262 +++ .../code-tables-php-copy-button/fixture.json | 24 + .../public.html.html | 2 + .../public.utf8-plain-text.txt | 203 ++ .../code-tables-php-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 176 ++ .../public.utf8-plain-text.txt | 185 ++ .../fixture.json | 24 + .../public.html.html | 266 +++ .../public.utf8-plain-text.txt | 1627 ++++++++++++++ .../fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 179 ++ .../public.utf8-plain-text.txt | 1919 ++++++++++++++++ .../mac-app-copy-button-guess/fixture.json | 19 + .../public.utf8-plain-text.txt | 22 + .../fixture.json | 24 + .../public.html.html | 47 + .../public.utf8-plain-text.txt | 235 ++ .../math-number-theory-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 1011 +++++++++ .../fixture.json | 24 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 15 + .../fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 46 + .../fixture.json | 24 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 126 ++ .../fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 111 + .../fixture.json | 24 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 475 ++++ .../nested-lists-emoji-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 374 ++++ .../fixture.json | 24 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 124 ++ .../fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 131 ++ .../mac-app-copy-button-guess/fixture.json | 19 + .../public.utf8-plain-text.txt | 22 + .../paste/excel/budget-range-mac/fixture.json | 27 + .../excel/budget-range-mac/public.html.html | 146 ++ .../excel/budget-range-mac/public.png.png | Bin 0 -> 893 bytes .../public.utf8-plain-text.txt | 6 + .../budget-range-windows/CF_UNICODETEXT.txt | 6 + .../paste/excel/budget-range-windows/Csv.csv | 6 + .../budget-range-windows/HTML_Format.html | 151 ++ .../paste/excel/budget-range-windows/PNG.png | Bin 0 -> 893 bytes .../excel/budget-range-windows/fixture.json | 31 + .../NSFilenamesPboardType.plist | 8 + .../finder/two-files-copied/fixture.json | 43 + .../item1.public.file-url.txt | 1 + .../item1.public.utf8-plain-text.txt | 1 + .../two-files-copied/kapy-sample-chart.png | Bin 0 -> 452 bytes .../two-files-copied/kapy-sample-notes.txt | 2 + .../two-files-copied/public.file-url.txt | 1 + .../public.utf8-plain-text.txt | 1 + .../gemini/code-tables-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../code-tables-selection/public.html.html | 1 + .../public.utf8-plain-text.txt | 57 + .../gemini/math-heavy-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../math-heavy-selection/public.html.html | 7 + .../public.utf8-plain-text.txt | 219 ++ .../gemini/math-tables-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../math-tables-selection/public.html.html | 1 + .../public.utf8-plain-text.txt | 103 + .../nested-lists-long-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 3 + .../public.utf8-plain-text.txt | 85 + .../github/issue-body-task-list/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../issue-body-task-list/public.html.html | 1 + .../public.utf8-plain-text.txt | 65 + .../github/pr-body-checklist/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../github/pr-body-checklist/public.html.html | 1 + .../public.utf8-plain-text.txt | 6 + .../fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 19 + .../public.utf8-plain-text.txt | 154 ++ .../fixture.json | 27 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 19 + .../fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 57 + .../fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 638 ++++++ .../vmware-com1-images-table/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../vmware-com1-images-table/public.html.html | 1 + .../public.utf8-plain-text.txt | 370 ++++ .../class-data-plain-view-only/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 6 + .../fixture.json | 27 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 5 + .../merged-cells-view-only/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../merged-cells-view-only/public.html.html | 1 + .../public.utf8-plain-text.txt | 14 + .../styled-list-view-only/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../styled-list-view-only/public.html.html | 1 + .../public.utf8-plain-text.txt | 10 + .../image/single-image-png-tiff/fixture.json | 23 + .../single-image-png-tiff/public.png.png | Bin 0 -> 2046 bytes .../single-image-png-tiff/public.tiff.tiff | Bin 0 -> 259382 bytes .../paste/numbers/table-cells/fixture.json | 27 + .../numbers/table-cells/public.html.html | 67 + .../paste/numbers/table-cells/public.rtf.rtf | 18 + .../table-cells/public.utf8-plain-text.txt | 4 + .../paste/outlook/email-body-mac/fixture.json | 23 + .../outlook/email-body-mac/public.html.html | 96 + .../email-body-mac/public.utf8-plain-text.txt | 11 + .../email-body-windows/CF_UNICODETEXT.txt | 11 + .../email-body-windows/HTML_Format.html | 101 + .../email-body-windows/Rich_Text_Format.rtf | 1 + .../outlook/email-body-windows/fixture.json | 27 + .../com.apple.flat-rtfd.rtfd | Bin 0 -> 4331 bytes .../fixture.json | 27 + .../public.rtf.rtf | 38 + .../public.utf8-plain-text.txt | 12 + .../perplexity/code-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../code-selection/public.html.html | 18 + .../code-selection/public.utf8-plain-text.txt | 54 + .../nested-lists-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../nested-lists-selection/public.html.html | 1 + .../public.utf8-plain-text.txt | 48 + .../table-links-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../table-links-selection/public.html.html | 1 + .../public.utf8-plain-text.txt | 23 + .../table-math-selection/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../table-math-selection/public.html.html | 4 + .../public.utf8-plain-text.txt | 65 + .../com.apple.flat-rtfd.rtfd | Bin 0 -> 2200 bytes .../com.apple.webarchive.webarchive | Bin 0 -> 3370 bytes .../fixture.json | 35 + .../public.html.html | 1 + .../public.rtf.rtf | 14 + .../public.utf8-plain-text.txt | 4 + .../fixture.json | 23 + .../public.html.html | 2 + .../public.utf8-plain-text.txt | 10 + .../askubuntu-answer-code-blocks/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 52 + .../vscode/python-selection/fixture.json | 31 + .../org.chromium.web-custom-data.bin | Bin 0 -> 216 bytes .../vscode/python-selection/public.html.html | 1 + .../public.utf8-plain-text.txt | 9 + .../python-selection/vscode-editor-data.json | 1 + .../vscode/typescript-selection/fixture.json | 31 + .../org.chromium.web-custom-data.bin | Bin 0 -> 224 bytes .../typescript-selection/public.html.html | 1 + .../public.utf8-plain-text.txt | 5 + .../vscode-editor-data.json | 1 + .../getemoji-people-skin-tones/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 645 ++++++ .../fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 72 + .../public.utf8-plain-text.txt | 328 +++ .../wikipedia/cairo-arabic-rtl/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../cairo-arabic-rtl/public.html.html | 1 + .../public.utf8-plain-text.txt | 10 + .../einstein-infobox-lead/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../einstein-infobox-lead/public.html.html | 1 + .../public.utf8-plain-text.txt | 70 + .../fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 23 + .../periodic-table-merged-cells/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 11 + .../quadratic-formula-derivation/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../public.html.html | 1 + .../public.utf8-plain-text.txt | 1971 +++++++++++++++++ .../quadratic-formula-math/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../quadratic-formula-math/public.html.html | 1 + .../public.utf8-plain-text.txt | 48 + .../roman-emperors-long/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../roman-emperors-long/public.html.html | 2 + .../public.utf8-plain-text.txt | 1660 ++++++++++++++ .../tokyo-climate-table-cjk/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../tokyo-climate-table-cjk/public.html.html | 1 + .../public.utf8-plain-text.txt | 120 + .../wikipedia/tokyo-japanese/fixture.json | 28 + .../org.chromium.source-url.txt | 1 + .../wikipedia/tokyo-japanese/public.html.html | 1 + .../tokyo-japanese/public.utf8-plain-text.txt | 11 + .../clip_image001.png | Bin 0 -> 607 bytes .../mixed-lists-table-image-mac/fixture.json | 30 + .../public.html.html | 286 +++ .../public.rtf.rtf | 37 + .../public.utf8-plain-text.txt | 13 + .../CF_UNICODETEXT.txt | 13 + .../HTML_Format.html | 291 +++ .../Rich_Text_Format.rtf | 37 + .../clip_image001.png | Bin 0 -> 607 bytes .../fixture.json | 30 + tool/paste_fixtures/README.md | 81 + tool/paste_fixtures/capture_macos.swift | 142 ++ tool/paste_fixtures/check_cf_html.mjs | 23 + tool/paste_fixtures/headless/.gitignore | 1 + tool/paste_fixtures/headless/apply_notes.mjs | 17 + tool/paste_fixtures/headless/capture.mjs | 63 + tool/paste_fixtures/headless/gcapture.mjs | 43 + tool/paste_fixtures/headless/lib.mjs | 78 + tool/paste_fixtures/headless/notes.json | 47 + tool/paste_fixtures/headless/package.json | 9 + tool/paste_fixtures/headless/run_google.sh | 15 + tool/paste_fixtures/headless/scan.mjs | 32 + .../headless/specs/ai-helpers.mjs | 19 + .../paste_fixtures/headless/specs/chatgpt.mjs | 33 + .../headless/specs/gemini-perplexity.mjs | 34 + .../paste_fixtures/headless/specs/helpers.mjs | 14 + tool/paste_fixtures/headless/specs/web.mjs | 40 + .../headless/specs/wikipedia.mjs | 53 + .../headless/watch_changecount.sh | 9 + tool/paste_fixtures/synthesize/apple.swift | 198 ++ tool/paste_fixtures/synthesize/apps.mjs | 134 ++ tool/paste_fixtures/synthesize/common.mjs | 100 + tool/paste_fixtures/synthesize/sheets.mjs | 293 +++ tool/paste_fixtures/synthesize/word.mjs | 484 ++++ tool/paste_fixtures/test_capture_macos.swift | 28 + tool/paste_fixtures/validate.mjs | 40 + 280 files changed, 20808 insertions(+) create mode 100644 test/fixtures/paste/INDEX.md create mode 100644 test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/com.apple.flat-rtfd.rtfd create mode 100644 test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/fixture.json create mode 100644 test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/public.html.html create mode 100644 test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/public.rtf.rtf create mode 100644 test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/code-c-spanish-copy-button/fixture.json create mode 100644 test/fixtures/paste/chatgpt/code-c-spanish-copy-button/public.html.html create mode 100644 test/fixtures/paste/chatgpt/code-c-spanish-copy-button/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/code-c-spanish-selection/fixture.json create mode 100644 test/fixtures/paste/chatgpt/code-c-spanish-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/chatgpt/code-c-spanish-selection/public.html.html create mode 100644 test/fixtures/paste/chatgpt/code-c-spanish-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/code-tables-php-copy-button/fixture.json create mode 100644 test/fixtures/paste/chatgpt/code-tables-php-copy-button/public.html.html create mode 100644 test/fixtures/paste/chatgpt/code-tables-php-copy-button/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/code-tables-php-selection/fixture.json create mode 100644 test/fixtures/paste/chatgpt/code-tables-php-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/chatgpt/code-tables-php-selection/public.html.html create mode 100644 test/fixtures/paste/chatgpt/code-tables-php-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/long-math-code-tables-images-copy-button/fixture.json create mode 100644 test/fixtures/paste/chatgpt/long-math-code-tables-images-copy-button/public.html.html create mode 100644 test/fixtures/paste/chatgpt/long-math-code-tables-images-copy-button/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/long-math-code-tables-images-selection/fixture.json create mode 100644 test/fixtures/paste/chatgpt/long-math-code-tables-images-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/chatgpt/long-math-code-tables-images-selection/public.html.html create mode 100644 test/fixtures/paste/chatgpt/long-math-code-tables-images-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/mac-app-copy-button-guess/fixture.json create mode 100644 test/fixtures/paste/chatgpt/mac-app-copy-button-guess/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/math-number-theory-copy-button/fixture.json create mode 100644 test/fixtures/paste/chatgpt/math-number-theory-copy-button/public.html.html create mode 100644 test/fixtures/paste/chatgpt/math-number-theory-copy-button/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/math-number-theory-selection/fixture.json create mode 100644 test/fixtures/paste/chatgpt/math-number-theory-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/chatgpt/math-number-theory-selection/public.html.html create mode 100644 test/fixtures/paste/chatgpt/math-number-theory-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/math-stochastic-processes-german-copy-button/fixture.json create mode 100644 test/fixtures/paste/chatgpt/math-stochastic-processes-german-copy-button/public.html.html create mode 100644 test/fixtures/paste/chatgpt/math-stochastic-processes-german-copy-button/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/math-stochastic-processes-german-selection/fixture.json create mode 100644 test/fixtures/paste/chatgpt/math-stochastic-processes-german-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/chatgpt/math-stochastic-processes-german-selection/public.html.html create mode 100644 test/fixtures/paste/chatgpt/math-stochastic-processes-german-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-2-copy-button/fixture.json create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-2-copy-button/public.html.html create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-2-copy-button/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-2-selection/fixture.json create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-2-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-2-selection/public.html.html create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-2-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-copy-button/fixture.json create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-copy-button/public.html.html create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-copy-button/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-selection/fixture.json create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-selection/public.html.html create mode 100644 test/fixtures/paste/chatgpt/nested-lists-emoji-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/table-math-headings-copy-button/fixture.json create mode 100644 test/fixtures/paste/chatgpt/table-math-headings-copy-button/public.html.html create mode 100644 test/fixtures/paste/chatgpt/table-math-headings-copy-button/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/chatgpt/table-math-headings-selection/fixture.json create mode 100644 test/fixtures/paste/chatgpt/table-math-headings-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/chatgpt/table-math-headings-selection/public.html.html create mode 100644 test/fixtures/paste/chatgpt/table-math-headings-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/claude/mac-app-copy-button-guess/fixture.json create mode 100644 test/fixtures/paste/claude/mac-app-copy-button-guess/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/excel/budget-range-mac/fixture.json create mode 100644 test/fixtures/paste/excel/budget-range-mac/public.html.html create mode 100644 test/fixtures/paste/excel/budget-range-mac/public.png.png create mode 100644 test/fixtures/paste/excel/budget-range-mac/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/excel/budget-range-windows/CF_UNICODETEXT.txt create mode 100644 test/fixtures/paste/excel/budget-range-windows/Csv.csv create mode 100644 test/fixtures/paste/excel/budget-range-windows/HTML_Format.html create mode 100644 test/fixtures/paste/excel/budget-range-windows/PNG.png create mode 100644 test/fixtures/paste/excel/budget-range-windows/fixture.json create mode 100644 test/fixtures/paste/finder/two-files-copied/NSFilenamesPboardType.plist create mode 100644 test/fixtures/paste/finder/two-files-copied/fixture.json create mode 100644 test/fixtures/paste/finder/two-files-copied/item1.public.file-url.txt create mode 100644 test/fixtures/paste/finder/two-files-copied/item1.public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/finder/two-files-copied/kapy-sample-chart.png create mode 100644 test/fixtures/paste/finder/two-files-copied/kapy-sample-notes.txt create mode 100644 test/fixtures/paste/finder/two-files-copied/public.file-url.txt create mode 100644 test/fixtures/paste/finder/two-files-copied/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/gemini/code-tables-selection/fixture.json create mode 100644 test/fixtures/paste/gemini/code-tables-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/gemini/code-tables-selection/public.html.html create mode 100644 test/fixtures/paste/gemini/code-tables-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/gemini/math-heavy-selection/fixture.json create mode 100644 test/fixtures/paste/gemini/math-heavy-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/gemini/math-heavy-selection/public.html.html create mode 100644 test/fixtures/paste/gemini/math-heavy-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/gemini/math-tables-selection/fixture.json create mode 100644 test/fixtures/paste/gemini/math-tables-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/gemini/math-tables-selection/public.html.html create mode 100644 test/fixtures/paste/gemini/math-tables-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/gemini/nested-lists-long-selection/fixture.json create mode 100644 test/fixtures/paste/gemini/nested-lists-long-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/gemini/nested-lists-long-selection/public.html.html create mode 100644 test/fixtures/paste/gemini/nested-lists-long-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/github/issue-body-task-list/fixture.json create mode 100644 test/fixtures/paste/github/issue-body-task-list/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/github/issue-body-task-list/public.html.html create mode 100644 test/fixtures/paste/github/issue-body-task-list/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/github/pr-body-checklist/fixture.json create mode 100644 test/fixtures/paste/github/pr-body-checklist/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/github/pr-body-checklist/public.html.html create mode 100644 test/fixtures/paste/github/pr-body-checklist/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/github/readme-got-headings-tables-code/fixture.json create mode 100644 test/fixtures/paste/github/readme-got-headings-tables-code/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/github/readme-got-headings-tables-code/public.html.html create mode 100644 test/fixtures/paste/github/readme-got-headings-tables-code/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/gmail/html-email-layout-tables-quote-signature/fixture.json create mode 100644 test/fixtures/paste/gmail/html-email-layout-tables-quote-signature/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/gmail/html-email-layout-tables-quote-signature/public.html.html create mode 100644 test/fixtures/paste/gmail/html-email-layout-tables-quote-signature/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/google-docs/trace-event-format-toc-and-intro/fixture.json create mode 100644 test/fixtures/paste/google-docs/trace-event-format-toc-and-intro/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/google-docs/trace-event-format-toc-and-intro/public.html.html create mode 100644 test/fixtures/paste/google-docs/trace-event-format-toc-and-intro/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/google-docs/trace-event-format-whole-document/fixture.json create mode 100644 test/fixtures/paste/google-docs/trace-event-format-whole-document/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/google-docs/trace-event-format-whole-document/public.html.html create mode 100644 test/fixtures/paste/google-docs/trace-event-format-whole-document/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/google-docs/vmware-com1-images-table/fixture.json create mode 100644 test/fixtures/paste/google-docs/vmware-com1-images-table/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/google-docs/vmware-com1-images-table/public.html.html create mode 100644 test/fixtures/paste/google-docs/vmware-com1-images-table/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/google-sheets/class-data-plain-view-only/fixture.json create mode 100644 test/fixtures/paste/google-sheets/class-data-plain-view-only/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/google-sheets/class-data-plain-view-only/public.html.html create mode 100644 test/fixtures/paste/google-sheets/class-data-plain-view-only/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/google-sheets/merged-cells-formulas-synthesized/fixture.json create mode 100644 test/fixtures/paste/google-sheets/merged-cells-formulas-synthesized/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/google-sheets/merged-cells-formulas-synthesized/public.html.html create mode 100644 test/fixtures/paste/google-sheets/merged-cells-formulas-synthesized/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/google-sheets/merged-cells-view-only/fixture.json create mode 100644 test/fixtures/paste/google-sheets/merged-cells-view-only/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/google-sheets/merged-cells-view-only/public.html.html create mode 100644 test/fixtures/paste/google-sheets/merged-cells-view-only/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/google-sheets/styled-list-view-only/fixture.json create mode 100644 test/fixtures/paste/google-sheets/styled-list-view-only/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/google-sheets/styled-list-view-only/public.html.html create mode 100644 test/fixtures/paste/google-sheets/styled-list-view-only/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/image/single-image-png-tiff/fixture.json create mode 100644 test/fixtures/paste/image/single-image-png-tiff/public.png.png create mode 100644 test/fixtures/paste/image/single-image-png-tiff/public.tiff.tiff create mode 100644 test/fixtures/paste/numbers/table-cells/fixture.json create mode 100644 test/fixtures/paste/numbers/table-cells/public.html.html create mode 100644 test/fixtures/paste/numbers/table-cells/public.rtf.rtf create mode 100644 test/fixtures/paste/numbers/table-cells/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/outlook/email-body-mac/fixture.json create mode 100644 test/fixtures/paste/outlook/email-body-mac/public.html.html create mode 100644 test/fixtures/paste/outlook/email-body-mac/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/outlook/email-body-windows/CF_UNICODETEXT.txt create mode 100644 test/fixtures/paste/outlook/email-body-windows/HTML_Format.html create mode 100644 test/fixtures/paste/outlook/email-body-windows/Rich_Text_Format.rtf create mode 100644 test/fixtures/paste/outlook/email-body-windows/fixture.json create mode 100644 test/fixtures/paste/pages/document-selection-lists-image/com.apple.flat-rtfd.rtfd create mode 100644 test/fixtures/paste/pages/document-selection-lists-image/fixture.json create mode 100644 test/fixtures/paste/pages/document-selection-lists-image/public.rtf.rtf create mode 100644 test/fixtures/paste/pages/document-selection-lists-image/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/perplexity/code-selection/fixture.json create mode 100644 test/fixtures/paste/perplexity/code-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/perplexity/code-selection/public.html.html create mode 100644 test/fixtures/paste/perplexity/code-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/perplexity/nested-lists-selection/fixture.json create mode 100644 test/fixtures/paste/perplexity/nested-lists-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/perplexity/nested-lists-selection/public.html.html create mode 100644 test/fixtures/paste/perplexity/nested-lists-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/perplexity/table-links-selection/fixture.json create mode 100644 test/fixtures/paste/perplexity/table-links-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/perplexity/table-links-selection/public.html.html create mode 100644 test/fixtures/paste/perplexity/table-links-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/perplexity/table-math-selection/fixture.json create mode 100644 test/fixtures/paste/perplexity/table-math-selection/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/perplexity/table-math-selection/public.html.html create mode 100644 test/fixtures/paste/perplexity/table-math-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/safari/selection-with-image-webarchive/com.apple.flat-rtfd.rtfd create mode 100644 test/fixtures/paste/safari/selection-with-image-webarchive/com.apple.webarchive.webarchive create mode 100644 test/fixtures/paste/safari/selection-with-image-webarchive/fixture.json create mode 100644 test/fixtures/paste/safari/selection-with-image-webarchive/public.html.html create mode 100644 test/fixtures/paste/safari/selection-with-image-webarchive/public.rtf.rtf create mode 100644 test/fixtures/paste/safari/selection-with-image-webarchive/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/slack/message-formatting-emoji-code/fixture.json create mode 100644 test/fixtures/paste/slack/message-formatting-emoji-code/public.html.html create mode 100644 test/fixtures/paste/slack/message-formatting-emoji-code/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/stackexchange/askubuntu-answer-code-blocks/fixture.json create mode 100644 test/fixtures/paste/stackexchange/askubuntu-answer-code-blocks/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/stackexchange/askubuntu-answer-code-blocks/public.html.html create mode 100644 test/fixtures/paste/stackexchange/askubuntu-answer-code-blocks/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/vscode/python-selection/fixture.json create mode 100644 test/fixtures/paste/vscode/python-selection/org.chromium.web-custom-data.bin create mode 100644 test/fixtures/paste/vscode/python-selection/public.html.html create mode 100644 test/fixtures/paste/vscode/python-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/vscode/python-selection/vscode-editor-data.json create mode 100644 test/fixtures/paste/vscode/typescript-selection/fixture.json create mode 100644 test/fixtures/paste/vscode/typescript-selection/org.chromium.web-custom-data.bin create mode 100644 test/fixtures/paste/vscode/typescript-selection/public.html.html create mode 100644 test/fixtures/paste/vscode/typescript-selection/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/vscode/typescript-selection/vscode-editor-data.json create mode 100644 test/fixtures/paste/web/getemoji-people-skin-tones/fixture.json create mode 100644 test/fixtures/paste/web/getemoji-people-skin-tones/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/web/getemoji-people-skin-tones/public.html.html create mode 100644 test/fixtures/paste/web/getemoji-people-skin-tones/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/web/mdn-html-images-relative-urls/fixture.json create mode 100644 test/fixtures/paste/web/mdn-html-images-relative-urls/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/web/mdn-html-images-relative-urls/public.html.html create mode 100644 test/fixtures/paste/web/mdn-html-images-relative-urls/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/wikipedia/cairo-arabic-rtl/fixture.json create mode 100644 test/fixtures/paste/wikipedia/cairo-arabic-rtl/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/wikipedia/cairo-arabic-rtl/public.html.html create mode 100644 test/fixtures/paste/wikipedia/cairo-arabic-rtl/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/wikipedia/einstein-infobox-lead/fixture.json create mode 100644 test/fixtures/paste/wikipedia/einstein-infobox-lead/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/wikipedia/einstein-infobox-lead/public.html.html create mode 100644 test/fixtures/paste/wikipedia/einstein-infobox-lead/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/wikipedia/einstein-section-with-edit-links/fixture.json create mode 100644 test/fixtures/paste/wikipedia/einstein-section-with-edit-links/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/wikipedia/einstein-section-with-edit-links/public.html.html create mode 100644 test/fixtures/paste/wikipedia/einstein-section-with-edit-links/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/wikipedia/periodic-table-merged-cells/fixture.json create mode 100644 test/fixtures/paste/wikipedia/periodic-table-merged-cells/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/wikipedia/periodic-table-merged-cells/public.html.html create mode 100644 test/fixtures/paste/wikipedia/periodic-table-merged-cells/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/wikipedia/quadratic-formula-derivation/fixture.json create mode 100644 test/fixtures/paste/wikipedia/quadratic-formula-derivation/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/wikipedia/quadratic-formula-derivation/public.html.html create mode 100644 test/fixtures/paste/wikipedia/quadratic-formula-derivation/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/wikipedia/quadratic-formula-math/fixture.json create mode 100644 test/fixtures/paste/wikipedia/quadratic-formula-math/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/wikipedia/quadratic-formula-math/public.html.html create mode 100644 test/fixtures/paste/wikipedia/quadratic-formula-math/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/wikipedia/roman-emperors-long/fixture.json create mode 100644 test/fixtures/paste/wikipedia/roman-emperors-long/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/wikipedia/roman-emperors-long/public.html.html create mode 100644 test/fixtures/paste/wikipedia/roman-emperors-long/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/wikipedia/tokyo-climate-table-cjk/fixture.json create mode 100644 test/fixtures/paste/wikipedia/tokyo-climate-table-cjk/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/wikipedia/tokyo-climate-table-cjk/public.html.html create mode 100644 test/fixtures/paste/wikipedia/tokyo-climate-table-cjk/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/wikipedia/tokyo-japanese/fixture.json create mode 100644 test/fixtures/paste/wikipedia/tokyo-japanese/org.chromium.source-url.txt create mode 100644 test/fixtures/paste/wikipedia/tokyo-japanese/public.html.html create mode 100644 test/fixtures/paste/wikipedia/tokyo-japanese/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/word/mixed-lists-table-image-mac/clip_image001.png create mode 100644 test/fixtures/paste/word/mixed-lists-table-image-mac/fixture.json create mode 100644 test/fixtures/paste/word/mixed-lists-table-image-mac/public.html.html create mode 100644 test/fixtures/paste/word/mixed-lists-table-image-mac/public.rtf.rtf create mode 100644 test/fixtures/paste/word/mixed-lists-table-image-mac/public.utf8-plain-text.txt create mode 100644 test/fixtures/paste/word/mixed-lists-table-image-windows/CF_UNICODETEXT.txt create mode 100644 test/fixtures/paste/word/mixed-lists-table-image-windows/HTML_Format.html create mode 100644 test/fixtures/paste/word/mixed-lists-table-image-windows/Rich_Text_Format.rtf create mode 100644 test/fixtures/paste/word/mixed-lists-table-image-windows/clip_image001.png create mode 100644 test/fixtures/paste/word/mixed-lists-table-image-windows/fixture.json create mode 100644 tool/paste_fixtures/README.md create mode 100644 tool/paste_fixtures/capture_macos.swift create mode 100644 tool/paste_fixtures/check_cf_html.mjs create mode 100644 tool/paste_fixtures/headless/.gitignore create mode 100644 tool/paste_fixtures/headless/apply_notes.mjs create mode 100644 tool/paste_fixtures/headless/capture.mjs create mode 100644 tool/paste_fixtures/headless/gcapture.mjs create mode 100644 tool/paste_fixtures/headless/lib.mjs create mode 100644 tool/paste_fixtures/headless/notes.json create mode 100644 tool/paste_fixtures/headless/package.json create mode 100755 tool/paste_fixtures/headless/run_google.sh create mode 100644 tool/paste_fixtures/headless/scan.mjs create mode 100644 tool/paste_fixtures/headless/specs/ai-helpers.mjs create mode 100644 tool/paste_fixtures/headless/specs/chatgpt.mjs create mode 100644 tool/paste_fixtures/headless/specs/gemini-perplexity.mjs create mode 100644 tool/paste_fixtures/headless/specs/helpers.mjs create mode 100644 tool/paste_fixtures/headless/specs/web.mjs create mode 100644 tool/paste_fixtures/headless/specs/wikipedia.mjs create mode 100755 tool/paste_fixtures/headless/watch_changecount.sh create mode 100644 tool/paste_fixtures/synthesize/apple.swift create mode 100644 tool/paste_fixtures/synthesize/apps.mjs create mode 100644 tool/paste_fixtures/synthesize/common.mjs create mode 100644 tool/paste_fixtures/synthesize/sheets.mjs create mode 100644 tool/paste_fixtures/synthesize/word.mjs create mode 100644 tool/paste_fixtures/test_capture_macos.swift create mode 100644 tool/paste_fixtures/validate.mjs diff --git a/test/fixtures/paste/INDEX.md b/test/fixtures/paste/INDEX.md new file mode 100644 index 0000000..494b329 --- /dev/null +++ b/test/fixtures/paste/INDEX.md @@ -0,0 +1,66 @@ +| fixture | capture | platform | items | representations | size | +| --- | --- | --- | --- | --- | --- | +| apple-notes/rich-note-title-lists-checklist-image | synthesized | macos | 1 | public.rtf, com.apple.flat-rtfd, public.utf8-plain-text, public.html | 10 KB | +| chatgpt/code-c-spanish-copy-button | real | macos | 1 | public.utf8-plain-text, public.html | 23 KB | +| chatgpt/code-c-spanish-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 56 KB | +| chatgpt/code-tables-php-copy-button | real | macos | 1 | public.utf8-plain-text, public.html | 37 KB | +| chatgpt/code-tables-php-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 49 KB | +| chatgpt/long-math-code-tables-images-copy-button | real | macos | 1 | public.utf8-plain-text, public.html | 308 KB | +| chatgpt/long-math-code-tables-images-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 397 KB | +| chatgpt/mac-app-copy-button-guess | synthesized | macos | 1 | public.utf8-plain-text | 1 KB | +| chatgpt/math-number-theory-copy-button | real | macos | 1 | public.utf8-plain-text, public.html | 63 KB | +| chatgpt/math-number-theory-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 66 KB | +| chatgpt/math-stochastic-processes-german-copy-button | real | macos | 1 | public.utf8-plain-text, public.html | 15 KB | +| chatgpt/math-stochastic-processes-german-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 18 KB | +| chatgpt/nested-lists-emoji-2-copy-button | real | macos | 1 | public.utf8-plain-text, public.html | 56 KB | +| chatgpt/nested-lists-emoji-2-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 67 KB | +| chatgpt/nested-lists-emoji-copy-button | real | macos | 1 | public.utf8-plain-text, public.html | 117 KB | +| chatgpt/nested-lists-emoji-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 172 KB | +| chatgpt/table-math-headings-copy-button | real | macos | 1 | public.utf8-plain-text, public.html | 47 KB | +| chatgpt/table-math-headings-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 59 KB | +| claude/mac-app-copy-button-guess | synthesized | macos | 1 | public.utf8-plain-text | 1 KB | +| excel/budget-range-mac | synthesized | macos | 1 | public.html, public.utf8-plain-text, public.png | 7 KB | +| excel/budget-range-windows | synthesized | windows | 1 | HTML Format, CF_UNICODETEXT, Csv, PNG | 7 KB | +| finder/two-files-copied | synthesized | macos | 2 | public.file-url, public.utf8-plain-text, NSFilenamesPboardType | 2 KB | +| gemini/code-tables-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 86 KB | +| gemini/math-heavy-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 125 KB | +| gemini/math-tables-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 92 KB | +| gemini/nested-lists-long-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 51 KB | +| github/issue-body-task-list | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 108 KB | +| github/pr-body-checklist | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 8 KB | +| github/readme-got-headings-tables-code | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 170 KB | +| gmail/html-email-layout-tables-quote-signature | synthesized | macos | 1 | public.html, public.utf8-plain-text, org.chromium.source-url | 5 KB | +| google-docs/trace-event-format-toc-and-intro | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 43 KB | +| google-docs/trace-event-format-whole-document | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 714 KB | +| google-docs/vmware-com1-images-table | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 993 KB | +| google-sheets/class-data-plain-view-only | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 3 KB | +| google-sheets/merged-cells-formulas-synthesized | synthesized | macos | 1 | public.html, public.utf8-plain-text, org.chromium.source-url | 6 KB | +| google-sheets/merged-cells-view-only | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 8 KB | +| google-sheets/styled-list-view-only | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 9 KB | +| image/single-image-png-tiff | synthesized | macos | 1 | public.png, public.tiff | 256 KB | +| numbers/table-cells | synthesized | macos | 1 | public.html, public.rtf, public.utf8-plain-text | 4 KB | +| outlook/email-body-mac | synthesized | macos | 1 | public.html, public.utf8-plain-text | 6 KB | +| outlook/email-body-windows | synthesized | windows | 1 | HTML Format, CF_UNICODETEXT, Rich Text Format | 7 KB | +| pages/document-selection-lists-image | synthesized | macos | 1 | public.rtf, com.apple.flat-rtfd, public.utf8-plain-text | 8 KB | +| perplexity/code-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 24 KB | +| perplexity/nested-lists-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 29 KB | +| perplexity/table-links-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 26 KB | +| perplexity/table-math-selection | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 43 KB | +| safari/selection-with-image-webarchive | synthesized | macos | 1 | com.apple.webarchive, public.rtf, com.apple.flat-rtfd, public.html, public.utf8-plain-text | 8 KB | +| slack/message-formatting-emoji-code | synthesized | macos | 1 | public.html, public.utf8-plain-text | 5 KB | +| stackexchange/askubuntu-answer-code-blocks | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 1000 KB | +| vscode/python-selection | synthesized | macos | 1 | public.html, public.utf8-plain-text, org.chromium.web-custom-data, vscode-editor-data | 4 KB | +| vscode/typescript-selection | synthesized | macos | 1 | public.html, public.utf8-plain-text, org.chromium.web-custom-data, vscode-editor-data | 4 KB | +| web/getemoji-people-skin-tones | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 1.1 MB | +| web/mdn-html-images-relative-urls | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 195 KB | +| wikipedia/cairo-arabic-rtl | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 27 KB | +| wikipedia/einstein-infobox-lead | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 109 KB | +| wikipedia/einstein-section-with-edit-links | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 52 KB | +| wikipedia/periodic-table-merged-cells | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 30 KB | +| wikipedia/quadratic-formula-derivation | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 697 KB | +| wikipedia/quadratic-formula-math | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 42 KB | +| wikipedia/roman-emperors-long | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 2.5 MB | +| wikipedia/tokyo-climate-table-cjk | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 32 KB | +| wikipedia/tokyo-japanese | real | macos | 1 | public.utf8-plain-text, public.html, org.chromium.source-url | 29 KB | +| word/mixed-lists-table-image-mac | synthesized | macos | 1 | public.html, public.rtf, public.utf8-plain-text | 23 KB | +| word/mixed-lists-table-image-windows | synthesized | windows | 1 | HTML Format, Rich Text Format, CF_UNICODETEXT | 23 KB | diff --git a/test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/com.apple.flat-rtfd.rtfd b/test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/com.apple.flat-rtfd.rtfd new file mode 100644 index 0000000000000000000000000000000000000000..72b12b9b7fd086e0186174ef3ac7104d3c9a1e34 GIT binary patch literal 4312 zcmds34Qv}%9k(xTV|%2{URi>^hO$*Jml{8Vd@_*-# zWK$P0L07>^cmMbQc<=x5d+&eGVBwGro}%1a479VWv)o`|I}FQR@KK_&!OG)W)_Yi|NRg~8N=WzD44M~O!~Qk8@iUD07$SgI9$?kvYhl9`IEQY|88C2>_| zVcm#{DIC@{#)2vii#TldQPad>?$;ztL@h+^C5$Ta=76q-{22UwxDBYKCDfaD1Xa2> zLHzEtI|Wgwx&dze*dQUPstQL8LNq=IstE$rQh3CyytcX^=94#Kl8nn*h=dBu__1P| zMkI(8$k1Ek^HyTTBk~6;nj9m@>^B*S1z_>7aM%9qIx008lY=TrVLr4zV8+WsXvkyn z(f*)8LskUdWm z5aqC60cpt+emK%OfS@>eP_GWoM4>TRUAiJ30GiiigD8FwWiDSD>GzjIN-rD(y_XoU z&&i_WkQe2PXVJV+(G##&v1)p9n<%fyS!YX{7Z$9!OB|Pt5N63L*!V2z@xXorQtjhJ zk^n;>J~+87S;==SkXp;c>$Oa(M9Tzbb6vH^GO6afny*U@O=bxLst6pTktictSXP*B zh;BFUazSWPULV3rSVUh-fDJL!egsEe)1X1(YZ{#g2YDNoa^dY%WvU^5-Zvo@B^t^m zfP&DCVaTn~CN7jPMU+8@S1d8*Vw_M>0y>HTXPtzA({zn+xycOLL-JG+5eO1W4|p*2 zL?oKii#Zw+5rSTeWCZ^TN>u2C8*x|-QO#tjmOFMfb==n4-iFph8H<}+Dk?})hNeWy z6+KpA=yE6~$Jg-I1yc-DWxVc^6&pmPNC<-KNvF#f%AQ3$+oSjw+Sb1VE#HWks=X>S zd;m6k%6a8ni@KsKeS4I~c_|T%#o-4;j0MNs3v5FX_Lxd7@=;xTuI$?CTdwpj-GC}W zC7Y58{6un%Xiea_P)4k>7(^wqNs#v6at}N6N}zaLY4{JT zL}4gQlW<;nvWq~Ipk9Tb;2@hEsYUuqSGt4rQqqU|D2t*HF=<3wDA&i{SuErOiGCEL zY7chbP5@_Xn`yl|Rme4r3>tzdd9&>u4d@ssyMN*1)~F3%wJ&)BLL32(JL| zqWksxuGXcX<8RaRb9;{R3AyKkJXayOe&4sVy}87_$_;EuYfEDX&}n!NI+w#Y@YA(7 z1F@SO%>mny->g0hjE{7+hPQ9GZG^GYX1|x(9NYxnRq#S^BSJwkJyKK{ALPnk3Crqj zHpg&lSR#o8*Hn+lRWp-1U7QiAGPUF@tbenRabxFtuG4BXV*?2Jv}~jt8MVI!*RZ;VZ>v%*9@Owz})!1 z&Yawq8C&OQpLwZmbbe}gD%JPg+|2p;l4Y;`<>ZQ=)z>+b#pi#0=$%{M`Q*2Yoqybb zCg+Cmx5mDc$$U4uwPB>rZlCCTBj6ZzIF2`-vI`eo&gVvN`plZA*P_XFt5%jiv7=$^ z;*G~j2iMu{6|W>S4QW9*a^dBBoSR(ES_{8PkUwF9g&dU#JcQw}!)=VbvZb-nQ+RJID zT3R~2eD$HyC)yjv#!HT^94rxplbKW33*!*h&&y`Yp5E3l_WAhMz{nQ6eOJvJb&hJM zGg&m$?CgZZrVhMz@7VIey#rsJJ#%h!V9(6!ubzAF$-f>*9TJ?ET&vM5cOP>&woaTl zZFe}X9{1wAsmZCQcFer=jUC5N_|MPH*3CC;D$@P$9W&@BinhI_sa@SpJ?6~C9s>_7eeVZeHJ zX!9r5qsjk^X@d{FJv;wE{T~7j$#uzf`0V&oWq^O + + + + + + + + + + +

Quarterly planning

+
+
    +
  • Ship the importer
  • +
      +
    • Word and Excel
    • +
    • Apple Notes
    • +
    +
  • Write the release notes
  • +
+
    +
  1. Collect fixtures
  2. +
  3. Write the parser
  4. +
  5. Review with design
  6. +
+

Buy milk

+

Send the invoice

+

chart.png

+ + diff --git a/test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/public.rtf.rtf b/test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/public.rtf.rtf new file mode 100644 index 0000000..664569f --- /dev/null +++ b/test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/public.rtf.rtf @@ -0,0 +1,38 @@ +{\rtf1\ansi\ansicpg1252\cocoartf2908 +\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fswiss\fcharset0 Helvetica-Bold;\f1\fswiss\fcharset0 Helvetica;\f2\fswiss\fcharset0 Helvetica-Oblique; +} +{\colortbl;\red255\green255\blue255;\red10\green96\blue255;} +{\*\expandedcolortbl;;\cssrgb\c0\c47843\c100000\cname systemBlueColor;} +{\*\listtable{\list\listtemplateid1\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{disc\}}{\leveltext\leveltemplateid1\'01\uc0\u8226 ;}{\levelnumbers;}\fi-360\li720\lin720 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{circle\}}{\leveltext\leveltemplateid2\'01\uc0\u9702 ;}{\levelnumbers;}\fi-360\li1440\lin1440 }{\listname ;}\listid1} +{\list\listtemplateid2\listhybrid{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{decimal\}}{\leveltext\leveltemplateid101\'01\'00;}{\levelnumbers\'01;}\fi-360\li720\lin720 }{\listname ;}\listid2}} +{\*\listoverridetable{\listoverride\listid1\listoverridecount0\ls1}{\listoverride\listid2\listoverridecount0\ls2}} +\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\pardirnatural\partightenfactor0 + +\f0\b\fs48 \cf0 Quarterly planning\ +\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\pardirnatural\partightenfactor0 + +\f1\b0\fs28 \cf0 Plain text, then +\f0\b bold +\f1\b0 , +\f2\i italic +\f1\i0 , \ul underlined\ulnone , \strike \strikec0 struck through\strike0\striked0 and a {\field{\*\fldinst{HYPERLINK "https://example.com/roadmap"}}{\fldrslt \cf2 \ul \ulc2 link}}.\ +\pard\tx360\tx720\li720\fi-720\pardirnatural\partightenfactor0 +\ls1\ilvl0\cf0 {\listtext \uc0\u8226 }Ship the importer\ +\pard\tx720\tx1080\li1080\fi-720\pardirnatural\partightenfactor0 +\ls1\ilvl1\cf0 {\listtext \uc0\u9702 }Word and Excel\ +{\listtext \uc0\u9702 }Apple Notes\ +\pard\tx360\tx720\li720\fi-720\pardirnatural\partightenfactor0 +\ls1\ilvl0\cf0 {\listtext \uc0\u8226 }Write the release notes\ +\pard\tx360\tx720\li720\fi-720\pardirnatural\partightenfactor0 +\ls2\ilvl0\cf0 {\listtext 1 }Collect fixtures\ +{\listtext 2 }Write the parser\ +{\listtext 3 }Review with design\ +\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\pardirnatural\partightenfactor0 +\cf0 Buy milk\ +Send the invoice\ +\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\pardirnatural\partightenfactor0 + +\fs24 \cf0 \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\pardirnatural\partightenfactor0 + +\fs28 \cf0 \ +} \ No newline at end of file diff --git a/test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/public.utf8-plain-text.txt b/test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/public.utf8-plain-text.txt new file mode 100644 index 0000000..c990107 --- /dev/null +++ b/test/fixtures/paste/apple-notes/rich-note-title-lists-checklist-image/public.utf8-plain-text.txt @@ -0,0 +1,12 @@ +Quarterly planning +Plain text, then bold, italic, underlined, struck through and a link. + • Ship the importer + ◦ Word and Excel + ◦ Apple Notes + • Write the release notes + 1 Collect fixtures + 2 Write the parser + 3 Review with design +Buy milk +Send the invoice + diff --git a/test/fixtures/paste/chatgpt/code-c-spanish-copy-button/fixture.json b/test/fixtures/paste/chatgpt/code-c-spanish-copy-button/fixture.json new file mode 100644 index 0000000..2e6321b --- /dev/null +++ b/test/fixtures/paste/chatgpt/code-c-spanish-copy-button/fixture.json @@ -0,0 +1,24 @@ +{ + "source": "chatgpt", + "case": "code-c-spanish-copy-button", + "app": "Chrome/157.0.8103.78 (chrome-headless-shell)", + "platform": "macos", + "capture": "real", + "how": "Opened the public ChatGPT share page and clicked the site's own \"Copy response\" button under the longest assistant answer (C code blocks in a Spanish answer).", + "url": "https://chatgpt.com/share/ccc23d98-6d4f-4be5-b9b6-b4464ff1bf9d", + "notes": "Copy-button capture. The site writes through navigator.clipboard.write, so there is no org.chromium.source-url. text/plain is the answer as markdown source (pipe tables, ``` fences, $...$ / $$...$$ math, hard line breaks as a trailing backslash); text/html is the app's rendered DOM full of hydration comments, wrapped in , with no inline styles. Spanish-language answer with several C code blocks (```c fences in plain text), headings, nested lists.", + "items": [ + { + "representations": [ + { + "type": "public.utf8-plain-text", + "file": "public.utf8-plain-text.txt" + }, + { + "type": "public.html", + "file": "public.html.html" + } + ] + } + ] +} diff --git a/test/fixtures/paste/chatgpt/code-c-spanish-copy-button/public.html.html b/test/fixtures/paste/chatgpt/code-c-spanish-copy-button/public.html.html new file mode 100644 index 0000000..c496b54 --- /dev/null +++ b/test/fixtures/paste/chatgpt/code-c-spanish-copy-button/public.html.html @@ -0,0 +1,224 @@ +

Writing a Lexer and Parser in C

Here's a basic lexer and parser in C for a hypothetical programming language that supports integer types constrained to specific integer ranges. I'll provide the relevant code for lexing and parsing integer types with constraints.

Lexer

Header (lexer.h)

c
#ifndef LEXER_H
+#define LEXER_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+typedef enum {
+    TOKEN_INT,
+    TOKEN_RANGE,
+    TOKEN_IDENTIFIER,
+    TOKEN_LPAREN,
+    TOKEN_RPAREN,
+    TOKEN_COLON,
+    TOKEN_COMMA,
+    TOKEN_EOF,
+    TOKEN_UNKNOWN
+} TokenType;
+
+typedef struct {
+    TokenType type;
+    char* value;
+} Token;
+
+typedef struct {
+    const char* source;
+    size_t length;
+    size_t position;
+} Lexer;
+
+Lexer* create_lexer(const char* source);
+void destroy_lexer(Lexer* lexer);
+Token next_token(Lexer* lexer);
+void destroy_token(Token token);
+
+#endif // LEXER_H
+

Implementation (lexer.c)

c
#include "lexer.h"
+
+Lexer* create_lexer(const char* source) {
+    Lexer* lexer = (Lexer*)malloc(sizeof(Lexer));
+    lexer->source = source;
+    lexer->length = strlen(source);
+    lexer->position = 0;
+    return lexer;
+}
+
+void destroy_lexer(Lexer* lexer) {
+    free(lexer);
+}
+
+static char peek_char(Lexer* lexer) {
+    if (lexer->position >= lexer->length) {
+        return '\0';
+    }
+    return lexer->source[lexer->position];
+}
+
+static char advance_char(Lexer* lexer) {
+    if (lexer->position >= lexer->length) {
+        return '\0';
+    }
+    return lexer->source[lexer->position++];
+}
+
+static Token make_token(TokenType type, const char* value) {
+    Token token;
+    token.type = type;
+    token.value = strdup(value);
+    return token;
+}
+
+static void skip_whitespace(Lexer* lexer) {
+    while (isspace(peek_char(lexer))) {
+        advance_char(lexer);
+    }
+}
+
+static Token scan_number(Lexer* lexer) {
+    size_t start = lexer->position - 1;
+    while (isdigit(peek_char(lexer))) {
+        advance_char(lexer);
+    }
+    char* value = strndup(lexer->source + start, lexer->position - start);
+    return make_token(TOKEN_INT, value);
+}
+
+static Token scan_identifier(Lexer* lexer) {
+    size_t start = lexer->position - 1;
+    while (isalnum(peek_char(lexer)) || peek_char(lexer) == '_') {
+        advance_char(lexer);
+    }
+    char* value = strndup(lexer->source + start, lexer->position - start);
+    return make_token(TOKEN_IDENTIFIER, value);
+}
+
+Token next_token(Lexer* lexer) {
+    skip_whitespace(lexer);
+    char current = advance_char(lexer);
+
+    if (isdigit(current)) {
+        return scan_number(lexer);
+    }
+
+    if (isalpha(current) || current == '_') {
+        return scan_identifier(lexer);
+    }
+
+    switch (current) {
+        case '\0': return make_token(TOKEN_EOF, "");
+        case '(': return make_token(TOKEN_LPAREN, "(");
+        case ')': return make_token(TOKEN_RPAREN, ")");
+        case ':': return make_token(TOKEN_COLON, ":");
+        case ',': return make_token(TOKEN_COMMA, ",");
+        case '-':
+            if (peek_char(lexer) == '>') {
+                advance_char(lexer);
+                return make_token(TOKEN_RANGE, "->");
+            }
+            break;
+    }
+
+    char unknown[2] = { current, '\0' };
+    return make_token(TOKEN_UNKNOWN, unknown);
+}
+
+void destroy_token(Token token) {
+    free(token.value);
+}
+

Parser

Header (parser.h)

c
#ifndef PARSER_H
+#define PARSER_H
+
+#include "lexer.h"
+
+typedef struct {
+    char* name;
+    int min_value;
+    int max_value;
+} ConstrainedIntType;
+
+typedef struct {
+    Lexer* lexer;
+    Token current_token;
+} Parser;
+
+Parser* create_parser(const char* source);
+void destroy_parser(Parser* parser);
+ConstrainedIntType* parse_constrained_int_type(Parser* parser);
+
+#endif // PARSER_H
+

Implementation (parser.c)

c
#include "parser.h"
+
+Parser* create_parser(const char* source) {
+    Parser* parser = (Parser*)malloc(sizeof(Parser));
+    parser->lexer = create_lexer(source);
+    parser->current_token = next_token(parser->lexer);
+    return parser;
+}
+
+void destroy_parser(Parser* parser) {
+    destroy_token(parser->current_token);
+    destroy_lexer(parser->lexer);
+    free(parser);
+}
+
+static void consume_token(Parser* parser, TokenType expected) {
+    if (parser->current_token.type == expected) {
+        destroy_token(parser->current_token);
+        parser->current_token = next_token(parser->lexer);
+    } else {
+        fprintf(stderr, "Error: Expected token of type %d but got %d\n", expected, parser->current_token.type);
+        exit(1);
+    }
+}
+
+static int parse_integer(Parser* parser) {
+    int value = atoi(parser->current_token.value);
+    consume_token(parser, TOKEN_INT);
+    return value;
+}
+
+ConstrainedIntType* parse_constrained_int_type(Parser* parser) {
+    ConstrainedIntType* result = (ConstrainedIntType*)malloc(sizeof(ConstrainedIntType));
+
+    if (parser->current_token.type != TOKEN_IDENTIFIER) {
+        fprintf(stderr, "Error: Expected identifier for type name\n");
+        exit(1);
+    }
+
+    result->name = strdup(parser->current_token.value);
+    consume_token(parser, TOKEN_IDENTIFIER);
+
+    consume_token(parser, TOKEN_LPAREN);
+    result->min_value = parse_integer(parser);
+    consume_token(parser, TOKEN_RANGE);
+    result->max_value = parse_integer(parser);
+    consume_token(parser, TOKEN_RPAREN);
+
+    return result;
+}
+

Main Program

To demonstrate the lexer and parser:

c
#include <stdio.h>
+#include "parser.h"
+
+int main() {
+    const char* source_code = "ConstrainedInt(0->100)";
+    Parser* parser = create_parser(source_code);
+
+    ConstrainedIntType* int_type = parse_constrained_int_type(parser);
+    printf("Parsed constrained int type:\n");
+    printf("Name: %s\n", int_type->name);
+    printf("Range: %d -> %d\n", int_type->min_value, int_type->max_value);
+
+    destroy_parser(parser);
+    free(int_type->name);
+    free(int_type);
+
+    return 0;
+}
+

Compilation and Execution

  1. Create files for the above code:
    • lexer.h
    • lexer.c
    • parser.h
    • parser.c
    • main.c
  2. Compile using:
bash
gcc -o parser lexer.c parser.c main.c
+
  1. Run:
bash
./parser
+

Output

Parsed constrained int type:
+Name: ConstrainedInt
+Range: 0 -> 100
+

This provides a basic foundation for a lexer and parser in C that can recognize integer types with specific ranges. You can extend this further by adding more language features.

\ No newline at end of file diff --git a/test/fixtures/paste/chatgpt/code-c-spanish-copy-button/public.utf8-plain-text.txt b/test/fixtures/paste/chatgpt/code-c-spanish-copy-button/public.utf8-plain-text.txt new file mode 100644 index 0000000..cdb0279 --- /dev/null +++ b/test/fixtures/paste/chatgpt/code-c-spanish-copy-button/public.utf8-plain-text.txt @@ -0,0 +1,296 @@ +### Writing a Lexer and Parser in C + +Here's a basic lexer and parser in C for a hypothetical programming language that supports integer types constrained to specific integer ranges. I'll provide the relevant code for lexing and parsing integer types with constraints. + +### Lexer + +#### Header (lexer.h) + +c + +```c +#ifndef LEXER_H +#define LEXER_H + +#include +#include +#include +#include + +typedef enum { + TOKEN_INT, + TOKEN_RANGE, + TOKEN_IDENTIFIER, + TOKEN_LPAREN, + TOKEN_RPAREN, + TOKEN_COLON, + TOKEN_COMMA, + TOKEN_EOF, + TOKEN_UNKNOWN +} TokenType; + +typedef struct { + TokenType type; + char* value; +} Token; + +typedef struct { + const char* source; + size_t length; + size_t position; +} Lexer; + +Lexer* create_lexer(const char* source); +void destroy_lexer(Lexer* lexer); +Token next_token(Lexer* lexer); +void destroy_token(Token token); + +#endif // LEXER_H +``` + +#### Implementation (lexer.c) + +c + +```c +#include "lexer.h" + +Lexer* create_lexer(const char* source) { + Lexer* lexer = (Lexer*)malloc(sizeof(Lexer)); + lexer->source = source; + lexer->length = strlen(source); + lexer->position = 0; + return lexer; +} + +void destroy_lexer(Lexer* lexer) { + free(lexer); +} + +static char peek_char(Lexer* lexer) { + if (lexer->position >= lexer->length) { + return '\0'; + } + return lexer->source[lexer->position]; +} + +static char advance_char(Lexer* lexer) { + if (lexer->position >= lexer->length) { + return '\0'; + } + return lexer->source[lexer->position++]; +} + +static Token make_token(TokenType type, const char* value) { + Token token; + token.type = type; + token.value = strdup(value); + return token; +} + +static void skip_whitespace(Lexer* lexer) { + while (isspace(peek_char(lexer))) { + advance_char(lexer); + } +} + +static Token scan_number(Lexer* lexer) { + size_t start = lexer->position - 1; + while (isdigit(peek_char(lexer))) { + advance_char(lexer); + } + char* value = strndup(lexer->source + start, lexer->position - start); + return make_token(TOKEN_INT, value); +} + +static Token scan_identifier(Lexer* lexer) { + size_t start = lexer->position - 1; + while (isalnum(peek_char(lexer)) || peek_char(lexer) == '_') { + advance_char(lexer); + } + char* value = strndup(lexer->source + start, lexer->position - start); + return make_token(TOKEN_IDENTIFIER, value); +} + +Token next_token(Lexer* lexer) { + skip_whitespace(lexer); + char current = advance_char(lexer); + + if (isdigit(current)) { + return scan_number(lexer); + } + + if (isalpha(current) || current == '_') { + return scan_identifier(lexer); + } + + switch (current) { + case '\0': return make_token(TOKEN_EOF, ""); + case '(': return make_token(TOKEN_LPAREN, "("); + case ')': return make_token(TOKEN_RPAREN, ")"); + case ':': return make_token(TOKEN_COLON, ":"); + case ',': return make_token(TOKEN_COMMA, ","); + case '-': + if (peek_char(lexer) == '>') { + advance_char(lexer); + return make_token(TOKEN_RANGE, "->"); + } + break; + } + + char unknown[2] = { current, '\0' }; + return make_token(TOKEN_UNKNOWN, unknown); +} + +void destroy_token(Token token) { + free(token.value); +} +``` + +### Parser + +#### Header (parser.h) + +c + +```c +#ifndef PARSER_H +#define PARSER_H + +#include "lexer.h" + +typedef struct { + char* name; + int min_value; + int max_value; +} ConstrainedIntType; + +typedef struct { + Lexer* lexer; + Token current_token; +} Parser; + +Parser* create_parser(const char* source); +void destroy_parser(Parser* parser); +ConstrainedIntType* parse_constrained_int_type(Parser* parser); + +#endif // PARSER_H +``` + +#### Implementation (parser.c) + +c + +```c +#include "parser.h" + +Parser* create_parser(const char* source) { + Parser* parser = (Parser*)malloc(sizeof(Parser)); + parser->lexer = create_lexer(source); + parser->current_token = next_token(parser->lexer); + return parser; +} + +void destroy_parser(Parser* parser) { + destroy_token(parser->current_token); + destroy_lexer(parser->lexer); + free(parser); +} + +static void consume_token(Parser* parser, TokenType expected) { + if (parser->current_token.type == expected) { + destroy_token(parser->current_token); + parser->current_token = next_token(parser->lexer); + } else { + fprintf(stderr, "Error: Expected token of type %d but got %d\n", expected, parser->current_token.type); + exit(1); + } +} + +static int parse_integer(Parser* parser) { + int value = atoi(parser->current_token.value); + consume_token(parser, TOKEN_INT); + return value; +} + +ConstrainedIntType* parse_constrained_int_type(Parser* parser) { + ConstrainedIntType* result = (ConstrainedIntType*)malloc(sizeof(ConstrainedIntType)); + + if (parser->current_token.type != TOKEN_IDENTIFIER) { + fprintf(stderr, "Error: Expected identifier for type name\n"); + exit(1); + } + + result->name = strdup(parser->current_token.value); + consume_token(parser, TOKEN_IDENTIFIER); + + consume_token(parser, TOKEN_LPAREN); + result->min_value = parse_integer(parser); + consume_token(parser, TOKEN_RANGE); + result->max_value = parse_integer(parser); + consume_token(parser, TOKEN_RPAREN); + + return result; +} +``` + +### Main Program + +To demonstrate the lexer and parser: + +c + +```c +#include +#include "parser.h" + +int main() { + const char* source_code = "ConstrainedInt(0->100)"; + Parser* parser = create_parser(source_code); + + ConstrainedIntType* int_type = parse_constrained_int_type(parser); + printf("Parsed constrained int type:\n"); + printf("Name: %s\n", int_type->name); + printf("Range: %d -> %d\n", int_type->min_value, int_type->max_value); + + destroy_parser(parser); + free(int_type->name); + free(int_type); + + return 0; +} +``` + +### Compilation and Execution + +1. Create files for the above code: + - `lexer.h` + - `lexer.c` + - `parser.h` + - `parser.c` + - `main.c` +2. Compile using: + +bash + +```bash +gcc -o parser lexer.c parser.c main.c +``` + +3. Run: + +bash + +```bash +./parser +``` + +### Output + +``` +Parsed constrained int type: +Name: ConstrainedInt +Range: 0 -> 100 +``` + +This provides a basic foundation for a lexer and parser in C that can recognize integer types with specific ranges. You can extend this further by adding more language features. \ No newline at end of file diff --git a/test/fixtures/paste/chatgpt/code-c-spanish-selection/fixture.json b/test/fixtures/paste/chatgpt/code-c-spanish-selection/fixture.json new file mode 100644 index 0000000..add6c37 --- /dev/null +++ b/test/fixtures/paste/chatgpt/code-c-spanish-selection/fixture.json @@ -0,0 +1,28 @@ +{ + "source": "chatgpt", + "case": "code-c-spanish-selection", + "app": "Chrome/157.0.8103.78 (chrome-headless-shell)", + "platform": "macos", + "capture": "real", + "how": "Opened the public ChatGPT share page and selected the longest assistant answer (C code blocks in a Spanish answer) from its first block to its last with a DOM range (what a mouse drag over the answer yields), then ran document.execCommand(\"copy\").", + "url": "https://chatgpt.com/share/ccc23d98-6d4f-4be5-b9b6-b4464ff1bf9d", + "notes": "Selection capture (DOM range + execCommand('copy')), so it is Chrome's serialization: org.chromium.source-url is the page URL, every element carries a computed inline style=, the first block starts with
, and plain text is the rendered text (UI labels such as 'Thought for ...' / 'Worked for ...' can lead it; tokens of rendered math sit on separate lines). Code blocks lose their language-* classes in this path. 8
 blocks, 10 headings, lists.",
+  "items": [
+    {
+      "representations": [
+        {
+          "type": "public.utf8-plain-text",
+          "file": "public.utf8-plain-text.txt"
+        },
+        {
+          "type": "public.html",
+          "file": "public.html.html"
+        },
+        {
+          "type": "org.chromium.source-url",
+          "file": "org.chromium.source-url.txt"
+        }
+      ]
+    }
+  ]
+}
diff --git a/test/fixtures/paste/chatgpt/code-c-spanish-selection/org.chromium.source-url.txt b/test/fixtures/paste/chatgpt/code-c-spanish-selection/org.chromium.source-url.txt
new file mode 100644
index 0000000..cfbe5bc
--- /dev/null
+++ b/test/fixtures/paste/chatgpt/code-c-spanish-selection/org.chromium.source-url.txt
@@ -0,0 +1 @@
+https://chatgpt.com/share/ccc23d98-6d4f-4be5-b9b6-b4464ff1bf9d
\ No newline at end of file
diff --git a/test/fixtures/paste/chatgpt/code-c-spanish-selection/public.html.html b/test/fixtures/paste/chatgpt/code-c-spanish-selection/public.html.html
new file mode 100644
index 0000000..f19b04e
--- /dev/null
+++ b/test/fixtures/paste/chatgpt/code-c-spanish-selection/public.html.html
@@ -0,0 +1,224 @@
+


Writing a Lexer and Parser in C

Here's a basic lexer and parser in C for a hypothetical programming language that supports integer types constrained to specific integer ranges. I'll provide the relevant code for lexing and parsing integer types with constraints.

Lexer

Header (lexer.h)

c
#ifndef LEXER_H
+#define LEXER_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+typedef enum {
+    TOKEN_INT,
+    TOKEN_RANGE,
+    TOKEN_IDENTIFIER,
+    TOKEN_LPAREN,
+    TOKEN_RPAREN,
+    TOKEN_COLON,
+    TOKEN_COMMA,
+    TOKEN_EOF,
+    TOKEN_UNKNOWN
+} TokenType;
+
+typedef struct {
+    TokenType type;
+    char* value;
+} Token;
+
+typedef struct {
+    const char* source;
+    size_t length;
+    size_t position;
+} Lexer;
+
+Lexer* create_lexer(const char* source);
+void destroy_lexer(Lexer* lexer);
+Token next_token(Lexer* lexer);
+void destroy_token(Token token);
+
+#endif // LEXER_H
+

Implementation (lexer.c)

c
#include "lexer.h"
+
+Lexer* create_lexer(const char* source) {
+    Lexer* lexer = (Lexer*)malloc(sizeof(Lexer));
+    lexer->source = source;
+    lexer->length = strlen(source);
+    lexer->position = 0;
+    return lexer;
+}
+
+void destroy_lexer(Lexer* lexer) {
+    free(lexer);
+}
+
+static char peek_char(Lexer* lexer) {
+    if (lexer->position >= lexer->length) {
+        return '\0';
+    }
+    return lexer->source[lexer->position];
+}
+
+static char advance_char(Lexer* lexer) {
+    if (lexer->position >= lexer->length) {
+        return '\0';
+    }
+    return lexer->source[lexer->position++];
+}
+
+static Token make_token(TokenType type, const char* value) {
+    Token token;
+    token.type = type;
+    token.value = strdup(value);
+    return token;
+}
+
+static void skip_whitespace(Lexer* lexer) {
+    while (isspace(peek_char(lexer))) {
+        advance_char(lexer);
+    }
+}
+
+static Token scan_number(Lexer* lexer) {
+    size_t start = lexer->position - 1;
+    while (isdigit(peek_char(lexer))) {
+        advance_char(lexer);
+    }
+    char* value = strndup(lexer->source + start, lexer->position - start);
+    return make_token(TOKEN_INT, value);
+}
+
+static Token scan_identifier(Lexer* lexer) {
+    size_t start = lexer->position - 1;
+    while (isalnum(peek_char(lexer)) || peek_char(lexer) == '_') {
+        advance_char(lexer);
+    }
+    char* value = strndup(lexer->source + start, lexer->position - start);
+    return make_token(TOKEN_IDENTIFIER, value);
+}
+
+Token next_token(Lexer* lexer) {
+    skip_whitespace(lexer);
+    char current = advance_char(lexer);
+
+    if (isdigit(current)) {
+        return scan_number(lexer);
+    }
+
+    if (isalpha(current) || current == '_') {
+        return scan_identifier(lexer);
+    }
+
+    switch (current) {
+        case '\0': return make_token(TOKEN_EOF, "");
+        case '(': return make_token(TOKEN_LPAREN, "(");
+        case ')': return make_token(TOKEN_RPAREN, ")");
+        case ':': return make_token(TOKEN_COLON, ":");
+        case ',': return make_token(TOKEN_COMMA, ",");
+        case '-':
+            if (peek_char(lexer) == '>') {
+                advance_char(lexer);
+                return make_token(TOKEN_RANGE, "->");
+            }
+            break;
+    }
+
+    char unknown[2] = { current, '\0' };
+    return make_token(TOKEN_UNKNOWN, unknown);
+}
+
+void destroy_token(Token token) {
+    free(token.value);
+}
+

Parser

Header (parser.h)

c
#ifndef PARSER_H
+#define PARSER_H
+
+#include "lexer.h"
+
+typedef struct {
+    char* name;
+    int min_value;
+    int max_value;
+} ConstrainedIntType;
+
+typedef struct {
+    Lexer* lexer;
+    Token current_token;
+} Parser;
+
+Parser* create_parser(const char* source);
+void destroy_parser(Parser* parser);
+ConstrainedIntType* parse_constrained_int_type(Parser* parser);
+
+#endif // PARSER_H
+

Implementation (parser.c)

c
#include "parser.h"
+
+Parser* create_parser(const char* source) {
+    Parser* parser = (Parser*)malloc(sizeof(Parser));
+    parser->lexer = create_lexer(source);
+    parser->current_token = next_token(parser->lexer);
+    return parser;
+}
+
+void destroy_parser(Parser* parser) {
+    destroy_token(parser->current_token);
+    destroy_lexer(parser->lexer);
+    free(parser);
+}
+
+static void consume_token(Parser* parser, TokenType expected) {
+    if (parser->current_token.type == expected) {
+        destroy_token(parser->current_token);
+        parser->current_token = next_token(parser->lexer);
+    } else {
+        fprintf(stderr, "Error: Expected token of type %d but got %d\n", expected, parser->current_token.type);
+        exit(1);
+    }
+}
+
+static int parse_integer(Parser* parser) {
+    int value = atoi(parser->current_token.value);
+    consume_token(parser, TOKEN_INT);
+    return value;
+}
+
+ConstrainedIntType* parse_constrained_int_type(Parser* parser) {
+    ConstrainedIntType* result = (ConstrainedIntType*)malloc(sizeof(ConstrainedIntType));
+
+    if (parser->current_token.type != TOKEN_IDENTIFIER) {
+        fprintf(stderr, "Error: Expected identifier for type name\n");
+        exit(1);
+    }
+
+    result->name = strdup(parser->current_token.value);
+    consume_token(parser, TOKEN_IDENTIFIER);
+
+    consume_token(parser, TOKEN_LPAREN);
+    result->min_value = parse_integer(parser);
+    consume_token(parser, TOKEN_RANGE);
+    result->max_value = parse_integer(parser);
+    consume_token(parser, TOKEN_RPAREN);
+
+    return result;
+}
+

Main Program

To demonstrate the lexer and parser:

c
#include <stdio.h>
+#include "parser.h"
+
+int main() {
+    const char* source_code = "ConstrainedInt(0->100)";
+    Parser* parser = create_parser(source_code);
+
+    ConstrainedIntType* int_type = parse_constrained_int_type(parser);
+    printf("Parsed constrained int type:\n");
+    printf("Name: %s\n", int_type->name);
+    printf("Range: %d -> %d\n", int_type->min_value, int_type->max_value);
+
+    destroy_parser(parser);
+    free(int_type->name);
+    free(int_type);
+
+    return 0;
+}
+

Compilation and Execution

  1. Create files for the above code:
    • lexer.h
    • lexer.c
    • parser.h
    • parser.c
    • main.c
  2. Compile using:
bash
gcc -o parser lexer.c parser.c main.c
+
  1. Run:
bash
./parser
+

Output

Parsed constrained int type:
+Name: ConstrainedInt
+Range: 0 -> 100
+

This provides a basic foundation for a lexer and parser in C that can recognize integer types with specific ranges. You can extend this further by adding more language features.

\ No newline at end of file diff --git a/test/fixtures/paste/chatgpt/code-c-spanish-selection/public.utf8-plain-text.txt b/test/fixtures/paste/chatgpt/code-c-spanish-selection/public.utf8-plain-text.txt new file mode 100644 index 0000000..c98dc99 --- /dev/null +++ b/test/fixtures/paste/chatgpt/code-c-spanish-selection/public.utf8-plain-text.txt @@ -0,0 +1,262 @@ + +Writing a Lexer and Parser in C +Here's a basic lexer and parser in C for a hypothetical programming language that supports integer types constrained to specific integer ranges. I'll provide the relevant code for lexing and parsing integer types with constraints. + +Lexer +Header (lexer.h) + +c +#ifndef LEXER_H +#define LEXER_H + +#include +#include +#include +#include + +typedef enum { + TOKEN_INT, + TOKEN_RANGE, + TOKEN_IDENTIFIER, + TOKEN_LPAREN, + TOKEN_RPAREN, + TOKEN_COLON, + TOKEN_COMMA, + TOKEN_EOF, + TOKEN_UNKNOWN +} TokenType; + +typedef struct { + TokenType type; + char* value; +} Token; + +typedef struct { + const char* source; + size_t length; + size_t position; +} Lexer; + +Lexer* create_lexer(const char* source); +void destroy_lexer(Lexer* lexer); +Token next_token(Lexer* lexer); +void destroy_token(Token token); + +#endif // LEXER_H +Implementation (lexer.c) + +c +#include "lexer.h" + +Lexer* create_lexer(const char* source) { + Lexer* lexer = (Lexer*)malloc(sizeof(Lexer)); + lexer->source = source; + lexer->length = strlen(source); + lexer->position = 0; + return lexer; +} + +void destroy_lexer(Lexer* lexer) { + free(lexer); +} + +static char peek_char(Lexer* lexer) { + if (lexer->position >= lexer->length) { + return '\0'; + } + return lexer->source[lexer->position]; +} + +static char advance_char(Lexer* lexer) { + if (lexer->position >= lexer->length) { + return '\0'; + } + return lexer->source[lexer->position++]; +} + +static Token make_token(TokenType type, const char* value) { + Token token; + token.type = type; + token.value = strdup(value); + return token; +} + +static void skip_whitespace(Lexer* lexer) { + while (isspace(peek_char(lexer))) { + advance_char(lexer); + } +} + +static Token scan_number(Lexer* lexer) { + size_t start = lexer->position - 1; + while (isdigit(peek_char(lexer))) { + advance_char(lexer); + } + char* value = strndup(lexer->source + start, lexer->position - start); + return make_token(TOKEN_INT, value); +} + +static Token scan_identifier(Lexer* lexer) { + size_t start = lexer->position - 1; + while (isalnum(peek_char(lexer)) || peek_char(lexer) == '_') { + advance_char(lexer); + } + char* value = strndup(lexer->source + start, lexer->position - start); + return make_token(TOKEN_IDENTIFIER, value); +} + +Token next_token(Lexer* lexer) { + skip_whitespace(lexer); + char current = advance_char(lexer); + + if (isdigit(current)) { + return scan_number(lexer); + } + + if (isalpha(current) || current == '_') { + return scan_identifier(lexer); + } + + switch (current) { + case '\0': return make_token(TOKEN_EOF, ""); + case '(': return make_token(TOKEN_LPAREN, "("); + case ')': return make_token(TOKEN_RPAREN, ")"); + case ':': return make_token(TOKEN_COLON, ":"); + case ',': return make_token(TOKEN_COMMA, ","); + case '-': + if (peek_char(lexer) == '>') { + advance_char(lexer); + return make_token(TOKEN_RANGE, "->"); + } + break; + } + + char unknown[2] = { current, '\0' }; + return make_token(TOKEN_UNKNOWN, unknown); +} + +void destroy_token(Token token) { + free(token.value); +} +Parser +Header (parser.h) + +c +#ifndef PARSER_H +#define PARSER_H + +#include "lexer.h" + +typedef struct { + char* name; + int min_value; + int max_value; +} ConstrainedIntType; + +typedef struct { + Lexer* lexer; + Token current_token; +} Parser; + +Parser* create_parser(const char* source); +void destroy_parser(Parser* parser); +ConstrainedIntType* parse_constrained_int_type(Parser* parser); + +#endif // PARSER_H +Implementation (parser.c) + +c +#include "parser.h" + +Parser* create_parser(const char* source) { + Parser* parser = (Parser*)malloc(sizeof(Parser)); + parser->lexer = create_lexer(source); + parser->current_token = next_token(parser->lexer); + return parser; +} + +void destroy_parser(Parser* parser) { + destroy_token(parser->current_token); + destroy_lexer(parser->lexer); + free(parser); +} + +static void consume_token(Parser* parser, TokenType expected) { + if (parser->current_token.type == expected) { + destroy_token(parser->current_token); + parser->current_token = next_token(parser->lexer); + } else { + fprintf(stderr, "Error: Expected token of type %d but got %d\n", expected, parser->current_token.type); + exit(1); + } +} + +static int parse_integer(Parser* parser) { + int value = atoi(parser->current_token.value); + consume_token(parser, TOKEN_INT); + return value; +} + +ConstrainedIntType* parse_constrained_int_type(Parser* parser) { + ConstrainedIntType* result = (ConstrainedIntType*)malloc(sizeof(ConstrainedIntType)); + + if (parser->current_token.type != TOKEN_IDENTIFIER) { + fprintf(stderr, "Error: Expected identifier for type name\n"); + exit(1); + } + + result->name = strdup(parser->current_token.value); + consume_token(parser, TOKEN_IDENTIFIER); + + consume_token(parser, TOKEN_LPAREN); + result->min_value = parse_integer(parser); + consume_token(parser, TOKEN_RANGE); + result->max_value = parse_integer(parser); + consume_token(parser, TOKEN_RPAREN); + + return result; +} +Main Program +To demonstrate the lexer and parser: + + +c +#include +#include "parser.h" + +int main() { + const char* source_code = "ConstrainedInt(0->100)"; + Parser* parser = create_parser(source_code); + + ConstrainedIntType* int_type = parse_constrained_int_type(parser); + printf("Parsed constrained int type:\n"); + printf("Name: %s\n", int_type->name); + printf("Range: %d -> %d\n", int_type->min_value, int_type->max_value); + + destroy_parser(parser); + free(int_type->name); + free(int_type); + + return 0; +} +Compilation and Execution +Create files for the above code: +lexer.h +lexer.c +parser.h +parser.c +main.c +Compile using: + +bash +gcc -o parser lexer.c parser.c main.c +Run: + +bash +./parser +Output + +Parsed constrained int type: +Name: ConstrainedInt +Range: 0 -> 100 +This provides a basic foundation for a lexer and parser in C that can recognize integer types with specific ranges. You can extend this further by adding more language features. \ No newline at end of file diff --git a/test/fixtures/paste/chatgpt/code-tables-php-copy-button/fixture.json b/test/fixtures/paste/chatgpt/code-tables-php-copy-button/fixture.json new file mode 100644 index 0000000..9484148 --- /dev/null +++ b/test/fixtures/paste/chatgpt/code-tables-php-copy-button/fixture.json @@ -0,0 +1,24 @@ +{ + "source": "chatgpt", + "case": "code-tables-php-copy-button", + "app": "Chrome/157.0.8103.78 (chrome-headless-shell)", + "platform": "macos", + "capture": "real", + "how": "Opened the public ChatGPT share page and clicked the site's own \"Copy response\" button under the longest assistant answer (PHP and other code blocks plus tables).", + "url": "https://chatgpt.com/share/6ad8ad3d-3f6c-83e9-abf0-41da8a0d6573", + "notes": "Copy-button capture. The site writes through navigator.clipboard.write, so there is no org.chromium.source-url. text/plain is the answer as markdown source (pipe tables, ``` fences, $...$ / $$...$$ math, hard line breaks as a trailing backslash); text/html is the app's rendered DOM full of hydration comments, wrapped in , with no inline styles. Fenced code (3
, classes language-text and language-c, so languages survive here), 3 tables, nested lists.",
+  "items": [
+    {
+      "representations": [
+        {
+          "type": "public.utf8-plain-text",
+          "file": "public.utf8-plain-text.txt"
+        },
+        {
+          "type": "public.html",
+          "file": "public.html.html"
+        }
+      ]
+    }
+  ]
+}
diff --git a/test/fixtures/paste/chatgpt/code-tables-php-copy-button/public.html.html b/test/fixtures/paste/chatgpt/code-tables-php-copy-button/public.html.html
new file mode 100644
index 0000000..a2070d2
--- /dev/null
+++ b/test/fixtures/paste/chatgpt/code-tables-php-copy-button/public.html.html
@@ -0,0 +1,2 @@
+

Yes—Chainguard’s published packages contain substantive security backports. The changes address both request-startup/session state and PHP’s handling of memory exhaustion. They go considerably further than disabling upload progress.

For your WHM/cPanel server, the practical conclusion is that session.upload_progress.enabled=Off remains a useful precaution, but you should still install PHP packages that your vendor explicitly identifies as fixing both CVEs.

I examined the image metadata, compared the previous and updated packages, recovered their build recipes, and compared shipped development headers and VM code with the corresponding PHP release source. Here is what I found.

1. What Chainguard actually published

At the time of my checks on 21 October 2026, the image SBOMs reported these PHP package revisions:

Image tags checkedPHP package revision
latest, latest-fpm8.5.11-r4
8.4, 8.4-fpm8.4.26-r4
8.3, 8.3-fpm8.3.35-r4
8.28.2.34-r4

The links above are the registry’s machine-readable SBOM attestations.

For PHP 8.5, I confirmed the transition from 8.5.11-r3 to 8.5.11-r4. The updated package retains the PHP 8.5.11 source base and adds these two patch files:

GHSA-w8hw-w9fx-j79w.patch
+GHSA-w8hw-w9fx-j79w-fixup.patch

It also adds a step to regenerate PHP’s VM executor, rebuild its compiled execution objects, and test the new memory-limit behavior. Those steps are recorded in the build recipe embedded in the published r4 package; they are absent from the previous r3 package.

The -r4 suffix matters. This is a downstream backport: an upstream-looking version such as 8.5.11 does not, by itself, establish whether the fix is installed. The same principle applies when you inspect an EasyApache package—check its complete vendor version and release.

How I obtained the source for review

The two original patch files were not retrievable through the source location referenced by the package. However, Fedora had made the PHP 8.5.12 source archive available. I downloaded it and checked its SHA-512 against Fedora’s published source manifest.

That archive’s NEWS explicitly groups:

  • CVE-2026-109618 and CVE-2026-109619;

  • GHSA-w8hw-w9fx-j79w and GHSA-6wmf-4rv5-p3rp;

under “Avoid state corruption via bailout.” This is in the PHP 8.5.12 source archive available through Fedora.

I then corroborated the relevant changes against Chainguard’s actual shipped headers and VM code. The implementation details below come from that source comparison. I cannot separately attribute individual changes to the main patch versus its -fixup file.

2. There is a direct fix for the updated blog’s stale-serialization-state finding

This is the part most directly relevant to your original question.

PHP now initializes certain request state before request-data processing can invoke the session upload-progress handler. The new helper, php_basic_early_rinit(), resets:

  • BG(serialize_lock);

  • BG(serialize);

  • BG(unserialize);

  • related URL-rewriter state.

The source comment explicitly explains why: the upload-progress handler can serialize or unserialize session data before normal module request initialization, usually called RINIT. The helper is now called early enough to precede that processing.

Why that matters: if an earlier request terminated while serialization bookkeeping was still populated, a subsequent request’s early upload-progress processing must not reuse that stale state. Moving initialization earlier directly addresses that lifecycle problem.

This is consistent with the updated article’s surviving concern about cross-request serialization state. It is more specific than a generic reference-count adjustment; the existing Z_TRY_ADDREF(progress->data) is still present.

Source locations: main/main.c, ext/standard/basic_functions.c, and the URL-scanner initialization code in the reviewed release source.

3. Upload-progress session parsing is restricted during startup

The corresponding source also introduces a special mode for reading and rewriting sessions during the early upload-progress pass.

In that mode, objects are represented internally as __PHP_Incomplete_Class, without resolving their application classes. That prevents this early processing from invoking:

  • Autoloaders.

  • unserialize_callback_func.

  • __wakeup().

  • __unserialize().

The serializer preserves the necessary object and enum representations so the session data can be written back without running those callbacks. This restriction is scoped to the early upload-progress pass.

There are several associated fixes:

  • Session globals are reset when multipart processing starts.

  • Upload-progress update and cleanup check whether session initialization actually succeeded.

  • The callback no longer runs through request_parse_body() after modules have been activated; the source specifically identifies that case as corrupting the session.

  • The temporary $_SESSION populated during the restricted early pass is removed afterward.

These changes make the startup path’s assumptions explicit: it can maintain progress information, but it must do so with correctly initialized state and without invoking application object behavior prematurely.

Source locations: ext/session/session.c, ext/standard/var.c, and ext/standard/var_unserializer.re in the release source.

4. The larger change: memory exhaustion is handled at safer boundaries

The engine changes are broader than session handling.

Previously, exceeding PHP’s memory limit could cause the allocator to report a fatal error and call zend_bailout(). A bailout is a nonlocal jump out of the current C execution path. If it interrupts an operation partway through updating internal state, ordinary cleanup and state restoration can be skipped.

The reviewed implementation introduces deferred out-of-memory handling:

  1. Record that memory exhaustion occurred, including the original error location.

  2. Mark an out-of-memory condition as pending.

  3. Signal the VM that it needs attention.

  4. Allow relevant internal routines to reach cleanup paths.

  5. Handle the fatal error and unwind execution at a controlled boundary.

The VM changes include handling failures that occur between opcodes, cleaning up unfinished call frames, and checking for pending memory errors around internal function calls. The actual Chainguard VM header contains these new handling paths.

This does not make memory exhaustion an ordinary recoverable application exception. The request still fails. It also does not eliminate every zend_bailout() in PHP: startup without an application execution frame, timeouts, and other fatal-error paths have their own behavior.

Source locations: Zend/zend_alloc.c, Zend/zend_execute_API.c, Zend/zend_vm_def.h, and generated Zend/zend_vm_execute.h; corroborated against the Chainguard r4 development package.

A new hard memory limit provides bounded cleanup headroom

To make deferred failure possible, ordinary allocations can temporarily go beyond memory_limit while the engine reaches a suitable stopping point.

A new directive controls a separate ceiling:

memory_hard_limit_percent

In the reviewed PHP 8.5 implementation, its default internal mode is -1. For a finite memory_limit, that means:

Existing memory_limitDefault hard threshold
128M256 MiB
256M512 MiB
1G2 GiB
2G3 GiB

The rule is twice the soft limit up to 1 GiB, then the soft limit plus 1 GiB, subject to the allocator’s maximum. An explicitly configured percentage must be at least 100.

These thresholds describe PHP-managed allocation accounting. They are not total worker RSS limits, and ordinary requests do not automatically consume the additional allowance. The extra headroom exists for exhaustion handling.

If an ordinary allocation would exceed the hard limit, the implementation logs a hard-limit error and calls:

_exit(137);

That immediately terminates the process, bypassing the normal PHP shutdown path. Consequently, exit status 137 accompanied by this new message can be PHP’s own deliberate exit; it does not, by itself, prove that the kernel’s OOM killer intervened.

Source locations: zend_mm_update_hard_limit() and zend_mm_hard_limit_error() in Zend/zend_alloc.c, plus the directive registration in main/main.c, in the reviewed release source.

Parsers and unserializers also gain explicit failure handling

The source adds allocation functions that can return failure when the soft limit would be exceeded. Updated callers can then release partially constructed data and return through their normal cleanup paths.

For example, multipart-buffer growth can preserve the original buffer when reallocation fails. Multipart parsing, ordinary POST-variable processing, and unserialization gain checks for pending memory exhaustion and cleanup of partially constructed values.

This is another reason the upload-progress switch cannot be equated with the complete fix: some changed request-processing paths operate independently of upload progress.

Source locations: Zend/zend_alloc.h, main/rfc1867.c, main/php_variables.c, main/SAPI.c, and ext/standard/var_unserializer.re in the reviewed source.

5. What the package tests establish—and what I checked about the backport

Chainguard’s new package-level regression test is designed to require the following behavior:

CaseRequired result in the test definition
Soft-limit exhaustion with memory_limit=8MFatal memory error and exit status 255, while reaching a marker after the allocation and a registered shutdown function
Allocation above the hard threshold with the same soft limitHard-limit error identifying a 16 MiB threshold and exit status 137
Configuration inspectionThe new memory_hard_limit_percent directive exists

These assertions are embedded in the published package’s build metadata. I inspected the definitions; I did not independently execute the tests.

The corresponding release source also adds regressions for stale unserialization bookkeeping, partially built call frames, request parsing under memory pressure, and preventing user-code execution during upload-progress processing.

The comparison supports a security backport, with a clear review limit

Six relevant headers in Chainguard’s shipped development package are byte-for-byte identical to the staged PHP 8.5.12 source, including the allocator, executor globals, session globals, early-initialization declaration, and serialization interfaces.

The VM template and generated executor are not completely identical to the full 8.5.12 release. I investigated that difference rather than assuming it was a missing security change:

Those differences are consistent with backporting the security changes onto 8.5.11 while the full 8.5.12 release also contains other bug fixes.

My confidence is strong that the published r4 packages contain the substantive patch family described here. The limits are that I did not retrieve the two original standalone patch files, independently execute their regression suite, or validate exploit resistance on your server. The evidence also does not justify assigning one patch file to each CVE—the release notes group the two vulnerabilities together.

6. What this means for your WHM/cPanel server

The patch review strengthens the case for updating the actual PHP runtime.

  1. Keep upload progress disabled while you obtain the vendor fix. That reduces exposure to the specific early session-processing path. It does not reproduce the engine, parser, and lifecycle changes above.

  2. Use a cPanel/EasyApache package explicitly documented to cover both CVEs, for every PHP branch serving your sites. Chainguard’s images are separate container runtimes; their publication does not update your installed ea-phpXX packages. cPanel manages its PHP packages through EasyApache 4 and the server’s package manager. (Chainguard)

  3. Verify the complete vendor package revision and recycle the affected PHP workers after updating. A backport can retain the upstream version number. Verify the runtime used by the websites, as well as any separate CLI jobs.

  4. Do not try to obtain this protection by adding memory_hard_limit_percent to an unpatched php.ini. The protection requires new compiled PHP code. I would initially retain the patched vendor’s default behavior rather than reduce the headroom as an improvised mitigation.

  5. Account for the changed exhaustion behavior operationally. After patching, review PHP worker memory budgets and logs with the temporary headroom and deliberate hard-limit exits in mind. That is particularly relevant if your FPM concurrency was sized using memory_limit as though it were a strict total-memory ceiling.

Finally, the updated blog’s observations about whether particular workers survive failed startup should not be used to exempt FPM or another handler from this update. The official PHP notice concerns two critical vulnerabilities and encourages all PHP users to upgrade; the source changes show why focusing exclusively on the upload-progress demonstration is too narrow. (2026)


If you want, I can:

  • Explain implications of Chainguard PHP patch for cPanel security

  • Detail the new PHP memory exhaustion handling introduced by the patches

  • Summarize the fixes related to PHP upload-progress session handling

\ No newline at end of file diff --git a/test/fixtures/paste/chatgpt/code-tables-php-copy-button/public.utf8-plain-text.txt b/test/fixtures/paste/chatgpt/code-tables-php-copy-button/public.utf8-plain-text.txt new file mode 100644 index 0000000..f16a222 --- /dev/null +++ b/test/fixtures/paste/chatgpt/code-tables-php-copy-button/public.utf8-plain-text.txt @@ -0,0 +1,203 @@ +**Yes—Chainguard’s published packages contain substantive security backports. The changes address both request-startup/session state and PHP’s handling of memory exhaustion.** They go considerably further than disabling upload progress. + +For your WHM/cPanel server, the practical conclusion is that **`session.upload_progress.enabled=Off` remains a useful precaution, but you should still install PHP packages that your vendor explicitly identifies as fixing both CVEs.** + +I examined the image metadata, compared the previous and updated packages, recovered their build recipes, and compared shipped development headers and VM code with the corresponding PHP release source. Here is what I found. + +## 1. What Chainguard actually published + +At the time of my checks on **21 October 2026**, the image SBOMs reported these PHP package revisions: + +| Image tags checked | PHP package revision | +| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------- | +| `latest`, `latest-fpm` | [8.5.11-r4](https://cgr.dev/v2/chainguard/php/blobs/sha256:8ae239bb82996bae9cbf28d9aac3ede5a37eb47c6decfcfa4d41dd3eb1e79202) | +| `8.4`, `8.4-fpm` | [8.4.26-r4](https://cgr.dev/v2/chainguard/php/blobs/sha256:ad15d4f251666381cfa7c08f77228841ed1b489ccee57efcbfa54f5e2db3127b) | +| `8.3`, `8.3-fpm` | [8.3.35-r4](https://cgr.dev/v2/chainguard/php/blobs/sha256:bc776fd9d24d3293fccd4c2228af525be1f9732435a4c7376e00e8b3bc0709dc) | +| `8.2` | [8.2.34-r4](https://cgr.dev/v2/chainguard/php/blobs/sha256:e42aa373672f2732cda622e02b8afc3cf1a1e85dac64b25f595988ac45e9b9f4) | + +The links above are the registry’s machine-readable SBOM attestations. + +For PHP 8.5, I confirmed the transition from **`8.5.11-r3` to `8.5.11-r4`**. The updated package retains the PHP 8.5.11 source base and adds these two patch files: + +```text +GHSA-w8hw-w9fx-j79w.patch +GHSA-w8hw-w9fx-j79w-fixup.patch +``` + +It also adds a step to regenerate PHP’s VM executor, rebuild its compiled execution objects, and test the new memory-limit behavior. Those steps are recorded in the build recipe embedded in the [published r4 package](https://packages.wolfi.dev/os/x86_64/php-8.5-8.5.11-r4.apk); they are absent from the [previous r3 package](https://packages.wolfi.dev/os/x86_64/php-8.5-8.5.11-r3.apk). + +**The `-r4` suffix matters.** This is a downstream backport: an upstream-looking version such as `8.5.11` does not, by itself, establish whether the fix is installed. The same principle applies when you inspect an EasyApache package—check its complete vendor version and release. + +### How I obtained the source for review + +The two original patch files were not retrievable through the source location referenced by the package. However, Fedora had made the **PHP 8.5.12 source archive** available. I downloaded it and checked its SHA-512 against [Fedora’s published source manifest](https://src.fedoraproject.org/rpms/php/raw/rawhide/f/sources). + +That archive’s `NEWS` explicitly groups: + +* `CVE-2026-109618` and `CVE-2026-109619`; +* `GHSA-w8hw-w9fx-j79w` and `GHSA-6wmf-4rv5-p3rp`; + +under **“Avoid state corruption via bailout.”** This is in the [PHP 8.5.12 source archive available through Fedora](https://src.fedoraproject.org/repo/pkgs/rpms/php/php-8.5.12.tar.xz/sha512/0a6615373cb4842a3e99632e0903f062f89410ffdc63fc754218ac64de7263119df3af2ec2570457fdc1c3108e5eecd9569dd3bab2769d8d280361bd5e25025b/php-8.5.12.tar.xz). + +I then corroborated the relevant changes against Chainguard’s actual shipped headers and VM code. The implementation details below come from that source comparison. I cannot separately attribute individual changes to the main patch versus its `-fixup` file. + +## 2. There is a direct fix for the updated blog’s stale-serialization-state finding + +This is the part most directly relevant to your original question. + +PHP now initializes certain request state **before request-data processing can invoke the session upload-progress handler**. The new helper, `php_basic_early_rinit()`, resets: + +* `BG(serialize_lock)`; +* `BG(serialize)`; +* `BG(unserialize)`; +* related URL-rewriter state. + +The source comment explicitly explains why: the upload-progress handler can serialize or unserialize session data **before normal module request initialization**, usually called RINIT. The helper is now called early enough to precede that processing. + +**Why that matters:** if an earlier request terminated while serialization bookkeeping was still populated, a subsequent request’s early upload-progress processing must not reuse that stale state. Moving initialization earlier directly addresses that lifecycle problem. + +This is consistent with the updated article’s surviving concern about cross-request serialization state. It is more specific than a generic reference-count adjustment; the existing `Z_TRY_ADDREF(progress->data)` is still present. + +*Source locations: `main/main.c`, `ext/standard/basic_functions.c`, and the URL-scanner initialization code in the reviewed [release source](https://src.fedoraproject.org/repo/pkgs/rpms/php/php-8.5.12.tar.xz/sha512/0a6615373cb4842a3e99632e0903f062f89410ffdc63fc754218ac64de7263119df3af2ec2570457fdc1c3108e5eecd9569dd3bab2769d8d280361bd5e25025b/php-8.5.12.tar.xz).* + +## 3. Upload-progress session parsing is restricted during startup + +The corresponding source also introduces a special mode for reading and rewriting sessions during the early upload-progress pass. + +In that mode, objects are represented internally as `__PHP_Incomplete_Class`, without resolving their application classes. That prevents this early processing from invoking: + +* Autoloaders. +* `unserialize_callback_func`. +* `__wakeup()`. +* `__unserialize()`. + +The serializer preserves the necessary object and enum representations so the session data can be written back without running those callbacks. **This restriction is scoped to the early upload-progress pass.** + +There are several associated fixes: + +* Session globals are reset when multipart processing starts. +* Upload-progress update and cleanup check whether session initialization actually succeeded. +* The callback no longer runs through `request_parse_body()` after modules have been activated; the source specifically identifies that case as corrupting the session. +* The temporary `$_SESSION` populated during the restricted early pass is removed afterward. + +These changes make the startup path’s assumptions explicit: it can maintain progress information, but it must do so with correctly initialized state and without invoking application object behavior prematurely. + +*Source locations: `ext/session/session.c`, `ext/standard/var.c`, and `ext/standard/var_unserializer.re` in the [release source](https://src.fedoraproject.org/repo/pkgs/rpms/php/php-8.5.12.tar.xz/sha512/0a6615373cb4842a3e99632e0903f062f89410ffdc63fc754218ac64de7263119df3af2ec2570457fdc1c3108e5eecd9569dd3bab2769d8d280361bd5e25025b/php-8.5.12.tar.xz).* + +## 4. The larger change: memory exhaustion is handled at safer boundaries + +The engine changes are broader than session handling. + +Previously, exceeding PHP’s memory limit could cause the allocator to report a fatal error and call `zend_bailout()`. A bailout is a nonlocal jump out of the current C execution path. If it interrupts an operation partway through updating internal state, ordinary cleanup and state restoration can be skipped. + +The reviewed implementation introduces **deferred out-of-memory handling**: + +1. Record that memory exhaustion occurred, including the original error location. +2. Mark an out-of-memory condition as pending. +3. Signal the VM that it needs attention. +4. Allow relevant internal routines to reach cleanup paths. +5. Handle the fatal error and unwind execution at a controlled boundary. + +The VM changes include handling failures that occur **between opcodes**, cleaning up unfinished call frames, and checking for pending memory errors around internal function calls. The actual Chainguard VM header contains these new handling paths. + +This does **not** make memory exhaustion an ordinary recoverable application exception. The request still fails. It also does not eliminate every `zend_bailout()` in PHP: startup without an application execution frame, timeouts, and other fatal-error paths have their own behavior. + +*Source locations: `Zend/zend_alloc.c`, `Zend/zend_execute_API.c`, `Zend/zend_vm_def.h`, and generated `Zend/zend_vm_execute.h`; corroborated against the [Chainguard r4 development package](https://packages.wolfi.dev/os/x86_64/php-8.5-dev-8.5.11-r4.apk).* + +### A new hard memory limit provides bounded cleanup headroom + +To make deferred failure possible, ordinary allocations can temporarily go beyond `memory_limit` while the engine reaches a suitable stopping point. + +A new directive controls a separate ceiling: + +```text +memory_hard_limit_percent +``` + +In the reviewed PHP 8.5 implementation, its default internal mode is `-1`. For a finite `memory_limit`, that means: + +| Existing `memory_limit` | Default hard threshold | +| ----------------------- | ---------------------: | +| `128M` | 256 MiB | +| `256M` | 512 MiB | +| `1G` | 2 GiB | +| `2G` | 3 GiB | + +The rule is twice the soft limit up to 1 GiB, then the soft limit plus 1 GiB, subject to the allocator’s maximum. An explicitly configured percentage must be at least 100. + +These thresholds describe **PHP-managed allocation accounting**. They are not total worker RSS limits, and ordinary requests do not automatically consume the additional allowance. The extra headroom exists for exhaustion handling. + +If an ordinary allocation would exceed the hard limit, the implementation logs a hard-limit error and calls: + +```c +_exit(137); +``` + +That immediately terminates the process, bypassing the normal PHP shutdown path. Consequently, **exit status 137 accompanied by this new message can be PHP’s own deliberate exit**; it does not, by itself, prove that the kernel’s OOM killer intervened. + +*Source locations: `zend_mm_update_hard_limit()` and `zend_mm_hard_limit_error()` in `Zend/zend_alloc.c`, plus the directive registration in `main/main.c`, in the reviewed [release source](https://src.fedoraproject.org/repo/pkgs/rpms/php/php-8.5.12.tar.xz/sha512/0a6615373cb4842a3e99632e0903f062f89410ffdc63fc754218ac64de7263119df3af2ec2570457fdc1c3108e5eecd9569dd3bab2769d8d280361bd5e25025b/php-8.5.12.tar.xz).* + +### Parsers and unserializers also gain explicit failure handling + +The source adds allocation functions that can return failure when the soft limit would be exceeded. Updated callers can then release partially constructed data and return through their normal cleanup paths. + +For example, multipart-buffer growth can preserve the original buffer when reallocation fails. Multipart parsing, ordinary POST-variable processing, and unserialization gain checks for pending memory exhaustion and cleanup of partially constructed values. + +This is another reason the upload-progress switch cannot be equated with the complete fix: **some changed request-processing paths operate independently of upload progress.** + +*Source locations: `Zend/zend_alloc.h`, `main/rfc1867.c`, `main/php_variables.c`, `main/SAPI.c`, and `ext/standard/var_unserializer.re` in the reviewed source.* + +## 5. What the package tests establish—and what I checked about the backport + +Chainguard’s new package-level regression test is designed to require the following behavior: + +| Case | Required result in the test definition | +| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- | +| Soft-limit exhaustion with `memory_limit=8M` | Fatal memory error and exit status `255`, while reaching a marker after the allocation and a registered shutdown function | +| Allocation above the hard threshold with the same soft limit | Hard-limit error identifying a 16 MiB threshold and exit status `137` | +| Configuration inspection | The new `memory_hard_limit_percent` directive exists | + +These assertions are embedded in the [published package’s build metadata](https://packages.wolfi.dev/os/x86_64/php-8.5-8.5.11-r4.apk). I inspected the definitions; I did not independently execute the tests. + +The corresponding release source also adds regressions for stale unserialization bookkeeping, partially built call frames, request parsing under memory pressure, and preventing user-code execution during upload-progress processing. + +### The comparison supports a security backport, with a clear review limit + +Six relevant headers in Chainguard’s shipped development package are **byte-for-byte identical** to the staged PHP 8.5.12 source, including the allocator, executor globals, session globals, early-initialization declaration, and serialization interfaces. + +The VM template and generated executor are not completely identical to the full 8.5.12 release. I investigated that difference rather than assuming it was a missing security change: + +* The VM template differs by changes corresponding exactly to an earlier [include/eval exception-handling fix](https://github.com/php/php-src/commit/e7b225697ef2251e3ecfdd21984489c633f94101). +* It also differs by an earlier [constant-comparison fix](https://github.com/php/php-src/commit/7c94b351dbb44f51cf210540f49cddae64fe2037). +* The new delayed-memory-error handling and unfinished-call cleanup are present in Chainguard’s generated VM. + +Those differences are consistent with backporting the security changes onto 8.5.11 while the full 8.5.12 release also contains other bug fixes. + +**My confidence is strong that the published r4 packages contain the substantive patch family described here.** The limits are that I did not retrieve the two original standalone patch files, independently execute their regression suite, or validate exploit resistance on your server. The evidence also does not justify assigning one patch file to each CVE—the release notes group the two vulnerabilities together. + +## 6. What this means for your WHM/cPanel server + +The patch review strengthens the case for updating the actual PHP runtime. + +1. **Keep upload progress disabled while you obtain the vendor fix.** That reduces exposure to the specific early session-processing path. It does not reproduce the engine, parser, and lifecycle changes above. + +2. **Use a cPanel/EasyApache package explicitly documented to cover both CVEs, for every PHP branch serving your sites.** Chainguard’s images are separate container runtimes; their publication does not update your installed `ea-phpXX` packages. cPanel manages its PHP packages through EasyApache 4 and the server’s package manager. ([Chainguard][1]) + +3. **Verify the complete vendor package revision and recycle the affected PHP workers after updating.** A backport can retain the upstream version number. Verify the runtime used by the websites, as well as any separate CLI jobs. + +4. **Do not try to obtain this protection by adding `memory_hard_limit_percent` to an unpatched `php.ini`.** The protection requires new compiled PHP code. I would initially retain the patched vendor’s default behavior rather than reduce the headroom as an improvised mitigation. + +5. **Account for the changed exhaustion behavior operationally.** After patching, review PHP worker memory budgets and logs with the temporary headroom and deliberate hard-limit exits in mind. That is particularly relevant if your FPM concurrency was sized using `memory_limit` as though it were a strict total-memory ceiling. + +Finally, the updated blog’s observations about whether particular workers survive failed startup should not be used to exempt FPM or another handler from this update. The official PHP notice concerns two critical vulnerabilities and encourages all PHP users to upgrade; the source changes show why focusing exclusively on the upload-progress demonstration is too narrow. ([2026][2]) + +--- + +If you want, I can: + +* Explain implications of Chainguard PHP patch for cPanel security +* Detail the new PHP memory exhaustion handling introduced by the patches +* Summarize the fixes related to PHP upload-progress session handling + +[1]: https://images.chainguard.dev/directory/image/php/overview?utm_source=chatgpt.com "php Secure-by-Default Container Image" +[2]: https://www.php.net/archive/2026.php?utm_source=chatgpt.com "PHP: News Archive" diff --git a/test/fixtures/paste/chatgpt/code-tables-php-selection/fixture.json b/test/fixtures/paste/chatgpt/code-tables-php-selection/fixture.json new file mode 100644 index 0000000..6eef874 --- /dev/null +++ b/test/fixtures/paste/chatgpt/code-tables-php-selection/fixture.json @@ -0,0 +1,28 @@ +{ + "source": "chatgpt", + "case": "code-tables-php-selection", + "app": "Chrome/157.0.8103.78 (chrome-headless-shell)", + "platform": "macos", + "capture": "real", + "how": "Opened the public ChatGPT share page and selected the longest assistant answer (PHP and other code blocks plus tables) from its first block to its last with a DOM range (what a mouse drag over the answer yields), then ran document.execCommand(\"copy\").", + "url": "https://chatgpt.com/share/6ad8ad3d-3f6c-83e9-abf0-41da8a0d6573", + "notes": "Selection capture (DOM range + execCommand('copy')), so it is Chrome's serialization: org.chromium.source-url is the page URL, every element carries a computed inline style=, the first block starts with
, and plain text is the rendered text (UI labels such as 'Thought for ...' / 'Worked for ...' can lead it; tokens of rendered math sit on separate lines). Code blocks lose their language-* classes in this path. 6
, 3 tables, 6 

Plain text, then bold, italic, underlined, struck through and a link.