webpack 5.108.2 → 5.108.4

package/lib/css/syntax.js

@@ -209,7 +209,6 @@ const CC_EXCLAMATION = "!".charCodeAt(0);
 const CC_UPPER_A = "A".charCodeAt(0);
 const CC_UPPER_F = "F".charCodeAt(0);
 const CC_UPPER_E = "E".charCodeAt(0);
-const CC_UPPER_U = "U".charCodeAt(0);
 const CC_UPPER_Z = "Z".charCodeAt(0);
 const CC_0 = "0".charCodeAt(0);
 const CC_9 = "9".charCodeAt(0);
@@ -298,17 +297,14 @@ const _isSpace = (cc) => cc === CC_SPACE || cc === CC_TAB;
 // rarer tab / newline tests.
 const _isWhiteSpace = (cc) => _isSpace(cc) || _isNewline(cc);
 
-/**
- * ident-start code point per the spec: a letter, a non-ASCII code point,
- * or U+005F LOW LINE (`_`).
- * @param {number} cc char code
- * @returns {boolean} true, if cc is an ident-start code point
- */
-const isIdentStartCodePoint = (cc) =>
-	(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
-	(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
-	cc === CC_LOW_LINE ||
-	cc >= 0x80;
+// 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
@@ -482,11 +478,17 @@ const _ifThreeCodePointsWouldStartANumber = (input, pos, f, s, t) => {
  * @returns {number} position just past the last ident-sequence code point
  */
 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.
 	for (;;) {
 		const cc = input.charCodeAt(pos);
 		pos++;
-		if (_isIdentCodePoint(cc)) continue;
-		if (_ifTwoCodePointsAreValidEscape(input, pos, cc)) {
+		if (cc < 128 ? _identCharTable[cc] === 1 : _isIdentStartCodePointCC(cc)) {
+			continue;
+		}
+		if (cc === CC_REVERSE_SOLIDUS && !_isNewline(input.charCodeAt(pos))) {
 			pos = _consumeAnEscapedCodePoint(input, pos);
 			continue;
 		}
@@ -619,7 +621,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);
 }
 
@@ -950,6 +952,96 @@ function consumeReverseSolidus(input, pos, out) {
 	return fill(out, TT_DELIM, pos - 1, pos);
 }
 
+// `consumeAToken` dispatch: the §4 token rules keyed by the lead code point are
+// === Tokenizer lead-character dispatch (CSS Syntax Level 3 §4 "consume a token") ===
+//
+// `consumeAToken` selects a sub-routine from the first ("lead") code point of each
+// token. The §4 rules are keyed on specific code points (`"` `#` `(` digit
+// ident-start …) that sit SPARSELY across the ASCII range, so a plain `switch (cc)`
+// compiles to a jump table spanning U+0009..U+007D in which the most common lead —
+// an ident-start letter — is not a case and reaches its handler only after the
+// digit/whitespace tests miss. `_charClass` precomputes, for every ASCII code
+// point, a dense handler id (`HC_*`, 0..12) so `consumeAToken` is one array load +
+// a compact 13-entry jump table and idents dispatch directly. Non-ASCII
+// (cc >= 128) is always ident-start per §4, so it skips the table.
+//
+// Extending for a spec change: repoint the code point in the build loop below; if
+// it needs a new sub-routine, add an `HC_*` id, a `case` in `consumeAToken`, and a
+// row here. This list is the authoritative "which lead code point dispatches
+// where" map (§4 "consume a token", step by lead code point):
+//
+//   HC_WHITESPACE      whitespace      U+0009 TAB  U+000A LF  U+000C FF  U+000D CR  U+0020 SPACE
+//   HC_STRING          string start    U+0022 "    U+0027 '
+//   HC_SINGLE          one-char token  ( ) , : ; [ ] { }   (its token type comes from `_singleTT`)
+//   HC_NUMBER_SIGN     hash / delim    U+0023 #
+//   HC_PLUS_SIGN       number / delim  U+002B +
+//   HC_HYPHEN_MINUS    number / CDC / ident / delim   U+002D -
+//   HC_FULL_STOP       number / delim  U+002E .
+//   HC_LESS_THAN       CDO / delim     U+003C <
+//   HC_AT_SIGN         at-keyword / delim   U+0040 @
+//   HC_REVERSE_SOLIDUS escape / delim  U+005C \
+//   HC_DIGIT           number          U+0030..U+0039 0-9
+//   HC_IDENT           ident-like      U+0041..U+005A A-Z  U+0061..U+007A a-z  U+005F _  (plus cc >= 128)
+//   HC_DELIM           anything else   -> a single <delim-token>
+//
+// `_singleTT[cc]` is the token type for the HC_SINGLE code points (a second table
+// so they share one handler instead of one `case` each). The default class 0 is
+// the delim handler (anything not matched below), so it needs no named constant.
+const HC_WHITESPACE = 1;
+const HC_STRING = 2;
+const HC_SINGLE = 3;
+const HC_NUMBER_SIGN = 4;
+const HC_PLUS_SIGN = 5;
+const HC_HYPHEN_MINUS = 6;
+const HC_FULL_STOP = 7;
+const HC_LESS_THAN = 8;
+const HC_AT_SIGN = 9;
+const HC_REVERSE_SOLIDUS = 10;
+const HC_DIGIT = 11;
+const HC_IDENT = 12;
+const _charClass = new Uint8Array(128);
+const _singleTT = new Uint8Array(128);
+_singleTT[CC_LEFT_PARENTHESIS] = TT_LEFT_PARENTHESIS;
+_singleTT[CC_RIGHT_PARENTHESIS] = TT_RIGHT_PARENTHESIS;
+_singleTT[CC_COMMA] = TT_COMMA;
+_singleTT[CC_COLON] = TT_COLON;
+_singleTT[CC_SEMICOLON] = TT_SEMICOLON;
+_singleTT[CC_LEFT_SQUARE] = TT_LEFT_SQUARE_BRACKET;
+_singleTT[CC_RIGHT_SQUARE] = TT_RIGHT_SQUARE_BRACKET;
+_singleTT[CC_LEFT_CURLY] = TT_LEFT_CURLY_BRACKET;
+_singleTT[CC_RIGHT_CURLY] = TT_RIGHT_CURLY_BRACKET;
+// Each ASCII code point belongs to exactly one class; HC_SINGLE is seeded from
+// `_singleTT` above, the rest follow §4's lead-code-point rules, and everything
+// unmatched stays the delim class (0). Keep this in sync with the table above.
+for (let i = 0; i < 128; i++) {
+	if (_singleTT[i] !== 0) {
+		_charClass[i] = HC_SINGLE;
+	} else if (_isWhiteSpace(i)) {
+		_charClass[i] = HC_WHITESPACE;
+	} else if (i === CC_QUOTATION_MARK || i === CC_APOSTROPHE) {
+		_charClass[i] = HC_STRING;
+	} else if (i === CC_NUMBER_SIGN) {
+		_charClass[i] = HC_NUMBER_SIGN;
+	} else if (i === CC_PLUS_SIGN) {
+		_charClass[i] = HC_PLUS_SIGN;
+	} else if (i === CC_HYPHEN_MINUS) {
+		_charClass[i] = HC_HYPHEN_MINUS;
+	} else if (i === CC_FULL_STOP) {
+		_charClass[i] = HC_FULL_STOP;
+	} else if (i === CC_LESS_THAN_SIGN) {
+		_charClass[i] = HC_LESS_THAN;
+	} else if (i === CC_AT_SIGN) {
+		_charClass[i] = HC_AT_SIGN;
+	} else if (i === CC_REVERSE_SOLIDUS) {
+		_charClass[i] = HC_REVERSE_SOLIDUS;
+	} else if (_isDigit(i)) {
+		_charClass[i] = HC_DIGIT;
+	} else if (_isIdentStartCodePointCC(i)) {
+		_charClass[i] = HC_IDENT;
+	}
+	// else stays the delim class (0)
+}
+
 /**
  * Per-character dispatcher. The outer loop has already advanced past
  * the lead code point (`pos - 1` is the lead).
@@ -960,65 +1052,50 @@ function consumeReverseSolidus(input, pos, out) {
  * @returns {MutableToken | undefined} the resulting token, or undefined at EOF
  */
 function consumeAToken(input, pos, cc, out) {
-	switch (cc) {
-		case CC_LINE_FEED:
-		case CC_CARRIAGE_RETURN:
-		case CC_FORM_FEED:
-		case CC_TAB:
-		case CC_SPACE:
+	// `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) {
+		// Run of whitespace → one <whitespace-token>.
+		case HC_WHITESPACE:
 			return consumeSpace(input, pos, out);
-		case CC_QUOTATION_MARK:
-		case CC_APOSTROPHE:
+		// `"` / `'` → <string-token> (or <bad-string-token> on a raw newline).
+		case HC_STRING:
 			return consumeAStringToken(input, pos, out);
-		case CC_NUMBER_SIGN:
+		// One-code-point token: its type is looked up in `_singleTT` (the `(` `)`
+		// `,` `:` `;` `[` `]` `{` `}` set), so all of them share this arm.
+		case HC_SINGLE:
+			return fill(out, _singleTT[cc], pos - 1, pos);
+		// `#` → <hash-token> if an ident/escape follows, else a <delim-token>.
+		case HC_NUMBER_SIGN:
 			return consumeNumberSign(input, pos, out);
-		case CC_LEFT_PARENTHESIS:
-			return fill(out, TT_LEFT_PARENTHESIS, pos - 1, pos);
-		case CC_RIGHT_PARENTHESIS:
-			return fill(out, TT_RIGHT_PARENTHESIS, pos - 1, pos);
-		case CC_PLUS_SIGN:
+		// `+` → <number-token> if it starts a number, else a <delim-token>.
+		case HC_PLUS_SIGN:
 			return consumePlusSign(input, pos, out);
-		case CC_COMMA:
-			return fill(out, TT_COMMA, pos - 1, pos);
-		case CC_HYPHEN_MINUS:
+		// `-` → number / <CDC-token> (`-->`) / ident / <delim-token>.
+		case HC_HYPHEN_MINUS:
 			return consumeHyphenMinus(input, pos, out);
-		case CC_FULL_STOP:
+		// `.` → <number-token> if a digit follows, else a <delim-token>.
+		case HC_FULL_STOP:
 			return consumeFullStop(input, pos, out);
-		case CC_COLON:
-			return fill(out, TT_COLON, pos - 1, pos);
-		case CC_SEMICOLON:
-			return fill(out, TT_SEMICOLON, pos - 1, pos);
-		case CC_LESS_THAN_SIGN:
+		// `<` → <CDO-token> (`<!--`), else a <delim-token>.
+		case HC_LESS_THAN:
 			return consumeLessThan(input, pos, out);
-		case CC_AT_SIGN:
+		// `@` → <at-keyword-token> if an ident follows, else a <delim-token>.
+		case HC_AT_SIGN:
 			return consumeCommercialAt(input, pos, out);
-		case CC_LEFT_SQUARE:
-			return fill(out, TT_LEFT_SQUARE_BRACKET, pos - 1, pos);
-		case CC_REVERSE_SOLIDUS:
+		// `\` → ident-like token if it's a valid escape, else a <delim-token>.
+		case HC_REVERSE_SOLIDUS:
 			return consumeReverseSolidus(input, pos, out);
-		case CC_RIGHT_SQUARE:
-			return fill(out, TT_RIGHT_SQUARE_BRACKET, pos - 1, pos);
-		case CC_LEFT_CURLY:
-			return fill(out, TT_LEFT_CURLY_BRACKET, pos - 1, pos);
-		case CC_RIGHT_CURLY:
-			return fill(out, TT_RIGHT_CURLY_BRACKET, pos - 1, pos);
+		// Digit → numeric token; `pos - 1` re-includes the digit the caller passed.
+		case HC_DIGIT:
+			return consumeANumericToken(input, pos - 1, out);
+		// Ident-start (letter / `_` / non-ASCII, incl. `u`/`U`) → ident / function /
+		// url token; `pos - 1` re-includes the lead code point.
+		case HC_IDENT:
+			return consumeAnIdentLikeToken(input, pos - 1, out);
 		default:
-			if (_isDigit(cc)) {
-				pos--;
-				return consumeANumericToken(input, pos, out);
-			}
-			if (cc === CC_LOWER_U || cc === CC_UPPER_U) {
-				// Unicode-range tokens are not produced — fall back to
-				// ident-like to match the existing tokenizer's behaviour.
-				pos--;
-				return consumeAnIdentLikeToken(input, pos, out);
-			}
-			if (isIdentStartCodePoint(cc)) {
-				pos--;
-				return consumeAnIdentLikeToken(input, pos, out);
-			}
-			// EOF is impossible here (caller guarded with the outer
-			// loop's `pos < input.length` check). Anything else: delim.
+			// HC_DELIM. EOF is impossible here (caller guarded with the outer
+			// loop's `pos < input.length` check). Anything else: a <delim-token>.
 			return fill(out, TT_DELIM, pos - 1, pos);
 	}
 }
@@ -1043,18 +1120,16 @@ function readToken(input, pos, out) {
 	// Comment: `/*…*/` is yielded as a token (filtered by `next`).
 	if (cc === CC_SOLIDUS && input.charCodeAt(pos + 1) === CC_ASTERISK) {
 		const start = pos;
-		pos += 2;
-		for (;;) {
-			// EOF in comment: emit the unterminated token so ranges cover all input.
-			if (pos === input.length) return fill(out, TT_COMMENT, start, pos);
-			if (
-				input.charCodeAt(pos) === CC_ASTERISK &&
-				input.charCodeAt(pos + 1) === CC_SOLIDUS
-			) {
-				return fill(out, TT_COMMENT, start, pos + 2);
-			}
-			pos++;
-		}
+		// Jump to the closing `*/` in one native scan instead of a per-character
+		// loop — comment bodies (license banners, source comments) can be long.
+		// No close: unterminated comment runs to EOF so ranges cover all input.
+		const close = input.indexOf("*/", pos + 2);
+		return fill(
+			out,
+			TT_COMMENT,
+			start,
+			close === -1 ? input.length : close + 2
+		);
 	}
 	// `consumeAToken` dispatches on the lead code point at `pos` (it expects the
 	// position just past the lead and the already-read lead code point).
@@ -1100,7 +1175,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,
@@ -1128,7 +1206,8 @@ const {
 	Declaration: T_DECLARATION,
 	AtRule: T_AT_RULE,
 	QualifiedRule: T_QUALIFIED_RULE,
-	Stylesheet: T_STYLESHEET
+	Stylesheet: T_STYLESHEET,
+	Comment: T_COMMENT
 } = NodeType;
 
 /**
@@ -1240,26 +1319,28 @@ class Token extends Node {
 	 * @param {number} end byte offset just past the token's last code point
 	 * @param {LocConverter} locConverter shared loc converter
 	 */
-	constructor(type, start, end, locConverter) {
-		super(type, start, end, locConverter);
-		// Lazily sliced from `range` on first `value` read (the common case), or
-		// pre-set when the value isn't the raw range slice (hash / at-keyword /
-		// url strip a prefix or use the content range). Deferring avoids slicing
-		// the many tokens — whitespace especially — whose value is never read.
-		/** @type {string | undefined} */
-		this._value = undefined;
-	}
+	// No own fields: a leaf token is exactly a `Node` plus the value getters
+	// below. `value` is derived from the byte range on read instead of cached in
+	// a `_value` slot — most tokens (whitespace, punctuation) never read it, and
+	// dropping the slot is ~8 bytes saved on every token (the bulk of all nodes).
+	// hash / at-keyword strip their `#` / `@` prefix; url uses its content range
+	// (`contentStart` / `contentEnd`, the token's only own fields).
 
 	/**
 	 * @returns {string} the token's value (raw source slice unless overridden)
 	 */
 	get value() {
-		const v = this._value;
-		if (v !== undefined) return v;
-		return (this._value = this._locConverter._input.slice(
-			this.start,
-			this.end
-		));
+		const input = this._locConverter._input;
+		const type = this.type;
+		// hash (`#name` → `name`) and at-keyword (`@name` → `name`) drop one char.
+		if (type === T_HASH || type === T_AT_KEYWORD) {
+			return input.slice(this.start + 1, this.end);
+		}
+		if (type === T_URL) {
+			const u = /** @type {UrlToken} */ (/** @type {unknown} */ (this));
+			return input.slice(u.contentStart, u.contentEnd);
+		}
+		return input.slice(this.start, this.end);
 	}
 
 	/**
@@ -1297,19 +1378,28 @@ class Token extends Node {
 
 	/**
 	 * Spec type flag. For number / dimension tokens it's "integer" / "number"
-	 * (derived from `value`); for hash tokens it's "id" / "unrestricted" (from the
-	 * stored `_isId`). The two senses share the name in the spec; the getter keeps
-	 * hash tokens the same object shape as numeric tokens (no own `typeFlag`).
+	 * (derived from `value`); for hash tokens it's "id" / "unrestricted" (re-derived
+	 * from the source). The two senses share the name in the spec; both are computed
+	 * on read so every leaf token keeps the same object shape (no own `typeFlag`).
 	 * @returns {"integer" | "number" | "id" | "unrestricted"} the spec type flag
 	 */
 	get typeFlag() {
 		if (this.type === T_HASH) {
-			// `_isId` is set only on hash tokens (see `tokenToNode`), kept off
-			// `Token`'s declared fields so numeric / plain tokens share one shape.
-			const isId = /** @type {{ _isId: boolean }} */ (
-				/** @type {unknown} */ (this)
-			)._isId;
-			return isId ? "id" : "unrestricted";
+			// Re-derive id-ness from the source (whether the name after `#` starts an
+			// ident sequence) rather than storing an `_isId` slot — keeps hash tokens
+			// the same shape as every other leaf token. Matches the lexer's
+			// `consumeNumberSign`, which sets `isId` from the same check.
+			const input = this._locConverter._input;
+			const p = this.start + 1;
+			return _ifThreeCodePointsWouldStartAnIdentSequence(
+				input,
+				p,
+				input.charCodeAt(p),
+				input.charCodeAt(p + 1),
+				input.charCodeAt(p + 2)
+			)
+				? "id"
+				: "unrestricted";
 		}
 		const v = this.value;
 		return _typeFlagOf(
@@ -1333,6 +1423,54 @@ class Token extends Node {
 	}
 }
 
+/**
+ * The non-leaf `Node` subclass: functions, simple blocks, declarations, at-rules
+ * and qualified rules. It declares the union of every container field up front so
+ * all five share **one** hidden class — the consume algorithms only overwrite the
+ * slots relevant to their type, never adding a property, so the shape never
+ * transitions. This caps the shape count: the walker's hot `.type` / `.value` /
+ * `.prelude` loads otherwise see eight distinct node maps (five container types
+ * plus the token / hash / url token maps), tipping V8's inline cache into the
+ * slow megamorphic path; folding the five containers into one leaves four maps
+ * (token, hash, url, container) — within the polymorphic limit, so those loads
+ * stay inline-cached. Unused-for-the-type slots keep their defaults (the field
+ * typedefs below document which fields each type uses). The stylesheet node is
+ * rare (one per parse) and stays a bare `Node`.
+ */
+class Container extends Node {
+	/**
+	 * @param {number} type node type
+	 * @param {number} start byte offset of the node's first code point
+	 * @param {number} end byte offset just past the node's last code point
+	 * @param {LocConverter} locConverter shared loc converter
+	 */
+	constructor(type, start, end, locConverter) {
+		super(type, start, end, locConverter);
+		/** @type {string} name (function / at-rule / declaration) */
+		this.name = "";
+		/** @type {number} */
+		this.nameStart = start;
+		/** @type {number} */
+		this.nameEnd = start;
+		/** @type {ComponentValue[] | null} component values (function / block / declaration) */
+		this.value = null;
+		/** @type {ComponentValue[] | null} prelude (at-rule / qualified rule) */
+		this.prelude = null;
+		/** @type {Declaration[] | null} */
+		this.declarations = null;
+		/** @type {Rule[] | null} */
+		this.childRules = null;
+		/** @type {number} `{` start offset, or -1 (at-rule / qualified rule) */
+		this.blockStart = -1;
+		/** @type {number} `}` end offset, or -1 (at-rule / qualified rule) */
+		this.blockEnd = -1;
+		/** @type {boolean} stripped `!important` (declaration) */
+		this.important = false;
+		/** @type {SimpleBlockToken | undefined} opening char (simple block) */
+		this.token = undefined;
+	}
+}
+
 /**
  * Number token (`123`, `-1.5`, `+2e3`). `value` is the raw source slice (the spec's "value"); `numericValue` / `typeFlag` / `sign` are lazy getters derived from it (see `Token`).
  * @typedef {Token & { numericValue: number, typeFlag: "integer" | "number", sign: "+" | "-" | "" }} NumberToken
@@ -1430,82 +1568,350 @@ class Token extends Node {
  * @typedef {Node & { rules: Rule[] }} Stylesheet
  */
 
+// Lexer-token-type → AST-node-type map. A single \`new Token\` construct site
+// (vs a ~20-case switch with a \`new Token\` in each arm) keeps V8 on the fast
+// monomorphic allocation path — the switch form showed up as generic construct
+// stubs in profiles. URL is the one type with extra own state, handled first.
+const _ttToNodeType = new Uint8Array(27);
+_ttToNodeType[TT_WHITESPACE] = T_WHITESPACE;
+_ttToNodeType[TT_IDENTIFIER] = T_IDENT;
+_ttToNodeType[TT_STRING] = T_STRING;
+_ttToNodeType[TT_DELIM] = T_DELIM;
+_ttToNodeType[TT_NUMBER] = T_NUMBER;
+_ttToNodeType[TT_PERCENTAGE] = T_PERCENTAGE;
+_ttToNodeType[TT_DIMENSION] = T_DIMENSION;
+_ttToNodeType[TT_HASH] = T_HASH;
+_ttToNodeType[TT_AT_KEYWORD] = T_AT_KEYWORD;
+_ttToNodeType[TT_BAD_STRING_TOKEN] = T_BAD_STRING;
+_ttToNodeType[TT_BAD_URL_TOKEN] = T_BAD_URL;
+_ttToNodeType[TT_COLON] = T_COLON;
+_ttToNodeType[TT_COMMA] = T_COMMA;
+_ttToNodeType[TT_SEMICOLON] = T_SEMICOLON;
+_ttToNodeType[TT_RIGHT_PARENTHESIS] = T_RIGHT_PARENTHESIS;
+_ttToNodeType[TT_RIGHT_SQUARE_BRACKET] = T_RIGHT_SQUARE_BRACKET;
+_ttToNodeType[TT_RIGHT_CURLY_BRACKET] = T_RIGHT_CURLY_BRACKET;
+_ttToNodeType[TT_CDO] = T_CDO;
+_ttToNodeType[TT_CDC] = T_CDC;
+
+// === AST construction backend ===
+// The consume algorithms build nodes through these module-level primitives
+// rather than `new Token` / `new Container` directly, so the node
+// representation can be swapped under the parser. The object backend below
+// builds the retainable `Node` / `Token` / `Container` tree the `parseA*`
+// entry points return; the Struct-of-Arrays backend (added separately) writes
+// the same nodes into reused typed arrays for the streaming `grammar`, where
+// per-node allocation dominates cost. Child lists are plain arrays in both
+// backends (a node ref is an object or an integer index); only node creation /
+// 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));
+
+// 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);
+/** @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;
+/** @type {(start: number, end: number, contentStart: number, contentEnd: number) => Node} */
+let _mkUrl;
+/** @type {(type: number, start: number, end: number) => Node} */
+let _mkContainer;
+/** @type {(start: number) => Node} */
+let _mkStylesheet;
+/** @type {(r: Node, v: string, nameStart: number, nameEnd: number) => void} */
+let _setName;
+/** @type {(r: Node, v: number) => void} */
+let _setEnd;
+/** @type {(r: Node, blockStart: number, blockEnd: number) => void} */
+let _setBlock;
+/** @type {(r: Node) => void} */
+let _setImportant;
+/** @type {(r: Node, ch: SimpleBlockToken) => void} */
+let _setToken;
+/** @type {(r: Node, list: Node[]) => void} */
+let _setValue;
+/** @type {(r: Node, list: Node[]) => void} */
+let _setPrelude;
+/** @type {(r: Node, decls: Node[], childRules: Node[]) => void} */
+let _setBody;
+/** @type {(r: Node, list: Node[]) => void} */
+let _setRules;
+/** @type {(r: Node) => number} */
+let _nType;
+/** @type {(r: Node) => number} */
+let _nStart;
+/** @type {(r: Node) => string} */
+let _nValue;
+/** @type {(r: Node) => SimpleBlockToken} */
+let _nToken;
+
+// Child lists are plain arrays in every backend; refs are pushed by value.
+const _list = () => /** @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} */
+const _objUrl = (start, end, cs, ce) => {
+	const u = /** @type {UrlToken} */ (new Token(T_URL, start, end, _lc));
+	u.contentStart = cs;
+	u.contentEnd = ce;
+	return u;
+};
+/** @type {typeof _mkContainer} */
+const _objContainer = (type, start, end) =>
+	new Container(type, start, end, _lc);
+/** @type {typeof _mkStylesheet} */
+const _objStylesheet = (start) => {
+	const s = /** @type {Stylesheet} */ (
+		new Node(T_STYLESHEET, start, start, _lc)
+	);
+	s.rules = [];
+	return s;
+};
+/** @param {LocConverter} lc loc converter for this parse */
+const useObjectBackend = (lc) => {
+	_lc = lc;
+	// `parseA*` return the full tree, so nothing is skipped.
+	_skipTypes = _NO_SKIP_TYPES;
+	_skipActive = false;
+	_skipSelectorPrelude = false;
+	_skipAtRulePrelude = false;
+	_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);
+};
+
+// -- 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
+// `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
+// 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 = [];
+/** @type {(Node[] | null)[]} */
+const _soaL1 = [];
+/** @type {(Node[] | null)[]} */
+const _soaL2 = [];
+let _soaInput = "";
+let _soaLC = /** @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));
+/** @type {(i: number) => Node} */
+const _ref = (i) => /** @type {Node} */ (/** @type {unknown} */ (i));
+
+/** @param {number} need minimum capacity */
+const _soaGrow = (need) => {
+	let cap = _soaCap || 4096;
+	while (cap < need) cap *= 2;
+	const ty = new Uint8Array(cap);
+	ty.set(_soaTy);
+	_soaTy = ty;
+	const st = new Int32Array(cap);
+	st.set(_soaSt);
+	_soaSt = st;
+	const en = new Int32Array(cap);
+	en.set(_soaEn);
+	_soaEn = en;
+	const a0 = new Int32Array(cap);
+	a0.set(_soaA0);
+	_soaA0 = a0;
+	const a1 = new Int32Array(cap);
+	a1.set(_soaA1);
+	_soaA1 = a1;
+	const a2 = new Int32Array(cap);
+	a2.set(_soaA2);
+	_soaA2 = a2;
+	const fl = new Uint8Array(cap);
+	fl.set(_soaFl);
+	_soaFl = fl;
+	_soaCap = cap;
+};
+/** @type {(type: number, start: number, end: number) => Node} */
+const _soaAlloc = (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".
+	// Leaves never read the flag / list slots — `_soaAllocContainer` clears
+	// them instead, keeping the dominant leaf allocation at three writes.
+	const i = _soaN + 1;
+	if (i >= _soaCap) _soaGrow(i + 1);
+	_soaTy[i] = type;
+	_soaSt[i] = start;
+	_soaEn[i] = end;
+	_soaN = i;
+	return _ref(i);
+};
+/** @type {(type: number, start: number, end: number) => Node} */
+const _soaAllocContainer = (type, start, end) => {
+	const r = _soaAlloc(type, start, end);
+	const i = _ix(r);
+	_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;
+	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
+// mid-parse reads and the SoA accessor.
+/**
+ * @param {number} i node id
+ * @returns {string} raw token value
+ */
+const _soaValueOf = (i) => {
+	const ty = _soaTy[i];
+	if (ty === T_HASH || ty === T_AT_KEYWORD) {
+		return _soaInput.slice(_soaSt[i] + 1, _soaEn[i]);
+	}
+	if (ty === T_URL) return _soaInput.slice(_soaA0[i], _soaA1[i]);
+	return _soaInput.slice(_soaSt[i], _soaEn[i]);
+};
+/**
+ * @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) => _soaAllocContainer(type, start, end);
+	_mkStylesheet = (start) => _soaAllocContainer(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)]]);
+};
+
 /**
  * Materialize a single non-block, non-function lexer token as its leaf AST node — the spec's "consume a token" result (§5.4.8 "anything else"), preserving stray closers / CDO / CDC.
  * @param {MutableToken} t token from the lexer
- * @param {string} input source
- * @param {LocConverter} locConverter shared loc converter
- * @returns {Token} the leaf token node
- */
-const tokenToNode = (t, input, locConverter) => {
-	switch (t.type) {
-		case TT_WHITESPACE:
-			return new Token(T_WHITESPACE, t.start, t.end, locConverter);
-		case TT_IDENTIFIER:
-			return new Token(T_IDENT, t.start, t.end, locConverter);
-		case TT_STRING:
-			return new Token(T_STRING, t.start, t.end, locConverter);
-		case TT_DELIM:
-			return new Token(T_DELIM, t.start, t.end, locConverter);
-		// Numeric tokens: construct only — `numericValue` / `typeFlag` / `sign` /
-		// `unit` are lazy `Token` getters, so the `Number()` parse + slices +
-		// `toLowerCase` are skipped for the (common) tokens never read numerically.
-		case TT_NUMBER:
-			return new Token(T_NUMBER, t.start, t.end, locConverter);
-		case TT_PERCENTAGE:
-			return new Token(T_PERCENTAGE, t.start, t.end, locConverter);
-		case TT_DIMENSION:
-			return new Token(T_DIMENSION, t.start, t.end, locConverter);
-		case TT_HASH: {
-			const hash = new Token(T_HASH, t.start, t.end, locConverter);
-			hash._value = input.slice(t.start + 1, t.end);
-			// Store the raw id-ness; the `typeFlag` getter maps it to "id" /
-			// "unrestricted". Kept off `Token`'s declared fields so non-hash
-			// tokens don't carry the slot.
-			/** @type {Token & { _isId: boolean }} */ (hash)._isId = t.isId;
-			return hash;
-		}
-		case TT_AT_KEYWORD: {
-			const at = new Token(T_AT_KEYWORD, t.start, t.end, locConverter);
-			at._value = input.slice(t.start + 1, t.end);
-			return at;
-		}
-		case TT_URL: {
-			const ut = /** @type {CssUrlToken} */ (t);
-			const url = /** @type {UrlToken} */ (
-				new Token(T_URL, t.start, t.end, locConverter)
-			);
-			url._value = input.slice(ut.contentStart, ut.contentEnd);
-			url.contentStart = ut.contentStart;
-			url.contentEnd = ut.contentEnd;
-			return url;
-		}
-		case TT_BAD_STRING_TOKEN:
-			return new Token(T_BAD_STRING, t.start, t.end, locConverter);
-		case TT_BAD_URL_TOKEN:
-			return new Token(T_BAD_URL, t.start, t.end, locConverter);
-		case TT_COLON:
-			return new Token(T_COLON, t.start, t.end, locConverter);
-		case TT_COMMA:
-			return new Token(T_COMMA, t.start, t.end, locConverter);
-		case TT_SEMICOLON:
-			return new Token(T_SEMICOLON, t.start, t.end, locConverter);
-		// Stray closers / CDO / CDC reach here only on malformed input; the spec
-		// preserves them as component values ("consume a token and return it").
-		case TT_RIGHT_PARENTHESIS:
-			return new Token(T_RIGHT_PARENTHESIS, t.start, t.end, locConverter);
-		case TT_RIGHT_SQUARE_BRACKET:
-			return new Token(T_RIGHT_SQUARE_BRACKET, t.start, t.end, locConverter);
-		case TT_RIGHT_CURLY_BRACKET:
-			return new Token(T_RIGHT_CURLY_BRACKET, t.start, t.end, locConverter);
-		case TT_CDO:
-			return new Token(T_CDO, t.start, t.end, locConverter);
-		case TT_CDC:
-			return new Token(T_CDC, t.start, t.end, locConverter);
-		/* istanbul ignore next -- @preserve: unreachable; blocks/functions are routed earlier, comments filtered, EOF guarded by callers */
-		default:
-			throw new Error(`Unexpected token type "${t.type}"`);
+ * @returns {Node} the leaf token node
+ */
+const tokenToNode = (t) => {
+	const tt = t.type;
+	// URL is the only leaf with own state (its content range); all others are a
+	// 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 _mkLeaf(_ttToNodeType[tt], t.start, t.end);
 };
 
 /**
@@ -1555,12 +1961,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 = [];
 	}
@@ -1574,14 +1980,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) {
@@ -1592,11 +1998,11 @@ class TokenStream {
 					pos = t.end;
 					continue;
 				}
-				this._next = t;
 				break;
 			}
+			this._hasNext = true;
 		}
-		return /** @type {MutableToken} */ (this._next);
+		return this._tok;
 	}
 
 	/**
@@ -1609,7 +2015,7 @@ class TokenStream {
 		const t = this.next();
 		if (t.type !== TT_EOF) {
 			this._pos = t.end;
-			this._next = undefined;
+			this._hasNext = false;
 		}
 		return t;
 	}
@@ -1623,7 +2029,7 @@ class TokenStream {
 		const t = this.next();
 		if (t.type !== TT_EOF) {
 			this._pos = t.end;
-			this._next = undefined;
+			this._hasNext = false;
 		}
 	}
 
@@ -1643,7 +2049,7 @@ class TokenStream {
 	 */
 	restoreMark() {
 		this._pos = /** @type {number} */ (this._marks.pop());
-		this._next = undefined;
+		this._hasNext = false;
 	}
 
 	/**
@@ -1697,15 +2103,13 @@ const parseAStylesheet = (input, comment) => {
 	// 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);
+	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} */ (
-		new Node(T_STYLESHEET, start, start, ts.locConverter)
-	);
-	stylesheet.rules = /** @type {Rule[]} */ ([]);
+	const stylesheet = /** @type {Stylesheet} */ (_mkStylesheet(start));
 	// 4. Consume a stylesheet's contents from input, and set the stylesheet's rules to the result.
-	stylesheet.rules = consumeAStylesheetsContents(ts);
-	stylesheet.end = ts.next().start;
+	_setRules(stylesheet, consumeAStylesheetsContents(ts));
+	_setEnd(stylesheet, ts.next().start);
 	// 5. Return the stylesheet.
 	return stylesheet;
 };
@@ -1723,6 +2127,7 @@ const parseAStylesheet = (input, comment) => {
 const parseAStylesheetsContents = (input, comment) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, 0, comment);
+	useObjectBackend(ts.locConverter);
 	// 2. Consume a stylesheet’s contents from input, and return the result.
 	return consumeAStylesheetsContents(ts);
 };
@@ -1738,6 +2143,7 @@ const parseAStylesheetsContents = (input, comment) => {
 const parseABlocksContents = (input, pos, comment) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, comment);
+	useObjectBackend(ts.locConverter);
 	// 2. Consume a block’s contents from input, and return the result.
 	return consumeABlocksContents(ts);
 };
@@ -1755,6 +2161,7 @@ const parseABlocksContents = (input, pos, comment) => {
 const parseARule = (input, pos, comment) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, comment);
+	useObjectBackend(ts.locConverter);
 	// 2. Discard whitespace from input.
 	while (ts.next().type === TT_WHITESPACE) ts.discard();
 	// 3. If the next token from input is an <EOF-token>, return a syntax error.
@@ -1785,6 +2192,7 @@ const parseARule = (input, pos, comment) => {
 const parseADeclaration = (input, pos, comment) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, comment);
+	useObjectBackend(ts.locConverter);
 	// 2. Discard whitespace from input.
 	while (ts.next().type === TT_WHITESPACE) ts.discard();
 	// 3. Consume a declaration from input. If anything was returned, return it. Otherwise, return a syntax error.
@@ -1801,6 +2209,7 @@ const parseADeclaration = (input, pos, comment) => {
 const parseAComponentValue = (input, pos, options = {}) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
+	useObjectBackend(ts.locConverter);
 	// 2. Discard whitespace from input.
 	while (ts.next().type === TT_WHITESPACE) ts.discard();
 	// 3. If input is empty, return a syntax error.
@@ -1825,6 +2234,7 @@ const parseAComponentValue = (input, pos, options = {}) => {
 const parseAListOfComponentValues = (input, pos, 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);
 };
@@ -1843,6 +2253,7 @@ const parseACommaSeparatedListOfComponentValues = (
 ) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
+	useObjectBackend(ts.locConverter);
 	// 2. Let groups be an empty list.
 	/** @type {ComponentValue[][]} */
 	const groups = [];
@@ -1924,17 +2335,23 @@ 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} */ (
-		new Node(T_AT_RULE, head.start, head.end, ts.locConverter)
+		_mkContainer(T_AT_RULE, head.start, head.end)
 	);
-	rule.name = ts.input.slice(head.start + 1, head.end);
-	rule.nameStart = head.start;
-	rule.nameEnd = head.end;
-	rule.prelude = /** @type {ComponentValue[]} */ ([]);
-	rule.declarations = null;
-	rule.childRules = null;
-	// -1 = no block (the `;` / EOF / nested-`}` at-rule forms).
-	rule.blockStart = -1;
-	rule.blockEnd = -1;
+	_setName(
+		rule,
+		ts.input.slice(head.start + 1, head.end),
+		head.start,
+		head.end
+	);
+	const prelude = _list();
+	_setPrelude(rule, prelude);
+	// 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 (;;) {
@@ -1945,7 +2362,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();
-			rule.end = t.start;
+			_setEnd(rule, t.start);
 			return rule;
 		}
 		// <}-token>
@@ -1953,27 +2370,31 @@ 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) {
-				rule.end = t.start;
+				_setEnd(rule, t.start);
 				return rule;
 			}
-			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) {
 			const block = consumeABlock(ts);
-			rule.declarations = block.decls;
-			rule.childRules = block.rules;
-			rule.blockStart = block.blockStart;
-			rule.blockEnd = block.blockEnd;
-			rule.end = block.blockEnd;
+			_setBody(rule, block.decls, block.rules);
+			_setBlock(rule, block.blockStart, block.blockEnd);
+			_setEnd(rule, block.blockEnd);
 			return rule;
 		}
 
 		// anything else
 		// Consume a component value from input and append the returned value to rule’s prelude.
