@depup/webpack 5.106.1-depup.0 → 5.109.0-depup.0

package/lib/Compiler.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const parseJson = require("json-parse-even-better-errors");
 const asyncLib = require("neo-async");
 const {
 	AsyncParallelHook,
@@ -18,7 +17,6 @@ const Cache = require("./Cache");
 const CacheFacade = require("./CacheFacade");
 const ChunkGraph = require("./ChunkGraph");
 const Compilation = require("./Compilation");
-const ConcurrentCompilationError = require("./ConcurrentCompilationError");
 const ContextModuleFactory = require("./ContextModuleFactory");
 const ModuleGraph = require("./ModuleGraph");
 const NormalModuleFactory = require("./NormalModuleFactory");
@@ -26,11 +24,16 @@ const RequestShortener = require("./RequestShortener");
 const ResolverFactory = require("./ResolverFactory");
 const Stats = require("./Stats");
 const Watching = require("./Watching");
-const WebpackError = require("./WebpackError");
+const ConcurrentCompilationError = require("./errors/ConcurrentCompilationError");
+const WebpackError = require("./errors/WebpackError");
 const { Logger } = require("./logging/Logger");
 const { dirname, join, mkdirp } = require("./util/fs");
-const { makePathsRelative } = require("./util/identifier");
+const {
+	WINDOWS_ABS_PATH_REGEXP,
+	makePathsRelative
+} = require("./util/identifier");
 const memoize = require("./util/memoize");
+const parseJson = require("./util/parseJson");
 const { isSourceEqual } = require("./util/source");
 const webpack = require(".");
 
@@ -67,12 +70,14 @@ const webpack = require(".");
 /** @typedef {import("schema-utils").ValidationErrorConfiguration} ValidationErrorConfiguration */
 
 /**
+ * Defines the compilation params type used by this module.
  * @typedef {object} CompilationParams
  * @property {NormalModuleFactory} normalModuleFactory
  * @property {ContextModuleFactory} contextModuleFactory
  */
 
 /**
+ * Defines the callback type used by this module.
  * @template T
  * @template [R=void]
  * @typedef {import("./webpack").Callback<T, R>} Callback
@@ -81,6 +86,7 @@ const webpack = require(".");
 /** @typedef {import("./webpack").ErrorCallback} ErrorCallback */
 
 /**
+ * Defines the run as child callback callback.
  * @callback RunAsChildCallback
  * @param {Error | null} err
  * @param {Chunk[]=} entries
@@ -89,6 +95,7 @@ const webpack = require(".");
  */
 
 /**
+ * Defines the known records type used by this module.
  * @typedef {object} KnownRecords
  * @property {SplitData[]=} aggressiveSplits
  * @property {RecordsChunks=} chunks
@@ -105,6 +112,7 @@ const webpack = require(".");
 /** @typedef {KnownRecords & Record<string, KnownRecords[]> & Record<string, EXPECTED_ANY>} Records */
 
 /**
+ * Defines the asset emitted info type used by this module.
  * @typedef {object} AssetEmittedInfo
  * @property {Buffer} content
  * @property {Source} source
@@ -121,6 +129,7 @@ const webpack = require(".");
 /** @typedef {{ buildInfo: BuildInfo, references: WeakReferences | undefined, memCache: MemCache }} ModuleMemCachesItem */
 
 /**
+ * Checks whether this object is sorted.
  * @template T
  * @param {T[]} array an array
  * @returns {boolean} true, if the array is sorted
@@ -133,6 +142,7 @@ const isSorted = (array) => {
 };
 
 /**
+ * Returns the object with properties sorted by property name.
  * @template {object} T
  * @param {T} obj an object
  * @param {(keyof T)[]} keys the keys of the object
@@ -147,6 +157,7 @@ const sortObject = (obj, keys) => {
 };
 
 /**
+ * Returns true, if the filename contains any hash.
  * @param {string} filename filename
  * @param {string | string[] | undefined} hashes list of hashes
  * @returns {boolean} true, if the filename contains any hash
@@ -163,6 +174,7 @@ const getValidate = memoize(() => require("schema-utils").validate);
 
 class Compiler {
 	/**
+	 * Creates an instance of Compiler.
 	 * @param {string} context the compilation path
 	 * @param {WebpackOptions} options options
 	 */
@@ -303,21 +315,28 @@ class Compiler {
 			browser: null,
 			webworker: null,
 			node: null,
+			deno: null,
+			bun: null,
 			nwjs: null,
-			electron: null
+			electron: null,
+			universal: null
 		};
 
 		this.options = options;
 
+		/** @type {string} */
 		this.context = context;
 
+		/** @type {RequestShortener} */
 		this.requestShortener = new RequestShortener(context, this.root);
 
+		/** @type {Cache} */
 		this.cache = new Cache();
 
 		/** @type {Map<Module, ModuleMemCachesItem> | undefined} */
 		this.moduleMemCaches = undefined;
 
+		/** @type {string} */
 		this.compilerPath = "";
 
 		/** @type {boolean} */
@@ -329,6 +348,7 @@ class Compiler {
 		/** @type {boolean} */
 		this.watchMode = false;
 
+		/** @type {boolean} */
 		this._backCompat = this.options.experiments.backCompat !== false;
 
 		/** @type {Compilation | undefined} */
@@ -354,6 +374,7 @@ class Compiler {
 	}
 
 	/**
+	 * Returns the cache facade instance.
 	 * @param {string} name cache name
 	 * @returns {CacheFacade} the cache facade instance
 	 */
@@ -366,6 +387,7 @@ class Compiler {
 	}
 
 	/**
+	 * Gets infrastructure logger.
 	 * @param {string | (() => string)} name name of the logger, or function called once to get the logger name
 	 * @returns {Logger} a logger with that name
 	 */
@@ -481,6 +503,26 @@ class Compiler {
 	}
 
 	/**
+	 * Release fields on a finished compilation that nothing reads after emit,
+	 * so the heap can shrink while user code still holds the Stats reference.
+	 * Recurses into child compilations. Stats output is preserved — only
+	 * codeGen byproducts are dropped.
+	 * @param {Compilation} compilation finished compilation to slim down
+	 * @returns {void}
+	 */
+	_releaseUnusedCompilationData(compilation) {
+		for (const child of compilation.children) {
+			this._releaseUnusedCompilationData(child);
+		}
+		// Rendered source per (module × runtime) — used only during seal/emit,
+		// never read by Stats, and not serialized to the persistent cache.
+		if (compilation.codeGenerationResults !== undefined) {
+			compilation.codeGenerationResults.map.clear();
+		}
+	}
+
+	/**
+	 * Returns a compiler watcher.
 	 * @param {WatchOptions} watchOptions the watcher's options
 	 * @param {Callback<Stats>} handler signals when the call finishes
 	 * @returns {Watching | undefined} a compiler watcher
@@ -498,6 +540,7 @@ class Compiler {
 	}
 
 	/**
+	 * Processes the provided stat.
 	 * @param {Callback<Stats>} callback signals when the call finishes
 	 * @returns {void}
 	 */
@@ -511,6 +554,7 @@ class Compiler {
 		let logger;
 
 		/**
+		 * Processes the provided err.
 		 * @param {Error | null} err error
 		 * @param {Stats=} stats stats
 		 */
@@ -532,6 +576,7 @@ class Compiler {
 		this.running = true;
 
 		/**
+		 * Processes the provided err.
 		 * @param {Error | null} err error
 		 * @param {Compilation=} _compilation compilation
 		 * @returns {void}
@@ -639,6 +684,7 @@ class Compiler {
 	}
 
 	/**
+	 * Processes the provided run as child callback.
 	 * @param {RunAsChildCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
@@ -646,6 +692,7 @@ class Compiler {
 		const startTime = Date.now();
 
 		/**
+		 * Processes the provided err.
 		 * @param {Error | null} err error
 		 * @param {Chunk[]=} entries entries
 		 * @param {Compilation=} compilation compilation
@@ -699,6 +746,7 @@ class Compiler {
 	}
 
 	/**
+	 * Processes the provided compilation.
 	 * @param {Compilation} compilation the compilation
 	 * @param {ErrorCallback} callback signals when the assets are emitted
 	 * @returns {void}
@@ -708,6 +756,7 @@ class Compiler {
 		let outputPath;
 
 		/**
+		 * Processes the provided err.
 		 * @param {Error=} err error
 		 * @returns {void}
 		 */
@@ -740,18 +789,21 @@ class Compiler {
 								includesHash(targetFile, info.fullhash));
 					}
 
+					const fs = /** @type {OutputFileSystem} */ (this.outputFileSystem);
+					// A Windows drive-absolute targetFile is written as-is; joining it onto
+					// outputPath would produce an invalid path (e.g. C:\out\D:\file). A
+					// leading "/" stays relative to outputPath (e.g. entry name "/dir/x").
+					const targetPath = WINDOWS_ABS_PATH_REGEXP.test(targetFile)
+						? targetFile
+						: join(fs, outputPath, targetFile);
+
 					/**
+					 * Processes the provided err.
 					 * @param {Error=} err error
 					 * @returns {void}
 					 */
 					const writeOut = (err) => {
 						if (err) return callback(err);
-						const targetPath = join(
-							/** @type {OutputFileSystem} */
-							(this.outputFileSystem),
-							outputPath,
-							targetFile
-						);
 						allTargetPaths.add(targetPath);
 
 						// check if the target file has already been written by this Compiler
@@ -875,6 +927,7 @@ ${other}`);
 						};
 
 						/**
+						 * Updates with replacement source.
 						 * @param {number} size size
 						 */
 						const updateWithReplacementSource = (size) => {
@@ -897,6 +950,7 @@ ${other}`);
 						};
 
 						/**
+						 * Updates file with replacement source.
 						 * @param {string} file file
 						 * @param {CacheEntry} cacheEntry cache entry
 						 * @param {number} size size
@@ -918,6 +972,7 @@ ${other}`);
 						};
 
 						/**
+						 * Process existing file.
 						 * @param {IStats} stats stats
 						 * @returns {void}
 						 */
@@ -1014,8 +1069,7 @@ ${other}`);
 					};
 
 					if (/\/|\\/.test(targetFile)) {
-						const fs = /** @type {OutputFileSystem} */ (this.outputFileSystem);
-						const dir = dirname(fs, join(fs, outputPath, targetFile));
+						const dir = dirname(fs, targetPath);
 						mkdirp(fs, dir, writeOut);
 					} else {
 						writeOut();
@@ -1052,6 +1106,7 @@ ${other}`);
 	}
 
 	/**
+	 * Processes the provided error callback.
 	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
@@ -1076,6 +1131,7 @@ ${other}`);
 	}
 
 	/**
+	 * Processes the provided error callback.
 	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
@@ -1125,6 +1181,7 @@ ${other}`);
 	}
 
 	/**
+	 * Processes the provided error callback.
 	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
@@ -1151,6 +1208,7 @@ ${other}`);
 	}
 
 	/**
+	 * Processes the provided error callback.
 	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
@@ -1173,13 +1231,15 @@ ${other}`);
 					if (err) return callback(err);
 
 					try {
-						this.records = parseJson(
-							/** @type {Buffer} */ (content).toString("utf8")
-						);
+						this.records =
+							/** @type {Records} */
+							(parseJson(/** @type {Buffer} */ (content).toString("utf8")));
 					} catch (parseErr) {
 						return callback(
 							new Error(
-								`Cannot parse records: ${/** @type {Error} */ (parseErr).message}`
+								`Cannot parse records: ${
+									/** @type {Error} */ (parseErr).message
+								}`
 							)
 						);
 					}
