webpack 5.111.1 → 5.112.1

package/lib/{dependencies → provide}/ProvidedDependency.js

@@ -5,25 +5,28 @@
 
 "use strict";
 
-const Dependency = require("../Dependency");
-const InitFragment = require("../InitFragment");
-const Template = require("../Template");
-const { InlinedUsedName } = require("../optimize/InlineExports");
+const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
+const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
+const ModuleDependency = require("../dependencies/core/ModuleDependency");
+const Dependency = require("../graph/Dependency");
+const { isInlinedUsedName } = require("../optimize/InlineExports");
+const InitFragment = require("../template/InitFragment");
+const Template = require("../template/Template");
 const makeSerializable = require("../util/makeSerializable");
 const { propertyAccess } = require("../util/property");
-const ModuleDependency = require("./ModuleDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
 /**
  * @import {
+ * 	DependencyKinds,
  * 	ReferencedExports,
  * 	UpdateHashContext,
  * 	ExportInfoName
- * } from "../Dependency"
+ * } from "../graph/Dependency"
  */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
+/** @import { DependencyTemplateContext } from "../template/DependencyTemplate" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import ModuleGraphConnection from "../graph/ModuleGraphConnection" */
 /** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, ExportInfoName[]]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, ExportInfoName[]]>} ObjectSerializerContext */
@@ -103,10 +106,14 @@ class ProvidedDependency extends ModuleDependency {
 	}
 }
 
