From 71a9b93963eefef936067cf6f6e2a959ccc6eada Mon Sep 17 00:00:00 2001 From: palmoni5 Date: Tue, 10 Nov 2026 20:38:29 +0200 Subject: [PATCH 1/6] fix(html): correct structural selectors and traverse deep DOM iteratively --- pkgs/html/lib/src/query_selector.dart | 64 ++++++++++++++++++++------- 1 file changed, 47 insertions(+), 17 deletions(-) diff --git a/pkgs/html/lib/src/query_selector.dart b/pkgs/html/lib/src/query_selector.dart index 38cbcbcce1..72d1193975 100644 --- a/pkgs/html/lib/src/query_selector.dart +++ b/pkgs/html/lib/src/query_selector.dart @@ -40,20 +40,39 @@ class SelectorEvaluator extends Visitor { return visitSelectorGroup(selector); } + // Explicit DFS preserves document order without recursive calls, which + // could overflow on deeply nested HTML documents. Element? querySelector(Node root, SelectorGroup selector) { - for (var element in root.nodes.whereType()) { - if (matches(element, selector)) return element; - final result = querySelector(element, selector); - if (result != null) return result; + final stack = >[root.nodes.iterator]; + while (stack.isNotEmpty) { + final cursor = stack.last; + if (!cursor.moveNext()) { + stack.removeLast(); + continue; + } + final node = cursor.current; + if (node is Element) { + if (matches(node, selector)) return node; + if (node.nodes.isNotEmpty) stack.add(node.nodes.iterator); + } } return null; } void querySelectorAll( Node root, SelectorGroup selector, List results) { - for (var element in root.nodes.whereType()) { - if (matches(element, selector)) results.add(element); - querySelectorAll(element, selector, results); + final stack = >[root.nodes.iterator]; + while (stack.isNotEmpty) { + final cursor = stack.last; + if (!cursor.moveNext()) { + stack.removeLast(); + continue; + } + final node = cursor.current; + if (node is Element) { + if (matches(node, selector)) results.add(node); + if (node.nodes.isNotEmpty) stack.add(node.nodes.iterator); + } } } @@ -142,19 +161,17 @@ class SelectorEvaluator extends Visitor { // http://dev.w3.org/csswg/selectors-4/#the-root-pseudo case 'root': - // TODO(jmesserly): fix when we have a .ownerDocument pointer - // return _element == _element.ownerDocument.rootElement; - return _element!.localName == 'html' && _element!.parentNode == null; + return _element!.parentNode is Document; // http://dev.w3.org/csswg/selectors-4/#the-empty-pseudo case 'empty': - return _element!.nodes - .any((n) => !(n is Element || n is Text && n.text.isNotEmpty)); + return !_element!.nodes + .any((n) => n is Element || n is Text && n.data.isNotEmpty); // http://dev.w3.org/csswg/selectors-4/#the-blank-pseudo case 'blank': - return _element!.nodes.any((n) => !(n is Element || - n is Text && n.text.runes.any((r) => !isWhitespaceCC(r)))); + return !_element!.nodes.any((n) => n is Element || + n is Text && n.data.runes.any((r) => !isWhitespaceCC(r))); // http://dev.w3.org/csswg/selectors-4/#the-first-child-pseudo case 'first-child': @@ -228,9 +245,22 @@ class SelectorEvaluator extends Visitor { final numericLiteral = literal.value as num; final parent = _element!.parentNode; - return parent != null && - numericLiteral > 0 && - parent.nodes.indexOf(_element) == numericLiteral; + if (parent == null || + !numericLiteral.isFinite || + numericLiteral <= 0 || + numericLiteral != numericLiteral.toInt()) { + return false; + } + var index = 0; + for (final sibling in parent.nodes) { + if (sibling is Element) { + index++; + if (identical(sibling, _element)) { + return index == numericLiteral; + } + } + } + return false; } break; From c1053c277125ba30b655357d05b61c712df786ce Mon Sep 17 00:00:00 2001 From: palmoni5 Date: Tue, 10 Nov 2026 20:38:31 +0200 Subject: [PATCH 2/6] perf(html): avoid class-token set allocations and honor ASCII whitespace --- pkgs/html/lib/src/css_class_set.dart | 40 ++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/pkgs/html/lib/src/css_class_set.dart b/pkgs/html/lib/src/css_class_set.dart index 04553d676b..060dd97c40 100644 --- a/pkgs/html/lib/src/css_class_set.dart +++ b/pkgs/html/lib/src/css_class_set.dart @@ -11,18 +11,48 @@ import '../dom.dart'; class ElementCssClassSet extends _CssClassSetImpl { final Element _element; + // HTML class tokens are separated by ASCII whitespace, not every Unicode + // whitespace character. Reuse the pattern when enumerating classes. + static final RegExp _classWhitespace = RegExp(r'[ \t\n\f\r]+'); + ElementCssClassSet(this._element); + static bool _isWhitespace(int char) => + char == 0x20 || + char == 0x09 || + char == 0x0A || + char == 0x0C || + char == 0x0D; + + // Selectors call classes.contains for each candidate element. Avoid + // allocating a split list and a LinkedHashSet for this hot path. + @override + bool contains(Object? value) { + if (value is! String || value.isEmpty) return false; + final classes = _element.className; + var i = 0; + while (i < classes.length) { + while (i < classes.length && _isWhitespace(classes.codeUnitAt(i))) { + i++; + } + final start = i; + while (i < classes.length && !_isWhitespace(classes.codeUnitAt(i))) { + i++; + } + if (i - start == value.length && classes.startsWith(value, start)) { + return true; + } + } + return false; + } + @override Set readClasses() { final s = LinkedHashSet(); final classname = _element.className; - for (var name in classname.split(' ')) { - final trimmed = name.trim(); - if (trimmed.isNotEmpty) { - s.add(trimmed); - } + for (final name in classname.split(_classWhitespace)) { + if (name.isNotEmpty) s.add(name); } return s; } From 9e04dbfe1519d429d1ab2e2df0e850d92d06477c Mon Sep 17 00:00:00 2001 From: palmoni5 Date: Tue, 10 Nov 2026 20:38:33 +0200 Subject: [PATCH 3/6] test(html): cover selectors, class whitespace and deep queries --- .../test/query_selector_regression_test.dart | 83 +++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 pkgs/html/test/query_selector_regression_test.dart diff --git a/pkgs/html/test/query_selector_regression_test.dart b/pkgs/html/test/query_selector_regression_test.dart new file mode 100644 index 0000000000..7d53dd8345 --- /dev/null +++ b/pkgs/html/test/query_selector_regression_test.dart @@ -0,0 +1,83 @@ +// Copyright (c) project authors. All rights reserved. +// Licensed under the MIT license. +// See LICENSE file in the project root for details. + +import 'package:html/dom.dart'; +import 'package:html/parser.dart'; +import 'package:test/test.dart'; + +void main() { + group('structural selectors', () { + test(':root matches the document element, not detached elements', () { + final document = parse('
'); + expect(document.querySelector(':root'), same(document.documentElement)); + expect(document.body!.querySelector(':root'), isNull); + expect(parseFragment('
').querySelector(':root'), isNull); + }); + + test(':empty ignores comments but not text or elements', () { + final document = parse( + '
' + '
שלום
' + '
', + ); + expect( + document.querySelectorAll('div:empty').map((e) => e.id).toList(), + ['empty', 'comment'], + ); + expect( + document.querySelectorAll('div:blank').map((e) => e.id).toList(), + ['empty', 'comment', 'space'], + ); + }); + + test(':nth-child counts element siblings starting with one', () { + final document = parse( + '
    text
  • ' + '\n
