webpack 5.97.1 → 5.104.1

package/lib/dependencies/CssIcssImportDependency.js

@@ -5,40 +5,117 @@
 
 "use strict";
 
+const WebpackError = require("../WebpackError");
+const { cssExportConvention } = require("../util/conventions");
 const makeSerializable = require("../util/makeSerializable");
-const CssIcssExportDependency = require("./CssIcssExportDependency");
-const CssLocalIdentifierDependency = require("./CssLocalIdentifierDependency");
-const ModuleDependency = require("./ModuleDependency");
+const memoize = require("../util/memoize");
+const CssImportDependency = require("./CssImportDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../CssModule")} CssModule */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+/** @typedef {import("./CssIcssExportDependency").ExportMode} ExportMode */
+/** @typedef {import("./CssIcssExportDependency").ExportType} ExportType */
 
-class CssIcssImportDependency extends ModuleDependency {
+const getCssIcssExportDependency = memoize(() =>
+	require("./CssIcssExportDependency")
+);
+
+class CssIcssImportDependency extends CssImportDependency {
 	/**
 	 * Example of dependency:
 	 *
-	 *:import('./style.css') { IMPORTED_NAME: v-primary }
+	 * :import('./style.css') { value: name }
 	 * @param {string} request request request path which needs resolving
-	 * @param {string} exportName export name
-	 * @param {[number, number]} range the range of dependency
+	 * @param {Range} range the range of dependency
+	 * @param {"local" | "global"} mode mode of the parsed CSS
+	 * @param {string} name name
+	 * @param {string=} exportName export value
+	 * @param {ExportMode=} exportMode export mode
+	 * @param {ExportType=} exportType export type
 	 */
-	constructor(request, exportName, range) {
-		super(request);
-		this.range = range;
-		this.exportName = exportName;
+	constructor(
+		request,
+		range,
+		mode,
+		name,
+		exportName = undefined,
+		exportMode = getCssIcssExportDependency().EXPORT_MODE.NONE,
+		exportType = getCssIcssExportDependency().EXPORT_TYPE.NORMAL
+	) {
+		super(request, range, mode);
+		this.name = name;
+		this.value = exportName;
+		this.interpolate = true;
+		this.exportMode = exportMode;
+		this.exportType = exportType;
 	}
 
 	get type() {
 		return "css :import";
 	}
 
-	get category() {
-		return "css-import";
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `${super.getResourceIdentifier()}|mode${this.mode}|name${this.name}`;
+	}
+
+	/**
+	 * @param {string} name export name
+	 * @param {CssGeneratorExportsConvention} convention convention of the export name
+	 * @returns {string[]} convention results
+	 */
+	getExportsConventionNames(name, convention) {
+		return cssExportConvention(name, convention);
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {ReferencedExports} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return [
+			{
+				name: [this.name],
+				canMangle: true
+			}
+		];
+	}
+
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} warnings
+	 */
+	getWarnings(moduleGraph) {
+		const module = moduleGraph.getModule(this);
+
+		if (
+			module &&
+			!moduleGraph.getExportsInfo(module).isExportProvided(this.name)
+		) {
+			const error = new WebpackError(
+				`Referenced name "${this.name}" in "${this.userRequest}" not found`
+			);
+			error.module = module;
+
+			return [error];
+		}
+
+		return null;
 	}
 
 	/**
@@ -46,8 +123,11 @@ class CssIcssImportDependency extends ModuleDependency {
 	 */
 	serialize(context) {
 		const { write } = context;
-		write(this.range);
-		write(this.exportName);
+		write(this.name);
+		write(this.value);
+		write(this.interpolate);
+		write(this.exportMode);
+		write(this.exportType);
 		super.serialize(context);
 	}
 
@@ -56,14 +136,17 @@ class CssIcssImportDependency extends ModuleDependency {
 	 */
 	deserialize(context) {
 		const { read } = context;
-		this.range = read();
-		this.exportName = read();
+		this.name = read();
+		this.value = read();
+		this.interpolate = read();
+		this.exportMode = read();
+		this.exportType = read();
 		super.deserialize(context);
 	}
 }
 
 CssIcssImportDependency.Template = class CssIcssImportDependencyTemplate extends (
-	ModuleDependency.Template
+	CssImportDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -73,40 +156,22 @@ CssIcssImportDependency.Template = class CssIcssImportDependencyTemplate extends
 	 */
 	apply(dependency, source, templateContext) {
 		const dep = /** @type {CssIcssImportDependency} */ (dependency);
-		const { range } = dep;
-		const module = templateContext.moduleGraph.getModule(dep);
-		let value;
-
-		for (const item of module.dependencies) {
-			if (
-				item instanceof CssLocalIdentifierDependency &&
-				dep.exportName === item.name
-			) {
-				value = CssLocalIdentifierDependency.Template.getIdentifier(
-					item,
-					dep.exportName,
-					{
-						...templateContext,
-						module
-					}
-				);
-				break;
-			} else if (
-				item instanceof CssIcssExportDependency &&
-				dep.exportName === item.name
-			) {
-				value = item.value;
-				break;
-			}
-		}
 
-		if (!value) {
-			throw new Error(
-				`Imported '${dep.exportName}' name from '${dep.request}' not found`
-			);
+		if (dep.value) {
+			const { moduleGraph } = templateContext;
+			const module =
+				/** @type {CssModule} */
+				(moduleGraph.getModule(dep));
+			const CssIcssExportDependency = getCssIcssExportDependency();
+			const template = new CssIcssExportDependency.Template();
+			const originalName = dep.name;
+			const originalExportName = dep.value;
+			dep.value = originalName;
+			dep.name = originalExportName;
+			template.apply(dep, source, { ...templateContext, module });
+			dep.name = originalName;
+			dep.value = originalExportName;
 		}
-
-		source.replace(range[0], range[1], value);
 	}
 };
 

package/lib/dependencies/CssIcssSymbolDependency.js

@@ -5,13 +5,15 @@
 
 "use strict";
 
+const { CSS_TYPE } = require("../ModuleSourceTypeConstants");
 const makeSerializable = require("../util/makeSerializable");
+const CssIcssExportDependency = require("./CssIcssExportDependency");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
@@ -24,23 +26,21 @@ const NullDependency = require("./NullDependency");
 class CssIcssSymbolDependency extends NullDependency {
 	/**
 	 * @param {string} name name
-	 * @param {string} value value
+	 * @param {string} symbol symbol
 	 * @param {Range} range range
+	 * @param {boolean=} isReference true when is reference, otherwise false
 	 */
-	constructor(name, value, range) {
+	constructor(name, symbol, range, isReference) {
 		super();
 		this.name = name;
-		this.value = value;
+		this.symbol = symbol;
 		this.range = range;
+		this.isReference = isReference;
 		this._hashUpdate = undefined;
 	}
 
 	get type() {
-		return "css @value identifier";
-	}
-
-	get category() {
-		return "self";
+		return "css symbol identifier";
 	}
 
 	/**
@@ -56,31 +56,14 @@ class CssIcssSymbolDependency extends NullDependency {
 		hash.update(this._hashUpdate);
 	}
 
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		return {
-			exports: [
-				{
-					name: this.name,
-					canMangle: true
-				}
-			],
-			dependencies: undefined
-		};
-	}
-
 	/**
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		return [[this.name]];
+		return [[this.symbol]];
 	}
 
 	/**
@@ -89,8 +72,10 @@ class CssIcssSymbolDependency extends NullDependency {
 	serialize(context) {
 		const { write } = context;
 		write(this.name);
+		write(this.symbol);
 		write(this.value);
 		write(this.range);
+		write(this.isReference);
 		super.serialize(context);
 	}
 
@@ -100,13 +85,15 @@ class CssIcssSymbolDependency extends NullDependency {
 	deserialize(context) {
 		const { read } = context;
 		this.name = read();
+		this.symbol = read();
 		this.value = read();
 		this.range = read();
+		this.isReference = read();
 		super.deserialize(context);
 	}
 }
 
-CssIcssSymbolDependency.Template = class CssValueAtRuleDependencyTemplate extends (
+CssIcssSymbolDependency.Template = class CssIcssSymbolDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
@@ -115,12 +102,23 @@ CssIcssSymbolDependency.Template = class CssValueAtRuleDependencyTemplate extend
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { cssData }) {
-		const dep = /** @type {CssIcssSymbolDependency} */ (dependency);
-
-		source.replace(dep.range[0], dep.range[1] - 1, dep.value);
-
-		cssData.exports.set(dep.name, dep.value);
+	apply(dependency, source, templateContext) {
+		if (templateContext.type === CSS_TYPE) {
+			const dep = /** @type {CssIcssSymbolDependency} */ (dependency);
+			/** @type {string | undefined} */
+			const value = dep.isReference
+				? CssIcssExportDependency.Template.findReference(
+						dep.symbol,
+						templateContext
+					)
+				: dep.symbol;
+
+			if (!value) {
+				return;
+			}
+
+			source.replace(dep.range[0], dep.range[1] - 1, value);
+		}
 	}
 };
 

package/lib/dependencies/CssImportDependency.js

@@ -9,19 +9,11 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../css/CssParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class CssImportDependency extends ModuleDependency {
 	/**
@@ -29,13 +21,15 @@ class CssImportDependency extends ModuleDependency {
 	 * \@import url("landscape.css") layer(forms) screen and (orientation: landscape) screen and (orientation: landscape);
 	 * @param {string} request request
 	 * @param {Range} range range of the argument
-	 * @param {string | undefined} layer layer
-	 * @param {string | undefined} supports list of supports conditions
-	 * @param {string | undefined} media list of media conditions
+	 * @param {"local" | "global"=} mode mode of the parsed CSS
+	 * @param {string=} layer layer
+	 * @param {string=} supports list of supports conditions
+	 * @param {string=} media list of media conditions
 	 */
-	constructor(request, range, layer, supports, media) {
+	constructor(request, range, mode, layer, supports, media) {
 		super(request);
 		this.range = range;
+		this.mode = mode;
 		this.layer = layer;
 		this.supports = supports;
 		this.media = media;
@@ -46,7 +40,7 @@ class CssImportDependency extends ModuleDependency {
 	}
 
 	get category() {
-		return "css-import";
+		return `css-import${this.mode ? `-${this.mode}-module` : ""}`;
 	}
 
 	/**
@@ -55,6 +49,10 @@ class CssImportDependency extends ModuleDependency {
 	getResourceIdentifier() {
 		let str = `context${this._context || ""}|module${this.request}`;
 
+		if (this.mode) {
+			str += `|mode${this.mode}`;
+		}
+
 		if (this.layer) {
 			str += `|layer${this.layer}`;
 		}
@@ -75,6 +73,8 @@ class CssImportDependency extends ModuleDependency {
 	 */
 	serialize(context) {
 		const { write } = context;
+		write(this.range);
+		write(this.mode);
 		write(this.layer);
 		write(this.supports);
 		write(this.media);
@@ -86,6 +86,8 @@ class CssImportDependency extends ModuleDependency {
 	 */
 	deserialize(context) {
 		const { read } = context;
+		this.range = read();
+		this.mode = read();
 		this.layer = read();
 		this.supports = read();
 		this.media = read();
@@ -103,6 +105,7 @@ CssImportDependency.Template = class CssImportDependencyTemplate extends (
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
+		if (templateContext.type === "javascript") return;
 		const dep = /** @type {CssImportDependency} */ (dependency);
 
 		source.replace(dep.range[0], dep.range[1] - 1, "");

package/lib/dependencies/CssUrlDependency.js

@@ -11,20 +11,14 @@ const memoize = require("../util/memoize");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 const getIgnoredRawDataUrlModule = memoize(
@@ -53,7 +47,7 @@ class CssUrlDependency extends ModuleDependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module | null} a module
+	 * @returns {Module} ignored module
 	 */
 	createIgnoredModule(context) {
 		return getIgnoredRawDataUrlModule();
@@ -82,7 +76,7 @@ class CssUrlDependency extends ModuleDependency {
  * @param {string} str string
  * @returns {string} string in quotes if needed
  */
-const cssEscapeString = str => {
+const cssEscapeString = (str) => {
 	let countWhiteOrBracket = 0;
 	let countQuotation = 0;
 	let countApostrophe = 0;
@@ -105,11 +99,11 @@ const cssEscapeString = str => {
 		}
 	}
 	if (countWhiteOrBracket < 2) {
-		return str.replace(/[\n\t ()'"\\]/g, m => `\\${m}`);
+		return str.replace(/[\n\t ()'"\\]/g, (m) => `\\${m}`);
 	} else if (countQuotation <= countApostrophe) {
-		return `"${str.replace(/[\n"\\]/g, m => `\\${m}`)}"`;
+		return `"${str.replace(/[\n"\\]/g, (m) => `\\${m}`)}"`;
 	}
-	return `'${str.replace(/[\n'\\]/g, m => `\\${m}`)}'`;
+	return `'${str.replace(/[\n'\\]/g, (m) => `\\${m}`)}'`;
 };
 
 CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
@@ -124,8 +118,9 @@ CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
 	apply(
 		dependency,
 		source,
-		{ moduleGraph, runtimeTemplate, codeGenerationResults }
+		{ type, moduleGraph, runtimeTemplate, codeGenerationResults }
 	) {
+		if (type === "javascript") return;
 		const dep = /** @type {CssUrlDependency} */ (dependency);
 		const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 

package/lib/dependencies/DynamicExports.js

@@ -6,16 +6,16 @@
 "use strict";
 
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
 
-/** @type {WeakMap<ParserState, boolean>} */
+/** @type {WeakMap<JavascriptParserState, boolean>} */
 const parserStateExportsState = new WeakMap();
 
 /**
- * @param {ParserState} parserState parser state
+ * @param {JavascriptParserState} parserState parser state
  * @returns {void}
  */
-module.exports.bailout = parserState => {
+module.exports.bailout = (parserState) => {
 	const value = parserStateExportsState.get(parserState);
 	parserStateExportsState.set(parserState, false);
 	if (value === true) {
@@ -26,10 +26,10 @@ module.exports.bailout = parserState => {
 };
 
 /**
- * @param {ParserState} parserState parser state
+ * @param {JavascriptParserState} parserState parser state
  * @returns {void}
  */
-module.exports.enable = parserState => {
+module.exports.enable = (parserState) => {
 	const value = parserStateExportsState.get(parserState);
 	if (value === false) return;
 	parserStateExportsState.set(parserState, true);
@@ -41,22 +41,19 @@ module.exports.enable = parserState => {
 };
 
 /**
- * @param {ParserState} parserState parser state
- * @returns {void}
+ * @param {JavascriptParserState} parserState parser state
+ * @returns {boolean} true, when enabled
  */
-module.exports.setFlagged = parserState => {
+module.exports.isEnabled = (parserState) => {
 	const value = parserStateExportsState.get(parserState);
-	if (value !== true) return;
-	const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
-	if (buildMeta.exportsType === "dynamic") return;
-	buildMeta.exportsType = "flagged";
+	return value === true;
 };
 
 /**
- * @param {ParserState} parserState parser state
+ * @param {JavascriptParserState} parserState parser state
  * @returns {void}
  */
-module.exports.setDynamic = parserState => {
+module.exports.setDynamic = (parserState) => {
 	const value = parserStateExportsState.get(parserState);
 	if (value !== true) return;
 	/** @type {BuildMeta} */
@@ -64,10 +61,13 @@ module.exports.setDynamic = parserState => {
 };
 
 /**
- * @param {ParserState} parserState parser state
- * @returns {boolean} true, when enabled
+ * @param {JavascriptParserState} parserState parser state
+ * @returns {void}
  */
-module.exports.isEnabled = parserState => {
+module.exports.setFlagged = (parserState) => {
 	const value = parserStateExportsState.get(parserState);
-	return value === true;
+	if (value !== true) return;
+	const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+	if (buildMeta.exportsType === "dynamic") return;
+	buildMeta.exportsType = "flagged";
 };

package/lib/dependencies/ExportsInfoDependency.js

@@ -10,28 +10,31 @@ const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @template T
+ * @typedef {import("../util/SortableSet")<T>} SortableSet
+ */
+
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} module the module
- * @param {string[] | null} _exportName name of the export if any
+ * @param {ExportInfoName[] | null} exportName_ name of the export if any
  * @param {string | null} property name of the requested property
  * @param {RuntimeSpec} runtime for which runtime
- * @returns {any} value of the property
+ * @returns {undefined | null | boolean | ExportInfoName[]} value of the property
  */
-const getProperty = (moduleGraph, module, _exportName, property, runtime) => {
-	if (!_exportName) {
+const getProperty = (moduleGraph, module, exportName_, property, runtime) => {
+	if (!exportName_) {
 		switch (property) {
 			case "usedExports": {
 				const usedExports = moduleGraph
@@ -44,11 +47,11 @@ const getProperty = (moduleGraph, module, _exportName, property, runtime) => {
 				) {
 					return usedExports;
 				}
-				return Array.from(usedExports).sort();
+				return [...usedExports].sort();
 			}
 		}
 	}
-	const exportName = /** @type {string[]} */ (_exportName);
+	const exportName = /** @type {ExportInfoName[]} */ (exportName_);
 	switch (property) {
 		case "canMangle": {
 			const exportsInfo = moduleGraph.getExportsInfo(module);
@@ -87,7 +90,7 @@ const getProperty = (moduleGraph, module, _exportName, property, runtime) => {
 class ExportsInfoDependency extends NullDependency {
 	/**
 	 * @param {Range} range range
-	 * @param {string[] | null} exportName export name
+	 * @param {ExportInfoName[] | null} exportName export name
 	 * @param {string | null} property property
 	 */
 	constructor(range, exportName, property) {