@depup/webpack 5.109.0-depup.0 → 5.109.2-depup.0

package/lib/css/syntax.js

@@ -683,6 +683,15 @@ function consumeSpace(input, pos, out) {
 	return fill(out, TT_WHITESPACE, start, pos);
 }
 
+// Sticky fast-forward classes: a native run-skip over the ordinary characters of
+// a string / url token, so long values (data: URIs, base64) don't cost one JS
+// char read each. The negated classes match exactly the per-char terminators the
+// loops below handle (quotes / backslash / newlines for strings; plus `(`, `)`,
+// whitespace and non-printable code points for urls).
+const _STRING_SAFE = /[^"'\\\n\r\f]+/y;
+// eslint-disable-next-line no-control-regex -- url terminators include the control range and DEL (they make a bad-url)
+const _URL_SAFE = /[^\u0000-\u0020\u007F"'()\\]+/y;
+
 /**
  * Consume a string token. Caller advanced past the opening quote so
  * `pos - 1` holds the ending code point and `pos - 1` is the start.
@@ -695,6 +704,8 @@ function consumeAStringToken(input, pos, out) {
 	const start = pos - 1;
 	const endingCodePoint = input.charCodeAt(pos - 1);
 	for (;;) {
+		_STRING_SAFE.lastIndex = pos;
+		if (_STRING_SAFE.test(input)) pos = _STRING_SAFE.lastIndex;
 		if (pos === input.length) {
 			return fill(out, TT_STRING, start, pos);
 		}
@@ -874,6 +885,8 @@ function consumeAUrlToken(input, pos, fnStart, out) {
 	const contentStart = pos;
 	out.contentStart = contentStart;
 	for (;;) {
+		_URL_SAFE.lastIndex = pos;
+		if (_URL_SAFE.test(input)) pos = _URL_SAFE.lastIndex;
 		if (pos === input.length) {
 			out.contentEnd = pos;
 			return fill(out, TT_URL, fnStart, pos);
@@ -1289,78 +1302,23 @@ const {
 } = NodeType;
 
 /**
- * Base AST node. All concrete nodes (tokens, simple blocks, functions,
- * declarations) inherit from this and carry the `[start, end)` byte `range`
- * of the source slice they cover. `loc` is computed on demand from a
- * shared `LocConverter` so we don't pay for line/column conversion until
- * a consumer (warning, error, dependency) actually needs it.
+ * Base AST node — the property-accessor view the `parseA*` entry points return
+ * (see `_makeReader`). Every concrete node carries the `[start, end)` byte
+ * `range` of the source slice it covers; `loc` is computed on demand from the
+ * shared `LocConverter`, so line/column conversion is only paid when a consumer
+ * needs it. The concrete node typedefs below extend this via `&`.
+ *
+ * Inside the parser a node ref is an integer id into the columns; the reader
+ * exposes this property shape over a retained snapshot of those columns.
+ * @typedef {object} Node
+ * @property {number} type node-type discriminator
+ * @property {number} start byte offset of the node's first code point
+ * @property {number} end byte offset just past the node's last code point
+ * @property {[number, number]} range the `[start, end)` byte range
+ * @property {{ start: { line: number, column: number }, end: { line: number, column: number } }} loc source location (1-based line, 0-based column)
+ * @property {() => string} toString source slice for this node
+ * @property {string} unescapedName name with CSS escapes resolved (name-bearing nodes only)
  */
-class Node {
-	/**
-	 * @param {number} type node type discriminator
-	 * @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) {
-		/** @type {number} */
-		this.type = type;
-		// Byte range as two inline fields rather than a `[start, end]` array —
-		// one fewer allocation per node and ~56 bytes lighter (×100k+ nodes).
-		/** @type {number} */
-		this.start = start;
-		/** @type {number} */
-		this.end = end;
-		/** @type {LocConverter} */
-		this._locConverter = locConverter;
-	}
-
-	/**
-	 * The `[start, end)` byte range as a tuple — compatibility view over
-	 * `start` / `end` (builds the array lazily; hot code reads the
-	 * fields directly).
-	 * @returns {[number, number]} the byte range
-	 */
-	get range() {
-		return [this.start, this.end];
-	}
-
-	get loc() {
-		const lc = this._locConverter;
-		// `LocConverter#get` mutates and returns the converter itself, so we
-		// must snapshot `line`/`column` between the two calls.
-		const s = lc.get(this.start);
-		const sl = s.line;
-		const sc = s.column;
-		const e = lc.get(this.end);
-		return {
-			start: { line: sl, column: sc },
-			end: { line: e.line, column: e.column }
-		};
-	}
-
-	/**
-	 * Serialize back to source — re-slices the original input (zero-alloc for
-	 * untouched nodes).
-	 * @returns {string} the source slice for this node
-	 */
-	toString() {
-		return this._locConverter._input.slice(this.start, this.end);
-	}
-
-	/**
-	 * For name-bearing nodes (function / at-rule): the `name` with CSS escapes
-	 * resolved, for case-insensitive keyword matching (`\75 rl` → `url`). Computed
-	 * on read via `unescapeIdentifier`'s no-escape fast path. Callers without a
-	 * `name` must not read this.
-	 * @returns {string} the unescaped name
-	 */
-	get unescapedName() {
-		return unescapeIdentifier(
-			/** @type {{ name: string }} */ (/** @type {unknown} */ (this)).name
-		);
-	}
-}
 
 /**
  * @param {string} s numeric text
@@ -1379,175 +1337,15 @@ const _typeFlagOf = (s) =>
 	s.includes(".") || s.includes("e") || s.includes("E") ? "number" : "integer";
 
 /**
- * Leaf token node — the only `Node` subclass. `value` is the raw source slice
+ * Leaf token node (property-accessor view) — `value` is the raw source slice
  * (identifier text, quoted string including quotes, a dimension's full `123px`,
- * …). Token-specific extras are named by the `HashToken` / `UrlToken` /
- * `NumberToken` / `DimensionToken` shape typedefs below.
- *
- * The numeric accessors (`numericValue` / `typeFlag` / `sign` / `unit`) are
- * getters, not stored fields: a number / dimension / percentage token costs
- * nothing beyond the base node unless a consumer reads them, and every leaf
- * token keeps a single object shape so the walker's `node.type` dispatch stays
- * monomorphic. They are only meaningful on the matching token type.
+ * …; hash / at-keyword drop their `#` / `@` prefix, url uses its content range).
+ * The `NumberToken` / `HashToken` / `UrlToken` / `DimensionToken` typedefs below
+ * narrow the value accessors. `numericValue` / `typeFlag` / `sign` / `unit` are
+ * derived from the source on read and are only meaningful on the matching token
+ * type; `contentStart` / `contentEnd` mark a url token's inner content range.
+ * @typedef {Node & { value: string, unescaped: string, numericValue: number, typeFlag: "integer" | "number" | "id" | "unrestricted", sign: "+" | "-" | "", unit: string, contentStart: number, contentEnd: number }} Token
  */
-class Token extends Node {
-	/**
-	 * @param {number} type node type
-	 * @param {number} start byte offset of the token's first code point
-	 * @param {number} end byte offset just past the token's last code point
-	 * @param {LocConverter} locConverter shared loc converter
-	 */
-	// 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 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);
-	}
-
-	/**
-	 * The token's value with CSS escapes resolved (`\2d` → `-`, `\75 rl` → `url`),
-	 * per https://www.w3.org/TR/css-syntax-3/#consume-escaped-code-point — the
-	 * form to match keywords / export as a CSS-Modules name against. For a string
-	 * token it is the content between the quotes (the spec string value). Computed
-	 * on read; `unescapeIdentifier` fast-returns the value unchanged when it has no
-	 * escapes (the common case), so nothing is stored per token.
-	 * @returns {string} the unescaped value
-	 */
-	get unescaped() {
-		const v = this.value;
-		// A string token's `value` carries its delimiting quotes; its value is the content between them.
-		return this.type === T_STRING
-			? unescapeIdentifier(v.slice(1, -1))
-			: unescapeIdentifier(v);
-	}
-
-	/**
-	 * Parsed numeric value (number / percentage / dimension tokens). Derived from
-	 * `value` on access — the `%` is dropped for percentages and the unit for
-	 * dimensions (split with `_consumeANumber`, recomputed here so nothing is
-	 * stored per token).
-	 * @returns {number} the parsed numeric value
-	 */
-	get numericValue() {
-		const v = this.value;
-		if (this.type === T_DIMENSION) {
-			return Number(v.slice(0, _consumeANumber(v, 0)));
-		}
-		if (this.type === T_PERCENTAGE) return Number(v.slice(0, -1));
-		return Number(v);
-	}
-
-	/**
-	 * Spec type flag. For number / dimension tokens it's "integer" / "number"
-	 * (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) {
-			// 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(
-			this.type === T_DIMENSION ? v.slice(0, _consumeANumber(v, 0)) : v
-		);
-	}
-
-	/**
-	 * @returns {"+" | "-" | ""} the spec sign (number / percentage / dimension tokens)
-	 */
-	get sign() {
-		return _signOf(this.value);
-	}
-
-	/**
-	 * @returns {string} the unit, lower-cased per spec (dimension tokens)
-	 */
-	get unit() {
-		const v = this.value;
-		return v.slice(_consumeANumber(v, 0)).toLowerCase();
-	}
-}
-
-/**
- * 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`).
@@ -1646,10 +1444,10 @@ class Container 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.
+// Lexer-token-type → AST-node-type map. A single `_makeLeaf` call site (vs a
+// ~20-case switch with an alloc in each arm) keeps V8 on the fast monomorphic
+// path — the switch form showed up as generic 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;
@@ -1671,21 +1469,14 @@ _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 _objLocConverter = /** @type {LocConverter} */ (
-	/** @type {unknown} */ (null)
-);
+// === AST construction ===
+// Nodes live in one struct-of-arrays node store: a node ref is an integer id
+// into parallel typed-array columns, so per-node allocation is avoided entirely.
+// The consume algorithms build nodes through the `_make*` / `_set*` primitives
+// below, which write those columns directly. The streaming `grammar` walks each
+// top-level node and recycles the columns; the `parseA*` entry points instead
+// retain the columns as a snapshot and hand back property-accessor nodes over it
+// (see `_makeReader`). Child lists are plain arrays of node ids in both modes.
 
 // Active skip state (from `CssProcessOptions.skip`), applied by the grammar.
 // `_skipTypes` is indexed by `NodeType` (1 = skip): drop that component-value