', + ); + expect(document.querySelector('li:nth-child(1)')?.id, 'first'); + expect(document.querySelector('li:nth-child(2)')?.id, 'second'); + expect(document.querySelector('li:nth-child(3)')?.id, 'third'); + expect(document.querySelector('li:nth-child(4)'), isNull); + }); + }); + + test('class selectors handle ASCII whitespace without allocations', () { + final element = Element.tag('span') + ..className = 'foo\tbar\nbaz\rqux\fquux'; + expect(element.classes.contains('bar'), isTrue); + expect(element.classes.contains('qux'), isTrue); + expect(element.classes.contains('foo bar'), isFalse); + expect(element.classes, {'foo', 'bar', 'baz', 'qux', 'quux'}); + final parent = Element.tag('div')..append(element); + expect(parent.querySelector('.baz'), same(element)); + element.className = 'foo\u00a0bar'; + expect(element.classes.contains('foo'), isFalse); + expect(element.classes.contains('foo\u00a0bar'), isTrue); + }); + + test('deep descendant queries retain preorder without recursion', () { + final root = Element.tag('main'); + var current = root; + for (var i = 0; i < 5000; i++) { + final child = Element.tag('section'); + current.append(child); + current = child; + } + current.append(Element.tag('span')..id = 'target'); + expect(root.querySelector('span')?.id, 'target'); + expect(root.querySelectorAll('span').single.id, 'target'); + }); + + test('iterative querySelectorAll preserves preorder', () { + final root = parseFragment( + '

