webpack 5.108.3 → 5.108.4

package/lib/css/CssParser.js

@@ -32,6 +32,7 @@ const {
 	A,
 	NodeType,
 	SourceProcessor,
+	buildSkipSet,
 	equalsLowerCase,
 	unescapeIdentifier
 } = require("./syntax");
@@ -93,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;
@@ -184,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.
@@ -598,7 +726,7 @@ const scanRuleBody = (declarations, childRules) => {
 				hasNestedBlock = true;
 				if (
 					!hasDirectDecl &&
-					!isPureBodyAtRule(`@${A.name(child).toLowerCase()}`) &&
+					!isPureBodyAtRule(`@${toLowerCaseIfNeeded(A.name(child))}`) &&
 					scanRuleBody(atDecls, atChildRules).hasDirectDecl
 				) {
 					hasDirectDecl = true;
@@ -916,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,
@@ -923,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
 			});
 		};
 
@@ -940,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);
@@ -969,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;
@@ -1242,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;
 		};
 
 		/**
@@ -1516,10 +1666,9 @@ class CssParser extends Parser {
 				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 }
-					} = A.loc(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(
@@ -1560,10 +1709,8 @@ class CssParser extends Parser {
 				if (cvType === NodeType.String) {
 					if (!found && options.string) {
 						const value = A.unescaped(cv);
-						const {
-							start: { line: sl, column: sc },
-							end: { line: el, column: ec }
-						} = A.loc(cv);
+						const { line: sl, column: sc } = locConverter.get(A.start(cv));
+						const { line: el, column: ec } = locConverter.get(A.end(cv));
 						addCssExport(
 							sl,
 							sc,
@@ -1590,10 +1737,8 @@ class CssParser extends Parser {
 						) {
 							continue;
 						}
-						const {
-							start: { line: sl, column: sc },
-							end: { line: el, column: ec }
-						} = A.loc(cv);
+						const { line: sl, column: sc } = locConverter.get(A.start(cv));
+						const { line: el, column: ec } = locConverter.get(A.end(cv));
 						addCssExport(
 							sl,
 							sc,
@@ -1614,9 +1759,12 @@ class CssParser extends Parser {
 
 				if (cvType === NodeType.Function) {
 					const fn = /** @type {FunctionNode} */ (cv);
