webpack 5.108.1 → 5.108.3

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,18 +297,6 @@ 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;
-
 /**
  * @param {number} cc char code
  * @returns {boolean} true, if cc is a digit
@@ -482,11 +469,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;
 		}
@@ -950,6 +943,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 +1043,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 +1111,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).
@@ -1240,26 +1306,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 +1365,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 +1410,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 +1555,320 @@ 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));
+
+/** @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;
+	_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".
+	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);
+};
+// 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) => _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)]]);
+};
+
 /**
  * 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);
 };
 
 /**
@@ -1697,15 +2060,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 +2084,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 +2100,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 +2118,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 +2149,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 +2166,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 +2191,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 +2210,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 +2292,18 @@ 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)
+	);
+	_setName(
+		rule,
+		ts.input.slice(head.start + 1, head.end),
+		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;
+	const prelude = _list();
+	_setPrelude(rule, prelude);
+	// declarations / childRules / blockStart (-1) / blockEnd (-1) keep their
+	// defaults (no block: the `;` / EOF / nested-`}` at-rule forms).
 
 	// Process input
 	for (;;) {
@@ -1945,7 +2314,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 +2322,25 @@ 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));
+			prelude.push(consumeATokenAsNode(ts));
 			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));
+		prelude.push(consumeAComponentValue(ts, t));
 	}
 };
 
@@ -1988,7 +2355,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 +2369,12 @@ 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).
 
 	// Process input
 	for (;;) {
@@ -2024,7 +2389,7 @@ 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));
+			prelude.push(consumeATokenAsNode(ts));
 			continue;
 		}
 		// <{-token>
@@ -2037,28 +2402,28 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 			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 < prelude.length &&
+				_nType(prelude[firstIdx]) === T_WHITESPACE
 			) {
 				firstIdx++;
 			}
 			let secondIdx = firstIdx + 1;
 			while (
-				secondIdx < rule.prelude.length &&
-				rule.prelude[secondIdx].type === T_WHITESPACE
+				secondIdx < prelude.length &&
+				_nType(prelude[secondIdx]) === T_WHITESPACE
 			) {
 				secondIdx++;
 			}
-			const first = rule.prelude[firstIdx];
-			const second = rule.prelude[secondIdx];
+			const first = prelude[firstIdx];
+			const second = 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 +2434,15 @@ 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));
+		prelude.push(consumeAComponentValue(ts, t));
 	}
 };
 
@@ -2245,22 +2608,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 +2640,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;
 			}
 		}
@@ -2366,17 +2715,19 @@ const consumeAListOfComponentValues = (ts, stopToken, nested = false) => {
 		}
 		// anything else
 		// Consume a component value from input, and append the result to values.
-		values.push(consumeAComponentValue(ts));
+		values.push(consumeAComponentValue(ts, t));
 	}
 };
 
 /**
  * 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 +2740,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 +2761,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 +2779,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 +2795,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 +2815,13 @@ 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));
+		val.push(consumeAComponentValue(ts, t));
 	}
 };
 
@@ -2690,6 +3045,7 @@ const TOP_LEVEL_CONSUMERS = {
 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.
@@ -2708,7 +3064,8 @@ 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;
@@ -2717,16 +3074,9 @@ const grammar = (input, visitors, options) => {
 			skip = skipFlag;
 			skipFlag = 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) {
 			const x = b.exit;
@@ -2741,7 +3091,9 @@ 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;
@@ -2751,28 +3103,21 @@ const grammar = (input, visitors, options) => {
 			skipFlag = 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) {
@@ -2788,7 +3133,10 @@ const grammar = (input, visitors, options) => {
 	const consume =
 		TOP_LEVEL_CONSUMERS[options.as || "stylesheet"] ||
 		consumeAStylesheetsContents;
-	consume(ts, (node) => walkRule(node, null));
+	consume(ts, (node) => {
+		walkRule(node, null);
+		_soaN = 0;
+	});
 };
 
 /**
@@ -2807,12 +3155,127 @@ class SourceProcessor extends GenericSourceProcessor {
 	}
 }
 
+// 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 = {
+	/** @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]];
+	},
+	/** @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]);
+		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 }
+		};
+	},
+	/** @type {(n: Node) => string} */
+	source: (n) => {
+		const i = _ix(n);
+		return _soaInput.slice(_soaSt[i], _soaEn[i]);
+	},
+	/** @type {(n: Node) => string} */
+	value: (n) => _soaValueOf(_ix(n)),
+	/** @type {(n: Node) => string} */
+	unescaped: (n) => {
+		const i = _ix(n);
+		const v = _soaValueOf(i);
+		return _soaTy[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) {
+			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
+		);
+	},
+	/** @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]);
+	},
+	/** @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;
+	},
+	/** @type {(n: Node, v: number) => void} */
+	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;