webpack 5.111.0 → 5.112.0

package/lib/dependencies/{HarmonyImportSpecifierDependency.js → esm/ESMImportSpecifierDependency.js}

@@ -5,69 +5,69 @@
 
 "use strict";
 
-const Dependency = require("../Dependency");
-const InitFragment = require("../InitFragment");
-const Template = require("../Template");
+const Dependency = require("../../graph/Dependency");
 const {
-	InlinedUsedName,
 	isExportInlined,
 	isInlineEnabled,
-	isInlineExportsEnabled
-} = require("../optimize/InlineExports");
+	isInlineExportsEnabled,
+	isInlinedUsedName
+} = require("../../optimize/InlineExports");
 const {
 	getDependencyUsedByExportsCondition
-} = require("../optimize/InnerGraph");
-const { getTrimmedIdsAndRange } = require("../util/chainedImports");
-const makeSerializable = require("../util/makeSerializable");
-const { propertyAccess } = require("../util/property");
-const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
-const HarmonyImportDependency = require("./HarmonyImportDependency");
-const HarmonyImportGuard = require("./HarmonyImportGuard");
-const { ImportPhaseUtils } = require("./ImportPhase");
+} = require("../../optimize/InnerGraph");
+const InitFragment = require("../../template/InitFragment");
+const Template = require("../../template/Template");
+const makeSerializable = require("../../util/makeSerializable");
+const { propertyAccess } = require("../../util/property");
+const { ImportPhaseUtils } = require("../core/ImportPhase");
+const { getTrimmedIdsAndRange } = require("../helpers/chainedImports");
+const traverseDestructuringAssignmentProperties = require("../helpers/traverseDestructuringAssignmentProperties");
+const ESMImportDependency = require("./ESMImportDependency");
+const ESMImportGuard = require("./ESMImportGuard");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import { GetConditionFn, ReferencedExports, UpdateHashContext } from "../Dependency" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import Module, { BuildMeta } from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import Hash from "../util/Hash" */
+/** @import { GetConditionFn, ReferencedExports, UpdateHashContext, DependencyKinds } from "../../graph/Dependency" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import Module, { BuildMeta } from "../../module/Module" */
+/** @import ModuleGraph from "../../graph/ModuleGraph" */
+/** @import Hash from "../../util/Hash" */
 /**
  * @import ModuleGraphConnection, {
  * 	ConnectionState
- * } from "../ModuleGraphConnection"
+ * } from "../../graph/ModuleGraphConnection"
  */
-/** @import WebpackError from "../errors/WebpackError" */
+/** @import WebpackError from "../../errors/WebpackError" */
 /**
  * @import {
  * 	DestructuringAssignmentProperties,
  * 	ImportAttributes,
  * 	Range
- * } from "../javascript/JavascriptParser"
+ * } from "../../javascript/JavascriptParser"
  */
-/** @import { UsedByExports } from "../optimize/InnerGraph" */
+/** @import { UsedByExports } from "../../optimize/InnerGraph" */
 /**
  * @import {
  * 	ObjectDeserializerContext,
  * 	ObjectSerializerContext
- * } from "../serialization/ObjectMiddleware"
+ * } from "../../serialization/ObjectMiddleware"
  */
-/** @import { RuntimeSpec } from "../util/runtime" */
-/** @import { IdRanges } from "../util/chainedImports" */
-/** @import { ExportPresenceMode } from "./HarmonyImportDependency" */
-/** @typedef {HarmonyImportDependency.Ids} Ids */
-/** @import { ImportPhaseType } from "./ImportPhase" */
-/** @import { DependencyGuard } from "./HarmonyImportGuard" */
+/** @import { RuntimeSpec } from "../../util/runtime" */
+/** @import { IdRanges } from "../helpers/chainedImports" */
+/** @import { ExportPresenceMode } from "./ESMImportDependency" */
+/** @typedef {ESMImportDependency.Ids} Ids */
+/** @import { ImportPhaseType } from "../core/ImportPhase" */
+/** @import { DependencyGuard } from "./ESMImportGuard" */
 /**
  * @import {
  * 	JavascriptModuleBuildMeta
- * } from "../javascript/JavascriptModule"
+ * } from "../../javascript/JavascriptModule"
  */
 
 const idsSymbol = /** @type {symbol} */ (
-	Symbol("HarmonyImportSpecifierDependency.ids")
+	Symbol("ESMImportSpecifierDependency.ids")
 );
 
