webpack 5.108.2 → 5.108.4

package/lib/css/CssParser.js

@@ -29,8 +29,10 @@ const {
 } = require("../util/magicComment");
 const topologicalSort = require("../util/topologicalSort");
 const {
+	A,
 	NodeType,
 	SourceProcessor,
+	buildSkipSet,
 	equalsLowerCase,
 	unescapeIdentifier
 } = require("./syntax");
@@ -65,6 +67,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);
@@ -91,8 +94,32 @@ const IMAGE_SET_FUNCTION = /^(?:-\w+-)?image-set$/i;
 const MAGIC_COMMENT_FAST_PATH =
 	/^\s*(webpack[A-Z][A-Za-z]+)\s*:\s*(true|false|null|-?\d+(?:\.\d+)?)\s*$/;
 const OPTIONALLY_VENDOR_PREFIXED_KEYFRAMES_AT_RULE = /^@(?:-\w+-)?keyframes$/;
+const VENDOR_PREFIX = /^-\w+-/;
 const COMPOSES_PROPERTY = /^(?:composes|compose-with)$/i;
 const IS_MODULES = /\.modules?\.[^.]+$/i;
+
+// Skip options for a non-CSS-Modules parse: drop the selector prelude (never
+// walked without modules) plus value / function-arg leaves nothing reads (the
+// `Ident` visitor no-ops, the `Declaration` visitor returns early, no ICSS).
+// `url` / functions / strings / blocks / commas are kept — they carry url()
+// rewrites and image-set fences. At-rule preludes are kept (`@media` / `@import`
+// are read). CSS-Modules parses skip nothing: selectors are walked and ICSS
+// `:export { k: v }` captures each value's byte range from its first / last node.
+const SKIP_NON_MODULES = {
+	types: buildSkipSet([
+		NodeType.Number,
+		NodeType.Dimension,
+		NodeType.Percentage,
+		NodeType.Ident,
+		NodeType.Hash,
+		NodeType.Colon,
+		NodeType.Delim,
+		// Nothing reads value/arg whitespace either — consumers use
+		// `nextNonWhitespace` / type checks that tolerate its absence.
+		NodeType.Whitespace
+	]),
+	selectorPrelude: true
+};
 const CSS_COMMENT = /\/\*((?!\*\/)[\s\S]*?)\*\//g;
 // `@value` recognizers (postcss-modules-values shape): the import form `<names> from <source>`, and the `<importName> as <localName>` alias inside it.
 const VALUE_IMPORT_FORM = /from(\/\*|\s)(?:[\s\S]+)$/i;
