webpack 5.110.3 → 5.111.0

package/lib/library/ModuleLibraryPlugin.js

@@ -14,9 +14,11 @@ const Template = require("../Template");
 const HarmonyExportExpressionDependency = require("../dependencies/HarmonyExportExpressionDependency");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const HarmonyExportSpecifierDependency = require("../dependencies/HarmonyExportSpecifierDependency");
+const ExternalStarReexportError = require("../errors/ExternalStarReexportError");
 const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const { InlinedUsedName } = require("../optimize/InlineExports");
+const { toJsStringLiteral } = require("../util/identifier");
 const {
 	RESERVED_IDENTIFIER,
 	SAFE_IDENTIFIER,
@@ -44,6 +46,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * 	ModuleRenderContext
  * } from "../javascript/JavascriptModulesPlugin"
  */
+/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * @import {
@@ -122,6 +125,18 @@ const definesOnlyNativeExports = (module, moduleGraph) => {
 const toExportName = (name) =>
 	SAFE_IDENTIFIER.test(name) ? name : JSON.stringify(name);
 
+/**
+ * Renders the import attributes of a reexport in the syntax the author wrote,
+ * since a legacy `assert` clause and a `with` clause are not interchangeable.
+ * @param {ImportAttributes | undefined} attributes the import attributes
+ * @returns {string} the attributes clause, empty when there are none
+ */
+const toAttributesClause = (attributes) => {
+	if (!attributes) return "";
+	const { _isLegacyAssert: isLegacyAssert, ...values } = attributes;
+	return ` ${isLegacyAssert ? "assert" : "with"} ${JSON.stringify(values)}`;
+};
+
 /**
  * Whether the export name can also be used as the declared binding name.
  * @param {string} name export name
@@ -367,6 +382,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			}
 		}
+		this._checkStarReexportedExternals(module, compilation);
 		moduleGraph.addExtraReason(module, "used as library export");
 		let entries = libraryEntryModules.get(compilation);
 		if (entries === undefined) {
@@ -376,6 +392,61 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		entries.add(module);
 	}
 
+	/**
+	 * Reports every external the entry star-reexports whose request names a property
+	 * path, which `export *` has no way to reference.
+	 * @param {Module} module the library entry module
+	 * @param {Compilation} compilation the compilation
+	 * @returns {void}
+	 */
+	_checkStarReexportedExternals(module, compilation) {
+		const { moduleGraph } = compilation;
+		/** @type {Set<Module>} */
+		const visitedReexportModules = new Set([module]);
+		/** @type {Module[]} */
+		const queue = [module];
+		/** @type {Set<ExternalModule>} */
+		const unsupportedExternals = new Set();
+
+		for (const current of queue) {
+			for (const connection of moduleGraph.getOutgoingConnections(current)) {
+				const dep = connection.dependency;
+
+				// Only handle star-reexport statement
+				if (
+					!(dep instanceof HarmonyExportImportedSpecifierDependency) ||
+					dep.name !== null
+				) {
+					continue;
+				}
+				const importedModule = connection.resolvedModule;
+
+				// Only a module providing unknown exports keeps its reexport rendered
+				if (
+					moduleGraph.getExportsInfo(importedModule)._otherExportsInfo
+						.provided !== null
+				) {
+					continue;
+				}
+				if (importedModule instanceof ExternalModule) {
+					const request = importedModule.getResolvedRequest();
+					if (Array.isArray(request) && request.length > 1) {
+						unsupportedExternals.add(importedModule);
+					}
+				} else if (!visitedReexportModules.has(importedModule)) {
+					visitedReexportModules.add(importedModule);
+					queue.push(importedModule);
+				}
+			}
+		}
+
+		for (const externalModule of unsupportedExternals) {
+			compilation.errors.push(
+				new ExternalStarReexportError(externalModule, module)
+			);
+		}
+	}
+
 	/**
 	 * Returns preprocess as needed by overriding.
 	 * @param {LibraryOptions} library normalized library option
@@ -415,14 +486,17 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	) {
 		const result = new ConcatSource(source);
 		/** @type {Set<string>} */
-		const moduleRequests = new Set();
+		const externalReexports = new Set();
 		/** @type {Map<string, string | InlinedUsedName>} */
 		const unknownProvidedExports = new Map();
+		/** @type {Set<Module>} */
+		const visitedReexportModules = new Set();
 
 		/**
 		 * Resolves dynamic star reexport.
 		 * @param {Module} module the module
 		 * @param {boolean} isDynamicReexport if module is dynamic reexported
+		 * @returns {void}
 		 */
 		const resolveDynamicStarReexport = (module, isDynamicReexport) => {
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
@@ -445,8 +519,22 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					) {
 						// Handle export * from 'external'
 						if (importedModule instanceof ExternalModule) {
-							moduleRequests.add(importedModule.userRequest);
-						} else {
+							const request = importedModule.getResolvedRequest();
+							// A property path is reported by `_checkStarReexportedExternals`,
+							// and an absent one by the external's own build
+							const specifier =
+								typeof request === "string"
+									? request
+									: Array.isArray(request) && request.length === 1
+										? request[0]
+										: undefined;
+							if (specifier !== undefined) {
+								externalReexports.add(
+									`export * from ${toJsStringLiteral(specifier)}${toAttributesClause(dep.attributes)};\n`
+								);
+							}
+						} else if (!visitedReexportModules.has(importedModule)) {
+							visitedReexportModules.add(importedModule);
 							resolveDynamicStarReexport(importedModule, true);
 						}
 					}
@@ -473,8 +561,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 		resolveDynamicStarReexport(module, false);
 
-		for (const request of moduleRequests) {
-			result.add(`export * from "${request}";\n`);
+		for (const reexport of externalReexports) {
+			result.add(reexport);
 		}
 
 		for (const [origin, used] of unknownProvidedExports) {
@@ -648,6 +736,29 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			}
 
+			const externalTarget = exportInfo.getTarget(moduleGraph);
+			if (
+				externalTarget &&
+				externalTarget.module instanceof ExternalModule &&
+				externalTarget.export &&
+				externalTarget.export.length === 1 &&
+				codeGenerationResults.has(externalTarget.module, chunk.runtime)
+			) {
+				const reexport = codeGenerationResults.getData(
+					externalTarget.module,
+					chunk.runtime,
+					"externalReexport"
+				);
+				if (reexport) {
+					if (!bindingsTakenOver) needExportsDeclaration = true;
+					result.add(
+						`export { ${toExportName(externalTarget.export[0])} as ${toExportName(originalName)} } ${reexport};\n`
+					);
+					alreadyRenderedExports.add(originalName);
+					continue;
+				}
+			}
+
 			// The exports of entry module are never inlined
 			const usedName =
 				/** @type {string} */

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -32,6 +32,28 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		this.runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * 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() {
+		const runtimeRequirements = this.runtimeRequirements;
+		/** @type {[string, string][]} */
+		const handlers = [];
+		if (runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "readFileVm"]);
+		}
+		// The hot update flow installs this one onto the same map while it runs.
+		if (runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "readFileVmHmr"]);
+		}
+		if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+			handlers.push([RuntimeGlobals.onChunksLoaded, "readFileVm"]);
+		}
+		return handlers;
+	}
+
 	/**
 	 * Returns generated code.
 	 * @private

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -32,6 +32,28 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 		this.runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * 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() {
+		const runtimeRequirements = this.runtimeRequirements;
+		/** @type {[string, string][]} */
+		const handlers = [];
+		if (runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "require"]);
+		}
+		// The hot update flow installs this one onto the same map while it runs.
+		if (runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "requireHmr"]);
+		}
+		if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+			handlers.push([RuntimeGlobals.onChunksLoaded, "require"]);
+		}
+		return handlers;
+	}
+
 	/**
 	 * Returns generated code.
 	 * @private

package/lib/optimize/ConcatenatedModule.js

@@ -34,11 +34,13 @@ const analyzeScope = require("../javascript/ScopeAnalyzer");
 const {
 	getDeferredCycleModuleIds,
 	getDeferredCycleModules,
+	getKnownExportNames,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("../util/ArrayHelpers");
 const LazySet = require("../util/LazySet");
+const { getBuildDiagnostics } = require("../util/buildDiagnostics");
 const {
 	compareModulesByFullName,
 	concatComparators
@@ -116,8 +118,7 @@ const { InlinedUsedName } = require("./InlineExports");
  * @import {
  * 	ChunkRenderContext,
  * 	Scope,
- * 	Reference,
- * 	Variable
+ * 	Reference
  * } from "../javascript/JavascriptModulesPlugin"
  */
 /** @import { Range } from "../javascript/JavascriptParser" */