-const { ExportPresenceModes } = HarmonyImportDependency;
+const { ExportPresenceModes } = ESMImportDependency;
 
 /**
  * One condition closure per module graph and variant rather than per dependency.
@@ -79,14 +79,9 @@ const { ExportPresenceModes } = HarmonyImportDependency;
  */
 const conditionsByModuleGraph = new WeakMap();
 
-class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
-	// read by `HarmonyImportGuard` in place of `instanceof`, which would cycle
-	get isHarmonyImportSpecifier() {
-		return true;
-	}
-
+class ESMImportSpecifierDependency extends ESMImportDependency {
 	/**
-	 * Creates an instance of HarmonyImportSpecifierDependency.
+	 * Creates an instance of ESMImportSpecifierDependency.
 	 * @param {string} request request
 	 * @param {number} sourceOrder source order
 	 * @param {Ids} ids ids
@@ -106,7 +101,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		exportPresenceMode,
 		phase,
 		attributes,
-		idRanges // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
+		idRanges // TODO in the next major release: make this non-optional. It must always be set to properly trim ids.
 	) {
 		super(request, sourceOrder, phase, attributes);
 		/** @type {Ids} */
@@ -134,9 +129,11 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.referencedPropertiesInDestructuring = undefined;
 		/** @type {DependencyGuard[] | undefined} */
 		this.branchGuards = undefined;
+		/** @type {undefined | boolean} this reference is an assignment target */
+		this.assignment = undefined;
 	}
 
-	// TODO webpack 6 remove
+	// TODO in the next major release: remove
 	/**
 	 * Returns id.
 	 * @deprecated
@@ -145,7 +142,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		throw new Error("id was renamed to ids and type changed to string[]");
 	}
 
-	// TODO webpack 6 remove
+	// TODO in the next major release: remove
 	/**
 	 * Returns id.
 	 * @deprecated
@@ -154,7 +151,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		throw new Error("id was renamed to ids and type changed to string[]");
 	}
 
-	// TODO webpack 6 remove
+	// TODO in the next major release: remove
 	/**
 	 * Updates id.
 	 * @deprecated
@@ -171,7 +168,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * Returns the export name this dependency requests from its target module (lazy barrel optimization).
 	 * @returns {string | true | null} export name, true for all exports, null for none
 	 */
-	getForwardId() {
+	get forwardId() {
 		return this.ids.length > 0 ? this.ids[0] : true;
 	}
 
@@ -231,7 +228,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		if (cached !== undefined) return cached;
 		/** @type {GetConditionFn} */
 		const condition = (connection, runtime) => {
-			const dep = /** @type {HarmonyImportSpecifierDependency} */ (
+			const dep = /** @type {ESMImportSpecifierDependency} */ (
 				connection.dependency
 			);
 			if (usedByExportsCondition !== null) {
@@ -253,7 +250,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 			const guards = dep.branchGuards;
 			if (
 				guards !== undefined &&
-				HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
+				ESMImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
 			) {
 				return false;
 			}
@@ -280,7 +277,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		const exportsInfo = moduleGraph.getExportsInfo(module);
 		if (!exportsInfo.hasInlinedUsedName(ids, runtime)) return;
 		const usedName = exportsInfo.getUsedName(ids, runtime);
-		if (usedName instanceof InlinedUsedName) {
+		if (isInlinedUsedName(usedName)) {
 			usedName.updateHash(hash);
 		}
 	}
@@ -379,8 +376,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 					{
 						name: ids,
 						canMangle: true,
-						// Need access the export value to trigger side effects for deferred module
-						canInline: !ImportPhaseUtils.isDefer(this.phase)
+						// Need access the export value to trigger side effects for deferred module.
+						// An inlined literal cannot be an assignment target at all.
+						canInline: !this.assignment && !ImportPhaseUtils.isDefer(this.phase)
 					}
 				]
 			: Dependency.EXPORTS_OBJECT_REFERENCED;
@@ -473,6 +471,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		write(this.usedByExports);
 		write(this.referencedPropertiesInDestructuring);
 		write(this.branchGuards);
+		write(this.assignment);
 		super.serialize(context);
 	}
 
@@ -495,17 +494,20 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.usedByExports = read();
 		this.referencedPropertiesInDestructuring = read();
 		this.branchGuards = read();
+		this.assignment = read();
 		super.deserialize(context);
 	}
 }
 