@@ -182,6 +209,109 @@ const normalizeUrl = (str, isString) => {
 const isDashedIdentifier = (identifier) =>
 	identifier.startsWith("--") && identifier.length >= 3;
 
+/**
+ * `s.toLowerCase()` that returns `s` itself (no allocation) when it can't
+ * change — no ASCII uppercase and no non-ASCII (whose Unicode case mapping is
+ * left to the real `toLowerCase`).
+ * @param {string} s string
+ * @returns {string} lowercased string
+ */
+const toLowerCaseIfNeeded = (s) => {
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if ((c >= 65 && c <= 90) || c > 127) return s.toLowerCase();
+	}
+	return s;
+};
+
+/**
+ * Case-sensitive equality of a source range against a literal — no slice.
+ * @param {string} input source
+ * @param {number} start range start
+ * @param {number} end range end (exclusive)
+ * @param {string} lit literal to match
+ * @returns {boolean} true when the range equals `lit`
+ */
+const rangeEquals = (input, start, end, lit) =>
+	end - start === lit.length && input.startsWith(lit, start);
+
+/**
+ * ASCII case-insensitive equality of a source range against a lowercase ASCII literal — no slice.
+ * @param {string} input source
+ * @param {number} start range start
+ * @param {number} end range end (exclusive)
+ * @param {string} lit lowercase ASCII literal to match
+ * @returns {boolean} true when the range equals `lit` ignoring ASCII case
+ */
+const rangeEqualsLowerCase = (input, start, end, lit) => {
+	if (end - start !== lit.length) return false;
+	for (let i = 0; i < lit.length; i++) {
+		let c = input.charCodeAt(start + i);
+		if (c >= 65 && c <= 90) c |= 0x20;
+		if (c !== lit.charCodeAt(i)) return false;
+	}
+	return true;
+};
+
+/**
+ * Range-keyed index over a known-properties table: ASCII-case-folded 31-hash
+ * of the name bytes → canonical key(s). Lets the Declaration visitor answer
+ * "is this a known property" (and get the canonical lowercase name) without
+ * slicing the property name out of the source per declaration.
+ * @type {WeakMap<Map<string, Record<string, number>>, Map<number, string | string[]>>}
+ */
+const KNOWN_PROPERTY_INDEX_CACHE = new WeakMap();
+
+/**
+ * Gets (or builds) the hash index for a known-properties table.
+ * @param {Map<string, Record<string, number>>} knownProperties known properties table
+ * @returns {Map<number, string | string[]>} hash → canonical name(s)
+ */
+const getKnownPropertyIndex = (knownProperties) => {
+	let index = KNOWN_PROPERTY_INDEX_CACHE.get(knownProperties);
+	if (index === undefined) {
+		index = new Map();
+		for (const name of knownProperties.keys()) {
+			let h = name.length;
+			for (let i = 0; i < name.length; i++) {
+				h = ((h << 5) - h + name.charCodeAt(i)) | 0;
+			}
+			const hit = index.get(h);
+			if (hit === undefined) index.set(h, name);
+			else if (typeof hit === "string") index.set(h, [hit, name]);
+			else hit.push(name);
+		}
+		KNOWN_PROPERTY_INDEX_CACHE.set(knownProperties, index);
+	}
+	return index;
+};
+
+/**
+ * Canonical known-property name for a source range (ASCII case-insensitive), without slicing.
+ * @param {Map<number, string | string[]>} index hash index from `getKnownPropertyIndex`
+ * @param {string} input source
+ * @param {number} start name start
+ * @param {number} end name end (exclusive)
+ * @returns {string | undefined} canonical lowercase name, or undefined when unknown
+ */
+const knownPropertyForRange = (index, input, start, end) => {
+	let h = end - start;
+	for (let i = start; i < end; i++) {
+		let c = input.charCodeAt(i);
+		if (c >= 65 && c <= 90) c |= 0x20;
+		h = ((h << 5) - h + c) | 0;
+	}
+	const hit = index.get(h);
+	if (hit === undefined) return undefined;
+	if (typeof hit === "string") {
+		return rangeEqualsLowerCase(input, start, end, hit) ? hit : undefined;
+	}
+	for (let i = 0; i < hit.length; i++) {
+		if (rangeEqualsLowerCase(input, start, end, hit[i])) return hit[i];
+	}
+	return undefined;
+};
+
 /**
  * `binarySearchBounds` comparator for `getComments` — hoisted so the lookup
  * doesn't allocate a fresh closure per call.
@@ -577,26 +707,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(`@${toLowerCaseIfNeeded(A.name(child))}`) &&
+					scanRuleBody(atDecls, atChildRules).hasDirectDecl
 				) {
 					hasDirectDecl = true;
 				}
@@ -686,7 +817,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 +837,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 +861,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 +877,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 +901,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)
 	};
 };
 
@@ -918,6 +1044,8 @@ class CssParser extends Parser {
 			exportMode = CssIcssExportDependency.EXPORT_MODE.REPLACE,
 			exportType = CssIcssExportDependency.EXPORT_TYPE.NORMAL
 		) => {
+			// Flat location numbers — the nested loc objects were the parser's
+			// hottest allocation (3 objects per exported name).
 			cssExportEntries.push({
 				name,
 				value,
@@ -925,7 +1053,10 @@ class CssParser extends Parser {
 				interpolate,
 				exportMode,
 				exportType,
-				loc: { start: { line: sl, column: sc }, end: { line: el, column: ec } }
+				locStartLine: sl,
+				locStartColumn: sc,
+				locEndLine: el,
+				locEndColumn: ec
 			});
 		};
 
@@ -942,12 +1073,29 @@ class CssParser extends Parser {
 
 		const isModules = mode === "global" || mode === "local";
 
+		/** @type {Map<string, boolean>} */
+		const selfReferenceCache = new Map();
+
 		/**
 		 * Whether a relative `from "<request>"` resolves back to the current module (matching query/fragment too).
+		 * Memoized per parse — `composes … from "./x.css"` repeats the same request many times per file.
 		 * @param {string} request request string from `from "<request>"`
 		 * @returns {boolean} true if request resolves to the current module
 		 */
 		const isSelfReferenceRequest = (request) => {
+			const cached = selfReferenceCache.get(request);
+			if (cached !== undefined) return cached;
+			const result = isSelfReferenceRequestUncached(request);
+			selfReferenceCache.set(request, result);
+			return result;
+		};
+
+		/**
+		 * Uncached `isSelfReferenceRequest`.
+		 * @param {string} request request string from `from "<request>"`
+		 * @returns {boolean} true if request resolves to the current module
+		 */
+		const isSelfReferenceRequestUncached = (request) => {
 			if (!RELATIVE_REQUEST.test(request)) return false;
 			if (!module.context) return false;
 			const parsedRequest = parseResource(request);
@@ -971,6 +1119,7 @@ class CssParser extends Parser {
 			customIdents: this.options.customIdents,
 			grid: this.options.grid
 		});