-		rule.prelude.push(consumeAComponentValue(ts));
+		const node = consumeAComponentValue(ts, t);
+		if (!skip) {
+			prelude.push(node);
+		} else if (_nType(node) === T_FUNCTION || _nType(node) === T_URL) {
+			prelude.push(node);
+		}
 	}
 };
 
@@ -1988,7 +2409,7 @@ const consumeAnAtRule = (ts, nested = false) => {
  */
 const consumeATokenAsNode = (ts) => {
 	const t = ts.consume();
-	return tokenToNode(t, ts.input, ts.locConverter);
+	return /** @type {Token} */ (tokenToNode(t));
 };
 
 /**
@@ -2002,14 +2423,19 @@ 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} */ (
-		new Node(T_QUALIFIED_RULE, start, start, ts.locConverter)
+		_mkContainer(T_QUALIFIED_RULE, start, start)
 	);
-	rule.prelude = /** @type {ComponentValue[]} */ ([]);
-	rule.declarations = null;
-	rule.childRules = null;
-	// -1 = no block (EOF reached before `{`).
-	rule.blockStart = -1;
-	rule.blockEnd = -1;
+	const prelude = _list();
+	_setPrelude(rule, prelude);
+	// 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 (;;) {
@@ -2024,7 +2450,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;
-			rule.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>
@@ -2034,31 +2466,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 < rule.prelude.length &&
-				rule.prelude[firstIdx].type === T_WHITESPACE
-			) {
-				firstIdx++;
-			}
-			let secondIdx = firstIdx + 1;
-			while (
-				secondIdx < rule.prelude.length &&
-				rule.prelude[secondIdx].type === 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 &&
+					_nType(prelude[firstIdx]) === T_WHITESPACE
+				) {
+					firstIdx++;
+				}
+				let secondIdx = firstIdx + 1;
+				while (
+					secondIdx < prelude.length &&
+					_nType(prelude[secondIdx]) === T_WHITESPACE
+				) {
+					secondIdx++;
+				}
+				first = prelude[firstIdx];
+				second = prelude[secondIdx];
 			}