-makeSerializable(
-	HarmonyImportSpecifierDependency,
+makeSerializable(ESMImportSpecifierDependency, [
+	"webpack/lib/dependencies/esm/ESMImportSpecifierDependency",
+	// TODO in the next major release: remove, it restores the packs written
+	// under the name the file had before the ESM rename
 	"webpack/lib/dependencies/HarmonyImportSpecifierDependency"
-);
+]);
 
-HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate extends (
-	HarmonyImportDependency.Template
+ESMImportSpecifierDependency.Template = class ESMImportSpecifierDependencyTemplate extends (
+	ESMImportDependency.Template
 ) {
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
@@ -515,7 +517,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const dep = /** @type {HarmonyImportSpecifierDependency} */ (dependency);
+		const dep = /** @type {ESMImportSpecifierDependency} */ (dependency);
 		const { moduleGraph, runtime, initFragments } = templateContext;
 		const connection = moduleGraph.getConnection(dep);
 		const ids = dep.getIds(moduleGraph);
@@ -528,7 +530,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 			initFragments.push(
 				new InitFragment(
 					`/* unused harmony import specifier */ var ${dep.name};\n`,
-					InitFragment.STAGE_HARMONY_IMPORTS,
+					InitFragment.STAGE_ESM_IMPORTS,
 					0,
 					`unused import specifier ${dep.name}`
 				)
@@ -603,7 +605,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				const used = destructuredExportsInfo.getUsedName(concatedIds, runtime);
 				if (!used) {
 					return;
-				} else if (used instanceof InlinedUsedName) {
+				} else if (isInlinedUsedName(used)) {
 					throw new Error(
 						`Should not inline for destructuring name ${concatedIds.join(".")}`
 					);
@@ -628,7 +630,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 
 	/**
 	 * Returns generated code.
-	 * @param {HarmonyImportSpecifierDependency} dep dependency
+	 * @param {ESMImportSpecifierDependency} dep dependency
 	 * @param {ReplaceSource} source source
 	 * @param {DependencyTemplateContext} templateContext context
 	 * @param {Ids} ids ids
@@ -677,6 +679,15 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}
 				);
+				// Concatenation merges the binding into a plain local a write would
+				// succeed against. Routing the write at a getter-only property of a
+				// throwaway object restores the TypeError the namespace gave it.
+				if (dep.assignment) {
+					// the local binding, the one name here an export is free not to
+					// spell as an identifier: `import { "a-b" as ab }`
+					const holder = `{ get ${dep.name}() { return ${exportExpr}; } }`;
+					exportExpr = `${dep.asiSafe ? "" : ";"}(${holder}).${dep.name}`;
+				}
 			}
 		} else {
 			super.apply(dep, source, templateContext);
@@ -708,11 +719,49 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 					!dep.referencedPropertiesInDestructuring &&
 					!ImportPhaseUtils.isDefer(dep.phase)
 			});
+
+			// Only a bare reference reads exactly what the binding names.
+			if (
+				dep.directImport === true &&
+				templateContext.dependencyTemplates.importBindingScopes
+			) {
+				// A call site drops the `this` a member access would bind, which is
+				// a statement's concern rather than the binding's value.
+				const value = dep.call
+					? runtimeTemplate.exportFromImport({
+							moduleGraph,
+							module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+							chunkGraph: templateContext.chunkGraph,
+							request: dep.request,
+							exportName: ids,
+							originModule: module,
+							asiSafe: true,
+							isCall: false,
+							callContext: false,
+							defaultInterop: true,
+							importVar: dep.getImportVar(moduleGraph),
+							initFragments,
+							runtime,
+							runtimeRequirements,
+							dependency: dep,
+							mangleableNamespace: false
+						})
+					: exportExpr;
+				if (!value.startsWith(";")) {
+					this._recordImportBinding(templateContext, dep.name, value);
+				}
+			}
 		}
 		return exportExpr;
 	}
 };
 
-HarmonyImportSpecifierDependency.idsSymbol = idsSymbol;
+ESMImportSpecifierDependency.idsSymbol = idsSymbol;
+
+/** @type {Set<keyof DependencyKinds>} */
+ESMImportSpecifierDependency.KINDS = new Set([
+	...ESMImportDependency.KINDS,
+	"esm-import-specifier"
+]);
 
-module.exports = HarmonyImportSpecifierDependency;
+module.exports = ESMImportSpecifierDependency;

package/lib/dependencies/esm/ESMModulesPlugin.js

@@ -0,0 +1,207 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../../module/ModuleTypeConstants");
+const CreateRequireParserPlugin = require("./CreateRequireParserPlugin");
+const ESMAcceptDependency = require("./ESMAcceptDependency");
+const ESMAcceptImportDependency = require("./ESMAcceptImportDependency");
+const ESMCompatibilityDependency = require("./ESMCompatibilityDependency");
+const ESMDetectionParserPlugin = require("./ESMDetectionParserPlugin");
+const ESMEvaluatedImportSpecifierDependency = require("./ESMEvaluatedImportSpecifierDependency");
+const ESMExportDependencyParserPlugin = require("./ESMExportDependencyParserPlugin");
+const ESMExportExpressionDependency = require("./ESMExportExpressionDependency");
+const ESMExportHeaderDependency = require("./ESMExportHeaderDependency");
+const ESMExportImportedSideEffectDependency = require("./ESMExportImportedSideEffectDependency");
+const ESMExportImportedSpecifierDependency = require("./ESMExportImportedSpecifierDependency");
+const ESMExportSpecifierDependency = require("./ESMExportSpecifierDependency");
+const ESMImportBareSideEffectDependency = require("./ESMImportBareSideEffectDependency");
+const ESMImportDependencyParserPlugin = require("./ESMImportDependencyParserPlugin");
+const ESMImportSideEffectDependency = require("./ESMImportSideEffectDependency");
+const ESMImportSpecifierDependency = require("./ESMImportSpecifierDependency");
+
+const ESMTopLevelThisParserPlugin = require("./ESMTopLevelThisParserPlugin");
+const TopLevelAwaitDependency = require("./TopLevelAwaitDependency");
+
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../../Compiler" */
+/** @import Parser from "../../javascript/JavascriptParser" */
+/** @import { BuildInfo } from "../../module/Module" */
+
+/**
+ * Defines the harmony modules plugin options type used by this module.
+ * @typedef {object} ESMModulesPluginOptions
+ * @property {boolean=} deferImport
+ */
+
+const PLUGIN_NAME = "ESMModulesPlugin";
+
+class ESMModulesPlugin {
+	/**
+	 * Creates an instance of ESMModulesPlugin.
+	 * @param {ESMModulesPluginOptions} options options
+	 */
+	constructor(options) {
+		/** @type {ESMModulesPluginOptions} */
+		this.options = options;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ESMCompatibilityDependency,
+					new ESMCompatibilityDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					TopLevelAwaitDependency,
+					new TopLevelAwaitDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ESMImportSideEffectDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ESMImportSideEffectDependency,
+					new ESMImportSideEffectDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ESMImportBareSideEffectDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ESMImportBareSideEffectDependency,
+					new ESMImportBareSideEffectDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ESMExportImportedSideEffectDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ESMExportImportedSideEffectDependency,
+					new ESMExportImportedSideEffectDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ESMImportSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ESMImportSpecifierDependency,
+					new ESMImportSpecifierDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ESMEvaluatedImportSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ESMEvaluatedImportSpecifierDependency,
+					new ESMEvaluatedImportSpecifierDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					ESMExportHeaderDependency,
+					new ESMExportHeaderDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					ESMExportExpressionDependency,
+					new ESMExportExpressionDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					ESMExportSpecifierDependency,
+					new ESMExportSpecifierDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ESMExportImportedSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ESMExportImportedSpecifierDependency,
+					new ESMExportImportedSpecifierDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					ESMAcceptDependency,
+					new ESMAcceptDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ESMAcceptImportDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ESMAcceptImportDependency,
+					new ESMAcceptImportDependency.Template()
+				);
+
+				/**
+				 * Handles the hook callback for this code path.
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					// TODO in the next major release: remove the `harmony` half,
+					// `esm` is its new spelling
+					const esm =
+						parserOptions.esm !== undefined
+							? parserOptions.esm
+							: parserOptions.harmony;
+					if (esm !== undefined && !esm) {
+						return;
+					}
+
+					if (parserOptions.specNamespaceObject) {
+						// Recorded on the module, because an importer asks the module it
+						// imports whether its namespace is a spec exotic object.
+						parser.hooks.program.tap(PLUGIN_NAME, () => {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).specNamespaceObject = true;
+						});
+					}
+
+					new ESMDetectionParserPlugin().apply(parser);
+					new ESMImportDependencyParserPlugin(parserOptions).apply(parser);
+					new ESMExportDependencyParserPlugin(parserOptions).apply(parser);
+					new ESMTopLevelThisParserPlugin().apply(parser);
+					if (parserOptions.createRequire) {
+						new CreateRequireParserPlugin(parserOptions).apply(parser);
+					}
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
+			}
+		);
+	}
+}
+
+module.exports = ESMModulesPlugin;

package/lib/dependencies/{HarmonyTopLevelThisParserPlugin.js → esm/ESMTopLevelThisParserPlugin.js}

@@ -5,14 +5,14 @@
 
 "use strict";
 
-const ConstDependency = require("./ConstDependency");
-const HarmonyExports = require("./HarmonyExports");
+const ConstDependency = require("../core/ConstDependency");
+const ESMExports = require("./ESMExports");
 
-/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
+/** @import JavascriptParser, { Range } from "../../javascript/JavascriptParser" */
 
-const PLUGIN_NAME = "HarmonyTopLevelThisParserPlugin";
+const PLUGIN_NAME = "ESMTopLevelThisParserPlugin";
 
-class HarmonyTopLevelThisParserPlugin {
+class ESMTopLevelThisParserPlugin {
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
@@ -21,7 +21,7 @@ class HarmonyTopLevelThisParserPlugin {
 	apply(parser) {
 		parser.hooks.expression.for("this").tap(PLUGIN_NAME, (node) => {
 			if (!parser.scope.topLevelScope) return;
-			if (HarmonyExports.isEnabled(parser.state)) {
+			if (ESMExports.isEnabled(parser.state)) {
 				const dep = new ConstDependency(
 					"undefined",
 					/** @type {Range} */ (node.range),
@@ -35,4 +35,4 @@ class HarmonyTopLevelThisParserPlugin {
 	}
 }
 
-module.exports = HarmonyTopLevelThisParserPlugin;
+module.exports = ESMTopLevelThisParserPlugin;

package/lib/dependencies/{TopLevelAwaitDependency.js → esm/TopLevelAwaitDependency.js}

@@ -4,20 +4,20 @@
 
 "use strict";
 
-const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
-const makeSerializable = require("../util/makeSerializable");
-const NullDependency = require("./NullDependency");
+const isGeneratorLowered = require("../../async-modules/isGeneratorLowered");
+const makeSerializable = require("../../util/makeSerializable");
+const NullDependency = require("../core/NullDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import Dependency from "../Dependency" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import Module from "../Module" */
-/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import Dependency from "../../graph/Dependency" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import Module from "../../module/Module" */
+/** @import { Range } from "../../javascript/JavascriptParser" */
 /**
  * @import {
  * 	ObjectDeserializerContext,
  * 	ObjectSerializerContext
- * } from "../serialization/ObjectMiddleware"
+ * } from "../../serialization/ObjectMiddleware"
  */
 
 /**
@@ -60,10 +60,11 @@ class TopLevelAwaitDependency extends NullDependency {
 	}
 }
 
-makeSerializable(
-	TopLevelAwaitDependency,
+makeSerializable(TopLevelAwaitDependency, [
+	"webpack/lib/dependencies/esm/TopLevelAwaitDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/TopLevelAwaitDependency"
-);
+]);
 
 TopLevelAwaitDependency.Template = class TopLevelAwaitDependencyTemplate extends (
 	NullDependency.Template

package/lib/dependencies/{DynamicExports.js → helpers/DynamicExports.js}

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @import { BuildMeta } from "../Module" */
-/** @import { JavascriptParserState } from "../javascript/JavascriptParser" */
+/** @import { BuildMeta } from "../../module/Module" */
+/** @import { JavascriptParserState } from "../../javascript/JavascriptParser" */
 
 /** @type {WeakMap<JavascriptParserState, boolean>} */
 const parserStateExportsState = new WeakMap();

package/lib/{util → dependencies/helpers}/chainedImports.js

@@ -5,10 +5,10 @@
 
 "use strict";
 
-/** @import Dependency from "../Dependency" */
-/** @import Module from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import Dependency from "../../graph/Dependency" */
+/** @import Module from "../../module/Module" */
+/** @import ModuleGraph from "../../graph/ModuleGraph" */
+/** @import { Range } from "../../javascript/JavascriptParser" */
 
 /** @typedef {Range[]} IdRanges */
 
@@ -39,10 +39,9 @@ module.exports.getTrimmedIdsAndRange = (
 	);
 	let trimmedRange = untrimmedRange;
 	if (trimmedIds.length !== untrimmedIds.length) {
-		// The array returned from dep.idRanges is right-aligned with the array returned from dep.names.
-		// Meaning, the two arrays may not always have the same number of elements, but the last element of
-		// dep.idRanges corresponds to [the expression fragment to the left of] the last element of dep.names.
-		// Use this to find the correct replacement range based on the number of ids that were trimmed.
+		// `dep.idRanges` is right-aligned with `dep.names`: the two may differ in
+		// length, but their last elements correspond, which is what turns the count
+		// of trimmed ids into the replacement range.
 		const idx =
 			ranges === undefined
 				? -1 /* trigger failure case below */
@@ -52,7 +51,7 @@ module.exports.getTrimmedIdsAndRange = (
 			// Should not happen but we can't throw an error here because of backward compatibility with
 			// external plugins in wp5.  Instead, we just disable trimming for now.  This may break some minifiers.
 			trimmedIds = untrimmedIds;
-			// TODO webpack 6 remove the "trimmedIds = ids" above and uncomment the following line instead.
+			// TODO in the next major release: remove the "trimmedIds = ids" above and uncomment the following line instead.
 			// throw new Error("Missing range starts data for id replacement trimming.");
 		} else {
 			trimmedRange = /** @type {Range[]} */ (ranges)[idx];