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

package/lib/debug/ProfilingPlugin.js

@@ -12,6 +12,7 @@ const {
 	WEBASSEMBLY_MODULES
 } = require("../ModuleTypeConstants");
 const { dirname, mkdirpSync } = require("../util/fs");
+const { fileUrlToPath } = require("../util/identifier");
 
 /** @import { Session } from "inspector" */
 /** @import { FullTap } from "tapable" */
@@ -149,10 +150,9 @@ class Profiler {
 			// Avoid coverage problems due indirect changes
 			/* istanbul ignore next */
 			if (profile.startTime < this._startTime || profile.endTime > endTime) {
-				// In some cases timestamps mismatch and we need to adjust them
-				// Both process.hrtime and the inspector timestamps claim to be relative
-				// to a unknown point in time. But they do not guarantee that this is the
-				// same point in time.
+				// `process.hrtime` and the inspector timestamps are each relative to an
+				// unknown point in time, with no guarantee it is the same point, so the
+				// two are rescaled onto one another here.
 				const duration = profile.endTime - profile.startTime;
 				const ownDuration = endTime - this._startTime;
 				const untracked = Math.max(0, ownDuration - duration);
@@ -258,6 +258,9 @@ class ProfilingPlugin {
 	 * @param {ProfilingPluginOptions=} options options object
 	 */
 	constructor(options = {}) {
+		if (typeof options.outputPath === "string") {
+			options.outputPath = fileUrlToPath(options.outputPath);
+		}
 		/** @type {ProfilingPluginOptions} */
 		this.options = options;
 	}

package/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { recordOptimizationBailout } = require("../util/buildDiagnostics");
 const AMDDefineDependency = require("./AMDDefineDependency");
 const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
 const AMDRequireContextDependency = require("./AMDRequireContextDependency");
@@ -35,6 +36,7 @@ const { addLocalModule, getLocalModule } = require("./LocalModulesHelpers");
  * } from "../../declarations/WebpackOptions"
  */
 /** @import Dependency from "../Dependency" */
+/** @import { BuildInfo } from "../Module" */
 /** @import BasicEvaluatedExpression from "../javascript/BasicEvaluatedExpression" */
 /**
  * @import JavascriptParser, {
@@ -353,9 +355,10 @@ class AMDDefineDependencyParserPlugin {
 				return;
 		}
 		DynamicExports.bailout(parser.state);
-		parser.state.compilation.moduleGraph
-			.getOptimizationBailout(parser.state.module)
-			.push("AMD bailout: define() prevents static exports analysis");
+		recordOptimizationBailout(
+			/** @type {BuildInfo} */ (parser.state.module.buildInfo),
+			"AMD bailout: define() prevents static exports analysis"
+		);
 		/** @type {Identifier[] | null} */
 		let fnParams = null;
 		let fnParamsOffset = 0;

package/lib/dependencies/AMDRuntimeModules.js

@@ -25,6 +25,15 @@ class AMDDefineRuntimeModule 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
@@ -58,6 +67,15 @@ class AMDOptionsRuntimeModule extends RuntimeModule {
 		this.options = options;
 	}
 
+	/**
+	 * 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/dependencies/CommonJsExportRequireDependency.js

@@ -273,23 +273,22 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 		const from = moduleGraph.getConnection(this);
 		if (!from) return;
 		if (esmUnwrap) {
-			// Full re-export `module.exports = require("./esm")` of a module
-			// with a `"module.exports"` named export: the wrapping module's
-			// `module.exports` becomes the unwrapped value, whose own
-			// properties webpack cannot enumerate statically.
+			// In `module.exports = require("./esm")` of a module carrying a
+			// `"module.exports"` export, this module's own exports become the
+			// unwrapped value, whose properties cannot be enumerated statically.
 			return {
 				exports: true,
 				canMangle: false,
 				dependencies: [from.module]
 			};
 		}
-		// The imported namespace ESM hasn't been flagged by
-		// FlagDependencyExportsPlugin yet (no exports determined), so its
-		// `"module.exports"` unwrap eligibility is still unknown. Star-reexporting
-		// now would add `__esModule` (and names) the monotonic merge can't retract
-		// once the module turns out to unwrap, making the result order-dependent
-		// across runtimes; defer — the `from.module` dependency re-queues us once
-		// its exports (owned names, or dynamic `other`) become known.
+		// WHY: the imported namespace ESM has not been flagged by
+		// FlagDependencyExportsPlugin yet, so its `"module.exports"` unwrap
+		// eligibility is still unknown. Star-reexporting now would add `__esModule`,
+		// and names, that the monotonic merge cannot retract once the module turns
+		// out to unwrap, making the result order-dependent across runtimes. Deferring
+		// is safe: the `from.module` dependency re-queues this once its exports —
+		// owned names, or a dynamic `other` — become known.
 		if (
 			importedModule &&
 			importedModule.getExportsType(moduleGraph, false) === "namespace"
@@ -528,7 +527,9 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 				: ids;
 			requireExpr = concatenationScope.createModuleReference(importedModule, {
 				ids: requestedIds.length > 0 ? requestedIds : undefined,
-				asiSafe: true,
+				// a used reexport keeps its assignment, so only an unused one is
+				// left standing where the original statement began
+				asiSafe: used ? true : dep.asiSafe,
 				moduleExportsAccess: true
 			});
 		} else {

package/lib/dependencies/CommonJsExportsParserPlugin.js

@@ -7,6 +7,7 @@
 
 const RuntimeGlobals = require("../RuntimeGlobals");
 const { evaluateToString } = require("../javascript/JavascriptParserHelpers");
+const { recordOptimizationBailout } = require("../util/buildDiagnostics");
 const formatLocation = require("../util/formatLocation");
 const { propertyAccess } = require("../util/property");
 const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
@@ -38,7 +39,7 @@ const FUNCTION_PROPERTY_DROP_HEAD =
  * } from "estree"
  */
 /** @import { ExportInfoName } from "../Dependency" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { BuildInfo } from "../Module" */
 /** @import BasicEvaluatedExpression from "../javascript/BasicEvaluatedExpression" */
 /**
  * @import JavascriptParser, {
@@ -357,15 +358,6 @@ const getObjectExportKind = (property) => {
 const PLUGIN_NAME = "CommonJsExportsParserPlugin";
 
 class CommonJsExportsParserPlugin {
-	/**
-	 * Creates an instance of CommonJsExportsParserPlugin.
-	 * @param {ModuleGraph} moduleGraph module graph
-	 */
-	constructor(moduleGraph) {
-		/** @type {ModuleGraph} */
-		this.moduleGraph = moduleGraph;
-	}
-
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
@@ -406,9 +398,10 @@ class CommonJsExportsParserPlugin {
 		 * @param {string} reason reason
 		 */
 		const bailoutHint = (reason) => {
-			this.moduleGraph
-				.getOptimizationBailout(parser.state.module)
-				.push(`CommonJS bailout: ${reason}`);
+			recordOptimizationBailout(
+				/** @type {BuildInfo} */ (parser.state.module.buildInfo),
+				`CommonJS bailout: ${reason}`
+			);
 		};
 		/** @type {unknown} */
 		let keptAllExportsForState;
@@ -479,6 +472,9 @@ class CommonJsExportsParserPlugin {
 					requireCall.ids,
 					!parser.isStatementLevelExpression(expr)
 				);
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expr.range)[0]
+				);
 				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.module.addDependency(dep);