-			const first = rule.prelude[firstIdx];
-			const second = rule.prelude[secondIdx];
 			if (
 				first &&
-				first.type === T_IDENT &&
+				_nType(first) === T_IDENT &&
 				// Test the source bytes directly — avoids forcing the lazy `value`
 				// slice just to check the `--` custom-property prefix.
-				ts.input.startsWith("--", first.start) &&
+				ts.input.startsWith("--", _nStart(first)) &&
 				second &&
-				second.type === T_COLON
+				_nType(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) {
@@ -2069,17 +2503,29 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 				return undefined;
 			}
 			const block = consumeABlock(ts);
-			rule.declarations = block.decls;
-			rule.childRules = block.rules;
-			rule.blockStart = block.blockStart;
-			rule.blockEnd = block.blockEnd;
-			rule.end = block.blockEnd;
+			_setBody(rule, block.decls, block.rules);
+			_setBlock(rule, block.blockStart, block.blockEnd);
+			_setEnd(rule, block.blockEnd);
 			return rule;
 		}
 
 		// anything else
 		// Consume a component value from input and append the result to rule’s prelude.
-		rule.prelude.push(consumeAComponentValue(ts));
+		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 = _nType(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);
+		}
 	}
 };
 
@@ -2103,7 +2549,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
  */
