@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/loaders/LoaderRunner.js

@@ -7,8 +7,12 @@
 
 const { readFile } = require("fs");
 const { parseResource } = require("../util/identifier");
+const { adjustSourceMapForRemovedBOM } = require("../util/removeBOM");
 const loadLoader = require("./loadLoader");
 
+/** @import { RawSourceMap } from "webpack-sources" */
+/** @import { Environment } from "../../declarations/WebpackOptions" */
+
 // 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");
@@ -43,14 +47,139 @@ const LOADER_TIMING = Symbol("loader timing");
 
 /** @typedef {(...args: EXPECTED_ANY[]) => void} LoaderCallback */
 
-/** @typedef {import("../../declarations/LoaderContext").LoaderRunnerLoaderContext<EXPECTED_ANY>} LoaderRunnerLoaderContext */
+/**
+ * @typedef {object} AdditionalDataKnown
+ * @property {EXPECTED_OBJECT} webpackAST the AST webpack should parse instead of the source
+ */
+
+/** @typedef {AdditionalDataKnown & Record<string, EXPECTED_ANY>} AdditionalData */
+
+/**
+ * @callback WebpackLoaderContextCallback
+ * @param {undefined | null | Error} err error object
+ * @param {(string | Buffer)=} content the loader result
+ * @param {(null | string | RawSourceMap)=} sourceMap a source map for the result
+ * @param {AdditionalData=} additionalData data passed to the next loader
+ * @returns {void}
+ */
+
+/**
+ * @typedef {object} LoaderEntry
+ * @property {string} request
+ * @property {string} path
+ * @property {string} query
+ * @property {string} fragment
+ * @property {EXPECTED_OBJECT | string | undefined} options
+ * @property {string} ident
+ * @property {EXPECTED_FUNCTION | undefined} normal
+ * @property {EXPECTED_FUNCTION | undefined} pitch
+ * @property {boolean | undefined} raw
+ * @property {EXPECTED_OBJECT | undefined} data
+ * @property {boolean} pitchExecuted
+ * @property {boolean} normalExecuted
+ * @property {("commonjs" | "module")=} type
+ */
+
+/**
+ * The members the runner never lets a loader assign. They carry no
+ * documentation, so a type literal loses nothing and keeps `readonly`
+ * @template OptionsType
+ * @typedef {{ readonly currentRequest: string, readonly data: EXPECTED_ANY, readonly previousRequest: string, readonly query: string | OptionsType, readonly remainingRequest: string, readonly request: string }} LoaderRunnerReadonlyContext
+ */
+
+/**
+ * @template OptionsType
+ * @typedef {object} LoaderRunnerMutableContext
+ * @property {(context: string) => void} addContextDependency Add a directory as dependency of the loader result.
+ * @property {(file: string) => void} addDependency Adds a file as dependency of the loader result in order to make them watchable.
+ * For example, html-loader uses this technique as it finds src and src-set attributes.
+ * Then, it sets the url's for those attributes as dependencies of the html file that is parsed.
+ * @property {(context: string) => void} addMissingDependency
+ * @property {() => WebpackLoaderContextCallback} async Make this loader async.
+ * @property {(flag?: boolean) => void} cacheable Make this loader result cacheable. By default it's cacheable.
+ * A cacheable loader must have a deterministic result, when inputs and dependencies haven't changed.
+ * This means the loader shouldn't have other dependencies than specified with this.addDependency.
+ * Most loaders are deterministic and cacheable.
+ * @property {WebpackLoaderContextCallback} callback
+ * @property {() => void} clearDependencies Remove all dependencies of the loader result. Even initial dependencies and these of other loaders.
+ * @property {string} context The directory of the module. Can be used as context for resolving other stuff.
+ * eg '/workspaces/ts-loader/examples/vanilla/src'
+ * @property {(file: string) => void} dependency alias of addDependency
+ * Adds a file as dependency of the loader result in order to make them watchable.
+ * For example, html-loader uses this technique as it finds src and src-set attributes.
+ * Then, it sets the url's for those attributes as dependencies of the html file that is parsed.
+ * @property {() => string[]} getContextDependencies
+ * @property {() => string[]} getDependencies
+ * @property {() => string[]} getMissingDependencies
+ * @property {number} loaderIndex The index in the loaders array of the current loader.
+ * In the example: in loader1: 0, in loader2: 1
+ * @property {LoaderEntry[]} loaders An array of all the loaders. It is writeable in the pitch phase.
+ * loaders = [{request: string, path: string, query: string, module: function}]
+ * @property {string} resourcePath The resource path.
+ * In the example: "/abc/resource.js"
+ * @property {string} resourceQuery The resource query string.
+ * Example: "?query"
+ * @property {string} resourceFragment The resource fragment.
+ * Example: "#frag"
+ * @property {string} resource The resource inclusive query and fragment.
+ * Example: "/abc/resource.js?query#frag"
+ * @property {string} target Target of compilation.
+ * Example: "web"
+ * @property {Environment} environment Tell what kind of ES-features may be used in the generated runtime-code.
+ * Example: { arrowFunction: true }
+ */
+
+/**
+ * The properties are added by https://github.com/webpack/loader-runner
+ * @template OptionsType
+ * @typedef {LoaderRunnerMutableContext<OptionsType> & LoaderRunnerReadonlyContext<OptionsType>} LoaderRunnerLoaderContext
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {(this: import("../NormalModule").LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: EXPECTED_OBJECT) => string | Buffer | Promise<string | Buffer> | void} PitchLoaderDefinitionFunction
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {(this: import("../NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: string, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} LoaderDefinitionFunction
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {(this: import("../NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: Buffer, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} RawLoaderDefinitionFunction
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {LoaderDefinitionFunction<OptionsType, ContextAdditions> & { raw?: false, pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions> }} LoaderDefinition
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {RawLoaderDefinitionFunction<OptionsType, ContextAdditions> & { raw: true, pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions> }} RawLoaderDefinition
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {object} LoaderModule
+ * @property {(RawLoaderDefinitionFunction<OptionsType, ContextAdditions> | LoaderDefinitionFunction<OptionsType, ContextAdditions>)=} default
+ * @property {false=} raw
+ * @property {PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>=} pitch
+ */
 
 /**
  * The loader context as the runner sees and mutates it: the canonical
  * `LoaderRunnerLoaderContext` shape (not re-declared here), with only the fields
  * the runner assigns internally before a loader runs widened to their mutable
  * form (nullable `context`/`callback`/`async`, `LoaderObject` loaders).
- * @typedef {Omit<LoaderRunnerLoaderContext, "context" | "callback" | "async" | "loaders"> & { context: string | null, callback: LoaderCallback | null, async: (() => LoaderCallback | undefined) | null, loaders: LoaderObject[] }} LoaderContext
+ * @typedef {Omit<LoaderRunnerLoaderContext<EXPECTED_ANY>, "context" | "callback" | "async" | "loaders"> & { context: string | null, callback: LoaderCallback | null, async: (() => LoaderCallback | undefined) | null, loaders: LoaderObject[] }} LoaderContext
  */
 
 const HASH_ESCAPE_REGEXP = /#/g;
