webpack 5.108.4 → 5.109.1

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -31,17 +31,25 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 		const defer = this._deferInterop;
 		const cst = runtimeTemplate.renderConst();
 		const lt = runtimeTemplate.renderLet();
+		const supportsSymbol = runtimeTemplate.supportsSymbol();
+		/** @type {(name: string, fallback: string) => string} */
+		const renderSymbol = (name, fallback) =>
+			supportsSymbol
+				? `Symbol("${name}")`
+				: `hasSymbol ? Symbol("${name}") : "${fallback}"`;
 		return Template.asString([
-			`${cst} hasSymbol = typeof Symbol === "function";`,
-			`${cst} webpackQueues = hasSymbol ? Symbol("webpack queues") : "__webpack_queues__";`,
+			...(supportsSymbol
+				? []
+				: [`${cst} hasSymbol = typeof Symbol === "function";`]),
+			`${cst} webpackQueues = ${renderSymbol("webpack queues", "__webpack_queues__")};`,
 			`${cst} webpackExports = ${
 				defer ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
-			}hasSymbol ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
-			`${cst} webpackError = hasSymbol ? Symbol("webpack error") : "__webpack_error__";`,
+			}${renderSymbol("webpack exports", RuntimeGlobals.exports)};`,
+			`${cst} webpackError = ${renderSymbol("webpack error", "__webpack_error__")};`,
 			defer
 				? Template.asString([
-						`${cst} webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = hasSymbol ? Symbol("webpack done") : "__webpack_done__";`,
-						`${cst} webpackDefer = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol} = hasSymbol ? Symbol("webpack defer") : "__webpack_defer__";`,
+						`${cst} webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = ${renderSymbol("webpack done", "__webpack_done__")};`,
+						`${cst} webpackDefer = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol} = ${renderSymbol("webpack defer", "__webpack_defer__")};`,
 						`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies} = ${runtimeTemplate.basicFunction(
 							"asyncDeps",
 							[
@@ -176,7 +184,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)))",
 								"q"
 							)};`,
-							`currentDeps.map(${runtimeTemplate.expressionFunction(
+							`currentDeps.forEach(${runtimeTemplate.expressionFunction(
 								`${
 									defer ? "dep[webpackDefer]||" : ""
 								}dep[webpackQueues](fnQueue)`,
@@ -188,10 +196,18 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				])}`,
 				`${cst} done = ${runtimeTemplate.expressionFunction(
 					`(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)${
-						defer ? ", promise[webpackDone] = true" : ""
+						defer
+							? ", promise[webpackDone] = true, module.evaluatingAsync = false"
+							: ""
 					}`,
 					"err"
 				)}`,
+				// Track the async body's whole lifetime (evaluating +
+				// evaluating-async states) with a dedicated flag — the sync require
+				// wrapper clears `module.evaluating` as soon as `.a` returns, so a
+				// deferred namespace reaching this module through a cycle relies on
+				// `evaluatingAsync` to keep throwing until it is fully evaluated.
+				defer ? "module.evaluatingAsync = true;" : "",
 				"body(handle, done);",
 				`${runtimeTemplate.optionalChaining("queue", "d < 0")} && (queue.d = 0);`
 			])};`

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -47,12 +47,18 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 			? "globalThis"
 			: RuntimeGlobals.global;
 
+		const entryOptions = chunk.getEntryOptions();
+		// A worklet chunk is always loaded as a module via `addModule`, so it can
+		// read `import.meta.url` directly instead of the worker-scope detection.
+		const fromImportMeta =
+			scriptType === "module" || Boolean(entryOptions && entryOptions.worklet);
+
 		const runtimeTemplate = compilation.runtimeTemplate;
 		const cst = runtimeTemplate.renderConst();
 		const lt = runtimeTemplate.renderLet();
 		return Template.asString([
 			`${lt} scriptUrl;`,
-			scriptType === "module"
+			fromImportMeta
 				? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
 				: Template.asString([
 						`if (${global}.importScripts) scriptUrl = ${global}.location + "";`,

package/lib/runtime/CommonJsWrapRuntimeModule.js

@@ -0,0 +1,37 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class CommonJsWrapRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("wrap commonjs module");
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.commonJsWrap;
+		return Template.asString([
+			"// execute a CommonJS module body with real module/exports objects, returning the final exports",
+			`${fn} = ${runtimeTemplate.basicFunction("body", [
+				`${runtimeTemplate.renderConst()} mod = { exports: {} };`,
+				"body.call(mod.exports, mod, mod.exports);",
+				"return mod.exports;"
+			])};`
+		]);
+	}
+}
+
+module.exports = CommonJsWrapRuntimeModule;

package/lib/runtime/GetWorkletBootstrapRuntimeModule.js

@@ -0,0 +1,59 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+/**
+ * Provides a single object URL (one per base URI) for the worklet bootstrap
+ * script. A worklet global scope has no `self` and no `location`; this script
+ * sets them up before the emitted chunks — which assume a worker-like scope —
+ * are added via `addModule`. Deduping by base URI avoids leaking a new object
+ * URL per worklet.
+ */
+class GetWorkletBootstrapRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("get worklet bootstrap", RuntimeModule.STAGE_ATTACH);
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const { getWorkletBootstrap, baseURI } = RuntimeGlobals;
+		const { runtimeTemplate } = /** @type {Compilation} */ (this.compilation);
+		// The arrow inside the blob string is fine — it runs in the worklet (always
+		// a module scope); the surrounding functions must respect `output.environment`.
+		const getter = runtimeTemplate.basicFunction("", [
+			`var base = ${baseURI};`,
+			"if (!cache.has(base)) {",
+			Template.indent([
+				"var script = [",
+				Template.indent([
+					// worklet scopes have no `self`; chunks assume a worker-like scope
+					'"globalThis.self = globalThis.self || globalThis;",',
+					// some runtime modules read `location`; forward the document base
+					'"globalThis.location = " + JSON.stringify(base) + ";"'
+				]),
+				'].join("\\n");',
+				'cache.set(base, URL.createObjectURL(new Blob([script], { type: "text/javascript" })));'
+			]),
+			"}",
+			"return cache.get(base);"
+		]);
+		return `${getWorkletBootstrap} = (${runtimeTemplate.basicFunction("", [
+			"var cache = new Map();",
+			`return ${getter};`
+		])})();`;
+	}
+}
+
+module.exports = GetWorkletBootstrapRuntimeModule;

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -6,12 +6,179 @@
 
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../Module").ExportsType} ExportsType */
 /** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 
+/**
+ * @typedef {object} DeferredCycleState
+ * @property {Map<Module, Set<Module>>} sccOf strongly-connected component per module (shared object per component)
+ * @property {Map<Module, Set<Module> | null>} peers memoized SCC peers (component minus the module) per deferred module
+ */
+
+/** @type {WeakMap<ModuleGraph, DeferredCycleState>} */
+const deferredCycleCache = new WeakMap();
+
+/**
+ * Materializes the active harmony-import targets of a module (deferred edges
+ * included, matching the spec's `RequestedModules` recursion).
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} module the module
+ * @returns {Module[]} imported modules
+ */
+function harmonyImportTargets(moduleGraph, module) {
+	const connections = moduleGraph.getOutgoingConnectionsByModule(module);
+	if (!connections) return [];
+	/** @type {Module[]} */
+	const targets = [];
+	for (const [dep, moduleConnections] of connections) {
+		if (
+			dep &&
+			moduleConnections.some(
+				(c) =>
+					c.dependency instanceof HarmonyImportDependency &&
+					c.isTargetActive(undefined)
+			)
+		) {
+			targets.push(dep);
+		}
+	}
+	return targets;
+}
+
+/**
+ * Assigns every module reachable from `seed` (through active harmony imports)
+ * to its strongly-connected component via an iterative Tarjan pass, writing the
+ * results into `sccOf`. Modules already assigned by an earlier pass are treated
+ * as finished, so across all deferred imports every edge is visited once
+ * (O(V + E) total) rather than re-walked per import.
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} seed the module to explore from
+ * @param {Map<Module, Set<Module>>} sccOf module-to-component map to populate
+ * @returns {void}
+ */
+function assignStronglyConnectedComponents(moduleGraph, seed, sccOf) {
+	if (sccOf.has(seed)) return;
+	/** @type {Map<Module, number>} */
+	const index = new Map();
+	/** @type {Map<Module, number>} */
+	const low = new Map();
+	/** @type {Set<Module>} */
+	const onStack = new Set();
+	/** @type {Module[]} */
+	const componentStack = [];
+	/** @type {{ node: Module, targets: Module[], i: number }[]} */
+	const work = [];
+	let counter = 0;
+	/**
+	 * @param {Module} node node to open
+	 */
+	const open = (node) => {
+		index.set(node, counter);
+		low.set(node, counter);
+		counter++;
+		componentStack.push(node);
+		onStack.add(node);
+		work.push({ node, targets: harmonyImportTargets(moduleGraph, node), i: 0 });
+	};
+	open(seed);
+	while (work.length > 0) {
+		const frame = work[work.length - 1];
+		if (frame.i < frame.targets.length) {
+			const next = frame.targets[frame.i++];
+			// Already in a finished component (from this or a prior pass): skip.
+			if (sccOf.has(next)) continue;
+			if (!index.has(next)) {
+				open(next);
+			} else if (onStack.has(next)) {
+				const nodeLow = /** @type {number} */ (low.get(frame.node));
+				const nextIndex = /** @type {number} */ (index.get(next));
+				if (nextIndex < nodeLow) low.set(frame.node, nextIndex);
+			}
+			continue;
+		}
+		work.pop();
+		const node = frame.node;
+		const nodeLow = /** @type {number} */ (low.get(node));
+		if (work.length > 0) {
+			const parent = work[work.length - 1].node;
+			if (nodeLow < /** @type {number} */ (low.get(parent))) {
+				low.set(parent, nodeLow);
+			}
+		}
+		if (nodeLow === index.get(node)) {
+			/** @type {Set<Module>} */
+			const component = new Set();
+			let member;
+			do {
+				member = /** @type {Module} */ (componentStack.pop());
+				onStack.delete(member);
+				component.add(member);
+			} while (member !== node);
+			for (const m of component) sccOf.set(m, component);
+		}
+	}
+}
+
+/**
+ * Per the TC39 import-defer spec's `ReadyForSyncExecution`, forcing evaluation
+ * of a deferred module must throw when any module in its transitive static
+ * import closure is currently evaluating. Only a module in `module`'s own
+ * strongly-connected component can be evaluating at that point (anything else it
+ * imports is either already evaluated or not started), so we emit just the SCC
+ * peers instead of the whole (potentially huge) forward closure.
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} module the deferred module
+ * @returns {Set<Module> | null} the SCC peers when cyclic, otherwise null
+ */
+function getDeferredCycleModules(moduleGraph, module) {
+	let state = deferredCycleCache.get(moduleGraph);
+	if (state === undefined) {
+		state = { sccOf: new Map(), peers: new Map() };
+		deferredCycleCache.set(moduleGraph, state);
+	}
+	const cached = state.peers.get(module);
+	if (cached !== undefined) return cached;
+	assignStronglyConnectedComponents(moduleGraph, module, state.sccOf);
+	const component = state.sccOf.get(module);
+	// A trivial component (size 1, no self-cycle peers) means no cycle; a direct
+	// self-loop is already covered by the `evaluating` check on `module` itself.
+	let result = null;
+	if (component !== undefined && component.size > 1) {
+		result = new Set(component);
+		result.delete(module);
+	}
+	state.peers.set(module, result);
+	return result;
+}
+
+/**
+ * Maps a defer-cycle closure to the runtime module ids whose `evaluating` flag
+ * the deferred namespace must check. `resolveId` maps a closure module to the
+ * runtime id that carries its evaluation state (its own id, or the id of the
+ * concatenated module that absorbed it); unresolved (`null`) members are
+ * dropped. Returns `null` when there is nothing to check.
+ * @param {Set<Module> | null} closure closure modules, or null when not cyclic
+ * @param {(module: Module) => ModuleId | null} resolveId maps a module to its runtime id
+ * @returns {ModuleId[] | null} deduplicated runtime ids, or null
+ */
+function getDeferredCycleModuleIds(closure, resolveId) {
+	if (closure === null) return null;
+	/** @type {Set<ModuleId>} */
+	const ids = new Set();
+	for (const module of closure) {
+		const id = resolveId(module);
+		if (id !== null) ids.add(id);
+	}
+	return ids.size > 0 ? [...ids] : null;
+}
+
 /**
  * @param {ExportsType} exportsType exports type
  * @returns {string} mode
@@ -29,6 +196,7 @@ function getMakeDeferredNamespaceModeFromExportsType(exportsType) {
  * @param {string} moduleId moduleId
  * @param {ExportsType} exportsType exportsType
  * @param {(ModuleId | null)[]} asyncDepsIds asyncDepsIds
+ * @param {ModuleId[] | null} syncCycleDepsIds transitive static closure ids when the module is part of a defer cycle
  * @param {RuntimeRequirements} runtimeRequirements runtime requirements
  * @returns {string} call make optimized deferred namespace object
  */
@@ -36,17 +204,23 @@ function getOptimizedDeferredModule(
 	moduleId,
 	exportsType,
 	asyncDepsIds,
+	syncCycleDepsIds,
 	runtimeRequirements
 ) {
 	runtimeRequirements.add(RuntimeGlobals.makeOptimizedDeferredNamespaceObject);
 	const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
-	return `${
-		RuntimeGlobals.makeOptimizedDeferredNamespaceObject
-	}(${moduleId}, ${mode}${
-		asyncDepsIds.length > 0
-			? `, ${JSON.stringify(asyncDepsIds.filter((x) => x !== null))}`
-			: ""
-	})`;
+	const asyncDeps = asyncDepsIds.filter((x) => x !== null);
+	const hasSync = syncCycleDepsIds !== null && syncCycleDepsIds.length > 0;
+	// `syncDeps` is passed positionally after `asyncDeps`, so a `0` placeholder
+	// keeps the slot when the module has cycle deps but no async deps.
+	const args = [moduleId, mode];
+	if (asyncDeps.length > 0 || hasSync) {
+		args.push(asyncDeps.length > 0 ? JSON.stringify(asyncDeps) : "0");
+	}
+	if (hasSync) args.push(JSON.stringify(syncCycleDepsIds));
+	return `${RuntimeGlobals.makeOptimizedDeferredNamespaceObject}(${args.join(
+		", "
+	)})`;
 }
 
 class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
@@ -72,7 +246,9 @@ class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeMod
 		const hasAsync = this.hasAsyncRuntime;
 		return Template.asString([
 			// Note: must be a function (not arrow), because this is used in body!
-			`${fn} = function(moduleId, mode${hasAsync ? ", asyncDeps" : ""}) {`,
+			// `asyncDeps` keeps a fixed positional slot even without async runtime
+			// so the trailing `syncDeps` (defer-cycle closure) always lines up.
+			`${fn} = function(moduleId, mode, asyncDeps, syncDeps) {`,
 			Template.indent([
 				`${cst} r = this;`,
 				hasAsync ? `${cst} isAsync = asyncDeps && asyncDeps.length;` : "",
@@ -80,6 +256,19 @@ class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeMod
 				Template.indent([
 					"get a() {",
 					Template.indent([
+						// Forcing evaluation of a module that is currently evaluating
+						// (a cycle reached through a deferred import) must throw rather
+						// than expose its partial exports. `syncDeps` (present only for
+						// cyclic deferred modules) carries the transitive static closure,
+						// so an evaluating dependency is caught before any evaluation.
+						`${cst} cachedModule = __webpack_module_cache__[moduleId];`,
+						'if (cachedModule !== undefined && (cachedModule.evaluating || cachedModule.evaluatingAsync)) throw new TypeError("Cannot access a deferred module namespace while the module is being evaluated");',
+						"if (syncDeps) for (var i = 0; i < syncDeps.length; i++) {",
+						Template.indent([
+							`${cst} depModule = __webpack_module_cache__[syncDeps[i]];`,
+							'if (depModule !== undefined && (depModule.evaluating || depModule.evaluatingAsync)) throw new TypeError("Cannot access a deferred module namespace while a dependency is being evaluated");'
+						]),
+						"}",
 						`${lt} exports = r(moduleId);`,
 						hasAsync
 							? `if(isAsync) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
@@ -164,6 +353,11 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 			"}",
 			"",
 			`${lt} init = ${runtimeTemplate.basicFunction("", [
+				// A deferred namespace that forces evaluation of a module that is
+				// already evaluating (a cycle) must throw rather than expose its
+				// partial exports.
+				`${cst} evaluatingModule = __webpack_module_cache__[moduleId];`,
+				'if (evaluatingModule !== undefined && (evaluatingModule.evaluating || evaluatingModule.evaluatingAsync)) throw new TypeError("Cannot access a deferred module namespace while the module is being evaluated");',
 				`ns = ${RuntimeGlobals.require}(moduleId);`,
 				hasAsync
 					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in ns) ns = ns[${RuntimeGlobals.asyncModuleExportSymbol}];`
@@ -348,6 +542,8 @@ module.exports.MakeDeferredNamespaceObjectRuntimeModule =
 	MakeDeferredNamespaceObjectRuntimeModule;
 module.exports.MakeOptimizedDeferredNamespaceObjectRuntimeModule =
 	MakeOptimizedDeferredNamespaceObjectRuntimeModule;
+module.exports.getDeferredCycleModuleIds = getDeferredCycleModuleIds;
+module.exports.getDeferredCycleModules = getDeferredCycleModules;
 module.exports.getMakeDeferredNamespaceModeFromExportsType =
 	getMakeDeferredNamespaceModeFromExportsType;
 module.exports.getOptimizedDeferredModule = getOptimizedDeferredModule;

package/lib/runtime/SetAnonymousDefaultNameRuntimeModule.js

@@ -25,8 +25,11 @@ class SetAnonymousDefaultNameRuntimeModule extends HelperRuntimeModule {
 		const fn = RuntimeGlobals.setAnonymousDefaultName;
 		return Template.asString([
 			"// set .name for anonymous default exports per ES spec",
+			"// skipped when the property is non-configurable (pre-ES2015 engines),",
+			"// where Object.defineProperty would throw",
 			`${fn} = ${runtimeTemplate.basicFunction("x", [
-				'(Object.getOwnPropertyDescriptor(x, "name") || {}).writable || Object.defineProperty(x, "name", { value: "default", configurable: true });'
+				'var descriptor = Object.getOwnPropertyDescriptor(x, "name");',
+				'if (!descriptor || (!descriptor.writable && descriptor.configurable)) Object.defineProperty(x, "name", { value: "default", configurable: true });'
 			])};`
 		]);
 	}

package/lib/schemes/HttpUriPlugin.js

@@ -233,6 +233,36 @@ const sanitizeUrlForError = (href) => {
 	}
 };
 
+/**
+ * Splits lockfile content containing git merge conflict markers (2-way or
+ * diff3) into its two sides so each can be parsed as valid JSON on its own.
+ * @param {string} content lockfile content with conflict markers
+ * @returns {[string, string]} the "ours" and "theirs" variants
+ */
+const splitMergeConflicts = (content) => {
+	/** @type {string[]} */
+	const ours = [];
+	/** @type {string[]} */
+	const theirs = [];
+	// 0 = shared, 1 = ours, 2 = theirs, 3 = common ancestor (diff3, dropped)
+	let side = 0;
+	for (const line of content.split(/\r?\n/)) {
+		if (line.startsWith("<<<<<<<")) {
+			side = 1;
+		} else if (line.startsWith("|||||||")) {
+			side = 3;
+		} else if (line.startsWith("=======")) {
+			side = 2;
+		} else if (line.startsWith(">>>>>>>")) {
+			side = 0;
+		} else {
+			if (side === 0 || side === 1) ours.push(line);
+			if (side === 0 || side === 2) theirs.push(line);
+		}
+	}
+	return [ours.join("\n"), theirs.join("\n")];
+};
+
 class Lockfile {
 	constructor() {
 		/** @type {number} */
@@ -247,7 +277,16 @@ class Lockfile {
 	 * @returns {Lockfile} lockfile
 	 */
 	static parse(content) {
-		// TODO handle merge conflicts
+		// A git merge conflict leaves `<<<<<<<`/`=======`/`>>>>>>>` markers; parse
+		// each side and union the entries, since lockfile changes only add keys.
+		if (content.includes("<<<<<<<")) {
+			const [ours, theirs] = splitMergeConflicts(content);
+			const lockfile = Lockfile.parse(ours);
+			for (const [key, entry] of Lockfile.parse(theirs).entries) {
+				if (!lockfile.entries.has(key)) lockfile.entries.set(key, entry);
+			}
+			return lockfile;
+		}
 		const data = JSON.parse(content);
 		if (data.version !== 1) {
 			throw new Error(`Unsupported lockfile version ${data.version}`);

package/lib/schemes/VirtualUrlPlugin.js

@@ -5,10 +5,9 @@
 
 "use strict";
 
-const { getContext } = require("loader-runner");
-
 const NormalModule = require("../NormalModule");
 const ModuleNotFoundError = require("../errors/ModuleNotFoundError");
+const { getContext } = require("../loaders/LoaderRunner");
 const { isAbsolute, join } = require("../util/fs");
 const { parseResourceWithoutFragment } = require("../util/identifier");