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

package/lib/css/CssModulesPlugin.js

@@ -95,14 +95,6 @@ const CssParser = require("./CssParser");
  * @property {Source} moduleSourceContent content
  */
 
-/**
- * Defines the compilation hooks type used by this module.
- * @typedef {object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
- * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
- * @property {SyncBailHook<[Chunk, Module[], Compilation], Module[] | undefined | void>} orderModules called for each CSS source type (CSS_IMPORT_TYPE, CSS_TYPE) with the chunk's modules pre-sorted by full module name; return an ordered `Module[]` to override the default import-order topological sort, or return `undefined` to keep the default
- */
-
 /**
  * Defines the module factory cache entry type used by this module.
  * @typedef {object} ModuleFactoryCacheEntry
@@ -220,6 +212,34 @@ const generatorValidationOptions = {
 
 const PLUGIN_NAME = "CssModulesPlugin";
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>}
+	 * @since 5.94.0
+	 */
+	renderModulePackage: new SyncWaterfallHook([
+		"source",
+		"module",
+		"renderContext"
+	]),
+	/**
+	 * @type {SyncHook<[Chunk, Hash, ChunkHashContext]>}
+	 * @since 5.94.0
+	 */
+	chunkHash: new SyncHook(["chunk", "hash", "context"]),
+	/**
+	 * Called for each CSS source type (CSS_IMPORT_TYPE, CSS_TYPE) with the chunk's modules pre-sorted by full module name; return an ordered `Module[]` to override the default import-order topological sort, or return `undefined` to keep the default.
+	 * @type {SyncBailHook<[Chunk, Module[], Compilation], Module[] | undefined | void>}
+	 * @since 5.107.0
+	 */
+	orderModules: new SyncBailHook(["chunk", "modules", "compilation"])
+});
+
+/**
+ * Defines the compilation hooks type used by this module.
+ * @typedef {ReturnType<typeof createCompilationHooks>} CompilationHooks
+ */
+
 class CssModulesPlugin {
 	constructor() {
 		/** @type {WeakMap<Source, ModuleFactoryCacheEntry>} */
@@ -1175,16 +1195,7 @@ class CssModulesPlugin {
 }
 
 CssModulesPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CompilationHooks} */ ({
-			renderModulePackage: new SyncWaterfallHook([
-				"source",
-				"module",
-				"renderContext"
-			]),
-			chunkHash: new SyncHook(["chunk", "hash", "context"]),
-			orderModules: new SyncBailHook(["chunk", "modules", "compilation"])
-		})
+	createCompilationHooks
 );
 
 module.exports = CssModulesPlugin;

package/lib/css/CssParser.js

@@ -82,6 +82,7 @@ const CC_FORM_FEED = "\f".charCodeAt(0);
 const CC_LEFT_CURLY = "{".charCodeAt(0);
 const CC_LOWER_V = "v".charCodeAt(0);
 const CC_UPPER_V = "V".charCodeAt(0);
+const CC_REVERSE_SOLIDUS = "\\".charCodeAt(0);
 
 // A parsed CSS comment. `loc` is computed on demand — only magic-comment error
 // warnings read it, so comment-heavy CSS skips the per-comment line/col work.
@@ -595,6 +596,20 @@ const isContainerKeyword = (input, start, end) => {
 	}
 };
 
+/**
+ * Whether the byte range contains a CSS escape (`\`) — function names are short, so this scan replaces a per-name slice.
+ * @param {string} input source
+ * @param {number} start start offset
+ * @param {number} end end offset (exclusive)
+ * @returns {boolean} true when the range contains a backslash
+ */
+const rangeHasEscape = (input, start, end) => {
+	for (let i = start; i < end; i++) {
+		if (input.charCodeAt(i) === CC_REVERSE_SOLIDUS) return true;
+	}
+	return false;
+};
+
 /**
  * @param {string} input source
  * @param {number} pos position
@@ -1848,26 +1863,6 @@ class CssParser extends Parser {
 			}
 		};
 
-		/**
-		 * The child list of an AST node (a function/block `value` or a rule `prelude`) for sibling lookahead.
-		 * @param {AstNode | null} parent parent node
-		 * @returns {AstNode[] | undefined} the child list, or undefined
-		 */
-		const childrenOf = (parent) => {
-			if (!parent) return undefined;
-			switch (A.type(parent)) {
-				case NodeType.Function:
-				case NodeType.SimpleBlock:
-				case NodeType.Declaration:
-					return A.children(parent);
-				case NodeType.AtRule:
-				case NodeType.QualifiedRule:
-					return A.prelude(parent);
-				default:
-					return undefined;
-			}
-		};
-
 		// `allowImport` mirrors `allowImportAtRule`: true until the first top-level block-bearing rule.
 		let allowImport = true;
 		// Persistent CSS-Modules mode for a top-level rule: set by bare `:local` / `:global`, leaks into sibling rules, reset at each top-level `}`.
