webpack 5.108.1 → 5.108.3

package/lib/css/CssParser.js

@@ -29,6 +29,7 @@ const {
 } = require("../util/magicComment");
 const topologicalSort = require("../util/topologicalSort");
 const {
+	A,
 	NodeType,
 	SourceProcessor,
 	equalsLowerCase,
@@ -65,6 +66,7 @@ const {
 /** @typedef {{ localName: string, value: string }} ValueAtRuleValue */
 
 const CC_COLON = ":".charCodeAt(0);
+const CC_HYPHEN_MINUS = "-".charCodeAt(0);
 const CC_SEMICOLON = ";".charCodeAt(0);
 const CC_TAB = "\t".charCodeAt(0);
 const CC_SPACE = " ".charCodeAt(0);
@@ -577,26 +579,27 @@ const isPureBodyAtRule = (name) =>
 
 /**
  * Scan a rule body once: does it hold a direct declaration counted against the enclosing rule (a declaration, or one in a transparent conditional-group at-rule like `@media`/`@supports`/…) and does it hold a nested block (qualified rule or any block-bearing at-rule)?
- * @param {{ declarations: Declaration[] | null, childRules: Rule[] | null }} body rule body
+ * @param {Declaration[] | null} declarations rule-body declarations
+ * @param {Rule[] | null} childRules rule-body child rules
  * @returns {{ hasDirectDecl: boolean, hasNestedBlock: boolean }} scan result
  */
-const scanRuleBody = (body) => {
-	let hasDirectDecl = Boolean(
-		body.declarations && body.declarations.length > 0
-	);
+const scanRuleBody = (declarations, childRules) => {
+	let hasDirectDecl = Boolean(declarations && declarations.length > 0);
 	let hasNestedBlock = false;
-	if (body.childRules) {
-		for (const child of body.childRules) {
-			if (child.type === NodeType.QualifiedRule) {
+	if (childRules) {
+		for (const child of childRules) {
+			const t = A.type(child);
+			if (t === NodeType.QualifiedRule) {
 				hasNestedBlock = true;
-			} else if (child.type === NodeType.AtRule) {
-				const at = /** @type {AtRule} */ (child);
-				if (!at.declarations && !at.childRules) continue;
+			} else if (t === NodeType.AtRule) {
+				const atDecls = A.declarations(child);
+				const atChildRules = A.childRules(child);
+				if (!atDecls && !atChildRules) continue;
 				hasNestedBlock = true;
 				if (
 					!hasDirectDecl &&
-					!isPureBodyAtRule(`@${at.name.toLowerCase()}`) &&
-					scanRuleBody(at).hasDirectDecl
+					!isPureBodyAtRule(`@${A.name(child).toLowerCase()}`) &&
+					scanRuleBody(atDecls, atChildRules).hasDirectDecl
 				) {
 					hasDirectDecl = true;
 				}
@@ -686,7 +689,7 @@ const parseValueAtRuleParams = (str) => {
  */
 const nextNonWhitespace = (nodes, from) => {
 	let i = from;
-	while (i < nodes.length && nodes[i].type === NodeType.Whitespace) i++;
+	while (i < nodes.length && A.type(nodes[i]) === NodeType.Whitespace) i++;
 	return i;
 };
 
@@ -706,21 +709,22 @@ const parseImportPrelude = (prelude) => {
 	let supportsNode;
 
 	for (const cv of prelude) {
-		if (cv.type === NodeType.Whitespace) continue;
+		const t = A.type(cv);
+		if (t === NodeType.Whitespace) continue;
 
 		if (!urlNode) {
-			if (cv.type === NodeType.Url || cv.type === NodeType.String) {
+			if (t === NodeType.Url || t === NodeType.String) {
 				urlNode = cv;
 				continue;
 			}
 			if (
-				cv.type === NodeType.Function &&
-				equalsLowerCase(/** @type {FunctionNode} */ (cv).unescapedName, "url")
+				t === NodeType.Function &&
+				equalsLowerCase(A.unescapedName(cv), "url")
 			) {
 				urlNode = cv;
 				continue;
 			}
-			if (cv.type === NodeType.Ident) {
+			if (t === NodeType.Ident) {
 				// CSS Modules: bare ident is a `@value` reference.
 				urlNode = cv;
 				continue;
@@ -729,14 +733,14 @@ const parseImportPrelude = (prelude) => {
 		}
 
 		if (!layerNode && !supportsNode) {
-			if (cv.type === NodeType.Ident) {
-				if (equalsLowerCase(/** @type {Token} */ (cv).unescaped, "layer")) {
+			if (t === NodeType.Ident) {
+				if (equalsLowerCase(A.unescaped(cv), "layer")) {
 					layerNode = cv;
 					continue;
 				}
 			} else if (
-				cv.type === NodeType.Function &&
-				equalsLowerCase(/** @type {FunctionNode} */ (cv).unescapedName, "layer")
+				t === NodeType.Function &&
+				equalsLowerCase(A.unescapedName(cv), "layer")
 			) {
 				layerNode = cv;
 				continue;
@@ -745,11 +749,8 @@ const parseImportPrelude = (prelude) => {
 
 		if (
 			!supportsNode &&
-			cv.type === NodeType.Function &&
-			equalsLowerCase(
-				/** @type {FunctionNode} */ (cv).unescapedName,
-				"supports"
-			)
+			t === NodeType.Function &&
+			equalsLowerCase(A.unescapedName(cv), "supports")
 		) {
 			supportsNode = /** @type {FunctionNode} */ (cv);
 			continue;
@@ -772,31 +773,28 @@ const parseImportPrelude = (prelude) => {
 const parseIcssImportRequest = (second, rule, source) => {
 	/** @type {AstNode[] | undefined} */
 	let args;
-	if (second.type === NodeType.Function) {
-		args = /** @type {FunctionNode} */ (second).value;
+	if (A.type(second) === NodeType.Function) {
+		args = A.children(second);
 	} else {
-		for (const p of rule.prelude) {
-			if (
-				p.type === NodeType.SimpleBlock &&
-				/** @type {SimpleBlock} */ (p).token === "("
-			) {
-				args = /** @type {SimpleBlock} */ (p).value;
+		for (const p of A.prelude(rule)) {
+			if (A.type(p) === NodeType.SimpleBlock && A.blockToken(p) === "(") {
+				args = A.children(p);
 				break;
 			}
 		}
 	}
 	// The first non-whitespace value inside `(...)` must be a string.
 	const innerStrToken =
-		args && args.find((v) => v.type !== NodeType.Whitespace);
-	if (!innerStrToken || innerStrToken.type !== NodeType.String) {
+		args && args.find((v) => A.type(v) !== NodeType.Whitespace);
+	if (!innerStrToken || A.type(innerStrToken) !== NodeType.String) {
 		const errorPos =
-			second.type === NodeType.Function
-				? /** @type {FunctionNode} */ (second).nameEnd + 1
-				: second.end;
+			A.type(second) === NodeType.Function
+				? A.nameEnd(second) + 1
+				: A.end(second);
 		return { errorPos };
 	}
 	return {
-		request: source.slice(innerStrToken.start + 1, innerStrToken.end - 1)
+		request: source.slice(A.start(innerStrToken) + 1, A.end(innerStrToken) - 1)
 	};
 };
 
@@ -1054,7 +1052,7 @@ class CssParser extends Parser {
 		/**
 		 * Unescape a CSS identifier from a source byte range — for value spans not
 		 * backed by a single token (string contents, `--` dashed-ident bodies,
-		 * composed names). Token-backed names use `node.unescaped` instead.
+		 * composed names). Token-backed names use `A.unescaped(node)` instead.
 		 * @param {number} start start offset
 		 * @param {number} end end offset
 		 * @returns {string} the unescaped identifier
@@ -1170,10 +1168,10 @@ class CssParser extends Parser {
 					const hasBody = Boolean(declarations || childRules);
 					let leaf = treatAsLeaf || !hasBody;
 					if (!leaf && hasBody) {
-						const { hasDirectDecl, hasNestedBlock } = scanRuleBody({
+						const { hasDirectDecl, hasNestedBlock } = scanRuleBody(
 							declarations,
 							childRules
-						});
+						);
 						leaf = hasDirectDecl || !hasNestedBlock;
 					}
 					if (leaf) this.report(preludeStart, preludeEnd);
@@ -1457,21 +1455,22 @@ class CssParser extends Parser {
 			};
 
 			// Body `{ name: value; … }` is parsed eagerly (§5.4.4) — emit a dep per declaration.
-			if (!rule.declarations || rule.blockStart === -1) return second.end;
-			for (const decl of rule.declarations) {
-				const vals = decl.value;
+			const ruleDecls = A.declarations(rule);
+			if (!ruleDecls || A.blockStart(rule) === -1) return A.end(second);
+			for (const decl of ruleDecls) {
+				const vals = A.children(decl);
 				if (vals.length === 0) continue;
-				const rawStart = vals[0].start;
-				const rawEnd = vals[vals.length - 1].end;
+				const rawStart = A.start(vals[0]);
+				const rawEnd = A.end(vals[vals.length - 1]);
 				createDep(
-					source.slice(decl.nameStart, decl.nameEnd),
+					source.slice(A.nameStart(decl), A.nameEnd(decl)),
 					source.slice(rawStart, rawEnd),
-					decl.nameEnd,
+					A.nameEnd(decl),
 					rawEnd
 				);
 			}
 
-			return skipWhiteLine(source, rule.blockEnd);
+			return skipWhiteLine(source, A.blockEnd(rule));
 		};
 
 		/**
@@ -1506,20 +1505,21 @@ class CssParser extends Parser {
 		 */
 		const processLocalOrGlobalFunction = (fn, type) => {
 			// Replace `local(` / `global(` (and a leading `:` for the `:local(`/`:global(` selector form) with empty.
-			const isColon = input.charCodeAt(fn.start - 1) === CC_COLON;
-			const openEnd = fn.nameEnd + 1;
+			const fnStart = A.start(fn);
+			const isColon = input.charCodeAt(fnStart - 1) === CC_COLON;
+			const openEnd = A.nameEnd(fn) + 1;
 			module.addPresentationalDependency(
-				new ConstDependency("", [isColon ? fn.start - 1 : fn.start, openEnd])
+				new ConstDependency("", [isColon ? fnStart - 1 : fnStart, openEnd])
 			);
 
 			if (type === 1) {
-				for (const cv of fn.value) {
-					if (cv.type !== NodeType.Ident) continue;
-					let identifier = /** @type {Token} */ (cv).unescaped;
+				for (const cv of A.children(fn)) {
+					if (A.type(cv) !== NodeType.Ident) continue;
+					let identifier = A.unescaped(cv);
 					const {
 						start: { line: sl, column: sc },
 						end: { line: el, column: ec }
-					} = cv.loc;
+					} = A.loc(cv);
 					const isDashedIdent = isDashedIdentifier(identifier);
 					if (isDashedIdent) identifier = identifier.slice(2);
 					addCssExport(
@@ -1529,7 +1529,7 @@ class CssParser extends Parser {
 						ec,
 						identifier,
 						getReexport(identifier),
-						[cv.start, cv.end],
+						[A.start(cv), A.end(cv)],
 						true,
 						CssIcssExportDependency.EXPORT_MODE.ONCE,
 						isDashedIdent
@@ -1541,7 +1541,7 @@ class CssParser extends Parser {
 
 			// Replace the closing `)`.
 			module.addPresentationalDependency(
-				new ConstDependency("", [fn.end - 1, fn.end])
+				new ConstDependency("", [A.end(fn) - 1, A.end(fn)])
 			);
 		};
 
@@ -1553,16 +1553,17 @@ class CssParser extends Parser {
 		 */
 		const processLocalAtRule = (atRule, options) => {
 			let found = false;
-			for (const cv of atRule.prelude) {
-				if (cv.type === NodeType.Whitespace) continue;
+			for (const cv of A.prelude(atRule)) {
+				const cvType = A.type(cv);
+				if (cvType === NodeType.Whitespace) continue;
 
-				if (cv.type === NodeType.String) {
+				if (cvType === NodeType.String) {
 					if (!found && options.string) {
-						const value = /** @type {Token} */ (cv).unescaped;
+						const value = A.unescaped(cv);
 						const {
 							start: { line: sl, column: sc },
 							end: { line: el, column: ec }
-						} = cv.loc;
+						} = A.loc(cv);
 						addCssExport(
 							sl,
 							sc,
@@ -1570,7 +1571,7 @@ class CssParser extends Parser {
 							ec,
 							value,
 							value,
-							[cv.start, cv.end],
+							[A.start(cv), A.end(cv)],
 							true,
 							CssIcssExportDependency.EXPORT_MODE.ONCE
 						);
@@ -1580,9 +1581,9 @@ class CssParser extends Parser {
 					continue;
 				}
 
-				if (cv.type === NodeType.Ident) {
+				if (cvType === NodeType.Ident) {
 					if (!found && options.identifier) {
-						const identifier = /** @type {Token} */ (cv).unescaped;
+						const identifier = A.unescaped(cv);
 						if (
 							options.identifier instanceof RegExp &&
 							options.identifier.test(identifier)
@@ -1592,7 +1593,7 @@ class CssParser extends Parser {
 						const {
 							start: { line: sl, column: sc },
 							end: { line: el, column: ec }
-						} = cv.loc;
+						} = A.loc(cv);
 						addCssExport(
 							sl,
 							sc,
@@ -1600,7 +1601,7 @@ class CssParser extends Parser {
 							ec,
 							identifier,
 							getReexport(identifier),
-							[cv.start, cv.end],
+							[A.start(cv), A.end(cv)],
 							true,
 							CssIcssExportDependency.EXPORT_MODE.ONCE,
 							CssIcssExportDependency.EXPORT_TYPE.NORMAL
@@ -1611,9 +1612,9 @@ class CssParser extends Parser {
 					continue;
 				}
 
-				if (cv.type === NodeType.Function) {
+				if (cvType === NodeType.Function) {
 					const fn = /** @type {FunctionNode} */ (cv);
-					const fname = fn.unescapedName.toLowerCase();
+					const fname = A.unescapedName(fn).toLowerCase();
 					const type =
 						fname === "local" ? 1 : fname === "global" ? 2 : undefined;
 					if (!found && type) {
@@ -1631,7 +1632,7 @@ class CssParser extends Parser {
 					}
 				}
 			}
-			return atRule.end;
+			return A.end(atRule);
 		};
 		/**
 		 * Emit the ICSS export declaring this module exports the given custom property.
@@ -1724,56 +1725,64 @@ class CssParser extends Parser {
 			/** @type {Token | undefined} */
 			let identNode;
 			let identIdx = -1;
-			for (let i = 0; i < fn.value.length; i++) {
-				const cv = fn.value[i];
-				if (cv.type === NodeType.Whitespace) continue;
-				if (cv.type === NodeType.Ident) {
+			const fv = A.children(fn);
+			for (let i = 0; i < fv.length; i++) {
+				const cv = fv[i];
+				if (A.type(cv) === NodeType.Whitespace) continue;
+				if (A.type(cv) === NodeType.Ident) {
 					identNode = /** @type {Token} */ (cv);
 					identIdx = i;
 				}
 				break;
 			}
-			if (!identNode || !isDashedIdentifier(identNode.value)) return;
+			if (!identNode) return;
 
-			const identStart = identNode.start;
-			const identEnd = identNode.end;
+			const identStart = A.start(identNode);
+			const identEnd = A.end(identNode);
+			// `isDashedIdentifier` on the value without slicing it: a literal `--`
+			// prefix of length >= 3 (escaped dashes don't match, same as the string
+			// form, since the raw bytes aren't `--`).
+			if (
+				identEnd - identStart < 3 ||
+				input.charCodeAt(identStart) !== CC_HYPHEN_MINUS ||
+				input.charCodeAt(identStart + 1) !== CC_HYPHEN_MINUS
+			) {
+				return;
+			}
 
 			let j = identIdx + 1;
-			while (j < fn.value.length && fn.value[j].type === NodeType.Whitespace) {
+			while (j < fv.length && A.type(fv[j]) === NodeType.Whitespace) {
 				j++;
 			}
 
 			if (
-				j >= fn.value.length ||
-				fn.value[j].type !== NodeType.Ident ||
-				!equalsLowerCase(/** @type {Token} */ (fn.value[j]).value, "from")
+				j >= fv.length ||
+				A.type(fv[j]) !== NodeType.Ident ||
+				!equalsLowerCase(A.value(fv[j]), "from")
 			) {
 				emitDashedIdentExport(identStart, identEnd);
 				return;
 			}
 
-			const fromIdent = fn.value[j];
+			const fromIdent = fv[j];
 			j++;
-			while (j < fn.value.length && fn.value[j].type === NodeType.Whitespace) {
+			while (j < fv.length && A.type(fv[j]) === NodeType.Whitespace) {
 				j++;
 			}
-			if (j >= fn.value.length) return;
+			if (j >= fv.length) return;
 
-			const source = fn.value[j];
-			if (
-				source.type === NodeType.Ident &&
-				/** @type {Token} */ (source).value === "global"
-			) {
-				emitDashedIdentFromGlobal(identEnd, source.end);
+			const src = fv[j];
+			if (A.type(src) === NodeType.Ident && A.value(src) === "global") {
+				emitDashedIdentFromGlobal(identEnd, A.end(src));
 				return;
 			}
-			if (source.type === NodeType.String) {
+			if (A.type(src) === NodeType.String) {
 				emitDashedIdentImport(
 					identStart,
 					identEnd,
-					fromIdent.start,
-					source.end,
-					input.slice(source.start + 1, source.end - 1)
+					A.start(fromIdent),
+					A.end(src),
+					input.slice(A.start(src) + 1, A.end(src) - 1)
 				);
 			}
 		};
@@ -1785,16 +1794,14 @@ class CssParser extends Parser {
 		 */
 		const childrenOf = (parent) => {
 			if (!parent) return undefined;
-			switch (parent.type) {
+			switch (A.type(parent)) {
 				case NodeType.Function:
-					return /** @type {FunctionNode} */ (parent).value;
 				case NodeType.SimpleBlock:
-					return /** @type {SimpleBlock} */ (parent).value;
 				case NodeType.Declaration:
-					return /** @type {Declaration} */ (parent).value;
+					return A.children(parent);
 				case NodeType.AtRule:
 				case NodeType.QualifiedRule:
-					return /** @type {AtRule | QualifiedRule} */ (parent).prelude;
+					return A.prelude(parent);
 				default:
 					return undefined;
 			}
@@ -1833,6 +1840,8 @@ class CssParser extends Parser {
 		let currentStructural;
 		// Cached on each structural enter and read per value token, so the hot Function / Ident / Url visitors don't re-derive the property / at-rule name on every visit.
 		let currentAtRuleName = "";
+		// Set by `handleImportAtRule` for a malformed `@import` so its prelude still emits orphan url() deps; read by `urlActive`. Reset per at-rule enter (replaces an ad-hoc property on the node).
+		let currentUrlRecovery = false;
 		/** Whether the current Declaration's property is a localizable known property. */
 		let currentDeclIsKnownProperty = false;
 		/** Whether the current `composes:` declaration owns the whole value (suppresses value rewrites). */
@@ -1853,13 +1862,16 @@ class CssParser extends Parser {
 		 */
 		const stripBareMarker = (colon, ident, after) => {
 			const afterIsWhitespace = Boolean(
-				after && after.type === NodeType.Whitespace
+				after && A.type(after) === NodeType.Whitespace
 			);
+			const identEnd = A.end(ident);
 			const stripEnd =
-				afterIsWhitespace && after.start === ident.end ? after.end : ident.end;
+				afterIsWhitespace && A.start(after) === identEnd
+					? A.end(after)
+					: identEnd;
 			if (isModules) {
 				module.addPresentationalDependency(
-					new ConstDependency("", [colon.start, stripEnd])
+					new ConstDependency("", [A.start(colon), stripEnd])
 				);
 			}
 			return afterIsWhitespace;
@@ -1874,17 +1886,18 @@ class CssParser extends Parser {
 		 */
 		const stripFunctionMarker = (colon, fn, isLocal) => {
 			if (!isModules) return;
-			let stripLeadEnd = fn.end - 1;
-			for (const arg of fn.value) {
-				if (arg.type !== NodeType.Whitespace) {
-					stripLeadEnd = arg.start;
+			const fnEnd = A.end(fn);
+			let stripLeadEnd = fnEnd - 1;
+			for (const arg of A.children(fn)) {
+				if (A.type(arg) !== NodeType.Whitespace) {
+					stripLeadEnd = A.start(arg);
 					break;
 				}
 			}
 			module.addPresentationalDependency(
-				new ConstDependency("", [colon.start, stripLeadEnd])
+				new ConstDependency("", [A.start(colon), stripLeadEnd])
 			);
-			let trailStart = fn.end - 1; // position of `)`
+			let trailStart = fnEnd - 1; // position of `)`
 			if (isLocal) {
 				while (
 					trailStart > 0 &&
@@ -1894,7 +1907,7 @@ class CssParser extends Parser {
 				}
 			}
 			module.addPresentationalDependency(
-				new ConstDependency("", [trailStart, fn.end])
+				new ConstDependency("", [trailStart, fnEnd])
 			);
 		};
 
@@ -1904,37 +1917,33 @@ class CssParser extends Parser {
 		 * @returns {void}
 		 */
 		const handleAttributeSelector = (block) => {
-			const attrParts = block.value;
+			const attrParts = A.children(block);
 			let ai = 0;
 			while (
 				ai < attrParts.length &&
-				attrParts[ai].type === NodeType.Whitespace
+				A.type(attrParts[ai]) === NodeType.Whitespace
 			) {
 				ai++;
 			}
 			const attrNameNode = attrParts[ai];
-			if (!attrNameNode || attrNameNode.type !== NodeType.Ident) return;
-			const attrName = /** @type {Token} */ (attrNameNode).unescaped;
+			if (!attrNameNode || A.type(attrNameNode) !== NodeType.Ident) return;
+			const attrName = A.unescaped(attrNameNode);
 			if (!equalsLowerCase(attrName, "class")) return;
 			ai++;
 			while (
 				ai < attrParts.length &&
-				attrParts[ai].type === NodeType.Whitespace
+				A.type(attrParts[ai]) === NodeType.Whitespace
 			) {
 				ai++;
 			}
 			// `=` or `~=` (two `Delim` tokens for the latter).
 			const op1 = attrParts[ai];
-			if (!op1 || op1.type !== NodeType.Delim) return;
-			const op1v = /** @type {Token} */ (op1).value;
+			if (!op1 || A.type(op1) !== NodeType.Delim) return;
+			const op1v = A.value(op1);
 			if (op1v === "~") {
 				ai++;
 				const op2 = attrParts[ai];
-				if (
-					!op2 ||
-					op2.type !== NodeType.Delim ||
-					/** @type {Token} */ (op2).value !== "="
-				) {
+				if (!op2 || A.type(op2) !== NodeType.Delim || A.value(op2) !== "=") {
 					return;
 				}
 			} else if (op1v !== "=") {
@@ -1943,7 +1952,7 @@ class CssParser extends Parser {
 			ai++;
 			while (
 				ai < attrParts.length &&
-				attrParts[ai].type === NodeType.Whitespace
+				A.type(attrParts[ai]) === NodeType.Whitespace
 			) {
 				ai++;
 			}
@@ -1953,12 +1962,12 @@ class CssParser extends Parser {
 			let classNameStart;
 			/** @type {number} */
 			let classNameEnd;
-			if (attrValueNode.type === NodeType.String) {
-				classNameStart = attrValueNode.start + 1;
-				classNameEnd = attrValueNode.end - 1;
-			} else if (attrValueNode.type === NodeType.Ident) {
-				classNameStart = attrValueNode.start;
-				classNameEnd = attrValueNode.end;
+			if (A.type(attrValueNode) === NodeType.String) {
+				classNameStart = A.start(attrValueNode) + 1;
+				classNameEnd = A.end(attrValueNode) - 1;
+			} else if (A.type(attrValueNode) === NodeType.Ident) {
+				classNameStart = A.start(attrValueNode);
+				classNameEnd = A.end(attrValueNode);
 			} else {
 				return;
 			}
@@ -1998,7 +2007,7 @@ class CssParser extends Parser {
 			}
 			for (let i = 0; i < values.length; i++) {
 				const v = values[i];
-				switch (v.type) {
+				switch (A.type(v)) {
 					case NodeType.Whitespace:
 						break;
 					case NodeType.Comma:
@@ -2013,8 +2022,9 @@ class CssParser extends Parser {
 						// Look ahead for `:local` / `:global` markers; other pseudos fall through.
 						const next = values[i + 1];
 						if (!next) break;
-						if (next.type === NodeType.Ident) {
-							const raw = /** @type {Token} */ (next).value;
+						const nextType = A.type(next);
+						if (nextType === NodeType.Ident) {
+							const raw = A.value(next);
 							const isLocal = equalsLowerCase(raw, "local");
 							if (isLocal || equalsLowerCase(raw, "global")) {
 								const id = isLocal ? "local" : "global";
@@ -2029,12 +2039,12 @@ class CssParser extends Parser {
 									this._emitWarning(
 										state,
 										`Missing whitespace after ':${id}' in '${source.slice(
-											v.start,
-											findLeftCurly(source, next.end) + 1
+											A.start(v),
+											findLeftCurly(source, A.end(next)) + 1
 										)}'`,
 										locConverter,
-										v.start,
-										next.end
+										A.start(v),
+										A.end(next)
 									);
 								}
 								segmentMode = id;
@@ -2042,14 +2052,18 @@ class CssParser extends Parser {
 								// Skip past the colon + ident.
 								i += 1;
 							}
-						} else if (next.type === NodeType.Function) {
+						} else if (nextType === NodeType.Function) {
 							const fn = /** @type {FunctionNode} */ (next);
-							const rawName = fn.unescapedName;
+							const rawName = A.unescapedName(fn);
 							const isLocal = equalsLowerCase(rawName, "local");
 							if (isLocal || equalsLowerCase(rawName, "global")) {
 								// `:local(…)` / `:global(…)`: scope mode to the args and strip the `:name(` … `)` wrapper.
 								stripFunctionMarker(v, fn, isLocal);
-								walkSelectorList(fn.value, isLocal ? "local" : "global", false);
+								walkSelectorList(
+									A.children(fn),
+									isLocal ? "local" : "global",
+									false
+								);
 								// Skip past the colon + function.
 								i += 1;
 							}
@@ -2058,26 +2072,19 @@ class CssParser extends Parser {
 					}
 					case NodeType.Function:
 						// Any other function (`:not(…)`, `:is(…)`, …): recurse with the segment mode preserved (only `:local(…)` / `:global(…)`, handled above, switch mode).
-						walkSelectorList(
-							/** @type {FunctionNode} */ (v).value,
-							segmentMode,
-							false
-						);
+						walkSelectorList(A.children(v), segmentMode, false);
 						break;
 					case NodeType.Hash: {
-						if (
-							/** @type {HashToken} */ (v).typeFlag !== "id" ||
-							segmentMode !== "local"
-						) {
+						if (A.typeFlag(v) !== "id" || segmentMode !== "local") {
 							break;
 						}
 						// ID selectors emit the ICSS export but aren't a `composes:` anchor.
-						const idValueStart = v.start + 1;
-						const idName = /** @type {Token} */ (v).unescaped;
+						const idValueStart = A.start(v) + 1;
+						const idName = A.unescaped(v);
 						const {
 							start: { line: idSl, column: idSc },
 							end: { line: idEl, column: idEc }
-						} = v.loc;
+						} = A.loc(v);
 						addCssExport(
 							idSl,
 							idSc,
@@ -2085,7 +2092,7 @@ class CssParser extends Parser {
 							idEc,
 							idName,
 							getReexport(idName),
-							[idValueStart, v.end],
+							[idValueStart, A.end(v)],
 							true,
 							CssIcssExportDependency.EXPORT_MODE.ONCE
 						);
@@ -2094,17 +2101,18 @@ class CssParser extends Parser {
 					}
 					case NodeType.SimpleBlock: {
 						const block = /** @type {SimpleBlock} */ (v);
-						if (block.token === "[") {
+						const bt = A.blockToken(block);
+						if (bt === "[") {
 							// Attribute selectors `[class="foo"]` localize only in local mode.
 							if (segmentMode === "local") handleAttributeSelector(block);
-						} else if (block.token === "(") {
+						} else if (bt === "(") {
 							// `@scope (.foo)` and other parenthesised selector wrappers — recurse into the `(…)` block.
-							walkSelectorList(block.value, segmentMode, false);
+							walkSelectorList(A.children(block), segmentMode, false);
 						}
 						break;
 					}
 					case NodeType.Delim: {
-						const delim = /** @type {Token} */ (v).value;
+						const delim = A.value(v);
 						if (delim === "&") {
 							// Pure-mode: a nesting `&` inherits a pure ancestor's purity.
 							if (topLevel && pure.ancestorHadLocal()) pure.markLocal();
@@ -2112,14 +2120,14 @@ class CssParser extends Parser {
 						}
 						if (delim !== ".") break;
 						const next = values[i + 1];
-						if (!next || next.type !== NodeType.Ident) break;
+						if (!next || A.type(next) !== NodeType.Ident) break;
 						if (segmentMode === "local") {
 							// `.<ident>` in local mode is a class selector (dep covers the ident bytes only).
-							const name = /** @type {Token} */ (next).unescaped;
+							const name = A.unescaped(next);
 							const {
 								start: { line: sl, column: sc },
 								end: { line: el, column: ec }
-							} = next.loc;
+							} = A.loc(next);
 							addCssExport(
 								sl,
 								sc,
@@ -2127,7 +2135,7 @@ class CssParser extends Parser {
 								ec,
 								name,
 								getReexport(name),
-								[next.start, next.end],
+								[A.start(next), A.end(next)],
 								true,
 								CssIcssExportDependency.EXPORT_MODE.ONCE
 							);
@@ -2136,9 +2144,9 @@ class CssParser extends Parser {
 							pure.markLocal();
 						} else {
 							// `.<ident>` in global mode: not localized, but the ident may be `@value`-defined and need ICSS rewrite.
-							const ident = /** @type {Token} */ (next).value;
+							const ident = A.value(next);
 							if (!isDashedIdentifier(ident) && icssDefinitions.has(ident)) {
-								emitICSSSymbol(ident, next.start, next.end);
+								emitICSSSymbol(ident, A.start(next), A.end(next));
 							}
 						}
 						// Skip the consumed ident.
@@ -2147,9 +2155,9 @@ class CssParser extends Parser {
 					}
 					case NodeType.Ident: {
 						// ICSS rewrite for a bare `@value`-defined ident used as a type-style selector.
-						const ident = /** @type {Token} */ (v).value;
+						const ident = A.value(v);
 						if (!isDashedIdentifier(ident) && icssDefinitions.has(ident)) {
-							emitICSSSymbol(ident, v.start, v.end);
+							emitICSSSymbol(ident, A.start(v), A.end(v));
 						}
 						break;
 					}
@@ -2172,11 +2180,11 @@ class CssParser extends Parser {
 		 */
 		const urlActive = () => {
 			if (!this.options.url || !currentStructural) return false;
-			if (currentStructural.type === NodeType.AtRule) {
-				const at = /** @type {AtRule & { urlRecovery?: boolean }} */ (
-					currentStructural
+			if (A.type(currentStructural) === NodeType.AtRule) {
+				return (
+					!equalsLowerCase(A.name(currentStructural), "import") ||
+					currentUrlRecovery
 				);
-				return !equalsLowerCase(at.name, "import") || Boolean(at.urlRecovery);
 			}
 			return true;
 		};
@@ -2204,10 +2212,11 @@ class CssParser extends Parser {
 		 */
 		const localGlobalActive = () => {
 			if (!isModules || !currentStructural) return false;
-			if (currentStructural.type === NodeType.AtRule) {
+			const t = A.type(currentStructural);
+			if (t === NodeType.AtRule) {
 				return !isLocalHandledAtRule(currentAtRuleName);
 			}
-			if (currentStructural.type === NodeType.Declaration) {
+			if (t === NodeType.Declaration) {
 				return !currentDeclComposesSkip;
 			}
 			return false;
@@ -2219,12 +2228,13 @@ class CssParser extends Parser {
 		 */
 		const icssActive = () => {
 			if (!isModules || !currentStructural) return false;
-			if (currentStructural.type === NodeType.AtRule) {
+			const t = A.type(currentStructural);
+			if (t === NodeType.AtRule) {
 				return (
 					currentAtRuleName !== "@value" && currentAtRuleName !== "@import"
 				);
 			}
-			if (currentStructural.type === NodeType.Declaration) {
+			if (t === NodeType.Declaration) {
 				return !currentDeclComposesSkip && !currentDeclIsKnownProperty;
 			}
 			return false;
@@ -2237,8 +2247,7 @@ class CssParser extends Parser {
 		 * @returns {void}
 		 */
 		const finishTopLevelRule = (node, blockBearing) => {
-			const at = /** @type {AtRule} */ (node);
-			if (!blockBearing || at.declarations || at.childRules) {
+			if (!blockBearing || A.declarations(node) || A.childRules(node)) {
 				allowImport = false;
 			}
 			pure.markSeenTopLevelRule();
@@ -2383,8 +2392,8 @@ class CssParser extends Parser {
 						'", "'
 					)}"`,
 					locConverter,
-					decl.start,
-					decl.end
+					A.start(decl),
+					A.end(decl)
 				);
 				return;
 			}
@@ -2395,8 +2404,8 @@ class CssParser extends Parser {
 			const groups = [];
 			/** @type {AstNode[]} */
 			let currentGroup = [];
-			for (const cv of decl.value) {
-				if (cv.type === NodeType.Comma) {
+			for (const cv of A.children(decl)) {
+				if (A.type(cv) === NodeType.Comma) {
 					groups.push(currentGroup);
 					currentGroup = [];
 				} else {
@@ -2419,20 +2428,20 @@ class CssParser extends Parser {
 
 				for (let i = 0; i < group.length; i++) {
 					const cv = group[i];
-					if (cv.type === NodeType.Whitespace) continue;
+					if (A.type(cv) === NodeType.Whitespace) continue;
 
 					if (phase === "expecting-source") {
-						if (cv.type === NodeType.String) {
+						if (A.type(cv) === NodeType.String) {
 							fromSource = {
 								kind: "string",
-								path: source.slice(cv.start + 1, cv.end - 1)
+								path: source.slice(A.start(cv) + 1, A.end(cv) - 1)
 							};
 							phase = "done";
 							continue;
 						}
 						if (
-							cv.type === NodeType.Ident &&
-							equalsLowerCase(/** @type {Token} */ (cv).value, "global")
+							A.type(cv) === NodeType.Ident &&
+							equalsLowerCase(A.value(cv), "global")
 						) {
 							fromSource = { kind: "global" };
 							phase = "done";
@@ -2448,8 +2457,8 @@ class CssParser extends Parser {
 						continue;
 					}
 
-					if (cv.type === NodeType.Ident) {
-						const identValue = /** @type {Token} */ (cv).value;
+					if (A.type(cv) === NodeType.Ident) {
+						const identValue = A.value(cv);
 						if (
 							equalsLowerCase(identValue, "from") &&
 							classNames.length > 0 &&
@@ -2459,21 +2468,21 @@ class CssParser extends Parser {
 							continue;
 						}
 						classNames.push({
-							start: cv.start,
-							end: cv.end,
+							start: A.start(cv),
+							end: A.end(cv),
 							isGlobal: false
 						});
 						continue;
 					}
 
-					if (cv.type === NodeType.Function) {
+					if (A.type(cv) === NodeType.Function) {
 						const fn = /** @type {FunctionNode} */ (cv);
-						const isGlobal = equalsLowerCase(fn.unescapedName, "global");
-						for (const inner of fn.value) {
-							if (inner.type === NodeType.Ident) {
+						const isGlobal = equalsLowerCase(A.unescapedName(fn), "global");
+						for (const inner of A.children(fn)) {
+							if (A.type(inner) === NodeType.Ident) {
 								classNames.push({
-									start: inner.start,
-									end: inner.end,
+									start: A.start(inner),
+									end: A.end(inner),
 									isGlobal
 								});
 								break;
@@ -2500,8 +2509,8 @@ class CssParser extends Parser {
 						state,
 						errorMessage,
 						locConverter,
-						errorToken.start,
-						errorToken.end
+						A.start(errorToken),
+						A.end(errorToken)
 					);
 					return;
 				}
@@ -2512,13 +2521,13 @@ class CssParser extends Parser {
 			}
 
 			// Strip the whole `composes: …;` (property name included) plus trailing same-line whitespace. The `;` and that whitespace aren't AST nodes (a block's contents drop them), so scan the source here.
-			let resumeAt = decl.end;
-			if (source.charCodeAt(decl.end) === CC_SEMICOLON) {
-				resumeAt = decl.end + 1;
+			let resumeAt = A.end(decl);
+			if (source.charCodeAt(A.end(decl)) === CC_SEMICOLON) {
+				resumeAt = A.end(decl) + 1;
 				while (isCssWhitespace(source.charCodeAt(resumeAt))) resumeAt++;
 			}
 			module.addPresentationalDependency(
-				new ConstDependency("", [decl.nameStart, resumeAt])
+				new ConstDependency("", [A.nameStart(decl), resumeAt])
 			);
 		};
 
@@ -2530,63 +2539,69 @@ class CssParser extends Parser {
 		const emitUrlFunction = (fn, fname) => {
 			if (fname === "url" || fname === "src") {
 				// Quoted `url("…")` / `src("…")`: first non-whitespace value must be the string token.
-				const first = fn.value[nextNonWhitespace(fn.value, 0)];
-				if (!first || first.type !== NodeType.String) return;
+				const first = A.children(fn)[nextNonWhitespace(A.children(fn), 0)];
+				if (!first || A.type(first) !== NodeType.String) return;
 				const string = /** @type {Token} */ (first);
 				if (
 					webpackIgnored(
-						[lastTokenEndForComments, fn.start],
-						string.start,
-						string.end
+						[lastTokenEndForComments, A.start(fn)],
+						A.start(string),
+						A.end(string)
 					)
 				) {
 					return;
 				}
 				const value = normalizeUrl(
-					input.slice(string.start + 1, string.end - 1),
+					input.slice(A.start(string) + 1, A.end(string) - 1),
 					true
 				);
 				// Ignore `url()`, `url('')` and `url("")`, they are valid by spec
 				if (value.length === 0) return;
 				const dep = new CssUrlDependency(
 					value,
-					[string.start, string.end],
+					[A.start(string), A.end(string)],
 					"string"
 				);
-				setDepLoc(dep, string.start, string.end);
+				setDepLoc(dep, A.start(string), A.end(string));
 				module.addDependency(dep);
 				module.addCodeGenerationDependency(dep);
 			} else if (IMAGE_SET_FUNCTION.test(fname)) {
 				// `image-set(…)`: each comma segment's first string is the URL; advance the magic-comment fence per string.
-				lastTokenEndForComments = fn.nameEnd + 1;
-				let prevStringEnd = fn.start;
+				lastTokenEndForComments = A.nameEnd(fn) + 1;
+				let prevStringEnd = A.start(fn);
 				let firstInSegment = true;
-				for (const cv of fn.value) {
-					if (cv.type === NodeType.Comma) {
+				for (const cv of A.children(fn)) {
+					if (A.type(cv) === NodeType.Comma) {
 						firstInSegment = true;
 						continue;
 					}
-					if (cv.type === NodeType.Whitespace) continue;
+					if (A.type(cv) === NodeType.Whitespace) continue;
 					const wasFirst = firstInSegment;
 					firstInSegment = false;
-					if (!wasFirst || cv.type !== NodeType.String) continue;
+					if (!wasFirst || A.type(cv) !== NodeType.String) continue;
 					const string = /** @type {Token} */ (cv);
 					const start = prevStringEnd;
-					prevStringEnd = string.end;
+					prevStringEnd = A.end(string);
 					const value = normalizeUrl(
-						input.slice(string.start + 1, string.end - 1),
+						input.slice(A.start(string) + 1, A.end(string) - 1),
 						true
 					);
 					if (value.length === 0) continue;
-					if (webpackIgnored([start, string.end], string.start, string.end)) {
+					if (
+						webpackIgnored(
+							[start, A.end(string)],
+							A.start(string),
+							A.end(string)
+						)
+					) {
 						continue;
 					}
 					const dep = new CssUrlDependency(
 						value,
-						[string.start, string.end],
+						[A.start(string), A.end(string)],
 						"url"
 					);
-					setDepLoc(dep, string.start, string.end);
+					setDepLoc(dep, A.start(string), A.end(string));
 					module.addDependency(dep);
 					module.addCodeGenerationDependency(dep);
 				}
@@ -2605,24 +2620,24 @@ class CssParser extends Parser {
 					state,
 					"Any '@import' rules must precede all other rules",
 					locConverter,
-					at.start,
-					at.nameEnd
+					A.start(at),
+					A.nameEnd(at)
 				);
 				return;
 			}
-			const importStart = at.start;
-			const importNameEnd = at.nameEnd;
+			const importStart = A.start(at);
+			const importNameEnd = A.nameEnd(at);
 			// We only accept `;`-terminated @import; block / EOF / `}` ends are silent bails.
-			if (source.charCodeAt(at.end) !== CC_SEMICOLON) return;
+			if (source.charCodeAt(A.end(at)) !== CC_SEMICOLON) return;
 
 			// Walk the prelude in spec order (URL → layer? → supports? → media query); anything else joins the media query.
 			const { urlNode, layerNode, supportsNode } = parseImportPrelude(
-				at.prelude
+				A.prelude(at)
 			);
 
-			const semi = at.end + 1; // position past `;`
+			const semi = A.end(at) + 1; // position past `;`
 
-			if (!urlNode || (urlNode.type === NodeType.Ident && !isModules)) {
+			if (!urlNode || (A.type(urlNode) === NodeType.Ident && !isModules)) {
 				this._emitWarning(
 					state,
 					`Expected URL in '${input.slice(importStart, semi)}'`,
@@ -2630,17 +2645,16 @@ class CssParser extends Parser {
 					importStart,
 					semi
 				);
-				// A malformed `@import` still emits orphan url() deps from its prelude — flag the node so the value visitors enable url().
-				/** @type {AtRule & { urlRecovery?: boolean }} */ (at).urlRecovery =
-					true;
+				// A malformed `@import` still emits orphan url() deps from its prelude — flag it so the value visitors enable url().
+				currentUrlRecovery = true;
 				return;
 			}
 
 			/** @type {string} */
 			let url;
-			if (urlNode.type === NodeType.Ident) {
+			if (A.type(urlNode) === NodeType.Ident) {
 				// URL given as identifier — resolve via CSS Modules `@value`.
-				const identName = /** @type {Token} */ (urlNode).value;
+				const identName = A.value(urlNode);
 				const def = icssDefinitions.get(identName);
 				if (!def) {
 					this._emitWarning(
@@ -2676,21 +2690,24 @@ class CssParser extends Parser {
 					(raw.startsWith("'") && raw.endsWith("'"))
 						? normalizeUrl(raw.slice(1, -1), true)
 						: normalizeUrl(raw, false);
-			} else if (urlNode.type === NodeType.Url) {
+			} else if (A.type(urlNode) === NodeType.Url) {
 				const ut = /** @type {UrlToken} */ (urlNode);
-				url = normalizeUrl(input.slice(ut.contentStart, ut.contentEnd), false);
-			} else if (urlNode.type === NodeType.String) {
 				url = normalizeUrl(
-					input.slice(urlNode.start + 1, urlNode.end - 1),
+					input.slice(A.contentStart(ut), A.contentEnd(ut)),
+					false
+				);
+			} else if (A.type(urlNode) === NodeType.String) {
+				url = normalizeUrl(
+					input.slice(A.start(urlNode) + 1, A.end(urlNode) - 1),
 					true
 				);
 			} else {
 				// url(...) function — first non-whitespace child is the string.
 				/** @type {Token | undefined} */
 				let string;
-				for (const inner of /** @type {FunctionNode} */ (urlNode).value) {
-					if (inner.type === NodeType.Whitespace) continue;
-					if (inner.type === NodeType.String) {
+				for (const inner of A.children(urlNode)) {
+					if (A.type(inner) === NodeType.Whitespace) continue;
+					if (A.type(inner) === NodeType.String) {
 						string = /** @type {Token} */ (inner);
 					}
 					break;
@@ -2705,11 +2722,16 @@ class CssParser extends Parser {
 					);
 					return;
 				}
-				url = normalizeUrl(input.slice(string.start + 1, string.end - 1), true);
+				url = normalizeUrl(
+					input.slice(A.start(string) + 1, A.end(string) - 1),
+					true
+				);
 			}
 
 			const newline = skipWhiteLine(input, semi);
-			if (webpackIgnored([importNameEnd, urlNode.end], importStart, newline)) {
+			if (
+				webpackIgnored([importNameEnd, A.end(urlNode)], importStart, newline)
+			) {
 				return;
 			}
 			if (url.length === 0) {
@@ -2723,10 +2745,10 @@ class CssParser extends Parser {
 			/** @type {undefined | string} */
 			let layer;
 			if (layerNode) {
-				if (layerNode.type === NodeType.Function) {
+				if (A.type(layerNode) === NodeType.Function) {
 					// `layer(<ident>)` — extract content between `(` and `)`.
 					const fn = /** @type {FunctionNode} */ (layerNode);
-					layer = input.slice(fn.nameEnd + 1, fn.end - 1).trim();
+					layer = input.slice(A.nameEnd(fn) + 1, A.end(fn) - 1).trim();
 				} else {
 					// Bare `layer` ident — anonymous layer.
 					layer = "";
@@ -2737,21 +2759,23 @@ class CssParser extends Parser {
 			let supports;
 			if (supportsNode) {
 				supports = input
-					.slice(supportsNode.nameEnd + 1, supportsNode.end - 1)
+					.slice(A.nameEnd(supportsNode) + 1, A.end(supportsNode) - 1)
 					.trim();
 			}
 
 			// Media query = whatever sits between the last url/layer/supports part and the closing `;`, trimmed. Start at the next non-whitespace prelude node (skips the gap, comments included).
 			const lastPrefixPart = supportsNode || layerNode || urlNode;
 			const afterIdx =
-				/** @type {AstNode[]} */ (at.prelude).indexOf(lastPrefixPart) + 1;
-			const nextIdx = nextNonWhitespace(at.prelude, afterIdx);
+				/** @type {AstNode[]} */ (A.prelude(at)).indexOf(lastPrefixPart) + 1;
+			const nextIdx = nextNonWhitespace(A.prelude(at), afterIdx);
 			const mediaStart =
-				nextIdx < at.prelude.length ? at.prelude[nextIdx].start : at.end;
+				nextIdx < A.prelude(at).length
+					? A.start(A.prelude(at)[nextIdx])
+					: A.end(at);
 			/** @type {undefined | string} */
 			let media;
-			if (mediaStart !== at.end) {
-				media = input.slice(mediaStart, at.end).trim();
+			if (mediaStart !== A.end(at)) {
+				media = input.slice(mediaStart, A.end(at)).trim();
 			}
 
 			const { line: sl, column: sc } = locConverter.get(importStart);
@@ -2793,9 +2817,9 @@ class CssParser extends Parser {
 		 * @param {AtRule} at the `@value` at-rule
 		 */
 		const handleValueAtRule = (at) => {
-			const start = at.start;
-			const nameEnd = at.nameEnd;
-			const semi = at.end;
+			const start = A.start(at);
+			const nameEnd = A.nameEnd(at);
+			const semi = A.end(at);
 			const atRuleEnd =
 				source.charCodeAt(semi) === CC_SEMICOLON ? semi + 1 : semi;
 			const params = input.slice(nameEnd, semi);
@@ -2956,12 +2980,12 @@ class CssParser extends Parser {
 			/** @type {(cvs: AstNode[]) => void} */
 			const walkExports = (cvs) => {
 				for (const cv of cvs) {
-					switch (cv.type) {
+					switch (A.type(cv)) {
 						case NodeType.Comma:
 							parsedKeywords = Object.create(null);
 							break;
 						case NodeType.Delim:
-							afterExclamation = /** @type {Token} */ (cv).value === "!";
+							afterExclamation = A.value(cv) === "!";
 							break;
 						case NodeType.Ident: {
 							if (isGridTemplate) break;
@@ -2969,7 +2993,7 @@ class CssParser extends Parser {
 								afterExclamation = false;
 								break;
 							}
-							const identifier = /** @type {Token} */ (cv).value;
+							const identifier = A.value(cv);
 							const keyword = identifier.toLowerCase();
 							parsedKeywords[keyword] =
 								typeof parsedKeywords[keyword] !== "undefined"
@@ -2981,7 +3005,7 @@ class CssParser extends Parser {
 							) {
 								break;
 							}
-							emit(cv.start, cv.end);
+							emit(A.start(cv), A.end(cv));
 							break;
 						}
 						case NodeType.String: {
@@ -2989,17 +3013,17 @@ class CssParser extends Parser {
 								declPropertyName === "animation" ||
 								declPropertyName === "animation-name"
 							) {
-								emit(cv.start, cv.end, true);
+								emit(A.start(cv), A.end(cv), true);
 							}
 							if (
 								declPropertyName === "grid" ||
 								declPropertyName === "grid-template" ||
 								declPropertyName === "grid-template-areas"
 							) {
-								const areas = /** @type {Token} */ (cv).unescaped;
+								const areas = A.unescaped(cv);
 								const matches = matchAll(/\b\w+\b/g, areas);
 								for (const match of matches) {
-									const areaStart = cv.start + 1 + match.index;
+									const areaStart = A.start(cv) + 1 + match.index;
 									emit(areaStart, areaStart + match[0].length, false);
 								}
 							}
@@ -3007,28 +3031,28 @@ class CssParser extends Parser {
 						}
 						case NodeType.SimpleBlock: {
 							const block = /** @type {SimpleBlock} */ (cv);
-							if (block.token === "[") {
+							if (A.blockToken(block) === "[") {
 								// Collect identifiers until the first non-ident token (`<line-names> = '[' <custom-ident>* ']'`).
-								for (const inner of block.value) {
-									if (inner.type === NodeType.Whitespace) continue;
-									if (inner.type !== NodeType.Ident) break;
-									emit(inner.start, inner.end);
+								for (const inner of A.children(block)) {
+									if (A.type(inner) === NodeType.Whitespace) continue;
+									if (A.type(inner) !== NodeType.Ident) break;
+									emit(A.start(inner), A.end(inner));
 								}
 							} else if (isGridTemplate) {
-								walkExports(block.value);
+								walkExports(A.children(block));
 							}
 							break;
 						}
 						case NodeType.Function:
 							if (isGridTemplate) {
-								walkExports(/** @type {FunctionNode} */ (cv).value);
+								walkExports(A.children(cv));
 							}
 							break;
 						// Other types carry no ICSS-export information.
 					}
 				}
 			};
-			walkExports(decl.value);
+			walkExports(A.children(decl));
 		};
 
 		/**
@@ -3047,27 +3071,26 @@ class CssParser extends Parser {
 		) => {
 			const acceptIdent = isKeyframes || isCounterStyle || isContainer;
 			const acceptString = isKeyframes;
-			for (const cv of at.prelude) {
-				if (cv.type === NodeType.Whitespace) continue;
-				if (cv.type === NodeType.String) {
+			for (const cv of A.prelude(at)) {
+				const cvType = A.type(cv);
+				if (cvType === NodeType.Whitespace) continue;
+				if (cvType === NodeType.String) {
 					if (acceptString) pure.markLocal();
 					break;
 				}
-				if (cv.type === NodeType.Ident) {
+				if (cvType === NodeType.Ident) {
 					if (!acceptIdent) break;
-					if (isContainer && isContainerKeyword(source, cv.start, cv.end)) {
+					if (
+						isContainer &&
+						isContainerKeyword(source, A.start(cv), A.end(cv))
+					) {
 						continue;
 					}
 					pure.markLocal();
 					break;
 				}
-				if (cv.type === NodeType.Function) {
-					if (
-						equalsLowerCase(
-							/** @type {FunctionNode} */ (cv).unescapedName,
-							"local"
-						)
-					) {
+				if (cvType === NodeType.Function) {
+					if (equalsLowerCase(A.unescapedName(cv), "local")) {
 						pure.markLocal();
 					}
 					break;
@@ -3083,7 +3106,8 @@ class CssParser extends Parser {
 				enter: (node, parent) => {
 					const at = /** @type {AtRule} */ (node);
 					const topLevel = parent === null;
-					advanceCommentCursor(at.start);
+					currentUrlRecovery = false;
+					advanceCommentCursor(A.start(at));
 					const savedAnchor = currentRule.hasLocalAnchor;
 					const savedLocalIdentifiers = currentRule.localIdentifiers;
 					// Only modules-mode walks mutate `localIdentifiers`; otherwise share
@@ -3091,33 +3115,32 @@ class CssParser extends Parser {
 					currentRule.localIdentifiers = isModules
 						? [...savedLocalIdentifiers]
 						: savedLocalIdentifiers;
-					const name = `@${at.name.toLowerCase()}`;
+					const name = `@${A.name(at).toLowerCase()}`;
 					switch (name) {
 						case "@namespace": {
 							this._emitWarning(
 								state,
 								"'@namespace' is not supported in bundled CSS",
 								locConverter,
-								at.start,
-								at.nameEnd
+								A.start(at),
+								A.nameEnd(at)
 							);
 							break;
 						}
 						case "@charset": {
 							if (/** @type {CssModule} */ (module).exportType !== "style") {
+								const atEnd = A.end(at);
 								const atRuleEnd =
-									source.charCodeAt(at.end) === CC_SEMICOLON
-										? at.end + 1
-										: at.end;
-								const dep = new ConstDependency("", [at.start, atRuleEnd]);
+									source.charCodeAt(atEnd) === CC_SEMICOLON ? atEnd + 1 : atEnd;
+								const dep = new ConstDependency("", [A.start(at), atRuleEnd]);
 								module.addPresentationalDependency(dep);
-								const string = at.prelude.find(
-									(v) => v.type !== NodeType.Whitespace
+								const string = A.prelude(at).find(
+									(v) => A.type(v) !== NodeType.Whitespace
 								);
-								if (string && string.type === NodeType.String) {
+								if (string && A.type(string) === NodeType.String) {
 									/** @type {CssModuleBuildInfo} */
 									(module.buildInfo).charset = source
-										.slice(string.start + 1, string.end - 1)
+										.slice(A.start(string) + 1, A.end(string) - 1)
 										.toUpperCase();
 								}
 							}
@@ -3158,11 +3181,11 @@ class CssParser extends Parser {
 					// `@scope (.x) to (.y)` — walk the prelude as a selector list.
 					if (
 						isModules &&
-						equalsLowerCase(at.name, "scope") &&
-						at.prelude.length > 0
+						equalsLowerCase(A.name(at), "scope") &&
+						A.prelude(at).length > 0
 					) {
 						walkSelectorList(
-							at.prelude,
+							A.prelude(at),
 							/** @type {"local" | "global"} */ (
 								mode === "local" ? "local" : "global"
 							)
@@ -3175,14 +3198,9 @@ class CssParser extends Parser {
 					currentStructural = at;
 					currentAtRuleName = name;
 					dashed.active = false;
-					// `@import` url() is the import target — only walk its prelude for url deps on malformed-import recovery (flagged on the node).
-					const atWithRecovery =
-						/** @type {AtRule & { urlRecovery?: boolean }} */ (at);
-					if (
-						this.options.url &&
-						(name !== "@import" || atWithRecovery.urlRecovery)
-					) {
-						lastTokenEndForComments = at.nameEnd;
+					// `@import` url() is the import target — only walk its prelude for url deps on malformed-import recovery.
+					if (this.options.url && (name !== "@import" || currentUrlRecovery)) {
+						lastTokenEndForComments = A.nameEnd(at);
 					}
 					// Dashed-ident scoping over the prelude (the Ident / Function visitors emit).
 					dashed.active = Boolean(
@@ -3219,18 +3237,21 @@ class CssParser extends Parser {
 					}
 
 					// pure.stack push for block-bearing at-rules.
-					const atHasBlock = Boolean(at.declarations || at.childRules);
-					if (atHasBlock && at.blockStart !== -1) {
+					const atDecls = A.declarations(at);
+					const atChildRules = A.childRules(at);
+					const atHasBlock = Boolean(atDecls || atChildRules);
+					const atBlockStart = A.blockStart(at);
+					if (atHasBlock && atBlockStart !== -1) {
 						const isAtRulePrelude = isPureBodyAtRule(name);
 						if (isAtRulePrelude) pure.finalizeSelector();
 						pure.enterBlock({
 							isRulePrelude: isAtRulePrelude,
 							treatAsLeaf: atTreatAsLeaf,
 							ownSkip: atSkipChildren,
-							declarations: at.declarations,
-							childRules: at.childRules,
-							preludeStart: at.start,
-							preludeEnd: at.blockStart
+							declarations: atDecls,
+							childRules: atChildRules,
+							preludeStart: A.start(at),
+							preludeEnd: atBlockStart
 						});
 					}
 
@@ -3239,7 +3260,7 @@ class CssParser extends Parser {
 						savedLocalIdentifiers,
 						name,
 						hasBlock: atHasBlock,
-						endsWithSemicolon: source.charCodeAt(at.end) === CC_SEMICOLON
+						endsWithSemicolon: source.charCodeAt(A.end(at)) === CC_SEMICOLON
 					});
 				},
 				// At-rule exit: pure-frame finalization, `suppressNextRulePrelude`, scope restore, top-level reset.
@@ -3266,25 +3287,27 @@ class CssParser extends Parser {
 				enter: (node, parent, ctx) => {
 					const rule = /** @type {QualifiedRule} */ (node);
 					const topLevel = parent === null;
-					advanceCommentCursor(rule.start);
+					advanceCommentCursor(A.start(rule));
 					// `:import(…) { … }` / `:export { … }` ICSS pseudo-rules are processed inline at top level; nested ones bail out.
 					if (isModules) {
-						const firstIdx = nextNonWhitespace(rule.prelude, 0);
+						const rulePrelude = A.prelude(rule);
+						const firstIdx = nextNonWhitespace(rulePrelude, 0);
 						if (
-							firstIdx + 1 < rule.prelude.length &&
-							rule.prelude[firstIdx].type === NodeType.Colon
+							firstIdx + 1 < rulePrelude.length &&
+							A.type(rulePrelude[firstIdx]) === NodeType.Colon
 						) {
-							const second = rule.prelude[firstIdx + 1];
+							const second = rulePrelude[firstIdx + 1];
+							const secondType = A.type(second);
 							const rawName =
-								second.type === NodeType.Ident
-									? /** @type {Token} */ (second).value
-									: second.type === NodeType.Function
-										? /** @type {FunctionNode} */ (second).name
+								secondType === NodeType.Ident
+									? A.value(second)
+									: secondType === NodeType.Function
+										? A.name(second)
 										: "";
 							const isImport = equalsLowerCase(rawName, "import");
 							if (isImport || equalsLowerCase(rawName, "export")) {
 								if (topLevel) {
-									const startColon = rule.prelude[firstIdx].start;
+									const startColon = A.start(rulePrelude[firstIdx]);
 									const endAfterBody = processImportOrExport(
 										isImport ? 0 : 1,
 										second,
@@ -3293,11 +3316,13 @@ class CssParser extends Parser {
 									module.addPresentationalDependency(
 										new ConstDependency("", [startColon, endAfterBody])
 									);
-									if (rule.blockStart !== -1) rule.blockEnd = endAfterBody;
-									rule.end = endAfterBody;
-								} else if (rule.blockStart !== -1) {
+									if (A.blockStart(rule) !== -1) {
+										A.setBlockEnd(rule, endAfterBody);
+									}
+									A.setEnd(rule, endAfterBody);
+								} else if (A.blockStart(rule) !== -1) {
 									// Nested `:import` / `:export` — leave the body alone.
-									rule.end = rule.blockEnd;
+									A.setEnd(rule, A.blockEnd(rule));
 								}
 								// Don't recurse into the body — handled inline above.
 								if (ctx) ctx.skipChildren();
@@ -3327,9 +3352,10 @@ class CssParser extends Parser {
 						savedComposesFiles
 					});
 					// Selectors are only CSS-Modules-relevant when `isModules` holds.
+					const rulePrelude = A.prelude(rule);
 					if (isModules) {
 						walkSelectorList(
-							rule.prelude,
+							rulePrelude,
 							/** @type {"local" | "global"} */ (
 								mode === "local" ? "local" : "global"
 							)
@@ -3339,20 +3365,20 @@ class CssParser extends Parser {
 					currentStructural = rule;
 					dashed.active = false;
 					dashed.emit = false;
-					if (this.options.url && rule.prelude.length > 0) {
-						lastTokenEndForComments = rule.prelude[0].start;
+					if (this.options.url && rulePrelude.length > 0) {
+						lastTokenEndForComments = A.start(rulePrelude[0]);
 					}
 					// Dashed-ident scoping for the deprecated `--foo: { … }` custom-property-set syntax (prelude starts with a dashed-ident).
 					if (
 						this.options.dashedIdents &&
 						isModules &&
-						rule.prelude.length > 0
+						rulePrelude.length > 0
 					) {
-						const first = rule.prelude[nextNonWhitespace(rule.prelude, 0)];
+						const first = rulePrelude[nextNonWhitespace(rulePrelude, 0)];
 						if (
 							first &&
-							first.type === NodeType.Ident &&
-							isDashedIdentifier(/** @type {Token} */ (first).value)
+							A.type(first) === NodeType.Ident &&
+							isDashedIdentifier(A.value(first))
 						) {
 							const effectiveLocalMode = isEffectivelyLocal();
 							if (effectiveLocalMode) {
@@ -3362,14 +3388,15 @@ class CssParser extends Parser {
 						}
 					}
 					// Pure-mode: report an impure prelude (if leaf-ish) and push the inherited-context frame before walking the body.
+					const ruleBlockStart = A.blockStart(rule);
 					pure.enterBlock({
 						isRulePrelude: true,
 						treatAsLeaf: false,
 						ownSkip: false,
-						declarations: rule.declarations,
-						childRules: rule.childRules,
-						preludeStart: rule.start,
-						preludeEnd: rule.blockStart !== -1 ? rule.blockStart : rule.end
+						declarations: A.declarations(rule),
+						childRules: A.childRules(rule),
+						preludeStart: A.start(rule),
+						preludeEnd: ruleBlockStart !== -1 ? ruleBlockStart : A.end(rule)
 					});
 				},
 				// Qualified-rule exit: pure-frame finalization, scope restore, top-level reset; no-op for bailed ICSS.
@@ -3391,13 +3418,8 @@ class CssParser extends Parser {
 				currentStructural = decl;
 				dashed.active = false;
 				dashed.emit = false;
-				const declPropertyName = decl.name
-					.replace(/^(-\w+-)/, "")
-					.toLowerCase();
-				// Cache the known-property flag so the per-token value visitors don't recompute it.
-				currentDeclIsKnownProperty = knownProperties.has(declPropertyName);
-				// Position `lastTokenEndForComments` just past the `:` so a magic comment before the url() is found.
-				let colonPos = decl.nameEnd;
+				// Position `lastTokenEndForComments` just past the `:` so a magic comment before a url() is found (every mode).
+				let colonPos = A.nameEnd(decl);
 				while (
 					colonPos < source.length &&
 					source.charCodeAt(colonPos) !== CC_COLON
@@ -3405,6 +3427,15 @@ class CssParser extends Parser {
 					colonPos++;
 				}
 				lastTokenEndForComments = colonPos + 1;
+				currentDeclIsKnownProperty = false;
+				currentDeclComposesSkip = false;
+				// Property-name analysis and value exports are CSS-Modules-only; a plain
+				// stylesheet's declarations need no per-decl name slice / known-property lookup.
+				if (!isModules) return;
+				const declName = A.name(decl);
+				const declPropertyName = declName.replace(/^(-\w+-)/, "").toLowerCase();
+				// Cache the known-property flag so the per-token value visitors don't recompute it.
+				currentDeclIsKnownProperty = knownProperties.has(declPropertyName);
 				const effectiveLocalMode = isEffectivelyLocal();
 				// `composes:` with a local anchor: its strip-dep covers the whole declaration, so suppress the value's local/global/dashed/ICSS rewrites.
 				currentDeclComposesSkip =
@@ -3413,31 +3444,29 @@ class CssParser extends Parser {
 				if (currentDeclComposesSkip) emitComposesWithAnchor(decl);
 				const skipForComposes = currentDeclComposesSkip;
 				// Known-property value localization (`animation-name: foo` exports `foo`).
-				if (isModules && effectiveLocalMode && currentDeclIsKnownProperty) {
+				if (effectiveLocalMode && currentDeclIsKnownProperty) {
 					emitKnownPropertyExports(decl, declPropertyName);
 				}
 				// Dashed-ident (custom-property) export of the property name; the value's dashed idents are scoped by the Ident / Function visitors (top-level only for unknown properties).
 				if (
 					this.options.dashedIdents &&
-					isModules &&
 					effectiveLocalMode &&
 					!skipForComposes
 				) {
-					if (isDashedIdentifier(decl.name)) {
-						emitDashedIdentExport(decl.nameStart, decl.nameEnd);
+					if (isDashedIdentifier(declName)) {
+						emitDashedIdentExport(A.nameStart(decl), A.nameEnd(decl));
 					}
 					dashed.active = true;
 					dashed.emit = !currentDeclIsKnownProperty;
 				}
 				// ICSS-symbol rewrite (`color: foo` when `foo` is `@value`-defined), skipping known properties, the composes anchor, and dashed idents (handled above).
 				if (
-					isModules &&
 					!skipForComposes &&
 					!currentDeclIsKnownProperty &&
-					!(dashed.active && isDashedIdentifier(decl.name)) &&
-					icssDefinitions.has(decl.name)
+					!(dashed.active && isDashedIdentifier(declName)) &&
+					icssDefinitions.has(declName)
 				) {
-					emitICSSSymbol(decl.name, decl.nameStart, decl.nameEnd);
+					emitICSSSymbol(declName, A.nameStart(decl), A.nameEnd(decl));
 				}
 			},
 			// Value-level visitors decide handling from the enclosing node via `urlActive()` / `localGlobalActive()` / `icssActive()`.
@@ -3447,7 +3476,7 @@ class CssParser extends Parser {
 				// Skip bare url-tokens for a known property in CSS-Modules local mode.
 				if (
 					currentStructural &&
-					currentStructural.type === NodeType.Declaration &&
+					A.type(currentStructural) === NodeType.Declaration &&
 					isModules &&
 					currentDeclIsKnownProperty &&
 					isEffectivelyLocal()
@@ -3456,15 +3485,15 @@ class CssParser extends Parser {
 				}
 				if (
 					webpackIgnored(
-						[lastTokenEndForComments, node.end],
+						[lastTokenEndForComments, A.end(node)],
 						lastTokenEndForComments,
-						node.end
+						A.end(node)
 					)
 				) {
 					return;
 				}
 				let value = normalizeUrl(
-					input.slice(url.contentStart, url.contentEnd),
+					input.slice(A.contentStart(url), A.contentEnd(url)),
 					false
 				);
 				// Ignore `url()`, `url('')` and `url("")`, they are valid by spec
@@ -3485,25 +3514,29 @@ class CssParser extends Parser {
 								state,
 								`'@value' identifier '${value}' was imported from another module and cannot be used inside 'url()' — only locally defined values are supported here`,
 								locConverter,
-								node.start,
-								node.end
+								A.start(node),
+								A.end(node)
 							);
 							return;
 						}
 					}
 				}
-				const dep = new CssUrlDependency(value, [node.start, node.end], "url");
-				setDepLoc(dep, node.start, node.end);
+				const dep = new CssUrlDependency(
+					value,
+					[A.start(node), A.end(node)],
+					"url"
+				);
+				setDepLoc(dep, A.start(node), A.end(node));
 				module.addDependency(dep);
 				module.addCodeGenerationDependency(dep);
 			},
 			[NodeType.Comma](node) {
-				if (urlActive()) lastTokenEndForComments = node.start;
+				if (urlActive()) lastTokenEndForComments = A.start(node);
 			},
 			[NodeType.Function]: {
 				enter: (node) => {
 					const fn = /** @type {FunctionNode} */ (node);
-					const fnameRaw = fn.unescapedName;
+					const fnameRaw = A.unescapedName(fn);
 					const fname = fnameRaw.toLowerCase();
 					if (urlActive()) emitUrlFunction(fn, fname);
 					if (
@@ -3519,7 +3552,7 @@ class CssParser extends Parser {
 						!(dashed.active && isDashedIdentifier(fnameRaw)) &&
 						icssDefinitions.has(fnameRaw)
 					) {
-						emitICSSSymbol(fnameRaw, fn.nameStart, fn.nameEnd);
+						emitICSSSymbol(fnameRaw, A.nameStart(fn), A.nameEnd(fn));
 					}
 					// Dashed-ident scoping: handle this function, then set the child nesting level's state for the walk.
 					dashed.push();
@@ -3531,9 +3564,9 @@ class CssParser extends Parser {
 							// `var(--foo, …)` / `style(--foo, …)`: emit the first ident; the fallback doesn't self-emit.
 							processDashedIdentInVarFunction(fn);
 							dashed.emit = false;
-						} else if (dashed.emit && isDashedIdentifier(fn.name)) {
+						} else if (dashed.emit && isDashedIdentifier(A.name(fn))) {
 							// Custom-function call `--my-func(args)` — the name is the exported dashed-ident.
-							emitDashedIdentExport(fn.nameStart, fn.nameEnd);
+							emitDashedIdentExport(A.nameStart(fn), A.nameEnd(fn));
 						}
 					}
 				},
@@ -3542,8 +3575,15 @@ class CssParser extends Parser {
 				}
 			},
 			[NodeType.Ident](node, parent) {
-				const identValue = /** @type {Token} */ (node).value;
-				if (dashed.active && isDashedIdentifier(identValue)) {
+				// Fast exit before slicing the ident value: outside dashed-ident scoping
+				// and ICSS context (any non-CSS-Modules stylesheet) a bare ident carries
+				// no work, and idents are the most common node, so skipping the per-ident
+				// `value` slice matters.
+				const dashedActive = dashed.active;
+				const icss = icssActive();
+				if (!dashedActive && !icss) return;
+				const identValue = A.value(node);
+				if (dashedActive && isDashedIdentifier(identValue)) {
 					// Dashed idents are scoped here, never `@value` ICSS-rewritten.
 					if (!dashed.emit) return;
 					// Resolve the `--foo from "./x.css"` / `--foo from global` import suffix via sibling lookahead.
@@ -3553,37 +3593,37 @@ class CssParser extends Parser {
 						const j = nextNonWhitespace(siblings, i + 1);
 						if (
 							j < siblings.length &&
-							siblings[j].type === NodeType.Ident &&
-							equalsLowerCase(/** @type {Token} */ (siblings[j]).value, "from")
+							A.type(siblings[j]) === NodeType.Ident &&
+							equalsLowerCase(A.value(siblings[j]), "from")
 						) {
 							const fromIdent = siblings[j];
 							const sourceNode = siblings[nextNonWhitespace(siblings, j + 1)];
 							if (
 								sourceNode &&
-								sourceNode.type === NodeType.Ident &&
-								/** @type {Token} */ (sourceNode).value === "global"
+								A.type(sourceNode) === NodeType.Ident &&
+								A.value(sourceNode) === "global"
 							) {
-								emitDashedIdentFromGlobal(node.end, sourceNode.end);
+								emitDashedIdentFromGlobal(A.end(node), A.end(sourceNode));
 								return;
 							}
-							if (sourceNode && sourceNode.type === NodeType.String) {
+							if (sourceNode && A.type(sourceNode) === NodeType.String) {
 								emitDashedIdentImport(
-									node.start,
-									node.end,
-									fromIdent.start,
-									sourceNode.end,
-									input.slice(sourceNode.start + 1, sourceNode.end - 1)
+									A.start(node),
+									A.end(node),
+									A.start(fromIdent),
+									A.end(sourceNode),
+									input.slice(A.start(sourceNode) + 1, A.end(sourceNode) - 1)
 								);
 								return;
 							}
 						}
 					}
-					emitDashedIdentExport(node.start, node.end);
+					emitDashedIdentExport(A.start(node), A.end(node));
 					return;
 				}
-				if (!icssActive()) return;
+				if (!icss) return;
 				if (icssDefinitions.has(identValue)) {
-					emitICSSSymbol(identValue, node.start, node.end);
+					emitICSSSymbol(identValue, A.start(node), A.end(node));
 				}
 			}
 		};