@@ -670,6 +666,9 @@ class CommonJsExportsParserPlugin {
 							false
 						);
 						dep.getter = reexport.getter;
+						dep.asiSafe = !parser.isAsiPosition(
+							/** @type {Range} */ (expr.range)[0]
+						);
 						dep.loc = parser.getLocation(expr);
 						dep.optional = Boolean(parser.scope.inTry);
 						parser.state.module.addDependency(dep);

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -212,6 +212,7 @@ const createRequireCallHandler = (
 				/** @type {Range} */ (expr.range)
 			);
 			if (binding) binding.dep = dep;
+			dep.asiSafe = !parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]);
 			dep.loc = parser.getLocation(expr);
 			dep.optional = Boolean(parser.scope.inTry);
 			parser.state.current.addDependency(dep);
@@ -737,11 +738,10 @@ class CommonJsImportsParserPlugin {
 		// #endregion
 
 		// #region Require bound to a const variable
-		// Track `const NAME = require(LITERAL)` so that static member accesses on
-		// `NAME` (e.g. `NAME.foo`, `NAME.foo()`) are forwarded to the same
-		// `CommonJsRequireDependency` as referenced exports — enabling tree
-		// shaking of CommonJS modules that are imported into a named binding
-		// rather than destructured.
+
+		// Track `const NAME = require(LITERAL)`, so a static member access on `NAME`
+		// forwards to the same dependency as a referenced export and a CommonJS
+		// module bound to a name still tree-shakes.
 		parser.hooks.preDeclarator.tap(PLUGIN_NAME, (declarator, statement) => {
 			if (statement.kind !== "const") return;
 			if (declarator.id.type !== "Identifier") return;

package/lib/dependencies/CommonJsPlugin.js

@@ -254,9 +254,7 @@ class CommonJsPlugin {
 					);
 
 					new CommonJsImportsParserPlugin(parserOptions).apply(parser);
-					new CommonJsExportsParserPlugin(compilation.moduleGraph).apply(
-						parser
-					);
+					new CommonJsExportsParserPlugin().apply(parser);
 				};
 
 				normalModuleFactory.hooks.parser
@@ -285,6 +283,15 @@ class HarmonyModuleDecoratorRuntimeModule 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
@@ -326,6 +333,15 @@ class NodeModuleDecoratorRuntimeModule 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/dependencies/CommonJsRequireDependency.js

@@ -20,6 +20,7 @@ const HarmonyImportGuard = require("./HarmonyImportGuard");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
+/** @import ConcatenationScope from "../ConcatenationScope" */
 /**
  * @import {
  * 	GetConditionFn,
@@ -30,12 +31,13 @@ const ModuleDependency = require("./ModuleDependency");
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 /** @import Module from "../Module" */
 /** @import ModuleGraph from "../ModuleGraph" */
+/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
 /** @import { Range } from "../javascript/JavascriptParser" */
 /** @import { UsedByExports } from "../optimize/InnerGraph" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /** @import { DependencyGuard } from "./HarmonyImportGuard" */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined]>} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined, boolean | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined, boolean | undefined]>} ObjectSerializerContext */
 
 /**
  * Trims a member-access path at the first segment that is definitively not a
@@ -91,6 +93,10 @@ class CommonJsRequireDependency extends ModuleDependency {
 		// `new require(...)`; see the template for the return-value rule
 		/** @type {boolean} */
 		this.callNew = false;
