@depup/webpack 5.109.2-depup.0 → 5.110.3-depup.0

package/lib/loaders/LoaderRunner.js

@@ -7,8 +7,13 @@
 
 const { readFile } = require("fs");
 const { parseResource } = require("../util/identifier");
+const { adjustSourceMapForRemovedBOM } = require("../util/removeBOM");
 const loadLoader = require("./loadLoader");
 
+// Set on a loader context to have each loader's own run measured. Absent
+// unless something asked for the measurement, and read once per loader.
+const LOADER_TIMING = Symbol("loader timing");
+
 /** @typedef {string | ({ loader: string } & Record<string, EXPECTED_ANY>)} LoaderItemInput */
 
 /**
@@ -55,6 +60,8 @@ const HASH_ESCAPE_REGEXP = /#/g;
 const UTF8_BOM_0 = 0xef;
 const UTF8_BOM_1 = 0xbb;
 const UTF8_BOM_2 = 0xbf;
+// U+FEFF, the BOM once decoded
+const BOM_CHAR_CODE = 0xfeff;
 
 /**
  * @param {Buffer} buf buffer
@@ -72,6 +79,14 @@ function utf8BufferToString(buf) {
 	return buf.toString("utf8");
 }
 
+/**
+ * @param {string} str string
+ * @returns {string} string, with a leading BOM removed
+ */
+function stringWithoutBOM(str) {
+	return str.charCodeAt(0) === BOM_CHAR_CODE ? str.slice(1) : str;
+}
+
 /**
  * Escape `#` with a preceding `\0` byte; short-circuits when there is no `#`.
  * @param {string} str input string
@@ -240,9 +255,17 @@ function runSyncOrAsync(fn, context, args, callback) {
 		return innerCallback;
 	};
 
+	const timing =
+		/** @type {{ [LOADER_TIMING]?: (loader: EXPECTED_ANY, run: () => EXPECTED_ANY) => EXPECTED_ANY }} */
+		(context)[LOADER_TIMING];
+
 	try {
 		const result = (function LOADER_EXECUTION() {
-			return fn.apply(context, args);
+			return timing
+				? timing(context.loaders[context.loaderIndex], () =>
+						fn.apply(context, args)
+					)
+				: fn.apply(context, args);
 		})();
 		if (isSync) {
 			isDone = true;
@@ -280,9 +303,19 @@ function runSyncOrAsync(fn, context, args, callback) {
 /**
  * @param {EXPECTED_ANY[]} args arguments
  * @param {boolean | null=} raw whether the loader wants a Buffer
+ * @param {boolean=} fromLoader whether args came from a loader rather than the resource
  * @returns {void}
  */
-function convertArgs(args, raw) {
+function convertArgs(args, raw, fromLoader) {
+	// A BOM only means anything at the start of a file, so one a loader produced
+	// is content the next loader must not see. The resource keeps its own.
+	if (fromLoader && typeof args[0] === "string") {
+		const withoutBOM = stringWithoutBOM(args[0]);
+		if (withoutBOM !== args[0]) {
+			args[0] = withoutBOM;
+			if (args[1]) args[1] = adjustSourceMapForRemovedBOM(args[1]);
+		}
+	}
 	if (!raw && Buffer.isBuffer(args[0])) {
 		args[0] = utf8BufferToString(args[0]);
 	} else if (raw && typeof args[0] === "string") {
@@ -295,9 +328,16 @@ function convertArgs(args, raw) {
  * @param {LoaderContext} loaderContext the loader context
  * @param {EXPECTED_ANY[]} args arguments
  * @param {(err: Error | null, args?: EXPECTED_ANY[]) => void} callback callback
+ * @param {boolean=} fromLoader whether args came from a loader rather than the resource
  * @returns {void}
  */
-function iterateNormalLoaders(options, loaderContext, args, callback) {
+function iterateNormalLoaders(
+	options,
+	loaderContext,
+	args,
+	callback,
+	fromLoader
+) {
 	while (loaderContext.loaderIndex >= 0) {
 		const currentLoaderObject =
 			loaderContext.loaders[loaderContext.loaderIndex];
@@ -315,11 +355,11 @@ function iterateNormalLoaders(options, loaderContext, args, callback) {
 			continue;
 		}
 
-		convertArgs(args, currentLoaderObject.raw);
+		convertArgs(args, currentLoaderObject.raw, fromLoader);
 
 		return runSyncOrAsync(fn, loaderContext, args, (err, ...nextArgs) => {
 			if (err) return callback(err);
-			iterateNormalLoaders(options, loaderContext, nextArgs, callback);
+			iterateNormalLoaders(options, loaderContext, nextArgs, callback, true);
 		});
 	}
 
@@ -398,7 +438,7 @@ function iteratePitchingLoaders(options, loaderContext, callback) {
 					}
 					if (hasArg) {
 						loaderContext.loaderIndex--;
-						iterateNormalLoaders(options, loaderContext, args, callback);
+						iterateNormalLoaders(options, loaderContext, args, callback, true);
 					} else {
 						iteratePitchingLoaders(options, loaderContext, callback);
 					}
@@ -427,6 +467,7 @@ function joinRequests(loaders, start, end, resource) {
 	return result + resource;
 }
 
+module.exports.LOADER_TIMING = LOADER_TIMING;
 module.exports.LoaderObject = LoaderObject;
 
 module.exports.createLoaderContext = createLoaderContext;

package/lib/loaders/loadLoader.js

@@ -6,9 +6,13 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
-const LoaderLoadingError = require("../errors/LoaderLoadingError");
+const memoize = require("../util/memoize");
 
-/** @typedef {import("./LoaderRunner").LoaderObject} LoaderObject */
+const getLoaderLoadingError = memoize(() =>
+	require("../errors/LoaderLoadingError")
+);
+
+/** @import { LoaderObject } from "./LoaderRunner" */
 
 /**
  * Lazily-compiled dynamic `import()`. Built on first use so this file still
@@ -26,7 +30,7 @@ let importModule;
 function handleResult(loader, module, callback) {
 	if (typeof module !== "function" && typeof module !== "object") {
 		return callback(
-			new LoaderLoadingError(
+			new (getLoaderLoadingError())(
 				`Module '${loader.path}' is not a loader (export function or es6 module)`
 			)
 		);
@@ -41,7 +45,7 @@ function handleResult(loader, module, callback) {
 		typeof loader.pitch !== "function"
 	) {
 		return callback(
-			new LoaderLoadingError(
+			new (getLoaderLoadingError())(
 				`Module '${loader.path}' is not a loader (must have normal or pitch function)`
 			)
 		);

package/lib/logging/createConsoleLogger.js

@@ -7,10 +7,13 @@
 
 const { LogType } = require("./Logger");
 
-/** @typedef {import("../../declarations/WebpackOptions").FilterItemTypes} FilterItemTypes */
-/** @typedef {import("../../declarations/WebpackOptions").FilterTypes} FilterTypes */
-/** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
-/** @typedef {import("./Logger").Args} Args */
+/**
+ * @import {
+ * 	FilterItemTypes,
+ * 	FilterTypes
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import { LogTypeEnum, Args } from "./Logger" */
 
 /** @typedef {(item: string) => boolean} FilterFunction */
 /** @typedef {(value: string, type: LogTypeEnum, args?: Args) => void} LoggingFunction */

package/lib/node/CommonJsChunkLoadingPlugin.js

@@ -8,9 +8,9 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenciesPlugin");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
+/** @import { RuntimeRequirements } from "../Module" */
 
 /**
  * Defines the common js chunk loading plugin options type used by this module.
@@ -71,30 +71,44 @@ class CommonJsChunkLoadingPlugin {
 			const handler = (chunk, set) => {
 				if (onceForChunkSet.has(chunk)) return;
 				onceForChunkSet.add(chunk);
+				if (!isEnabledForChunk(chunk)) return;
+				compilation.addRuntimeModule(chunk, new ChunkLoadingRuntimeModule(set));
+			};
+			/**
+			 * Installing a chunk is the only part that writes the module factories and
+			 * looks a chunk id up; a base uri or `onChunksLoaded` comes without either.
+			 * Kept off `handler`, which runs once per chunk and so cannot see which of the
+			 * requirements below the chunk ends up with.
+			 * @param {Chunk} chunk chunk
+			 * @param {RuntimeRequirements} set runtime requirements
+			 */
+			const installHandler = (chunk, set) => {
 				if (!isEnabledForChunk(chunk)) return;
 				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
 				set.add(RuntimeGlobals.hasOwnProperty);
-				compilation.addRuntimeModule(chunk, new ChunkLoadingRuntimeModule(set));
 			};
 
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunkHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadManifest)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.baseURI)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.externalInstallChunk)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.onChunksLoaded)
-				.tap(PLUGIN_NAME, handler);
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.hmrDownloadUpdateHandlers,
+				RuntimeGlobals.hmrDownloadManifest,
+				RuntimeGlobals.baseURI,
+				RuntimeGlobals.externalInstallChunk,
+				RuntimeGlobals.onChunksLoaded
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, handler);
+			}
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.externalInstallChunk,
+				RuntimeGlobals.hmrDownloadUpdateHandlers
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, installHandler);
+			}
 
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.ensureChunkHandlers)

