webpack 5.108.3 → 5.109.0

package/lib/css/syntax.js

@@ -199,6 +199,7 @@ const CC_AT_SIGN = "@".charCodeAt(0);
 
 const CC_LOW_LINE = "_".charCodeAt(0);
 const CC_LOWER_A = "a".charCodeAt(0);
+const CC_LOWER_D = "d".charCodeAt(0);
 const CC_LOWER_F = "f".charCodeAt(0);
 const CC_LOWER_E = "e".charCodeAt(0);
 const CC_LOWER_U = "u".charCodeAt(0);
@@ -297,6 +298,15 @@ const _isSpace = (cc) => cc === CC_SPACE || cc === CC_TAB;
 // rarer tab / newline tests.
 const _isWhiteSpace = (cc) => _isSpace(cc) || _isNewline(cc);
 
+// Whitespace membership table for the run-consumption loop — one load instead
+// of up to five compares per char. EOF (NaN) / non-ASCII index to undefined.
+const _wsTable = new Uint8Array(128);
+_wsTable[CC_SPACE] = 1;
+_wsTable[CC_TAB] = 1;
+_wsTable[CC_LINE_FEED] = 1;
+_wsTable[CC_CARRIAGE_RETURN] = 1;
+_wsTable[CC_FORM_FEED] = 1;
+
 /**
  * @param {number} cc char code
  * @returns {boolean} true, if cc is a digit
@@ -332,11 +342,15 @@ const _isIdentStartCodePointCC = (cc) =>
 /**
  * Spec: ident-code = ident-start / digit / hyphen-minus.
  */
