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

package/lib/ExternalModule.js

@@ -25,55 +25,75 @@ const WebpackError = require("./WebpackError");
 const { DEFAULTS } = require("./config/defaults");
 const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const StaticExportsDependency = require("./dependencies/StaticExportsDependency");
-const EnvironmentNotSupportAsyncWarning = require("./errors/EnvironmentNotSupportAsyncWarning");
 const { coreModules } = require("./node/nodeBuiltins");
 const createHash = require("./util/createHash");
 const createHooksRegistry = require("./util/createHooksRegistry");
 const extractUrlAndGlobal = require("./util/extractUrlAndGlobal");
 const makeSerializable = require("./util/makeSerializable");
+const memoize = require("./util/memoize");
 const { propertyAccess } = require("./util/property");
 const { register } = require("./util/serialization");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").ExternalsType} ExternalsType */
-/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
-/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Compilation").UnsafeCacheData} UnsafeCacheData */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./Generator").GenerateContext} GenerateContext */
-/** @typedef {import("./Generator").SourceTypes} SourceTypes */
-/** @typedef {import("./Module").ModuleId} ModuleId */
-/** @typedef {import("./Module").BuildCallback} BuildCallback */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */
-/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").LibIdent} LibIdent */
-/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
-/** @typedef {import("./Module").Sources} Sources */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
-/** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
-/** @typedef {import("../declarations/WebpackOptions").ExternalItemInterop} ExternalInterop */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined, ExternalInterop | undefined]>} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined, ExternalInterop | undefined]>} ObjectSerializerContext */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+const getEnvironmentNotSupportAsyncWarning = memoize(() =>
+	require("./errors/EnvironmentNotSupportAsyncWarning")
+);
+
+/** @import { Source } from "webpack-sources" */
+/**
+ * @import {
+ * 	ExternalsType,
+ * 	HashFunction,
+ * 	ExternalItemInterop as ExternalInterop
+ * } from "../declarations/WebpackOptions"
+ */
+/**
+ * @import {
+ * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
+ * } from "./config/defaults"
+ */
+/** @import Chunk from "./Chunk" */
+/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
+/** @import Compilation, { UnsafeCacheData } from "./Compilation" */
+/** @import { UpdateHashContext } from "./Dependency" */
+/** @import ExportsInfo from "./ExportsInfo" */
+/** @import { GenerateContext } from "./Generator" */
+/**
+ * @import {
+ * 	BuildMeta,
+ * 	BuildCallback,
+ * 	BuildInfo,
+ * 	CodeGenerationContext,
+ * 	CodeGenerationResult,
+ * 	CodeGenerationResultData,
+ * 	ConcatenationBailoutReasonContext,
+ * 	LibIdentOptions,
+ * 	LibIdent,
+ * 	NeedBuildCallback,
+ * 	NeedBuildContext,
+ * 	RuntimeRequirements,
+ * 	ReadOnlyRuntimeRequirements,
+ * 	Sources,
+ * 	SourceTypes
+ * } from "./Module"
+ */
+/** @import ModuleGraph from "./ModuleGraph" */
+/** @import { ConnectionState } from "./ModuleGraphConnection" */
+/** @import NormalModuleFactory from "./NormalModuleFactory" */
+/** @import RequestShortener from "./RequestShortener" */
+/** @import { ResolverWithOptions } from "./ResolverFactory" */
+/** @import RuntimeTemplate from "./RuntimeTemplate" */
+/**
+ * @import {
+ * 	ChunkRenderContext
+ * } from "./javascript/JavascriptModulesPlugin"
+ */
+/** @import { ImportAttributes } from "./javascript/JavascriptParser" */
+/** @import { ImportPhaseType } from "./dependencies/ImportPhase" */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined, ExternalInterop | undefined, boolean | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined, ExternalInterop | undefined, boolean | undefined]>} ObjectSerializerContext */
+/** @import Hash from "./util/Hash" */
+/** @import { InputFileSystem } from "./util/fs" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 /** @typedef {{ attributes?: ImportAttributes, phase?: ImportPhaseType, externalType: "import" | "module" | undefined }} ImportDependencyMeta */
 /** @typedef {{ layer?: string, supports?: string, media?: string }} CssImportDependencyMeta */