package/lib/node/NodeEnvironmentPlugin.js

@@ -11,9 +11,13 @@ const createConsoleLogger = require("../logging/createConsoleLogger");
 const NodeWatchFileSystem = require("./NodeWatchFileSystem");
 const nodeConsole = require("./nodeConsole");
 
-/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/**
+ * @import {
+ * 	InfrastructureLogging
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import { InputFileSystem } from "../util/fs" */
 
 /**
  * Defines the node environment plugin options type used by this module.
@@ -62,6 +66,16 @@ class NodeEnvironmentPlugin {
 		compiler.outputFileSystem = fs;
 		compiler.intermediateFileSystem = fs;
 		compiler.watchFileSystem = new NodeWatchFileSystem(inputFileSystem);
+		// Symmetric to the beforeRun purge below: the stat/readdir/readFile caches
+		// would otherwise outlive `close()` for as long as the compiler is held.
+		compiler.hooks.shutdown.tap(PLUGIN_NAME, () => {
+			if (
+				compiler.inputFileSystem === inputFileSystem &&
+				inputFileSystem.purge
+			) {
+				inputFileSystem.purge();
+			}
+		});
 		compiler.hooks.beforeRun.tap(PLUGIN_NAME, (compiler) => {
 			if (
 				compiler.inputFileSystem === inputFileSystem &&

package/lib/node/NodeSourcePlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Compiler from "../Compiler" */
 
 class NodeSourcePlugin {
 	/**

package/lib/node/NodeTargetPlugin.js

@@ -8,8 +8,8 @@
 const ExternalsPlugin = require("../ExternalsPlugin");
 const { builtins } = require("./nodeBuiltins");
 
-/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import { ExternalsType } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
 
 class NodeTargetPlugin {
 	/**
@@ -39,5 +39,6 @@ class NodeTargetPlugin {
 	}
 }
 
+NodeTargetPlugin.builtins = builtins;
+
 module.exports = NodeTargetPlugin;
-module.exports.builtins = builtins;

package/lib/node/NodeTemplatePlugin.js

@@ -8,7 +8,7 @@
 const CommonJsChunkFormatPlugin = require("../javascript/CommonJsChunkFormatPlugin");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Compiler from "../Compiler" */
 
 /**
  * Represents the node template plugin runtime component.

package/lib/node/NodeWatchFileSystem.js

@@ -6,15 +6,75 @@
 "use strict";
 
 const util = require("util");
-const Watchpack = require("watchpack");
+const memoize = require("../util/memoize");
+
+// watchpack is only reachable from `watch`, so non-watch builds never load it
+const getWatchpack = memoize(() => require("watchpack"));
 
 /** @typedef {InstanceType<import("watchpack")>} Watchpack */
-/** @typedef {import("watchpack").TimeInfoEntries} TimeInfoEntries */
-/** @typedef {import("watchpack").WatchOptions} WatchOptions */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("../util/fs").WatchMethod} WatchMethod */
-/** @typedef {import("../util/fs").Changes} Changes */
-/** @typedef {import("../util/fs").Removals} Removals */
+/** @import { TimeInfoEntries, WatchOptions } from "watchpack" */
+/**
+ * @import {
+ * 	InputFileSystem,
+ * 	WatchMethod,
+ * 	Changes,
+ * 	Removals
+ * } from "../util/fs"
+ */
+
+// Watchpack pools DirectoryWatchers per options object identity; interning by
+// value lets a MultiCompiler's children share one pool instead of one scan each.
+/** @type {Map<string, WatchOptions>} */
+const canonicalWatchOptions = new Map();
+/** @type {WeakMap<RegExp, string>} */
+const regExpKeys = new WeakMap();
+let nextRegExpKey = 0;
+
+// A RegExp keys by reference, so two configs spelling the same one inline do
+// not share a pool.
+/**
+ * @param {WatchOptions["ignored"]} ignored the `ignored` option
+ * @returns {string} key describing it, or "" when it cannot be keyed
+ */
+const ignoredKey = (ignored) => {
+	if (ignored === undefined || ignored === null) return "-";
+	if (typeof ignored === "string") return `s${ignored}`;
+	if (Array.isArray(ignored)) return `a${JSON.stringify(ignored)}`;
+	if (!(ignored instanceof RegExp)) return "";
+	let key = regExpKeys.get(ignored);
+	if (key === undefined) {
+		key = `r${nextRegExpKey++}`;
+		regExpKeys.set(ignored, key);
+	}
+	return key;
+};
+
+// Snapshot rather than keep the caller's object: mutating it later would hand
+// the next caller options it never asked for.
+/**
+ * @param {WatchOptions} options watch options
+ * @returns {WatchOptions} a shared object equal to `options`, or `options`
+ */
+const getCanonicalWatchOptions = (options) => {
+	const ignored = ignoredKey(options.ignored);
+	if (ignored === "") return options;
+	const key = `${options.aggregateTimeout}|${Boolean(
+		options.followSymlinks
+	)}|${options.poll}|${ignored}`;
+	const canonical = canonicalWatchOptions.get(key);
+	if (canonical !== undefined) return canonical;
+	/** @type {WatchOptions} */
+	const snapshot = {
+		aggregateTimeout: options.aggregateTimeout,
+		followSymlinks: options.followSymlinks,
+		ignored: Array.isArray(options.ignored)
+			? [...options.ignored]
+			: options.ignored,
+		poll: options.poll
+	};
+	canonicalWatchOptions.set(key, snapshot);
+	return snapshot;
+};
 
 class NodeWatchFileSystem {
 	/**
@@ -28,8 +88,9 @@ class NodeWatchFileSystem {
 		this.watcherOptions = {
 			aggregateTimeout: 0
 		};
+		// `watch` replaces this with a watcher built from its own options
 		/** @type {Watchpack | null} */
-		this.watcher = new Watchpack(this.watcherOptions);
+		this.watcher = null;
 	}
 
 	/** @type {WatchMethod} */
