@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/css/CssParser.js

@@ -164,13 +164,14 @@ const fontMimeType = (request) => {
 	return getMimeTypes().lookup(resourcePath);
 };
 
-// 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.
+// WHY: skip options for a non-CSS-Modules parse. The selector prelude is never
+// walked without modules, and the value and function-arg leaves reach nothing —
+// the `Ident` visitor no-ops, the `Declaration` visitor returns early, and there
+// is no ICSS. `url`, functions, strings, blocks and commas are kept, carrying
+// the `url()` rewrites and image-set fences, and at-rule preludes too, since
+// `@media` and `@import` are read. A CSS-Modules parse skips nothing: selectors
+// are walked, and ICSS `:export { k: v }` captures each value's byte range from
+// its first and last node.
 const SKIP_NON_MODULES = {
 	types: buildSkipSet([
 		NodeType.Number,
@@ -207,6 +208,10 @@ const VALUE_AS_ALIAS = /\s+as\s+/;
 // `@value name value`: end of the name run (first non-space followed by space).
 const VALUE_NAME_BOUNDARY = /\S\s/;
 const ONLY_WHITESPACE = /^\s+$/;
+// A `@value` whose whole value is one `.class` / `#id`, the only shape whose
+// localizable ident is knowable without re-parsing the substitution.
+const SIMPLE_CLASS_OR_ID_VALUE =
+	/^([.#])(-?(?:[A-Za-z_]|[\u0080-\uFFFF])(?:[\w-]|[\u0080-\uFFFF])*)$/;
 // Relative request prefix (`./` or `../`) — `isSelfReferenceRequest` per `from`.
 const RELATIVE_REQUEST = /^\.{1,2}\//;
 
@@ -994,6 +999,19 @@ class CssParser extends Parser {
 			d.entries.push(cssExportEntries.length);
 		};
 
+		// Start offsets of the idents an at-rule's own prelude handler already
+		// replaced: two deps over one range concatenate rather than the later winning.
+		/** @type {Set<number>} */
+		const handledPreludeIdents = new Set();
+		// Only a prelude is walked by both a handler and the value visitors, so
+		// nothing outside one pays for the bookkeeping.
+		let trackingPreludeIdents = false;
+
+		// Start offsets of `@value`-named dashed idents a `var()` handler already
+		// scoped; only those are walked twice, so plain dashed idents cost nothing.
+		/** @type {Set<number>} */
+		const handledDashedValueIdents = new Set();
+
 		// All `:export`-style exports are collected into a single
 		// `CssIcssExportDependency` per module (emitted at parse end) instead of one
 		// `Dependency` per export — far fewer retained objects on CSS-heavy builds.
@@ -1024,6 +1042,7 @@ class CssParser extends Parser {
 			exportMode = CssIcssExportDependency.EXPORT_MODE.REPLACE,
 			exportType = CssIcssExportDependency.EXPORT_TYPE.NORMAL
 		) => {
+			if (trackingPreludeIdents && range) handledPreludeIdents.add(range[0]);
 			// Flat location numbers — the nested loc objects were the parser's
 			// hottest allocation (3 objects per exported name).
 			cssExportEntries.push({
@@ -1556,13 +1575,15 @@ class CssParser extends Parser {
 		};
 
 		/**
-		 * Emit a `CssIcssSymbolDependency` rewrite for an ident resolving to an `@value`-defined ICSS symbol (source-order semantics hold since the walker handles each `@value` before later references).
+		 * Emit a `CssIcssSymbolDependency` rewrite for an ident resolving to an `@value`-defined ICSS symbol (source-order semantics hold since the walker handles each `@value` before later references). A no-op for an ident an at-rule's own prelude handler already replaced.
 		 * @param {string} name ICSS symbol name
 		 * @param {number} start start position
 		 * @param {number} end end position
 		 * @returns {number} `end` of the rewritten ident range
 		 */
 		const emitICSSSymbol = (name, start, end) => {
+			if (handledPreludeIdents.has(start)) return end;
+			if (trackingPreludeIdents) handledPreludeIdents.add(start);
 			const def =
 				/** @type {IcssDefinition} */
 				(icssDefinitions.get(name));
@@ -1580,6 +1601,37 @@ class CssParser extends Parser {
 			return end;
 		};
 
+		/**
+		 * The `.class` / `#id` a locally defined `@value` stands for, when its whole value is exactly one of those. Undefined for an imported value or any richer selector, which stay a plain textual substitution.
+		 * @param {string} name `@value` name used where a selector is expected
+		 * @returns {["." | "#", string] | undefined} the selector's prefix and the ident to localize
+		 */
+		const localizableSelectorValue = (name) => {
+			const def = icssDefinitions.get(name);
+			if (!def || def.importName || typeof def.value !== "string") {
+				return undefined;
+			}
+			const match = SIMPLE_CLASS_OR_ID_VALUE.exec(def.value.trim());
+			return match
+				? [/** @type {"." | "#"} */ (match[1]), match[2]]
+				: undefined;
+		};
+
+		/**
+		 * The dashed ident a locally defined `@value` stands for, without its `--` prefix, when its whole value is exactly one. Undefined for an imported value or any richer value, which stay a plain textual substitution.
+		 * @param {string} name `@value` name used where a dashed ident is expected
+		 * @returns {string | undefined} the name to localize, sans `--`
+		 */
+		const localizableDashedValue = (name) => {
+			if (icssDefinitions.size === 0) return undefined;
+			const def = icssDefinitions.get(name);
+			if (!def || def.importName || typeof def.value !== "string") {
+				return undefined;
+			}
+			const value = def.value.trim();
+			return isDashedIdentifier(value) ? value.slice(2) : undefined;
+		};
+
 		/**
 		 * Process a `local(...)` / `global(...)` pseudo-function: strip the call (and a leading legacy `:`) via a presentational dep, then emit `local()`'s inner top-level idents as ICSS exports.
 		 * @param {FunctionNode} fn parsed local/global function node
@@ -1740,12 +1792,12 @@ class CssParser extends Parser {
 				: unescapeRange(identStart, identEnd).slice(2);
 
 		/**
-		 * Emit the ICSS export declaring this module exports the given custom property.
-		 * @param {number} identStart start of the `--<name>` ident
+		 * Emit the ICSS export declaring this module exports the given custom property, naming it explicitly rather than reading it back from the replaced range. A `@value` standing in for a dashed ident is scoped under the name it resolves to, not the name written at the use site.
+		 * @param {string} identifier custom property name, sans `--`
+		 * @param {number} identStart start of the replaced ident
 		 * @param {number} identEnd end of the ident (exclusive)
 		 */
-		const emitDashedIdentExport = (identStart, identEnd) => {
-			const identifier = dashedIdentName(identStart, identEnd);
+		const emitNamedDashedIdentExport = (identifier, identStart, identEnd) => {
 			const { line: sl, column: sc } = locConverter.get(identStart);
 			const { line: el, column: ec } = locConverter.get(identEnd);
 			recordDeclaration(identifier, "custom property", sl, sc);
@@ -1763,6 +1815,19 @@ class CssParser extends Parser {
 			);
 		};
 
+		/**
+		 * Emit the ICSS export declaring this module exports the given custom property.
+		 * @param {number} identStart start of the `--<name>` ident
+		 * @param {number} identEnd end of the ident (exclusive)
+		 */
+		const emitDashedIdentExport = (identStart, identEnd) => {
+			emitNamedDashedIdentExport(
+				dashedIdentName(identStart, identEnd),
+				identStart,
+				identEnd
+			);
+		};
+
 		/**
 		 * Emit `--<name> from "<path>"` as an ICSS import + export, stripping ` from "<path>"` so the runtime sees just `--<name>` (dep ranges end at `sourceEnd - 1`, the closing quote).
 		 * @param {number} identStart start of the `--<name>` ident
@@ -1846,7 +1911,16 @@ class CssParser extends Parser {
 
 			const identStart = A.start(identNode);
 			const identEnd = A.end(identNode);
-			if (!rangeIsDashedIdentifier(input, identStart, identEnd)) return;
+			if (!rangeIsDashedIdentifier(input, identStart, identEnd)) {
+				// `var(v)` where `@value v: --foo` names the same property `var(--foo)`
+				// does, so it is scoped here rather than substituted verbatim.
+				const dashedName = localizableDashedValue(A.value(identNode));
+				if (dashedName !== undefined) {
+					handledDashedValueIdents.add(identStart);
+					emitNamedDashedIdentExport(dashedName, identStart, identEnd);
+				}
+				return;
+			}
 
 			let j = identIdx + 1;
 			while (j < fv.length && A.type(fv[j]) === NodeType.Whitespace) {
@@ -2351,12 +2425,52 @@ class CssParser extends Parser {
 						break;
 					}
 					case NodeType.Ident: {
-						// ICSS rewrite for a bare `@value`-defined ident used as a type-style selector; only worth the slice when definitions exist.
+						// A bare `@value`-defined ident stands in for a 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));
+						if (isDashedIdentifier(ident) || !icssDefinitions.has(ident)) {
+							break;
+						}
+						const identStart = A.start(v);
+						const identEnd = A.end(v);
+						// A value naming one class / id is localized like the selector the
+						// author would have written; anything else is substituted verbatim.
+						const localizable =
+							segmentMode === "local"
+								? localizableSelectorValue(ident)
+								: undefined;
+						if (localizable === undefined) {
+							emitICSSSymbol(ident, identStart, identEnd);
+							break;
+						}
+						const [prefix, localName] = localizable;
+						const { line: sl, column: sc } = locConverter.get(identStart);
+						const { line: el, column: ec } = locConverter.get(identEnd);
+						module.addPresentationalDependency(
+							new ConstDependency(prefix, [identStart, identStart])
+						);
+						recordDeclaration(
+							localName,
+							prefix === "." ? "class" : "id",
+							sl,
+							sc
+						);
+						addCssExport(
+							sl,
+							sc,
+							el,
+							ec,
+							localName,
+							getReexport(localName),
+							[identStart, identEnd],
+							true,
+							CssIcssExportDependency.EXPORT_MODE.ONCE
+						);
+						if (prefix === ".") {
+							currentRule.hasLocalAnchor = true;
+							currentRule.localIdentifiers.push(localName);
 						}
+						pure.markLocal();
 						break;
 					}
 					default:
@@ -4074,6 +4188,10 @@ class CssParser extends Parser {
 					// truncates back to this length (no per-rule copy).
 					const savedLocalIdentifierCount = currentRule.localIdentifiers.length;
 					const name = `@${toLowerCaseIfNeeded(A.unescapedName(at))}`;
+					// The dispatch below is the only place a prelude is rewritten ahead
+					// of the value visitors, so the marks live exactly as long as it.
+					if (handledPreludeIdents.size !== 0) handledPreludeIdents.clear();
+					trackingPreludeIdents = true;
 					switch (name) {
 						case "@namespace": {
 							this._emitWarning(
@@ -4173,6 +4291,7 @@ class CssParser extends Parser {
 							)
 						);
 					}
+					trackingPreludeIdents = false;
 
 					// Prelude value-visitor context; AST-handled at-rules emit their own deps so they're excluded from the local() / global() / ICSS walks.
 					const effectiveLocalMode = isEffectivelyLocal();
@@ -4696,13 +4815,13 @@ class CssParser extends Parser {
 			},
 			[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. The dashed
-				// probe reads two char codes instead of slicing (escaped dashes don't
-				// match, same as the string form — cf. `processDashedIdentInVarFunction`).
+				// WHY: a 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` or `:import`
+				// definitions the ICSS probe can never hit, so it does not warrant the
+				// slice either. The dashed probe reads two char codes instead of slicing,
+				// and an escaped dash does not match, as in the string form.
 				const dashedActive = dashed.active;
 				const icss = icssActive() && icssDefinitions.size !== 0;
 				if (!dashedActive && !icss) return;
@@ -4777,17 +4896,29 @@ class CssParser extends Parser {
 				if (dashed.counterArgs) return;
 				// Deferred: only the ICSS probe needs the ident's string value.
 				const identValue = A.value(node);
-				if (icssDefinitions.has(identValue)) {
-					emitICSSSymbol(identValue, identStart, identEnd);
+				if (!icssDefinitions.has(identValue)) return;
+				// Already scoped by the enclosing `var()` handler.
+				if (
+					handledDashedValueIdents.size !== 0 &&
+					handledDashedValueIdents.has(identStart)
+				) {
+					return;
+				}
+				// A `@value` resolving to a dashed ident sits where `--foo` would be
+				// scoped, so it is localized rather than substituted verbatim.
+				if (dashedActive && dashed.emit) {
+					const dashedName = localizableDashedValue(identValue);
+					if (dashedName !== undefined) {
+						emitNamedDashedIdentExport(dashedName, identStart, identEnd);
+						return;
+					}
 				}
+				emitICSSSymbol(identValue, identStart, identEnd);
 			}
 		};
-		// `as` selects the top-level production (§5.3): a `style` attribute is a
-		// 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).
+		// `as` selects the top-level production of §5.3: a `style` attribute is a
+		// block's contents, anything else a full stylesheet. `as` and `skip` are
+		// per-parse, so only the per-source `locConverter` reaches `process`.
 		new SourceProcessor()
 			.use(/** @type {VisitorMap} */ (visitors))
 			.process(source, {

package/lib/css/CssServerStylesRuntimeModule.js

@@ -26,6 +26,15 @@ class CssServerStylesRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/css/cssMinify.js

@@ -31,9 +31,9 @@
  * imported at module scope: `minimizer-webpack-plugin` ships this function to its
  * worker pool as source (a top-level import wouldn't survive), and `require("webpack")`
  * re-resolves in the worker — via the installed package, or the dev self-link.
- * @param {{ [file: string]: string }} input a single `{ filename: code }` entry
+ * @param {{ [file: string]: string | Buffer }} input a single `{ filename: code }` entry; a `Buffer` is read as UTF-8
  * @param {object=} sourceMap the asset's input source map — the plugin chains it onto the map returned here, so it isn't read directly
- * @param {{ as?: "stylesheet" | "block-contents", environment?: CssEnvironment, convertLengthUnits?: boolean, rewriteCustomProperties?: boolean, renderEmbeddedSource?: AsyncEmbeddedSourceRenderer } & CssTransformOptions=} minimizerOptions minimizer options — `environment` carries the target's CSS abilities (see `output.environment`), so a spelling the target cannot read is not reached for; the rest is `optimization.minimize.css` (e.g. `convertLengthUnits`, and the per-transform switches). `renderEmbeddedSource` minifies source this stylesheet embeds, and may be asynchronous: one parse serves both it and the output
+ * @param {{ as?: "stylesheet" | "block-contents", environment?: CssEnvironment, convertLengthUnits?: boolean, mergeDistantRules?: boolean, rewriteCustomProperties?: boolean, unusedSymbols?: string[], pseudoClasses?: { [name: string]: string }, renderEmbeddedSource?: AsyncEmbeddedSourceRenderer } & CssTransformOptions=} minimizerOptions minimizer options — `environment` carries the target's CSS abilities (see `output.environment`), so a spelling the target cannot read is not reached for; the rest is `optimization.minimize.css` (e.g. `convertLengthUnits`, and the per-transform switches). `renderEmbeddedSource` minifies source this stylesheet embeds, and may be asynchronous: one parse serves both it and the output
  * @returns {Promise<{ code: string, map?: SourceMap, warnings?: (Error | string)[], errors?: (Error | string)[] }>} the minified CSS, its input->output source map (one anchor for the whole of a `block-contents` print, which is emitted as one piece), and what a renderer reported over what this embeds
  */
 const cssMinify = async (input, sourceMap, minimizerOptions = {}) => {
@@ -44,36 +44,40 @@ const cssMinify = async (input, sourceMap, minimizerOptions = {}) => {
 
 	// TODO expose the remaining declined transforms on `optimization.minimize.css`
 	// like `convertLengthUnits` — the switches below turn off what webpack does
-	// make, not what it declines. Each is on in other minifiers; what each costs:
-	// - dropping a declaration a later one overrides, which loses a fallback pair
-	//   an engine that cannot read the newer spelling depends on;
-	// - merging rules a third stands between, and merging non-adjacent `@media`,
-	//   both of which reorder the cascade (csso loses ~12,900 Tailwind classes to
-	//   it). Adjacent rules sharing a block do join, nothing being between them to
-	//   step over — only where every selector is a shape each engine parses, since
-	//   one it cannot invalidates the whole list and loses the rest with it;
-	// - the color conversions webpack declines rather than guesses. Every polar and
-	//   Lab function converts to hex, except two cases the other minifiers convert
-	//   regardless: a channel landing near a `.5` boundary, where implementations
-	//   round opposite ways (it is why esbuild and lightningcss emit different
-	//   bytes for `hwb(194 0% 0%)`), and a Lab-family color outside the sRGB gamut,
-	//   which hex would clip to a different color rather than respell.
-	// Which longhand families merge into their shorthand is decided in
-	// `tooling/generate-css-data.js`, and three kinds are excluded there for good
-	// rather than pending an option:
-	// - a shorthand gathering a whole family (`border`, `font`, `background`,
+	// make, not what it declines.
+
+	// WHY: each transform webpack declines is on in other minifiers, and each costs
+	// something measured.
+	// - Dropping a declaration a later one overrides loses a fallback pair an
+	//   engine that cannot read the newer spelling depends on.
+	// - Merging rules a third stands between, and merging non-adjacent `@media`,
+	//   both reorder the cascade (csso loses ~12,900 Tailwind classes to it).
+	//   Adjacent rules sharing a block do join, nothing being between them to step
+	//   over — only where every selector is a shape each engine parses, since one
+	//   it cannot invalidates the whole list and loses the rest with it.
+	// - Two color conversions are declined rather than guessed. Every polar and Lab
+	//   function converts to hex, except a channel landing near a `.5` boundary,
+	//   where implementations round opposite ways (which is why esbuild and
+	//   lightningcss emit different bytes for `hwb(194 0% 0%)`), and a Lab-family
+	//   color outside the sRGB gamut, which hex would clip rather than respell.
+
+	// WHY: which longhand families merge into their shorthand is decided in
+	// `tooling/generate-css-data.js`, where three kinds are excluded for good
+	// rather than pending an option.
+	// - A shorthand gathering a whole family (`border`, `font`, `background`,
 	//   `transition`, `flex`, `columns`) resets longhands `computed` does not
 	//   name — `border` clears `border-image`, `font` clears `font-size-adjust` —
-	//   so the merge would drop a declaration nothing in the family wrote. The
-	//   ones checked against a browser and found to reset nothing else do merge
-	//   (`FAMILY_LONGHANDS`), where each value parses back into its own slot;
-	// - a shorthand materially newer than its longhands (`place-items`/`-content`
+	//   so the merge would drop a declaration nothing in the family wrote. The ones
+	//   checked against a browser and found to reset nothing else do merge
+	//   (`FAMILY_LONGHANDS`), where each value parses back into its own slot.
+	// - A shorthand materially newer than its longhands (`place-items`/`-content`
 	//   /`-self`) would lose both declarations, not one, on a target reading only
-	//   the longhands. `output.environment` states this for `inset` alone.
-	//   `overflow` is newer only two values wide, so it merges when it collapses;
-	// - a pair two shorthands both claim, which cannot be right for both. None
+	//   the longhands. `output.environment` states this for `inset` alone, and
+	//   `overflow` is newer only two values wide, so it merges when it collapses.
+	// - A pair two shorthands both claim, which cannot be right for both. None
 	//   today: `mdn-data` gave `corner-inline-start-shape` the block-start edge's
 	//   corners, corrected in the generator to the pair Chromium computes.
+
 	const {
 		SourceProcessor,
 		askEmbeddedRenderer,
@@ -81,16 +85,20 @@ const cssMinify = async (input, sourceMap, minimizerOptions = {}) => {
 		embeddedText,
 		pickTransforms
 	} = webpack.css.syntax;
-	const [[file, code]] = Object.entries(input);
-	// `process` parses once, and with `mode: "minify"` the same walk also prints
-	// the safely minified serialization — no second parse. Naming the input with
-	// `source` / `content` is what asks for the map, which the plugin composes
-	// back to the original source.
+	const [[file, given]] = Object.entries(input);
+	// The plugin hands a text minifier a string; the type admits an image's bytes.
+	const code = typeof given === "string" ? given : given.toString("utf8");
+	// `process` parses once, and under `mode: "minify"` the same walk prints the
+	// minified serialization too. Naming the input with `source` or `content` is
+	// what asks for the map the plugin composes back to the original.
 	const {
 		as,
 		environment,
 		convertLengthUnits,
+		mergeDistantRules,
 		rewriteCustomProperties,
+		unusedSymbols,
+		pseudoClasses,
 		renderEmbeddedSource
 	} = minimizerOptions;
 	// One set of options, handed to the print. `as` names the production: a
@@ -103,7 +111,10 @@ const cssMinify = async (input, sourceMap, minimizerOptions = {}) => {
 		content: code,
 		environment,
 		convertLengthUnits,
+		mergeDistantRules,
 		rewriteCustomProperties,
+		unusedSymbols,
+		pseudoClasses,
 		// The per-transform switches stand beside those rather than nested in
 		// them, so a config names one the way it names `convertLengthUnits`;
 		// `pickTransforms` is what knows which names those are.