webpack 5.59.0 → 5.76.0

package/lib/ids/DeterministicModuleIdsPlugin.js

@@ -9,7 +9,7 @@ const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
 const {
-	getUsedModuleIds,
+	getUsedModuleIdsAndModules,
 	getFullModuleName,
 	assignDeterministicIds
 } = require("./IdHelpers");
@@ -18,8 +18,17 @@ const {
 /** @typedef {import("../Module")} Module */
 
 class DeterministicModuleIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {Object} options options
+	 * @param {string=} options.context context relative to which module identifiers are computed
+	 * @param {function(Module): boolean=} options.test selector function for modules
+	 * @param {number=} options.maxLength maximum id length in digits (used as starting point)
+	 * @param {number=} options.salt hash salt for ids
+	 * @param {boolean=} options.fixedLength do not increase the maxLength to find an optimal id space size
+	 * @param {boolean=} options.failOnConflict throw an error when id conflicts occur (instead of rehashing)
+	 */
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**
@@ -31,40 +40,51 @@ class DeterministicModuleIdsPlugin {
 		compiler.hooks.compilation.tap(
 			"DeterministicModuleIdsPlugin",
 			compilation => {
-				compilation.hooks.moduleIds.tap(
-					"DeterministicModuleIdsPlugin",
-					modules => {
-						const chunkGraph = compilation.chunkGraph;
-						const context = this.options.context
-							? this.options.context
-							: compiler.context;
-						const maxLength = this.options.maxLength || 3;
+				compilation.hooks.moduleIds.tap("DeterministicModuleIdsPlugin", () => {
+					const chunkGraph = compilation.chunkGraph;
+					const context = this.options.context
+						? this.options.context
+						: compiler.context;
+					const maxLength = this.options.maxLength || 3;
+					const failOnConflict = this.options.failOnConflict || false;
+					const fixedLength = this.options.fixedLength || false;
+					const salt = this.options.salt || 0;
+					let conflicts = 0;
 
-						const usedIds = getUsedModuleIds(compilation);
-						assignDeterministicIds(
-							Array.from(modules).filter(module => {
-								if (!module.needId) return false;
-								if (chunkGraph.getNumberOfModuleChunks(module) === 0)
-									return false;
-								return chunkGraph.getModuleId(module) === null;
-							}),
-							module => getFullModuleName(module, context, compiler.root),
-							compareModulesByPreOrderIndexOrIdentifier(
-								compilation.moduleGraph
-							),
-							(module, id) => {
-								const size = usedIds.size;
-								usedIds.add(`${id}`);
-								if (size === usedIds.size) return false;
-								chunkGraph.setModuleId(module, id);
-								return true;
-							},
-							[Math.pow(10, maxLength)],
-							10,
-							usedIds.size
+					const [usedIds, modules] = getUsedModuleIdsAndModules(
+						compilation,
+						this.options.test
+					);
+					assignDeterministicIds(
+						modules,
+						module => getFullModuleName(module, context, compiler.root),
+						failOnConflict
+							? () => 0
+							: compareModulesByPreOrderIndexOrIdentifier(
+									compilation.moduleGraph
+							  ),
+						(module, id) => {
+							const size = usedIds.size;
+							usedIds.add(`${id}`);
+							if (size === usedIds.size) {
+								conflicts++;
+								return false;
+							}
+							chunkGraph.setModuleId(module, id);
+							return true;
+						},
+						[Math.pow(10, maxLength)],
+						fixedLength ? 0 : 10,
+						usedIds.size,
+						salt
+					);
+					if (failOnConflict && conflicts)
+						throw new Error(
+							`Assigning deterministic module ids has lead to ${conflicts} conflict${
+								conflicts > 1 ? "s" : ""
+							}.\nIncrease the 'maxLength' to increase the id space and make conflicts less likely (recommended when there are many conflicts or application is expected to grow), or add an 'salt' number to try another hash starting value in the same id space (recommended when there is only a single conflict).`
 						);
-					}
-				);
+				});
 			}
 		);
 	}

package/lib/ids/HashedModuleIdsPlugin.js

@@ -10,7 +10,10 @@ const {
 } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
 const createHash = require("../util/createHash");
-const { getUsedModuleIds, getFullModuleName } = require("./IdHelpers");
+const {
+	getUsedModuleIdsAndModules,
+	getFullModuleName
+} = require("./IdHelpers");
 
 /** @typedef {import("../../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
 
@@ -43,22 +46,16 @@ class HashedModuleIdsPlugin {
 	apply(compiler) {
 		const options = this.options;
 		compiler.hooks.compilation.tap("HashedModuleIdsPlugin", compilation => {
-			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", modules => {
+			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", () => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.options.context
 					? this.options.context
 					: compiler.context;
 
-				const usedIds = getUsedModuleIds(compilation);
-				const modulesInNaturalOrder = Array.from(modules)
-					.filter(m => {
-						if (!m.needId) return false;
-						if (chunkGraph.getNumberOfModuleChunks(m) === 0) return false;
-						return chunkGraph.getModuleId(module) === null;
-					})
-					.sort(
-						compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
-					);
+				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
+				const modulesInNaturalOrder = modules.sort(
+					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
+				);
 				for (const module of modulesInNaturalOrder) {
 					const ident = getFullModuleName(module, context, compiler.root);
 					const hash = createHash(options.hashFunction);
@@ -67,8 +64,8 @@ class HashedModuleIdsPlugin {
 						hash.digest(options.hashDigest)
 					);
 					let len = options.hashDigestLength;
-					while (usedIds.has(hashId.substr(0, len))) len++;
-					const moduleId = hashId.substr(0, len);
+					while (usedIds.has(hashId.slice(0, len))) len++;
+					const moduleId = hashId.slice(0, len);
 					chunkGraph.setModuleId(module, moduleId);
 					usedIds.add(moduleId);
 				}

package/lib/ids/IdHelpers.js

@@ -25,7 +25,7 @@ const getHash = (str, len, hashFunction) => {
 	const hash = createHash(hashFunction);
 	hash.update(str);
 	const digest = /** @type {string} */ (hash.digest("hex"));
-	return digest.substr(0, len);
+	return digest.slice(0, len);
 };
 
 /**
@@ -234,11 +234,14 @@ const addToMapOfItems = (map, key, value) => {
 
 /**
  * @param {Compilation} compilation the compilation
- * @returns {Set<string>} used module ids as strings
+ * @param {function(Module): boolean=} filter filter modules
+ * @returns {[Set<string>, Module[]]} used module ids as strings and modules without id matching the filter
  */
-const getUsedModuleIds = compilation => {
+const getUsedModuleIdsAndModules = (compilation, filter) => {
 	const chunkGraph = compilation.chunkGraph;
 
+	const modules = [];
+
 	/** @type {Set<string>} */
 	const usedIds = new Set();
 	if (compilation.usedModuleIds) {
@@ -248,15 +251,23 @@ const getUsedModuleIds = compilation => {
 	}
 
 	for (const module of compilation.modules) {
+		if (!module.needId) continue;
 		const moduleId = chunkGraph.getModuleId(module);
 		if (moduleId !== null) {
 			usedIds.add(moduleId + "");
+		} else {
+			if (
+				(!filter || filter(module)) &&
+				chunkGraph.getNumberOfModuleChunks(module) !== 0
+			) {
+				modules.push(module);
+			}
 		}
 	}
 
-	return usedIds;
+	return [usedIds, modules];
 };
-exports.getUsedModuleIds = getUsedModuleIds;
+exports.getUsedModuleIdsAndModules = getUsedModuleIdsAndModules;
 
 /**
  * @param {Compilation} compilation the compilation
@@ -359,6 +370,7 @@ exports.assignNames = assignNames;
  * @param {number[]} ranges usable ranges for ids
  * @param {number} expandFactor factor to create more ranges
  * @param {number} extraSpace extra space to allocate, i. e. when some ids are already used
+ * @param {number} salt salting number to initialize hashing
  * @returns {void}
  */
 const assignDeterministicIds = (
@@ -368,13 +380,14 @@ const assignDeterministicIds = (
 	assignId,
 	ranges = [10],
 	expandFactor = 10,
-	extraSpace = 0
+	extraSpace = 0,
+	salt = 0
 ) => {
 	items.sort(comparator);
 
 	// max 5% fill rate
 	const optimalRange = Math.min(
-		Math.ceil(items.length * 20) + extraSpace,
+		items.length * 20 + extraSpace,
 		Number.MAX_SAFE_INTEGER
 	);
 
@@ -384,15 +397,17 @@ const assignDeterministicIds = (
 		i++;
 		if (i < ranges.length) {
 			range = Math.min(ranges[i], Number.MAX_SAFE_INTEGER);
-		} else {
+		} else if (expandFactor) {
 			range = Math.min(range * expandFactor, Number.MAX_SAFE_INTEGER);
+		} else {
+			break;
 		}
 	}
 
 	for (const item of items) {
 		const ident = getName(item);
 		let id;
-		let i = 0;
+		let i = salt;
 		do {
 			id = numberHash(ident + i++, range);
 		} while (!assignId(item, id));
@@ -401,15 +416,14 @@ const assignDeterministicIds = (
 exports.assignDeterministicIds = assignDeterministicIds;
 
 /**
+ * @param {Set<string>} usedIds used ids
  * @param {Iterable<Module>} modules the modules
  * @param {Compilation} compilation the compilation
  * @returns {void}
  */
-const assignAscendingModuleIds = (modules, compilation) => {
+const assignAscendingModuleIds = (usedIds, modules, compilation) => {
 	const chunkGraph = compilation.chunkGraph;
 
-	const usedIds = getUsedModuleIds(compilation);
-
 	let nextId = 0;
 	let assignId;
 	if (usedIds.size > 0) {

package/lib/ids/NamedModuleIdsPlugin.js

@@ -10,7 +10,7 @@ const {
 	getShortModuleName,
 	getLongModuleName,
 	assignNames,
-	getUsedModuleIds,
+	getUsedModuleIdsAndModules,
 	assignAscendingModuleIds
 } = require("./IdHelpers");
 
@@ -31,27 +31,24 @@ class NamedModuleIdsPlugin {
 		const { root } = compiler;
 		compiler.hooks.compilation.tap("NamedModuleIdsPlugin", compilation => {
 			const { hashFunction } = compilation.outputOptions;
-			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", modules => {
+			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", () => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.options.context
 					? this.options.context
 					: compiler.context;
 
+				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
 				const unnamedModules = assignNames(
-					Array.from(modules).filter(module => {
-						if (!module.needId) return false;
-						if (chunkGraph.getNumberOfModuleChunks(module) === 0) return false;
-						return chunkGraph.getModuleId(module) === null;
-					}),
+					modules,
 					m => getShortModuleName(m, context, root),
 					(m, shortName) =>
 						getLongModuleName(shortName, m, context, hashFunction, root),
 					compareModulesByIdentifier,
-					getUsedModuleIds(compilation),
+					usedIds,
 					(m, name) => chunkGraph.setModuleId(m, name)
 				);
 				if (unnamedModules.length > 0) {
-					assignAscendingModuleIds(unnamedModules, compilation);
+					assignAscendingModuleIds(usedIds, unnamedModules, compilation);
 				}
 			});
 		});

package/lib/ids/NaturalModuleIdsPlugin.js

@@ -8,7 +8,10 @@
 const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
-const { assignAscendingModuleIds } = require("./IdHelpers");
+const {
+	assignAscendingModuleIds,
+	getUsedModuleIdsAndModules
+} = require("./IdHelpers");
 
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -22,18 +25,12 @@ class NaturalModuleIdsPlugin {
 	apply(compiler) {
 		compiler.hooks.compilation.tap("NaturalModuleIdsPlugin", compilation => {
 			compilation.hooks.moduleIds.tap("NaturalModuleIdsPlugin", modules => {
-				const chunkGraph = compilation.chunkGraph;
-				const modulesInNaturalOrder = Array.from(modules)
-					.filter(
-						m =>
-							m.needId &&
-							chunkGraph.getNumberOfModuleChunks(m) > 0 &&
-							chunkGraph.getModuleId(m) === null
-					)
-					.sort(
-						compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
-					);
-				assignAscendingModuleIds(modulesInNaturalOrder, compilation);
+				const [usedIds, modulesInNaturalOrder] =
+					getUsedModuleIdsAndModules(compilation);
+				modulesInNaturalOrder.sort(
+					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
+				);
+				assignAscendingModuleIds(usedIds, modulesInNaturalOrder, compilation);
 			});
 		});
 	}

package/lib/ids/OccurrenceModuleIdsPlugin.js

@@ -9,7 +9,10 @@ const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
-const { assignAscendingModuleIds } = require("./IdHelpers");
+const {
+	assignAscendingModuleIds,
+	getUsedModuleIdsAndModules
+} = require("./IdHelpers");
 
 /** @typedef {import("../../declarations/plugins/ids/OccurrenceModuleIdsPlugin").OccurrenceModuleIdsPluginOptions} OccurrenceModuleIdsPluginOptions */
 /** @typedef {import("../Compiler")} Compiler */
@@ -44,15 +47,11 @@ class OccurrenceModuleIdsPlugin {
 		compiler.hooks.compilation.tap("OccurrenceModuleIdsPlugin", compilation => {
 			const moduleGraph = compilation.moduleGraph;
 
-			compilation.hooks.moduleIds.tap("OccurrenceModuleIdsPlugin", modules => {
+			compilation.hooks.moduleIds.tap("OccurrenceModuleIdsPlugin", () => {
 				const chunkGraph = compilation.chunkGraph;
 
-				const modulesInOccurrenceOrder = Array.from(modules).filter(
-					m =>
-						m.needId &&
-						chunkGraph.getNumberOfModuleChunks(m) > 0 &&
-						chunkGraph.getModuleId(m) === null
-				);
+				const [usedIds, modulesInOccurrenceOrder] =
+					getUsedModuleIdsAndModules(compilation);
 
 				const occursInInitialChunksMap = new Map();
 				const occursInAllChunksMap = new Map();
@@ -121,7 +120,7 @@ class OccurrenceModuleIdsPlugin {
 					}
 				}
 
-				for (const m of modules) {
+				for (const m of modulesInOccurrenceOrder) {
 					const result =
 						countOccurs(m) +
 						chunkGraph.getNumberOfModuleChunks(m) +
@@ -147,7 +146,11 @@ class OccurrenceModuleIdsPlugin {
 					return naturalCompare(a, b);
 				});
 
-				assignAscendingModuleIds(modulesInOccurrenceOrder, compilation);
+				assignAscendingModuleIds(
+					usedIds,
+					modulesInOccurrenceOrder,
+					compilation
+				);
 			});
 		});
 	}

package/lib/ids/SyncModuleIdsPlugin.js

@@ -0,0 +1,140 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { WebpackError } = require("..");
+const { getUsedModuleIdsAndModules } = require("./IdHelpers");
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+const plugin = "SyncModuleIdsPlugin";
+
+class SyncModuleIdsPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {string} options.path path to file
+	 * @param {string=} options.context context for module names
+	 * @param {function(Module): boolean} options.test selector for modules
+	 * @param {"read" | "create" | "merge" | "update"=} options.mode operation mode (defaults to merge)
+	 */
+	constructor({ path, context, test, mode }) {
+		this._path = path;
+		this._context = context;
+		this._test = test || (() => true);
+		const readAndWrite = !mode || mode === "merge" || mode === "update";
+		this._read = readAndWrite || mode === "read";
+		this._write = readAndWrite || mode === "create";
+		this._prune = mode === "update";
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		/** @type {Map<string, string | number>} */
+		let data;
+		let dataChanged = false;
+		if (this._read) {
+			compiler.hooks.readRecords.tapAsync(plugin, callback => {
+				const fs = compiler.intermediateFileSystem;
+				fs.readFile(this._path, (err, buffer) => {
+					if (err) {
+						if (err.code !== "ENOENT") {
+							return callback(err);
+						}
+						return callback();
+					}
+					const json = JSON.parse(buffer.toString());
+					data = new Map();
+					for (const key of Object.keys(json)) {
+						data.set(key, json[key]);
+					}
+					dataChanged = false;
+					return callback();
+				});
+			});
+		}
+		if (this._write) {
+			compiler.hooks.emitRecords.tapAsync(plugin, callback => {
+				if (!data || !dataChanged) return callback();
+				const json = {};
+				const sorted = Array.from(data).sort(([a], [b]) => (a < b ? -1 : 1));
+				for (const [key, value] of sorted) {
+					json[key] = value;
+				}
+				const fs = compiler.intermediateFileSystem;
+				fs.writeFile(this._path, JSON.stringify(json), callback);
+			});
+		}
+		compiler.hooks.thisCompilation.tap(plugin, compilation => {
+			const associatedObjectForCache = compiler.root;
+			const context = this._context || compiler.context;
+			if (this._read) {
+				compilation.hooks.reviveModules.tap(plugin, (_1, _2) => {
+					if (!data) return;
+					const { chunkGraph } = compilation;
+					const [usedIds, modules] = getUsedModuleIdsAndModules(
+						compilation,
+						this._test
+					);
+					for (const module of modules) {
+						const name = module.libIdent({
+							context,
+							associatedObjectForCache
+						});
+						if (!name) continue;
+						const id = data.get(name);
+						const idAsString = `${id}`;
+						if (usedIds.has(idAsString)) {
+							const err = new WebpackError(
+								`SyncModuleIdsPlugin: Unable to restore id '${id}' from '${this._path}' as it's already used.`
+							);
+							err.module = module;
+							compilation.errors.push(err);
+						}
+						chunkGraph.setModuleId(module, id);
+						usedIds.add(idAsString);
+					}
+				});
+			}
+			if (this._write) {
+				compilation.hooks.recordModules.tap(plugin, modules => {
+					const { chunkGraph } = compilation;
+					let oldData = data;
+					if (!oldData) {
+						oldData = data = new Map();
+					} else if (this._prune) {
+						data = new Map();
+					}
+					for (const module of modules) {
+						if (this._test(module)) {
+							const name = module.libIdent({
+								context,
+								associatedObjectForCache
+							});
+							if (!name) continue;
+							const id = chunkGraph.getModuleId(module);
+							if (id === null) continue;
+							const oldId = oldData.get(name);
+							if (oldId !== id) {
+								dataChanged = true;
+							} else if (data === oldData) {
+								continue;
+							}
+							data.set(name, id);
+						}
+					}
+					if (data.size !== oldData.size) dataChanged = true;
+				});
+			}
+		});
+	}
+}
+
+module.exports = SyncModuleIdsPlugin;

package/lib/index.js

@@ -11,6 +11,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
 /** @typedef {import("../declarations/WebpackOptions").EntryNormalized} EntryNormalized */
 /** @typedef {import("../declarations/WebpackOptions").EntryObject} EntryObject */
+/** @typedef {import("../declarations/WebpackOptions").FileCacheOptions} FileCacheOptions */
 /** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
@@ -19,15 +20,23 @@ const memoize = require("./util/memoize");
 /** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
+/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptions} Configuration */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./Compilation").Asset} Asset */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compilation").EntryOptions} EntryOptions */
+/** @typedef {import("./Compilation").PathData} PathData */
+/** @typedef {import("./Compiler").AssetEmittedInfo} AssetEmittedInfo */
 /** @typedef {import("./MultiStats")} MultiStats */
 /** @typedef {import("./Parser").ParserState} ParserState */
+/** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
+/** @typedef {import("./ResolverFactory").Resolver} Resolver */
 /** @typedef {import("./Watching")} Watching */
+/** @typedef {import("./cli").Argument} Argument */
+/** @typedef {import("./cli").Problem} Problem */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
@@ -333,6 +342,9 @@ module.exports = mergeExports(fn, {
 		get ModuleDependency() {
 			return require("./dependencies/ModuleDependency");
 		},
+		get HarmonyImportDependency() {
+			return require("./dependencies/HarmonyImportDependency");
+		},
 		get ConstDependency() {
 			return require("./dependencies/ConstDependency");
 		},
@@ -483,6 +495,9 @@ module.exports = mergeExports(fn, {
 	wasm: {
 		get AsyncWebAssemblyModulesPlugin() {
 			return require("./wasm-async/AsyncWebAssemblyModulesPlugin");
+		},
+		get EnableWasmLoadingPlugin() {
+			return require("./wasm/EnableWasmLoadingPlugin");
 		}
 	},
 
@@ -561,6 +576,11 @@ module.exports = mergeExports(fn, {
 			get HttpUriPlugin() {
 				return require("./schemes/HttpUriPlugin");
 			}
+		},
+		ids: {
+			get SyncModuleIdsPlugin() {
+				return require("./ids/SyncModuleIdsPlugin");
+			}
 		}
 	}
 });

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -45,7 +45,7 @@ class ArrayPushCallbackChunkFormatPlugin {
 						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 						const hotUpdateChunk =
 							chunk instanceof HotUpdateChunk ? chunk : null;
-						const globalObject = runtimeTemplate.outputOptions.globalObject;
+						const globalObject = runtimeTemplate.globalObject;
 						const source = new ConcatSource();
 						const runtimeModules =
 							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
@@ -138,7 +138,7 @@ class ArrayPushCallbackChunkFormatPlugin {
 					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
 						if (chunk.hasRuntime()) return;
 						hash.update(
-							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.outputOptions.globalObject}`
+							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.globalObject}`
 						);
 						const entries = Array.from(
 							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)

package/lib/javascript/BasicEvaluatedExpression.js

@@ -61,12 +61,14 @@ class BasicEvaluatedExpression {
 		/** @type {BasicEvaluatedExpression | undefined} */
 		this.postfix = undefined;
 		this.wrappedInnerExpressions = undefined;
-		/** @type {string | undefined} */
+		/** @type {string | VariableInfoInterface | undefined} */
 		this.identifier = undefined;
 		/** @type {VariableInfoInterface} */
 		this.rootInfo = undefined;
 		/** @type {() => string[]} */
 		this.getMembers = undefined;
+		/** @type {() => boolean[]} */
+		this.getMembersOptionals = undefined;
 		/** @type {EsTreeNode} */
 		this.expression = undefined;
 	}
@@ -342,11 +344,12 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
-	setIdentifier(identifier, rootInfo, getMembers) {
+	setIdentifier(identifier, rootInfo, getMembers, getMembersOptionals) {
 		this.type = TypeIdentifier;
 		this.identifier = identifier;
 		this.rootInfo = rootInfo;
 		this.getMembers = getMembers;
+		this.getMembersOptionals = getMembersOptionals;
 		this.sideEffects = true;
 		return this;
 	}