-// ASCII lookup built from the predicate so behaviour is identical; non-ASCII
-// (>= 128) keeps the inline check. `_consumeAnIdentSequence` hits this per code
-// point, and class/property names (hyphen + digit heavy) are the longest
-// comparison-chain path — a table load is constant-time instead.
-const _identCharTable = new Uint8Array(128);
+// Full `charCodeAt` range (0..0xFFFF) so the per-code-point ident test is one
+// table load with no `cc < 128` branch — `_consumeAnIdentSequence` runs this on
+// every character of every ident / class / property name (the tokenizer's
+// hottest loop). Every non-ASCII code unit (>= 0x80) is an ident code point per
+// spec, so those default to 1; only the ASCII rows carry real classification.
+// Callers must index with `cc | 0`: EOF (`charCodeAt` → NaN) becomes 0 (NUL,
+// not an ident) — a raw NaN index is an out-of-range access that permanently
+// degrades the load site's IC.
+const _identCharTable = new Uint8Array(0x10000).fill(1);
 for (let i = 0; i < 128; i++) {
 	_identCharTable[i] =
 		_isLetter(i) || i === CC_LOW_LINE || _isDigit(i) || i === CC_HYPHEN_MINUS
@@ -347,8 +361,7 @@ for (let i = 0; i < 128; i++) {
  * @param {number} cc char code
  * @returns {boolean} true, if cc is an ident-sequence code point
  */
-const _isIdentCodePoint = (cc) =>
-	cc < 128 ? _identCharTable[cc] === 1 : _isIdentStartCodePointCC(cc);
+const _isIdentCodePoint = (cc) => _identCharTable[cc | 0] === 1;
 
 /**
  * ASCII case-insensitive equality against a lowercase literal — avoids the
@@ -368,6 +381,58 @@ const equalsLowerCase = (s, lit) => {
 	return true;
 };
 
+/**
+ * Case-sensitive equality of a source range against a literal — no slice.
+ * @param {string} input source
+ * @param {number} start range start
+ * @param {number} end range end (exclusive)
+ * @param {string} lit literal to match
+ * @returns {boolean} true when the range equals `lit`
+ */
+const rangeEquals = (input, start, end, lit) =>
+	end - start === lit.length && input.startsWith(lit, start);
+
+/**
+ * ASCII case-insensitive equality of a source range against a lowercase ASCII literal — no slice.
+ * @param {string} input source
+ * @param {number} start range start
+ * @param {number} end range end (exclusive)
+ * @param {string} lit lowercase ASCII literal to match
+ * @returns {boolean} true when the range equals `lit` ignoring ASCII case
+ */
+const rangeEqualsLowerCase = (input, start, end, lit) => {
+	if (end - start !== lit.length) return false;
+	for (let i = 0; i < lit.length; i++) {
+		let c = input.charCodeAt(start + i);
+		if (c >= CC_UPPER_A && c <= CC_UPPER_Z) c |= 0x20;
+		if (c !== lit.charCodeAt(i)) return false;
+	}
+	return true;
+};
+
+/**
+ * `s.toLowerCase()` that returns `s` itself (no allocation) when it can't
+ * change — no ASCII uppercase and no non-ASCII (whose Unicode case mapping is
+ * left to the real `toLowerCase`).
+ * @param {string} s string
+ * @returns {string} lowercased string
+ */
+const toLowerCaseIfNeeded = (s) => {
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if ((c >= CC_UPPER_A && c <= CC_UPPER_Z) || c > 127) return s.toLowerCase();
+	}
+	return s;
+};
+
+/**
+ * A custom property name (`<dashed-ident>`): a `--`-prefixed identifier other than bare `--`.
+ * @param {string} identifier identifier
+ * @returns {boolean} true when identifier is dashed, otherwise false
+ */
+const isDashedIdentifier = (identifier) =>
+	identifier.startsWith("--") && identifier.length >= 3;
+
 /**
  * Consume an escaped code point.
  * @param {string} input input
@@ -385,7 +450,8 @@ const _consumeAnEscapedCodePoint = (input, pos) => {
 	if (pos === input.length) return pos;
 	if (_isHexDigit(cc)) {
 		for (let i = 0; i < 5; i++) {
-			if (_isHexDigit(input.charCodeAt(pos))) pos++;
+			if (!_isHexDigit(input.charCodeAt(pos))) break;
+			pos++;
 		}
 		const trail = input.charCodeAt(pos);
 		if (_isWhiteSpace(trail)) {
@@ -471,12 +537,13 @@ const _ifThreeCodePointsWouldStartANumber = (input, pos, f, s, t) => {
 const _consumeAnIdentSequence = (input, pos) => {
 	// Hot loop (every ident, at-keyword, hash, function name, unit). Both checks
 	// are inlined from `_isIdentCodePoint` / `_ifTwoCodePointsAreValidEscape`: the
-	// ASCII ident test is a single table load, and the escape test reads the
-	// following code point only when `cc` is a `\` (rare) instead of eagerly.
+	// ident test is a single full-range table load (no `cc < 128` branch), and the
+	// escape test reads the following code point only when `cc` is a `\` (rare)
+	// instead of eagerly.
 	for (;;) {
-		const cc = input.charCodeAt(pos);
+		const cc = input.charCodeAt(pos) | 0;
 		pos++;
-		if (cc < 128 ? _identCharTable[cc] === 1 : _isIdentStartCodePointCC(cc)) {
+		if (_identCharTable[cc] === 1) {
 			continue;
 		}
 		if (cc === CC_REVERSE_SOLIDUS && !_isNewline(input.charCodeAt(pos))) {
@@ -612,7 +679,7 @@ const fill = (out, type, start, end) => {
  */
 function consumeSpace(input, pos, out) {
 	const start = pos - 1;
-	while (_isWhiteSpace(input.charCodeAt(pos))) pos++;
+	while (_wsTable[input.charCodeAt(pos)] === 1) pos++;
 	return fill(out, TT_WHITESPACE, start, pos);
 }
 
@@ -691,17 +758,33 @@ function consumeNumberSign(input, pos, out) {
  * @returns {MutableToken | undefined} the resulting token, or undefined at EOF
  */
 function consumeHyphenMinus(input, pos, out) {
-	if (_ifThreeCodePointsWouldStartANumber(input, pos)) {
+	// Read the two lookahead code points once; the lead is the known `-`.
+	const second = input.charCodeAt(pos);
+	const third = input.charCodeAt(pos + 1);
+	if (
+		_ifThreeCodePointsWouldStartANumber(
+			input,
+			pos,
+			CC_HYPHEN_MINUS,
+			second,
+			third
+		)
+	) {
 		pos--;
 		return consumeANumericToken(input, pos, out);
 	}
-	if (
-		input.charCodeAt(pos) === CC_HYPHEN_MINUS &&
-		input.charCodeAt(pos + 1) === CC_GREATER_THAN_SIGN
-	) {
+	if (second === CC_HYPHEN_MINUS && third === CC_GREATER_THAN_SIGN) {
 		return fill(out, TT_CDC, pos - 1, pos + 2);
 	}
-	if (_ifThreeCodePointsWouldStartAnIdentSequence(input, pos)) {
+	if (
+		_ifThreeCodePointsWouldStartAnIdentSequence(
+			input,
+			pos,
+			CC_HYPHEN_MINUS,
+			second,
+			third
+		)
+	) {
 		pos--;
 		return consumeAnIdentLikeToken(input, pos, out);
 	}
@@ -792,7 +875,7 @@ function consumeAUrlToken(input, pos, fnStart, out) {
 	out.contentStart = contentStart;
 	for (;;) {
 		if (pos === input.length) {
-			out.contentEnd = pos - 1;
+			out.contentEnd = pos;
 			return fill(out, TT_URL, fnStart, pos);
 		}
 		const cc = input.charCodeAt(pos);
@@ -990,7 +1073,11 @@ const HC_AT_SIGN = 9;
 const HC_REVERSE_SOLIDUS = 10;
 const HC_DIGIT = 11;
 const HC_IDENT = 12;
-const _charClass = new Uint8Array(128);
+// Full `charCodeAt` range so `consumeAToken` dispatches with one table load and
+// no `cc < 128` branch. Every non-ASCII code point (>= 0x80) is an ident-start
+// lead per §4, so those rows are seeded to `HC_IDENT`; the ASCII rows below
+// overwrite 0..127 with their real class.
+const _charClass = new Uint8Array(0x10000).fill(HC_IDENT, 128);
 const _singleTT = new Uint8Array(128);
 _singleTT[CC_LEFT_PARENTHESIS] = TT_LEFT_PARENTHESIS;
 _singleTT[CC_RIGHT_PARENTHESIS] = TT_RIGHT_PARENTHESIS;
@@ -1045,7 +1132,7 @@ for (let i = 0; i < 128; i++) {
 function consumeAToken(input, pos, cc, out) {
 	// `u` / `U` would start a unicode-range token in the spec; those are not
 	// produced, so they map to HC_IDENT and fall through to ident-like.
-	switch (cc < 128 ? _charClass[cc] : HC_IDENT) {
+	switch (_charClass[cc]) {
 		// Run of whitespace → one <whitespace-token>.
 		case HC_WHITESPACE:
 			return consumeSpace(input, pos, out);
@@ -1166,7 +1253,10 @@ const NodeType = {
 	Declaration: 23,
 	AtRule: 24,
 	QualifiedRule: 25,
-	Stylesheet: 26
+	Stylesheet: 26,
+	// Comments are never tree nodes; this type exists only so a `NodeType.Comment`
+	// visitor can be registered (fired during tokenization — see `grammar`).
+	Comment: 27
 };
 const {
 	Ident: T_IDENT,
@@ -1194,7 +1284,8 @@ const {
 	Declaration: T_DECLARATION,
 	AtRule: T_AT_RULE,
 	QualifiedRule: T_QUALIFIED_RULE,
-	Stylesheet: T_STYLESHEET
+	Stylesheet: T_STYLESHEET,
+	Comment: T_COMMENT
 } = NodeType;
 
 /**
@@ -1592,17 +1683,46 @@ _ttToNodeType[TT_CDC] = T_CDC;
 // field access differs, so only those ops are swapped.
 
 // Current loc converter for the active parse (object backend reads it).
-let _lc = /** @type {LocConverter} */ (/** @type {unknown} */ (null));
+let _objLocConverter = /** @type {LocConverter} */ (
+	/** @type {unknown} */ (null)
+);
+
+// Active skip state (from `CssProcessOptions.skip`), applied by the grammar.
+// `_skipTypes` is indexed by `NodeType` (1 = skip): drop that component-value
+// leaf / container from declaration value and function-arg lists. The two
+// prelude flags scan a rule's prelude without materializing its tree (url tokens
+// / functions kept, so `url()` in a selector or `@import url(…)` still resolves).
+// A skipped node is still tokenized (positions stay correct) but never pushed,
+// so it is never walked or read — the caller must only skip what nothing reads.
+// `useObjectBackend` restores the defaults so `parseA*` build the full tree.
+const _NO_SKIP_TYPES = new Uint8Array(32);
+// Shared frozen empty list for block bodies with no decls / no child rules (the
+// common case — most rules carry only declarations). Every consumer reads these
+// lists read-only and null-guards, so one immutable instance replaces ~one empty
+// array allocation per rule; frozen so any errant push fails loud.
+const _EMPTY_LIST = /** @type {Rule[]} */ (
+	/** @type {unknown} */ (Object.freeze([]))
+);
+/** @type {Uint8Array} */
+let _skipTypes = _NO_SKIP_TYPES;
+// Fast-path flag: true only when a real skip set is active, so the (dominant)
+// no-skip parses pay one boolean test instead of a node-type lookup per value.
+let _skipActive = false;
+let _skipSelectorPrelude = false;
+let _skipAtRulePrelude = false;
 
 /** @type {(type: number, start: number, end: number) => Node} */
-let _mkLeaf;
+let _makeLeaf;
 /** @type {(start: number, end: number, contentStart: number, contentEnd: number) => Node} */
-let _mkUrl;
+let _makeUrl;
 /** @type {(type: number, start: number, end: number) => Node} */
-let _mkContainer;
+let _makeContainer;
 /** @type {(start: number) => Node} */
-let _mkStylesheet;
-/** @type {(r: Node, v: string, nameStart: number, nameEnd: number) => void} */
+let _makeStylesheet;
+// Offsets only — the object backend derives the name string itself (an
+// at-rule's name skips its `@`), so the SoA backend never pays for a slice
+// it would immediately discard (it re-derives names from offsets on read).
+/** @type {(r: Node, nameStart: number, nameEnd: number) => void} */
 let _setName;
 /** @type {(r: Node, v: number) => void} */
 let _setEnd;
@@ -1621,170 +1741,265 @@ let _setBody;
 /** @type {(r: Node, list: Node[]) => void} */
 let _setRules;
 /** @type {(r: Node) => number} */
-let _nType;
+let _nodeTypeOf;
 /** @type {(r: Node) => number} */
-let _nStart;
+let _nodeStartOf;
 /** @type {(r: Node) => string} */
-let _nValue;
+let _nodeValueOf;
 /** @type {(r: Node) => SimpleBlockToken} */
-let _nToken;
+let _nodeTokenOf;
 
 // Child lists are plain arrays in every backend; refs are pushed by value.
-const _list = () => /** @type {Node[]} */ ([]);
+// Content-list allocation: the object backend uses a per-site `[]` literal
+// (each site keeps its own V8 allocation site — a shared helper collapses them
+// and defeats escape analysis / pretenuring), the SoA backend recycles scratch
+// arrays through a pool — a sealed list is copied into the flat value buffer
+// and its array returned to the pool by `_soaSetValue`, so the streaming parse
+// allocates no per-list array. An abandoned (never-sealed) list simply falls
+// out of the pool. `_soaActive` gates the pool at each site.
+let _soaActive = false;
+/** @type {Node[][]} */
+const _listPool = [];
+const _soaList = () =>
+	_listPool.length > 0
+		? /** @type {Node[]} */ (_listPool.pop())
+		: /** @type {Node[]} */ ([]);
 
 // -- object backend: builds the retainable class-instance tree --
-/** @type {typeof _mkLeaf} */
-const _objLeaf = (type, start, end) => new Token(type, start, end, _lc);
-/** @type {typeof _mkUrl} */
+/** @type {typeof _makeLeaf} */
+const _objLeaf = (type, start, end) =>
+	new Token(type, start, end, _objLocConverter);
+/** @type {typeof _makeUrl} */
 const _objUrl = (start, end, cs, ce) => {
-	const u = /** @type {UrlToken} */ (new Token(T_URL, start, end, _lc));
+	const u = /** @type {UrlToken} */ (
+		new Token(T_URL, start, end, _objLocConverter)
+	);
 	u.contentStart = cs;
 	u.contentEnd = ce;
 	return u;
 };
-/** @type {typeof _mkContainer} */
+/** @type {typeof _makeContainer} */
 const _objContainer = (type, start, end) =>
-	new Container(type, start, end, _lc);
-/** @type {typeof _mkStylesheet} */
+	new Container(type, start, end, _objLocConverter);
+/** @type {typeof _makeStylesheet} */
 const _objStylesheet = (start) => {
 	const s = /** @type {Stylesheet} */ (
-		new Node(T_STYLESHEET, start, start, _lc)
+		new Node(T_STYLESHEET, start, start, _objLocConverter)
 	);
 	s.rules = [];
 	return s;
 };
+// The backend function sets are module-level constants (not closures rebuilt
+// per parse): the dispatch slots keep one function identity forever, so the
+// per-node call sites in the consume algorithms stay monomorphic instead of
+// seeing a fresh closure per parse. They capture only module-level state.
+/** @type {typeof _setName} */
+const _objSetName = (r, ns, ne) => {
+	const c = /** @type {Container} */ (r);
+	// An at-rule's `nameStart` points at its `@`, which the name excludes.
+	c.name = _objLocConverter._input.slice(
+		r.type === T_AT_RULE ? ns + 1 : ns,
+		ne
+	);
+	c.nameStart = ns;
+	c.nameEnd = ne;
+};
+/** @type {typeof _setEnd} */
+const _objSetEnd = (r, v) => {
+	r.end = v;
+};
+/** @type {typeof _setBlock} */
+const _objSetBlock = (r, bs, be) => {
+	const c = /** @type {Container} */ (r);
+	c.blockStart = bs;
+	c.blockEnd = be;
+};
+/** @type {typeof _setImportant} */
+const _objSetImportant = (r) => {
+	/** @type {Container} */ (r).important = true;
+};
+/** @type {typeof _setToken} */
+const _objSetToken = (r, ch) => {
+	/** @type {Container} */ (r).token = ch;
+};
+/** @type {typeof _setValue} */
+const _objSetValue = (r, list) => {
+	/** @type {Container} */ (r).value = /** @type {ComponentValue[]} */ (list);
+};
+/** @type {typeof _setPrelude} */
+const _objSetPrelude = (r, list) => {
+	/** @type {Container} */ (r).prelude = /** @type {ComponentValue[]} */ (list);
+};
+/** @type {typeof _setBody} */
+const _objSetBody = (r, decls, childRules) => {
+	const c = /** @type {Container} */ (r);
+	c.declarations = /** @type {Declaration[]} */ (decls);
+	c.childRules = /** @type {Rule[]} */ (childRules);
+};
+/** @type {typeof _setRules} */
+const _objSetRules = (r, list) => {
+	/** @type {Stylesheet} */ (r).rules = /** @type {Rule[]} */ (list);
+};
+/** @type {typeof _nodeTypeOf} */
+const _objNodeTypeOf = (r) => r.type;
+/** @type {typeof _nodeStartOf} */
+const _objNodeStartOf = (r) => r.start;
+/** @type {typeof _nodeValueOf} */
+const _objNodeValueOf = (r) => /** @type {Token} */ (r).value;
+/** @type {typeof _nodeTokenOf} */
+const _objNodeTokenOf = (r) =>
+	/** @type {SimpleBlockToken} */ (/** @type {Container} */ (r).token);
 /** @param {LocConverter} lc loc converter for this parse */
 const useObjectBackend = (lc) => {
-	_lc = lc;
-	_mkLeaf = _objLeaf;
-	_mkUrl = _objUrl;
-	_mkContainer = _objContainer;
-	_mkStylesheet = _objStylesheet;
-	_setName = (r, v, ns, ne) => {
-		const c = /** @type {Container} */ (r);
-		c.name = v;
-		c.nameStart = ns;
-		c.nameEnd = ne;
-	};
-	_setEnd = (r, v) => {
-		r.end = v;
-	};
-	_setBlock = (r, bs, be) => {
-		const c = /** @type {Container} */ (r);
-		c.blockStart = bs;
-		c.blockEnd = be;
-	};
-	_setImportant = (r) => {
-		/** @type {Container} */ (r).important = true;
-	};
-	_setToken = (r, ch) => {
-		/** @type {Container} */ (r).token = ch;
-	};
-	_setValue = (r, list) => {
-		/** @type {Container} */ (r).value = /** @type {ComponentValue[]} */ (list);
-	};
-	_setPrelude = (r, list) => {
-		/** @type {Container} */ (r).prelude = /** @type {ComponentValue[]} */ (
-			list
-		);
-	};
-	_setBody = (r, decls, childRules) => {
-		const c = /** @type {Container} */ (r);
-		c.declarations = /** @type {Declaration[]} */ (decls);
-		c.childRules = /** @type {Rule[]} */ (childRules);
-	};
-	_setRules = (r, list) => {
-		/** @type {Stylesheet} */ (r).rules = /** @type {Rule[]} */ (list);
-	};
-	_nType = (r) => r.type;
-	_nStart = (r) => r.start;
-	_nValue = (r) => /** @type {Token} */ (r).value;
-	_nToken = (r) =>
-		/** @type {SimpleBlockToken} */ (/** @type {Container} */ (r).token);
+	_objLocConverter = lc;
+	_soaActive = false;
+	// `parseA*` return the full tree, so nothing is skipped.
+	_skipTypes = _NO_SKIP_TYPES;
+	_skipActive = false;
+	_skipSelectorPrelude = false;
+	_skipAtRulePrelude = false;
+	_makeLeaf = _objLeaf;
+	_makeUrl = _objUrl;
+	_makeContainer = _objContainer;
+	_makeStylesheet = _objStylesheet;
+	_setName = _objSetName;
+	_setEnd = _objSetEnd;
+	_setBlock = _objSetBlock;
+	_setImportant = _objSetImportant;
+	_setToken = _objSetToken;
+	_setValue = _objSetValue;
+	_setPrelude = _objSetPrelude;
+	_setBody = _objSetBody;
+	_setRules = _objSetRules;
+	_nodeTypeOf = _objNodeTypeOf;
+	_nodeStartOf = _objNodeStartOf;
+	_nodeValueOf = _objNodeValueOf;
+	_nodeTokenOf = _objNodeTokenOf;
 };
 
 // -- struct-of-arrays backend: writes nodes into reused typed arrays --
 // A node ref is its integer id; fields live in parallel arrays indexed by id.
-// Three reused int slots (`_soaA0/1/2`) plus a flags byte carry the per-type
-// extras; child lists hang off three object arrays. Slot meaning by type:
-//   url:         a0 contentStart, a1 contentEnd
-//   function:    a0 nameEnd
-//   declaration: a0 nameEnd, flags bit0 important
-//   at-rule:     a0 nameEnd, a1 blockStart, a2 blockEnd
-//   qualified:   a1 blockStart, a2 blockEnd
+// Three reused int slots (`_soaAux0/1/2`) plus a flags byte carry the per-type
+// extras; child lists hang off three object arrays. Aux slot meaning by type:
+//   url:         aux0 contentStart, aux1 contentEnd
+//   function:    aux0 nameEnd
+//   declaration: aux0 nameEnd, flags bit0 important
+//   at-rule:     aux0 nameEnd, aux1 blockStart, aux2 blockEnd
+//   qualified:   aux1 blockStart, aux2 blockEnd
 // `name` / `nameStart` / a simple block's `token` are derived from the source
-// on read (see the SoA accessors), so they need no slot. Lists: l0 =
-// value | prelude | stylesheet rules, l1 = declarations, l2 = childRules.
-// `grammar` resets `_soaN` to 0 after each top-level rule's walk, so the
+// on read (see the SoA accessors), so they need no slot. A node's main content
+// (value | prelude | stylesheet rules) is a `_soaFlat` span (see below).
+// `grammar` resets `_soaNodeCount` to 0 after each top-level rule's walk, so the
 // buffers are reused across rules and the parse allocates almost nothing.
-let _soaCap = 0;
-let _soaN = 0;
-let _soaTy = new Uint8Array(0);
-let _soaSt = new Int32Array(0);
-let _soaEn = new Int32Array(0);
-let _soaA0 = new Int32Array(0);
-let _soaA1 = new Int32Array(0);
-let _soaA2 = new Int32Array(0);
-let _soaFl = new Uint8Array(0);
-/** @type {(Node[] | null)[]} */
-const _soaL0 = [];
+let _soaCapacity = 0;
+let _soaNodeCount = 0;
+let _soaTypes = new Uint8Array(0);
+let _soaStarts = new Int32Array(0);
+let _soaEnds = new Int32Array(0);
+let _soaAux0 = new Int32Array(0);
+let _soaAux1 = new Int32Array(0);
+let _soaAux2 = new Int32Array(0);
+let _soaFlags = new Uint8Array(0);
+// Content-list spans: a container's value / prelude is `_soaFlat[start, start+len)`
+// (node refs), recycled per top-level rule like the node columns.
+let _soaListStarts = new Int32Array(0);
+let _soaListLens = new Int32Array(0);
+let _soaFlat = new Int32Array(0);
+let _soaFlatTop = 0;
+// Peak usage of the current parse, and use-once regrow hints: after an
+// over-capacity shrink the next grow jumps straight back to the previous
+// parse's peak (one exact-fit allocation instead of re-doubling up).
+let _soaPeak = 0;
+let _soaFlatPeak = 0;
+let _soaGrowHint = 0;
+let _soaFlatGrowHint = 0;
+
+/** @param {number} need minimum flat-buffer capacity */
+const _soaFlatGrow = (need) => {
+	let cap = _soaFlat.length || 4096;
+	if (_soaFlatGrowHint > cap) cap = _soaFlatGrowHint;
+	_soaFlatGrowHint = 0;
+	while (cap < need) cap *= 2;
+	const next = new Int32Array(cap);
+	next.set(_soaFlat);
+	_soaFlat = next;
+};
 /** @type {(Node[] | null)[]} */
-const _soaL1 = [];
+const _soaDeclarationLists = [];
 /** @type {(Node[] | null)[]} */
-const _soaL2 = [];
+const _soaChildRuleLists = [];
 let _soaInput = "";
-let _soaLC = /** @type {LocConverter} */ (/** @type {unknown} */ (null));
+let _soaLocConverter = /** @type {LocConverter} */ (
+	/** @type {unknown} */ (null)
+);
 
 // Node refs are integers here but typed `Node` across the parser; these are
 // identity casts that just satisfy the type system at the boundary.
 /** @type {(n: Node) => number} */
-const _ix = (n) => /** @type {number} */ (/** @type {unknown} */ (n));
+const _nodeIndex = (n) => /** @type {number} */ (/** @type {unknown} */ (n));
 /** @type {(i: number) => Node} */
-const _ref = (i) => /** @type {Node} */ (/** @type {unknown} */ (i));
+const _nodeRef = (i) => /** @type {Node} */ (/** @type {unknown} */ (i));
 
 /** @param {number} need minimum capacity */
 const _soaGrow = (need) => {
-	let cap = _soaCap || 4096;
+	let cap = _soaCapacity || 4096;
+	if (_soaGrowHint > cap) cap = _soaGrowHint;
+	_soaGrowHint = 0;
 	while (cap < need) cap *= 2;
 	const ty = new Uint8Array(cap);
-	ty.set(_soaTy);
-	_soaTy = ty;
+	ty.set(_soaTypes);
+	_soaTypes = ty;
 	const st = new Int32Array(cap);
-	st.set(_soaSt);
-	_soaSt = st;
+	st.set(_soaStarts);
+	_soaStarts = st;
 	const en = new Int32Array(cap);
-	en.set(_soaEn);
-	_soaEn = en;
+	en.set(_soaEnds);
+	_soaEnds = en;
 	const a0 = new Int32Array(cap);
-	a0.set(_soaA0);
-	_soaA0 = a0;
+	a0.set(_soaAux0);
+	_soaAux0 = a0;
 	const a1 = new Int32Array(cap);
-	a1.set(_soaA1);
-	_soaA1 = a1;
+	a1.set(_soaAux1);
+	_soaAux1 = a1;
 	const a2 = new Int32Array(cap);
-	a2.set(_soaA2);
-	_soaA2 = a2;
+	a2.set(_soaAux2);
+	_soaAux2 = a2;
 	const fl = new Uint8Array(cap);
-	fl.set(_soaFl);
-	_soaFl = fl;
-	_soaCap = cap;
+	fl.set(_soaFlags);
+	_soaFlags = fl;
+	const ls = new Int32Array(cap);
+	ls.set(_soaListStarts);
+	_soaListStarts = ls;
+	const ll = new Int32Array(cap);
+	ll.set(_soaListLens);
+	_soaListLens = ll;
+	_soaCapacity = cap;
 };
 /** @type {(type: number, start: number, end: number) => Node} */
-const _soaAlloc = (type, start, end) => {
+const _soaAllocNode = (type, start, end) => {
 	// Ids are 1-based: a node ref is used in truthiness checks (`if (!parent)`),
 	// so 0 must stay reserved for "no node".
-	const i = _soaN + 1;
-	if (i >= _soaCap) _soaGrow(i + 1);
-	_soaTy[i] = type;
-	_soaSt[i] = start;
-	_soaEn[i] = end;
-	_soaFl[i] = 0;
-	// Clear list slots so a reused id never exposes a previous node's children.
-	_soaL0[i] = null;
-	_soaL1[i] = null;
-	_soaL2[i] = null;
-	_soaN = i;
-	return _ref(i);
+	// Leaves never read the flag / list slots — `_soaAllocContainer` clears
+	// them instead, keeping the dominant leaf allocation at three writes.
+	const i = _soaNodeCount + 1;
+	if (i >= _soaCapacity) _soaGrow(i + 1);
+	_soaTypes[i] = type;
+	_soaStarts[i] = start;
+	_soaEnds[i] = end;
+	_soaNodeCount = i;
+	return _nodeRef(i);
+};
+/** @type {(type: number, start: number, end: number) => Node} */
+const _soaAllocContainer = (type, start, end) => {
+	const r = _soaAllocNode(type, start, end);
+	const i = _nodeIndex(r);
+	_soaFlags[i] = 0;
+	// Clear list slots so a reused id never exposes a previous node's children
+	// (content lists are flat spans, so zeroing the length suffices).
+	_soaListLens[i] = 0;
+	_soaDeclarationLists[i] = null;
+	_soaChildRuleLists[i] = null;
+	return r;
 };
 // Raw token value (the lazy `Token.value` form): hash / at-keyword drop their
 // one-char prefix, url uses its content range. Shared by the parser's
@@ -1794,65 +2009,107 @@ const _soaAlloc = (type, start, end) => {
  * @returns {string} raw token value
  */
 const _soaValueOf = (i) => {
-	const ty = _soaTy[i];
+	const ty = _soaTypes[i];
 	if (ty === T_HASH || ty === T_AT_KEYWORD) {
-		return _soaInput.slice(_soaSt[i] + 1, _soaEn[i]);
+		return _soaInput.slice(_soaStarts[i] + 1, _soaEnds[i]);
 	}
-	if (ty === T_URL) return _soaInput.slice(_soaA0[i], _soaA1[i]);
-	return _soaInput.slice(_soaSt[i], _soaEn[i]);
+	if (ty === T_URL) return _soaInput.slice(_soaAux0[i], _soaAux1[i]);
+	return _soaInput.slice(_soaStarts[i], _soaEnds[i]);
+};
+// Module-level constants for the same reason as the `_objSet*` set above.
+/** @type {typeof _makeUrl} */
+const _soaMakeUrl = (start, end, cs, ce) => {
+	const r = _soaAllocNode(T_URL, start, end);
+	_soaAux0[_nodeIndex(r)] = cs;
+	_soaAux1[_nodeIndex(r)] = ce;
+	return r;
+};
+/** @type {typeof _makeStylesheet} */
+const _soaMakeStylesheet = (start) =>
+	_soaAllocContainer(T_STYLESHEET, start, start);
+// name / nameStart are derived from start + nameEnd; only nameEnd is stored.
+/** @type {typeof _setName} */
+const _soaSetName = (r, ns, ne) => {
+	_soaAux0[_nodeIndex(r)] = ne;
+};
+/** @type {typeof _setEnd} */
+const _soaSetEnd = (r, v) => {
+	_soaEnds[_nodeIndex(r)] = v;
+};
+/** @type {typeof _setBlock} */
+const _soaSetBlock = (r, bs, be) => {
+	const i = _nodeIndex(r);
+	_soaAux1[i] = bs;
+	_soaAux2[i] = be;
+};
+/** @type {typeof _setImportant} */
+const _soaSetImportant = (r) => {
+	_soaFlags[_nodeIndex(r)] |= 1;
 };
+// A simple block's token is derived from its opening char on read.
+/** @type {typeof _setToken} */
+const _soaSetToken = (r, ch) => {};
+/** @type {typeof _setValue} */
+const _soaSetValue = (r, list) => {
+	// Seal the finished list: copy its refs into the flat buffer and hand the
+	// scratch array back to the pool. The caller never touches `list` again.
+	const i = _nodeIndex(r);
+	const len = list.length;
+	const start = _soaFlatTop;
+	if (start + len > _soaFlat.length) _soaFlatGrow(start + len);
+	for (let k = 0; k < len; k++) {
+		_soaFlat[start + k] = _nodeIndex(list[k]);
+	}
+	_soaFlatTop = start + len;
+	_soaListStarts[i] = start;
+	_soaListLens[i] = len;
+	list.length = 0;
+	_listPool.push(list);
+};
+/** @type {typeof _setBody} */
+const _soaSetBody = (r, decls, childRules) => {
+	const i = _nodeIndex(r);
+	_soaDeclarationLists[i] = decls;
+	_soaChildRuleLists[i] = childRules;
+};
+/** @type {typeof _nodeTypeOf} */
+const _soaNodeTypeOf = (r) => _soaTypes[_nodeIndex(r)];
+/** @type {typeof _nodeStartOf} */
+const _soaNodeStartOf = (r) => _soaStarts[_nodeIndex(r)];
+/** @type {typeof _nodeValueOf} */
+const _soaNodeValueOf = (r) => _soaValueOf(_nodeIndex(r));
+/** @type {typeof _nodeTokenOf} */
+const _soaNodeTokenOf = (r) =>
+	/** @type {SimpleBlockToken} */ (_soaInput[_soaStarts[_nodeIndex(r)]]);
 /**
  * @param {string} input source
  * @param {LocConverter} lc loc converter
  */
 const useSoaBackend = (input, lc) => {
 	_soaInput = input;
-	_soaLC = lc;
-	_soaN = 0;
-	_mkLeaf = (type, start, end) => _soaAlloc(type, start, end);
-	_mkUrl = (start, end, cs, ce) => {
-		const r = _soaAlloc(T_URL, start, end);
-		_soaA0[_ix(r)] = cs;
-		_soaA1[_ix(r)] = ce;
-		return r;
-	};
-	_mkContainer = (type, start, end) => _soaAlloc(type, start, end);
-	_mkStylesheet = (start) => _soaAlloc(T_STYLESHEET, start, start);
-	// name / nameStart are derived from start + nameEnd; only nameEnd is stored.
-	_setName = (r, v, ns, ne) => {
-		_soaA0[_ix(r)] = ne;
-	};
-	_setEnd = (r, v) => {
-		_soaEn[_ix(r)] = v;
-	};
-	_setBlock = (r, bs, be) => {
-		const i = _ix(r);
-		_soaA1[i] = bs;
-		_soaA2[i] = be;
-	};
-	_setImportant = (r) => {
-		_soaFl[_ix(r)] |= 1;
-	};
-	// A simple block's token is derived from its opening char on read.
-	_setToken = (r, ch) => {};
-	_setValue = (r, list) => {
-		_soaL0[_ix(r)] = list;
-	};
-	_setPrelude = (r, list) => {
-		_soaL0[_ix(r)] = list;
-	};
-	_setBody = (r, decls, childRules) => {
-		const i = _ix(r);
-		_soaL1[i] = decls;
-		_soaL2[i] = childRules;
-	};
-	_setRules = (r, list) => {
-		_soaL0[_ix(r)] = list;
-	};
-	_nType = (r) => _soaTy[_ix(r)];
-	_nStart = (r) => _soaSt[_ix(r)];
-	_nValue = (r) => _soaValueOf(_ix(r));
-	_nToken = (r) => /** @type {SimpleBlockToken} */ (_soaInput[_soaSt[_ix(r)]]);
+	_soaLocConverter = lc;
+	_soaNodeCount = 0;
+	_soaFlatTop = 0;
+	_soaActive = true;
+	// The alloc primitives are the slot functions directly — no wrapper hop.
+	_makeLeaf = _soaAllocNode;
+	_makeUrl = _soaMakeUrl;
+	_makeContainer = _soaAllocContainer;
+	_makeStylesheet = _soaMakeStylesheet;
+	_setName = _soaSetName;
+	_setEnd = _soaSetEnd;
+	_setBlock = _soaSetBlock;
+	_setImportant = _soaSetImportant;
+	_setToken = _soaSetToken;
+	_setValue = _soaSetValue;
+	// value / prelude / rules all land in the one content-list slot.
+	_setPrelude = _soaSetValue;
+	_setBody = _soaSetBody;
+	_setRules = _soaSetValue;
+	_nodeTypeOf = _soaNodeTypeOf;
+	_nodeStartOf = _soaNodeStartOf;
+	_nodeValueOf = _soaNodeValueOf;
+	_nodeTokenOf = _soaNodeTokenOf;
 };
 
 /**
@@ -1866,9 +2123,9 @@ const tokenToNode = (t) => {
 	// plain leaf whose node type comes from the map.
 	if (tt === TT_URL) {
 		const ut = /** @type {CssUrlToken} */ (t);
-		return _mkUrl(t.start, t.end, ut.contentStart, ut.contentEnd);
+		return _makeUrl(t.start, t.end, ut.contentStart, ut.contentEnd);
 	}
-	return _mkLeaf(_ttToNodeType[tt], t.start, t.end);
+	return _makeLeaf(_ttToNodeType[tt], t.start, t.end);
 };
 
 /**
@@ -1918,12 +2175,12 @@ class TokenStream {
 		/** @type {number} */
 		this._commentHigh = pos;
 		// Single reused token the lexer writes into on the `next` path — see
-		// `MutableToken`. `_next` points at it when a token is cached, else
-		// `undefined` (re-tokenize on next read).
+		// `MutableToken`. `_hasNext` marks it cached — a boolean instead of an
+		// object slot, so caching a token never pays a GC write barrier.
 		/** @type {MutableToken} */
 		this._tok = createToken();
-		/** @type {MutableToken | undefined} the next token, lazily tokenized */
-		this._next = undefined;
+		/** @type {boolean} whether `_tok` holds the (lazily tokenized) next token */
+		this._hasNext = false;
 		/** @type {number[]} byte offsets to rewind to */
 		this._marks = [];
 	}
@@ -1937,14 +2194,14 @@ class TokenStream {
 	 * @returns {MutableToken} the next token
 	 */
 	next() {
-		if (this._next === undefined) {
+		if (!this._hasNext) {
 			const input = this.input;
 			const tok = this._tok;
 			let pos = this._pos;
 			for (;;) {
 				const t = readToken(input, pos, tok);
 				if (t === undefined) {
-					this._next = fill(tok, TT_EOF, input.length, input.length);
+					fill(tok, TT_EOF, input.length, input.length);
 					break;
 				}
 				if (t.type === TT_COMMENT) {
@@ -1955,11 +2212,11 @@ class TokenStream {
 					pos = t.end;
 					continue;
 				}
-				this._next = t;
 				break;
 			}
+			this._hasNext = true;
 		}
-		return /** @type {MutableToken} */ (this._next);
+		return this._tok;
 	}
 
 	/**
@@ -1972,7 +2229,7 @@ class TokenStream {
 		const t = this.next();
 		if (t.type !== TT_EOF) {
 			this._pos = t.end;
-			this._next = undefined;
+			this._hasNext = false;
 		}
 		return t;
 	}
@@ -1986,7 +2243,7 @@ class TokenStream {
 		const t = this.next();
 		if (t.type !== TT_EOF) {
 			this._pos = t.end;
-			this._next = undefined;
+			this._hasNext = false;
 		}
 	}
 
@@ -2006,7 +2263,7 @@ class TokenStream {
 	 */
 	restoreMark() {
 		this._pos = /** @type {number} */ (this._marks.pop());
-		this._next = undefined;
+		this._hasNext = false;
 	}
 
 	/**
@@ -2045,7 +2302,7 @@ const normalizeIntoTokenStream = (input, pos, onComment) =>
 // algorithms that drive the tokenizer.
 
 /**
- * @typedef {object} ParseListOptions
+ * @typedef {object} ParseOptions
  * @property {((input: string, start: number, end: number) => number)=} comment optional comment-token callback; the public `parse*` entry points use it to build the `TokenStream` so the outer parser's comment tracker still sees magic comments inside the consumed range
  */
 
@@ -2053,17 +2310,18 @@ const normalizeIntoTokenStream = (input, pos, onComment) =>
  * Parse a stylesheet, CSS Syntax Level 3
  * [§5.3.4](https://drafts.csswg.org/css-syntax/#parse-stylesheet).
  * @param {string | TokenStream} input source string or an existing token stream
- * @param {((input: string, start: number, end: number) => number)=} comment optional comment-token callback (string input only)
+ * @param {number=} pos start position (string input only)
+ * @param {ParseOptions=} options optional comment-token callback (string input only)
  * @returns {Stylesheet} the parsed stylesheet
  */
-const parseAStylesheet = (input, comment) => {
+const parseAStylesheet = (input, pos = 0, options = {}) => {
 	// 1. If input is a byte stream for a stylesheet, decode bytes from input, and set input to the result.
 	// 2. Normalize input, and set input to the result.
-	const ts = normalizeIntoTokenStream(input, 0, comment);
+	const ts = normalizeIntoTokenStream(input, pos, options.comment);
 	useObjectBackend(ts.locConverter);
 	// 3. Create a new stylesheet, with its location set to location (or null, if location was not passed).
 	const start = ts.next().start;
-	const stylesheet = /** @type {Stylesheet} */ (_mkStylesheet(start));
+	const stylesheet = /** @type {Stylesheet} */ (_makeStylesheet(start));
 	// 4. Consume a stylesheet's contents from input, and set the stylesheet's rules to the result.
 	_setRules(stylesheet, consumeAStylesheetsContents(ts));
 	_setEnd(stylesheet, ts.next().start);
@@ -2078,12 +2336,13 @@ const parseAStylesheet = (input, comment) => {
  * declarations are parse errors (never produced) and top-level CDO (`<!--`) /
  * CDC (`-->`) tokens are discarded.
  * @param {string | TokenStream} input source string or an existing token stream
- * @param {((input: string, start: number, end: number) => number)=} comment optional comment-token callback (string input only)
+ * @param {number=} pos start position (string input only)
+ * @param {ParseOptions=} options optional comment-token callback (string input only)
  * @returns {Rule[]} top-level rules
  */
-const parseAStylesheetsContents = (input, comment) => {
+const parseAStylesheetsContents = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
-	const ts = normalizeIntoTokenStream(input, 0, comment);
+	const ts = normalizeIntoTokenStream(input, pos, options.comment);
 	useObjectBackend(ts.locConverter);
 	// 2. Consume a stylesheet’s contents from input, and return the result.
 	return consumeAStylesheetsContents(ts);
@@ -2094,12 +2353,12 @@ const parseAStylesheetsContents = (input, comment) => {
  * [§5.3.6](https://drafts.csswg.org/css-syntax/#parse-block-contents).
  * @param {string | TokenStream} input source string or an existing token stream
  * @param {number=} pos start position (string input only; just past the opening `{`, or 0)
- * @param {((input: string, start: number, end: number) => number)=} comment optional comment-token callback (string input only)
+ * @param {ParseOptions=} options optional comment-token callback (string input only)
  * @returns {{ decls: Declaration[], rules: Rule[] }} block decls + rules
  */
-const parseABlocksContents = (input, pos, comment) => {
+const parseABlocksContents = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
-	const ts = normalizeIntoTokenStream(input, pos, comment);
+	const ts = normalizeIntoTokenStream(input, pos, options.comment);
 	useObjectBackend(ts.locConverter);
 	// 2. Consume a block’s contents from input, and return the result.
 	return consumeABlocksContents(ts);
@@ -2112,12 +2371,12 @@ const parseABlocksContents = (input, pos, comment) => {
  * whitespace; `undefined` (syntax error) otherwise.
  * @param {string | TokenStream} input source string or an existing token stream
  * @param {number=} pos start position (string input only)
- * @param {((input: string, start: number, end: number) => number)=} comment optional comment-token callback (string input only)
+ * @param {ParseOptions=} options optional comment-token callback (string input only)
  * @returns {Rule | undefined} the parsed rule
  */
-const parseARule = (input, pos, comment) => {
+const parseARule = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
-	const ts = normalizeIntoTokenStream(input, pos, comment);
+	const ts = normalizeIntoTokenStream(input, pos, options.comment);
 	useObjectBackend(ts.locConverter);
 	// 2. Discard whitespace from input.
 	while (ts.next().type === TT_WHITESPACE) ts.discard();
@@ -2143,12 +2402,12 @@ const parseARule = (input, pos, comment) => {
  * [§5.3.8](https://drafts.csswg.org/css-syntax/#parse-declaration).
  * @param {string | TokenStream} input source string or an existing token stream
  * @param {number=} pos start position (string input only)
- * @param {((input: string, start: number, end: number) => number)=} comment optional comment-token callback (string input only)
+ * @param {ParseOptions=} options optional comment-token callback (string input only)
  * @returns {Declaration | undefined} the parsed declaration, or undefined
  */
-const parseADeclaration = (input, pos, comment) => {
+const parseADeclaration = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
-	const ts = normalizeIntoTokenStream(input, pos, comment);
+	const ts = normalizeIntoTokenStream(input, pos, options.comment);
 	useObjectBackend(ts.locConverter);
 	// 2. Discard whitespace from input.
 	while (ts.next().type === TT_WHITESPACE) ts.discard();
@@ -2160,10 +2419,10 @@ const parseADeclaration = (input, pos, comment) => {
  * Parse a component value, CSS Syntax Level 3 [§5.3.9](https://drafts.csswg.org/css-syntax/#parse-component-value) — strict entry point that consumes one value and returns `undefined` if non-whitespace input trails (use `consumeAComponentValue` for "one value, ignore the rest").
  * @param {string | TokenStream} input source string or an existing token stream
  * @param {number=} pos start position (string input only)
- * @param {{ comment?: (input: string, start: number, end: number) => number }=} options optional comment-token callback (string input only)
+ * @param {ParseOptions=} options optional comment-token callback (string input only)
  * @returns {ComponentValue | undefined} the parsed component value, or `undefined` on empty / trailing-garbage input
  */
-const parseAComponentValue = (input, pos, options = {}) => {
+const parseAComponentValue = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
 	useObjectBackend(ts.locConverter);
@@ -2185,27 +2444,28 @@ const parseAComponentValue = (input, pos, options = {}) => {
  * [§5.3.10](https://drafts.csswg.org/css-syntax/#parse-list-of-components).
  * @param {string | TokenStream} input source string or an existing token stream
  * @param {number=} pos start position (string input only)
- * @param {ParseListOptions=} options comment callback
+ * @param {ParseOptions=} options comment callback
  * @returns {ComponentValue[]} component values
  */
-const parseAListOfComponentValues = (input, pos, options = {}) => {
+const parseAListOfComponentValues = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
 	useObjectBackend(ts.locConverter);
 	// 2. Consume a list of component values from input, and return the result.
-	return consumeAListOfComponentValues(ts);
+	// (`null` needs `bailOnCurly`, which is not passed here.)
+	return /** @type {ComponentValue[]} */ (consumeAListOfComponentValues(ts));
 };
 
 /**
  * Parse a comma-separated list of component values, CSS Syntax Level 3 [§5.3.11](https://drafts.csswg.org/css-syntax/#parse-comma-list) — consumes one `<comma-token>`-stopped group of component values per iteration until EOF.
  * @param {string | TokenStream} input source string or an existing token stream
  * @param {number=} pos start position (string input only)
- * @param {ParseListOptions=} options comment callback
+ * @param {ParseOptions=} options comment callback
  * @returns {ComponentValue[][]} comma-separated groups of component values
  */
 const parseACommaSeparatedListOfComponentValues = (
 	input,
-	pos,
+	pos = 0,
 	options = {}
 ) => {
 	// 1. Normalize input, and set input to the result.
@@ -2217,7 +2477,11 @@ const parseACommaSeparatedListOfComponentValues = (
 	// 3. While input is not empty:
 	while (ts.next().type !== TT_EOF) {
 		// 3.1. Consume a list of component values from input, with <comma-token> as the stop token, and append the result to groups.
-		groups.push(consumeAListOfComponentValues(ts, TT_COMMA));
+		groups.push(
+			/** @type {ComponentValue[]} */ (
+				consumeAListOfComponentValues(ts, TT_COMMA)
+			)
+		);
 		// 3.2 Discard a token from input.
 		ts.discard();
 	}
@@ -2292,19 +2556,20 @@ const consumeAnAtRule = (ts, nested = false) => {
 	// Consume a token from input, and let rule be a new at-rule with its name set to the returned token’s value, its prelude initially set to an empty list, and no declarations or child rules.
 	const head = ts.consume();
 	const rule = /** @type {AtRule} */ (
-		_mkContainer(T_AT_RULE, head.start, head.end)
-	);
-	_setName(
-		rule,
-		ts.input.slice(head.start + 1, head.end),
-		head.start,
-		head.end
+		_makeContainer(T_AT_RULE, head.start, head.end)
 	);
-	const prelude = _list();
-	_setPrelude(rule, prelude);
+	_setName(rule, head.start, head.end);
+	// Sealed (`_setPrelude`) at each return — the SoA backend consumes the
+	// scratch array when sealing, so it must be complete by then.
+	const prelude = _soaActive ? _soaList() : [];
 	// declarations / childRules / blockStart (-1) / blockEnd (-1) keep their
 	// defaults (no block: the `;` / EOF / nested-`}` at-rule forms).
 
+	// Like `consumeAQualifiedRule`: skip mode scans the prelude without
+	// materializing it (url tokens / functions kept so `@import url(…)` still
+	// resolves); the block boundary is found by scanning, not the prelude nodes.
+	const skip = _skipAtRulePrelude;
+
 	// Process input
 	for (;;) {
 		const t = ts.next();
@@ -2314,6 +2579,7 @@ const consumeAnAtRule = (ts, nested = false) => {
 		// Discard a token from input. If rule is valid in the current context, return it; otherwise return nothing.
 		if (t.type === TT_SEMICOLON || t.type === TT_EOF) {
 			ts.discard();
+			_setPrelude(rule, prelude);
 			_setEnd(rule, t.start);
 			return rule;
 		}
@@ -2322,15 +2588,18 @@ const consumeAnAtRule = (ts, nested = false) => {
 		// Otherwise, consume a token and append the result to rule’s prelude.
 		else if (t.type === TT_RIGHT_CURLY_BRACKET) {
 			if (nested) {
+				_setPrelude(rule, prelude);
 				_setEnd(rule, t.start);
 				return rule;
 			}
-			prelude.push(consumeATokenAsNode(ts));
+			const node = consumeATokenAsNode(ts);
+			if (!skip) prelude.push(node);
 			continue;
 		}
 		// <{-token>
 		// Consume a block from input, and assign the result to rule's declarations and child rules.
 		else if (t.type === TT_LEFT_CURLY_BRACKET) {
+			_setPrelude(rule, prelude);
 			const block = consumeABlock(ts);
 			_setBody(rule, block.decls, block.rules);
 			_setBlock(rule, block.blockStart, block.blockEnd);
@@ -2340,7 +2609,15 @@ const consumeAnAtRule = (ts, nested = false) => {
 
 		// anything else
 		// Consume a component value from input and append the returned value to rule’s prelude.
-		prelude.push(consumeAComponentValue(ts, t));
+		const node = consumeAComponentValue(ts, t);
+		if (!skip) {
+			prelude.push(node);
+		} else if (
+			_nodeTypeOf(node) === T_FUNCTION ||
+			_nodeTypeOf(node) === T_URL
+		) {
+			prelude.push(node);
+		}
 	}
 };
 
@@ -2369,13 +2646,21 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 	const start = ts.next().start;
 	// Let rule be a new qualified rule with its prelude, declarations, and child rules all initially set to empty lists.
 	const rule = /** @type {QualifiedRule} */ (
-		_mkContainer(T_QUALIFIED_RULE, start, start)
+		_makeContainer(T_QUALIFIED_RULE, start, start)
 	);
-	const prelude = _list();
-	_setPrelude(rule, prelude);
+	// Sealed (`_setPrelude`) at the `{` exit — the only path that returns the
+	// rule; the parse-error exits abandon the scratch unsealed.
+	const prelude = _soaActive ? _soaList() : [];
 	// declarations / childRules / blockStart (-1) / blockEnd (-1) keep their
 	// defaults (no block until a `{` is reached).
 
+	// Skip mode leaves `prelude` empty (selector text is recovered from the
+	// rule's byte range, not its nodes); `first`/`second` still track the first
+	// two non-whitespace tokens the `--foo: {` disambiguation below needs.
+	const skip = _skipSelectorPrelude;
+	let first = /** @type {Node} */ (/** @type {unknown} */ (0));
+	let second = /** @type {Node} */ (/** @type {unknown} */ (0));
+
 	// Process input
 	for (;;) {
 		const t = ts.next();
@@ -2389,7 +2674,13 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 		// This is a parse error. If nested is true, return nothing. Otherwise, consume a token and append the result to rule’s prelude.
 		else if (t.type === TT_RIGHT_CURLY_BRACKET) {
 			if (nested) return undefined;
-			prelude.push(consumeATokenAsNode(ts));
+			const node = consumeATokenAsNode(ts);
+			if (skip) {
+				if (!first) first = node;
+				else if (!second) second = node;
+			} else {
+				prelude.push(node);
+			}
 			continue;
 		}
 		// <{-token>
@@ -2399,31 +2690,33 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 		// (This disambiguates custom-property declarations from nested qualified rules — `--foo: { … }` at top level of a block is a declaration, not a rule.)
 		// Otherwise, consume a block from input, and let child rules be the result.
 		else if (t.type === TT_LEFT_CURLY_BRACKET) {
-			let firstIdx = 0;
-			/* istanbul ignore next -- @preserve: leading whitespace is discarded before the rule, so the prelude never starts with it */
-			while (
-				firstIdx < prelude.length &&
-				_nType(prelude[firstIdx]) === T_WHITESPACE
-			) {
-				firstIdx++;
-			}
-			let secondIdx = firstIdx + 1;
-			while (
-				secondIdx < prelude.length &&
-				_nType(prelude[secondIdx]) === T_WHITESPACE
-			) {
-				secondIdx++;
+			if (!skip) {
+				let firstIdx = 0;
+				/* istanbul ignore next -- @preserve: leading whitespace is discarded before the rule, so the prelude never starts with it */
+				while (
+					firstIdx < prelude.length &&
+					_nodeTypeOf(prelude[firstIdx]) === T_WHITESPACE
+				) {
+					firstIdx++;
+				}
+				let secondIdx = firstIdx + 1;
+				while (
+					secondIdx < prelude.length &&
+					_nodeTypeOf(prelude[secondIdx]) === T_WHITESPACE
+				) {
+					secondIdx++;
+				}
+				first = prelude[firstIdx];
+				second = prelude[secondIdx];
 			}
-			const first = prelude[firstIdx];
-			const second = prelude[secondIdx];
 			if (
 				first &&
-				_nType(first) === T_IDENT &&
+				_nodeTypeOf(first) === T_IDENT &&
 				// Test the source bytes directly — avoids forcing the lazy `value`
 				// slice just to check the `--` custom-property prefix.
-				ts.input.startsWith("--", _nStart(first)) &&
+				ts.input.startsWith("--", _nodeStartOf(first)) &&
 				second &&
-				_nType(second) === T_COLON
+				_nodeTypeOf(second) === T_COLON
 			) {
 				/* istanbul ignore if -- @preserve: when nested, `declarationStartLikely` routes every `--x:` to consumeADeclaration (which accepts custom properties), so this fallthrough is unreachable */
 				if (nested) {
@@ -2433,6 +2726,7 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 				}
 				return undefined;
 			}
+			_setPrelude(rule, prelude);
 			const block = consumeABlock(ts);
 			_setBody(rule, block.decls, block.rules);
 			_setBlock(rule, block.blockStart, block.blockEnd);
@@ -2442,7 +2736,21 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 
 		// anything else
 		// Consume a component value from input and append the result to rule’s prelude.
-		prelude.push(consumeAComponentValue(ts, t));
+		const node = consumeAComponentValue(ts, t);
+		if (skip) {
+			// Keep only url-bearing nodes (url tokens, or functions that may hold a
+			// url like `:unknown(url(x))`) so the url visitor still rewrites them;
+			// other selector tokens have no non-modules consumer, so drop them.
+			const ty = _nodeTypeOf(node);
+			if (ty === T_FUNCTION || ty === T_URL) prelude.push(node);
+			// Track the first two non-whitespace tokens for the disambiguation above.
+			if (t.type !== TT_WHITESPACE) {
+				if (!first) first = node;
+				else if (!second) second = node;
+			}
+		} else {
+			prelude.push(node);
+		}
 	}
 };
 
@@ -2466,7 +2774,8 @@ const consumeABlock = (ts) => {
 };
 
 /**
- * 2-token lookahead: is the next non-whitespace pair `<ident> <colon>` (the prerequisite for consume-a-declaration steps 1 + 3)? Used by `consumeABlocksContents` to skip a declaration attempt that would otherwise call consume-the-remnants-of-a-bad-declaration and be undone by `restoreMark`. A webpack fast-path, not a spec algorithm — so the implementation is free to peek cheaply. It scans raw code points after the cached ident for the next significant one (skipping whitespace + comments) rather than tokenizing them, and never advances the stream: the ident stays cached in `_next` for `consumeADeclaration` to reuse instead of re-tokenizing the property name. Comments skipped here fire `onComment` later, when the chosen consume algorithm tokenizes past them (once, in source order, as before).
+ * 2-token lookahead: is the next non-whitespace pair `<ident> <colon>`?
+ * Peeks raw code points without advancing; comments still fire `onComment` later.
  * @param {TokenStream} ts token stream
  * @returns {boolean} true if consume-a-declaration's step 1 + step 3 would both succeed on the current input
  */
@@ -2517,8 +2826,12 @@ const declarationStartLikely = (ts) => {
 const consumeABlocksContents = (ts, onNode) => {
 	/** @type {Declaration[]} */
 	const decls = [];
-	/** @type {Rule[]} */
-	const rules = [];
+	// Child rules are the common empty case (most rules carry only declarations),
+	// so `rules` is allocated lazily and returned as the shared frozen
+	// `_EMPTY_LIST` when nothing was appended — one fewer array per rule. `decls`
+	// stays eager so the hot declaration append keeps a branch-free `push`.
+	/** @type {Rule[] | null} */
+	let rules = null;
 
 	// Process input:
 	for (;;) {
@@ -2532,7 +2845,7 @@ const consumeABlocksContents = (ts, onNode) => {
 		// <EOF-token> / <}-token>
 		// Return decls and rules.
 		else if (t.type === TT_EOF || t.type === TT_RIGHT_CURLY_BRACKET) {
-			return { decls, rules };
+			return { decls, rules: rules || _EMPTY_LIST };
 		}
 		// <at-keyword-token>
 		// Consume an at-rule from input, with nested set to true. If a rule was returned, append it to rules.
@@ -2540,7 +2853,7 @@ const consumeABlocksContents = (ts, onNode) => {
 			const atRule = consumeAnAtRule(ts, true);
 			if (atRule) {
 				if (onNode) onNode(atRule);
-				else rules.push(atRule);
+				else (rules || (rules = [])).push(atRule);
 			}
 		}
 		// anything else
@@ -2563,7 +2876,7 @@ const consumeABlocksContents = (ts, onNode) => {
 			const rule = consumeAQualifiedRule(ts, TT_SEMICOLON, true);
 			if (rule) {
 				if (onNode) onNode(rule);
-				else rules.push(rule);
+				else (rules || (rules = [])).push(rule);
 			}
 		}
 	}
@@ -2611,14 +2924,14 @@ const consumeADeclaration = (ts, nested = false) => {
 	// name "" / nameStart / nameEnd (= start) / important (false) keep their
 	// `Container` defaults; `value` is set unconditionally at step 5 below.
 	const decl = /** @type {Declaration} */ (
-		_mkContainer(T_DECLARATION, start, start)
+		_makeContainer(T_DECLARATION, start, start)
 	);
 
 	// 1. If the next token is an <ident-token>, consume a token from input and set decl's name to the returned token's value.
 	// Otherwise, consume the remnants of a bad declaration from input, with nested, and return nothing.
 	if (ts.next().type === TT_IDENTIFIER) {
 		const head = ts.consume();
-		_setName(decl, input.slice(head.start, head.end), head.start, head.end);
+		_setName(decl, head.start, head.end);
 	} else {
 		consumeTheRemnantsOfABadDeclaration(ts, nested);
 		return undefined;
@@ -2639,23 +2952,39 @@ const consumeADeclaration = (ts, nested = false) => {
 	// 4. Discard whitespace from input.
 	while (ts.next().type === TT_WHITESPACE) ts.discard();
 
+	// Step 8's custom-property test, computed early so the value parse can bail.
+	const isCustomProperty = input.startsWith("--", start);
+
 	// 5. Consume a list of component values from input, with nested, and with <semicolon-token> as the stop token, and set decl's value to the result.
-	const value = consumeAListOfComponentValues(ts, TT_SEMICOLON, nested);
-	_setValue(decl, value);
+	//    A nested non-custom declaration bails on a top-level `{` — step 8 would
+	//    reject it and the caller restores its mark, so parsing the block (the
+	//    entire nested-rule body, re-parsed as a qualified rule after the
+	//    restore) would be pure waste.
+	const value = consumeAListOfComponentValues(
+		ts,
+		TT_SEMICOLON,
+		nested,
+		nested && !isCustomProperty
+	);
+	if (value === null) return undefined;
+	// `_setValue` waits until step 9: steps 6-8 still trim / scan the scratch,
+	// and the SoA backend consumes it when sealing.
 	_setEnd(decl, ts.next().start);
 
 	// 6. If the last two non-<whitespace-token>s in decl's value are a <delim-token> with the value "!" followed by an <ident-token> with a value that is an ASCII case-insensitive match for "important", remove them from decl's value and set decl's important flag.
 	{
 		let last = value.length - 1;
-		while (last >= 0 && _nType(value[last]) === T_WHITESPACE) last--;
+		while (last >= 0 && _nodeTypeOf(value[last]) === T_WHITESPACE) last--;
 		let prev = last - 1;
-		while (prev >= 0 && _nType(value[prev]) === T_WHITESPACE) prev--;
+		while (prev >= 0 && _nodeTypeOf(value[prev]) === T_WHITESPACE) prev--;
+		// `!` delim first: it's almost always absent, and `_nodeValueOf` allocates
+		// a slice — this order pays it only for genuine `!important` candidates.
 		if (
 			prev >= 0 &&
-			_nType(value[last]) === T_IDENT &&
-			equalsLowerCase(_nValue(value[last]), "important") &&
-			_nType(value[prev]) === T_DELIM &&
-			input.charCodeAt(_nStart(value[prev])) === CC_EXCLAMATION
+			_nodeTypeOf(value[prev]) === T_DELIM &&
+			input.charCodeAt(_nodeStartOf(value[prev])) === CC_EXCLAMATION &&
+			_nodeTypeOf(value[last]) === T_IDENT &&
+			equalsLowerCase(_nodeValueOf(value[last]), "important")
 		) {
 			_setImportant(decl);
 			value.length = prev;
@@ -2663,7 +2992,10 @@ const consumeADeclaration = (ts, nested = false) => {
 	}
 
 	// 7. While the last item in decl's value is a <whitespace-token>, remove that token.
-	while (value.length > 0 && _nType(value[value.length - 1]) === T_WHITESPACE) {
+	while (
+		value.length > 0 &&
+		_nodeTypeOf(value[value.length - 1]) === T_WHITESPACE
+	) {
 		value.pop();
 	}
 
@@ -2671,17 +3003,17 @@ const consumeADeclaration = (ts, nested = false) => {
 	//    Otherwise, if decl's value contains a top-level simple block with an associated token of <{-token>, return nothing.
 	//    (That is, a top-level {}-block is only allowed as the entire value of a non-custom property — for CSS Nesting, `consumeABlocksContents`'s `mark` / `restore a mark` will retry the input as a qualified rule.)
 	//    Otherwise, accept the declaration. (The spec also checks "contains any non-whitespace-tokens at the top level" → return nothing; we keep empty-value declarations because callers — e.g. `@value name:;` — rely on them.)
-	const isCustomProperty = input.startsWith("--", start);
 	if (!isCustomProperty) {
 		for (let i = 0; i < value.length; i++) {
 			const v = value[i];
-			if (_nType(v) === T_SIMPLE_BLOCK && _nToken(v) === "{") {
+			if (_nodeTypeOf(v) === T_SIMPLE_BLOCK && _nodeTokenOf(v) === "{") {
 				return undefined;
 			}
 		}
 	}
 
 	// 9. Return decl.
+	_setValue(decl, value);
 	return decl;
 };
 
@@ -2690,11 +3022,16 @@ const consumeADeclaration = (ts, nested = false) => {
  * @param {TokenStream} ts token stream
  * @param {number=} stopToken token type that terminates the list (left unconsumed)
  * @param {boolean=} nested true inside a `{}` block — a top-level `}` ends the list (left unconsumed)
- * @returns {ComponentValue[]} consumed component values
- */
-const consumeAListOfComponentValues = (ts, stopToken, nested = false) => {
-	/** @type {ComponentValue[]} */
-	const values = [];
+ * @param {boolean=} bailOnCurly abort with `null` on a top-level `{` (left unconsumed) — for callers that would reject the list anyway (consume-a-declaration step 8) and restore a mark
+ * @returns {ComponentValue[] | null} consumed component values, or `null` when `bailOnCurly` hit
+ */
+const consumeAListOfComponentValues = (
+	ts,
+	stopToken,
+	nested = false,
+	bailOnCurly = false
+) => {
+	const values = /** @type {ComponentValue[]} */ (_soaActive ? _soaList() : []);
 	// Process input
 	for (;;) {
 		const t = ts.next();
@@ -2710,12 +3047,33 @@ const consumeAListOfComponentValues = (ts, stopToken, nested = false) => {
 		// Otherwise, this is a parse error. Consume a token from input and append the result to values.
 		if (t.type === TT_RIGHT_CURLY_BRACKET) {
 			if (nested) return values;
-			values.push(consumeATokenAsNode(ts));
+			const closer = consumeATokenAsNode(ts);
+			// Keep unless the type is explicitly marked skip (1); an out-of-range
+			// lookup on a short `skip.types` yields `undefined`, which must not drop.
+			if (!_skipActive || _skipTypes[_nodeTypeOf(closer)] !== 1) {
+				values.push(closer);
+			}
 			continue;
 		}
+		// A top-level `{` dooms the list for a bailing caller — stop before the
+		// whole block is parsed only to be thrown away on the caller's restore.
+		if (bailOnCurly && t.type === TT_LEFT_CURLY_BRACKET) return null;
 		// anything else
 		// Consume a component value from input, and append the result to values.
-		values.push(consumeAComponentValue(ts, t));
+		// Skipped leaf types short-circuit before materializing: no SoA slot is
+		// written and no node is built (blocks / functions never skip here).
+		const tt = t.type;
+		if (
+			_skipActive &&
+			tt !== TT_FUNCTION &&
+			!(tt >= TT_LEFT_PARENTHESIS && tt <= TT_LEFT_CURLY_BRACKET) &&
+			_skipTypes[_ttToNodeType[tt]] === 1
+		) {
+			ts.consume();
+			continue;
+		}
+		const node = consumeAComponentValue(ts, t);
+		if (!_skipActive || _skipTypes[_nodeTypeOf(node)] !== 1) values.push(node);
 	}
 };
 
@@ -2761,11 +3119,11 @@ const consumeASimpleBlock = (ts) => {
 
 	// Let block be a new simple block with its associated token set to the next token and with its value initially set to an empty list.
 	const block = /** @type {SimpleBlock} */ (
-		_mkContainer(T_SIMPLE_BLOCK, open.start, open.end)
+		_makeContainer(T_SIMPLE_BLOCK, open.start, open.end)
 	);
 	_setToken(block, token);
-	const val = _list();
-	_setValue(block, val);
+	// Sealed (`_setValue`) at the return, once complete.
+	const val = _soaActive ? _soaList() : [];
 
 	// Discard a token from input.
 	ts.discard();
@@ -2779,6 +3137,7 @@ const consumeASimpleBlock = (ts) => {
 		// Discard a token from input. Return block.
 		if (t.type === TT_EOF || t.type === ending) {
 			ts.discard();
+			_setValue(block, val);
 			_setEnd(block, t.end);
 			return block;
 		}
@@ -2795,16 +3154,15 @@ const consumeASimpleBlock = (ts) => {
  * @returns {FunctionNode | undefined} the consumed function node
  */
 const consumeAFunction = (ts) => {
-	const { input } = ts;
 	// Assert (spec): the next token is a <function-token>.
 	// Consume a token from input, and let function be a new function with its name equal the returned token’s value, and a value set to an empty list.
 	const tFn = ts.consume();
 	const fn = /** @type {FunctionNode} */ (
-		_mkContainer(T_FUNCTION, tFn.start, tFn.end)
+		_makeContainer(T_FUNCTION, tFn.start, tFn.end)
 	);
-	_setName(fn, input.slice(tFn.start, tFn.end - 1), tFn.start, tFn.end - 1);
-	const val = _list();
-	_setValue(fn, val);
+	_setName(fn, tFn.start, tFn.end - 1);
+	// Sealed (`_setValue`) at the return, once complete.
+	const val = _soaActive ? _soaList() : [];
 
 	// Process input
 	for (;;) {
@@ -2815,13 +3173,26 @@ const consumeAFunction = (ts) => {
 			// <)-token>
 			// Discard a token from input. Return function.
 			ts.discard();
+			_setValue(fn, val);
 			_setEnd(fn, t.end);
 			return fn;
 		}
 
 		// anything else
 		// Consume a component value from input and append the result to function’s value.
-		val.push(consumeAComponentValue(ts, t));
+		// Same pre-materialization skip as `consumeAListOfComponentValues`.
+		const tt = t.type;
+		if (
+			_skipActive &&
+			tt !== TT_FUNCTION &&
+			!(tt >= TT_LEFT_PARENTHESIS && tt <= TT_LEFT_CURLY_BRACKET) &&
+			_skipTypes[_ttToNodeType[tt]] === 1
+		) {
+			ts.consume();
+			continue;
+		}
+		const node = consumeAComponentValue(ts, t);
+		if (!_skipActive || _skipTypes[_nodeTypeOf(node)] !== 1) val.push(node);
 	}
 };
 
@@ -2879,13 +3250,18 @@ const _escapeIdentifier = (str) => {
 	}
 	output = lastFlush === 0 ? str : output + str.slice(lastFlush);
 
-	const firstChar = str.charAt(0);
-
-	if (/^-[-\d]/.test(output)) {
+	// `-` and digits are class 0 (never escaped above), so testing `str`'s lead
+	// char codes is equivalent to regexes over `output` — and keeps the common
+	// nothing-to-do call regex-free.
+	const first = str.charCodeAt(0);
+	if (
+		first === CC_HYPHEN_MINUS &&
+		(str.charCodeAt(1) === CC_HYPHEN_MINUS || _isDigit(str.charCodeAt(1)))
+	) {
 		output = `\\-${output.slice(1)}`;
-	} else if (/\d/.test(firstChar)) {
+	} else if (_isDigit(first)) {
 		// A leading digit becomes `\3<digit> `, another `\HEX ` run to clean up.
-		output = `\\3${firstChar} ${output.slice(1)}`;
+		output = `\\3${str.charAt(0)} ${output.slice(1)}`;
 		needSpaceFix = true;
 	}
 
@@ -2919,7 +3295,6 @@ const _escapeIdentifier = (str) => {
  */
 const gobbleHex = (str, start) => {
 	let hex = "";
-	let spaceTerminated = false;
 
 	for (let i = 0; i < 6; i++) {
 		const code = str.charCodeAt(start + i);
@@ -2928,8 +3303,6 @@ const gobbleHex = (str, start) => {
 			(code >= 48 && code <= 57) ||
 			(code >= 65 && code <= 70) ||
 			(code >= 97 && code <= 102);
-		// https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
-		spaceTerminated = code === 32;
 		if (!valid) break;
 		// parseInt below is case-insensitive, so keep the original char.
 		hex += str[start + i];
@@ -2937,6 +3310,16 @@ const gobbleHex = (str, start) => {
 
 	if (hex.length === 0) return undefined;
 
+	// One trailing whitespace terminates the escape, matching the tokenizer's
+	// `_consumeAnEscapedCodePoint` — including after a full 6-digit escape, for
+	// any CSS whitespace (not just space), plus the extra LF of a CRLF pair.
+	// https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
+	let consumed = hex.length;
+	const trail = str.charCodeAt(start + hex.length);
+	if (_isWhiteSpace(trail)) {
+		consumed = consumeExtraNewline(trail, str, start + hex.length + 1) - start;
+	}
+
 	const codePoint = Number.parseInt(hex, 16);
 	const isSurrogate = codePoint >= 0xd800 && codePoint <= 0xdfff;
 
@@ -2944,13 +3327,10 @@ const gobbleHex = (str, start) => {
 	// "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point"
 	// https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point
 	if (isSurrogate || codePoint === 0x0000 || codePoint > 0x10ffff) {
-		return ["�", hex.length + (spaceTerminated ? 1 : 0)];
+		return ["�", consumed];
 	}
 
-	return [
-		String.fromCodePoint(codePoint),
-		hex.length + (spaceTerminated ? 1 : 0)
-	];
+	return [String.fromCodePoint(codePoint), consumed];
 };
 
 /**
@@ -2996,14 +3376,74 @@ const _unescapeIdentifier = (str) => {
 const escapeIdentifier = makeCacheable(_escapeIdentifier);
 const unescapeIdentifier = makeCacheable(_unescapeIdentifier);
 
+// A url-token / url-string value's escaped newlines (`url("im\<newline>g.png")`).
+const STRING_MULTILINE = /\\[\n\r\f]/g;
+// Leading / trailing CSS whitespace inside a quoted url value.
+const TRIM_WHITE_SPACES = /(^[ \t\n\r\f]*|[ \t\n\r\f]*$)/g;
+// One CSS escape: `\` + up to 6 hex digits (+ optional whitespace) or any char.
+const UNESCAPE = /\\([0-9a-f]{1,6}[ \t\n\r\f]?|[\s\S])/gi;
+
+/**
+ * Normalize a url value (a url-token's content or a url string's body) into
+ * the form requests are resolved from: escaped newlines removed (string form),
+ * edge whitespace trimmed, CSS escapes and percent-encoding decoded
+ * (`data:` URIs excepted).
+ * @param {string} str url string
+ * @param {boolean} isString is url wrapped in quotes
+ * @returns {string} normalized url
+ */
+const normalizeUrl = (str, isString) => {
+	// Fast paths: skip the regex engine for the common URL with no escape and
+	// no edge whitespace (e.g. `./img.png`). Each guard is equivalent to the
+	// regex being a no-op.
+	// Remove escaped newlines from a string-token url like `url("im\<newline>g.png")`.
+	if (isString && str.includes("\\")) {
+		str = str.replace(STRING_MULTILINE, "");
+	}
+
+	// Remove unnecessary spaces from `url("   img.png	 ")`
+	if (
+		str.length !== 0 &&
+		(_isWhiteSpace(str.charCodeAt(0)) ||
+			_isWhiteSpace(str.charCodeAt(str.length - 1)))
+	) {
+		str = str.replace(TRIM_WHITE_SPACES, "");
+	}
+
+	// Unescape
+	if (str.includes("\\")) {
+		str = str.replace(UNESCAPE, (match) => {
+			if (match.length > 2) {
+				return String.fromCharCode(Number.parseInt(match.slice(1).trim(), 16));
+			}
+			return match[1];
+		});
+	}
+
+	// Char-code gate so the dominant non-`data:` url skips the regex test.
+	if ((str.charCodeAt(0) | 0x20) === CC_LOWER_D && /^data:/i.test(str)) {
+		return str;
+	}
+
+	if (str.includes("%")) {
+		// Convert `url('%2E/img.png')` -> `url('./img.png')`
+		try {
+			str = decodeURIComponent(str);
+		} catch (_err) {
+			// Ignore
+		}
+	}
+
+	return str;
+};
+
 // CSS-typed views over the generic visitor machinery (`util/SourceProcessor`),
 // re-exported so consumers keep importing them from this module.
 /**
- * @typedef {import("../util/SourceProcessor").VisitorContext} VisitorContext
- * @typedef {import("../util/SourceProcessor").VisitorFn<Node>} VisitorFn
- * @typedef {import("../util/SourceProcessor").VisitorBucket<Node>} VisitorBucket
- * @typedef {import("../util/SourceProcessor").VisitorMap<Node>} VisitorMap
- * @typedef {import("../util/SourceProcessor").CompiledVisitorMap<Node>} CompiledVisitorMap
+ * @typedef {import("../util/SourceProcessor").VisitorFn<CssPath>} VisitorFn
+ * @typedef {import("../util/SourceProcessor").VisitorBucket<CssPath>} VisitorBucket
+ * @typedef {import("../util/SourceProcessor").VisitorMap<CssPath>} VisitorMap
+ * @typedef {import("../util/SourceProcessor").CompiledVisitorMap<CssPath>} CompiledVisitorMap
  */
 
 /**
@@ -3027,10 +3467,149 @@ const TOP_LEVEL_CONSUMERS = {
 /**
  * @typedef {object} CssProcessOptions
  * @property {LocConverter=} locConverter shared loc converter (default a fresh one over the input)
- * @property {((input: string, start: number, end: number) => number)=} comment comment-token callback
  * @property {boolean=} recurseBlocks walk into block bodies' nested rules (default true)
  * @property {("stylesheet" | "block-contents")=} as which top-level production to consume the source as (see `TOP_LEVEL_CONSUMERS`): `"stylesheet"` (default) or `"block-contents"` (a block's contents, e.g. an HTML `style` attribute)
+ * @property {SkipOptions=} skip what the grammar may leave un-materialized to go faster — safe only for parts nothing reads in the active parse; default skip nothing
+ */
+
+/**
+ * `CssProcessOptions.skip`: two independent axes, so each reads unambiguously.
+ * @typedef {object} SkipOptions
+ * @property {Uint8Array=} types component-value node types to drop from declaration value / function-arg lists (indexed by `NodeType`, 1 = skip; build with `buildSkipSet`)
+ * @property {boolean=} selectorPrelude drop qualified-rule (selector) preludes — the rule and its block are still produced (default false)
+ * @property {boolean=} atRulePrelude drop at-rule preludes — the at-rule and its block are still produced (default false)
+ */
+
+// Per-parse walk state in module slots (same pattern as `_skip*`) so the walk
+// functions below are module-level constants: one function identity across
+// parses keeps the recursive per-node call sites monomorphic and drops the
+// per-parse closure allocations.
+/** @typedef {import("../util/SourceProcessor").CompiledVisitorBucket<CssPath>} CompiledVisitorBucket */
+/** @type {CompiledVisitorMap} */
+let _visitors = /** @type {CompiledVisitorMap} */ (/** @type {unknown} */ ([]));
+let _recurseBlocks = true;
+/** @type {CompiledVisitorBucket | undefined} */
+let _commentBucket;
+
+// Comments reach the visitor map through `NodeType.Comment` instead of a
+// side callback. They fire during tokenization — in source order among
+// comments, not interleaved with the node walk — on a transient SoA node so
+// `A.start`/`end`/`loc`/`source` work. No comment visitor → no callback →
+// the tokenizer skips comments with zero overhead.
+/** @type {(input: string, start: number, end: number) => number} */
+const _grammarOnComment = (_input, start, end) => {
+	const node = _soaAllocNode(T_COMMENT, start, end);
+	_currentNode = node;
+	_currentParent = null;
+	const bucket = /** @type {CompiledVisitorBucket} */ (_commentBucket);
+	const e = bucket.enter;
+	for (let i = 0; i < e.length; i++) e[i](A);
+	const x = bucket.exit;
+	for (let i = 0; i < x.length; i++) x[i](A);
+	return end;
+};
+
+/**
+ * Walk a component-value subtree; children are already materialized. Fetches
+ * the node's visitor bucket once (reused for enter + exit) and uses index
+ * loops — `for…of` would allocate an iterator per node on this hot path.
+ * @param {Node} node component-value root
+ * @param {Node | null} parent enclosing node
+ */
+const _walkValue = (node, parent) => {
+	const ty = _soaTypes[_nodeIndex(node)];
+	const b = _visitors[ty];
+	let skip = false;
+	if (b !== undefined && b.enter.length !== 0) {
+		_walkSkip = false;
+		_currentNode = node;
+		_currentParent = parent;
+		const e = b.enter;
+		for (let i = 0; i < e.length; i++) e[i](A);
+		skip = _walkSkip;
+		_walkSkip = false;
+	}
+	if (!skip && (ty === T_FUNCTION || ty === T_SIMPLE_BLOCK)) {
+		const i0 = _nodeIndex(node);
+		const vs = _soaListStarts[i0];
+		const ve = vs + _soaListLens[i0];
+		for (let i = vs; i < ve; i++) _walkValue(_nodeRef(_soaFlat[i]), node);
+	}
+	if (b !== undefined) {
+		// Rebind: descending into children moved the path.
+		_currentNode = node;
+		_currentParent = parent;
+		const x = b.exit;
+		for (let i = 0; i < x.length; i++) x[i](A);
+	}
+};
+
+/**
+ * Walk a structural subtree; an at-rule / qualified-rule's block was parsed
+ * eagerly (§5.4.4), so its `value` holds the nested rules / declarations.
+ * @param {Node} node structural-tree root
+ * @param {Node | null} parent enclosing node
+ */
+const _walkRule = (node, parent) => {
+	const i0 = _nodeIndex(node);
+	const ty = _soaTypes[i0];
+	const b = _visitors[ty];
+	let skip = false;
+	if (b !== undefined && b.enter.length !== 0) {
+		_walkSkip = false;
+		_currentNode = node;
+		_currentParent = parent;
+		const e = b.enter;
+		for (let i = 0; i < e.length; i++) e[i](A);
+		skip = _walkSkip;
+		_walkSkip = false;
+	}
+	if (!skip) {
+		if (ty === T_AT_RULE || ty === T_QUALIFIED_RULE) {
+			const ps = _soaListStarts[i0];
+			const pe = ps + _soaListLens[i0];
+			for (let i = ps; i < pe; i++) _walkValue(_nodeRef(_soaFlat[i]), node);
+			if (_recurseBlocks) {
+				// Declarations then child rules — downstream consumers don't need them strictly interleaved in source order.
+				const decls = _soaDeclarationLists[i0];
+				if (decls) {
+					for (let i = 0; i < decls.length; i++) _walkRule(decls[i], node);
+				}
+				const ch = _soaChildRuleLists[i0];
+				if (ch) for (let i = 0; i < ch.length; i++) _walkRule(ch[i], node);
+			}
+		} else if (ty === T_DECLARATION) {
+			const vs = _soaListStarts[i0];
+			const ve = vs + _soaListLens[i0];
+			for (let i = vs; i < ve; i++) _walkValue(_nodeRef(_soaFlat[i]), node);
+		}
+	}
+	if (b !== undefined) {
+		// Rebind: descending into children moved the path.
+		_currentNode = node;
+		_currentParent = parent;
+		const x = b.exit;
+		for (let i = 0; i < x.length; i++) x[i](A);
+	}
+};
+
+/**
+ * The `grammar` streaming sink: walk one top-level node, then recycle the SoA
+ * buffers for the next.
+ * @param {Rule | Declaration} node top-level node
  */
+const _walkTopLevel = (node) => {
+	_walkRule(node, null);
+	if (_soaNodeCount > _soaPeak) _soaPeak = _soaNodeCount;
+	if (_soaFlatTop > _soaFlatPeak) _soaFlatPeak = _soaFlatTop;
+	_soaNodeCount = 0;
+	_soaFlatTop = 0;
+};
+
+// The SoA buffers grow to the largest single top-level rule ever parsed and
+// live at module level; above this capacity they are re-shrunk after a parse
+// so one pathological rule can't pin megabytes for the process lifetime.
+const _SOA_SHRINK_CAPACITY = 65536;
 
 /**
  * The CSS `SourceProcessor` grammar: consume top-level rules one at a time
@@ -3043,100 +3622,66 @@ const TOP_LEVEL_CONSUMERS = {
  * @param {CssProcessOptions} options process options
  */
 const grammar = (input, visitors, options) => {
-	const { comment } = options;
 	const locConverter = options.locConverter || new LocConverter(input);
 	useSoaBackend(input, locConverter);
-	const recurseBlocks = options.recurseBlocks !== false;
-
-	// Babel's `path.skip()`, children-only. Reset per `enter` dispatch.
-	let skipFlag = false;
-	const visitorCtx = {
-		skipChildren() {
-			skipFlag = true;
-		}
-	};
-
-	/**
-	 * Walk a component-value subtree; children are already materialized. Fetches
-	 * the node's visitor bucket once (reused for enter + exit) and uses index
-	 * loops — `for…of` would allocate an iterator per node on this hot path.
-	 * @param {Node} node component-value root
-	 * @param {Node | null} parent enclosing node
-	 */
-	const walkValue = (node, parent) => {
-		const ty = _soaTy[_ix(node)];
-		const b = visitors[ty];
-		let skip = false;
-		if (b !== undefined && b.enter.length !== 0) {
-			skipFlag = false;
-			const e = b.enter;
-			for (let i = 0; i < e.length; i++) e[i](node, parent, visitorCtx);
-			skip = skipFlag;
-			skipFlag = false;
-		}
-		if (!skip && (ty === T_FUNCTION || ty === T_SIMPLE_BLOCK)) {
-			const v = /** @type {Node[]} */ (_soaL0[_ix(node)]);
-			for (let i = 0; i < v.length; i++) walkValue(v[i], node);
-		}
-		if (b !== undefined) {
-			const x = b.exit;
-			for (let i = 0; i < x.length; i++) x[i](node, parent, visitorCtx);
-		}
-	};
-
-	/**
-	 * Walk a structural subtree; an at-rule / qualified-rule's block was parsed
-	 * eagerly (§5.4.4), so its `value` holds the nested rules / declarations.
-	 * @param {Node} node structural-tree root
-	 * @param {Node | null} parent enclosing node
-	 */
-	const walkRule = (node, parent) => {
-		const i0 = _ix(node);
-		const ty = _soaTy[i0];
-		const b = visitors[ty];
-		let skip = false;
-		if (b !== undefined && b.enter.length !== 0) {
-			skipFlag = false;
-			const e = b.enter;
-			for (let i = 0; i < e.length; i++) e[i](node, parent, visitorCtx);
-			skip = skipFlag;
-			skipFlag = false;
-		}
-		if (!skip) {
-			if (ty === T_AT_RULE || ty === T_QUALIFIED_RULE) {
-				const p = /** @type {Node[]} */ (_soaL0[i0]);
-				for (let i = 0; i < p.length; i++) walkValue(p[i], node);
-				if (recurseBlocks) {
-					// Declarations then child rules — downstream consumers don't need them strictly interleaved in source order.
-					const decls = _soaL1[i0];
-					if (decls) {
-						for (let i = 0; i < decls.length; i++) walkRule(decls[i], node);
-					}
-					const ch = _soaL2[i0];
-					if (ch) for (let i = 0; i < ch.length; i++) walkRule(ch[i], node);
-				}
-			} else if (ty === T_DECLARATION) {
-				const v = /** @type {Node[]} */ (_soaL0[i0]);
-				for (let i = 0; i < v.length; i++) walkValue(v[i], node);
-			}
-		}
-		if (b !== undefined) {
-			const x = b.exit;
-			for (let i = 0; i < x.length; i++) x[i](node, parent, visitorCtx);
-		}
-	};
+	const skip = options.skip;
+	_skipTypes = (skip && skip.types) || _NO_SKIP_TYPES;
+	_skipActive = _skipTypes !== _NO_SKIP_TYPES;
+	_skipSelectorPrelude = skip !== undefined && skip.selectorPrelude === true;
+	_skipAtRulePrelude = skip !== undefined && skip.atRulePrelude === true;
+	_recurseBlocks = options.recurseBlocks !== false;
+	_visitors = visitors;
+	_commentBucket = visitors[T_COMMENT];
 
 	// Stream each top-level node (selected by `as`) to the walker the moment it's
 	// consumed, rather than collecting them first — so the whole AST is never
 	// held at once; peak heap is ~one top-level node's subtree.
-	const ts = new TokenStream(input, 0, locConverter, comment);
+	const ts = new TokenStream(
+		input,
+		0,
+		locConverter,
+		_commentBucket === undefined ? undefined : _grammarOnComment
+	);
 	const consume =
 		TOP_LEVEL_CONSUMERS[options.as || "stylesheet"] ||
 		consumeAStylesheetsContents;
-	consume(ts, (node) => {
-		walkRule(node, null);
-		_soaN = 0;
-	});
+	try {
+		consume(ts, _walkTopLevel);
+	} finally {
+		// Drop the module-level SoA references so the last parsed source (and
+		// its LocConverter / child lists / visitors) don't stay alive between
+		// parses.
+		_soaInput = "";
+		_soaLocConverter = /** @type {LocConverter} */ (
+			/** @type {unknown} */ (null)
+		);
+		_soaDeclarationLists.length = 0;
+		_soaChildRuleLists.length = 0;
+		_soaFlatTop = 0;
+		_listPool.length = 0;
+		if (_soaFlat.length > _SOA_SHRINK_CAPACITY) {
+			_soaFlatGrowHint = _soaFlatPeak;
+			_soaFlat = new Int32Array(0);
+		}
+		_visitors = /** @type {CompiledVisitorMap} */ (/** @type {unknown} */ ([]));
+		_commentBucket = undefined;
+		if (_soaCapacity > _SOA_SHRINK_CAPACITY) {
+			// +1: node ids are 1-based and grow fires at `id >= capacity`.
+			_soaGrowHint = _soaPeak + 1;
+			_soaCapacity = 0;
+			_soaTypes = new Uint8Array(0);
+			_soaStarts = new Int32Array(0);
+			_soaEnds = new Int32Array(0);
+			_soaAux0 = new Int32Array(0);
+			_soaAux1 = new Int32Array(0);
+			_soaAux2 = new Int32Array(0);
+			_soaFlags = new Uint8Array(0);
+			_soaListStarts = new Int32Array(0);
+			_soaListLens = new Int32Array(0);
+		}
+		_soaPeak = 0;
+		_soaFlatPeak = 0;
+	}
 };
 
 /**
@@ -3144,17 +3689,68 @@ const grammar = (input, visitors, options) => {
  * `grammar`. Babel-style usage:
  *
  * ```
- * processor.use({ [NodeType.AtRule]: (at) => {}, [NodeType.Declaration]: { enter, exit } });
- * processor.process(source);
+ * new SourceProcessor({ skip }).use({ [NodeType.AtRule]: (path) => {} }).process(source);
  * ```
- * @extends {GenericSourceProcessor<Node, CssProcessOptions>}
+ * @extends {GenericSourceProcessor<CssPath, CssProcessOptions>}
  */
 class SourceProcessor extends GenericSourceProcessor {
-	constructor() {
-		super(grammar);
+	/**
+	 * @param {CssProcessOptions=} options default process options (`skip`, `as`, …) for every `process` call
+	 */
+	constructor(options) {
+		super(grammar, options);
 	}
 }
 
+/**
+ * Build a `SkipOptions.types` set (drop these component-value node types from
+ * value / function-arg lists) from a list of `NodeType`s. Preludes are separate
+ * (`SkipOptions.selectorPrelude` / `atRulePrelude`). The caller owns the safety
+ * contract: only pass types nothing reads in the intended parse. Two
+ * grammar-internal caveats beyond consumer needs: dropping both `Delim` and
+ * `Ident` loses `!important` detection, and dropping `SimpleBlock` loses the
+ * custom-property `{}`-value check (and its subtree). Precompute once per
+ * configuration and reuse across parses.
+ * @param {number[]} nodeTypes component-value node types to drop
+ * @returns {Uint8Array} skip-types set indexed by `NodeType`
+ */
+const buildSkipSet = (nodeTypes) => {
+	const set = new Uint8Array(32);
+	for (let i = 0; i < nodeTypes.length; i++) set[nodeTypes[i]] = 1;
+	return set;
+};
+
+/* eslint-disable jsdoc/require-template -- `A` below is the accessor const, not a type parameter */
+/**
+ * The CSS path (Babel's `path` shape): the AST accessor with the walk's
+ * current position on it — the single argument every visitor receives.
+ * @typedef {typeof A} CssPath
+ */
+/* eslint-enable jsdoc/require-template */
+
+// A fresh (safely retainable) array view of a node's flat content span —
+// visitors that read `A.children` / `A.prelude` may keep the result.
+/** @type {(n: Node) => Node[]} */
+const _materializeList = (n) => {
+	const i = _nodeIndex(n);
+	const start = _soaListStarts[i];
+	const len = _soaListLens[i];
+	/** @type {Node[]} */
+	const out = [];
+	for (let k = 0; k < len; k++) out.push(_nodeRef(_soaFlat[start + k]));
+	return out;
+};
+
+// Babel's `path.skip()`, children-only: set by `A.skipChildren()` during an
+// `enter` dispatch, consumed by the walk.
+let _walkSkip = false;
+// The walk's current position (`A.node` / `A.parent` read these; module-level
+// so the accessor methods' defaults avoid self-referential `this` typing).
+/** @type {Node} */
+let _currentNode = /** @type {Node} */ (/** @type {unknown} */ (0));
+/** @type {Node | null} */
+let _currentParent = null;
+
 // AST field-access seam. Every AST-node field read by `CssParser` goes through
 // one of these accessors so the node representation can change underneath the
 // consumer without touching it. Today they are backed by the `Node` / `Token` /
@@ -3163,51 +3759,104 @@ class SourceProcessor extends GenericSourceProcessor {
 // consumer edit. `value` is the leaf-token string; container child lists are
 // `children` / `prelude` / `declarations` / `childRules`.
 const A = {
-	/** @type {(n: Node) => number} */
-	type: (n) => _soaTy[_ix(n)],
-	/** @type {(n: Node) => number} */
-	start: (n) => _soaSt[_ix(n)],
-	/** @type {(n: Node) => number} */
-	end: (n) => _soaEn[_ix(n)],
-	/** @type {(n: Node) => [number, number]} */
-	range: (n) => {
-		const i = _ix(n);
-		return [_soaSt[i], _soaEn[i]];
+	// === path position (rebound by the walk before every visitor call) ===
+	/**
+	 * @returns {Node} current node — only valid during a visitor callback
+	 */
+	get node() {
+		return _currentNode;
+	},
+	/**
+	 * @returns {Node | null} enclosing node (null = a top-level node)
+	 */
+	get parent() {
+		return _currentParent;
+	},
+	/** Stop the walk descending into the current node (enter only). */
+	skipChildren() {
+		_walkSkip = true;
 	},
-	/** @type {(n: Node) => { start: { line: number, column: number }, end: { line: number, column: number } }} */
-	loc: (n) => {
-		const i = _ix(n);
-		const lc = _soaLC;
-		const s = lc.get(_soaSt[i]);
+	// === field reads — `n` defaults to the current node ===
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} node type
+	 */
+	type(n = _currentNode) {
+		return _soaTypes[_nodeIndex(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} start offset
+	 */
+	start(n = _currentNode) {
+		return _soaStarts[_nodeIndex(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} end offset
+	 */
+	end(n = _currentNode) {
+		return _soaEnds[_nodeIndex(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {[number, number]} start / end offsets
+	 */
+	range(n = _currentNode) {
+		const i = _nodeIndex(n);
+		return [_soaStarts[i], _soaEnds[i]];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {{ start: { line: number, column: number }, end: { line: number, column: number } }} source location
+	 */
+	loc(n = _currentNode) {
+		const i = _nodeIndex(n);
+		const lc = _soaLocConverter;
+		const s = lc.get(_soaStarts[i]);
 		const sl = s.line;
 		const sc = s.column;
-		const e = lc.get(_soaEn[i]);
+		const e = lc.get(_soaEnds[i]);
 		return {
 			start: { line: sl, column: sc },
 			end: { line: e.line, column: e.column }
 		};
 	},
-	/** @type {(n: Node) => string} */
-	source: (n) => {
-		const i = _ix(n);
-		return _soaInput.slice(_soaSt[i], _soaEn[i]);
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} raw source slice
+	 */
+	source(n = _currentNode) {
+		const i = _nodeIndex(n);
+		return _soaInput.slice(_soaStarts[i], _soaEnds[i]);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} raw token value
+	 */
+	value(n = _currentNode) {
+		return _soaValueOf(_nodeIndex(n));
 	},
-	/** @type {(n: Node) => string} */
-	value: (n) => _soaValueOf(_ix(n)),
-	/** @type {(n: Node) => string} */
-	unescaped: (n) => {
-		const i = _ix(n);
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} unescaped token value
+	 */
+	unescaped(n = _currentNode) {
+		const i = _nodeIndex(n);
 		const v = _soaValueOf(i);
-		return _soaTy[i] === T_STRING
+		return _soaTypes[i] === T_STRING
 			? unescapeIdentifier(v.slice(1, -1))
 			: unescapeIdentifier(v);
 	},
-	/** @type {(n: Node) => string} */
-	typeFlag: (n) => {
-		const i = _ix(n);
-		if (_soaTy[i] === T_HASH) {
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} hash / numeric type flag
+	 */
+	typeFlag(n = _currentNode) {
+		const i = _nodeIndex(n);
+		if (_soaTypes[i] === T_HASH) {
 			const input = _soaInput;
-			const p = _soaSt[i] + 1;
+			const p = _soaStarts[i] + 1;
 			return _ifThreeCodePointsWouldStartAnIdentSequence(
 				input,
 				p,
@@ -3220,52 +3869,130 @@ const A = {
 		}
 		const v = _soaValueOf(i);
 		return _typeFlagOf(
-			_soaTy[i] === T_DIMENSION ? v.slice(0, _consumeANumber(v, 0)) : v
+			_soaTypes[i] === T_DIMENSION ? v.slice(0, _consumeANumber(v, 0)) : v
+		);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} url content start offset
+	 */
+	contentStart(n = _currentNode) {
+		return _soaAux0[_nodeIndex(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} url content end offset
+	 */
+	contentEnd(n = _currentNode) {
+		return _soaAux1[_nodeIndex(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} rule / declaration / function name
+	 */
+	name(n = _currentNode) {
+		const i = _nodeIndex(n);
+		return _soaTypes[i] === T_AT_RULE
+			? _soaInput.slice(_soaStarts[i] + 1, _soaAux0[i])
+			: _soaInput.slice(_soaStarts[i], _soaAux0[i]);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} name start offset
+	 */
+	nameStart(n = _currentNode) {
+		return _soaStarts[_nodeIndex(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} name end offset
+	 */
+	nameEnd(n = _currentNode) {
+		return _soaAux0[_nodeIndex(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} unescaped name
+	 */
+	unescapedName(n = _currentNode) {
+		return unescapeIdentifier(A.name(n));
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {ComponentValue[]} function / block children
+	 */
+	children(n = _currentNode) {
+		return /** @type {ComponentValue[]} */ (_materializeList(n));
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {ComponentValue[]} rule prelude
+	 */
+	prelude(n = _currentNode) {
+		return /** @type {ComponentValue[]} */ (_materializeList(n));
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {Declaration[] | null} block declarations
+	 */
+	declarations(n = _currentNode) {
+		return /** @type {Declaration[] | null} */ (
+			_soaDeclarationLists[_nodeIndex(n)]
 		);
 	},
-	/** @type {(n: Node) => number} */
-	contentStart: (n) => _soaA0[_ix(n)],
-	/** @type {(n: Node) => number} */
-	contentEnd: (n) => _soaA1[_ix(n)],
-	/** @type {(n: Node) => string} */
-	name: (n) => {
-		const i = _ix(n);
-		return _soaTy[i] === T_AT_RULE
-			? _soaInput.slice(_soaSt[i] + 1, _soaA0[i])
-			: _soaInput.slice(_soaSt[i], _soaA0[i]);
+	/**
+	 * @param {Node=} n node
+	 * @returns {Rule[] | null} block child rules
+	 */
+	childRules(n = _currentNode) {
+		return /** @type {Rule[] | null} */ (_soaChildRuleLists[_nodeIndex(n)]);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} block start offset
+	 */
+	blockStart(n = _currentNode) {
+		return _soaAux1[_nodeIndex(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} block end offset
+	 */
+	blockEnd(n = _currentNode) {
+		return _soaAux2[_nodeIndex(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {boolean} `!important` flag
+	 */
+	important(n = _currentNode) {
+		return (_soaFlags[_nodeIndex(n)] & 1) !== 0;
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {SimpleBlockToken} block opening token
+	 */
+	blockToken(n = _currentNode) {
+		return /** @type {SimpleBlockToken} */ (
+			_soaInput[_soaStarts[_nodeIndex(n)]]
+		);
 	},
-	/** @type {(n: Node) => number} */
-	nameStart: (n) => _soaSt[_ix(n)],
-	/** @type {(n: Node) => number} */
-	nameEnd: (n) => _soaA0[_ix(n)],
-	/** @type {(n: Node) => string} */
-	unescapedName: (n) => unescapeIdentifier(A.name(n)),
-	/** @type {(n: Node) => ComponentValue[]} */
-	children: (n) => /** @type {ComponentValue[]} */ (_soaL0[_ix(n)]),
-	/** @type {(n: Node) => ComponentValue[]} */
-	prelude: (n) => /** @type {ComponentValue[]} */ (_soaL0[_ix(n)]),
-	/** @type {(n: Node) => Declaration[] | null} */
-	declarations: (n) => /** @type {Declaration[] | null} */ (_soaL1[_ix(n)]),
-	/** @type {(n: Node) => Rule[] | null} */
-	childRules: (n) => /** @type {Rule[] | null} */ (_soaL2[_ix(n)]),
-	/** @type {(n: Node) => number} */
-	blockStart: (n) => _soaA1[_ix(n)],
-	/** @type {(n: Node) => number} */
-	blockEnd: (n) => _soaA2[_ix(n)],
-	/** @type {(n: Node) => boolean} */
-	important: (n) => (_soaFl[_ix(n)] & 1) !== 0,
-	/** @type {(n: Node) => SimpleBlockToken} */
-	blockToken: (n) =>
-		/** @type {SimpleBlockToken} */ (_soaInput[_soaSt[_ix(n)]]),
 	// Writers — `CssParser` rewrites a rule's end / block-end when it folds an
-	// inline ICSS `:import` / `:export` body into a single dependency.
-	/** @type {(n: Node, v: number) => void} */
-	setEnd: (n, v) => {
-		_soaEn[_ix(n)] = v;
+	// inline ICSS `:import` / `:export` body into a single dependency. The
+	// node stays explicit here: writes should never be implicit on position.
+	/**
+	 * @param {Node} n node
+	 * @param {number} v new end offset
+	 */
+	setEnd(n, v) {
+		_soaEnds[_nodeIndex(n)] = v;
 	},
-	/** @type {(n: Node, v: number) => void} */
-	setBlockEnd: (n, v) => {
-		_soaA2[_ix(n)] = v;
+	/**
+	 * @param {Node} n node
+	 * @param {number} v new block end offset
+	 */
+	setBlockEnd(n, v) {
+		_soaAux2[_nodeIndex(n)] = v;
 	}
 };
 
@@ -3307,8 +4034,14 @@ module.exports.TT_URL = TT_URL;
 module.exports.TT_WHITESPACE = TT_WHITESPACE;
 module.exports.Token = Token;
 module.exports.TokenStream = TokenStream;
+module.exports.buildSkipSet = buildSkipSet;
 module.exports.equalsLowerCase = equalsLowerCase;
 module.exports.escapeIdentifier = escapeIdentifier;
+module.exports.isDashedIdentifier = isDashedIdentifier;
+// CSS Syntax §4.2 "whitespace" (space / tab / newline / CR / FF) — the
+// tokenizer's whitespace class, exported under the spec's name.
+module.exports.isWhitespace = _isWhiteSpace;
+module.exports.normalizeUrl = normalizeUrl;
 module.exports.parseABlocksContents = parseABlocksContents;
 module.exports.parseACommaSeparatedListOfComponentValues =
 	parseACommaSeparatedListOfComponentValues;
@@ -3318,5 +4051,8 @@ module.exports.parseAListOfComponentValues = parseAListOfComponentValues;
 module.exports.parseARule = parseARule;
 module.exports.parseAStylesheet = parseAStylesheet;
 module.exports.parseAStylesheetsContents = parseAStylesheetsContents;
+module.exports.rangeEquals = rangeEquals;
+module.exports.rangeEqualsLowerCase = rangeEqualsLowerCase;
 module.exports.readToken = readToken;
+module.exports.toLowerCaseIfNeeded = toLowerCaseIfNeeded;
 module.exports.unescapeIdentifier = unescapeIdentifier;