@@ -2245,22 +2692,17 @@ const consumeADeclaration = (ts, nested = false) => {
 	const { input } = ts;
 	// Let decl be a new declaration, with an initially empty name and a value set to an empty list.
 	const start = ts.next().start;
+	// name "" / nameStart / nameEnd (= start) / important (false) keep their
+	// `Container` defaults; `value` is set unconditionally at step 5 below.
 	const decl = /** @type {Declaration} */ (
-		new Node(T_DECLARATION, start, start, ts.locConverter)
+		_mkContainer(T_DECLARATION, start, start)
 	);
-	decl.name = "";
-	decl.nameStart = start;
-	decl.nameEnd = start;
-	decl.value = /** @type {ComponentValue[]} */ ([]);
-	decl.important = false;
 
 	// 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();
-		decl.nameStart = head.start;
-		decl.nameEnd = head.end;
-		decl.name = input.slice(head.start, head.end);
+		_setName(decl, input.slice(head.start, head.end), head.start, head.end);
 	} else {
 		consumeTheRemnantsOfABadDeclaration(ts, nested);
 		return undefined;
@@ -2282,51 +2724,42 @@ const consumeADeclaration = (ts, nested = false) => {
 	while (ts.next().type === TT_WHITESPACE) ts.discard();
 
 	// 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.
-	decl.value = consumeAListOfComponentValues(ts, TT_SEMICOLON, nested);
-	decl.end = ts.next().start;
+	const value = consumeAListOfComponentValues(ts, TT_SEMICOLON, nested);
+	_setValue(decl, value);
+	_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 = decl.value.length - 1;
-		while (last >= 0 && decl.value[last].type === T_WHITESPACE) last--;
+		let last = value.length - 1;
+		while (last >= 0 && _nType(value[last]) === T_WHITESPACE) last--;
 		let prev = last - 1;
-		while (prev >= 0 && decl.value[prev].type === T_WHITESPACE) prev--;
+		while (prev >= 0 && _nType(value[prev]) === T_WHITESPACE) prev--;
 		if (
 			prev >= 0 &&
-			decl.value[last].type === T_IDENT &&
-			equalsLowerCase(
-				/** @type {Token} */ (decl.value[last]).value,
-				"important"
-			) &&
-			decl.value[prev].type === T_DELIM &&
-			input.charCodeAt(decl.value[prev].start) === CC_EXCLAMATION
+			_nType(value[last]) === T_IDENT &&
+			equalsLowerCase(_nValue(value[last]), "important") &&
+			_nType(value[prev]) === T_DELIM &&
+			input.charCodeAt(_nStart(value[prev])) === CC_EXCLAMATION
 		) {
-			decl.important = true;
-			decl.value.length = prev;
+			_setImportant(decl);
+			value.length = prev;
 		}
 	}
 
 	// 7. While the last item in decl's value is a <whitespace-token>, remove that token.
-	while (
-		decl.value.length > 0 &&
-		decl.value[decl.value.length - 1].type === T_WHITESPACE
-	) {
-		decl.value.pop();
+	while (value.length > 0 && _nType(value[value.length - 1]) === T_WHITESPACE) {
+		value.pop();
 	}
 
 	// 8. If decl's name starts with "--" (a custom property), it can contain any value (including a top-level `{}` block) — accept it.
 	//    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("--", decl.nameStart);
+	const isCustomProperty = input.startsWith("--", start);
 	if (!isCustomProperty) {
-		const value = decl.value;
 		for (let i = 0; i < value.length; i++) {
 			const v = value[i];
-			if (
-				v.type === T_SIMPLE_BLOCK &&
-				/** @type {SimpleBlock} */ (v).token === "{"
-			) {
+			if (_nType(v) === T_SIMPLE_BLOCK && _nToken(v) === "{") {
 				return undefined;
 			}
 		}
@@ -2361,22 +2794,40 @@ 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[_nType(closer)] !== 1) values.push(closer);
 			continue;
 		}
 		// anything else
 		// Consume a component value from input, and append the result to values.
-		values.push(consumeAComponentValue(ts));
+		// 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[_nType(node)] !== 1) values.push(node);
 	}
 };
 
 /**
  * Consume a component value, CSS Syntax Level 3 [§5.4.8](https://drafts.csswg.org/css-syntax/#consume-component-value) — consumes the next value (simple block, function, or single token); callers guard against EOF before calling.
  * @param {TokenStream} ts token stream
+ * @param {MutableToken=} t the next token, if the caller already peeked it (defaults to `ts.next()`)
  * @returns {SimpleBlock | FunctionNode | ComponentValue} the consumed component value
  */
