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

package/lib/stats/StatsFactory.js

@@ -8,38 +8,37 @@
 const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
 const smartGrouping = require("../util/smartGrouping");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGroup").OriginRecord} OriginRecord */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").Asset} Asset */
-/** @typedef {import("../Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph").ModuleProfile} ModuleProfile */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
+/** @import Chunk from "../Chunk" */
+/** @import { OriginRecord } from "../ChunkGroup" */
+/** @import Compilation, { Asset } from "../Compilation" */
+/** @import Dependency from "../Dependency" */
+/** @import Module from "../Module" */
+/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
 /** @typedef {import("../util/comparators").Comparator<EXPECTED_ANY>} Comparator */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import ModuleProfile from "../ModuleProfile" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * Defines the group config type used by this module.
  * @template T, R
  * @typedef {import("../util/smartGrouping").GroupConfig<T, R>} GroupConfig
  */
-/** @typedef {import("./DefaultStatsFactoryPlugin").ChunkGroupInfoWithName} ChunkGroupInfoWithName */
-/** @typedef {import("./DefaultStatsFactoryPlugin").ModuleIssuerPath} ModuleIssuerPath */
-/** @typedef {import("./DefaultStatsFactoryPlugin").ModuleTrace} ModuleTrace */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkOrigin} StatsChunkOrigin */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsError} StatsError */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModule} StatsModule */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleIssuer} StatsModuleIssuer */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
+/**
+ * @import {
+ * 	ChunkGroupInfoWithName,
+ * 	ModuleTrace,
+ * 	StatsAsset,
+ * 	StatsChunk,
+ * 	StatsChunkGroup,
+ * 	StatsChunkOrigin,
+ * 	StatsCompilation,
+ * 	StatsError,
+ * 	StatsModule,
+ * 	StatsModuleReason,
+ * 	StatsModuleTraceDependency,
+ * 	StatsModuleTraceItem,
+ * 	StatsProfile
+ * } from "./DefaultStatsFactoryPlugin"
+ */
 
 /**
  * Defines the known stats factory context type used by this module.

package/lib/stats/StatsPrinter.js

@@ -7,18 +7,22 @@
 
 const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
 
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsError} StatsError */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsLogging} StatsLogging */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModule} StatsModule */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleIssuer} StatsModuleIssuer */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
+/**
+ * @import {
+ * 	StatsAsset,
+ * 	StatsChunk,
+ * 	StatsChunkGroup,
+ * 	StatsCompilation,
+ * 	StatsError,
+ * 	StatsLogging,
+ * 	StatsModule,
+ * 	StatsModuleIssuer,
+ * 	StatsModuleReason,
+ * 	StatsModuleTraceDependency,
+ * 	StatsModuleTraceItem,
+ * 	StatsProfile
+ * } from "./DefaultStatsFactoryPlugin"
+ */
 
 /**
  * Defines the printed element type used by this module.

package/lib/typescript/TypeScriptPlugin.js

@@ -6,26 +6,25 @@
 "use strict";
 
 const mod = require("module");
+const { SourceMapSource } = require("webpack-sources");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const NormalModule = require("../NormalModule");
-const ModuleBuildError = require("../errors/ModuleBuildError");
 const memoize = require("../util/memoize");
-const removeBOM = require("../util/removeBOM");
+const { removeBOMFromResult } = require("../util/removeBOM");
 
-/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../NormalModule")} NormalModuleType */
-/** @typedef {import("../NormalModule").Result} Result */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-
-const getSourceMapSource = memoize(
-	() => require("webpack-sources").SourceMapSource
+const getModuleBuildError = memoize(() =>
+	require("../errors/ModuleBuildError")
 );
 
+/** @import { RawSourceMap } from "webpack-sources" */
+/** @import Compiler from "../Compiler" */
+/** @import NormalModuleType, { Result } from "../NormalModule" */
+/** @import JavascriptParser from "../javascript/JavascriptParser" */
+
 const PLUGIN_NAME = "TypeScriptPlugin";
 
 /** @type {Set<string>} */
@@ -103,7 +102,6 @@ const composeWithLoaderSourceMap = (
 	preStripSource,
 	loaderSourceMap
 ) => {
-	const SourceMapSource = getSourceMapSource();
 	const composed = new SourceMapSource(
 		strippedSource,
 		resource,
@@ -117,7 +115,7 @@ const composeWithLoaderSourceMap = (
 
 /**
  * Run `module.stripTypeScriptTypes` on the input, wrapping any thrown
- * `TypeScript ...` errors as `ModuleBuildError` so they surface as
+ * `TypeScript ...` errors as `getModuleBuildError()` so they surface as
  * per-module build errors instead of uncaught exceptions.
  * @param {string} input pre-strip TS source (BOM-free string)
  * @returns {string} stripped JS
@@ -130,20 +128,16 @@ const stripTypes = (input) => {
 		// eslint-disable-next-line n/no-unsupported-features/node-builtins
 		return mod.stripTypeScriptTypes(input, { mode: "strip" });
 	} catch (err) {
-		throw new ModuleBuildError(/** @type {Error} */ (err));
+		throw new (getModuleBuildError())(/** @type {Error} */ (err));
 	}
 };
 
 /**
- * Coerce a Buffer-or-string source to a UTF-8 string, dropping any BOM.
  * @param {string | Buffer} source raw source from the loader pipeline
- * @returns {string} UTF-8 string without BOM
+ * @returns {string} UTF-8 string
  */
-const toBomFreeString = (source) => {
-	const text = Buffer.isBuffer(source) ? source.toString("utf8") : source;
-	const stripped = removeBOM(text);
-	return typeof stripped === "string" ? stripped : stripped.toString("utf8");
-};
+const asString = (source) =>
+	Buffer.isBuffer(source) ? source.toString("utf8") : source;
 
 class TypeScriptPlugin {
 	/**
@@ -176,15 +170,17 @@ class TypeScriptPlugin {
 		if (!resource || !isTypeScriptResource(resource)) return result;
 
 		if (TSX_RESOURCE_RE.test(resource)) {
-			throw new ModuleBuildError(new Error(TSX_NOT_SUPPORTED));
+			throw new (getModuleBuildError())(new Error(TSX_NOT_SUPPORTED));
 		}
 
 		if (!("stripTypeScriptTypes" in mod)) {
-			throw new ModuleBuildError(new Error(NODE_API_MISSING));
+			throw new (getModuleBuildError())(new Error(NODE_API_MISSING));
 		}
 
-		const [rawSource, loaderSourceMap, ...rest] = result;
-		const preStripSource = toBomFreeString(rawSource);
+		// A BOM must be off the source before it is stripped of types, and its
+		// map moved with it.
+		const [rawSource, loaderSourceMap, ...rest] = removeBOMFromResult(result);
+		const preStripSource = asString(rawSource);
 		const strippedSource = stripTypes(preStripSource);
 
 		const needSourceMap = module.useSourceMap || module.useSimpleSourceMap;

package/lib/url/URLParserPlugin.js

@@ -14,20 +14,33 @@ const {
 } = require("../dependencies/ImportMetaPlugin");
 const URLContextDependency = require("../dependencies/URLContextDependency");
 const URLDependency = require("../dependencies/URLDependency");
-const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
-const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const { getInnerGraphUtils } = require("../optimize/InnerGraph");
 const ResourceHintPlugin = require("../prefetch/ResourceHintPlugin");
+const memoize = require("../util/memoize");
 
-/** @typedef {import("estree").MemberExpression} MemberExpression */
-/** @typedef {import("estree").NewExpression} NewExpressionNode */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+const getUnsupportedFeatureWarning = memoize(() =>
+	require("../errors/UnsupportedFeatureWarning")
+);
+
+const getCommentCompilationWarning = memoize(() =>
+	require("../errors/CommentCompilationWarning")
+);
+
+/**
+ * @import {
+ * 	MemberExpression,
+ * 	NewExpression as NewExpressionNode
+ * } from "estree"
+ */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import NormalModule from "../NormalModule" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "URLParserPlugin";
 
@@ -179,7 +192,7 @@ class URLParserPlugin {
 				for (const e of commentErrors) {
 					const { comment } = e;
 					parser.state.module.addWarning(
-						new CommentCompilationWarning(
+						new (getCommentCompilationWarning())(
 							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
 							parser.getLocation(comment)
 						)
@@ -190,7 +203,7 @@ class URLParserPlugin {
 			if (importOptions && importOptions.webpackIgnore !== undefined) {
 				if (typeof importOptions.webpackIgnore !== "boolean") {
 					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
+						new (getUnsupportedFeatureWarning())(
 							`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
 							parser.getLocation(expr)
 						)
@@ -286,7 +299,7 @@ class URLParserPlugin {
 						!(importOptions.webpackInclude instanceof RegExp)
 					) {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
 								parser.getLocation(expr)
 							)
@@ -301,7 +314,7 @@ class URLParserPlugin {
 						!(importOptions.webpackExclude instanceof RegExp)
 					) {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
 								parser.getLocation(expr)
 							)

package/lib/util/ArrayQueue.js

@@ -90,11 +90,11 @@ class ArrayQueue {
 	[Symbol.iterator]() {
 		return {
 			next: () => {
-				const item = this.dequeue();
-				if (item) {
+				// length, not truthiness: a queued `0`/`false`/`undefined` is a value
+				if (this.length > 0) {
 					return {
 						done: false,
-						value: item
+						value: /** @type {T} */ (this.dequeue())
 					};
 				}
 				return {

package/lib/util/AsyncQueue.js

@@ -226,9 +226,10 @@ class AsyncQueue {
 	 */
 	invalidate(item) {
 		const key = this._getKey(item);
-		const entry =
-			/** @type {AsyncQueueEntry<T, K, R>} */
-			(this._entries.get(key));
+		const entry = this._entries.get(key);
+		// nothing queued for this item in the current run (e.g. incremental rebuild
+		// against a persisted graph) — nothing to invalidate
+		if (entry === undefined) return;
 		this._entries.delete(key);
 		if (entry.state === QUEUED_STATE) {
 			this._queued.delete(entry);

package/lib/util/Hash.js

@@ -5,7 +5,11 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").HashDigest} Encoding */
+/**
+ * @import {
+ * 	HashDigest as Encoding
+ * } from "../../declarations/WebpackOptions"
+ */
 /** @typedef {string | typeof Hash} HashFunction */
 
 class Hash {

package/lib/util/LazySet.js

@@ -34,10 +34,15 @@ const flatten = (targetSet, toDeepMerge) => {
 	for (const set of toDeepMerge) {
 		if (set._set.size > 0) targetSet.add(set._set);
 		if (set._needMerge) {
-			for (const mergedSet of set._toMerge) {
-				targetSet.add(mergedSet);
+			// `_needMerge` means at least one queue exists, not both
+			if (set._toMerge !== undefined) {
+				for (const mergedSet of set._toMerge) {
+					targetSet.add(mergedSet);
+				}
+			}
+			if (set._toDeepMerge !== undefined) {
+				flatten(targetSet, set._toDeepMerge);
 			}
-			flatten(targetSet, set._toDeepMerge);
 		}
 	}
 };
@@ -63,10 +68,12 @@ class LazySet {
 	constructor(iterable) {
 		/** @type {Set<T>} */
 		this._set = new Set(iterable);
-		/** @type {Set<Iterable<T>>} */
-		this._toMerge = new Set();
-		/** @type {LazySet<T>[]} */
-		this._toDeepMerge = [];
+		// Both queues stay undefined until something is actually queued: most
+		// lazy sets never merge, and a build creates thousands of them.
+		/** @type {Set<Iterable<T>> | undefined} */
+		this._toMerge = undefined;
+		/** @type {LazySet<T>[] | undefined} */
+		this._toDeepMerge = undefined;
 		/** @type {boolean} */
 		this._needMerge = false;
 		/** @type {boolean} */
@@ -77,8 +84,11 @@ class LazySet {
 	 * Flattens any nested lazy sets that were queued for merging.
 	 */
 	_flatten() {
-		flatten(this._toMerge, this._toDeepMerge);
-		this._toDeepMerge.length = 0;
+		const toDeepMerge = this._toDeepMerge;
+		if (toDeepMerge === undefined || toDeepMerge.length === 0) return;
+		const toMerge = this._toMerge || (this._toMerge = new Set());
+		flatten(toMerge, toDeepMerge);
+		toDeepMerge.length = 0;
 	}
 
 	/**
@@ -86,8 +96,11 @@ class LazySet {
 	 */
 	_merge() {
 		this._flatten();
-		merge(this._set, this._toMerge);
-		this._toMerge.clear();
+		const toMerge = this._toMerge;
+		if (toMerge !== undefined) {
+			merge(this._set, toMerge);
+			toMerge.clear();
+		}
 		this._needMerge = false;
 	}
 
@@ -96,11 +109,9 @@ class LazySet {
 	 * @returns {boolean} true when no items have been stored or queued
 	 */
 	_isEmpty() {
-		return (
-			this._set.size === 0 &&
-			this._toMerge.size === 0 &&
-			this._toDeepMerge.length === 0
-		);
+		if (this._set.size > 0) return false;
+		if (this._toMerge !== undefined && this._toMerge.size > 0) return false;
+		return this._toDeepMerge === undefined || this._toDeepMerge.length === 0;
 	}
 
 	/**
@@ -137,16 +148,18 @@ class LazySet {
 		} else {
 			if (iterable instanceof LazySet) {
 				if (iterable._isEmpty()) return this;
-				this._toDeepMerge.push(iterable);
+				const toDeepMerge = this._toDeepMerge || (this._toDeepMerge = []);
+				toDeepMerge.push(iterable);
 				this._needMerge = true;
-				if (this._toDeepMerge.length > 100000) {
+				if (toDeepMerge.length > 100000) {
 					this._flatten();
 				}
 			} else {
-				this._toMerge.add(iterable);
+				(this._toMerge || (this._toMerge = new Set())).add(iterable);
 				this._needMerge = true;
 			}
-			if (this._toMerge.size > 100000) this._merge();
+			const toMerge = this._toMerge;
+			if (toMerge !== undefined && toMerge.size > 100000) this._merge();
 		}
 		return this;
 	}
@@ -156,8 +169,8 @@ class LazySet {
 	 */
 	clear() {
 		this._set.clear();
-		this._toMerge.clear();
-		this._toDeepMerge.length = 0;
+		if (this._toMerge !== undefined) this._toMerge.clear();
+		if (this._toDeepMerge !== undefined) this._toDeepMerge.length = 0;
 		this._needMerge = false;
 		this._deopt = false;
 	}

package/lib/util/LocConverter.js

@@ -19,6 +19,10 @@ class LocConverter {
 		this.column = 0;
 		/** @type {number} */
 		this.pos = 0;
+		// Next `\n` at/after `pos` (`input.length` if none, -1 = unknown);
+		// when >= pos there is no `\n` in [pos, _nextNewline).
+		/** @type {number} */
+		this._nextNewline = -1;
 	}
 
 	/**
@@ -28,30 +32,49 @@ class LocConverter {
 	 */
 	get(pos) {
 		if (this.pos !== pos) {
+			const input = this._input;
 			if (this.pos < pos) {
-				// Advance: delta-bounded scan of [this.pos, pos), allocation-free
-				// (unbounded index scans go quadratic on newline-free input).
-				const input = this._input;
-				let last = -1;
-				for (let j = this.pos; j < pos; j++) {
-					if (input.charCodeAt(j) === 10) {
-						this.line++;
-						last = j;
+				// Advance: O(1) on the same line via the cached next-newline offset,
+				// otherwise hop newline-to-newline with native indexOf — each re-scan
+				// is bounded by one line, amortized O(1)/byte for monotone callers.
+				let next = this._nextNewline;
+				if (next < this.pos) {
+					next = input.indexOf("\n", this.pos);
+					if (next === -1) next = input.length;
+				}
+				if (pos <= next) {
+					this.column += pos - this.pos;
+				} else {
+					let line = this.line;
+					let last = next;
+					for (;;) {
+						line++;
+						next = input.indexOf("\n", last + 1);
+						if (next === -1) next = input.length;
+						// `next >= input.length` guards termination for out-of-range `pos`.
+						if (pos <= next || next >= input.length) break;
+						last = next;
 					}
+					this.line = line;
+					this.column = pos - last - 1;
 				}
-				this.column =
-					last === -1 ? this.column + (pos - this.pos) : pos - last - 1;
+				this._nextNewline = next;
+			} else if (this.line === 1) {
+				// Retreat on line 1: no `\n` precedes `pos`, the cache stays valid.
+				this.column = pos;
 			} else {
 				// Retreat: count newlines crossed in (pos, this.pos), i.e.
 				// exclude the newline at `this.pos` itself. By convention a
 				// `\n` is the last column of its line, so when `this.pos`
 				// sits on one we're already on the line containing it; only
 				// newlines strictly **before** `this.pos` and at-or-after
-				// `pos` represent crossed line boundaries.
-				let i = this._input.lastIndexOf("\n", this.pos - 1);
+				// `pos` represent crossed line boundaries. The smallest
+				// crossed one is the next newline after the new position.
+				let i = input.lastIndexOf("\n", this.pos - 1);
 				while (i >= pos) {
+					this._nextNewline = i;
 					this.line--;
-					i = i > 0 ? this._input.lastIndexOf("\n", i - 1) : -1;
+					i = i > 0 ? input.lastIndexOf("\n", i - 1) : -1;
 				}
 				this.column = i === -1 ? pos : pos - i - 1;
 			}