+		// whether the position the call sits at cannot be joined to what precedes
+		// it by ASI; only meaningful once the call renders as a module reference
+		/** @type {boolean | undefined} */
+		this.asiSafe = undefined;
 	}
 
 	get type() {
@@ -200,6 +206,19 @@ class CommonJsRequireDependency extends ModuleDependency {
 		return concatenateCommonJsModules && this._canConcatenate;
 	}
 
+	/**
+	 * @param {ModuleGraphConnection} connection the active connection of this dependency
+	 * @param {ConcatenationScope} concatenationScope the concatenation scope
+	 * @returns {boolean} true when the call becomes a module reference
+	 */
+	rendersAsConcatenatedReference(connection, concatenationScope) {
+		return (
+			this._canConcatenate &&
+			this.valueRange !== undefined &&
+			concatenationScope.isModuleInScope(connection.module)
+		);
+	}
+
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
@@ -211,7 +230,8 @@ class CommonJsRequireDependency extends ModuleDependency {
 			.write(this.branchGuards)
 			.write(this._canConcatenate)
 			.write(this.callNew)
-			.write(this.usedByExports);
+			.write(this.usedByExports)
+			.write(this.asiSafe);
 		super.serialize(context);
 	}
 
@@ -231,7 +251,9 @@ class CommonJsRequireDependency extends ModuleDependency {
 		this.callNew = c4.read();
 		const c5 = c4.rest;
 		this.usedByExports = c5.read();
-		super.deserialize(c5.rest);
+		const c6 = c5.rest;
+		this.asiSafe = c6.read();
+		super.deserialize(c6.rest);
 	}
 }
 
