webpack 5.111.0 → 5.111.1

package/lib/buildChunkGraph.js

@@ -641,16 +641,13 @@ const visitModules = (
 					}
 				} else {
 					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
-					// Fill in options the existing entrypoint hasn't set yet. We never
-					// overwrite: blocks that dedupe to one entrypoint (e.g. several
-					// workers pointing at the same module) legitimately carry distinct
-					// values such as `runtime`, so the first block to create the
-					// entrypoint wins and later ones only contribute missing keys.
-					// `name` is excluded: it is the entrypoint's identity, fixed at
-					// creation (and used to key namedChunkGroups), so back-filling it
-					// from a block that deduped in via its module would leave
-					// `entrypoint.name` out of sync and make module codegen
-					// order-dependent, which breaks persistent caching.
+					// Fill in only the options still unset: blocks deduping to one
+					// entrypoint may carry different values, so the first to create it
+					// wins.
+
+					// `name` is excluded, being the entrypoint's identity and fixed at
+					// creation. Back-filling it would make codegen order-dependent, which
+					// breaks persistent caching.
 					const existingOptions = entrypoint.options;
 					for (const key_ of Object.keys(entryOptions)) {
 						const key =
@@ -1370,11 +1367,10 @@ const connectChunkGroups = (
 
 	// For each edge in the basic chunk graph
 	for (const [block, connections] of blockConnections) {
-		// 1. Check if connection is needed
-		// When none of the dependencies need to be connected
-		// we can skip all of them
-		// It's not possible to filter each item so it doesn't create inconsistent
-		// connections and modules can only create one version
+		// Skip the whole set when no dependency needs connecting. They cannot be
+		// filtered one by one without inconsistent connections, since a module can
+		// only carry one version.
+
 		// TODO maybe decide this per runtime
 		if (
 			// Blocks with nested blocks must stay connected — skipping orphans the

package/lib/cache/MemoryCachePlugin.js

@@ -31,13 +31,13 @@ class MemoryCachePlugin {
 				const cacheEntry = cache.get(identifier);
 				// A recorded miss: the whole chain was asked for this identifier already.
 				if (cacheEntry === null) return null;
-				// Etags are compared by identity — a lazy one is interned per source
-				// object, so equal content reached through a second object is a
+				// WHY: etags are compared by identity, and a lazy one is interned per
+				// source object, so equal content reached through a second object is a
 				// different etag. Hashing to tell those apart would cost every hit what
 				// laziness saves, so a mismatch falls through to the next stage instead:
 				// the file cache compares etags by value and can still answer. Returning
-				// `null` here would bail the hook and lose that (`Cache.get` maps it to
-				// `undefined` regardless, so it buys the caller nothing).
+				// `null` here would bail the hook and lose that, and `Cache.get` maps it
+				// to `undefined` regardless, so it buys the caller nothing.
 				if (cacheEntry !== undefined && cacheEntry.etag === etag) {
 					return cacheEntry.data;
 				}

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -79,10 +79,9 @@ class MemoryWithGcCachePlugin {
 					continue;
 				}
 				if (entry !== undefined) {
-					// We don't delete the cache entry, but set it to undefined instead
-					// This reserves the location in the data table and avoids rehashing
-					// when constantly adding and removing entries.
-					// It will be deleted when removed from oldCache.
+					// Set to undefined rather than deleted, reserving the slot and sparing
+					// a rehash as entries come and go. It goes for good once `oldCache`
+					// drops it.
 					cache.set(identifier, undefined);
 					oldCache.delete(identifier);
 					oldCache.set(identifier, {
@@ -105,13 +104,13 @@ class MemoryWithGcCachePlugin {
 				const cacheEntry = cache.get(identifier);
 				// A recorded miss: the whole chain was asked for this identifier already.
 				if (cacheEntry === null) return null;
-				// Etags are compared by identity — a lazy one is interned per source
-				// object, so equal content reached through a second object is a
+				// WHY: etags are compared by identity, and a lazy one is interned per
+				// source object, so equal content reached through a second object is a
 				// different etag. Hashing to tell those apart would cost every hit what
 				// laziness saves, so a mismatch falls through to the next stage instead:
 				// the file cache compares etags by value and can still answer. Returning
-				// `null` here would bail the hook and lose that (`Cache.get` maps it to
-				// `undefined` regardless, so it buys the caller nothing).
+				// `null` here would bail the hook and lose that, and `Cache.get` maps it
+				// to `undefined` regardless, so it buys the caller nothing.
 				let known = cacheEntry !== undefined;
 				if (cacheEntry !== undefined) {
 					if (cacheEntry.etag === etag) return cacheEntry.data;

package/lib/cache/PackFileCacheStrategy.js

@@ -901,24 +901,9 @@ makeSerializable(
 /** @typedef {(() => Promise<PackContentItems> | PackContentItems) & Partial<{ options: { size?: number } }>} LazyFunction */
 
 class PackContent {
-	/*
-		This class can be in these states:
-		   |   this.lazy    | this.content | this.outdated | state
-		A1 |   undefined    |     Map      |     false     | fresh content
-		A2 |   undefined    |     Map      |     true      | (will not happen)
-		B1 | lazy () => {}  |  undefined   |     false     | not deserialized
-		B2 | lazy () => {}  |  undefined   |     true      | not deserialized, but some items has been removed
-		C1 | lazy* () => {} |     Map      |     false     | deserialized
-		C2 | lazy* () => {} |     Map      |     true      | deserialized, and some items has been removed
-
-		this.used is a subset of this.items.
-		this.items is a subset of this.content.keys() resp. this.lazy().map.keys()
-		When this.outdated === false, this.items === this.content.keys() resp. this.lazy().map.keys()
-		When this.outdated === true, this.items should be used to recreated this.lazy/this.content.
-		When this.lazy and this.content is set, they contain the same data.
-		this.get must only be called with a valid item from this.items.
-		In state C this.lazy is unMemoized
-	*/
+	// `used` is a subset of `items`, itself a subset of the content's keys, and the
+	// two coincide while `outdated` is false. `lazy` and `content` hold the same
+	// data whenever both are set, and `get` takes only an item of `items`.
 
 	/**
 	 * Creates an instance of PackContent.

package/lib/cache/getLazyHashedEtag.js

@@ -42,11 +42,9 @@ class LazyHashedEtag {
 			/** @type {HashableObject} */
 			(this._obj).updateHash(hash);
 			this._hash = hash.digest("base64");
-			// Drop the captured object once the hash is memoized. The hash is
-			// never reset, so we never need `_obj` again — and many callers
-			// (e.g. `SourceMapDevToolPlugin`, `RealContentHashPlugin`) capture
-			// a heavy `CachedSource` here that would otherwise stay reachable
-			// through this etag for the lifetime of the compilation cache.
+			// Drop the captured object once the hash is memoized: the hash never
+			// resets, and callers often capture a heavy `CachedSource` that would
+			// otherwise stay reachable for the compilation cache's lifetime.
 			this._obj = undefined;
 		}
 		return this._hash;

package/lib/config/browserslistTargetHandler.js

@@ -422,10 +422,7 @@ const resolve = (browsers) => {
 			ios_saf: [15, 4],
 			samsung: 17,
 			android: 93,
-			// and_qq: Not supported
-			// baidu: Not supported
-			// and_uc: Not supported
-			// kaios: Not supported
+			// and_qq, baidu, and_uc and kaios are not supported.
 			node: [16, 9]
 		}),
 		topLevelAwait: rawChecker({
@@ -441,10 +438,7 @@ const resolve = (browsers) => {
 			ios_saf: 15,
 			samsung: 15,
 			android: 89,
-			// and_qq: Not supported
-			// baidu: Not supported
-			// and_uc: Not supported
-			// kaios: Not supported
+			// and_qq, baidu, and_uc and kaios are not supported.
 			node: [14, 8]
 		}),
 		spread: rawChecker({

package/lib/config/defaults.js

@@ -492,10 +492,9 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		library: options.output.library
 	});
 
-	// `output.resourceHints.urlHints` shorthand: fan the project-wide rules out
-	// as the base `urlHints` of every URL-emitting parser (JS `new URL`, CSS
-	// `url()`, HTML `<img src>`). They go first so parser-scoped
-	// `parser.<type>.urlHints` rules — matched later, last-match-wins — override.
+	// `output.resourceHints.urlHints` fans the project-wide rules out as the base
+	// `urlHints` of every URL-emitting parser. They go first, so a parser-scoped
+	// rule matches later and wins.
 	const outputUrlHints =
 		options.output.resourceHints && options.output.resourceHints.urlHints;
 	if (outputUrlHints && outputUrlHints.length > 0) {
@@ -660,14 +659,12 @@ const applyExperimentsDefaults = (
 		experiments.futureDefaults ? true : "auto"
 	);
 
-	// Resolve the "auto" default: enable the built-in css/html module type unless
-	// the user already registered a loader (or explicit type) for these files, so
-	// enabling them by default does not break existing css-loader/html-loader setups.
-	// The built-in `/\.css$/i` rule also covers `.module.css`, so a loader scoped to
-	// CSS modules must disable the built-in type too — sample both extensions.
-	// When enabled implicitly the value stays `"auto"` (truthy): Css/HtmlModulesPlugin
-	// then step aside per-module for requests that loaders were applied to
-	// (inline requests or loaders injected via hooks, e.g. html-webpack-plugin).
+	// Resolve `"auto"`: enable the built-in type unless a loader is already
+	// registered for these files, so the default breaks no existing setup. Both
+	// extensions are sampled, since `/\.css$/i` also covers `.module.css`.
+
+	// Enabled implicitly the value stays `"auto"`, and the plugins then step
+	// aside per module for requests loaders were applied to.
 	// TODO webpack 6: css/html default to `true`, drop the `"auto"` marker.
 	if (experiments.css === "auto") {
 		experiments.css =
@@ -1227,18 +1224,13 @@ const applyModuleDefaults = (
 	}
 
 	if (html) {
-		// `module.generator.html.extract` is intentionally left undefined by
-		// default: HtmlGenerator treats undefined as "extract iff this HTML
-		// module is a compilation entry", which is the HTML-entry-point
-		// behaviour. Setting `extract: true` forces extraction for all HTML
-		// modules (including imported ones); `extract: false` disables it
-		// everywhere.
+		// `extract` is deliberately left undefined, which HtmlGenerator reads as
+		// "extract only a module that is a compilation entry". `true` forces it for
+		// imported modules too, `false` disables it everywhere.
 		F(module.generator, HTML_MODULE_TYPE, () => ({}));
-		// `module.parser.html.sources` defaults to `true` — HtmlParser uses
-		// the built-in source list to extract URL-like attributes (`<img
-		// src>`, `<link href>`, `<script src>`, …) as webpack dependencies.
-		// Users may pass `false` to disable extraction entirely or an array
-		// (with `"..."` to include the defaults) to customize it.
+		// `sources` defaults to `true`, so HtmlParser extracts URL-like attributes
+		// as dependencies from its built-in list. `false` disables extraction, and
+		// an array customizes it, with `"..."` keeping the defaults.
 		F(module.parser, HTML_MODULE_TYPE, () => ({}));
 		D(
 			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[HTML_MODULE_TYPE]>} */
@@ -1372,11 +1364,9 @@ const applyModuleDefaults = (
 				type: CSS_MODULE_TYPE,
 				resolve
 			});
-			// For CSS modules, i.e. `.class { composes: className from "./style.css" }`
-			// We inherit for such constructions, but skip files that are already
-			// detected as CSS modules by extension (`.module.<ext>`) — they get
-			// the same modules-mode behavior from the auto rule, and forcing a
-			// different type stamp here would create a duplicate module instance.
+			// For `composes: className from "./style.css"`. A file already detected as
+			// a CSS module by extension is skipped: it gets modules mode from the auto
+			// rule anyway, and a second type stamp would duplicate the module.
 			const moduleExtension = /\.module\.\w+$/i;
 			rules.push({
 				dependency: /css-import-local-module/,
@@ -1426,11 +1416,9 @@ const applyModuleDefaults = (
 				type: HTML_MODULE_TYPE,
 				resolve
 			});
-			// `<iframe srcdoc>` content is fed back through the HTML pipeline as a
-			// `data:text/html` module. `extract: "inline"` exposes the processed
-			// HTML on the `html` codegen channel that `HtmlInlineHtmlDependency.
-			// Template` reads back into the attribute, without emitting a standalone
-			// `.html` file (the module is never a page on its own).
+			// `<iframe srcdoc>` content goes back through the HTML pipeline as a
+			// `data:text/html` module. `extract: "inline"` exposes it on the `html`
+			// channel without emitting a file: it is never a page on its own.
 			rules.push({
 				dependency: "html-srcdoc",
 				generator: {
@@ -1439,12 +1427,9 @@ const applyModuleDefaults = (
 				resolve
 			});
 			if (css) {
-				// Inline `<style>` content in an HTML module is fed into the
-				// CSS pipeline as a `data:text/css` virtual module. We force
-				// `exportType: "text"` so the CSS module exposes the
-				// processed CSS text on the `css-text` codegen channel that
-				// `HtmlInlineStyleDependency.Template` reads back into the
-				// `<style>` tag.
+				// Inline `<style>` content goes into the CSS pipeline as a
+				// `data:text/css` module. `exportType: "text"` is forced, so the
+				// processed text reaches the `css-text` channel the template reads.
 				rules.push({
 					dependency: "html-style",
 					parser: {
@@ -1750,12 +1735,11 @@ const applyOutputDefaults = (
 		"const",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.const))
 	);
-	// Only the browserslist target reports these; everywhere else they stay
-	// unset, which `optimistic` reads as the modern spelling being available —
-	// the same policy the JS features above follow.
-	// `let` was added after `const`; targets predating it report only `const`,
-	// so fall back to `const` when `let` is unreported (undefined). Targets that
-	// do report `let` (browserslist, built-ins) keep their own accurate value.
+	// Only the browserslist target reports these; unset elsewhere, which
+	// `optimistic` reads as the modern spelling being available.
+
+	// `let` was added after `const`, so a target predating it reports only
+	// `const` and falls back to it. One reporting `let` keeps its own value.
 	F(environment, "let", () =>
 		conditionallyOptimistic(
 			/** @type {boolean | undefined} */ (tp && tp.let),
@@ -1887,10 +1871,9 @@ const applyOutputDefaults = (
 			tp && optimistic(/** @type {boolean | undefined} */ (tp.modulePreload))
 	);
 
-	// Vite-style default for ESM output (`output.module`): preload the entry's
-	// initial dependency graph, which native `import()` would otherwise fetch in
-	// a waterfall. Classic output loads initial chunks via parallel `<script>`
-	// tags (no waterfall), so it stays opt-in.
+	// For ESM output, preload the entry's initial dependency graph, which native
+	// `import()` would otherwise fetch in a waterfall. Classic output loads its
+	// initial chunks in parallel already, so it stays opt-in.
 	if (output.module && output.resourceHints === undefined) {
 		output.resourceHints = {};
 	}
@@ -1944,13 +1927,9 @@ const applyOutputDefaults = (
 		}
 		return "[id].css";
 	});
-	// Derive html filename defaults from `output.filename` / `output.chunkFilename`
-	// (the same shape the CSS pipeline uses), but if the derived template lacks
-	// any per-module differentiator, fall back to `[name].html` so multiple
-	// extracted HTML modules in one compilation don't collide on the same
-	// emitted file. For example: `output.filename: "bundle.js"` would derive
-	// `bundle.html` — two `.html` modules extracted in the same build would
-	// both want that name and conflict at emit time.
+	// Derive the html filenames from `output.filename`, as the CSS pipeline does.
+	// A derived template with no per-module placeholder falls back to
+	// `[name].html`, or two extracted modules would want the same file.
 	const HAS_PATH_PLACEHOLDER_REGEXP =
 		/\[(name|id|chunkhash|contenthash|fullhash|hash)/;
 	/**
@@ -1997,11 +1976,9 @@ const applyOutputDefaults = (
 		if (tp) {
 			if (tp.global) return "global";
 			if (tp.globalThis) return "globalThis";
-			// Universal target (web + node): no one identifier is defined on both
-			// sides, so `globalThis` where the target reports nothing against it,
-			// and a guarded pair where it does — `self` covers window and worker
-			// scopes, `global` covers Node.js. Naming either alone leaves the other
-			// platform reading an undeclared binding.
+			// A universal target has no identifier defined on both sides, so this is
+			// `globalThis` where nothing argues against it and a guarded pair where
+			// something does: naming one alone leaves the other undeclared.
 			if (tp.web === null && tp.node === null) {
 				return tp.globalThis === undefined
 					? "globalThis"
@@ -2531,19 +2508,17 @@ const applyOptimizationDefaults = (
 				// Lazy load the minimizer plugin
 				const TerserPlugin = require("minimizer-webpack-plugin");
 
-				// One minimizer instance (one worker-thread pool) handles JS and, when
-				// native CSS / HTML is enabled, those assets too — an array of minify
-				// functions each dispatched by its own `filter` (terser -> JS,
-				// cssMinify -> CSS, htmlMinify -> HTML). The CSS / HTML serializers stay
-				// worker-safe by resolving their parser with `require("webpack/…")` in
-				// the worker, so all three share the same pool. `test` is widened to let
-				// CSS / HTML assets reach the dispatcher.
-				// Step aside for a minimizer the user already configured for these
-				// types: whichever of the two ran first would mark the asset
-				// `minimized` and silently disable the other, so webpack only claims
-				// what nothing else does. Their asset matchers are read directly rather
-				// than resolved per asset — a coarse check, but it keeps the outcome
-				// independent of tap order and of the plugin version in use.
+				// WHY: one minimizer instance, so one worker-thread pool, handles JS and
+				// — where native CSS and HTML are enabled — those assets too, as an array
+				// of minify functions each dispatched by its own `filter`: terser to JS,
+				// `cssMinify` to CSS, `htmlMinify` to HTML. The CSS and HTML serializers
+				// stay worker-safe by resolving their parser with `require("webpack/…")`
+				// in the worker, so all three share the pool, and `test` is widened to let
+				// those assets reach the dispatcher.
+
+				// Step aside for a minimizer the user configured for these types:
+				// whichever ran first would mark the asset `minimized` and silently
+				// disable the other. Matchers are read directly, coarse but stable.
 				const claimedByOtherMinimizer = require("./getClaimedAssetTypes")(
 					compiler
 				);
@@ -2619,10 +2594,9 @@ const applyOptimizationDefaults = (
 				}
 				if (minifyHtml) {
 					minify.push(require("../html/htmlMinify"));
-					// `minimize.css` rides along under its own key rather than spread
-					// beside the HTML options: the two name some of the same switches
-					// (`quotes`, `comments`), and one flat object would hand
-					// each language the other's answer.
+					// `minimize.css` rides under its own key rather than spread beside the
+					// HTML options: the two name some of the same switches, so one flat
+					// object would hand each language the other's answer.
 					minimizerOptions.push({
 						environment: cssEnvironment,
 						css: cssOptions,

package/lib/config/getClaimedAssetTypes.js

@@ -17,19 +17,18 @@ const { matchObject } = require("../ModuleFilenameHelpers");
  * @returns {boolean} whether the candidate minimizes that file
  */
 const claims = (candidate, file) => {
-	// Every minimizer in the `minimizer-webpack-plugin` family (itself,
-	// `css-minimizer-webpack-plugin`, `html-minimizer-webpack-plugin`, …) keeps
-	// the minify implementation on `options.minimizer` and its asset matcher
-	// alongside it in the shape `matchObject` reads. The matcher alone is not
-	// enough to recognize one: `BannerPlugin` and `SourceMapDevToolPlugin` carry
-	// the same three keys, and `LoaderOptionsPlugin` defaults `test` to match
-	// every file — reading those as minimizers would disable minification.
+	// WHY: every minimizer in the `minimizer-webpack-plugin` family — itself,
+	// `css-minimizer-webpack-plugin`, `html-minimizer-webpack-plugin`, … — keeps
+	// its implementation on `options.minimizer` and its asset matcher alongside
+	// it, in the shape `matchObject` reads. The matcher alone is not enough to
+	// recognize one: `BannerPlugin` and `SourceMapDevToolPlugin` carry the same
+	// three keys, and `LoaderOptionsPlugin` defaults `test` to match every file,
+	// so reading those as minimizers would disable minification.
 	const { options } = /** @type {{ options?: MinimizerOptions }} */ (candidate);
 	if (!options || !options.minimizer) return false;
-	// `test`/`include` say which types it handles, `exclude` only narrows the
-	// files within them — honouring that narrowing would make a minimizer scoped
-	// to a subdirectory claim nothing, and webpack would then race it on the very
-	// files it was configured for.
+	// `test` and `include` say which types it handles, while `exclude` only
+	// narrows the files within them: honoring that narrowing would let a minimizer
+	// scoped to a subdirectory claim nothing, and webpack would then race it.
 	const { test, include } = options;
 	return (
 		(test !== undefined && matchObject({ test }, file)) ||

package/lib/config/target.js

@@ -345,10 +345,9 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 		"Bun in version X.Y. Output is always ECMAScript modules. Examples: bun, bun1.1.",
 		/^bun((\d+)(?:\.(\d+))?)?$/,
 		() => ({
-			// Bun is a modern, Node.js-compatible runtime; every released version
-			// supports the full modern ECMAScript feature set, so the version is
-			// accepted but does not gate any feature. Output is always ESM, so sync
-			// CommonJS `require` is never available.
+			// Every released Bun supports the full modern feature set, so a version is
+			// accepted but gates nothing. Output is always ESM, leaving no synchronous
+			// CommonJS `require`.
 			node: true,
 			bun: true,
 			web: false,

package/lib/{ContextExclusionPlugin.js → context/ContextExclusionPlugin.js}

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @import Compiler from "./Compiler" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "ContextExclusionPlugin";
 

package/lib/{ContextModule.js → context/ContextModule.js}

@@ -6,49 +6,52 @@
 "use strict";
 
 const { OriginalSource, RawSource } = require("webpack-sources");
-const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
-const Module = require("./Module");
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const Module = require("../Module");
 const {
 	JAVASCRIPT_TYPE,
 	JAVASCRIPT_TYPES
-} = require("./ModuleSourceTypeConstants");
-const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const Template = require("./Template");
+} = require("../ModuleSourceTypeConstants");
+const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
 const {
 	getOutgoingAsyncModules
-} = require("./async-modules/AsyncModuleHelpers");
-const { ImportPhase, ImportPhaseUtils } = require("./dependencies/ImportPhase");
-const { makeWebpackError } = require("./errors/HookWebpackError");
-const WebpackError = require("./errors/WebpackError");
+} = require("../async-modules/AsyncModuleHelpers");
+const {
+	ImportPhase,
+	ImportPhaseUtils
+} = require("../dependencies/ImportPhase");
+const { makeWebpackError } = require("../errors/HookWebpackError");
+const WebpackError = require("../errors/WebpackError");
 const {
 	compareLocations,
 	compareModulesById,
 	compareSelect,
 	concatComparators,
 	keepOriginalOrder
-} = require("./util/comparators");
+} = require("../util/comparators");
 const {
 	contextify,
 	makePathsRelative,
 	parseResource
-} = require("./util/identifier");
-const makeSerializable = require("./util/makeSerializable");
-const { propertyAccess } = require("./util/property");
+} = require("../util/identifier");
+const makeSerializable = require("../util/makeSerializable");
+const { propertyAccess } = require("../util/property");
 
 /** @import { Source } from "webpack-sources" */
-/** @import { ResolveOptions } from "../declarations/WebpackOptions" */
+/** @import { ResolveOptions } from "../../declarations/WebpackOptions" */
 /**
  * @import {
  * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
- * } from "./config/defaults"
+ * } from "../config/defaults"
  */
-/** @import Chunk, { ChunkId, ChunkName } from "./Chunk" */
-/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
-/** @import { RawChunkGroupOptions } from "./ChunkGroup" */
-/** @import Compilation, { FileSystemDependencies } from "./Compilation" */
-/** @import Dependency, { RawReferencedExports } from "./Dependency" */
-/** @import { Snapshot } from "./FileSystemInfo" */
+/** @import Chunk, { ChunkId, ChunkName } from "../Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../ChunkGraph" */
+/** @import { RawChunkGroupOptions } from "../ChunkGroup" */
+/** @import Compilation, { FileSystemDependencies } from "../Compilation" */
+/** @import Dependency, { RawReferencedExports } from "../Dependency" */
+/** @import { Snapshot } from "../FileSystemInfo" */
 /**
  * @import {
  * 	BuildCallback,
@@ -63,17 +66,17 @@ const { propertyAccess } = require("./util/property");
  * 	RuntimeRequirements,
  * 	Sources,
  * 	SourceTypes
- * } from "./Module"
+ * } from "../Module"
  */
-/** @import RequestShortener from "./RequestShortener" */
-/** @import { ResolverWithOptions } from "./ResolverFactory" */
-/** @import RuntimeTemplate from "./RuntimeTemplate" */
-/** @import ContextElementDependency from "./dependencies/ContextElementDependency" */
-/** @import { ImportAttributes } from "./javascript/JavascriptParser" */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<[string, boolean]>} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<[string, boolean]>} ObjectSerializerContext */
-/** @import { InputFileSystem } from "./util/fs" */
-/** @import { ImportPhaseType } from "./dependencies/ImportPhase" */
+/** @import RequestShortener from "../RequestShortener" */
+/** @import { ResolverWithOptions } from "../ResolverFactory" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import ContextElementDependency from "../dependencies/ContextElementDependency" */
+/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, boolean]>} ObjectSerializerContext */
+/** @import { InputFileSystem } from "../util/fs" */
+/** @import { ImportPhaseType } from "../dependencies/ImportPhase" */
 
 /** @typedef {"sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"} ContextMode Context mode */
 
@@ -1473,7 +1476,7 @@ module.exports = webpackEmptyAsyncContext;`;
 		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
 		const globImportAccess = this.getImportPropertyAccess();
 		const sortedDependencies =
-			/** @type {import("./dependencies/ContextElementDependency")[]} */
+			/** @type {import("../dependencies/ContextElementDependency")[]} */
 			(dependencies).sort((a, b) =>
 				a.userRequest < b.userRequest
 					? -1
@@ -1724,6 +1727,6 @@ module.exports = webpackEmptyAsyncContext;`;
 	}
 }
 
-makeSerializable(ContextModule, "webpack/lib/ContextModule");
+makeSerializable(ContextModule, "webpack/lib/context/ContextModule");
 
 module.exports = ContextModule;