@@ -277,6 +297,32 @@ const getSourceForCommonJsExternalInNodeModule = (
 	};
 };
 
+/**
+ * A phase is syntax the target has to read, with no form to fall back to. Reported
+ * like the `import()` check beside it, so the build fails rather than the bundle.
+ * @param {ImportPhaseType | undefined} phase the phase the reference asks for
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {void}
+ */
+const checkPhaseIsSupported = (phase, runtimeTemplate) => {
+	if (
+		ImportPhaseUtils.isDefer(phase) &&
+		!runtimeTemplate.supportsDeferImport()
+	) {
+		throw new Error(
+			"The target environment doesn't support 'import defer', so an external cannot be imported in the defer phase. Set 'output.environment.deferImport' when the target reads it."
+		);
+	}
+	if (
+		ImportPhaseUtils.isSource(phase) &&
+		!runtimeTemplate.supportsSourceImport()
+	) {
+		throw new Error(
+			"The target environment doesn't support 'import source', so an external cannot be imported in the source phase. Set 'output.environment.sourceImport' when the target reads it."
+		);
+	}
+};
+
 /**
  * Gets source for import external.
  * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
@@ -299,15 +345,24 @@ const getSourceForImportExternal = (
 		);
 	}
 	const phase = dependencyMeta && dependencyMeta.phase;
+	checkPhaseIsSupported(phase, runtimeTemplate);
 	// `import.defer(…)` and `import.source(…)` are only valid forms of the
 	// native `import(…)` function, so we only emit the phase suffix when the
-	// importFunctionName is the default `"import"`.
-	const importName =
-		baseImportName === "import" && ImportPhaseUtils.isDefer(phase)
-			? "import.defer"
-			: baseImportName === "import" && ImportPhaseUtils.isSource(phase)
-				? "import.source"
-				: baseImportName;
+	// importFunctionName is the default `"import"`. Anything else has no phase
+	// form at all, and dropping it would silently import eagerly instead.
+	if (
+		baseImportName !== "import" &&
+		(ImportPhaseUtils.isDefer(phase) || ImportPhaseUtils.isSource(phase))
+	) {
+		throw new Error(
+			`'import.defer' and 'import.source' are forms of the native 'import()', so an external cannot be imported in a phase while 'output.importFunctionName' is '${baseImportName}'`
+		);
+	}
+	const importName = ImportPhaseUtils.isDefer(phase)
+		? "import.defer"
+		: ImportPhaseUtils.isSource(phase)
+			? "import.source"
+			: baseImportName;
 	const attributes =
 		dependencyMeta && dependencyMeta.attributes
 			? dependencyMeta.attributes._isLegacyAssert
@@ -317,18 +372,24 @@ const getSourceForImportExternal = (
 					)} }`
 				: `, { with: ${JSON.stringify(dependencyMeta.attributes)} }`
 			: "";
+	// `import.source(…)` resolves to the source object itself, while every other
+	// external here resolves to a namespace. Consumers unwrap `default` to reach a
+	// source, so hand them that shape rather than a value they read `default` off.
+	const asNamespace = ImportPhaseUtils.isSource(phase)
+		? `.then(${runtimeTemplate.returningFunction('{ "default": m }', "m")})`
+		: "";
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
 			expression: `${importName}(${JSON.stringify(
 				moduleAndSpecifiers
-			)}${attributes});`
+			)}${attributes})${asNamespace};`
 		};
 	}
 	if (moduleAndSpecifiers.length === 1) {
 		return {
 			expression: `${importName}(${JSON.stringify(
 				moduleAndSpecifiers[0]
-			)}${attributes});`
+			)}${attributes})${asNamespace};`
 		};
 	}
 	const moduleName = moduleAndSpecifiers[0];
@@ -384,6 +445,14 @@ class ModuleExternalInitFragment extends InitFragment {
 					.digest("hex")
 					.slice(0, 8)}`;
 			}
+			// One request in two phases is two imports, so the phase must reach the dedupe
+			// key and the binding name — otherwise one silently replaces the other.
+			const phase = dependencyMeta && dependencyMeta.phase;
+			if (ImportPhaseUtils.isDefer(phase)) {
+				ident += "_defer";
+			} else if (ImportPhaseUtils.isSource(phase)) {
+				ident += "_source";
+			}
 		}
 
 		super(
@@ -444,8 +513,15 @@ class ModuleExternalInitFragment extends InitFragment {
 					: ` with ${JSON.stringify(dependencyMeta.attributes)}`
 				: "";
 		const phase = dependencyMeta && dependencyMeta.phase;
+		checkPhaseIsSupported(phase, context.runtimeTemplate);
 		let content = "";
-		if (imported === true) {
+		if (ImportPhaseUtils.isSource(phase) && imported === true) {
+			// There is no `import source * as ns` form: the source phase binds one
+			// identifier, so it stands in for the namespace the other branches build.
+			content = `import source ${identifier} from ${JSON.stringify(
+				request
+			)}${attributes};\n`;
+		} else if (imported === true) {
 			// namespace
 			const phaseKeyword = ImportPhaseUtils.isDefer(phase) ? "defer " : "";
 			content = `import ${phaseKeyword}* as ${identifier} from ${JSON.stringify(
@@ -621,6 +697,16 @@ const getSourceForModuleExternal = (
 		imported = true;
 	}
 
+	// A source phase binds `default` alone. With nothing used the list would be empty
+	// and emit `import "…"`, evaluating the module whose source was asked for instead.
+	if (
+		ImportPhaseUtils.isSource(phase) &&
+		Array.isArray(imported) &&
+		imported.length === 0
+	) {
+		imported = [["default", "default"]];
+	}
+
 	const initFragment = new ModuleExternalInitFragment(
 		moduleAndSpecifiers[0],
 		imported,
@@ -636,7 +722,9 @@ const getSourceForModuleExternal = (
 	)}`;
 	let expression = baseAccess;
 
-	const useNamespace = imported === true;
+	// A source-phase binding is not a namespace object, so nothing about it can be
+	// remapped export by export — the binding itself is what the reference reads.
+	const useNamespace = imported === true && !ImportPhaseUtils.isSource(phase);
 	/** @type {undefined | string} */
 	let moduleRemapping;
 	if (useNamespace) {
@@ -653,7 +741,9 @@ const getSourceForModuleExternal = (
 		init: moduleRemapping
 			? `${runtimeTemplate.renderConst()} x = ${runtimeTemplate.basicFunction(
 					"y",
-					`${runtimeTemplate.renderConst()} x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x`
+					`${runtimeTemplate.renderConst()} x = {}; ${
+						RuntimeGlobals.definePropertyGetters
+					}(x, y); return x`
 				)} \n${runtimeTemplate.renderConst()} y = ${runtimeTemplate.returningFunction(
 					runtimeTemplate.returningFunction("x"),
 					"x"
@@ -810,10 +900,16 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
 /** @typedef {Record<string, string | string[]>} RequestRecord */
 /** @typedef {string | string[] | RequestRecord} ExternalModuleRequest */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncBailHook<[Chunk, Compilation], boolean>}
+	 * @since 5.106.0
+	 */
+	chunkCondition: new SyncBailHook(["chunk", "compilation"])
+});
+
 /**
- * Defines the external module hooks type used by this module.
- * @typedef {object} ExternalModuleHooks
- * @property {SyncBailHook<[Chunk, Compilation], boolean>} chunkCondition
+ * @typedef {ReturnType<typeof createCompilationHooks>} ExternalModuleHooks
  */
 
 /**
@@ -832,8 +928,16 @@ class ExternalModule extends Module {
 	 * @param {string} userRequest user request
 	 * @param {DependencyMeta=} dependencyMeta dependency meta
 	 * @param {ExternalInterop=} interop how the external's exports interoperate with ES module imports
+	 * @param {boolean=} sideEffects whether importing the external has side effects (undefined = assume it has)
 	 */
-	constructor(request, type, userRequest, dependencyMeta, interop) {
+	constructor(
+		request,
+		type,
+		userRequest,
+		dependencyMeta,
+		interop,
+		sideEffects
+	) {
 		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
 
 		// Redeclared with the external module specific shape
@@ -851,6 +955,11 @@ class ExternalModule extends Module {
 		this.dependencyMeta = dependencyMeta;
 		/** @type {ExternalInterop | undefined} interop shape of the external's exports (undefined = importer-driven default) */
 		this.interop = interop;
+		/** @type {boolean | undefined} declared side-effects state (undefined = assume side effects, webpack can't analyze an external) */
+		this.sideEffects = sideEffects;
+		if (sideEffects !== undefined) {
+			this.factoryMeta = { sideEffectFree: !sideEffects };
+		}
 	}
 
 	/**
@@ -858,17 +967,14 @@ class ExternalModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		if (this.externalType === "asset" && this.dependencyMeta) {
-			const sourceType =
-				/** @type {AssetDependencyMeta} */
-				(this.dependencyMeta).sourceType;
-			// TODO webpack 6 drop "css-url" once the alias is removed
-			if (sourceType === ASSET_URL_TYPE || sourceType === "css-url") {
-				return ASSET_URL_TYPES;
-			}
-		} else if (this.externalType === "css-import") {
-			return CSS_IMPORT_TYPES;
+		// resolved, so a type rendering no javascript is never reported as a
+		// javascript module — that would emit a dead `false` factory in the chunk
+		const type = this._resolveExternalType(this.externalType);
+		// TODO webpack 6 drop "css-url" once the alias is removed
+		if (type === ASSET_URL_TYPE || type === "css-url") {
+			return ASSET_URL_TYPES;
 		}
+		if (type === "css-import") return CSS_IMPORT_TYPES;
 
 		return JAVASCRIPT_TYPES;
 	}
@@ -903,6 +1009,19 @@ class ExternalModule extends Module {
 		return compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0;
 	}
 
+	/**
+	 * Gets side effects connection state.
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
+	 */
+	getSideEffectsConnectionState(moduleGraph) {
+		if (this.factoryMeta !== undefined) {
+			if (this.factoryMeta.sideEffectFree) return false;
+			if (this.factoryMeta.sideEffectFree === false) return true;
+		}
+		return true;
+	}
+
 	/**
 	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
@@ -923,6 +1042,11 @@ class ExternalModule extends Module {
 			}
 		}
 		if (this.interop) id += `|interop=${this.interop}`;
+		// two externals for the same target with a different side-effects state
+		// must not be merged into one module
+		if (this.sideEffects !== undefined) {
+			id += `|sideEffects=${this.sideEffects}`;
+		}
 		return id;
 	}
 
@@ -1008,7 +1132,7 @@ class ExternalModule extends Module {
 					}
 				} else {
 					this.buildMeta.async = true;
-					EnvironmentNotSupportAsyncWarning.check(
+					getEnvironmentNotSupportAsyncWarning().check(
 						this,
 						compilation.runtimeTemplate,
 						"external module"
@@ -1021,7 +1145,7 @@ class ExternalModule extends Module {
 				break;
 			case "script":
 				this.buildMeta.async = true;
-				EnvironmentNotSupportAsyncWarning.check(
+				getEnvironmentNotSupportAsyncWarning().check(
 					this,
 					compilation.runtimeTemplate,
 					"external script"
@@ -1029,7 +1153,7 @@ class ExternalModule extends Module {
 				break;
 			case "promise":
 				this.buildMeta.async = true;
-				EnvironmentNotSupportAsyncWarning.check(
+				getEnvironmentNotSupportAsyncWarning().check(
 					this,
 					compilation.runtimeTemplate,
 					"external promise"
@@ -1037,7 +1161,7 @@ class ExternalModule extends Module {
 				break;
 			case "amd-async":
 				this.buildMeta.async = true;
-				EnvironmentNotSupportAsyncWarning.check(
+				getEnvironmentNotSupportAsyncWarning().check(
 					this,
 					compilation.runtimeTemplate,
 					"external amd-async"
@@ -1045,7 +1169,7 @@ class ExternalModule extends Module {
 				break;
 			case "import":
 				this.buildMeta.async = true;
-				EnvironmentNotSupportAsyncWarning.check(
+				getEnvironmentNotSupportAsyncWarning().check(
 					this,
 					compilation.runtimeTemplate,
 					"external import"
@@ -1101,6 +1225,19 @@ class ExternalModule extends Module {
 		return undefined;
 	}
 
+	/**
+	 * @returns {boolean} true, when it may be wrapped
+	 */
+	canBeWrappedInConcatenation() {
+		if (/** @type {BuildMeta} */ (this.buildMeta).async) {
+			return false;
+		}
+		// every other synchronous type is a plain expression; only "module"
+		// renders as a hoisted `import` declaration, and passing it the
+		// concatenation scope is what narrows it to named specifiers
+		return this._resolveExternalType(this.externalType) !== "module";
+	}
+
 	/**
 	 * Get request and external type.
 	 * @private
@@ -1132,7 +1269,14 @@ class ExternalModule extends Module {
 					.externalType;
 			}
 			return "module";
-		} else if (externalType === "asset") {
+		} else if (
+			// TODO webpack 6 drop "css-url" once the alias is removed
+			externalType === "asset" ||
+			externalType === ASSET_URL_TYPE ||
+			externalType === "css-url"
+		) {
+			// the consumer decides: a css `url()` reads the url out of the module
+			// (marked by the factory), a `new URL()` requires the `asset` wrapper
 			if (
 				this.dependencyMeta &&
 				/** @type {AssetDependencyMeta} */
@@ -1337,6 +1481,13 @@ class ExternalModule extends Module {
 				};
 			}
 			default: {
+				// A wrapped external runs as a module body inside the wrapper, so it
+				// renders the plain `module.exports =` form: its exports are read
+				// through the wrapper accessor, not through a shared-scope binding.
+				const wrapped = Boolean(
+					concatenationScope &&
+					/** @type {ConcatenationScope} */ (concatenationScope).isWrapped()
+				);
 				const sourceData = this._getSourceData(
 					request,
 					externalType,
@@ -1345,7 +1496,7 @@ class ExternalModule extends Module {
 					chunkGraph,
 					runtime,
 					this.dependencyMeta,
-					concatenationScope
+					wrapped ? undefined : concatenationScope
 				);
 
 				// sourceString can be empty str only when there is concatenationScope
@@ -1359,9 +1510,12 @@ class ExternalModule extends Module {
 					sourceString = "";
 					const scope = /** @type {ConcatenationScope} */ (concatenationScope);
 					for (const [specifier, finalName] of specifiers) {
+						// the hoisted `import { x as finalName }` binding is a top-level
+						// name of the chunk, reserve it before members get renamed
+						scope.usedNames.add(finalName);
 						scope.registerRawExport(specifier, finalName);
 					}
-				} else if (concatenationScope) {
+				} else if (concatenationScope && !wrapped) {
 					sourceString = `${runtimeTemplate.renderConst()} ${
 						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
 					} = ${sourceString};`;
@@ -1448,6 +1602,9 @@ class ExternalModule extends Module {
 			}
 		}
 		if (this.interop) hash.update(`|interop=${this.interop}`);
+		if (this.sideEffects !== undefined) {
+			hash.update(`|sideEffects=${this.sideEffects}`);
+		}
 		super.updateHash(hash, context);
 	}
 
@@ -1461,7 +1618,8 @@ class ExternalModule extends Module {
 			.write(this.externalType)
 			.write(this.userRequest)
 			.write(this.dependencyMeta)
-			.write(this.interop);
+			.write(this.interop)
+			.write(this.sideEffects);
 
 		super.serialize(context);
 	}
@@ -1480,21 +1638,21 @@ class ExternalModule extends Module {
 		this.dependencyMeta = c3.read();
 		const c4 = c3.rest;
 		this.interop = c4.read();
+		const c5 = c4.rest;
+		this.sideEffects = c5.read();
 
-		super.deserialize(c4.rest);
+		super.deserialize(c5.rest);
 	}
 }
 
 ExternalModule.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {ExternalModuleHooks} */ ({
-			chunkCondition: new SyncBailHook(["chunk", "compilation"])
-		})
+	createCompilationHooks
 );
 
 makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
 
-module.exports = ExternalModule;
-module.exports.ModuleExternalInitFragment = ModuleExternalInitFragment;
-module.exports.getExternalModuleNodeCommonjsInitFragment =
+ExternalModule.ModuleExternalInitFragment = ModuleExternalInitFragment;
+ExternalModule.getExternalModuleNodeCommonjsInitFragment =
 	getExternalModuleNodeCommonjsInitFragment;
+
+module.exports = ExternalModule;