@@ -278,9 +300,9 @@ CommonJsRequireDependency.Template = class CommonJsRequireDependencyTemplate ext
 		if (
 			connection &&
 			concatenationScope !== undefined &&
-			dep.valueRange !== undefined &&
-			concatenationScope.isModuleInScope(connection.module)
+			dep.rendersAsConcatenatedReference(connection, concatenationScope)
 		) {
+			const valueRange = /** @type {Range} */ (dep.valueRange);
 			let content = concatenationScope.createModuleReference(
 				connection.module,
 				{
@@ -288,7 +310,9 @@ CommonJsRequireDependency.Template = class CommonJsRequireDependencyTemplate ext
 					ids: isRequireEsmModuleExportsModule(connection.module, moduleGraph)
 						? [ESM_MODULE_EXPORTS_NAME]
 						: undefined,
-					asiSafe: true,
+					// `new` wraps the reference in a call, so only a plain
+					// replacement inherits the original call's position
+					asiSafe: dep.callNew ? true : dep.asiSafe,
 					moduleExportsAccess: true
 				}
 			);
@@ -300,8 +324,7 @@ CommonJsRequireDependency.Template = class CommonJsRequireDependencyTemplate ext
 				);
 				content = `${RuntimeGlobals.constructRequire}(${content})`;
 			}
-			source.replace(dep.valueRange[0], dep.valueRange[1] - 1, content);
-			concatenationScope.registerReplacedRequire(dep.valueRange);
+			source.replace(valueRange[0], valueRange[1] - 1, content);
 			return;
 		}
 		const importedModule = /** @type {Module} */ (moduleGraph.getModule(dep));

package/lib/dependencies/CommonJsSelfReferenceDependency.js

@@ -207,10 +207,8 @@ CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependency
 		}
 
 		if (base === dep.base && equals(used, dep.names)) {
-			// Nothing has to be changed
-			// We don't use a replacement for compat reasons
-			// for plugins that update `module._source` which they
-			// shouldn't do!
+			// Nothing has to change, and no replacement is emitted: plugins that
+			// update `module._source`, which they should not, depend on that.
 			return;
 		}
 

package/lib/dependencies/ContextDependency.js

@@ -15,7 +15,7 @@ const getCriticalDependencyWarning = memoize(() =>
 );
 
 /** @import { Range } from "../javascript/JavascriptParser" */
-/** @import { ContextOptions } from "../ContextModule" */
+/** @import { ContextOptions } from "../context/ContextModule" */
 /** @import { TRANSITIVE } from "../Dependency" */
 /** @import ModuleGraph from "../ModuleGraph" */
 /** @import WebpackError from "../errors/WebpackError" */

package/lib/dependencies/ContextDependencyHelpers.js

@@ -107,15 +107,9 @@ module.exports.create = (
 				)
 				.join("");
 
-		// Example: `./context/pre${e}inner${e}inner2${e}post?query#frag`
-		// context: "./context"
-		// prefix: "./pre"
-		// innerQuasis: [BEE("inner"), BEE("inner2")]
-		// (BEE = BasicEvaluatedExpression)
-		// postfix: "post"
-		// query: "?query"
-		// fragment: "#frag"
-		// regExp: /^\.\/pre.*inner.*inner2.*post$/
+		// The template's quasis become the literal anchors of the regexp and its
+		// expressions the gaps between them, so `./context/pre${e}inner${e}post`
+		// matches `/^\.\/pre.*inner.*post$/` under the context `./context`.
 		const regExp = new RegExp(
 			`^${quoteMeta(prefix)}${innerRegExp}${quoteMeta(postfix)}$`
 		);

package/lib/dependencies/ContextDependencyTemplateAsRequireCall.js

@@ -22,11 +22,9 @@ class ContextDependencyTemplateAsRequireCall
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
+	apply(dependency, source, templateContext) {
+		const { runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements } =
+			templateContext;
 		const dep = /** @type {ContextDependency} */ (dependency);
 		let moduleExports = runtimeTemplate.moduleExports({
 			module: moduleGraph.getModule(dep),
@@ -49,8 +47,7 @@ class ContextDependencyTemplateAsRequireCall
 						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
 					}
 				}
-				source.replace(dep.valueRange[1], range[1] - 1, ")");
-				source.replace(range[0], dep.valueRange[0] - 1, `${moduleExports}(`);
+				this.replaceCall(dep, source, moduleExports, templateContext);
 			} else {
 				source.replace(range[0], range[1] - 1, moduleExports);
 			}
@@ -58,6 +55,22 @@ class ContextDependencyTemplateAsRequireCall
 			source.replace(range[0], range[1] - 1, moduleExports);
 		}
 	}