-makeSerializable(
-	ProvidedDependency,
+/** @type {Set<keyof DependencyKinds>} */
+ProvidedDependency.KINDS = new Set([...ModuleDependency.KINDS, "provided"]);
+
+makeSerializable(ProvidedDependency, [
+	"webpack/lib/provide/ProvidedDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/ProvidedDependency"
-);
+]);
 
 class ProvidedDependencyTemplate extends ModuleDependency.Template {
 	/**
@@ -120,6 +127,7 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 		dependency,
 		source,
 		{
+			module,
 			runtime,
 			runtimeTemplate,
 			moduleGraph,
@@ -142,24 +150,49 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 			runtimeRequirements
 		});
 
+		// An async module only exposes its exports once awaited, and only an ESM
+		// consumer is async itself (see `InferAsyncModulesPlugin`).
+		const isAsync =
+			moduleGraph.isAsync(connection.module) && moduleGraph.isAsync(module);
+		const target = isAsync ? dep.identifier : moduleRaw;
 		const provided = !usedName
-			? moduleRaw
-			: usedName instanceof InlinedUsedName
-				? `(${moduleRaw}, ${usedName.render(
+			? target
+			: isInlinedUsedName(usedName)
+				? `(${target}, ${usedName.render(
 						Template.toNormalComment(
 							`inlined export ${propertyAccess(dep.ids)}`
 						)
 					)})`
-				: `${moduleRaw}${propertyAccess(/** @type {string[]} */ (usedName), 0)}`;
+				: `${target}${propertyAccess(/** @type {string[]} */ (usedName), 0)}`;
 
 		initFragments.push(
 			new InitFragment(
-				`/* provided dependency */ var ${dep.identifier} = ${provided};\n`,
+				`/* provided dependency */ var ${dep.identifier} = ${
+					isAsync ? moduleRaw : provided
+				};\n`,
 				InitFragment.STAGE_PROVIDES,
 				1,
 				`provided ${dep.identifier}`
 			)
 		);
+		if (isAsync) {
+			initFragments.push(
+				new AwaitDependenciesInitFragment(
+					new Map([[dep.identifier, dep.identifier]]),
+					isGeneratorLowered(module, moduleGraph, runtimeTemplate)
+				)
+			);
+			if (provided !== target) {
+				initFragments.push(
+					new InitFragment(
+						`${dep.identifier} = ${provided};\n`,
+						InitFragment.STAGE_ASYNC_ESM_IMPORTS,
+						1,
+						`provided async ${dep.identifier}`
+					)
+				);
+			}
+		}
 		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
 	}
 }

package/lib/{IgnorePlugin.js → resolve/IgnorePlugin.js}

@@ -5,19 +5,36 @@
 
 "use strict";
 
-const RawModule = require("./RawModule");
-const EntryDependency = require("./dependencies/EntryDependency");
+const isDependencyKind = require("../graph/isDependencyKind");
+const RawModule = require("../module/RawModule");
+
+/** @import Compiler from "../Compiler" */
+/** @import { ResolveData } from "../module/NormalModuleFactory" */
+/** @import { BeforeContextResolveData } from "../context/ContextModuleFactory" */
 
 /**
- * @import {
- * 	IgnorePluginOptions
- * } from "../declarations/plugins/IgnorePlugin"
+ * @inline
+ * @tsType import('./IgnorePlugin').CheckResourceFn
+ * @typedef {(resource: string, context: string) => boolean} CheckResourceFn
  */
-/** @import Compiler from "./Compiler" */
-/** @import { ResolveData } from "./NormalModuleFactory" */
-/** @import { BeforeContextResolveData } from "./context/ContextModuleFactory" */
 
-/** @typedef {(resource: string, context: string) => boolean} CheckResourceFn */
+/**
+ * @inline
+ * @typedef {object} IgnorePluginPatternOptions
+ * @property {RegExp=} contextRegExp A RegExp to test the context (directory) against.
+ * @property {RegExp} resourceRegExp A RegExp to test the request against.
+ */
+
+/**
+ * @inline
+ * @typedef {object} IgnorePluginCheckOptions
+ * @property {CheckResourceFn} checkResource A filter function for resource and context.
+ */
+
+/**
+ * @schema plugins/IgnorePlugin
+ * @typedef {IgnorePluginPatternOptions | IgnorePluginCheckOptions} IgnorePluginOptions
+ */
 
 const PLUGIN_NAME = "IgnorePlugin";
 
@@ -71,14 +88,14 @@ class IgnorePlugin {
 	apply(compiler) {
 		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
 			compiler.validate(
-				/** @type {EXPECTED_ANY} */
-				(require("../schemas/plugins/IgnorePlugin.json")),
+				require("../../schemas/plugins/IgnorePlugin.json"),
 				this.options,
 				{
 					name: "Ignore Plugin",
 					baseDataPath: "options"
 				},
-				(options) => require("../schemas/plugins/IgnorePlugin.check")(options)
+				(options) =>
+					require("../../schemas/plugins/IgnorePlugin.check")(options)
 			);
 		});
 
@@ -89,7 +106,7 @@ class IgnorePlugin {
 				if (
 					result === false &&
 					resolveData.dependencies.length > 0 &&
-					resolveData.dependencies[0] instanceof EntryDependency
+					isDependencyKind(resolveData.dependencies[0], "entry")
 				) {
 					const module = new RawModule(
 						"",

package/lib/{NormalModuleReplacementPlugin.js → resolve/NormalModuleReplacementPlugin.js}

@@ -5,11 +5,11 @@
 
 "use strict";
 
-const { dirname, isAbsolute, join } = require("./util/fs");
+const { dirname, isAbsolute, join } = require("../fs/fs");
 
-/** @import Compiler from "./Compiler" */
-/** @import { ResolveData } from "./NormalModuleFactory" */
-/** @import { InputFileSystem } from "./util/fs" */
+/** @import Compiler from "../Compiler" */
+/** @import { ResolveData } from "../module/NormalModuleFactory" */
+/** @import { InputFileSystem } from "../fs/fs" */
 
 /** @typedef {(resolveData: ResolveData) => void} ModuleReplacer */
 

package/lib/{ResolverFactory.js → resolve/ResolverFactory.js}

@@ -11,12 +11,16 @@ const {
 	cachedCleverMerge,
 	removeOperations,
 	resolveByProperty
-} = require("./util/cleverMerge");
+} = require("../util/cleverMerge");
+const memoize = require("../util/memoize");
+const getResolveOptionsKey = require("./getResolveOptionsKey");
+
+const getGlobUtils = memoize(() => require("../util/globUtils"));
 
 /** @typedef {import("enhanced-resolve").Resolver} Resolver */
-/** @typedef {import("../declarations/WebpackOptions").ResolvePluginInstance} ResolvePluginInstance */
+/** @typedef {import("../../declarations/WebpackOptions").ResolvePluginInstance} ResolvePluginInstance */
 /** @import { ResolveOptions } from "enhanced-resolve" */
-/** @import { ResolveOptions as WebpackResolveOptions } from "../declarations/WebpackOptions" */
+/** @import { ResolveOptions as WebpackResolveOptions } from "../../declarations/WebpackOptions" */
 
 /** @typedef {WebpackResolveOptions & { dependencyType?: string, resolveToContext?: boolean }} ResolveOptionsWithDependencyType */
 /**
@@ -61,13 +65,22 @@ const convertToResolveOptions = (resolveOptionsWithDepType) => {
 			partialOptions
 		);
 
-	return /** @type {ResolveOptions} */ (
+	const resolveOptions = /** @type {ResolveOptions} */ (
 		removeOperations(
 			resolveByProperty(options, "byDependency", dependencyType),
 			// Keep the `unsafeCache` because it can be a `Proxy`
 			["unsafeCache"]
 		)
 	);
+	if (resolveOptions.restrictions) {
+		// enhanced-resolve reads a string as a directory, so a glob goes as a RegExp
+		const { compileRelativeGlobPaths, createPathGlobRegExp } = getGlobUtils();
+		resolveOptions.restrictions = compileRelativeGlobPaths(
+			resolveOptions.restrictions,
+			createPathGlobRegExp
+		);
+	}
+	return resolveOptions;
 };
 
 /**
@@ -112,7 +125,7 @@ module.exports = class ResolverFactory {
 		if (cachedResolver) {
 			return cachedResolver;
 		}
-		const ident = JSON.stringify(resolveOptions);
+		const ident = getResolveOptionsKey(resolveOptions).key;
 		const resolver = typedCaches.stringified.get(ident);
 		if (resolver) {
 			typedCaches.direct.set(resolveOptions, resolver);

package/lib/resolve/getResolveOptionsKey.js

@@ -0,0 +1,59 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import { ResolveOptionsWithDependencyType } from "./ResolverFactory" */
+
+/** @type {WeakMap<EXPECTED_OBJECT | EXPECTED_FUNCTION, number>} */
+const identities = new WeakMap();
+let nextIdentity = 0;
+
+/**
+ * Serializes resolve options into a cache key. Plain JSON values and regular expressions are keyed by content; functions, class instances and `unsafeCache` objects by identity, which holds only within this process.
+ * @param {ResolveOptionsWithDependencyType} options resolve options
+ * @returns {{ key: string, persistent: boolean }} the key, and whether it means the same in another process
+ */
+const getResolveOptionsKey = (options) => {
+	let persistent = true;
+	const key = JSON.stringify(
+		options,
+		/**
+		 * @this {Record<string, unknown>}
+		 * @param {string} name property name
+		 * @param {unknown} value value, after any `toJSON()`
+		 * @returns {unknown} value to serialize
+		 */
+		function replacer(name, value) {
+			// `toJSON()` already ran, so a plugin could pass for plain data
+			value = this[name];
+			if (
+				value === null ||
+				(typeof value !== "object" && typeof value !== "function") ||
+				Array.isArray(value)
+			) {
+				return value;
+			}
+			if (value instanceof RegExp) return { regexp: value.toString() };
+			const prototype = Object.getPrototypeOf(value);
+			if (
+				name !== "unsafeCache" &&
+				(prototype === Object.prototype || prototype === null)
+			) {
+				return value;
+			}
+			let identity = identities.get(value);
+			if (identity === undefined) {
+				identity = nextIdentity++;
+				identities.set(value, identity);
+			}
+			persistent = false;
+			return { identity };
+		}
+	);
+	return { key, persistent };
+};
+
+module.exports = getResolveOptionsKey;

package/lib/rules/BasicEffectRulePlugin.js

@@ -15,7 +15,7 @@
  * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
  */
 
-/** @typedef {KeysOfTypes<RuleSetRule, string | boolean | { [k: string]: EXPECTED_ANY }>} BasicEffectRuleKeys */
+/** @typedef {KeysOfTypes<RuleSetRule, string | boolean | EXPECTED_OBJECT>} BasicEffectRuleKeys */
 
 const PLUGIN_NAME = "BasicEffectRulePlugin";
 

package/lib/rules/RuleSetCompiler.js

@@ -6,17 +6,23 @@
 "use strict";
 
 const { SyncHook } = require("tapable");
-const { createPathGlobMatcher } = require("../util/globUtils");
-const { fileUrlToPath } = require("../util/identifier");
+const { compileGlobList } = require("../util/globUtils");
+const {
+	RELATIVE_PATH_PREFIX_REGEXP,
+	fileUrlToPath
+} = require("../util/identifier");
 
 /** @import { ResolveRequest } from "enhanced-resolve" */
+/** @import { JsonValue } from "../fs/fs" */
 /**
  * @import {
  * 	Falsy,
  * 	RuleSetUseItem,
  * 	RuleSetLoaderOptions,
  * 	RuleSetRule,
- * 	RuleSetConditionAbsolute
+ * 	RuleSetConditionAbsolute,
+ * 	RuleSetGlob,
+ * 	RuleSetGlobs
  * } from "../../declarations/WebpackOptions"
  */
 
@@ -79,7 +85,7 @@ const { fileUrlToPath } = require("../util/identifier");
  * Defines the effect use type used by this module.
  * @typedef {object} EffectUse
  * @property {EffectUseType} type
- * @property {{ loader: string, options?: string | null | Record<string, EXPECTED_ANY>, ident?: string }} value
+ * @property {{ loader: string, options?: RuleSetLoaderOptions | null, ident?: string }} value
  */
 
 /**
@@ -110,34 +116,11 @@ const { fileUrlToPath } = require("../util/identifier");
 
 /** @typedef {Set<string>} UnhandledProperties */
 
-/** @typedef {(str: string) => boolean} GlobMatcher */
 /** @typedef {(data: EffectData) => (RuleSetUseItem | (Falsy | RuleSetUseItem)[])} RuleSetUseFn */
 /** @typedef {(value: string) => boolean} RuleSetConditionFn */
 
 /** @typedef {{ apply: (ruleSetCompiler: RuleSetCompiler) => void }} RuleSetPlugin */
 
-/**
- * @param {GlobMatcher[]} positive patterns that select
- * @param {GlobMatcher[]} negative patterns that subtract
- * @returns {GlobMatcher} matcher
- */
-const combineGlobMatchers = (positive, negative) => {
-	/** @type {GlobMatcher} */
-	const matchPositive =
-		positive.length === 0
-			? () => true
-			: positive.length === 1
-				? positive[0]
-				: (str) => positive.some((match) => match(str));
-	if (negative.length === 0) return matchPositive;
-	/** @type {GlobMatcher} */
-	const matchNegative =
-		negative.length === 1
-			? negative[0]
-			: (str) => negative.some((match) => match(str));
-	return (str) => matchPositive(str) && !matchNegative(str);
-};
-
 class RuleSetCompiler {
 	/**
 	 * Creates an instance of RuleSetCompiler.
@@ -182,7 +165,7 @@ class RuleSetCompiler {
 			for (const condition of rule.conditions) {
 				const p = condition.property;
 				if (Array.isArray(p)) {
-					/** @type {EXPECTED_ANY} */
+					/** @type {EffectData | EffectData[keyof EffectData] | JsonValue} */
 					let current = data;
 					for (const subProperty of p) {
 						if (
@@ -190,14 +173,22 @@ class RuleSetCompiler {
 							typeof current === "object" &&
 							Object.prototype.hasOwnProperty.call(current, subProperty)
 						) {
-							current = current[/** @type {keyof EffectData} */ (subProperty)];
+							current = /** @type {Record<string, JsonValue>} */ (current)[
+								subProperty
+							];
 						} else {
 							current = undefined;
 							break;
 						}
 					}
 					if (current !== undefined) {
-						if (!condition.fn(current)) return false;
+						if (
+							!condition.fn(
+								/** @type {EffectData[keyof EffectData]} */ (current)
+							)
+						) {
+							return false;
+						}
 						continue;
 					}
 				} else if (p in data) {
@@ -475,31 +466,30 @@ class RuleSetCompiler {
 		if (globs.length === 0) {
 			throw this.error(path, glob, "Expected glob pattern, but got empty list");
 		}
-		/** @type {GlobMatcher[]} */
-		const positive = [];
-		/** @type {GlobMatcher[]} */
-		const negative = [];
+		/**
+		 * @param {number} i pattern index
+		 * @returns {string} path of the pattern
+		 */
+		const patternPath = (i) => (Array.isArray(glob) ? `${path}[${i}]` : path);
 		for (let i = 0; i < globs.length; i++) {
-			const pattern = globs[i];
-			const patternPath = Array.isArray(glob) ? `${path}[${i}]` : path;
-			if (typeof pattern !== "string") {
+			if (typeof globs[i] !== "string") {
 				throw this.error(
-					patternPath,
-					pattern,
-					`Unexpected ${typeof pattern} when glob pattern was expected`
+					patternPath(i),
+					globs[i],
+					`Unexpected ${typeof globs[i]} when glob pattern was expected`
 				);
 			}
-			const negated = pattern.startsWith("!");
-			const match = createPathGlobMatcher(negated ? pattern.slice(1) : pattern);
-			if (match === null) {
-				throw this.error(patternPath, pattern, "Invalid glob pattern");
-			}
-			(negated ? negative : positive).push(match);
 		}
-		const match = combineGlobMatchers(positive, negative);
+		const match = compileGlobList(globs, (pattern, i) => {
+			throw this.error(patternPath(i), pattern, "Invalid glob pattern");
+		});
 		return {
 			matchWhenEmpty: match(""),
-			fn: (v) => typeof v === "string" && match(v)
+			// a relative value starts where its `./` and `../` end, as a relative
+			// pattern matches at any depth
+			fn: (v) =>
+				typeof v === "string" &&
+				match(v.replace(RELATIVE_PATH_PREFIX_REGEXP, ""))
 		};
 	}
 
@@ -545,8 +535,9 @@ class RuleSetCompiler {
 
 	/**
 	 * Returns an error object.
+	 * @template T
 	 * @param {string} path current path
-	 * @param {EXPECTED_ANY} value value at the error location
+	 * @param {T} value value at the error location
 	 * @param {string} message message explaining the problem
 	 * @returns {Error} an error object
 	 */
@@ -837,7 +828,7 @@ const someSpellingContains = (pattern, probe, expandFirst) => {
 };
 
 /**
- * @param {EXPECTED_ANY} glob glob pattern(s)
+ * @param {RuleSetGlob | RuleSetGlobs | undefined} glob glob pattern(s)
  * @param {string} extension extension including the dot (e.g. `".css"`)
  * @returns {boolean} whether a pattern targets the extension
  */
@@ -861,7 +852,7 @@ const globReferencesExtension = (glob, extension) => {
  * generic sample path doesn't match its (possibly filename-scoped) pattern.
  * The extension may be spelled by an alternation (`\.(css|scss)$`) or a
  * character class (`\.[jt]sx?$`), so those are expanded before probing.
- * @param {EXPECTED_ANY} condition condition
+ * @param {RuleSetConditionAbsolute | undefined} condition condition
  * @param {string} extProbe escaped extension probe (e.g. `"\\.css"`)
  * @returns {boolean} whether a regexp in the condition targets the extension
  */

package/lib/rules/UseEffectRulePlugin.js

@@ -173,9 +173,7 @@ class UseEffectRulePlugin {
 								);
 							});
 						}
-						return [
-							useToEffect(path, path, /** @type {RuleSetUseItem} */ (items))
-						];
+						return [useToEffect(path, path, items)];
 					};
 
 					if (typeof use === "function") {

package/lib/runtime/AsyncModuleGeneratorRuntimeModule.js

@@ -4,9 +4,9 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
+const Template = require("../template/Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
 
 /** @import Compilation from "../Compilation" */
 

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -4,11 +4,12 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
+const Template = require("../template/Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
 
 /** @import Compilation from "../Compilation" */
+/** @import Chunk from "../graph/Chunk" */
 
 class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 	/**
@@ -32,7 +33,15 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.asyncModule;
 		const defer = this._deferInterop;
+		const exposeExports =
+			defer ||
+			compilation.chunkGraph
+				.getTreeRuntimeRequirements(/** @type {Chunk} */ (this.chunk))
+				.has(RuntimeGlobals.asyncModuleExportSymbol);
 		const strictErrors = this._strictModuleErrorHandling;
+		const moduleCache = this.receivesHotUpdates()
+			? RuntimeGlobals.moduleCache
+			: "__webpack_module_cache__";
 		const rejectCall = "reject(promise[webpackError] = err)";
 		const rejectExpression = strictErrors
 			? `(markCycle(err), ${rejectCall})`
@@ -51,7 +60,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				: [`${cst} hasSymbol = typeof Symbol === "function";`]),
 			`${cst} webpackQueues = ${renderSymbol("webpack queues", "__webpack_queues__")};`,
 			`${cst} webpackExports = ${
-				defer ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
+				exposeExports ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
 			}${renderSymbol("webpack exports", RuntimeGlobals.exports)};`,
 			`${cst} webpackError = ${renderSymbol("webpack error", "__webpack_error__")};`,
 			...(strictErrors ? [`${cst} cycleGroups = {};`] : []),
@@ -65,7 +74,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								Template.indent([
 									`${cst} hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {`,
 									Template.indent([
-										`${cst} cache = __webpack_module_cache__[id];`,
+										`${cst} cache = ${moduleCache}[id];`,
 										"if (!cache) return true;",
 										// A cached entry no longer means finished, and a rejected
 										// one is done but its error must still reach the importer.
@@ -223,7 +232,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 									`group && group.forEach(${runtimeTemplate.basicFunction(
 										"id",
 										[
-											`${cst} peer = __webpack_module_cache__[id];`,
+											`${cst} peer = ${moduleCache}[id];`,
 											"if (peer && peer.error === undefined) peer.error = err;"
 										]
 									)})`,

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -4,12 +4,12 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
-const Template = require("../Template");
+const Template = require("../template/Template");
+const RuntimeGlobals = require("./RuntimeGlobals");
+const RuntimeModule = require("./RuntimeModule");
 
-/** @import Chunk from "../Chunk" */
-/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
 /** @import Compilation from "../Compilation" */
 
 class AutoPublicPathRuntimeModule extends RuntimeModule {

package/lib/runtime/BaseUriRuntimeModule.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
+const RuntimeModule = require("./RuntimeModule");
 const { renderBaseUri } = require("./baseUri");
 
 /**
@@ -14,7 +14,7 @@ const { renderBaseUri } = require("./baseUri");
  * 	EntryDescriptionNormalized as EntryDescription
  * } from "../../declarations/WebpackOptions"
  */
-/** @import Chunk from "../Chunk" */
+/** @import Chunk from "../graph/Chunk" */
 /** @import Compilation from "../Compilation" */
 
 class BaseUriRuntimeModule extends RuntimeModule {

package/lib/runtime/ChunkNameRuntimeModule.js

@@ -4,8 +4,8 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
+const RuntimeModule = require("./RuntimeModule");
 
 class ChunkNameRuntimeModule extends RuntimeModule {
 	/**

package/lib/runtime/CompatGetDefaultExportRuntimeModule.js

@@ -4,9 +4,9 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
+const Template = require("../template/Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
 
 /** @import Compilation from "../Compilation" */