+		const knownPropertyIndex = getKnownPropertyIndex(knownProperties);
 
 		/** @type {CssModuleBuildMeta} */
 		(module.buildMeta).isCssModule = isModules;
@@ -1054,7 +1203,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 +1319,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);
@@ -1244,18 +1393,17 @@ class CssParser extends Parser {
 			modeData ? modeData === "local" : mode === "local";
 
 		/**
-		 * Comment callback: push every comment-token (in source order) onto the local `comments`, read back by `advanceCommentCursor` (pure-mode flags) and `parseCommentOptions` (magic comments).
-		 * @param {string} input input
-		 * @param {number} start start
-		 * @param {number} end end
-		 * @returns {number} end
+		 * Comment visitor (`NodeType.Comment`): push every comment (in source order) onto the local `comments`, read back by `advanceCommentCursor` (pure-mode flags) and `parseCommentOptions` (magic comments).
+		 * @param {import("./syntax").CssPath} path walk path at the comment node
 		 */
-		const comment = (input, start, end) => {
+		const commentVisitor = (path) => {
+			const node = path.node;
+			const start = A.start(node);
+			const end = A.end(node);
 			comments.push({
-				value: input.slice(start + 2, end - 2),
+				value: source.slice(start + 2, end - 2),
 				range: [start, end]
 			});
-			return end;
 		};
 
 		/**
@@ -1457,21 +1605,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 +1655,20 @@ 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;
-					const {
-						start: { line: sl, column: sc },
-						end: { line: el, column: ec }
-					} = cv.loc;
+				for (const cv of A.children(fn)) {
+					if (A.type(cv) !== NodeType.Ident) continue;
+					let identifier = A.unescaped(cv);
+					// Cursor reads instead of `A.loc` — no location objects allocated.
+					const { line: sl, column: sc } = locConverter.get(A.start(cv));
+					const { line: el, column: ec } = locConverter.get(A.end(cv));
 					const isDashedIdent = isDashedIdentifier(identifier);
 					if (isDashedIdent) identifier = identifier.slice(2);
 					addCssExport(
@@ -1529,7 +1678,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 +1690,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 +1702,15 @@ 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 {
-							start: { line: sl, column: sc },
-							end: { line: el, column: ec }
-						} = cv.loc;
+						const value = A.unescaped(cv);
+						const { line: sl, column: sc } = locConverter.get(A.start(cv));
+						const { line: el, column: ec } = locConverter.get(A.end(cv));
 						addCssExport(
 							sl,
 							sc,
@@ -1570,7 +1718,7 @@ class CssParser extends Parser {
 							ec,
 							value,
 							value,
-							[cv.start, cv.end],
+							[A.start(cv), A.end(cv)],
 							true,
 							CssIcssExportDependency.EXPORT_MODE.ONCE
 						);
@@ -1580,19 +1728,17 @@ 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)
 						) {
 							continue;
 						}
-						const {
-							start: { line: sl, column: sc },
-							end: { line: el, column: ec }
-						} = cv.loc;
+						const { line: sl, column: sc } = locConverter.get(A.start(cv));
+						const { line: el, column: ec } = locConverter.get(A.end(cv));
 						addCssExport(
 							sl,
 							sc,
@@ -1600,7 +1746,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,11 +1757,14 @@ 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 type =
-						fname === "local" ? 1 : fname === "global" ? 2 : undefined;
+					const fname = A.unescapedName(fn);
+					const type = equalsLowerCase(fname, "local")
+						? 1
+						: equalsLowerCase(fname, "global")
+							? 2
+							: undefined;
 					if (!found && type) {
 						found = true;
 						if (type === 1) pure.markLocal();
@@ -1625,13 +1774,13 @@ class CssParser extends Parser {
 					if (
 						this.options.dashedIdents &&
 						isLocalMode() &&
-						(fname === "var" || fname === "style")
+						(equalsLowerCase(fname, "var") || equalsLowerCase(fname, "style"))
 					) {
 						processDashedIdentInVarFunction(fn);
 					}
 				}
 			}
-			return atRule.end;
+			return A.end(atRule);
 		};
 		/**
 		 * Emit the ICSS export declaring this module exports the given custom property.
@@ -1724,56 +1873,67 @@ 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 ||
+				!rangeEqualsLowerCase(input, A.start(fv[j]), A.end(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];
+			const src = fv[j];
 			if (
-				source.type === NodeType.Ident &&
-				/** @type {Token} */ (source).value === "global"
+				A.type(src) === NodeType.Ident &&
+				rangeEquals(input, A.start(src), A.end(src), "global")
 			) {
-				emitDashedIdentFromGlobal(identEnd, source.end);
+				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 +1945,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 +1991,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 +2013,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 +2037,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 +2058,7 @@ class CssParser extends Parser {
 				}
 			}
 			module.addPresentationalDependency(
-				new ConstDependency("", [trailStart, fn.end])
+				new ConstDependency("", [trailStart, fnEnd])
 			);
 		};
 