+
+	/**
+	 * Rewrites the call around its request, dropping anything the original one
+	 * carried after it. Overridden where a later argument must be kept.
+	 * @param {ContextDependency} dep the dependency
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {string} moduleExports the expression the request is passed to
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	replaceCall(dep, source, moduleExports, templateContext) {
+		const range = /** @type {Range} */ (dep.range);
+		const valueRange = /** @type {Range} */ (dep.valueRange);
+		source.replace(valueRange[1], range[1] - 1, ")");
+		source.replace(range[0], valueRange[0] - 1, `${moduleExports}(`);
+	}
 }
 
 module.exports = ContextDependencyTemplateAsRequireCall;

package/lib/dependencies/ContextElementDependency.js

@@ -9,7 +9,7 @@ const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @import ContextModule from "../ContextModule" */
+/** @import ContextModule from "../context/ContextModule" */
 /** @import { RawReferencedExports, ReferencedExports } from "../Dependency" */
 /** @import Module from "../Module" */
 /** @import ModuleGraph from "../ModuleGraph" */

package/lib/dependencies/CssIcssExportDependency.js

@@ -370,10 +370,9 @@ class CssIcssExportDependency extends NullDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		// `composes: foo;` (SELF_REFERENCE) references the composed class
-		// (`entry.value`), not the composing class. Every other entry mode
-		// keeps the whole exports object referenced (legacy behaviour), so the
-		// presence of any such entry subsumes the self-reference names.
+		// `composes: foo;` references the composed class, not the composing one.
+		// Every other entry mode references the whole exports object, so one such
+		// entry subsumes the self-reference names.
 		let hasNonSelfReference = false;
 		/** @type {ReferencedExports} */
 		const referenced = [];
@@ -850,10 +849,9 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 		if (!entry.interpolate) return value;
 		const { moduleGraph, module, chunkGraph, runtimeTemplate } =
 			templateContext;
-		// Key order is by rising cardinality: `moduleGraph.cached` is a trie that
-		// allocates a node per level per new prefix, so the per-export `value` goes
-		// last — otherwise every export name forks the trie and re-allocates the
-		// three elements below it, which are constant for the whole compilation.
+		// Keys are ordered by rising cardinality, since `moduleGraph.cached` is a
+		// trie allocating a node per level per prefix: the per-export `value` last,
+		// or every name forks the trie above the parts constant for the build.
 		return moduleGraph.cached(
 			computeInterpolatedIdentifier,
 			/** @type {CssModule} */ (module),
@@ -916,7 +914,13 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 			}
 
 			if (entry.exportType === EXPORT_TYPE.GRID_CUSTOM_IDENTIFIER) {
-				value += `-${entry.name}`;
+				// The suffix names what the identifier was built from, so it follows a
+				// `@value` to its resolved name — both spellings select the same line.
+				value += `-${
+					isReference
+						? /** @type {string[]} */ (entry.value)[0]
+						: /** @type {string} */ (entry.value)
+				}`;
 			}
 
 			if (isJs && entry.exportMode !== EXPORT_MODE.NONE) {

package/lib/dependencies/CssIcssImportDependency.js

@@ -100,12 +100,9 @@ class CssIcssImportDependency extends CssImportDependency {
 
 		if (!module) return null;
 
-		// The target module stores exports under the names produced by its
-		// `exportsConvention`, so a raw `isExportProvided(this.importName)`
-		// would false-positive against `camel-case-only` / `dashes-only` (and
-		// any custom function that drops the original spelling). Expand
-		// `importName` through the *target* module's convention and accept
-		// if any alias is provided.
+		// The target stores exports under its own `exportsConvention`, so asking for
+		// the raw name misses under `camel-case-only` or any convention dropping the
+		// original spelling. Expand through that convention and accept any alias.
 		const generator =
 			/** @type {CssGenerator | undefined} */
 			(module.generator);

package/lib/dependencies/CssUrlDependency.js

@@ -84,11 +84,9 @@ class CssUrlDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		// The dependency template substitutes the referenced asset's hashed
-		// filename into the rendered CSS at code-generation time. Folding the
-		// asset module's content hash into the dependency hash ensures the
-		// CSS module's hash invalidates — and the CSS chunk's contenthash
-		// updates — whenever the referenced asset's content changes.
+		// The template substitutes the asset's hashed filename into the rendered CSS,
+		// so folding that asset's content hash in here is what makes the CSS module's
+		// hash, and the chunk's contenthash, follow the asset.
 		const { chunkGraph } = context;
 		const module = chunkGraph.moduleGraph.getModule(this);
 		if (!module) return;