@@ -247,6 +248,7 @@ const findIdentifiers = (source) => {
  * @property {boolean} deferred the module is deferred at least once
  * @property {boolean} deferredNamespaceObjectUsed deferred namespace object that being used in a not-analyzable way so it must be materialized
  * @property {string | undefined} deferredNamespaceObjectName deferred namespace object that being used in a not-analyzable way so it must be materialized
+ * @property {boolean} specNamespaceObjectUsed an import reads the spec namespace object the module hands out
  * @property {boolean} interopNamespaceObjectUsed "default-with-named" namespace
  * @property {string | undefined} interopNamespaceObjectName "default-with-named" namespace
  * @property {boolean} interopNamespaceObject2Used "default-only" namespace
@@ -423,13 +425,26 @@ const getInteropExpr = (info, interopName) =>
  * slot, but a wrapped one only runs when its accessor is called, so dropping
  * the reference would drop the module's side effects with it.
  * @param {ConcatenatedModuleInfo} info module info
+ * @param {boolean | undefined} asiSafe asiSafe
  * @returns {string} expression evaluating to undefined
  */
-const getUnusedExportExpr = (info) =>
+const getUnusedExportExpr = (info, asiSafe) =>
 	info.wrapped
-		? `/* unused export */ (${info.namespaceObjectName}, undefined)`
+		? `${asiSafe === false ? ";" : ""}/* unused export */ (${info.namespaceObjectName}, undefined)`
 		: "/* unused export */ undefined";
 
+/**
+ * Parenthesizes a reference that may already carry an ASI guard of its own,
+ * keeping that guard outside the new parentheses — nested it would not parse.
+ * @param {string} reference the reference
+ * @param {boolean | undefined} asiSafe asiSafe
+ * @returns {string} the parenthesized reference
+ */
+const parenthesizeReference = (reference, asiSafe) =>
+	asiSafe === false
+		? `;(${reference.startsWith(";") ? reference.slice(1) : reference})`
+		: `(${reference})`;
+
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {ModuleInfo} info module info
@@ -484,7 +499,7 @@ const getFinalBinding = (
 		if (!usedName) {
 			return {
 				info,
-				rawName: getUnusedExportExpr(info),
+				rawName: getUnusedExportExpr(info, asiSafe),
 				ids: [],
 				exportName
 			};
@@ -667,7 +682,7 @@ const getFinalBinding = (
 					exportName,
 					accessorCall: info.wrapped
 				};
-			case "external":
+			case "external": {
 				if (deferred) {
 					info.deferredNamespaceObjectUsed = true;
 					return {
@@ -677,13 +692,30 @@ const getFinalBinding = (
 						exportName
 					};
 				}
+
+				// `require()` reads the exports object rather than a namespace, so
+				// only an import gets the spec object and interop keeps working.
+				const spec =
+					!moduleExportsAccess &&
+					exportsType === "namespace" &&
+					Boolean(
+						/** @type {BuildInfo} */
+						(info.module.buildInfo).specNamespaceObject
+					);
+				const rawName = getExternalModuleExpr(info);
+
+				if (spec) info.specNamespaceObjectUsed = true;
+
 				return {
 					info,
-					rawName: getExternalModuleExpr(info),
+					rawName: spec
+						? `${RuntimeGlobals.specNamespaceObject}(${rawName})`
+						: rawName,
 					ids: exportName,
 					exportName,
-					accessorCall: info.wrapped
+					accessorCall: spec || info.wrapped
 				};
+			}
 		}
 	}
 	const exportsInfo = moduleGraph.getExportsInfo(info.module);
@@ -981,12 +1013,12 @@ const getFinalName = (
 						? `;(0,${reference})`
 						: `/*#__PURE__*/Object(${reference})`;
 			} else if (binding.info.wrapped) {
-				return asiSafe === false ? `;(${reference})` : `(${reference})`;
+				return parenthesizeReference(reference, asiSafe);
 			}
 		} else if (accessorCall && !asCall) {
 			// without parentheses `new X()` would construct the accessor rather
 			// than what it returns
-			return asiSafe === false ? `;(${reference})` : `(${reference})`;
+			return parenthesizeReference(reference, asiSafe);
 		}
 
 		return reference;
@@ -1183,15 +1215,17 @@ class ConcatenatedModule extends Module {
 
 		for (const m of this._modules) {
 			// populate cacheable
-			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
-				m.buildInfo
-			);
+			const { cacheable, diagnostics } = /** @type {BuildInfo} */ (m.buildInfo);
 			if (!cacheable) {
 				this.buildInfo.cacheable = false;
+				const notCacheableReasons =
+					diagnostics === undefined
+						? undefined
+						: diagnostics.notCacheableReasons;
 				if (notCacheableReasons) {
+					const own = getBuildDiagnostics(this.buildInfo);
 					const reasons =
-						this.buildInfo.notCacheableReasons ||
-						(this.buildInfo.notCacheableReasons = []);
+						own.notCacheableReasons || (own.notCacheableReasons = []);
 					for (const reason of notCacheableReasons) {
 						if (!reasons.includes(reason)) reasons.push(reason);
 					}
@@ -1821,6 +1855,15 @@ class ConcatenatedModule extends Module {
 				return info.escapeNamespaceObjectName;
 			}
 			const exportsInfo = moduleGraph.getExportsInfo(info.module);
+			// Its names are not mangled, and the wrapped binding is already the
+			// namespace, so a decoupled object would only shadow it.
+			if (
+				/** @type {BuildInfo} */
+				(info.module.buildInfo).specNamespaceObject
+			) {
+				return undefined;
+			}
+
 			let mangled = false;
 			for (const exportInfo of exportsInfo.orderedExports) {
 				if (exportInfo.provided === false) continue;
@@ -2719,10 +2762,18 @@ ${defineGetters}`
 					runtimeRequirements
 				});
 				const moduleId = JSON.stringify(chunkGraph.getModuleId(info.module));
+				const required = `${RuntimeGlobals.require}(${moduleId})`;
+
+				// The wrapping happens per reference, so only the helper has to be
+				// declared here.
+				if (info.specNamespaceObjectUsed) {
+					runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+				}
+
 				const body =
 					condition === "true"
-						? `return ${RuntimeGlobals.require}(${moduleId});`
-						: `if (${condition}) return ${RuntimeGlobals.require}(${moduleId});`;
+						? `return ${required};`
+						: `if (${condition}) return ${required};`;
 				result.add(
 					`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
 						requestShortener
@@ -2778,14 +2829,31 @@ ${defineGetters}`
 				);
 				if (info.deferredNamespaceObjectUsed) {
 					runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
+					// Every call site for a module must agree on the shape, since the
+					// runtime caches one namespace object per module and mode.
+					const deferredExportsType = getExportsType(
+						moduleGraph,
+						info,
+						strictHarmonyModule
+					);
+					const names = getKnownExportNames(
+						moduleGraph,
+						info.module,
+						deferredExportsType
+					);
+					runtimeRequirements.add(
+						names
+							? RuntimeGlobals.hasSealedDeferredNamespace
+							: RuntimeGlobals.hasSynthesizedDeferredNamespace
+					);
 					result.add(
 						`\nvar ${info.deferredNamespaceObjectName} = /*#__PURE__*/${
 							RuntimeGlobals.makeDeferredNamespaceObject
 						}(${JSON.stringify(
 							chunkGraph.getModuleId(info.module)
 						)}, ${getMakeDeferredNamespaceModeFromExportsType(
-							getExportsType(moduleGraph, info, strictHarmonyModule)
-						)});`
+							deferredExportsType
+						)}${names ? `, ${JSON.stringify(names)}` : ""});`
 					);
 				}
 			}
@@ -2871,7 +2939,15 @@ ${defineGetters}`
 						// External module bindings may be wrapped in
 						// runtime-condition `if` blocks but referenced outside,
 						// so they must remain function-scoped (`var`).
-						result.add(`var ${info.name} = __webpack_require__(${moduleId});`);
+						const required = `__webpack_require__(${moduleId})`;
+
+						// The wrapping happens per reference, so only the helper has
+						// to be declared here.
+						if (info.specNamespaceObjectUsed) {
+							runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+						}
+
+						result.add(`var ${info.name} = ${required};`);
 
 						// Decoupled namespace object for an escaping mangled external
 						// module must come after its import variable is defined.
@@ -3179,6 +3255,7 @@ ${defineGetters}`
 							namespaceFnName: undefined,
 							escapeNamespaceObjectName: undefined,
 							deferredName: undefined,
+							specNamespaceObjectUsed: false,
 							interopNamespaceObjectUsed: false,
 							interopNamespaceObjectName: undefined,
 							interopNamespaceObject2Used: false,

package/lib/optimize/ConstExportsPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const CircularModulesPlugin = require("../CircularModulesPlugin");
 const { UsageState } = require("../ExportsInfo");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
@@ -15,10 +16,11 @@ const { VariableInfoFlags } = require("../javascript/JavascriptParser");
 const {
 	InlinedUsedName,
 	enableInlineExports,
-	findModulesInCycles,
 	toInlinedValue
 } = require("./InlineExports");
 
+const { CircularKind } = CircularModulesPlugin;
+
 /** @import { InlinedValue } from "./InlineExports" */
 /** @import Compiler from "../Compiler" */
 /** @import ExportsInfo from "../ExportsInfo" */
@@ -162,54 +164,63 @@ class ConstExportsPlugin {
 				enableInlineExports(compilation.moduleGraph);
 
 				const moduleGraph = compilation.moduleGraph;
-				compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, (modules) => {
-					// A cycle peer may read an export during its temporal dead zone,
-					// where the binding must throw and a literal would answer.
-					const inCycle = findModulesInCycles(moduleGraph, modules);
-					/** @type {Set<ExportsInfo>} */
-					const visited = new Set();
-					/** @type {ExportsInfo[]} */
-					let queue = [];
-					for (const module of modules) {
-						if (inCycle.has(module)) continue;
-						queue.push(moduleGraph.getExportsInfo(module));
-					}
-					while (queue.length > 0) {
-						const items = queue;
-						queue = [];
-						for (const exportsInfo of items) {
-							if (visited.has(exportsInfo)) continue;
-							visited.add(exportsInfo);
-							// Other-export usage means we can't safely inline (some non-statically-known consumer)
+				// After CircularModulesPlugin (STAGE_DETECT): needs Binding kind flags.
+				compilation.hooks.optimizeDependencies.tap(
+					{
+						name: PLUGIN_NAME,
+						stage: CircularModulesPlugin.STAGE_DETECT + 1
+					},
+					(modules) => {
+						/** @type {Set<ExportsInfo>} */
+						const visited = new Set();
+						/** @type {ExportsInfo[]} */
+						let queue = [];
+						for (const module of modules) {
+							// Binding-observable cycle peers must keep TDZ live bindings.
 							if (
-								exportsInfo.otherExportsInfo.getUsed(undefined) !==
-								UsageState.Unused
+								CircularModulesPlugin.isCircular(module, CircularKind.Binding)
 							) {
 								continue;
 							}
-							for (const exportInfo of exportsInfo.ownedExports) {
-								const inlined = exportInfo.canInline();
-								const doInline =
-									!exportInfo.hasUsedName() &&
-									inlined !== undefined &&
-									exportInfo.provided === true;
-								if (doInline) {
-									exportInfo.setUsedName(new InlinedUsedName(inlined));
-									exportsInfo.markInlinedExports();
+							queue.push(moduleGraph.getExportsInfo(module));
+						}
+						while (queue.length > 0) {
+							const items = queue;
+							queue = [];
+							for (const exportsInfo of items) {
+								if (visited.has(exportsInfo)) continue;
+								visited.add(exportsInfo);
+								// Other-export usage means we can't safely inline (some non-statically-known consumer)
+								if (
+									exportsInfo.otherExportsInfo.getUsed(undefined) !==
+									UsageState.Unused
+								) {
+									continue;
 								}
-								if (exportInfo.exportsInfoOwned && exportInfo.exportsInfo) {
-									const used = exportInfo.getUsed(undefined);
-									if (
-										used === UsageState.OnlyPropertiesUsed ||
-										used === UsageState.Unused
-									) {
-										queue.push(exportInfo.exportsInfo);
+								for (const exportInfo of exportsInfo.ownedExports) {
+									const inlined = exportInfo.canInline();
+									const doInline =
+										!exportInfo.hasUsedName() &&
+										inlined !== undefined &&
+										exportInfo.provided === true;
+									if (doInline) {
+										exportInfo.setUsedName(new InlinedUsedName(inlined));
+										exportsInfo.markInlinedExports();
+									}
+									if (exportInfo.exportsInfoOwned && exportInfo.exportsInfo) {
+										const used = exportInfo.getUsed(undefined);
+										if (
+											used === UsageState.OnlyPropertiesUsed ||
+											used === UsageState.Unused
+										) {
+											queue.push(exportInfo.exportsInfo);
+										}
 									}
 								}
 							}
 						}
 					}
-				});
+				);
 			}
 		);
 	}