' + '', + ); + expect( + root.querySelectorAll('span').map((e) => e.id).toList(), + ['one', 'two', 'three'], + ); + }); +} From 1c4249d9e1c661336ece404c04e5064dfa19de5a Mon Sep 17 00:00:00 2001 From: palmoni5 Date: Tue, 10 Nov 2026 21:04:18 +0200 Subject: [PATCH 4/6] perf(html): avoid class-set wrapper allocation in selector matching --- pkgs/html/lib/src/css_class_set.dart | 59 +++++++++++++++------------- 1 file changed, 31 insertions(+), 28 deletions(-) diff --git a/pkgs/html/lib/src/css_class_set.dart b/pkgs/html/lib/src/css_class_set.dart index 060dd97c40..dfbb893d00 100644 --- a/pkgs/html/lib/src/css_class_set.dart +++ b/pkgs/html/lib/src/css_class_set.dart @@ -8,6 +8,33 @@ import 'dart:collection'; import '../dom.dart'; +// Scans class tokens without creating an ElementCssClassSet or temporary set. +// HTML's class separator is ASCII whitespace (not arbitrary Unicode space). +bool hasHtmlClassToken(String classes, String value) { + if (value.isEmpty) return false; + var i = 0; + while (i < classes.length) { + while (i < classes.length && _isWhitespace(classes.codeUnitAt(i))) { + i++; + } + final start = i; + while (i < classes.length && !_isWhitespace(classes.codeUnitAt(i))) { + i++; + } + if (i - start == value.length && classes.startsWith(value, start)) { + return true; + } + } + return false; +} + +bool _isWhitespace(int char) => + char == 0x20 || + char == 0x09 || + char == 0x0A || + char == 0x0C || + char == 0x0D; + class ElementCssClassSet extends _CssClassSetImpl { final Element _element; @@ -17,34 +44,10 @@ class ElementCssClassSet extends _CssClassSetImpl { ElementCssClassSet(this._element); - static bool _isWhitespace(int char) => - char == 0x20 || - char == 0x09 || - char == 0x0A || - char == 0x0C || - char == 0x0D; - - // Selectors call classes.contains for each candidate element. Avoid - // allocating a split list and a LinkedHashSet for this hot path. - @override - bool contains(Object? value) { - if (value is! String || value.isEmpty) return false; - final classes = _element.className; - var i = 0; - while (i < classes.length) { - while (i < classes.length && _isWhitespace(classes.codeUnitAt(i))) { - i++; - } - final start = i; - while (i < classes.length && !_isWhitespace(classes.codeUnitAt(i))) { - i++; - } - if (i - start == value.length && classes.startsWith(value, start)) { - return true; - } - } - return false; - } + // Selectors use the direct helper to avoid allocating a set wrapper. + @override + bool contains(Object? value) => + value is String && hasHtmlClassToken(_element.className, value); @override Set readClasses() { From 07daf0fad4c1a8a70dc6970b89ed9cacb429eb3b Mon Sep 17 00:00:00 2001 From: palmoni5 Date: Tue, 10 Nov 2026 21:04:20 +0200 Subject: [PATCH 5/6] perf(html): match class selectors without class-set allocation --- pkgs/html/lib/src/query_selector.dart | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pkgs/html/lib/src/query_selector.dart b/pkgs/html/lib/src/query_selector.dart index 72d1193975..67a3f27b88 100644 --- a/pkgs/html/lib/src/query_selector.dart +++ b/pkgs/html/lib/src/query_selector.dart @@ -10,6 +10,7 @@ import 'package:csslib/visitor.dart'; import '../dom.dart'; import 'constants.dart' show isWhitespaceCC; +import 'css_class_set.dart' show hasHtmlClassToken; Element? querySelector(Node node, String selector) => SelectorEvaluator().querySelector(node, _parseSelectorList(selector)); @@ -308,7 +309,7 @@ class SelectorEvaluator extends Visitor { @override bool visitClassSelector(ClassSelector node) => - _element!.classes.contains(node.name); + hasHtmlClassToken(_element!.className, node.name); // TODO(jmesserly): negation should support any selectors in level 4, // not just simple selectors. From 5cb9a793a55a024af70049a71077d242898841eb Mon Sep 17 00:00:00 2001 From: palmoni5 Date: Tue, 10 Nov 2026 21:45:58 +0200 Subject: [PATCH 6/6] fix(html): split [attr~=value] on ASCII whitespace; add changelog Reuse the class token scanner for the ~= attribute operator, which only split on spaces. Make the deep-query regression test deep enough to overflow the previous recursive traversal, apply dart format, and document the selector fixes in the changelog. --- pkgs/html/CHANGELOG.md | 2 ++ pkgs/html/lib/src/query_selector.dart | 6 +++--- pkgs/html/test/query_selector_regression_test.dart | 9 +++++---- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/pkgs/html/CHANGELOG.md b/pkgs/html/CHANGELOG.md index 49551962fe..47cc50eb35 100644 --- a/pkgs/html/CHANGELOG.md +++ b/pkgs/html/CHANGELOG.md @@ -13,6 +13,8 @@ - Fix `Node.remove` and `NodeList.remove` leaving a stale `parentNode`, `Node.insertBefore`, `NodeList.insert`, `insertAll` and `operator []=` using a shifted index when moving an earlier sibling, and `reparentChildren` emptying a node reparented to itself. Moving all children of another node (`append` of a `DocumentFragment`, `reparentChildren`, `innerHtml`) now runs in linear time. - `getElementById`, `getElementsByTagName` and `getElementsByClassName` no longer parse a CSS selector. IDs and class names that are not valid CSS identifiers (such as `a:b`, `a.b` or `1`) now match exactly instead of throwing or matching the wrong element, `getElementById('')` returns `null`, class names are split on HTML ASCII whitespace, and deeply nested documents no longer overflow the stack. - Reduce allocations when decoding numeric and named character references and when sniffing `` declarations. +- Fix `querySelector` and `querySelectorAll` matching of `:root` (now the element whose parent is the `Document`), `:empty` and `:blank` (previously inverted), and numeric `:nth-child(n)` (now counts element siblings from 1), and traverse descendants iteratively so deeply nested documents no longer overflow the stack. +- Class selectors, `[attr~=value]` selectors and `Element.classes` now split their values on ASCII whitespace (space, tab, LF, FF, CR) as the HTML standard requires, and class selectors no longer allocate a class set per candidate element. ## 0.15.7 diff --git a/pkgs/html/lib/src/query_selector.dart b/pkgs/html/lib/src/query_selector.dart index 67a3f27b88..cedf3fb309 100644 --- a/pkgs/html/lib/src/query_selector.dart +++ b/pkgs/html/lib/src/query_selector.dart @@ -171,7 +171,8 @@ class SelectorEvaluator extends Visitor { // http://dev.w3.org/csswg/selectors-4/#the-blank-pseudo case 'blank': - return !_element!.nodes.any((n) => n is Element || + return !_element!.nodes.any((n) => + n is Element || n is Text && n.data.runes.any((r) => !isWhitespaceCC(r))); // http://dev.w3.org/csswg/selectors-4/#the-first-child-pseudo @@ -332,8 +333,7 @@ class SelectorEvaluator extends Visitor { final select = '${node.value}'; return switch (node.operatorKind) { TokenKind.EQUALS => value == select, - TokenKind.INCLUDES => - value.split(' ').any((v) => v.isNotEmpty && v == select), + TokenKind.INCLUDES => hasHtmlClassToken(value, select), TokenKind.DASH_MATCH => value.startsWith(select) && (value.length == select.length || value[select.length] == '-'), TokenKind.PREFIX_MATCH => value.startsWith(select), diff --git a/pkgs/html/test/query_selector_regression_test.dart b/pkgs/html/test/query_selector_regression_test.dart index 7d53dd8345..665b439e46 100644 --- a/pkgs/html/test/query_selector_regression_test.dart +++ b/pkgs/html/test/query_selector_regression_test.dart @@ -43,15 +43,16 @@ void main() { }); }); - test('class selectors handle ASCII whitespace without allocations', () { - final element = Element.tag('span') - ..className = 'foo\tbar\nbaz\rqux\fquux'; + test('class tokens are separated by ASCII whitespace only', () { + final element = Element.tag('span')..className = 'foo\tbar\nbaz\rqux\fquux'; expect(element.classes.contains('bar'), isTrue); expect(element.classes.contains('qux'), isTrue); expect(element.classes.contains('foo bar'), isFalse); expect(element.classes, {'foo', 'bar', 'baz', 'qux', 'quux'}); final parent = Element.tag('div')..append(element); expect(parent.querySelector('.baz'), same(element)); + expect(parent.querySelector('[class~=qux]'), same(element)); + expect(parent.querySelector('[class~="bar baz"]'), isNull); element.className = 'foo\u00a0bar'; expect(element.classes.contains('foo'), isFalse); expect(element.classes.contains('foo\u00a0bar'), isTrue); @@ -60,7 +61,7 @@ void main() { test('deep descendant queries retain preorder without recursion', () { final root = Element.tag('main'); var current = root; - for (var i = 0; i < 5000; i++) { + for (var i = 0; i < 100000; i++) { final child = Element.tag('section'); current.append(child); current = child;