@@ -64,7 +125,7 @@ class NodeWatchFileSystem {
 			throw new Error("Invalid arguments: 'callbackUndelayed'");
 		}
 		const oldWatcher = this.watcher;
-		this.watcher = new Watchpack(options);
+		this.watcher = new (getWatchpack())(getCanonicalWatchOptions(options));
 
 		if (callbackUndelayed) {
 			this.watcher.once("change", callbackUndelayed);

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -10,19 +10,16 @@ const Template = require("../Template");
 const {
 	generateJavascriptHMR
 } = require("../hmr/JavascriptHotModuleReplacementHelper");
-const {
-	chunkHasJs,
-	getChunkFilenameTemplate
-} = require("../javascript/JavascriptModulesPlugin");
+const { chunkHasJs } = require("../javascript/JavascriptModulesPlugin");
 const { getInitialChunkIds } = require("../javascript/StartupHelpers");
+const { renderBaseUri } = require("../runtime/baseUri");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
-const { getUndoPath } = require("../util/identifier");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Compilation from "../Compilation" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import { ReadOnlyRuntimeRequirements } from "../Module" */
 
 class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
@@ -45,15 +42,14 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	 */
 	_generateBaseUri(chunk, rootOutputDir, runtimeTemplate) {
 		const options = chunk.getEntryOptions();
-		if (options && options.baseUri) {
-			return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
-		}
-
-		return `${RuntimeGlobals.baseURI} = require(${runtimeTemplate.renderNodePrefixForCoreModule("url")}).pathToFileURL(${
-			rootOutputDir
-				? `__dirname + ${JSON.stringify(`/${rootOutputDir}`)}`
-				: "__filename"
-		});`;
+		return renderBaseUri(
+			options ? options.baseUri : undefined,
+			`require(${runtimeTemplate.renderNodePrefixForCoreModule("url")}).pathToFileURL(${
+				rootOutputDir
+					? `__dirname + ${JSON.stringify(`/${rootOutputDir}`)}`
+					: "__filename"
+			})`
+		);
 	}
 
 	/**
@@ -86,18 +82,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		const outputName = compilation.getPath(
-			getChunkFilenameTemplate(chunk, compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
-			}
-		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			compilation.outputOptions.path,
-			false
-		);
+		const rootOutputDir = runtimeTemplate.chunkRootOutputDir(chunk, false);
 
 		const stateExpression = withHmr
 			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_readFileVm`
@@ -108,18 +93,30 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 			)
 		)}\n}`;
 
+		// Every part below that reads the table. A chunk asking only for `.b` gets this
+		// module for the base uri alone, and then has nothing to look up.
+		const withInstalledChunks =
+			withOnChunkLoad || withLoading || withExternalInstallChunk || withHmr;
+
 		return Template.asString([
 			withBaseURI
 				? this._generateBaseUri(chunk, rootOutputDir, runtimeTemplate)
 				: "// no baseURI",
 			"",
-			"// object to store loaded chunks",
-			'// "0" means "already loaded", Promise means loading',
-			`var installedChunks = ${
-				stateExpression
-					? runtimeTemplate.assignOr(stateExpression, installedChunksObject)
-					: installedChunksObject
-			};`,
+			withInstalledChunks
+				? Template.asString([
+						"// object to store loaded chunks",
+						'// "0" means "already loaded", Promise means loading',
+						`var installedChunks = ${
+							stateExpression
+								? runtimeTemplate.assignOr(
+										stateExpression,
+										installedChunksObject
+									)
+								: installedChunksObject
+						};`
+					])
+				: "// no installed chunks",
 			"",
 			withOnChunkLoad
 				? `${