-const consumeAComponentValue = (ts) => {
-	const t = ts.next();
+const consumeAComponentValue = (ts, t = ts.next()) => {
+	// `t` is the next token; hot callers already peeked it and pass it in to
+	// skip a redundant `ts.next()` per component value.
 	// <{-token> / <[-token> / <(-token> (the three contiguous opening brackets)
 	// Consume a simple block from input and return the result.
 	if (t.type >= TT_LEFT_PARENTHESIS && t.type <= TT_LEFT_CURLY_BRACKET) {
@@ -2389,7 +2840,11 @@ const consumeAComponentValue = (ts) => {
 	}
 	// anything else
 	// Consume a token from input and return the result. (Asserted: not EOF.)
-	return consumeATokenAsNode(ts);
+	// Inlined `consumeATokenAsNode`: `t` is already the peeked next token, so
+	// advance past it and materialize it directly — one fewer call per leaf
+	// component value (the bulk of the nodes on a large stylesheet).
+	ts.consume();
+	return /** @type {ComponentValue} */ (tokenToNode(t));
 };
 
 /**
@@ -2406,10 +2861,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} */ (
-		new Node(T_SIMPLE_BLOCK, open.start, open.end, ts.locConverter)
+		_mkContainer(T_SIMPLE_BLOCK, open.start, open.end)
 	);
-	block.token = token;
-	block.value = /** @type {ComponentValue[]} */ ([]);
+	_setToken(block, token);
+	const val = _list();
+	_setValue(block, val);
 
 	// Discard a token from input.
 	ts.discard();
@@ -2423,13 +2879,13 @@ const consumeASimpleBlock = (ts) => {
 		// Discard a token from input. Return block.
 		if (t.type === TT_EOF || t.type === ending) {
 			ts.discard();
-			block.end = t.end;
+			_setEnd(block, t.end);
 			return block;
 		}
 
 		// anything else
 		// Consume a component value from input and append the result to block’s value.
-		block.value.push(consumeAComponentValue(ts));
+		val.push(consumeAComponentValue(ts, t));
 	}
 };
 
@@ -2439,17 +2895,16 @@ const consumeASimpleBlock = (ts) => {
  * @returns {FunctionNode | undefined} the consumed function node
  */
 const consumeAFunction = (ts) => {
-	const { input, locConverter } = 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} */ (
-		new Node(T_FUNCTION, tFn.start, tFn.end, locConverter)
+		_mkContainer(T_FUNCTION, tFn.start, tFn.end)
 	);
-	fn.name = input.slice(tFn.start, tFn.end - 1);
-	fn.nameStart = tFn.start;
-	fn.nameEnd = tFn.end - 1;
-	fn.value = /** @type {ComponentValue[]} */ ([]);
+	_setName(fn, input.slice(tFn.start, tFn.end - 1), tFn.start, tFn.end - 1);
+	const val = _list();
+	_setValue(fn, val);
 
 	// Process input
 	for (;;) {
@@ -2460,13 +2915,25 @@ const consumeAFunction = (ts) => {
 			// <)-token>
 			// Discard a token from input. Return function.
 			ts.discard();
-			fn.end = t.end;
+			_setEnd(fn, t.end);
 			return fn;
 		}
 
 		// anything else
 		// Consume a component value from input and append the result to function’s value.
-		fn.value.push(consumeAComponentValue(ts));
+		// 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[_nType(node)] !== 1) val.push(node);
 	}
 };
 
@@ -2644,11 +3111,10 @@ const unescapeIdentifier = makeCacheable(_unescapeIdentifier);
 // 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
  */
 
 /**
@@ -2672,9 +3138,17 @@ 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)
  */
 
 /**
@@ -2688,17 +3162,36 @@ 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 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;
 	const recurseBlocks = options.recurseBlocks !== false;
 
-	// Babel's `path.skip()`, children-only. Reset per `enter` dispatch.
-	let skipFlag = false;
-	const visitorCtx = {
-		skipChildren() {
-			skipFlag = true;
-		}
-	};
+	// 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.
+	const commentBucket = visitors[T_COMMENT];
+	const onComment =
+		commentBucket === undefined
+			? undefined
+			: /** @type {(input: string, start: number, end: number) => number} */ (
+					(_input, start, end) => {
+						const node = _soaAlloc(T_COMMENT, start, end);
+						_curNode = node;
+						_curParent = null;
+						const e = commentBucket.enter;
+						for (let i = 0; i < e.length; i++) e[i](A);
+						const x = commentBucket.exit;
+						for (let i = 0; i < x.length; i++) x[i](A);
+						return end;
+					}
+				);
 
 	/**
 	 * Walk a component-value subtree; children are already materialized. Fetches
@@ -2708,29 +3201,28 @@ const grammar = (input, visitors, options) => {
 	 * @param {Node | null} parent enclosing node
 	 */
 	const walkValue = (node, parent) => {
-		const b = visitors[node.type];
+		const ty = _soaTy[_ix(node)];
+		const b = visitors[ty];
 		let skip = false;
 		if (b !== undefined && b.enter.length !== 0) {
-			skipFlag = false;
+			_walkSkip = false;
+			_curNode = node;
+			_curParent = parent;
 			const e = b.enter;
-			for (let i = 0; i < e.length; i++) e[i](node, parent, visitorCtx);
-			skip = skipFlag;
-			skipFlag = false;
+			for (let i = 0; i < e.length; i++) e[i](A);
+			skip = _walkSkip;
+			_walkSkip = false;
 		}
-		if (!skip) {
-			switch (node.type) {
-				case T_FUNCTION:
-				case T_SIMPLE_BLOCK: {
-					const v = /** @type {FunctionNode | SimpleBlock} */ (node).value;
-					for (let i = 0; i < v.length; i++) walkValue(v[i], node);
-					break;
-				}
-				// All other types are leaf tokens.
-			}
+		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) {
+			// Rebind: descending into children moved the path.
+			_curNode = node;
+			_curParent = parent;
 			const x = b.exit;
-			for (let i = 0; i < x.length; i++) x[i](node, parent, visitorCtx);
+			for (let i = 0; i < x.length; i++) x[i](A);
 		}
 	};
 
@@ -2741,54 +3233,67 @@ const grammar = (input, visitors, options) => {
 	 * @param {Node | null} parent enclosing node
 	 */
 	const walkRule = (node, parent) => {
-		const b = visitors[node.type];
+		const i0 = _ix(node);
+		const ty = _soaTy[i0];
+		const b = visitors[ty];
 		let skip = false;
 		if (b !== undefined && b.enter.length !== 0) {
-			skipFlag = false;
+			_walkSkip = false;
+			_curNode = node;
+			_curParent = parent;
 			const e = b.enter;
-			for (let i = 0; i < e.length; i++) e[i](node, parent, visitorCtx);
-			skip = skipFlag;
-			skipFlag = false;
+			for (let i = 0; i < e.length; i++) e[i](A);
+			skip = _walkSkip;
+			_walkSkip = false;
 		}
 		if (!skip) {
-			switch (node.type) {
-				case T_AT_RULE:
-				case T_QUALIFIED_RULE: {
-					const r = /** @type {AtRule | QualifiedRule} */ (node);
-					const p = r.prelude;
-					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 = r.declarations;
-						if (decls) {
-							for (let i = 0; i < decls.length; i++) walkRule(decls[i], node);
-						}
-						const ch = r.childRules;
-						if (ch) for (let i = 0; i < ch.length; i++) walkRule(ch[i], node);
+			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);
 					}
-					break;
-				}
-				case T_DECLARATION: {
-					const v = /** @type {Declaration} */ (node).value;
-					for (let i = 0; i < v.length; i++) walkValue(v[i], node);
-					break;
+					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) {
+			// Rebind: descending into children moved the path.
+			_curNode = node;
+			_curParent = parent;
 			const x = b.exit;
-			for (let i = 0; i < x.length; i++) x[i](node, parent, visitorCtx);
+			for (let i = 0; i < x.length; i++) x[i](A);
 		}
 	};
 
 	// 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, onComment);
 	const consume =
 		TOP_LEVEL_CONSUMERS[options.as || "stylesheet"] ||
 		consumeAStylesheetsContents;
-	consume(ts, (node) => walkRule(node, null));
+	try {
+		consume(ts, (node) => {
+			walkRule(node, null);
+			_soaN = 0;
+		});
+	} finally {
+		// Drop the module-level SoA references so the last parsed source (and
+		// its LocConverter / child lists) don't stay alive between parses.
+		_soaInput = "";
+		_soaLC = /** @type {LocConverter} */ (/** @type {unknown} */ (null));
+		_soaL0.length = 0;
+		_soaL1.length = 0;
+		_soaL2.length = 0;
+	}
 };
 
 /**
@@ -2796,23 +3301,303 @@ 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 */
+
+// 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 _curNode = /** @type {Node} */ (/** @type {unknown} */ (0));
+/** @type {Node | null} */
+let _curParent = 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` /
+// `Container` objects (`n` is a node); the Struct-of-Arrays migration rewrites
+// the bodies to index typed arrays (`n` becomes an integer node id) without any
+// consumer edit. `value` is the leaf-token string; container child lists are
+// `children` / `prelude` / `declarations` / `childRules`.
+const A = {
+	// === path position (rebound by the walk before every visitor call) ===
+	/**
+	 * @returns {Node} current node — only valid during a visitor callback
+	 */
+	get node() {
+		return _curNode;
+	},
+	/**
+	 * @returns {Node | null} enclosing node (null = a top-level node)
+	 */
+	get parent() {
+		return _curParent;
+	},
+	/** Stop the walk descending into the current node (enter only). */
+	skipChildren() {
+		_walkSkip = true;
+	},
+	// === field reads — `n` defaults to the current node ===
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} node type
+	 */
+	type(n = _curNode) {
+		return _soaTy[_ix(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} start offset
+	 */
+	start(n = _curNode) {
+		return _soaSt[_ix(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} end offset
+	 */
+	end(n = _curNode) {
+		return _soaEn[_ix(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {[number, number]} start / end offsets
+	 */
+	range(n = _curNode) {
+		const i = _ix(n);
+		return [_soaSt[i], _soaEn[i]];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {{ start: { line: number, column: number }, end: { line: number, column: number } }} source location
+	 */
+	loc(n = _curNode) {
+		const i = _ix(n);
+		const lc = _soaLC;
+		const s = lc.get(_soaSt[i]);
+		const sl = s.line;
+		const sc = s.column;
+		const e = lc.get(_soaEn[i]);
+		return {
+			start: { line: sl, column: sc },
+			end: { line: e.line, column: e.column }
+		};
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} raw source slice
+	 */
+	source(n = _curNode) {
+		const i = _ix(n);
+		return _soaInput.slice(_soaSt[i], _soaEn[i]);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} raw token value
+	 */
+	value(n = _curNode) {
+		return _soaValueOf(_ix(n));
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} unescaped token value
+	 */
+	unescaped(n = _curNode) {
+		const i = _ix(n);
+		const v = _soaValueOf(i);
+		return _soaTy[i] === T_STRING
+			? unescapeIdentifier(v.slice(1, -1))
+			: unescapeIdentifier(v);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} hash / numeric type flag
+	 */
+	typeFlag(n = _curNode) {
+		const i = _ix(n);
+		if (_soaTy[i] === T_HASH) {
+			const input = _soaInput;
+			const p = _soaSt[i] + 1;
+			return _ifThreeCodePointsWouldStartAnIdentSequence(
+				input,
+				p,
+				input.charCodeAt(p),
+				input.charCodeAt(p + 1),
+				input.charCodeAt(p + 2)
+			)
+				? "id"
+				: "unrestricted";
+		}
+		const v = _soaValueOf(i);
+		return _typeFlagOf(
+			_soaTy[i] === T_DIMENSION ? v.slice(0, _consumeANumber(v, 0)) : v
+		);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} url content start offset
+	 */
+	contentStart(n = _curNode) {
+		return _soaA0[_ix(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} url content end offset
+	 */
+	contentEnd(n = _curNode) {
+		return _soaA1[_ix(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} rule / declaration / function name
+	 */
+	name(n = _curNode) {
+		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 {number} name start offset
+	 */
+	nameStart(n = _curNode) {
+		return _soaSt[_ix(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} name end offset
+	 */
+	nameEnd(n = _curNode) {
+		return _soaA0[_ix(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {string} unescaped name
+	 */
+	unescapedName(n = _curNode) {
+		return unescapeIdentifier(A.name(n));
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {ComponentValue[]} function / block children
+	 */
+	children(n = _curNode) {
+		return /** @type {ComponentValue[]} */ (_soaL0[_ix(n)]);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {ComponentValue[]} rule prelude
+	 */
+	prelude(n = _curNode) {
+		return /** @type {ComponentValue[]} */ (_soaL0[_ix(n)]);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {Declaration[] | null} block declarations
+	 */
+	declarations(n = _curNode) {
+		return /** @type {Declaration[] | null} */ (_soaL1[_ix(n)]);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {Rule[] | null} block child rules
+	 */
+	childRules(n = _curNode) {
+		return /** @type {Rule[] | null} */ (_soaL2[_ix(n)]);
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} block start offset
+	 */
+	blockStart(n = _curNode) {
+		return _soaA1[_ix(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} block end offset
+	 */
+	blockEnd(n = _curNode) {
+		return _soaA2[_ix(n)];
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {boolean} `!important` flag
+	 */
+	important(n = _curNode) {
+		return (_soaFl[_ix(n)] & 1) !== 0;
+	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {SimpleBlockToken} block opening token
+	 */
+	blockToken(n = _curNode) {
+		return /** @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. 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) {
+		_soaEn[_ix(n)] = v;
+	},
+	/**
+	 * @param {Node} n node
+	 * @param {number} v new block end offset
+	 */
+	setBlockEnd(n, v) {
+		_soaA2[_ix(n)] = v;
+	}
+};
+
 // The two AST runtime classes — `Node` and its sole subclass `Token` (the
 // other node shapes are `@typedef`s over `Node`, exported as types only). Plus
 // the full CSS-Syntax-3 §5.3 `parseA*` entry-point surface, `consumeASimpleBlock`
 // (the one §5.4 algorithm exposed as a byte entry point for `CssParser`), the
 // `TokenStream` (so callers can pass a pre-built stream to any `parseA*`), and
 // the `escape` / `unescapeIdentifier` string utils.
+module.exports.A = A;
 module.exports.Node = Node;
 module.exports.NodeType = NodeType;
 module.exports.SourceProcessor = SourceProcessor;
@@ -2844,6 +3629,7 @@ 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.parseABlocksContents = parseABlocksContents;