-					const fname = A.unescapedName(fn).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();
@@ -1626,7 +1774,7 @@ class CssParser extends Parser {
 					if (
 						this.options.dashedIdents &&
 						isLocalMode() &&
-						(fname === "var" || fname === "style")
+						(equalsLowerCase(fname, "var") || equalsLowerCase(fname, "style"))
 					) {
 						processDashedIdentInVarFunction(fn);
 					}
@@ -1758,7 +1906,7 @@ class CssParser extends Parser {
 			if (
 				j >= fv.length ||
 				A.type(fv[j]) !== NodeType.Ident ||
-				!equalsLowerCase(A.value(fv[j]), "from")
+				!rangeEqualsLowerCase(input, A.start(fv[j]), A.end(fv[j]), "from")
 			) {
 				emitDashedIdentExport(identStart, identEnd);
 				return;
@@ -1772,7 +1920,10 @@ class CssParser extends Parser {
 			if (j >= fv.length) return;
 
 			const src = fv[j];
-			if (A.type(src) === NodeType.Ident && A.value(src) === "global") {
+			if (
+				A.type(src) === NodeType.Ident &&
+				rangeEquals(input, A.start(src), A.end(src), "global")
+			) {
 				emitDashedIdentFromGlobal(identEnd, A.end(src));
 				return;
 			}
@@ -2081,10 +2232,8 @@ class CssParser extends Parser {
 						// ID selectors emit the ICSS export but aren't a `composes:` anchor.
 						const idValueStart = A.start(v) + 1;
 						const idName = A.unescaped(v);
-						const {
-							start: { line: idSl, column: idSc },
-							end: { line: idEl, column: idEc }
-						} = A.loc(v);
+						const { line: idSl, column: idSc } = locConverter.get(A.start(v));
+						const { line: idEl, column: idEc } = locConverter.get(A.end(v));
 						addCssExport(
 							idSl,
 							idSc,
@@ -2124,10 +2273,9 @@ class CssParser extends Parser {
 						if (segmentMode === "local") {
 							// `.<ident>` in local mode is a class selector (dep covers the ident bytes only).
 							const name = A.unescaped(next);
-							const {
-								start: { line: sl, column: sc },
-								end: { line: el, column: ec }
-							} = A.loc(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,
@@ -2142,7 +2290,7 @@ class CssParser extends Parser {
 							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 = A.value(next);
 							if (!isDashedIdentifier(ident) && icssDefinitions.has(ident)) {
@@ -2154,7 +2302,8 @@ class CssParser extends Parser {
 						break;
 					}
 					case NodeType.Ident: {
-						// ICSS rewrite for a bare `@value`-defined ident used as a type-style selector.
+						// 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, A.start(v), A.end(v));
@@ -2181,10 +2330,8 @@ class CssParser extends Parser {
 		const urlActive = () => {
 			if (!this.options.url || !currentStructural) return false;
 			if (A.type(currentStructural) === NodeType.AtRule) {
-				return (
-					!equalsLowerCase(A.name(currentStructural), "import") ||
-					currentUrlRecovery
-				);
+				// `currentAtRuleName` is cached on at-rule enter — no per-value slice.
+				return currentAtRuleName !== "@import" || currentUrlRecovery;
 			}
 			return true;
 		};
@@ -2534,10 +2681,10 @@ class CssParser extends Parser {
 		/**
 		 * 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 = A.children(fn)[nextNonWhitespace(A.children(fn), 0)];
 				if (!first || A.type(first) !== NodeType.String) return;
@@ -2994,7 +3141,8 @@ class CssParser extends Parser {
 								break;
 							}
 							const identifier = A.value(cv);
-							const keyword = identifier.toLowerCase();
+							// Values are almost always lowercase already — avoid the copy.
+							const keyword = toLowerCaseIfNeeded(identifier);
 							parsedKeywords[keyword] =
 								typeof parsedKeywords[keyword] !== "undefined"
 									? parsedKeywords[keyword] + 1
@@ -3101,11 +3249,13 @@ 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;
+					const topLevel = path.parent === null;
 					currentUrlRecovery = false;
 					advanceCommentCursor(A.start(at));
 					const savedAnchor = currentRule.hasLocalAnchor;
@@ -3115,7 +3265,7 @@ class CssParser extends Parser {
 					currentRule.localIdentifiers = isModules
 						? [...savedLocalIdentifiers]
 						: savedLocalIdentifiers;
-					const name = `@${A.name(at).toLowerCase()}`;
+					const name = `@${toLowerCaseIfNeeded(A.name(at))}`;
 					switch (name) {
 						case "@namespace": {
 							this._emitWarning(
@@ -3264,7 +3414,8 @@ class CssParser extends Parser {
 					});
 				},
 				// 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) {
@@ -3279,14 +3430,15 @@ 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;
+					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) {
@@ -3325,7 +3477,7 @@ class CssParser extends Parser {
 									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;
 							}
@@ -3400,7 +3552,8 @@ class CssParser extends Parser {
 					});
 				},
 				// 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();
@@ -3408,11 +3561,12 @@ 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;
@@ -3432,20 +3586,47 @@ class CssParser extends Parser {
 				// 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 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 (effectiveLocalMode && currentDeclIsKnownProperty) {
-					emitKnownPropertyExports(decl, declPropertyName);
+					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 (
@@ -3453,24 +3634,33 @@ class CssParser extends Parser {
 					effectiveLocalMode &&
 					!skipForComposes
 				) {
-					if (isDashedIdentifier(declName)) {
-						emitDashedIdentExport(A.nameStart(decl), A.nameEnd(decl));
+					// 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 (
 					!skipForComposes &&
 					!currentDeclIsKnownProperty &&
-					!(dashed.active && isDashedIdentifier(declName)) &&
-					icssDefinitions.has(declName)
+					icssDefinitions.size !== 0
 				) {
-					emitICSSSymbol(declName, A.nameStart(decl), A.nameEnd(decl));
+					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.
@@ -3530,25 +3720,27 @@ class CssParser extends Parser {
 				module.addDependency(dep);
 				module.addCodeGenerationDependency(dep);
 			},
-			[NodeType.Comma](node) {
+			[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 = A.unescapedName(fn);
-					const fname = fnameRaw.toLowerCase();
-					if (urlActive()) emitUrlFunction(fn, fname);
-					if (
-						localGlobalActive() &&
-						(fname === "local" || fname === "global")
-					) {
-						processLocalOrGlobalFunction(fn, fname === "local" ? 1 : 2);
+					// `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)
 					) {
@@ -3557,10 +3749,13 @@ class CssParser extends Parser {
 					// 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;
@@ -3574,34 +3769,46 @@ class CssParser extends Parser {
 					dashed.pop();
 				}
 			},
-			[NodeType.Ident](node, parent) {
+			[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.
+				// `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();
+				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 &&
 							A.type(siblings[j]) === NodeType.Ident &&
-							equalsLowerCase(A.value(siblings[j]), "from")
+							rangeEqualsLowerCase(
+								input,
+								A.start(siblings[j]),
+								A.end(siblings[j]),
+								"from"
+							)
 						) {
 							const fromIdent = siblings[j];
 							const sourceNode = siblings[nextNonWhitespace(siblings, j + 1)];
 							if (
 								sourceNode &&
 								A.type(sourceNode) === NodeType.Ident &&
-								A.value(sourceNode) === "global"
+								rangeEquals(
+									input,
+									A.start(sourceNode),
+									A.end(sourceNode),
+									"global"
+								)
 							) {
 								emitDashedIdentFromGlobal(A.end(node), A.end(sourceNode));
 								return;
@@ -3628,14 +3835,17 @@ class CssParser extends Parser {
 			}
 		};
 		// `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;