@@ -2639,10 +2634,39 @@ 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 unescaped function name (any case)
+		 * @param {string | undefined} escapedName the unescaped function name when it carries an escape, undefined for the raw byte-range path
 		 */
-		const emitUrlFunction = (fn, fname) => {
-			if (equalsLowerCase(fname, "url") || equalsLowerCase(fname, "src")) {
+		const emitUrlFunction = (fn, escapedName) => {
+			const fnNameStart = A.nameStart(fn);
+			const fnNameEnd = A.nameEnd(fn);
+			let isUrlOrSrc;
+			let isImageSet = false;
+			if (escapedName !== undefined) {
+				isUrlOrSrc =
+					equalsLowerCase(escapedName, "url") ||
+					equalsLowerCase(escapedName, "src");
+				if (!isUrlOrSrc) isImageSet = IMAGE_SET_FUNCTION.test(escapedName);
+			} else {
+				const nameLength = fnNameEnd - fnNameStart;
+				isUrlOrSrc =
+					nameLength === 3 &&
+					(rangeEqualsLowerCase(input, fnNameStart, fnNameEnd, "url") ||
+						rangeEqualsLowerCase(input, fnNameStart, fnNameEnd, "src"));
+				if (!isUrlOrSrc) {
+					// Suffix probe first, so only a vendor-prefixed `…-image-set` pays the slice + regex.
+					isImageSet =
+						nameLength >= 9 &&
+						rangeEqualsLowerCase(
+							input,
+							fnNameEnd - 9,
+							fnNameEnd,
+							"image-set"
+						) &&
+						(nameLength === 9 ||
+							IMAGE_SET_FUNCTION.test(input.slice(fnNameStart, fnNameEnd)));
+				}
+			}
+			if (isUrlOrSrc) {
 				// 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;
@@ -2673,9 +2697,9 @@ class CssParser extends Parser {
 				);
 				module.addDependency(dep);
 				module.addCodeGenerationDependency(dep);
-			} else if (IMAGE_SET_FUNCTION.test(fname)) {
+			} else if (isImageSet) {
 				// `image-set(…)`: each comma segment's first string is the URL; advance the magic-comment fence per string.
-				lastTokenEndForComments = A.nameEnd(fn) + 1;
+				lastTokenEndForComments = fnNameEnd + 1;
 				let prevStringEnd = A.start(fn);
 				let firstInSegment = true;
 				for (const cv of A.children(fn)) {
@@ -4052,12 +4076,34 @@ class CssParser extends Parser {
 				enter: (path) => {
 					const node = path.node;
 					const fn = /** @type {FunctionNode} */ (node);
-					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);
+					const fnNameStart = A.nameStart(fn);
+					const fnNameEnd = A.nameEnd(fn);
+					const fnNameLength = fnNameEnd - fnNameStart;
+					// Functions are the densest value nodes, so the name is matched by raw byte range; only a name carrying an escape (rare) pays the unescaped slice.
+					/** @type {string | undefined} */
+					let escapedName;
+					let isLocalFn = false;
+					let isGlobalFn = false;
+					if (rangeHasEscape(input, fnNameStart, fnNameEnd)) {
+						escapedName = A.unescapedName(fn);
+						isLocalFn = equalsLowerCase(escapedName, "local");
+						isGlobalFn = !isLocalFn && equalsLowerCase(escapedName, "global");
+					} else if (fnNameLength === 5) {
+						isLocalFn = rangeEqualsLowerCase(
+							input,
+							fnNameStart,
+							fnNameEnd,
+							"local"
+						);
+					} else if (fnNameLength === 6) {
+						isGlobalFn = rangeEqualsLowerCase(
+							input,
+							fnNameStart,
+							fnNameEnd,
+							"global"
+						);
+					}
+					if (urlActive()) emitUrlFunction(fn, escapedName);
 					if (localGlobalActive() && (isLocalFn || isGlobalFn)) {
 						processLocalOrGlobalFunction(fn, isLocalFn ? 1 : 2);
 					}
@@ -4065,10 +4111,16 @@ class CssParser extends Parser {
 						icssActive() &&
 						!isLocalFn &&
 						!isGlobalFn &&
-						!(dashed.active && isDashedIdentifier(fnameRaw)) &&
-						icssDefinitions.has(fnameRaw)
+						icssDefinitions.size !== 0
 					) {
-						emitICSSSymbol(fnameRaw, A.nameStart(fn), A.nameEnd(fn));
+						// Without an escape the raw name equals the unescaped one — only the `@value`-lookup path needs the string at all.
+						const fname = escapedName === undefined ? A.name(fn) : escapedName;
+						if (
+							!(dashed.active && isDashedIdentifier(fname)) &&
+							icssDefinitions.has(fname)
+						) {
+							emitICSSSymbol(fname, fnNameStart, fnNameEnd);
+						}
 					}
 					// Dashed-ident scoping: handle this function, then set the child nesting level's state for the walk.
 					dashed.push();
@@ -4077,15 +4129,35 @@ class CssParser extends Parser {
 							// `local()` / `global()` dashed args go through the ICSS path above, not here.
 							dashed.active = false;
 						} else if (
-							equalsLowerCase(fnameRaw, "var") ||
-							equalsLowerCase(fnameRaw, "style")
+							escapedName === undefined
+								? (fnNameLength === 3 &&
+										rangeEqualsLowerCase(
+											input,
+											fnNameStart,
+											fnNameEnd,
+											"var"
+										)) ||
+									(fnNameLength === 5 &&
+										rangeEqualsLowerCase(
+											input,
+											fnNameStart,
+											fnNameEnd,
+											"style"
+										))
+								: equalsLowerCase(escapedName, "var") ||
+									equalsLowerCase(escapedName, "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(A.name(fn))) {
-							// Custom-function call `--my-func(args)` — the name is the exported dashed-ident.
-							emitDashedIdentExport(A.nameStart(fn), A.nameEnd(fn));
+						} else if (
+							dashed.emit &&
+							fnNameLength >= 3 &&
+							input.charCodeAt(fnNameStart) === CC_HYPHEN_MINUS &&
+							input.charCodeAt(fnNameStart + 1) === CC_HYPHEN_MINUS
+						) {
+							// Custom-function call `--my-func(args)` — the name is the exported dashed-ident (a literal `--` prefix, like the `A.name` string check it replaces).
+							emitDashedIdentExport(fnNameStart, fnNameEnd);
 						}
 					}
 				},
@@ -4107,23 +4179,36 @@ class CssParser extends Parser {
 				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(path.parent);
-					const i = siblings ? siblings.indexOf(node) : -1;
-					if (siblings && i !== -1) {
-						const j = nextNonWhitespace(siblings, i + 1);
+					// Resolve the `--foo from "./x.css"` / `--foo from global` import suffix via sibling lookahead over the parent's child span (`path.index` avoids materializing the sibling list per dashed ident).
+					const parent = path.parent;
+					if (parent) {
+						const count = A.childCount(parent);
+						let j = path.index + 1;
+						while (
+							j < count &&
+							A.type(A.childAt(parent, j)) === NodeType.Whitespace
+						) {
+							j++;
+						}
+						const fromIdent = j < count ? A.childAt(parent, j) : undefined;
 						if (
-							j < siblings.length &&
-							A.type(siblings[j]) === NodeType.Ident &&
+							fromIdent &&
+							A.type(fromIdent) === NodeType.Ident &&
 							rangeEqualsLowerCase(
 								input,
-								A.start(siblings[j]),
-								A.end(siblings[j]),
+								A.start(fromIdent),
+								A.end(fromIdent),
 								"from"
 							)
 						) {
-							const fromIdent = siblings[j];
-							const sourceNode = siblings[nextNonWhitespace(siblings, j + 1)];
+							j++;
+							while (
+								j < count &&
+								A.type(A.childAt(parent, j)) === NodeType.Whitespace
+							) {
+								j++;
+							}
+							const sourceNode = j < count ? A.childAt(parent, j) : undefined;
 							if (
 								sourceNode &&
 								A.type(sourceNode) === NodeType.Ident &&