@@ -1191,6 +1251,7 @@ ${other}`);
 	}
 
 	/**
+	 * Creates a child compiler.
 	 * @param {Compilation} compilation the compilation
 	 * @param {string} compilerName the compiler's name
 	 * @param {number} compilerIndex the compiler's index
@@ -1293,6 +1354,7 @@ ${other}`);
 	}
 
 	/**
+	 * Creates a compilation.
 	 * @param {CompilationParams} params the compilation parameters
 	 * @returns {Compilation} compilation
 	 */
@@ -1302,6 +1364,7 @@ ${other}`);
 	}
 
 	/**
+	 * Returns the created compilation.
 	 * @param {CompilationParams} params the compilation parameters
 	 * @returns {Compilation} the created compilation
 	 */
@@ -1343,6 +1406,7 @@ ${other}`);
 	}
 
 	/**
+	 * Processes the provided compilation.
 	 * @param {Callback<Compilation>} callback signals when the compilation finishes
 	 * @returns {void}
 	 */
@@ -1394,6 +1458,7 @@ ${other}`);
 	}
 
 	/**
+	 * Processes the provided error callback.
 	 * @param {ErrorCallback} callback signals when the compiler closes
 	 * @returns {void}
 	 */
@@ -1407,9 +1472,14 @@ ${other}`);
 		}
 		this.hooks.shutdown.callAsync((err) => {
 			if (err) return callback(err);
-			// Get rid of reference to last compilation to avoid leaking memory
-			// We can't run this._cleanupLastCompilation() as the Stats to this compilation
-			// might be still in use. We try to get rid of the reference to the cache instead.
+			// Defer a microtask so a close() made inside the run callback can't
+			// release codeGenerationResults before afterDone fires on the same stack.
+			const lastCompilation = this._lastCompilation;
+			if (lastCompilation !== undefined) {
+				Promise.resolve().then(() => {
+					this._releaseUnusedCompilationData(lastCompilation);
+				});
+			}
 			this._lastCompilation = undefined;
 			this._lastNormalModuleFactory = undefined;
 			this.cache.shutdown(callback);
@@ -1431,6 +1501,7 @@ ${other}`);
 		}
 
 		/**
+		 * Returns schema.
 		 * @returns {Schema} schema
 		 */
 		const getSchema = () => {
@@ -1444,12 +1515,7 @@ ${other}`);
 		// // If we have precompiled schema let's use it
 		if (check) {
 			if (!check(value)) {
-				getValidate()(
-					getSchema(),
-					/** @type {EXPECTED_OBJECT | EXPECTED_OBJECT[]} */
-					(value),
-					options
-				);
+				getValidate()(getSchema(), value, options);
 				require("util").deprecate(
 					() => {},
 					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
@@ -1460,11 +1526,7 @@ ${other}`);
 		}
 
 		// Otherwise let's standard validation
-		getValidate()(
-			getSchema(),
-			/** @type {EXPECTED_OBJECT | EXPECTED_OBJECT[]} */ (value),
-			options
-		);
+		getValidate()(getSchema(), value, options);
 	}
 }
 

package/lib/ConcatenationScope.js

@@ -17,24 +17,34 @@ const {
 /** @typedef {import("./optimize/ConcatenatedModule").ExportName} Ids */
 
 const MODULE_REFERENCE_REGEXP =
-	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(?:_asiSafe(\d))?__$/;
+	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(_mangleableNs)?(?:_asiSafe(\d))?__$/;
 
 /**
+ * Encodes how a concatenated module reference should be interpreted when it is
+ * later reconstructed from its placeholder identifier.
  * @typedef {object} ModuleReferenceOptions
- * @property {Ids} ids the properties/exports of the module
+ * @property {Ids} ids the properties or exports selected from the referenced module
  * @property {boolean} call true, when this referenced export is called
  * @property {boolean} directImport true, when this referenced export is directly imported (not via property access)
  * @property {boolean} deferredImport true, when this referenced export is deferred
+ * @property {boolean} mangleableNamespace true, when a whole-namespace reference may use a decoupled namespace object that keeps the original export names
  * @property {boolean | undefined} asiSafe if the position is ASI safe or unknown
  */
 
+/**
+ * Tracks the symbols and cross-module references needed while rendering a
+ * concatenated module.
+ */
 class ConcatenationScope {
 	/**
+	 * Creates the mutable scope object used while rendering a concatenated
+	 * module and its cross-module references.
 	 * @param {ModuleInfo[] | Map<Module, ModuleInfo>} modulesMap all module info by module
 	 * @param {ConcatenatedModuleInfo} currentModule the current module info
 	 * @param {Set<string>} usedNames all used names
 	 */
 	constructor(modulesMap, currentModule, usedNames) {
+		/** @type {ConcatenatedModuleInfo} */
 		this._currentModule = currentModule;
 		if (Array.isArray(modulesMap)) {
 			/** @type {Map<Module, ConcatenatedModuleInfo>} */
@@ -44,11 +54,14 @@ class ConcatenationScope {
 			}
 			modulesMap = map;
 		}
+		/** @type {Set<string>} */
 		this.usedNames = usedNames;
+		/** @type {Map<Module, ModuleInfo>} */
 		this._modulesMap = modulesMap;
 	}
 
 	/**
+	 * Checks whether a module participates in the current concatenation scope.
 	 * @param {Module} module the referenced module
 	 * @returns {boolean} true, when it's in the scope
 	 */
@@ -57,6 +70,8 @@ class ConcatenationScope {
 	}
 
 	/**
+	 * Records the symbol that should be used when the current module exports a
+	 * named binding.
 	 * @param {string} exportName name of the export
 	 * @param {string} symbol identifier of the export in source code
 	 */
@@ -70,6 +85,8 @@ class ConcatenationScope {
 	}
 
 	/**
+	 * Records a raw expression that can be used to reference an export without
+	 * going through the normal symbol map.
 	 * @param {string} exportName name of the export
 	 * @param {string} expression expression to be used
 	 */
@@ -83,6 +100,7 @@ class ConcatenationScope {
 	}
 
 	/**
+	 * Returns the raw expression registered for an export, if one exists.
 	 * @param {string} exportName name of the export
 	 * @returns {string | undefined} the expression of the export
 	 */
@@ -94,6 +112,8 @@ class ConcatenationScope {
 	}
 
 	/**
+	 * Replaces the raw expression for an export only when that export already
+	 * has an entry in the raw export map.
 	 * @param {string} exportName name of the export
 	 * @param {string} expression expression to be used
 	 */
@@ -107,6 +127,7 @@ class ConcatenationScope {
 	}
 
 	/**
+	 * Records the symbol that should be used for the synthetic namespace export.
 	 * @param {string} symbol identifier of the export in source code
 	 */
 	registerNamespaceExport(symbol) {
@@ -114,6 +135,8 @@ class ConcatenationScope {
 	}
 
 	/**
+	 * Encodes a reference to another concatenated module as a placeholder
+	 * identifier that can be parsed later during code generation.
 	 * @param {Module} module the referenced module
 	 * @param {Partial<ModuleReferenceOptions>} options options
 	 * @returns {string} the reference as identifier
@@ -125,6 +148,7 @@ class ConcatenationScope {
 			call = false,
 			directImport = false,
 			deferredImport = false,
+			mangleableNamespace = false,
 			asiSafe = false
 		}
 	) {
@@ -132,6 +156,7 @@ class ConcatenationScope {
 		const callFlag = call ? "_call" : "";
 		const directImportFlag = directImport ? "_directImport" : "";
 		const deferredImportFlag = deferredImport ? "_deferredImport" : "";
+		const mangleableNamespaceFlag = mangleableNamespace ? "_mangleableNs" : "";
 		const asiSafeFlag = asiSafe
 			? "_asiSafe1"
 			: asiSafe === false
@@ -141,10 +166,12 @@ class ConcatenationScope {
 			? Buffer.from(JSON.stringify(ids), "utf8").toString("hex")
 			: "ns";
 		// a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
-		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${deferredImportFlag}${asiSafeFlag}__._`;
+		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${deferredImportFlag}${mangleableNamespaceFlag}${asiSafeFlag}__._`;
 	}
 
 	/**
+	 * Checks whether an identifier is one of webpack's encoded concatenation
+	 * module references.
 	 * @param {string} name the identifier
 	 * @returns {boolean} true, when it's an module reference
 	 */
@@ -153,6 +180,8 @@ class ConcatenationScope {
 	}
 
 	/**
+	 * Parses an encoded module reference back into its module index and
+	 * reference flags.
 	 * @param {string} name the identifier
 	 * @returns {ModuleReferenceOptions & { index: number } | null} parsed options and index
 	 */
@@ -160,7 +189,7 @@ class ConcatenationScope {
 		const match = MODULE_REFERENCE_REGEXP.exec(name);
 		if (!match) return null;
 		const index = Number(match[1]);
-		const asiSafe = match[6];
+		const asiSafe = match[7];
 		return {
 			index,
 			ids:
@@ -170,6 +199,7 @@ class ConcatenationScope {
 			call: Boolean(match[3]),
 			directImport: Boolean(match[4]),
 			deferredImport: Boolean(match[5]),
+			mangleableNamespace: Boolean(match[6]),
 			asiSafe: asiSafe ? asiSafe === "1" : undefined
 		};
 	}

package/lib/ConditionalInitFragment.js

@@ -15,6 +15,7 @@ const { mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
+ * Returns wrapped source.
  * @param {string} condition condition
  * @param {string | Source} source source
  * @returns {string | Source} wrapped source
@@ -36,10 +37,12 @@ const wrapInCondition = (condition, source) => {
 };
 
 /**
+ * Represents ConditionalInitFragment.
  * @extends {InitFragment<GenerateContext>}
  */
 class ConditionalInitFragment extends InitFragment {
 	/**
+	 * Creates an instance of ConditionalInitFragment.
 	 * @param {string | Source | undefined} content the source code that will be included as initialization code
 	 * @param {number} stage category of initialization code (contribute to order)
 	 * @param {number} position position in the category (contribute to order)
@@ -60,6 +63,7 @@ class ConditionalInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Returns the source code that will be included as initialization code.
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
@@ -77,6 +81,7 @@ class ConditionalInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Returns the source code that will be included at the end of the module.
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included at the end of the module
 	 */
@@ -94,6 +99,7 @@ class ConditionalInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Returns merged fragment.
 	 * @param {ConditionalInitFragment} other fragment to merge with
 	 * @returns {ConditionalInitFragment} merged fragment
 	 */