@@ -59,6 +188,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
@@ -76,6 +207,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
@@ -292,9 +431,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") {
@@ -307,9 +456,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];
@@ -327,11 +483,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);
 		});
 	}
 
@@ -410,7 +566,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);
 					}
@@ -547,7 +703,7 @@ function createLoaderContext(base) {
  * Marks the request as not cacheable with the given reasons instead of
  * attributing the currently running loader (used by the host when the cause
  * lives outside the loader, e.g. in a child compilation of `importModule`).
- * @param {LoaderRunnerLoaderContext} loaderContext loader context
+ * @param {LoaderRunnerLoaderContext<EXPECTED_ANY>} loaderContext loader context
  * @param {string[]} reasons reasons why the request is not cacheable
  * @returns {void}
  */
@@ -654,12 +810,12 @@ const ACCESSORS = {
  * @returns {void}
  */
 module.exports.runLoaders = function runLoaders(options, callback) {
-	// reuse a context already prepared by createLoaderContext (e.g. from
-	// NormalModule), else augment the caller-provided context (or a fresh object)
-	// in place. State is intentionally preserved across the handoff, so host hooks
-	// (e.g. beforeLoaders) can pre-add dependencies or mark the request
-	// non-cacheable before the run; a caller re-running on the same context should
-	// clearDependencies() first to avoid accumulating stale dependencies.
+	// WHY: reuse a context `createLoaderContext` already prepared, from
+	// NormalModule say, else augment the caller-provided context, or a fresh
+	// object, in place. State is intentionally preserved across the handoff, so a
+	// host hook such as `beforeLoaders` can pre-add dependencies or mark the
+	// request non-cacheable before the run; a caller re-running on the same context
+	// should `clearDependencies()` first, to avoid accumulating stale ones.
 	const provided = /** @type {EXPECTED_ANY} */ (options.context);
 	const loaderContext =
 		provided && provided[LOADER_STATE]

package/lib/node/NodeWatchFileSystem.js

@@ -147,15 +147,9 @@ class NodeWatchFileSystem {
 		const directoriesSet =
 			directories instanceof Set ? directories : new Set(directories);
 
-		// Watchpack reports a watched directory (a context dependency) in
-		// `changes` whenever its contents change, alongside the individual
-		// file events. The default `fs.purge(dir)` matches cache keys by
-		// prefix, so it would wipe the stat cache of every file inside the
-		// directory even though only file-level events actually invalidate
-		// file stats. For directories we explicitly watch, purge only the
-		// directory's own entry (`{ exact: true }`, enhanced-resolve >=
-		// 5.22.0); file-level events in the same aggregated batch still
-		// handle file stats and the parent readdir invalidation.
+		// Watchpack reports a watched directory whenever its contents change, and
+		// `fs.purge(dir)` matches by prefix, wiping every file's stat cache with it.
+		// Only its own entry is purged; the batch's file events carry the rest.
 		/**
 		 * @param {Changes | null | undefined} changes changes set
 		 * @param {Removals | null | undefined} removals removals set

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -32,6 +32,28 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		this.runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		const runtimeRequirements = this.runtimeRequirements;
+		/** @type {[string, string][]} */
+		const handlers = [];
+		if (runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "readFileVm"]);
+		}
+		// The hot update flow installs this one onto the same map while it runs.
+		if (runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "readFileVmHmr"]);
+		}
+		if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+			handlers.push([RuntimeGlobals.onChunksLoaded, "readFileVm"]);
+		}
+		return handlers;
+	}
+
 	/**
 	 * Returns generated code.
 	 * @private

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -62,27 +62,20 @@ class ReadFileCompileAsyncWasmPlugin {
 			// settled while the plugin is being applied.
 			/**
 			 * @param {string} path rendered path to the wasm file
-			 * @param {RuntimeSpec} runtime the runtime this loader serves
+			 * @param {boolean} analyzable whether the call site bakes a complete URL
 			 * @returns {string} the argument to hand the reader
 			 */