@@ -1904,37 +2068,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 +2103,7 @@ class CssParser extends Parser {
 			ai++;
 			while (
 				ai < attrParts.length &&
-				attrParts[ai].type === NodeType.Whitespace
+				A.type(attrParts[ai]) === NodeType.Whitespace
 			) {
 				ai++;
 			}
@@ -1953,12 +2113,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 +2158,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 +2173,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 +2190,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 +2203,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 +2223,17 @@ 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 {
-							start: { line: idSl, column: idSc },
-							end: { line: idEl, column: idEc }
-						} = v.loc;
+						const idValueStart = A.start(v) + 1;
+						const idName = A.unescaped(v);
+						const { line: idSl, column: idSc } = locConverter.get(A.start(v));
+						const { line: idEl, column: idEc } = locConverter.get(A.end(v));
 						addCssExport(
 							idSl,
 							idSc,
@@ -2085,7 +2241,7 @@ class CssParser extends Parser {
 							idEc,
 							idName,
 							getReexport(idName),
-							[idValueStart, v.end],
+							[idValueStart, A.end(v)],
 							true,
 							CssIcssExportDependency.EXPORT_MODE.ONCE
 						);
@@ -2094,17 +2250,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 +2269,13 @@ 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 {
-								start: { line: sl, column: sc },
-								end: { line: el, column: ec }
-							} = next.loc;
+							const name = A.unescaped(next);
+							// Cursor reads instead of `A.loc` — this is the hottest export site.
+							const { line: sl, column: sc } = locConverter.get(A.start(next));
+							const { line: el, column: ec } = locConverter.get(A.end(next));
 							addCssExport(
 								sl,
 								sc,
@@ -2127,18 +2283,18 @@ class CssParser extends Parser {
 								ec,
 								name,
 								getReexport(name),
-								[next.start, next.end],
+								[A.start(next), A.end(next)],
 								true,
 								CssIcssExportDependency.EXPORT_MODE.ONCE
 							);
 							currentRule.hasLocalAnchor = true;
 							currentRule.localIdentifiers.push(name);
 							pure.markLocal();
-						} else {
+						} else if (icssDefinitions.size !== 0) {
 							// `.<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.
@@ -2146,10 +2302,11 @@ class CssParser extends Parser {
 						break;
 					}
 					case NodeType.Ident: {
-						// ICSS rewrite for a bare `@value`-defined ident used as a type-style selector.
-						const ident = /** @type {Token} */ (v).value;
+						// ICSS rewrite for a bare `@value`-defined ident used as a type-style selector; only worth the slice when definitions exist.
+						if (icssDefinitions.size === 0) break;
+						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 +2329,9 @@ 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
-				);
-				return !equalsLowerCase(at.name, "import") || Boolean(at.urlRecovery);
+			if (A.type(currentStructural) === NodeType.AtRule) {
+				// `currentAtRuleName` is cached on at-rule enter — no per-value slice.
+				return currentAtRuleName !== "@import" || currentUrlRecovery;
 			}
 			return true;
 		};
@@ -2204,10 +2359,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 +2375,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 +2394,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 +2539,8 @@ class CssParser extends Parser {
 						'", "'
 					)}"`,
 					locConverter,
-					decl.start,
-					decl.end
+					A.start(decl),
+					A.end(decl)
 				);
 				return;
 			}
