webpack 5.110.2 → 5.111.0

package/lib/dependencies/ImportMetaPlugin.js

@@ -27,6 +27,7 @@ const createHooksRegistry = require("../util/createHooksRegistry");
 const { propertyAccess } = require("../util/property");
 const BuildTimeConstDependency = require("./BuildTimeConstDependency");
 const ConstDependency = require("./ConstDependency");
+const ImportMetaMainDependency = require("./ImportMetaMainDependency");
 const ImportMetaResolveDependency = require("./ImportMetaResolveDependency");
 const ModuleInitFragmentDependency = require("./ModuleInitFragmentDependency");
 
@@ -154,17 +155,44 @@ const isImportMetaFieldEnabled = (importMeta, field) => {
 };
 
 /**
- * Renders the `import.meta.main` comparison and bails out of scope hoisting.
+ * Renders the `import.meta.main` comparison, which reads the module argument a
+ * scope-hoisted module does not have. A caller that can answer the expression
+ * statically for an inner module rules out only the concatenation root.
  * @param {Parser} parser the parser
+ * @param {boolean} staticWhenInner whether an inner concatenated module answers it without the comparison
  * @returns {string} the comparison expression
  */
-const renderImportMetaMain = (parser) => {
+const renderImportMetaMain = (parser, staticWhenInner) => {
 	const currentModule = parser.state.module;
-	/** @type {JavascriptModuleBuildInfo} */
-	(currentModule.buildInfo).moduleConcatenationBailout = IMPORT_META_MAIN;
+	const buildInfo =
+		/** @type {JavascriptModuleBuildInfo} */
+		(currentModule.buildInfo);
+	if (staticWhenInner) {
+		buildInfo.moduleConcatenationRootBailout = IMPORT_META_MAIN;
+	} else {
+		buildInfo.moduleConcatenationBailout = IMPORT_META_MAIN;
+	}
 	return `${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${currentModule.moduleArgument}`;
 };
 
+const IMPORT_META_VAR = "__webpack_import_meta__";
+
+/**
+ * The name of the module's synthesized `import.meta` binding, stepped aside when
+ * the source already spells it. Re-bundling webpack output is the case that
+ * matters: the earlier binding would shadow this one and make it initialize
+ * itself.
+ * @param {Parser} parser the parser
+ * @returns {string} a name no declaration in this module takes
+ */
+const importMetaVarName = (parser) => {
+	const { source } = parser.state;
+	if (!source || !source.includes(IMPORT_META_VAR)) return IMPORT_META_VAR;
+	let index = 2;
+	while (source.includes(`__webpack_import_meta_${index}__`)) index++;
+	return `__webpack_import_meta_${index}__`;
+};
+
 /**
  * Checks whether the callee is the `import.meta.resolve` member.
  * @param {Expression | Super} callee call callee
@@ -261,6 +289,10 @@ class ImportMetaPlugin {
 					BuildTimeConstDependency,
 					new BuildTimeConstDependency.Template()
 				);
+				compilation.dependencyTemplates.set(
+					ImportMetaMainDependency,
+					new ImportMetaMainDependency.Template()
+				);
 
 				/**
 				 * Returns file url.
@@ -442,7 +474,7 @@ class ImportMetaPlugin {
 							const referencedPropertiesInDestructuring =
 								parser.destructuringAssignmentPropertiesFor(metaProperty);
 							if (!referencedPropertiesInDestructuring) {
-								const varName = "__webpack_import_meta__";
+								const varName = importMetaVarName(parser);
 								const knownProps = [];
 								if (isImportMetaFieldEnabled(importMeta, "url")) {
 									knownProps.push(`url: ${importMetaUrl()}`);
@@ -451,7 +483,9 @@ class ImportMetaPlugin {
 									knownProps.push(`webpack: ${importMetaWebpackVersion()}`);
 								}
 								if (isImportMetaFieldEnabled(importMeta, "main")) {
-									knownProps.push(`main: ${renderImportMetaMain(parser)}`);
+									knownProps.push(
+										`main: ${renderImportMetaMain(parser, false)}`
+									);
 								}
 								if (isImportMetaFieldEnabled(importMeta, "env")) {
 									addDefinitionValueDependencies();
@@ -471,8 +505,10 @@ class ImportMetaPlugin {
 								const plainInitCode = `var ${varName} = {${knownProps.join(
 									", "
 								)}};\n`;
+								// Each module owns its `import.meta`: it copies the bundle's one
+								// and inherits from it, so later host writes stay visible.
 								const initCode = preserveUnknown(importMeta)
-									? `var ${varName} = Object.assign(import.meta, {${knownProps.join(
+									? `var ${varName} = Object.assign(Object.create(import.meta), import.meta, {${knownProps.join(
 											", "
 										)}});\n`
 									: plainInitCode;
@@ -556,7 +592,7 @@ class ImportMetaPlugin {
 										break;
 									case "main":
 										if (fieldEnabled) {
-											append(`main: ${renderImportMetaMain(parser)},`);
+											append(`main: ${renderImportMetaMain(parser, false)},`);
 											runtimeRequirements.push(
 												RuntimeGlobals.moduleCache,
 												RuntimeGlobals.entryModuleId,
@@ -740,13 +776,21 @@ class ImportMetaPlugin {
 					if (isImportMetaFieldEnabled(importMeta, "main")) {
 						parser.hooks.expression
 							.for(IMPORT_META_MAIN)
-							.tap(PLUGIN_NAME, (expr) =>
-								toConstantDependency(parser, renderImportMetaMain(parser), [
-									RuntimeGlobals.moduleCache,
-									RuntimeGlobals.entryModuleId,
-									RuntimeGlobals.module
-								])(expr)
-							);
+							.tap(PLUGIN_NAME, (expr) => {
+								const dep = new ImportMetaMainDependency(
+									renderImportMetaMain(parser, true),
+									"false",
+									/** @type {Range} */ (expr.range),
+									[
+										RuntimeGlobals.moduleCache,
+										RuntimeGlobals.entryModuleId,
+										RuntimeGlobals.module
+									]
+								);
+								dep.loc = parser.getLocation(expr);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
 						parser.hooks.typeof
 							.for(IMPORT_META_MAIN)
 							.tap(

package/lib/dependencies/ImportParserPlugin.js

@@ -209,20 +209,18 @@ const isStaticStringAttributes = (node) => {
 				: key.type === "Literal"
 					? key.value
 					: undefined;
-		if (keyName === "with" || keyName === "assert") {
-			const value = prop.value;
-			if (value.type !== "ObjectExpression") return false;
-			for (const attr of value.properties) {
-				if (attr.type !== "Property" || attr.kind !== "init" || attr.computed) {
-					return false;
-				}
-				const attrValue = attr.value;
-				if (
-					attrValue.type !== "Literal" ||
-					typeof attrValue.value !== "string"
-				) {
-					return false;
-				}
+		// Any other key is an expression webpack cannot account for, and its
+		// value still evaluates, so the argument has to stay.
+		if (keyName !== "with" && keyName !== "assert") return false;
+		const value = prop.value;
+		if (value.type !== "ObjectExpression") return false;
+		for (const attr of value.properties) {
+			if (attr.type !== "Property" || attr.kind !== "init" || attr.computed) {
+				return false;
+			}
+			const attrValue = attr.value;
+			if (attrValue.type !== "Literal" || typeof attrValue.value !== "string") {
+				return false;
 			}
 		}
 	}
@@ -676,6 +674,18 @@ class ImportParserPlugin {
 					parser
 				);
 				if (!dep) return;
+				// The context module ignores the options argument, but the spec
+				// evaluates it, so anything but a static attributes object stays.
+				const optionsNode = expr.options;
+				if (
+					optionsNode &&
+					optionsNode.range &&
+					!isStaticStringAttributes(optionsNode)
+				) {
+					/** @type {ImportContextDependency} */ (dep).optionsRange =
+						/** @type {Range} */ (optionsNode.range);
+					parser.walkExpression(optionsNode);
+				}
 				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.current.addDependency(dep);

package/lib/dependencies/RequireHeaderDependency.js

@@ -76,30 +76,29 @@ RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate extends
 		{ moduleGraph, runtime, runtimeRequirements, concatenationScope }
 	) {
 		const dep = /** @type {RequireHeaderDependency} */ (dependency);
-
-		// the paired require dependency already replaced the whole call
-		if (
-			concatenationScope !== undefined &&
-			concatenationScope.isInsideReplacedRequire(dep.range[0])
-		) {
-			return;
-		}
-
 		const requireDep = dep.requireDependency;
-		// Skip when the paired call became `0`; dead-branch still needs the header.
 		if (requireDep) {
 			const connection = moduleGraph.getConnection(requireDep);
-			if (
-				connection &&
-				!connection.isTargetActive(runtime) &&
-				requireDep.isEvaluationOnly()
-			) {
-				const guards = requireDep.branchGuards;
-				if (
-					guards === undefined ||
-					!HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
-				) {
-					return;
+			if (connection) {
+				if (connection.isTargetActive(runtime)) {
+					if (
+						concatenationScope !== undefined &&
+						requireDep.rendersAsConcatenatedReference(
+							connection,
+							concatenationScope
+						)
+					) {
+						return;
+					}
+				} else if (requireDep.isEvaluationOnly()) {
+					// Skip when the paired call became `0`; dead-branch still needs the header.
+					const guards = requireDep.branchGuards;
+					if (
+						guards === undefined ||
+						!HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
+					) {
+						return;
+					}
 				}
 			}
 		}

package/lib/dependencies/SystemRuntimeModule.js

@@ -24,6 +24,15 @@ class SystemRuntimeModule 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/WorkerDependency.js

@@ -140,8 +140,7 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 			dep.options.publicPath,
 			chunk,
 			templateContext.module,
-			chunkGraph,
-			runtimeRequirements
+			chunkGraph
 		);
 
 		if (analyzableSpecifier !== null) {

package/lib/dependencies/WorkletDependency.js

@@ -144,8 +144,7 @@ WorkletDependency.Template = class WorkletDependencyTemplate extends (
 			dep.options.publicPath,
 			entryChunk,
 			module,
-			chunkGraph,
-			runtimeRequirements
+			chunkGraph
 		);
 		if (analyzableSpecifier !== null) {
 			source.replace(

package/lib/dependencies/importOptionsCheck.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const Template = require("../Template");
+
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+
+/**
+ * Wraps an import so its arguments evaluate in source order and the options are
+ * checked, rejecting rather than throwing. The last parameter holds them.
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {string[]} parameters parameter names, the options one last
+ * @param {string} content the import expression to return once the check passes
+ * @returns {string} the wrapping function
+ */
+const importOptionsCheck = (runtimeTemplate, parameters, content) => {
+	const options = parameters[parameters.length - 1];
+	return runtimeTemplate.basicFunction(parameters.join(", "), [
+		"try {",
+		Template.indent([
+			`if (${options} !== undefined) {`,
+			Template.indent([
+				`if ((typeof ${options} !== "object" && typeof ${options} !== "function") || ${options} === null) throw new TypeError("The second argument to import() must be an object");`,
+				`var a = ${options}["with"];`,
+				"if (a !== undefined) {",
+				Template.indent([
+					'if ((typeof a !== "object" && typeof a !== "function") || a === null) throw new TypeError("The \'with\' option must be an object");',
+					"for (var k = Object.keys(a), i = 0; i < k.length; i++) {",
+					Template.indent([
+						'if (typeof a[k[i]] !== "string") throw new TypeError("Import attribute values must be strings");'
+					]),
+					"}"
+				]),
+				"}"
+			]),
+			"}"
+		]),
+		"} catch (e) { return Promise.reject(e); }",
+		`return ${content};`
+	]);
+};
+
+module.exports = importOptionsCheck;

package/lib/dll/DelegatedModule.js

@@ -242,6 +242,7 @@ class DelegatedModule extends Module {
 	updateHash(hash, context) {
 		hash.update(this.delegationType);
 		hash.update(JSON.stringify(this.request));
+		hash.update(JSON.stringify(this.delegateData));
 		super.updateHash(hash, context);
 	}
 
@@ -299,7 +300,23 @@ class DelegatedModule extends Module {
 		this.delegationType = m.delegationType;
 		this.userRequest = m.userRequest;
 		this.originalRequest = m.originalRequest;
-		this.delegateData = m.delegateData;
+		const next = m.delegateData;
+		// cleanupForCache clears delegateData; compare surviving build products instead.
+		if (this.buildMeta) {
+			const nextMeta = { ...next.buildMeta };
+			const exportsDependency = this.dependencies[1];
+			const builtExports =
+				exportsDependency instanceof StaticExportsDependency
+					? exportsDependency.exports
+					: undefined;
+			if (
+				JSON.stringify(this.buildMeta) !== JSON.stringify(nextMeta) ||
+				JSON.stringify(builtExports) !== JSON.stringify(next.exports || true)
+			) {
+				this.buildMeta = undefined;
+			}
+		}
+		this.delegateData = next;
 	}
 
 	/**

package/lib/dll/DllReferencePlugin.js

@@ -8,7 +8,7 @@
 const ExternalModuleFactoryPlugin = require("../ExternalModuleFactoryPlugin");
 const DelegatedSourceDependency = require("../dependencies/DelegatedSourceDependency");
 const WebpackError = require("../errors/WebpackError");
-const { makePathsRelative } = require("../util/identifier");
+const { fileUrlToPath, makePathsRelative } = require("../util/identifier");
 const parseJson = require("../util/parseJson");
 const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
 
@@ -72,12 +72,13 @@ class DllReferencePlugin {
 			if ("manifest" in this.options) {
 				const manifest = this.options.manifest;
 				if (typeof manifest === "string") {
+					const manifestPath = fileUrlToPath(manifest);
 					/** @type {InputFileSystem} */
-					(compiler.inputFileSystem).readFile(manifest, (err, result) => {
+					(compiler.inputFileSystem).readFile(manifestPath, (err, result) => {
 						if (err) return callback(err);
 						/** @type {CompilationDataItem} */
 						const data = {
-							path: manifest,
+							path: manifestPath,
 							data: undefined,
 							error: undefined
 						};
@@ -93,13 +94,13 @@ class DllReferencePlugin {
 						} catch (parseErr) {
 							// Store the error in the params so that it can
 							// be added as a compilation error later on.
-							const manifestPath = makePathsRelative(
+							const relativePath = makePathsRelative(
 								compiler.context,
-								manifest,
+								manifestPath,
 								compiler.root
 							);
 							data.error = new DllManifestError(
-								manifestPath,
+								relativePath,
 								/** @type {Error} */ (parseErr).message
 							);
 						}
@@ -153,7 +154,9 @@ class DllReferencePlugin {
 				source,
 				type: this.options.type,
 				scope: this.options.scope,
-				context: this.options.context || compiler.context,
+				context: this.options.context
+					? fileUrlToPath(this.options.context)
+					: compiler.context,
 				content:
 					/** @type {DllReferencePluginOptionsContent} */
 					(resolvedContent),
@@ -176,7 +179,7 @@ class DllReferencePlugin {
 							/** @type {DllManifestError} */ (data.error)
 						);
 					}
-					compilation.fileDependencies.add(manifest);
+					compilation.fileDependencies.add(fileUrlToPath(manifest));
 				}
 			}
 		});

package/lib/dll/LibManifestPlugin.js

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const EntryDependency = require("../dependencies/EntryDependency");
 const { someInIterable } = require("../util/IterableHelpers");
+const asyncLib = require("../util/async");
 const { compareModulesById } = require("../util/comparators");
 const { dirname, mkdirp } = require("../util/fs");
 

package/lib/errors/AnalyzableBailoutsWarning.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} BailoutDetails
+ * @property {string} reason what keeps the runtime form, as the code generation recorded it
+ * @property {string[]} modules the modules it was recorded on, as many as are printed
+ * @property {number} count how many modules it was recorded on in all
+ */
+
+class AnalyzableBailoutsWarning extends WebpackError {
+	/**
+	 * Creates an instance of AnalyzableBailoutsWarning.
+	 * @param {BailoutDetails[]} bailouts the reasons found, the most frequent first
+	 * @param {number} references how many module and reason pairs there are
+	 */
+	constructor(bailouts, references) {
+		const list = bailouts
+			.map((it) => {
+				const more = it.count - it.modules.length;
+				const names = `${it.modules.join(", ")}${more > 0 ? `, and ${more} more` : ""}`;
+				return `\n  ${it.reason}\n    ${names}`;
+			})
+			.join("");
+
+		super(
+			`analyzable ESM output: ${references} ${references === 1 ? "reference keeps" : "references keep"} the runtime form:${list}\nA bundler reading this output cannot follow such a reference without running webpack's runtime. Each reason names the setting that keeps it; changing that setting lets the reference be written as a literal import() or new URL().\nFor more info visit https://webpack.js.org/configuration/output/#outputmodule`
+		);
+
+		/** @type {string} */
+		this.name = "AnalyzableBailoutsWarning";
+	}
+}
+
+module.exports = AnalyzableBailoutsWarning;

package/lib/errors/DotenvFileError.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * Error for a dotenv file that exists but could not be read. An absent file is
+ * normal and reported through `missingDependencies` instead.
+ */
+class DotenvFileError extends WebpackError {
+	/**
+	 * @param {string} file path of the dotenv file
+	 * @param {Error} error underlying file system error
+	 */
+	constructor(file, error) {
+		super(`Unable to read the dotenv file ${file}\n${error.message}`);
+
+		this.name = "DotenvFileError";
+		/** @type {string} */
+		this.file = file;
+		this.error = error;
+	}
+}
+
+module.exports = DotenvFileError;

package/lib/errors/DuplicateModulesWarning.js

@@ -12,6 +12,7 @@ const WebpackError = require("./WebpackError");
  * @typedef {object} DuplicateModuleDetails
  * @property {string} name
  * @property {number} chunks how many chunks carry a copy
+ * @property {string[]} entrypoints the entrypoints those chunks belong to, when more than one
  * @property {number} wasted bytes the extra copies cost
  */
 
@@ -23,18 +24,22 @@ class DuplicateModulesWarning extends WebpackError {
 	 */
 	constructor(modules, wasted) {
 		const list = modules
-			.map(
-				(module) =>
-					`\n  ${module.name} (in ${module.chunks} chunks, ${formatSize(
-						module.wasted
-					)} extra)`
-			)
+			.map((module) => {
+				// Which entrypoints pay for it is the actionable part, so it leads
+				// where the copies are spread across more than one.
+				const where =
+					module.entrypoints.length > 1
+						? `in ${module.entrypoints.join(", ")}, ${module.chunks} chunks`
+						: `in ${module.chunks} chunks`;
+
+				return `\n  ${module.name} (${where}, ${formatSize(module.wasted)} extra)`;
+			})
 			.join("");
 
 		super(
 			`duplicate modules: copies of the same module across chunks add ${formatSize(
 				wasted
-			)}:${list}\nA module reached from several chunks is emitted into each of them unless a shared chunk holds it. 'optimization.splitChunks' can pull it into one.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
+			)}:${list}\nA module reached from several chunks is emitted into each of them unless a shared chunk holds it. 'optimization.splitChunks' can pull it into one, with 'chunks: "all"' where the copies are in different entrypoints.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
 		);
 
 		/** @type {string} */

package/lib/errors/EmptyCopyPatternWarning.js

@@ -0,0 +1,26 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class EmptyCopyPatternWarning extends WebpackError {
+	/**
+	 * Creates an instance of EmptyCopyPatternWarning.
+	 * @param {string} from the `from` of the pattern as written in the configuration
+	 * @param {string} glob the glob `from` was resolved to
+	 */
+	constructor(from, glob) {
+		super(
+			`The '${from}' pattern of 'output.copy' copied no file.\nIt resolved to '${glob}', which matches nothing on disk — usually a typo, a path relative to the wrong directory, or a directory a previous build step was supposed to create.\nSilence it with 'ignoreWarnings' when the pattern is optional.`
+		);
+
+		/** @type {string} */
+		this.name = "EmptyCopyPatternWarning";
+	}
+}
+
+module.exports = EmptyCopyPatternWarning;

package/lib/errors/ExternalStarReexportError.js

@@ -0,0 +1,44 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @import ExternalModule from "../ExternalModule" */
+/** @import Module from "../Module" */
+
+/**
+ * Error raised when a `module` library reexports everything from an external
+ * whose request names a property path instead of a module.
+ */
+class ExternalStarReexportError extends WebpackError {
+	/**
+	 * Captures the external and the library entry reexporting from it.
+	 * @param {ExternalModule} externalModule the reexported external
+	 * @param {Module} module the library entry module
+	 */
+	constructor(externalModule, module) {
+		const request = /** @type {string[]} */ (
+			externalModule.getResolvedRequest()
+		);
+		super(
+			`Can't 'export * from ${JSON.stringify(
+				externalModule.userRequest
+			)}': the external is configured as ${JSON.stringify(
+				request
+			)}, which is a property of ${JSON.stringify(
+				request[0]
+			)} and has no module specifier to reexport. Reexport the names explicitly or configure the external without a property path.`
+		);
+
+		/** @type {string} */
+		this.name = "ExternalStarReexportError";
+		/** @type {Module} */
+		this.module = module;
+	}
+}
+
+module.exports = ExternalStarReexportError;

package/lib/errors/ImportedBindingAssignmentError.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const WebpackError = require("./WebpackError");
+
+class ImportedBindingAssignmentError extends WebpackError {
+	/**
+	 * Creates an instance of ImportedBindingAssignmentError.
+	 * @param {string} name the local name of the namespace binding
+	 */
+	constructor(name) {
+		super(
+			`Assignment to the imported binding '${name}'. A namespace import is immutable, so this throws a TypeError where the module is a real ES module.`
+		);
+
+		this.name = "ImportedBindingAssignmentError";
+	}
+}
+
+makeSerializable(
+	ImportedBindingAssignmentError,
+	"webpack/lib/errors/ImportedBindingAssignmentError"
+);
+
+module.exports = ImportedBindingAssignmentError;