-			const wasmUrlArg = (path, runtime) =>
-				compilation.runtimeTemplate.supportsAnalyzable(
-					"wasm",
-					undefined,
-					undefined,
-					runtime
-				)
-					? path
-					: compilation.runtimeTemplate.importMetaUrl(path);
+			const wasmUrlArg = (path, analyzable) =>
+				analyzable ? path : compilation.runtimeTemplate.importMetaUrl(path);
 			/**
-			 * @type {(path: string, runtime: RuntimeSpec) => string} callback to generate code to load the wasm file
+			 * @type {(path: string, runtime: RuntimeSpec, analyzable: boolean) => string} callback to generate code to load the wasm file
 			 */
 			const generateLoadBinaryCode = this._import
-				? (path, runtime) =>
+				? (path, runtime, analyzable) =>
 						Template.asString([
 							"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 							Template.indent([
-								`readFile(${wasmUrlArg(path, runtime)}, (err, buffer) => {`,
+								`readFile(${wasmUrlArg(path, analyzable)}, (err, buffer) => {`,
 								Template.indent([
 									"if (err) return reject(err);",
 									"",
@@ -154,7 +147,7 @@ class ReadFileCompileAsyncWasmPlugin {
 					if (
 						!compilation.runtimeTemplate.supportsAnalyzable(
 							"wasm",
-							undefined,
+							chunkGraph,
 							undefined,
 							chunk.runtime
 						) &&
@@ -196,7 +189,7 @@ class ReadFileCompileAsyncWasmPlugin {
 					if (
 						!compilation.runtimeTemplate.supportsAnalyzable(
 							"wasm",
-							undefined,
+							chunkGraph,
 							undefined,
 							chunk.runtime
 						) &&

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -32,6 +32,28 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 		this.runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		const runtimeRequirements = this.runtimeRequirements;
+		/** @type {[string, string][]} */
+		const handlers = [];
+		if (runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "require"]);
+		}
+		// The hot update flow installs this one onto the same map while it runs.
+		if (runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "requireHmr"]);
+		}
+		if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+			handlers.push([RuntimeGlobals.onChunksLoaded, "require"]);
+		}
+		return handlers;
+	}
+
 	/**
 	 * Returns generated code.
 	 * @private

package/lib/optimize/AggressiveMergingPlugin.js

@@ -53,11 +53,9 @@ class AggressiveMergingPlugin {
 				},
 				(chunks) => {
 					const chunkGraph = compilation.chunkGraph;
-					// Only the single best pair is merged per pass (the hook re-runs
-					// after each merge), so track the max directly instead of building
-					// and sorting the full O(chunks²) list of pairs every pass. A strict
-					// `>` keeps the first-encountered best, matching the previous stable
-					// descending sort's `[0]`.
+					// One pair is merged per pass and the hook re-runs, so the maximum is
+					// tracked directly rather than sorting every pair each time. A strict
+					// `>` keeps the first best found, as a stable descending sort would.
 					/** @type {Chunk | undefined} */
 					let bestA;
 					/** @type {Chunk | undefined} */