@@ -2395,8 +2551,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 +2575,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 +2604,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 +2615,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 +2656,8 @@ class CssParser extends Parser {
 						state,
 						errorMessage,
 						locConverter,
-						errorToken.start,
-						errorToken.end
+						A.start(errorToken),
+						A.end(errorToken)
 					);
 					return;
 				}
@@ -2512,81 +2668,87 @@ 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])
 			);
 		};
 
 		/**
 		 * Emit url() deps for a `url(...)` / `src(...)` / `image-set(...)` value function.
 		 * @param {FunctionNode} fn the function node
-		 * @param {string} fname the function name, lower-cased
+		 * @param {string} fname the unescaped function name (any case)
 		 */
 		const emitUrlFunction = (fn, fname) => {
-			if (fname === "url" || fname === "src") {
+			if (equalsLowerCase(fname, "url") || equalsLowerCase(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 +2767,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 +2792,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 +2837,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 +2869,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 +2892,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 +2906,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 +2964,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 +3127,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,8 +3140,9 @@ class CssParser extends Parser {
 								afterExclamation = false;
 								break;
 							}
-							const identifier = /** @type {Token} */ (cv).value;
-							const keyword = identifier.toLowerCase();
+							const identifier = A.value(cv);
+							// Values are almost always lowercase already — avoid the copy.
+							const keyword = toLowerCaseIfNeeded(identifier);
 							parsedKeywords[keyword] =
 								typeof parsedKeywords[keyword] !== "undefined"
 									? parsedKeywords[keyword] + 1
@@ -2981,7 +3153,7 @@ class CssParser extends Parser {
 							) {
 								break;
 							}
-							emit(cv.start, cv.end);
+							emit(A.start(cv), A.end(cv));
 							break;
 						}
 						case NodeType.String: {
@@ -2989,17 +3161,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 +3179,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 +3219,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;
@@ -3078,12 +3249,15 @@ class CssParser extends Parser {
 		// Drive the walk through SourceProcessor: structural enter / exit map to the `walkAst…Enter` / `…Exit` halves; value visitors handle url / ICSS / local-global.
 		/** @type {VisitorMap} */
 		const visitors = {
+			[NodeType.Comment]: commentVisitor,
 			[NodeType.AtRule]: {
 				// At-rule enter: scope save, name dispatch, prelude value context, pure-block push.
-				enter: (node, parent) => {
+				enter: (path) => {
+					const node = path.node;
 					const at = /** @type {AtRule} */ (node);
-					const topLevel = parent === null;
-					advanceCommentCursor(at.start);
+					const topLevel = path.parent === null;
+					currentUrlRecovery = false;
+					advanceCommentCursor(A.start(at));
 					const savedAnchor = currentRule.hasLocalAnchor;
 					const savedLocalIdentifiers = currentRule.localIdentifiers;
 					// Only modules-mode walks mutate `localIdentifiers`; otherwise share
@@ -3091,33 +3265,32 @@ class CssParser extends Parser {
 					currentRule.localIdentifiers = isModules
 						? [...savedLocalIdentifiers]
 						: savedLocalIdentifiers;
-					const name = `@${at.name.toLowerCase()}`;
+					const name = `@${toLowerCaseIfNeeded(A.name(at))}`;
 					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 +3331,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 +3348,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 +3387,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,11 +3410,12 @@ 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.
-				exit: (node, parent) => {
+				exit: (path) => {
+					const node = path.node;
 					const state = atRuleStateStack.pop();
 					if (!state) return;
 					if (state.hasBlock) {
@@ -3258,33 +3430,36 @@ class CssParser extends Parser {
 					}
 					currentRule.hasLocalAnchor = state.savedAnchor;
 					currentRule.localIdentifiers = state.savedLocalIdentifiers;
-					if (parent === null) finishTopLevelRule(node, true);
+					if (path.parent === null) finishTopLevelRule(node, true);
 				}
 			},
 			[NodeType.QualifiedRule]: {
-				// Qualified-rule enter: scope setup, selector + prelude context, pure-block push; `:import` / `:export` bail via `ctx.skipChildren()`.
-				enter: (node, parent, ctx) => {
+				// Qualified-rule enter: scope setup, selector + prelude context, pure-block push; `:import` / `:export` bail via `path.skipChildren()`.
+				enter: (path) => {
+					const node = path.node;
 					const rule = /** @type {QualifiedRule} */ (node);
-					const topLevel = parent === null;
-					advanceCommentCursor(rule.start);
+					const topLevel = path.parent === null;
+					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,14 +3468,16 @@ 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();
+								path.skipChildren();
 								qualifiedRuleStateStack.push({ bailed: true });
 								return;
 							}
@@ -3327,9 +3504,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 +3517,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,18 +3540,20 @@ 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.
-				exit: (node, parent) => {
+				exit: (path) => {
+					const node = path.node;
 					const state = qualifiedRuleStateStack.pop();
 					if (!state || state.bailed) return;
 					pure.exitBlock();
@@ -3381,23 +3561,19 @@ class CssParser extends Parser {
 					currentRule.localIdentifiers = state.savedLocalIdentifiers;
 					currentRule.composesPrevFile = state.savedPrevComposesFile;
 					currentRule.composesFiles = state.savedComposesFiles;
-					if (parent === null) finishTopLevelRule(node, false);
+					if (path.parent === null) finishTopLevelRule(node, false);
 				}
 			},
 			// Top-level declarations are parse errors (dropped by `parseAStylesheet`), so a declaration's parent is always a block.
-			[NodeType.Declaration]: (node) => {
+			[NodeType.Declaration]: (path) => {
+				const node = path.node;
 				const decl = /** @type {Declaration} */ (node);
 				// Reset value-visitor context, read by the value visitors below.
 				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,49 +3581,92 @@ 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 nameStart = A.nameStart(decl);
+				const nameEnd = A.nameEnd(decl);
+				// Range-based name analysis — the common declaration never
+				// slices its name out of the source.
+				/** @type {string | undefined} */
+				let declName;
+				/** @type {string | undefined} */
+				let declPropertyName;
+				if (source.charCodeAt(nameStart) === CC_HYPHEN_MINUS) {
+					// Vendor-prefixed or custom property — rare, take the string path.
+					declName = A.name(decl);
+					declPropertyName = toLowerCaseIfNeeded(
+						declName.replace(VENDOR_PREFIX, "")
+					);
+					currentDeclIsKnownProperty = knownProperties.has(declPropertyName);
+				} else {
+					declPropertyName = knownPropertyForRange(
+						knownPropertyIndex,
+						source,
+						nameStart,
+						nameEnd
+					);
+					// Cache the known-property flag so the per-token value visitors don't recompute it.
+					currentDeclIsKnownProperty = declPropertyName !== undefined;
+				}
 				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 =
 					currentRule.hasLocalAnchor &&
-					COMPOSES_PROPERTY.test(declPropertyName);
+					(declPropertyName !== undefined
+						? COMPOSES_PROPERTY.test(declPropertyName)
+						: rangeEqualsLowerCase(source, nameStart, nameEnd, "composes") ||
+							rangeEqualsLowerCase(source, nameStart, nameEnd, "compose-with"));
 				if (currentDeclComposesSkip) emitComposesWithAnchor(decl);
 				const skipForComposes = currentDeclComposesSkip;
 				// Known-property value localization (`animation-name: foo` exports `foo`).
-				if (isModules && effectiveLocalMode && currentDeclIsKnownProperty) {
-					emitKnownPropertyExports(decl, declPropertyName);
+				if (effectiveLocalMode && currentDeclIsKnownProperty) {
+					emitKnownPropertyExports(
+						decl,
+						/** @type {string} */ (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);
+					// Only the `-`-prefixed path can carry a dashed ident.
+					if (declName !== undefined && isDashedIdentifier(declName)) {
+						emitDashedIdentExport(nameStart, nameEnd);
 					}
 					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).
+				// ICSS-symbol rewrite (`color: foo` when `foo` is `@value`-defined), skipping known properties, the composes anchor, and dashed idents (handled above). Nothing to rewrite without definitions — don't slice the name.
 				if (
-					isModules &&
 					!skipForComposes &&
 					!currentDeclIsKnownProperty &&
-					!(dashed.active && isDashedIdentifier(decl.name)) &&
-					icssDefinitions.has(decl.name)
+					icssDefinitions.size !== 0
 				) {
-					emitICSSSymbol(decl.name, decl.nameStart, decl.nameEnd);
+					if (declName === undefined) {
+						declName = source.slice(nameStart, nameEnd);
+					}
+					if (
+						!(dashed.active && isDashedIdentifier(declName)) &&
+						icssDefinitions.has(declName)
+					) {
+						emitICSSSymbol(declName, nameStart, nameEnd);
+					}
 				}
 			},
 			// Value-level visitors decide handling from the enclosing node via `urlActive()` / `localGlobalActive()` / `icssActive()`.
-			[NodeType.Url]: (node) => {
+			[NodeType.Url]: (path) => {
+				const node = path.node;
 				const url = /** @type {UrlToken} */ (node);
 				if (!urlActive()) return;
 				// 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 +3675,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,55 +3704,64 @@ 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;
+			[NodeType.Comma](path) {
+				const node = path.node;
+				if (urlActive()) lastTokenEndForComments = A.start(node);
 			},
 			[NodeType.Function]: {
-				enter: (node) => {
+				enter: (path) => {
+					const node = path.node;
 					const fn = /** @type {FunctionNode} */ (node);
-					const fnameRaw = fn.unescapedName;
-					const fname = fnameRaw.toLowerCase();
-					if (urlActive()) emitUrlFunction(fn, fname);
-					if (
-						localGlobalActive() &&
-						(fname === "local" || fname === "global")
-					) {
-						processLocalOrGlobalFunction(fn, fname === "local" ? 1 : 2);
+					const fnameRaw = A.unescapedName(fn);
+					// `equalsLowerCase` keeps this visitor free of a per-function
+					// lowercased copy — functions are the densest value nodes.
+					const isLocalFn = equalsLowerCase(fnameRaw, "local");
+					const isGlobalFn = !isLocalFn && equalsLowerCase(fnameRaw, "global");
+					if (urlActive()) emitUrlFunction(fn, fnameRaw);
+					if (localGlobalActive() && (isLocalFn || isGlobalFn)) {
+						processLocalOrGlobalFunction(fn, isLocalFn ? 1 : 2);
 					}
 					if (
 						icssActive() &&
-						fname !== "local" &&
-						fname !== "global" &&
+						!isLocalFn &&
+						!isGlobalFn &&
 						!(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();
 					if (dashed.active) {
-						if (fname === "local" || fname === "global") {
+						if (isLocalFn || isGlobalFn) {
 							// `local()` / `global()` dashed args go through the ICSS path above, not here.
 							dashed.active = false;
-						} else if (fname === "var" || fname === "style") {
+						} else if (
+							equalsLowerCase(fnameRaw, "var") ||
+							equalsLowerCase(fnameRaw, "style")
+						) {
 							// `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));
 						}
 					}
 				},
@@ -3541,61 +3769,83 @@ class CssParser extends Parser {
 					dashed.pop();
 				}
 			},
-			[NodeType.Ident](node, parent) {
-				const identValue = /** @type {Token} */ (node).value;
-				if (dashed.active && isDashedIdentifier(identValue)) {
+			[NodeType.Ident](path) {
+				const node = path.node;
+				// 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. With no `@value`/`:import` definitions the ICSS
+				// probe can never hit, so it doesn't warrant the slice either.
+				const dashedActive = dashed.active;
+				const icss = icssActive() && icssDefinitions.size !== 0;
+				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.
-					const siblings = childrenOf(parent);
+					const siblings = childrenOf(path.parent);
 					const i = siblings ? siblings.indexOf(node) : -1;
 					if (siblings && i !== -1) {
 						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 &&
+							rangeEqualsLowerCase(
+								input,
+								A.start(siblings[j]),
+								A.end(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 &&
+								rangeEquals(
+									input,
+									A.start(sourceNode),
+									A.end(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));
 				}
 			}
 		};
 		// `as` selects the top-level production (§5.3): a `style` attribute is a
-		// block's contents, everything else a full stylesheet (the default).
-		new SourceProcessor()
+		// block's contents, everything else a full stylesheet (the default). `as`
+		// and `skip` are per-parse config on the processor; only `locConverter`
+		// (per-source) is passed to `process`. One skip set: selector prelude +
+		// unread value leaves (non-modules only; CSS Modules needs its selectors
+		// and ICSS-captured values).
+		new SourceProcessor({
+			as: /** @type {"stylesheet" | "block-contents"} */ (this.options.as),
+			skip: isModules ? undefined : SKIP_NON_MODULES
+		})
 			.use(/** @type {VisitorMap} */ (visitors))
-			.process(source, {
-				locConverter,
-				comment,
-				as: /** @type {"stylesheet" | "block-contents"} */ (this.options.as)
-			});
+			.process(source, { locConverter });
 
 		/** @type {BuildInfo} */
 		(module.buildInfo).strict = true;