@@ -1694,7 +1485,7 @@ let _objLocConverter = /** @type {LocConverter} */ (
 // / 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.
+// `parseA*` leave these at their no-skip defaults so they build the full tree.
 const _NO_SKIP_TYPES = new Uint8Array(32);
 // Shared frozen empty list for block bodies with no decls / no child rules (the
 // common case — most rules carry only declarations). Every consumer reads these
@@ -1711,227 +1502,71 @@ let _skipActive = false;
 let _skipSelectorPrelude = false;
 let _skipAtRulePrelude = false;
 
-/** @type {(type: number, start: number, end: number) => Node} */
-let _makeLeaf;
-/** @type {(start: number, end: number, contentStart: number, contentEnd: number) => Node} */
-let _makeUrl;
-/** @type {(type: number, start: number, end: number) => Node} */
-let _makeContainer;
-/** @type {(start: number) => Node} */
-let _makeStylesheet;
-// Offsets only — the object backend derives the name string itself (an
-// at-rule's name skips its `@`), so the SoA backend never pays for a slice
-// it would immediately discard (it re-derives names from offsets on read).
-/** @type {(r: Node, nameStart: number, nameEnd: number) => void} */
-let _setName;
-/** @type {(r: Node, v: number) => void} */
-let _setEnd;
-/** @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 _nodeTypeOf;
-/** @type {(r: Node) => number} */
-let _nodeStartOf;
-/** @type {(r: Node) => string} */
-let _nodeValueOf;
-/** @type {(r: Node) => SimpleBlockToken} */
-let _nodeTokenOf;
-
-// Child lists are plain arrays in every backend; refs are pushed by value.
-// Content-list allocation: the object backend uses a per-site `[]` literal
-// (each site keeps its own V8 allocation site — a shared helper collapses them
-// and defeats escape analysis / pretenuring), the SoA backend recycles scratch
-// arrays through a pool — a sealed list is copied into the flat value buffer
-// and its array returned to the pool by `_soaSetValue`, so the streaming parse
-// allocates no per-list array. An abandoned (never-sealed) list simply falls
-// out of the pool. `_soaActive` gates the pool at each site.
-let _soaActive = false;
+// Scratch content-list pool: a container's value / prelude is built in a plain
+// array, then sealed into the flat value buffer by `_setValue`, which returns
+// the array to the pool — so a parse allocates almost no per-list arrays. An
+// abandoned (never-sealed) list simply falls out of the pool.
 /** @type {Node[][]} */
 const _listPool = [];
-const _soaList = () =>
+const _takeList = () =>
 	_listPool.length > 0
 		? /** @type {Node[]} */ (_listPool.pop())
 		: /** @type {Node[]} */ ([]);
 
-// -- object backend: builds the retainable class-instance tree --
-/** @type {typeof _makeLeaf} */
-const _objLeaf = (type, start, end) =>
-	new Token(type, start, end, _objLocConverter);
-/** @type {typeof _makeUrl} */
-const _objUrl = (start, end, cs, ce) => {
-	const u = /** @type {UrlToken} */ (
-		new Token(T_URL, start, end, _objLocConverter)
-	);
-	u.contentStart = cs;
-	u.contentEnd = ce;
-	return u;
-};
-/** @type {typeof _makeContainer} */
-const _objContainer = (type, start, end) =>
-	new Container(type, start, end, _objLocConverter);
-/** @type {typeof _makeStylesheet} */
-const _objStylesheet = (start) => {
-	const s = /** @type {Stylesheet} */ (
-		new Node(T_STYLESHEET, start, start, _objLocConverter)
-	);
-	s.rules = [];
-	return s;
-};
-// The backend function sets are module-level constants (not closures rebuilt
-// per parse): the dispatch slots keep one function identity forever, so the
-// per-node call sites in the consume algorithms stay monomorphic instead of
-// seeing a fresh closure per parse. They capture only module-level state.
-/** @type {typeof _setName} */
-const _objSetName = (r, ns, ne) => {
-	const c = /** @type {Container} */ (r);
-	// An at-rule's `nameStart` points at its `@`, which the name excludes.
-	c.name = _objLocConverter._input.slice(
-		r.type === T_AT_RULE ? ns + 1 : ns,
-		ne
-	);
-	c.nameStart = ns;
-	c.nameEnd = ne;
-};
-/** @type {typeof _setEnd} */
-const _objSetEnd = (r, v) => {
-	r.end = v;
-};
-/** @type {typeof _setBlock} */
-const _objSetBlock = (r, bs, be) => {
-	const c = /** @type {Container} */ (r);
-	c.blockStart = bs;
-	c.blockEnd = be;
-};
-/** @type {typeof _setImportant} */
-const _objSetImportant = (r) => {
-	/** @type {Container} */ (r).important = true;
-};
-/** @type {typeof _setToken} */
-const _objSetToken = (r, ch) => {
-	/** @type {Container} */ (r).token = ch;
-};
-/** @type {typeof _setValue} */
-const _objSetValue = (r, list) => {
-	/** @type {Container} */ (r).value = /** @type {ComponentValue[]} */ (list);
-};
-/** @type {typeof _setPrelude} */
-const _objSetPrelude = (r, list) => {
-	/** @type {Container} */ (r).prelude = /** @type {ComponentValue[]} */ (list);
-};
-/** @type {typeof _setBody} */
-const _objSetBody = (r, decls, childRules) => {
-	const c = /** @type {Container} */ (r);
-	c.declarations = /** @type {Declaration[]} */ (decls);
-	c.childRules = /** @type {Rule[]} */ (childRules);
-};
-/** @type {typeof _setRules} */
-const _objSetRules = (r, list) => {
-	/** @type {Stylesheet} */ (r).rules = /** @type {Rule[]} */ (list);
-};
-/** @type {typeof _nodeTypeOf} */
-const _objNodeTypeOf = (r) => r.type;
-/** @type {typeof _nodeStartOf} */
-const _objNodeStartOf = (r) => r.start;
-/** @type {typeof _nodeValueOf} */
-const _objNodeValueOf = (r) => /** @type {Token} */ (r).value;
-/** @type {typeof _nodeTokenOf} */
-const _objNodeTokenOf = (r) =>
-	/** @type {SimpleBlockToken} */ (/** @type {Container} */ (r).token);
-/** @param {LocConverter} lc loc converter for this parse */
-const useObjectBackend = (lc) => {
-	_objLocConverter = lc;
-	_soaActive = false;
-	// `parseA*` return the full tree, so nothing is skipped.
-	_skipTypes = _NO_SKIP_TYPES;
-	_skipActive = false;
-	_skipSelectorPrelude = false;
-	_skipAtRulePrelude = false;
-	_makeLeaf = _objLeaf;
-	_makeUrl = _objUrl;
-	_makeContainer = _objContainer;
-	_makeStylesheet = _objStylesheet;
-	_setName = _objSetName;
-	_setEnd = _objSetEnd;
-	_setBlock = _objSetBlock;
-	_setImportant = _objSetImportant;
-	_setToken = _objSetToken;
-	_setValue = _objSetValue;
-	_setPrelude = _objSetPrelude;
-	_setBody = _objSetBody;
-	_setRules = _objSetRules;
-	_nodeTypeOf = _objNodeTypeOf;
-	_nodeStartOf = _objNodeStartOf;
-	_nodeValueOf = _objNodeValueOf;
-	_nodeTokenOf = _objNodeTokenOf;
-};
-
-// -- struct-of-arrays backend: writes nodes into reused typed arrays --
+// -- struct-of-arrays store: nodes live in reused typed-array columns --
 // A node ref is its integer id; fields live in parallel arrays indexed by id.
-// Three reused int slots (`_soaAux0/1/2`) plus a flags byte carry the per-type
+// Two reused int slots (`_aux0/1`) plus a flags byte carry the per-type
 // extras; child lists hang off three object arrays. Aux slot meaning by type:
 //   url:         aux0 contentStart, aux1 contentEnd
 //   function:    aux0 nameEnd
 //   declaration: aux0 nameEnd, flags bit0 important
-//   at-rule:     aux0 nameEnd, aux1 blockStart, aux2 blockEnd
-//   qualified:   aux1 blockStart, aux2 blockEnd
+//   at-rule:     aux0 nameEnd, aux1 blockStart (blockEnd == end)
+//   qualified:   aux1 blockStart (blockEnd == end)
 // `name` / `nameStart` / a simple block's `token` are derived from the source
-// on read (see the SoA accessors), so they need no slot. A node's main content
-// (value | prelude | stylesheet rules) is a `_soaFlat` span (see below).
-// `grammar` resets `_soaNodeCount` to 0 after each top-level rule's walk, so the
+// on read (see the accessors), so they need no slot. A node's main content
+// (value | prelude | stylesheet rules) is a `_flat` span (see below).
+// `grammar` resets `_nodeCount` to 0 after each top-level rule's walk, so the
 // buffers are reused across rules and the parse allocates almost nothing.
-let _soaCapacity = 0;
-let _soaNodeCount = 0;
-let _soaTypes = new Uint8Array(0);
-let _soaStarts = new Int32Array(0);
-let _soaEnds = new Int32Array(0);
-let _soaAux0 = new Int32Array(0);
-let _soaAux1 = new Int32Array(0);
-let _soaAux2 = new Int32Array(0);
-let _soaFlags = new Uint8Array(0);
-// Content-list spans: a container's value / prelude is `_soaFlat[start, start+len)`
+let _capacity = 0;
+let _nodeCount = 0;
+let _types = new Uint8Array(0);
+let _starts = new Int32Array(0);
+let _ends = new Int32Array(0);
+let _aux0 = new Int32Array(0);
+let _aux1 = new Int32Array(0);
+let _flags = new Uint8Array(0);
+// Content-list spans: a container's value / prelude is `_flat[start, start+len)`
 // (node refs), recycled per top-level rule like the node columns.
-let _soaListStarts = new Int32Array(0);
-let _soaListLens = new Int32Array(0);
-let _soaFlat = new Int32Array(0);
-let _soaFlatTop = 0;
+let _listStarts = new Int32Array(0);
+let _listLens = new Int32Array(0);
+let _flat = new Int32Array(0);
+let _flatTop = 0;
 // Peak usage of the current parse, and use-once regrow hints: after an
 // over-capacity shrink the next grow jumps straight back to the previous
 // parse's peak (one exact-fit allocation instead of re-doubling up).
-let _soaPeak = 0;
-let _soaFlatPeak = 0;
-let _soaGrowHint = 0;
-let _soaFlatGrowHint = 0;
+let _peak = 0;
+let _flatPeak = 0;
+let _growHint = 0;
+let _flatGrowHint = 0;
 
 /** @param {number} need minimum flat-buffer capacity */
-const _soaFlatGrow = (need) => {
-	let cap = _soaFlat.length || 4096;
-	if (_soaFlatGrowHint > cap) cap = _soaFlatGrowHint;
-	_soaFlatGrowHint = 0;
+const _flatGrow = (need) => {
+	let cap = _flat.length || 4096;
+	if (_flatGrowHint > cap) cap = _flatGrowHint;
+	_flatGrowHint = 0;
 	while (cap < need) cap *= 2;
 	const next = new Int32Array(cap);
-	next.set(_soaFlat);
-	_soaFlat = next;
+	next.set(_flat);
+	_flat = next;
 };
+// Reassigned (not mutated) when a `parseA*` parse hands its columns to a
+// retained snapshot, so the next parse starts on fresh arrays.
 /** @type {(Node[] | null)[]} */
-const _soaDeclarationLists = [];
+let _declarationLists = [];
 /** @type {(Node[] | null)[]} */
-const _soaChildRuleLists = [];
-let _soaInput = "";
-let _soaLocConverter = /** @type {LocConverter} */ (
-	/** @type {unknown} */ (null)
-);
+let _childRuleLists = [];
+let _input = "";
+let _locConverter = /** @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.
@@ -1941,175 +1576,181 @@ const _nodeIndex = (n) => /** @type {number} */ (/** @type {unknown} */ (n));
 const _nodeRef = (i) => /** @type {Node} */ (/** @type {unknown} */ (i));
 
 /** @param {number} need minimum capacity */
-const _soaGrow = (need) => {
-	let cap = _soaCapacity || 4096;
-	if (_soaGrowHint > cap) cap = _soaGrowHint;
-	_soaGrowHint = 0;
+const _grow = (need) => {
+	let cap = _capacity || 4096;
+	if (_growHint > cap) cap = _growHint;
+	_growHint = 0;
 	while (cap < need) cap *= 2;
 	const ty = new Uint8Array(cap);
-	ty.set(_soaTypes);
-	_soaTypes = ty;
+	ty.set(_types);
+	_types = ty;
 	const st = new Int32Array(cap);
-	st.set(_soaStarts);
-	_soaStarts = st;
+	st.set(_starts);
+	_starts = st;
 	const en = new Int32Array(cap);
-	en.set(_soaEnds);
-	_soaEnds = en;
+	en.set(_ends);
+	_ends = en;
 	const a0 = new Int32Array(cap);
-	a0.set(_soaAux0);
-	_soaAux0 = a0;
+	a0.set(_aux0);
+	_aux0 = a0;
 	const a1 = new Int32Array(cap);
-	a1.set(_soaAux1);
-	_soaAux1 = a1;
-	const a2 = new Int32Array(cap);
-	a2.set(_soaAux2);
-	_soaAux2 = a2;
+	a1.set(_aux1);
+	_aux1 = a1;
 	const fl = new Uint8Array(cap);
-	fl.set(_soaFlags);
-	_soaFlags = fl;
+	fl.set(_flags);
+	_flags = fl;
 	const ls = new Int32Array(cap);
-	ls.set(_soaListStarts);
-	_soaListStarts = ls;
+	ls.set(_listStarts);
+	_listStarts = ls;
 	const ll = new Int32Array(cap);
-	ll.set(_soaListLens);
-	_soaListLens = ll;
-	_soaCapacity = cap;
+	ll.set(_listLens);
+	_listLens = ll;
+	_capacity = cap;
 };
 /** @type {(type: number, start: number, end: number) => Node} */
-const _soaAllocNode = (type, start, end) => {
+const _makeLeaf = (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
+	// Leaves never read the flag / list slots — `_makeContainer` clears
 	// them instead, keeping the dominant leaf allocation at three writes.
-	const i = _soaNodeCount + 1;
-	if (i >= _soaCapacity) _soaGrow(i + 1);
-	_soaTypes[i] = type;
-	_soaStarts[i] = start;
-	_soaEnds[i] = end;
-	_soaNodeCount = i;
+	const i = _nodeCount + 1;
+	if (i >= _capacity) _grow(i + 1);
+	_types[i] = type;
+	_starts[i] = start;
+	_ends[i] = end;
+	_nodeCount = i;
 	return _nodeRef(i);
 };
 /** @type {(type: number, start: number, end: number) => Node} */
-const _soaAllocContainer = (type, start, end) => {
-	const r = _soaAllocNode(type, start, end);
+const _makeContainer = (type, start, end) => {
+	const r = _makeLeaf(type, start, end);
 	const i = _nodeIndex(r);
-	_soaFlags[i] = 0;
-	// Clear list slots so a reused id never exposes a previous node's children
-	// (content lists are flat spans, so zeroing the length suffices).
-	_soaListLens[i] = 0;
-	_soaDeclarationLists[i] = null;
-	_soaChildRuleLists[i] = null;
+	_flags[i] = 0;
+	// Clear the content-span length so a reused id never exposes a previous
+	// node's children (content lists are flat spans, so zeroing the length
+	// suffices). `blockStart` (aux1) is NOT defaulted here: only at-rules and
+	// qualified rules carry a block, and they set it on every return path
+	// (`_setBlock`, or `-1` for the no-block forms). `blockEnd` is not stored — a
+	// block rule's `end` is its `blockEnd` (see `_setBlock`), else it is `-1`.
+	_listLens[i] = 0;
+	// The decl / child-rule slots are read only for rules (the walk guards on
+	// type; readers treat a missing slot as `null`), so only rules clear them —
+	// clearing every container would write these `id`-indexed arrays at scattered
+	// ids and degrade them to slow dictionary mode on large non-recycling parses.
+	if (type === T_AT_RULE || type === T_QUALIFIED_RULE) {
+		_declarationLists[i] = null;
+		_childRuleLists[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.
+// mid-parse reads and the accessor.
 /**
  * @param {number} i node id
  * @returns {string} raw token value
  */
-const _soaValueOf = (i) => {
-	const ty = _soaTypes[i];
+const _valueOf = (i) => {
+	const ty = _types[i];
 	if (ty === T_HASH || ty === T_AT_KEYWORD) {
-		return _soaInput.slice(_soaStarts[i] + 1, _soaEnds[i]);
+		return _input.slice(_starts[i] + 1, _ends[i]);
 	}
-	if (ty === T_URL) return _soaInput.slice(_soaAux0[i], _soaAux1[i]);
-	return _soaInput.slice(_soaStarts[i], _soaEnds[i]);
+	if (ty === T_URL) return _input.slice(_aux0[i], _aux1[i]);
+	return _input.slice(_starts[i], _ends[i]);
 };
-// Module-level constants for the same reason as the `_objSet*` set above.
-/** @type {typeof _makeUrl} */
-const _soaMakeUrl = (start, end, cs, ce) => {
-	const r = _soaAllocNode(T_URL, start, end);
-	_soaAux0[_nodeIndex(r)] = cs;
-	_soaAux1[_nodeIndex(r)] = ce;
+// Module-level constants (not per-parse closures), so each consume-algorithm
+// call site keeps one function identity and stays monomorphic.
+/** @type {(start: number, end: number, contentStart: number, contentEnd: number) => Node} */
+const _makeUrl = (start, end, cs, ce) => {
+	const r = _makeLeaf(T_URL, start, end);
+	_aux0[_nodeIndex(r)] = cs;
+	_aux1[_nodeIndex(r)] = ce;
 	return r;
 };
-/** @type {typeof _makeStylesheet} */
-const _soaMakeStylesheet = (start) =>
-	_soaAllocContainer(T_STYLESHEET, start, start);
+/** @type {(start: number) => Node} */
+const _makeStylesheet = (start) => _makeContainer(T_STYLESHEET, start, start);
 // name / nameStart are derived from start + nameEnd; only nameEnd is stored.
-/** @type {typeof _setName} */
-const _soaSetName = (r, ns, ne) => {
-	_soaAux0[_nodeIndex(r)] = ne;
+/** @type {(r: Node, nameStart: number, nameEnd: number) => void} */
+const _setName = (r, ns, ne) => {
+	_aux0[_nodeIndex(r)] = ne;
 };
-/** @type {typeof _setEnd} */
-const _soaSetEnd = (r, v) => {
-	_soaEnds[_nodeIndex(r)] = v;
+/** @type {(r: Node, v: number) => void} */
+const _setEnd = (r, v) => {
+	_ends[_nodeIndex(r)] = v;
 };
-/** @type {typeof _setBlock} */
-const _soaSetBlock = (r, bs, be) => {
-	const i = _nodeIndex(r);
-	_soaAux1[i] = bs;
-	_soaAux2[i] = be;
+// `blockEnd` is not stored: for a block rule the parser sets `end` to the
+// block end right after this (so `A.blockEnd` reads `end`); a `-1` blockStart
+// marks the no-block forms, where `blockEnd` derives to `-1`.
+/** @type {(r: Node, blockStart: number) => void} */
+const _setBlock = (r, bs) => {
+	_aux1[_nodeIndex(r)] = bs;
 };
-/** @type {typeof _setImportant} */
-const _soaSetImportant = (r) => {
-	_soaFlags[_nodeIndex(r)] |= 1;
+/** @type {(r: Node) => void} */
+const _setImportant = (r) => {
+	_flags[_nodeIndex(r)] |= 1;
 };
 // A simple block's token is derived from its opening char on read.
-/** @type {typeof _setToken} */
-const _soaSetToken = (r, ch) => {};
-/** @type {typeof _setValue} */
-const _soaSetValue = (r, list) => {
+/** @type {(r: Node, ch: SimpleBlockToken) => void} */
+const _setToken = (r, ch) => {};
+/** @type {(r: Node, list: Node[]) => void} */
+const _setValue = (r, list) => {
 	// Seal the finished list: copy its refs into the flat buffer and hand the
 	// scratch array back to the pool. The caller never touches `list` again.
-	const i = _nodeIndex(r);
 	const len = list.length;
-	const start = _soaFlatTop;
-	if (start + len > _soaFlat.length) _soaFlatGrow(start + len);
-	for (let k = 0; k < len; k++) {
-		_soaFlat[start + k] = _nodeIndex(list[k]);
-	}
-	_soaFlatTop = start + len;
-	_soaListStarts[i] = start;
-	_soaListLens[i] = len;
-	list.length = 0;
+	// Empty seal (common in non-modules skip mode, where value/prelude leaves are
+	// dropped): `_makeContainer` already left `_listLens` at 0, so skip the flat
+	// writes entirely and just recycle the scratch array.
+	if (len !== 0) {
+		const i = _nodeIndex(r);
+		const start = _flatTop;
+		if (start + len > _flat.length) _flatGrow(start + len);
+		for (let k = 0; k < len; k++) {
+			_flat[start + k] = _nodeIndex(list[k]);
+		}
+		_flatTop = start + len;
+		_listStarts[i] = start;
+		_listLens[i] = len;
+		list.length = 0;
+	}
 	_listPool.push(list);
 };
-/** @type {typeof _setBody} */
-const _soaSetBody = (r, decls, childRules) => {
+/** @type {(r: Node, decls: Node[], childRules: Node[]) => void} */
+const _setBody = (r, decls, childRules) => {
 	const i = _nodeIndex(r);
-	_soaDeclarationLists[i] = decls;
-	_soaChildRuleLists[i] = childRules;
-};
-/** @type {typeof _nodeTypeOf} */
-const _soaNodeTypeOf = (r) => _soaTypes[_nodeIndex(r)];
-/** @type {typeof _nodeStartOf} */
-const _soaNodeStartOf = (r) => _soaStarts[_nodeIndex(r)];
-/** @type {typeof _nodeValueOf} */
-const _soaNodeValueOf = (r) => _soaValueOf(_nodeIndex(r));
-/** @type {typeof _nodeTokenOf} */
-const _soaNodeTokenOf = (r) =>
-	/** @type {SimpleBlockToken} */ (_soaInput[_soaStarts[_nodeIndex(r)]]);
-/**
+	_declarationLists[i] = decls;
+	_childRuleLists[i] = childRules;
+};
+/** @type {(r: Node) => number} */
+const _nodeTypeOf = (r) => _types[_nodeIndex(r)];
+/** @type {(r: Node) => number} */
+const _nodeStartOf = (r) => _starts[_nodeIndex(r)];
+/** @type {(r: Node) => string} */
+const _nodeValueOf = (r) => _valueOf(_nodeIndex(r));
+/** @type {(r: Node) => SimpleBlockToken} */
+const _nodeTokenOf = (r) =>
+	/** @type {SimpleBlockToken} */ (_input[_starts[_nodeIndex(r)]]);
+// A container's value, a rule's prelude, and a stylesheet's rules all seal into
+// the one content-list writer, so `_setPrelude` / `_setRules` are named views of
+// `_setValue` that keep the consume algorithms reading in spec terms.
+const _setPrelude = _setValue;
+const _setRules = _setValue;
+
+/**
+ * Start a parse into the store: point it at this source, reset the node /
+ * flat cursors so nodes accumulate from id 1, and clear skip state (`grammar`
+ * sets its own afterwards; `parseA*` leave it off to build the full tree).
  * @param {string} input source
  * @param {LocConverter} lc loc converter
  */
-const useSoaBackend = (input, lc) => {
-	_soaInput = input;
-	_soaLocConverter = lc;
-	_soaNodeCount = 0;
-	_soaFlatTop = 0;
-	_soaActive = true;
-	// The alloc primitives are the slot functions directly — no wrapper hop.
-	_makeLeaf = _soaAllocNode;
-	_makeUrl = _soaMakeUrl;
-	_makeContainer = _soaAllocContainer;
-	_makeStylesheet = _soaMakeStylesheet;
-	_setName = _soaSetName;
-	_setEnd = _soaSetEnd;
-	_setBlock = _soaSetBlock;
-	_setImportant = _soaSetImportant;
-	_setToken = _soaSetToken;
-	_setValue = _soaSetValue;
-	// value / prelude / rules all land in the one content-list slot.
-	_setPrelude = _soaSetValue;
-	_setBody = _soaSetBody;
-	_setRules = _soaSetValue;
-	_nodeTypeOf = _soaNodeTypeOf;
-	_nodeStartOf = _soaNodeStartOf;
-	_nodeValueOf = _soaNodeValueOf;
-	_nodeTokenOf = _soaNodeTokenOf;
+const _setupParse = (input, lc) => {
+	_input = input;
+	_locConverter = lc;
+	_nodeCount = 0;
+	_flatTop = 0;
+	_skipTypes = _NO_SKIP_TYPES;
+	_skipActive = false;
+	_skipSelectorPrelude = false;
+	_skipAtRulePrelude = false;
 };
 
 /**
@@ -2247,6 +1888,20 @@ class TokenStream {
 		}
 	}
 
+	/**
+	 * Advance past the already-peeked next token, skipping the redundant `next()`
+	 * re-check `consume` / `discard` pay. Precondition: the caller has just called
+	 * `next()` (so `_tok` is the cached next token and `_hasNext` is true) and that
+	 * token is not the `<eof-token>` — the hot "peek, decide, advance" sites where
+	 * both always hold. Callers that can't guarantee a non-EOF cached token use
+	 * `consume` / `discard` instead.
+	 * @returns {void}
+	 */
+	advance() {
+		this._pos = this._tok.end;
+		this._hasNext = false;
+	}
+
 	/**
 	 * Mark (CSS Syntax §3 "mark") — push the current cursor position.
 	 * @returns {void}
@@ -2306,6 +1961,353 @@ const normalizeIntoTokenStream = (input, pos, onComment) =>
  * @property {((input: string, start: number, end: number) => number)=} comment optional comment-token callback; the public `parse*` entry points use it to build the `TokenStream` so the outer parser's comment tracker still sees magic comments inside the consumed range
  */
 
+// === parseA* retained store + property-accessor readers ===
+// `grammar` recycles the columns per top-level rule, but the `parseA*` entry
+// points must hand back a tree that outlives the parse. Each `parseA*` run parses
+// into the columns without recycling, then `_finishStore` hands them to a
+// snapshot object and resets the module columns to fresh arrays so the next parse
+// can't clobber it. Nodes are exposed as `parseA*` readers: plain objects sharing
+// one module-level prototype whose getters index the reader's own snapshot by node
+// id — no per-node class, no eager string slices, child readers built lazily on
+// access. A single shared prototype (rather than one per store) keeps the readers
+// monomorphic across parses, so `_readerAt` and every getter stay on the fast path.
+
+/**
+ * @typedef {object} NodeReader
+ * @property {NodeStore} _store snapshot this reader indexes
+ * @property {number} _i node id into the snapshot columns
+ * @property {number} type node type
+ * @property {number} start start offset
+ * @property {number} end end offset
+ * @property {[number, number]} range start / end offsets
+ * @property {{ start: { line: number, column: number }, end: { line: number, column: number } }} loc source location
+ * @property {() => string} toString source slice
+ * @property {string | ComponentValue[]} value token value (leaf) or component-value list (function / block / declaration)
+ * @property {string} unescaped unescaped token value
+ * @property {number} numericValue parsed numeric value
+ * @property {"integer" | "number" | "id" | "unrestricted"} typeFlag spec type flag
+ * @property {"+" | "-" | ""} sign spec sign
+ * @property {string} unit dimension unit (lower-cased)
+ * @property {number} contentStart url content start offset
+ * @property {number} contentEnd url content end offset
+ * @property {string} name rule / declaration / function name
+ * @property {number} nameStart name start offset
+ * @property {number} nameEnd name end offset
+ * @property {string} unescapedName unescaped name
+ * @property {ComponentValue[]} prelude rule prelude
+ * @property {Declaration[] | null} declarations block declarations
+ * @property {Rule[] | null} childRules block child rules
+ * @property {number} blockStart `{` start offset
+ * @property {number} blockEnd `}` end offset
+ * @property {boolean} important `!important` flag
+ * @property {SimpleBlockToken} token simple-block opening char
+ * @property {Rule[]} rules stylesheet rules
+ */
+
+/**
+ * @typedef {object} NodeStore
+ * @property {string} input source
+ * @property {LocConverter} lc loc converter
+ * @property {Uint8Array} types node-type column
+ * @property {Int32Array} starts start-offset column
+ * @property {Int32Array} ends end-offset column
+ * @property {Int32Array} aux0 aux slot 0
+ * @property {Int32Array} aux1 aux slot 1
+ * @property {Uint8Array} flags flags column
+ * @property {Int32Array} listStarts content-span start column
+ * @property {Int32Array} listLens content-span length column
+ * @property {Int32Array} flat flat node-ref buffer
+ * @property {(Node[] | null)[]} declLists per-node declaration lists
+ * @property {(Node[] | null)[]} childLists per-node child-rule lists
+ */
+
+// Shared frozen empty list for a block body with no declarations / child rules,
+// so equal-empty reads return one reference (mirrors `_EMPTY_LIST`).
+const _READER_EMPTY = /** @type {Rule[]} */ (
+	/** @type {unknown} */ (Object.freeze([]))
+);
+
+/**
+ * Raw token value over a snapshot (the lazy `Token.value` form): hash / at-keyword
+ * drop their one-char prefix, url uses its content range.
+ * @param {NodeStore} store snapshot
+ * @param {number} i node id
+ * @returns {string} raw token value
+ */
+const _storeValueOf = (store, i) => {
+	const ty = store.types[i];
+	if (ty === T_HASH || ty === T_AT_KEYWORD) {
+		return store.input.slice(store.starts[i] + 1, store.ends[i]);
+	}
+	if (ty === T_URL) return store.input.slice(store.aux0[i], store.aux1[i]);
+	return store.input.slice(store.starts[i], store.ends[i]);
+};
+
+/**
+ * @param {NodeStore} store snapshot
+ * @param {number} i node id
+ * @returns {Node} reader over node `i`
+ */
+const _readerAt = (store, i) => {
+	const o = Object.create(NODE_READER_PROTO);
+	o._store = store;
+	o._i = i;
+	return /** @type {Node} */ (o);
+};
+
+/**
+ * Readers over a container's flat content span (value / prelude / rules).
+ * @param {NodeStore} store snapshot
+ * @param {number} i container id
+ * @returns {Node[]} child readers
+ */
+const _readList = (store, i) => {
+	const s = store.listStarts[i];
+	const len = store.listLens[i];
+	const flat = store.flat;
+	/** @type {Node[]} */
+	const out = [];
+	for (let k = 0; k < len; k++) out.push(_readerAt(store, flat[s + k]));
+	return out;
+};
+
+/**
+ * Readers over a node-id list (declarations / child rules).
+ * @param {NodeStore} store snapshot
+ * @param {Node[]} list node-id list
+ * @returns {Node[]} child readers
+ */
+const _readRefList = (store, list) => {
+	/** @type {Node[]} */
+	const out = [];
+	for (let k = 0; k < list.length; k++) {
+		out.push(_readerAt(store, _nodeIndex(list[k])));
+	}
+	return out;
+};
+
+// Module-level reader prototype shared by every `parseA*` reader. Getters index
+// the reader's own `_store` snapshot by its `_i` node id; because the prototype is
+// created once (not per store), all readers share one hidden map and stay
+// monomorphic across parses.
+const NODE_READER_PROTO = /** @type {NodeReader} */ ({
+	_store: /** @type {NodeStore} */ (/** @type {unknown} */ (null)),
+	_i: 0,
+	get type() {
+		return this._store.types[this._i];
+	},
+	get start() {
+		return this._store.starts[this._i];
+	},
+	get end() {
+		return this._store.ends[this._i];
+	},
+	get range() {
+		const store = this._store;
+		const i = this._i;
+		return /** @type {[number, number]} */ ([store.starts[i], store.ends[i]]);
+	},
+	get loc() {
+		const store = this._store;
+		const i = this._i;
+		const lc = store.lc;
+		// `LocConverter#get` mutates and returns itself, so snapshot the first.
+		const s = lc.get(store.starts[i]);
+		const sl = s.line;
+		const sc = s.column;
+		const e = lc.get(store.ends[i]);
+		return {
+			start: { line: sl, column: sc },
+			end: { line: e.line, column: e.column }
+		};
+	},
+	toString() {
+		const store = this._store;
+		const i = this._i;
+		return store.input.slice(store.starts[i], store.ends[i]);
+	},
+	get value() {
+		const store = this._store;
+		const i = this._i;
+		const ty = store.types[i];
+		// function / simple-block / declaration expose their component-value
+		// list; every leaf token exposes its raw string value.
+		return ty === T_FUNCTION || ty === T_SIMPLE_BLOCK || ty === T_DECLARATION
+			? /** @type {ComponentValue[]} */ (_readList(store, i))
+			: _storeValueOf(store, i);
+	},
+	get unescaped() {
+		const store = this._store;
+		const i = this._i;
+		const v = _storeValueOf(store, i);
+		return store.types[i] === T_STRING
+			? unescapeIdentifier(v.slice(1, -1))
+			: unescapeIdentifier(v);
+	},
+	get numericValue() {
+		const store = this._store;
+		const i = this._i;
+		const v = _storeValueOf(store, i);
+		if (store.types[i] === T_DIMENSION) {
+			return Number(v.slice(0, _consumeANumber(v, 0)));
+		}
+		if (store.types[i] === T_PERCENTAGE) return Number(v.slice(0, -1));
+		return Number(v);
+	},
+	get typeFlag() {
+		const store = this._store;
+		const i = this._i;
+		if (store.types[i] === T_HASH) {
+			const input = store.input;
+			const p = store.starts[i] + 1;
+			return _ifThreeCodePointsWouldStartAnIdentSequence(
+				input,
+				p,
+				input.charCodeAt(p),
+				input.charCodeAt(p + 1),
+				input.charCodeAt(p + 2)
+			)
+				? "id"
+				: "unrestricted";
+		}
+		const v = _storeValueOf(store, i);
+		return _typeFlagOf(
+			store.types[i] === T_DIMENSION ? v.slice(0, _consumeANumber(v, 0)) : v
+		);
+	},
+	get sign() {
+		return _signOf(_storeValueOf(this._store, this._i));
+	},
+	get unit() {
+		const v = _storeValueOf(this._store, this._i);
+		return v.slice(_consumeANumber(v, 0)).toLowerCase();
+	},
+	get contentStart() {
+		return this._store.aux0[this._i];
+	},
+	get contentEnd() {
+		return this._store.aux1[this._i];
+	},
+	get name() {
+		const store = this._store;
+		const i = this._i;
+		// An at-rule's name skips its `@`; others start at the node.
+		return store.types[i] === T_AT_RULE
+			? store.input.slice(store.starts[i] + 1, store.aux0[i])
+			: store.input.slice(store.starts[i], store.aux0[i]);
+	},
+	get nameStart() {
+		return this._store.starts[this._i];
+	},
+	get nameEnd() {
+		return this._store.aux0[this._i];
+	},
+	get unescapedName() {
+		return unescapeIdentifier(this.name);
+	},
+	get prelude() {
+		return /** @type {ComponentValue[]} */ (_readList(this._store, this._i));
+	},
+	get declarations() {
+		const store = this._store;
+		// Non-rule containers never populate this slot (see `_makeContainer`), so a
+		// missing entry (`undefined`) is normalized to `null` — same as a rule with
+		// no block.
+		const list = store.declLists[this._i] || null;
+		return list === null
+			? null
+			: /** @type {Declaration[]} */ (
+					list.length > 0 ? _readRefList(store, list) : _READER_EMPTY
+				);
+	},
+	get childRules() {
+		const store = this._store;
+		const list = store.childLists[this._i] || null;
+		return list === null
+			? null
+			: /** @type {Rule[]} */ (
+					list.length > 0 ? _readRefList(store, list) : _READER_EMPTY
+				);
+	},
+	get blockStart() {
+		return this._store.aux1[this._i];
+	},
+	get blockEnd() {
+		const store = this._store;
+		const i = this._i;
+		return store.aux1[i] !== -1 ? store.ends[i] : -1;
+	},
+	get important() {
+		return (this._store.flags[this._i] & 1) !== 0;
+	},
+	get token() {
+		const store = this._store;
+		return /** @type {SimpleBlockToken} */ (store.input[store.starts[this._i]]);
+	},
+	get rules() {
+		return /** @type {Rule[]} */ (_readList(this._store, this._i));
+	}
+});
+
+/**
+ * Hand the module's live columns to a retained snapshot, then reset the
+ * module columns to fresh empty arrays so the next parse starts clean and can't
+ * mutate this store. Called once per `parseA*` after all consuming is done.
+ * @returns {NodeStore} the retained snapshot
+ */
+const _finishStore = () => {
+	/** @type {NodeStore} */
+	const store = {
+		input: _input,
+		lc: _locConverter,
+		types: _types,
+		starts: _starts,
+		ends: _ends,
+		aux0: _aux0,
+		aux1: _aux1,
+		flags: _flags,
+		listStarts: _listStarts,
+		listLens: _listLens,
+		flat: _flat,
+		declLists: _declarationLists,
+		childLists: _childRuleLists
+	};
+	// Carry this parse's size forward as a one-shot grow hint so the next parse
+	// allocates its columns once instead of re-doubling from scratch (node ids
+	// are 1-based, so `+1`).
+	_growHint = _nodeCount + 1;
+	_flatGrowHint = _flatTop;
+	// Reset module state — the columns now belong to `store`.
+	_capacity = 0;
+	_nodeCount = 0;
+	_flatTop = 0;
+	_types = new Uint8Array(0);
+	_starts = new Int32Array(0);
+	_ends = new Int32Array(0);
+	_aux0 = new Int32Array(0);
+	_aux1 = new Int32Array(0);
+	_flags = new Uint8Array(0);
+	_listStarts = new Int32Array(0);
+	_listLens = new Int32Array(0);
+	_flat = new Int32Array(0);
+	_declarationLists = [];
+	_childRuleLists = [];
+	_listPool.length = 0;
+	_input = "";
+	_locConverter = /** @type {LocConverter} */ (/** @type {unknown} */ (null));
+	return store;
+};
+
+/**
+ * Finish the parse and wrap one consumed node ref as a `parseA*` reader, keeping
+ * the caller's node type.
+ * @template {Node} T
+ * @param {T} ref consumed node ref
+ * @returns {T} reader over the retained snapshot
+ */
+const _finishOne = (ref) =>
+	/** @type {T} */ (_readerAt(_finishStore(), _nodeIndex(ref)));
+
 /**
  * Parse a stylesheet, CSS Syntax Level 3
  * [§5.3.4](https://drafts.csswg.org/css-syntax/#parse-stylesheet).
@@ -2318,15 +2320,17 @@ const parseAStylesheet = (input, pos = 0, options = {}) => {
 	// 1. If input is a byte stream for a stylesheet, decode bytes from input, and set input to the result.
 	// 2. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
-	useObjectBackend(ts.locConverter);
+	_setupParse(ts.input, 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} */ (_makeStylesheet(start));
+	const stylesheet = _makeStylesheet(start);
 	// 4. Consume a stylesheet's contents from input, and set the stylesheet's rules to the result.
 	_setRules(stylesheet, consumeAStylesheetsContents(ts));
 	_setEnd(stylesheet, ts.next().start);
 	// 5. Return the stylesheet.
-	return stylesheet;
+	return /** @type {Stylesheet} */ (
+		_readerAt(_finishStore(), _nodeIndex(stylesheet))
+	);
 };
 
 /**
@@ -2343,9 +2347,11 @@ const parseAStylesheet = (input, pos = 0, options = {}) => {
 const parseAStylesheetsContents = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
-	useObjectBackend(ts.locConverter);
+	_setupParse(ts.input, ts.locConverter);
 	// 2. Consume a stylesheet’s contents from input, and return the result.
-	return consumeAStylesheetsContents(ts);
+	const rules = consumeAStylesheetsContents(ts);
+	const store = _finishStore();
+	return /** @type {Rule[]} */ (_readRefList(store, rules));
 };
 
 /**
@@ -2359,9 +2365,17 @@ const parseAStylesheetsContents = (input, pos = 0, options = {}) => {
 const parseABlocksContents = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
-	useObjectBackend(ts.locConverter);
+	_setupParse(ts.input, ts.locConverter);
 	// 2. Consume a block’s contents from input, and return the result.
-	return consumeABlocksContents(ts);
+	const { decls, rules } = consumeABlocksContents(ts);
+	const store = _finishStore();
+	return {
+		decls: /** @type {Declaration[]} */ (_readRefList(store, decls)),
+		rules:
+			rules.length > 0
+				? /** @type {Rule[]} */ (_readRefList(store, rules))
+				: _READER_EMPTY
+	};
 };
 
 /**
@@ -2377,9 +2391,9 @@ const parseABlocksContents = (input, pos = 0, options = {}) => {
 const parseARule = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
-	useObjectBackend(ts.locConverter);
+	_setupParse(ts.input, ts.locConverter);
 	// 2. Discard whitespace from input.
-	while (ts.next().type === TT_WHITESPACE) ts.discard();
+	while (ts.next().type === TT_WHITESPACE) ts.advance();
 	// 3. If the next token from input is an <EOF-token>, return a syntax error.
 	// Otherwise, if the next token from input is an <at-keyword-token>, consume an at-rule from input, and let rule be the return value.
 	// Otherwise, consume a qualified rule from input and let rule be the return value.
@@ -2392,9 +2406,9 @@ const parseARule = (input, pos = 0, options = {}) => {
 			: consumeAQualifiedRule(ts);
 	if (!rule) return undefined;
 	// 4. Discard whitespace from input.
-	while (ts.next().type === TT_WHITESPACE) ts.discard();
+	while (ts.next().type === TT_WHITESPACE) ts.advance();
 	// 5. If the next token from input is an <EOF-token>, return rule. Otherwise, return a syntax error.
-	return ts.next().type === TT_EOF ? rule : undefined;
+	return ts.next().type === TT_EOF ? _finishOne(rule) : undefined;
 };
 
 /**
@@ -2408,11 +2422,12 @@ const parseARule = (input, pos = 0, options = {}) => {
 const parseADeclaration = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
-	useObjectBackend(ts.locConverter);
+	_setupParse(ts.input, ts.locConverter);
 	// 2. Discard whitespace from input.
-	while (ts.next().type === TT_WHITESPACE) ts.discard();
+	while (ts.next().type === TT_WHITESPACE) ts.advance();
 	// 3. Consume a declaration from input. If anything was returned, return it. Otherwise, return a syntax error.
-	return consumeADeclaration(ts);
+	const decl = consumeADeclaration(ts);
+	return decl === undefined ? undefined : _finishOne(decl);
 };
 
 /**
@@ -2425,18 +2440,17 @@ const parseADeclaration = (input, pos = 0, options = {}) => {
 const parseAComponentValue = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
-	useObjectBackend(ts.locConverter);
+	_setupParse(ts.input, ts.locConverter);
 	// 2. Discard whitespace from input.
-	while (ts.next().type === TT_WHITESPACE) ts.discard();
+	while (ts.next().type === TT_WHITESPACE) ts.advance();
 	// 3. If input is empty, return a syntax error.
 	if (ts.next().type === TT_EOF) return undefined;
 	// 4. Consume a component value from input and let value be the return value.
 	const result = consumeAComponentValue(ts);
 	// 5. Discard whitespace from input.
-	while (ts.next().type === TT_WHITESPACE) ts.discard();
+	while (ts.next().type === TT_WHITESPACE) ts.advance();
 	// 6. If input is empty, return value. Otherwise, return a syntax error.
-	if (ts.next().type === TT_EOF) return result;
-	return undefined;
+	return ts.next().type === TT_EOF ? _finishOne(result) : undefined;
 };
 
 /**
@@ -2450,10 +2464,12 @@ const parseAComponentValue = (input, pos = 0, options = {}) => {
 const parseAListOfComponentValues = (input, pos = 0, options = {}) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
-	useObjectBackend(ts.locConverter);
+	_setupParse(ts.input, ts.locConverter);
 	// 2. Consume a list of component values from input, and return the result.
 	// (`null` needs `bailOnCurly`, which is not passed here.)
-	return /** @type {ComponentValue[]} */ (consumeAListOfComponentValues(ts));
+	const values = /** @type {Node[]} */ (consumeAListOfComponentValues(ts));
+	const store = _finishStore();
+	return /** @type {ComponentValue[]} */ (_readRefList(store, values));
 };
 
 /**
@@ -2470,23 +2486,24 @@ const parseACommaSeparatedListOfComponentValues = (
 ) => {
 	// 1. Normalize input, and set input to the result.
 	const ts = normalizeIntoTokenStream(input, pos, options.comment);
-	useObjectBackend(ts.locConverter);
+	_setupParse(ts.input, ts.locConverter);
 	// 2. Let groups be an empty list.
-	/** @type {ComponentValue[][]} */
+	/** @type {Node[][]} */
 	const groups = [];
 	// 3. While input is not empty:
 	while (ts.next().type !== TT_EOF) {
 		// 3.1. Consume a list of component values from input, with <comma-token> as the stop token, and append the result to groups.
 		groups.push(
-			/** @type {ComponentValue[]} */ (
-				consumeAListOfComponentValues(ts, TT_COMMA)
-			)
+			/** @type {Node[]} */ (consumeAListOfComponentValues(ts, TT_COMMA))
 		);
 		// 3.2 Discard a token from input.
 		ts.discard();
 	}
-	// 4. Return groups.
-	return groups;
+	// 4. Return groups — wrap each group's refs against the retained snapshot.
+	const store = _finishStore();
+	return groups.map(
+		(g) => /** @type {ComponentValue[]} */ (_readRefList(store, g))
+	);
 };
 
 // === Parser algorithms (CSS Syntax Level 3 §5.4) ===
@@ -2559,11 +2576,11 @@ const consumeAnAtRule = (ts, nested = false) => {
 		_makeContainer(T_AT_RULE, head.start, head.end)
 	);
 	_setName(rule, head.start, head.end);
-	// Sealed (`_setPrelude`) at each return — the SoA backend consumes the
+	// Sealed (`_setPrelude`) at each return — the store consumes the
 	// scratch array when sealing, so it must be complete by then.
-	const prelude = _soaActive ? _soaList() : [];
-	// declarations / childRules / blockStart (-1) / blockEnd (-1) keep their
-	// defaults (no block: the `;` / EOF / nested-`}` at-rule forms).
+	const prelude = _takeList();
+	// declarations / childRules stay null (no block); the `;` / EOF / nested-`}`
+	// forms set blockStart / blockEnd to -1 explicitly at their return below.
 
 	// Like `consumeAQualifiedRule`: skip mode scans the prelude without
 	// materializing it (url tokens / functions kept so `@import url(…)` still
@@ -2580,6 +2597,7 @@ const consumeAnAtRule = (ts, nested = false) => {
 		if (t.type === TT_SEMICOLON || t.type === TT_EOF) {
 			ts.discard();
 			_setPrelude(rule, prelude);
+			_setBlock(rule, -1);
 			_setEnd(rule, t.start);
 			return rule;
 		}
@@ -2589,6 +2607,7 @@ const consumeAnAtRule = (ts, nested = false) => {
 		else if (t.type === TT_RIGHT_CURLY_BRACKET) {
 			if (nested) {
 				_setPrelude(rule, prelude);
+				_setBlock(rule, -1);
 				_setEnd(rule, t.start);
 				return rule;
 			}
@@ -2602,7 +2621,7 @@ const consumeAnAtRule = (ts, nested = false) => {
 			_setPrelude(rule, prelude);
 			const block = consumeABlock(ts);
 			_setBody(rule, block.decls, block.rules);
-			_setBlock(rule, block.blockStart, block.blockEnd);
+			_setBlock(rule, block.blockStart);
 			_setEnd(rule, block.blockEnd);
 			return rule;
 		}
@@ -2649,17 +2668,28 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 		_makeContainer(T_QUALIFIED_RULE, start, start)
 	);
 	// Sealed (`_setPrelude`) at the `{` exit — the only path that returns the
-	// rule; the parse-error exits abandon the scratch unsealed.
-	const prelude = _soaActive ? _soaList() : [];
-	// declarations / childRules / blockStart (-1) / blockEnd (-1) keep their
-	// defaults (no block until a `{` is reached).
+	// rule; the parse-error exits abandon the scratch unsealed. Allocated lazily
+	// on first push: skip mode usually pushes nothing (empty selector prelude),
+	// and `_makeContainer` already zeroed the rule's list length, so a null
+	// prelude reads as empty in the walk.
+	/** @type {Node[] | null} */
+	let prelude = null;
+	// A returned qualified rule always has a block (only the `{` exit returns a
+	// rule), so `_setBlock` always runs — no blockStart / blockEnd default needed.
 
 	// 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;
+	// Non-skip: first two non-whitespace prelude nodes (computed at the `{`).
 	let first = /** @type {Node} */ (/** @type {unknown} */ (0));
 	let second = /** @type {Node} */ (/** @type {unknown} */ (0));
+	// Skip mode: the same two tokens tracked by token type + start, so a dropped
+	// leaf selector token needs no materialized node just for the disambiguation.
+	// `0` (no token type) = unset.
+	let firstTT = 0;
+	let firstStart = 0;
+	let secondTT = 0;
 
 	// Process input
 	for (;;) {
@@ -2674,12 +2704,17 @@ 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;
-			const node = consumeATokenAsNode(ts);
 			if (skip) {
-				if (!first) first = node;
-				else if (!second) second = node;
+				// Stray `}` is a non-ws token; record its type/start, drop the node.
+				if (firstTT === 0) {
+					firstTT = t.type;
+					firstStart = t.start;
+				} else if (secondTT === 0) {
+					secondTT = t.type;
+				}
+				ts.advance();
 			} else {
-				prelude.push(node);
+				(prelude || (prelude = _takeList())).push(consumeATokenAsNode(ts));
 			}
 			continue;
 		}
@@ -2690,7 +2725,18 @@ 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) {
-			if (!skip) {
+			// `--foo: {` disambiguation: are the first two non-ws prelude tokens an
+			// ident starting with `--` followed by a colon? Skip mode reads the
+			// tracked token type/start; non-skip reads the materialized prelude.
+			let dashedDeclaration;
+			if (skip) {
+				dashedDeclaration =
+					firstTT === TT_IDENTIFIER &&
+					ts.input.startsWith("--", firstStart) &&
+					secondTT === TT_COLON;
+			} else if (prelude === null) {
+				dashedDeclaration = false;
+			} else {
 				let firstIdx = 0;
 				/* istanbul ignore next -- @preserve: leading whitespace is discarded before the rule, so the prelude never starts with it */
 				while (
@@ -2708,16 +2754,16 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 				}
 				first = prelude[firstIdx];
 				second = prelude[secondIdx];
+				dashedDeclaration =
+					first &&
+					_nodeTypeOf(first) === T_IDENT &&
+					// Test the source bytes directly — avoids forcing the lazy `value`
+					// slice just to check the `--` custom-property prefix.
+					ts.input.startsWith("--", _nodeStartOf(first)) &&
+					second &&
+					_nodeTypeOf(second) === T_COLON;
 			}
-			if (
-				first &&
-				_nodeTypeOf(first) === T_IDENT &&
-				// Test the source bytes directly — avoids forcing the lazy `value`
-				// slice just to check the `--` custom-property prefix.
-				ts.input.startsWith("--", _nodeStartOf(first)) &&
-				second &&
-				_nodeTypeOf(second) === T_COLON
-			) {
+			if (dashedDeclaration) {
 				/* istanbul ignore if -- @preserve: when nested, `declarationStartLikely` routes every `--x:` to consumeADeclaration (which accepts custom properties), so this fallthrough is unreachable */
 				if (nested) {
 					consumeTheRemnantsOfABadDeclaration(ts, true);
@@ -2726,30 +2772,45 @@ const consumeAQualifiedRule = (ts, stopToken, nested = false) => {
 				}
 				return undefined;
 			}
-			_setPrelude(rule, prelude);
+			if (prelude !== null) _setPrelude(rule, prelude);
 			const block = consumeABlock(ts);
 			_setBody(rule, block.decls, block.rules);
-			_setBlock(rule, block.blockStart, block.blockEnd);
+			_setBlock(rule, block.blockStart);
 			_setEnd(rule, block.blockEnd);
 			return rule;
 		}
 
 		// anything else
 		// Consume a component value from input and append the result to rule’s prelude.
-		const node = consumeAComponentValue(ts, t);
 		if (skip) {
-			// Keep only url-bearing nodes (url tokens, or functions that may hold a
-			// url like `:unknown(url(x))`) so the url visitor still rewrites them;
-			// other selector tokens have no non-modules consumer, so drop them.
-			const ty = _nodeTypeOf(node);
-			if (ty === T_FUNCTION || ty === T_URL) prelude.push(node);
+			const tt = t.type;
 			// 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;
+			if (tt !== TT_WHITESPACE) {
+				if (firstTT === 0) {
+					firstTT = tt;
+					firstStart = t.start;
+				} else if (secondTT === 0) {
+					secondTT = tt;
+				}
+			}
+			// Only functions (which may hold a url like `:unknown(url(x))`) and the
+			// `(` / `[` blocks that must be balanced are materialized; the url
+			// visitor keeps url / function nodes. Every other selector leaf token has
+			// no non-modules consumer — drop it without building a node.
+			if (
+				tt === TT_FUNCTION ||
+				(tt >= TT_LEFT_PARENTHESIS && tt <= TT_LEFT_CURLY_BRACKET)
+			) {
+				const node = consumeAComponentValue(ts, t);
+				const ty = _nodeTypeOf(node);
+				if (ty === T_FUNCTION || ty === T_URL) {
+					(prelude || (prelude = _takeList())).push(node);
+				}
+			} else {
+				ts.advance();
 			}
 		} else {
-			prelude.push(node);
+			(prelude || (prelude = _takeList())).push(consumeAComponentValue(ts, t));
 		}
 	}
 };
@@ -2838,9 +2899,9 @@ const consumeABlocksContents = (ts, onNode) => {
 		const t = ts.next();
 
 		// <whitespace-token> / <semicolon-token>
-		// Discard a token from input.
+		// Discard a token from input (`t` was just peeked and is non-EOF).
 		if (t.type === TT_WHITESPACE || t.type === TT_SEMICOLON) {
-			ts.discard();
+			ts.advance();
 		}
 		// <EOF-token> / <}-token>
 		// Return decls and rules.
@@ -2921,8 +2982,8 @@ 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.
+	// nameEnd (= start) / important (unset) keep their container defaults;
+	// `value` is set unconditionally at step 5 below.
 	const decl = /** @type {Declaration} */ (
 		_makeContainer(T_DECLARATION, start, start)
 	);
@@ -2938,19 +2999,19 @@ const consumeADeclaration = (ts, nested = false) => {
 	}
 
 	// 2. Discard whitespace from input.
-	while (ts.next().type === TT_WHITESPACE) ts.discard();
+	while (ts.next().type === TT_WHITESPACE) ts.advance();
 
 	// 3. If the next token is a <colon-token>, discard a token from input.
 	//    Otherwise, consume the remnants of a bad declaration from input, with nested, and return nothing.
 	if (ts.next().type === TT_COLON) {
-		ts.discard();
+		ts.advance();
 	} else {
 		consumeTheRemnantsOfABadDeclaration(ts, nested);
 		return undefined;
 	}
 
 	// 4. Discard whitespace from input.
-	while (ts.next().type === TT_WHITESPACE) ts.discard();
+	while (ts.next().type === TT_WHITESPACE) ts.advance();
 
 	// Step 8's custom-property test, computed early so the value parse can bail.
 	const isCustomProperty = input.startsWith("--", start);
@@ -2968,7 +3029,7 @@ const consumeADeclaration = (ts, nested = false) => {
 	);
 	if (value === null) return undefined;
 	// `_setValue` waits until step 9: steps 6-8 still trim / scan the scratch,
-	// and the SoA backend consumes it when sealing.
+	// and the store consumes it when sealing.
 	_setEnd(decl, ts.next().start);
 
 	// 6. If the last two non-<whitespace-token>s in decl's value are a <delim-token> with the value "!" followed by an <ident-token> with a value that is an ASCII case-insensitive match for "important", remove them from decl's value and set decl's important flag.
@@ -3031,7 +3092,7 @@ const consumeAListOfComponentValues = (
 	nested = false,
 	bailOnCurly = false
 ) => {
-	const values = /** @type {ComponentValue[]} */ (_soaActive ? _soaList() : []);
+	const values = /** @type {ComponentValue[]} */ (_takeList());
 	// Process input
 	for (;;) {
 		const t = ts.next();
@@ -3060,7 +3121,7 @@ const consumeAListOfComponentValues = (
 		if (bailOnCurly && t.type === TT_LEFT_CURLY_BRACKET) return null;
 		// anything else
 		// Consume a component value from input, and append the result to values.
-		// Skipped leaf types short-circuit before materializing: no SoA slot is
+		// Skipped leaf types short-circuit before materializing: no column slot is
 		// written and no node is built (blocks / functions never skip here).
 		const tt = t.type;
 		if (
@@ -3069,7 +3130,8 @@ const consumeAListOfComponentValues = (
 			!(tt >= TT_LEFT_PARENTHESIS && tt <= TT_LEFT_CURLY_BRACKET) &&
 			_skipTypes[_ttToNodeType[tt]] === 1
 		) {
-			ts.consume();
+			// `t` was just peeked and is a skipped value leaf (never EOF).
+			ts.advance();
 			continue;
 		}
 		const node = consumeAComponentValue(ts, t);
@@ -3098,10 +3160,11 @@ const consumeAComponentValue = (ts, t = ts.next()) => {
 	}
 	// anything else
 	// Consume a token from input and return the result. (Asserted: not EOF.)
-	// 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();
+	// Inlined `consumeATokenAsNode`: `t` is already the peeked next token (and not
+	// EOF), so `advance` past it and materialize it directly — no redundant
+	// `next()` and one fewer call per leaf component value (the bulk of the nodes
+	// on a large stylesheet).
+	ts.advance();
 	return /** @type {ComponentValue} */ (tokenToNode(t));
 };
 
@@ -3123,7 +3186,7 @@ const consumeASimpleBlock = (ts) => {
 	);
 	_setToken(block, token);
 	// Sealed (`_setValue`) at the return, once complete.
-	const val = _soaActive ? _soaList() : [];
+	const val = _takeList();
 
 	// Discard a token from input.
 	ts.discard();
@@ -3162,7 +3225,7 @@ const consumeAFunction = (ts) => {
 	);
 	_setName(fn, tFn.start, tFn.end - 1);
 	// Sealed (`_setValue`) at the return, once complete.
-	const val = _soaActive ? _soaList() : [];
+	const val = _takeList();
 
 	// Process input
 	for (;;) {
@@ -3188,7 +3251,8 @@ const consumeAFunction = (ts) => {
 			!(tt >= TT_LEFT_PARENTHESIS && tt <= TT_LEFT_CURLY_BRACKET) &&
 			_skipTypes[_ttToNodeType[tt]] === 1
 		) {
-			ts.consume();
+			// `t` was just peeked and is a skipped value leaf (never EOF).
+			ts.advance();
 			continue;
 		}
 		const node = consumeAComponentValue(ts, t);
@@ -3493,14 +3557,15 @@ let _commentBucket;
 
 // Comments reach the visitor map through `NodeType.Comment` instead of a
 // side callback. They fire during tokenization — in source order among
-// comments, not interleaved with the node walk — on a transient SoA node so
+// comments, not interleaved with the node walk — on a transient store node so
 // `A.start`/`end`/`loc`/`source` work. No comment visitor → no callback →
 // the tokenizer skips comments with zero overhead.
 /** @type {(input: string, start: number, end: number) => number} */
-const _grammarOnComment = (_input, start, end) => {
-	const node = _soaAllocNode(T_COMMENT, start, end);
+const _grammarOnComment = (_src, start, end) => {
+	const node = _makeLeaf(T_COMMENT, start, end);
 	_currentNode = node;
 	_currentParent = null;
+	_currentIndex = 0;
 	const bucket = /** @type {CompiledVisitorBucket} */ (_commentBucket);
 	const e = bucket.enter;
 	for (let i = 0; i < e.length; i++) e[i](A);
@@ -3515,15 +3580,17 @@ const _grammarOnComment = (_input, start, end) => {
  * loops — `for…of` would allocate an iterator per node on this hot path.
  * @param {Node} node component-value root
  * @param {Node | null} parent enclosing node
+ * @param {number} index node's index within its sibling list
  */
-const _walkValue = (node, parent) => {
-	const ty = _soaTypes[_nodeIndex(node)];
+const _walkValue = (node, parent, index) => {
+	const ty = _types[_nodeIndex(node)];
 	const b = _visitors[ty];
 	let skip = false;
 	if (b !== undefined && b.enter.length !== 0) {
 		_walkSkip = false;
 		_currentNode = node;
 		_currentParent = parent;
+		_currentIndex = index;
 		const e = b.enter;
 		for (let i = 0; i < e.length; i++) e[i](A);
 		skip = _walkSkip;
@@ -3531,14 +3598,15 @@ const _walkValue = (node, parent) => {
 	}
 	if (!skip && (ty === T_FUNCTION || ty === T_SIMPLE_BLOCK)) {
 		const i0 = _nodeIndex(node);
-		const vs = _soaListStarts[i0];
-		const ve = vs + _soaListLens[i0];
-		for (let i = vs; i < ve; i++) _walkValue(_nodeRef(_soaFlat[i]), node);
+		const vs = _listStarts[i0];
+		const ve = vs + _listLens[i0];
+		for (let i = vs; i < ve; i++) _walkValue(_nodeRef(_flat[i]), node, i - vs);
 	}
 	if (b !== undefined) {
 		// Rebind: descending into children moved the path.
 		_currentNode = node;
 		_currentParent = parent;
+		_currentIndex = index;
 		const x = b.exit;
 		for (let i = 0; i < x.length; i++) x[i](A);
 	}
@@ -3549,16 +3617,18 @@ const _walkValue = (node, parent) => {
  * eagerly (§5.4.4), so its `value` holds the nested rules / declarations.
  * @param {Node} node structural-tree root
  * @param {Node | null} parent enclosing node
+ * @param {number} index node's index within its sibling list (declarations and child rules index independently)
  */
-const _walkRule = (node, parent) => {
+const _walkRule = (node, parent, index) => {
 	const i0 = _nodeIndex(node);
-	const ty = _soaTypes[i0];
+	const ty = _types[i0];
 	const b = _visitors[ty];
 	let skip = false;
 	if (b !== undefined && b.enter.length !== 0) {
 		_walkSkip = false;
 		_currentNode = node;
 		_currentParent = parent;
+		_currentIndex = index;
 		const e = b.enter;
 		for (let i = 0; i < e.length; i++) e[i](A);
 		skip = _walkSkip;
@@ -3566,50 +3636,55 @@ const _walkRule = (node, parent) => {
 	}
 	if (!skip) {
 		if (ty === T_AT_RULE || ty === T_QUALIFIED_RULE) {
-			const ps = _soaListStarts[i0];
-			const pe = ps + _soaListLens[i0];
-			for (let i = ps; i < pe; i++) _walkValue(_nodeRef(_soaFlat[i]), node);
+			const ps = _listStarts[i0];
+			const pe = ps + _listLens[i0];
+			for (let i = ps; i < pe; i++) {
+				_walkValue(_nodeRef(_flat[i]), node, i - ps);
+			}
 			if (_recurseBlocks) {
 				// Declarations then child rules — downstream consumers don't need them strictly interleaved in source order.
-				const decls = _soaDeclarationLists[i0];
+				const decls = _declarationLists[i0];
 				if (decls) {
-					for (let i = 0; i < decls.length; i++) _walkRule(decls[i], node);
+					for (let i = 0; i < decls.length; i++) _walkRule(decls[i], node, i);
 				}
-				const ch = _soaChildRuleLists[i0];
-				if (ch) for (let i = 0; i < ch.length; i++) _walkRule(ch[i], node);
+				const ch = _childRuleLists[i0];
+				if (ch) for (let i = 0; i < ch.length; i++) _walkRule(ch[i], node, i);
 			}
 		} else if (ty === T_DECLARATION) {
-			const vs = _soaListStarts[i0];
-			const ve = vs + _soaListLens[i0];
-			for (let i = vs; i < ve; i++) _walkValue(_nodeRef(_soaFlat[i]), node);
+			const vs = _listStarts[i0];
+			const ve = vs + _listLens[i0];
+			for (let i = vs; i < ve; i++) {
+				_walkValue(_nodeRef(_flat[i]), node, i - vs);
+			}
 		}
 	}
 	if (b !== undefined) {
 		// Rebind: descending into children moved the path.
 		_currentNode = node;
 		_currentParent = parent;
+		_currentIndex = index;
 		const x = b.exit;
 		for (let i = 0; i < x.length; i++) x[i](A);
 	}
 };
 
 /**
- * The `grammar` streaming sink: walk one top-level node, then recycle the SoA
+ * The `grammar` streaming sink: walk one top-level node, then recycle the
  * buffers for the next.
  * @param {Rule | Declaration} node top-level node
  */
 const _walkTopLevel = (node) => {
-	_walkRule(node, null);
-	if (_soaNodeCount > _soaPeak) _soaPeak = _soaNodeCount;
-	if (_soaFlatTop > _soaFlatPeak) _soaFlatPeak = _soaFlatTop;
-	_soaNodeCount = 0;
-	_soaFlatTop = 0;
+	_walkRule(node, null, 0);
+	if (_nodeCount > _peak) _peak = _nodeCount;
+	if (_flatTop > _flatPeak) _flatPeak = _flatTop;
+	_nodeCount = 0;
+	_flatTop = 0;
 };
 
-// The SoA buffers grow to the largest single top-level rule ever parsed and
+// The store buffers grow to the largest single top-level rule ever parsed and
 // live at module level; above this capacity they are re-shrunk after a parse
 // so one pathological rule can't pin megabytes for the process lifetime.
-const _SOA_SHRINK_CAPACITY = 65536;
+const _SHRINK_CAPACITY = 65536;
 
 /**
  * The CSS `SourceProcessor` grammar: consume top-level rules one at a time
@@ -3623,7 +3698,7 @@ const _SOA_SHRINK_CAPACITY = 65536;
  */
 const grammar = (input, visitors, options) => {
 	const locConverter = options.locConverter || new LocConverter(input);
-	useSoaBackend(input, locConverter);
+	_setupParse(input, locConverter);
 	const skip = options.skip;
 	_skipTypes = (skip && skip.types) || _NO_SKIP_TYPES;
 	_skipActive = _skipTypes !== _NO_SKIP_TYPES;
@@ -3648,39 +3723,36 @@ const grammar = (input, visitors, options) => {
 	try {
 		consume(ts, _walkTopLevel);
 	} finally {
-		// Drop the module-level SoA references so the last parsed source (and
+		// Drop the module-level column references so the last parsed source (and
 		// its LocConverter / child lists / visitors) don't stay alive between
 		// parses.
-		_soaInput = "";
-		_soaLocConverter = /** @type {LocConverter} */ (
-			/** @type {unknown} */ (null)
-		);
-		_soaDeclarationLists.length = 0;
-		_soaChildRuleLists.length = 0;
-		_soaFlatTop = 0;
+		_input = "";
+		_locConverter = /** @type {LocConverter} */ (/** @type {unknown} */ (null));
+		_declarationLists.length = 0;
+		_childRuleLists.length = 0;
+		_flatTop = 0;
 		_listPool.length = 0;
-		if (_soaFlat.length > _SOA_SHRINK_CAPACITY) {
-			_soaFlatGrowHint = _soaFlatPeak;
-			_soaFlat = new Int32Array(0);
+		if (_flat.length > _SHRINK_CAPACITY) {
+			_flatGrowHint = _flatPeak;
+			_flat = new Int32Array(0);
 		}
 		_visitors = /** @type {CompiledVisitorMap} */ (/** @type {unknown} */ ([]));
 		_commentBucket = undefined;
-		if (_soaCapacity > _SOA_SHRINK_CAPACITY) {
+		if (_capacity > _SHRINK_CAPACITY) {
 			// +1: node ids are 1-based and grow fires at `id >= capacity`.
-			_soaGrowHint = _soaPeak + 1;
-			_soaCapacity = 0;
-			_soaTypes = new Uint8Array(0);
-			_soaStarts = new Int32Array(0);
-			_soaEnds = new Int32Array(0);
-			_soaAux0 = new Int32Array(0);
-			_soaAux1 = new Int32Array(0);
-			_soaAux2 = new Int32Array(0);
-			_soaFlags = new Uint8Array(0);
-			_soaListStarts = new Int32Array(0);
-			_soaListLens = new Int32Array(0);
+			_growHint = _peak + 1;
+			_capacity = 0;
+			_types = new Uint8Array(0);
+			_starts = new Int32Array(0);
+			_ends = new Int32Array(0);
+			_aux0 = new Int32Array(0);
+			_aux1 = new Int32Array(0);
+			_flags = new Uint8Array(0);
+			_listStarts = new Int32Array(0);
+			_listLens = new Int32Array(0);
 		}
-		_soaPeak = 0;
-		_soaFlatPeak = 0;
+		_peak = 0;
+		_flatPeak = 0;
 	}
 };
 
@@ -3733,11 +3805,11 @@ const buildSkipSet = (nodeTypes) => {
 /** @type {(n: Node) => Node[]} */
 const _materializeList = (n) => {
 	const i = _nodeIndex(n);
-	const start = _soaListStarts[i];
-	const len = _soaListLens[i];
+	const start = _listStarts[i];
+	const len = _listLens[i];
 	/** @type {Node[]} */
 	const out = [];
-	for (let k = 0; k < len; k++) out.push(_nodeRef(_soaFlat[start + k]));
+	for (let k = 0; k < len; k++) out.push(_nodeRef(_flat[start + k]));
 	return out;
 };
 
@@ -3750,14 +3822,15 @@ let _walkSkip = false;
 let _currentNode = /** @type {Node} */ (/** @type {unknown} */ (0));
 /** @type {Node | null} */
 let _currentParent = null;
+// Index of the current node within its sibling list (a rule body's declarations
+// and child rules are separate lists, so each indexes from 0 independently).
+let _currentIndex = 0;
 
 // 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`.
+// one of these accessors (`n` is an integer node id into the columns), so
+// the storage stays behind the accessor 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) ===
 	/**
@@ -3772,6 +3845,12 @@ const A = {
 	get parent() {
 		return _currentParent;
 	},
+	/**
+	 * @returns {number} index of the current node within its sibling list (0 for a top-level node) — only valid during a visitor callback
+	 */
+	get index() {
+		return _currentIndex;
+	},
 	/** Stop the walk descending into the current node (enter only). */
 	skipChildren() {
 		_walkSkip = true;
@@ -3782,21 +3861,21 @@ const A = {
 	 * @returns {number} node type
 	 */
 	type(n = _currentNode) {
-		return _soaTypes[_nodeIndex(n)];
+		return _types[_nodeIndex(n)];
 	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {number} start offset
 	 */
 	start(n = _currentNode) {
-		return _soaStarts[_nodeIndex(n)];
+		return _starts[_nodeIndex(n)];
 	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {number} end offset
 	 */
 	end(n = _currentNode) {
-		return _soaEnds[_nodeIndex(n)];
+		return _ends[_nodeIndex(n)];
 	},
 	/**
 	 * @param {Node=} n node
@@ -3804,7 +3883,7 @@ const A = {
 	 */
 	range(n = _currentNode) {
 		const i = _nodeIndex(n);
-		return [_soaStarts[i], _soaEnds[i]];
+		return [_starts[i], _ends[i]];
 	},
 	/**
 	 * @param {Node=} n node
@@ -3812,11 +3891,11 @@ const A = {
 	 */
 	loc(n = _currentNode) {
 		const i = _nodeIndex(n);
-		const lc = _soaLocConverter;
-		const s = lc.get(_soaStarts[i]);
+		const lc = _locConverter;
+		const s = lc.get(_starts[i]);
 		const sl = s.line;
 		const sc = s.column;
-		const e = lc.get(_soaEnds[i]);
+		const e = lc.get(_ends[i]);
 		return {
 			start: { line: sl, column: sc },
 			end: { line: e.line, column: e.column }
@@ -3828,14 +3907,14 @@ const A = {
 	 */
 	source(n = _currentNode) {
 		const i = _nodeIndex(n);
-		return _soaInput.slice(_soaStarts[i], _soaEnds[i]);
+		return _input.slice(_starts[i], _ends[i]);
 	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {string} raw token value
 	 */
 	value(n = _currentNode) {
-		return _soaValueOf(_nodeIndex(n));
+		return _valueOf(_nodeIndex(n));
 	},
 	/**
 	 * @param {Node=} n node
@@ -3843,8 +3922,8 @@ const A = {
 	 */
 	unescaped(n = _currentNode) {
 		const i = _nodeIndex(n);
-		const v = _soaValueOf(i);
-		return _soaTypes[i] === T_STRING
+		const v = _valueOf(i);
+		return _types[i] === T_STRING
 			? unescapeIdentifier(v.slice(1, -1))
 			: unescapeIdentifier(v);
 	},
@@ -3854,9 +3933,9 @@ const A = {
 	 */
 	typeFlag(n = _currentNode) {
 		const i = _nodeIndex(n);
-		if (_soaTypes[i] === T_HASH) {
-			const input = _soaInput;
-			const p = _soaStarts[i] + 1;
+		if (_types[i] === T_HASH) {
+			const input = _input;
+			const p = _starts[i] + 1;
 			return _ifThreeCodePointsWouldStartAnIdentSequence(
 				input,
 				p,
@@ -3867,9 +3946,9 @@ const A = {
 				? "id"
 				: "unrestricted";
 		}
-		const v = _soaValueOf(i);
+		const v = _valueOf(i);
 		return _typeFlagOf(
-			_soaTypes[i] === T_DIMENSION ? v.slice(0, _consumeANumber(v, 0)) : v
+			_types[i] === T_DIMENSION ? v.slice(0, _consumeANumber(v, 0)) : v
 		);
 	},
 	/**
@@ -3877,14 +3956,14 @@ const A = {
 	 * @returns {number} url content start offset
 	 */
 	contentStart(n = _currentNode) {
-		return _soaAux0[_nodeIndex(n)];
+		return _aux0[_nodeIndex(n)];
 	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {number} url content end offset
 	 */
 	contentEnd(n = _currentNode) {
-		return _soaAux1[_nodeIndex(n)];
+		return _aux1[_nodeIndex(n)];
 	},
 	/**
 	 * @param {Node=} n node
@@ -3892,23 +3971,23 @@ const A = {
 	 */
 	name(n = _currentNode) {
 		const i = _nodeIndex(n);
-		return _soaTypes[i] === T_AT_RULE
-			? _soaInput.slice(_soaStarts[i] + 1, _soaAux0[i])
-			: _soaInput.slice(_soaStarts[i], _soaAux0[i]);
+		return _types[i] === T_AT_RULE
+			? _input.slice(_starts[i] + 1, _aux0[i])
+			: _input.slice(_starts[i], _aux0[i]);
 	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {number} name start offset
 	 */
 	nameStart(n = _currentNode) {
-		return _soaStarts[_nodeIndex(n)];
+		return _starts[_nodeIndex(n)];
 	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {number} name end offset
 	 */
 	nameEnd(n = _currentNode) {
-		return _soaAux0[_nodeIndex(n)];
+		return _aux0[_nodeIndex(n)];
 	},
 	/**
 	 * @param {Node=} n node
@@ -3931,13 +4010,32 @@ const A = {
 	prelude(n = _currentNode) {
 		return /** @type {ComponentValue[]} */ (_materializeList(n));
 	},
+	/**
+	 * @param {Node=} n node
+	 * @returns {number} number of children (value / prelude) without materializing the list
+	 */
+	childCount(n = _currentNode) {
+		return _listLens[_nodeIndex(n)];
+	},
+	/**
+	 * @param {Node} n node
+	 * @param {number} i child index (`0 <= i < childCount(n)`)
+	 * @returns {ComponentValue} i-th child (value / prelude) without materializing the list
+	 */
+	childAt(n, i) {
+		return /** @type {ComponentValue} */ (
+			_nodeRef(_flat[_listStarts[_nodeIndex(n)] + i])
+		);
+	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {Declaration[] | null} block declarations
 	 */
 	declarations(n = _currentNode) {
+		// `_makeContainer` only populates this slot for rules; a non-rule node
+		// reads `undefined`, normalized to `null` to keep the documented contract.
 		return /** @type {Declaration[] | null} */ (
-			_soaDeclarationLists[_nodeIndex(n)]
+			_declarationLists[_nodeIndex(n)] || null
 		);
 	},
 	/**
@@ -3945,65 +4043,65 @@ const A = {
 	 * @returns {Rule[] | null} block child rules
 	 */
 	childRules(n = _currentNode) {
-		return /** @type {Rule[] | null} */ (_soaChildRuleLists[_nodeIndex(n)]);
+		return /** @type {Rule[] | null} */ (
+			_childRuleLists[_nodeIndex(n)] || null
+		);
 	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {number} block start offset
 	 */
 	blockStart(n = _currentNode) {
-		return _soaAux1[_nodeIndex(n)];
+		return _aux1[_nodeIndex(n)];
 	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {number} block end offset
 	 */
 	blockEnd(n = _currentNode) {
-		return _soaAux2[_nodeIndex(n)];
+		const i = _nodeIndex(n);
+		return _aux1[i] !== -1 ? _ends[i] : -1;
 	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {boolean} `!important` flag
 	 */
 	important(n = _currentNode) {
-		return (_soaFlags[_nodeIndex(n)] & 1) !== 0;
+		return (_flags[_nodeIndex(n)] & 1) !== 0;
 	},
 	/**
 	 * @param {Node=} n node
 	 * @returns {SimpleBlockToken} block opening token
 	 */
 	blockToken(n = _currentNode) {
-		return /** @type {SimpleBlockToken} */ (
-			_soaInput[_soaStarts[_nodeIndex(n)]]
-		);
+		return /** @type {SimpleBlockToken} */ (_input[_starts[_nodeIndex(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.
+	// inline ICSS `:import` / `:export` body into a single dependency. A block
+	// rule's `blockEnd` is its `end`, so `setBlockEnd` writes the same `end` slot.
 	/**
 	 * @param {Node} n node
 	 * @param {number} v new end offset
 	 */
 	setEnd(n, v) {
-		_soaEnds[_nodeIndex(n)] = v;
+		_ends[_nodeIndex(n)] = v;
 	},
 	/**
 	 * @param {Node} n node
 	 * @param {number} v new block end offset
 	 */
 	setBlockEnd(n, v) {
-		_soaAux2[_nodeIndex(n)] = v;
+		_ends[_nodeIndex(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.
+// The AST node shapes (`Node`, `Token`, and the container typedefs) are types
+// only — nodes are integer ids into the store, surfaced by the `A` visitor
+// accessor and the `parseA*` readers. Runtime exports: the `A` accessor, the
+// full CSS-Syntax-3 §5.3 `parseA*` entry-point surface, 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;
 module.exports.TT_AT_KEYWORD = TT_AT_KEYWORD;
@@ -4032,7 +4130,6 @@ module.exports.TT_SEMICOLON = TT_SEMICOLON;
 module.exports.TT_STRING = TT_STRING;
 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;