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

package/lib/util/StringXor.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../util/Hash")} Hash */
+/** @import Hash from "../util/Hash" */
 
 /**
  * StringXor class provides methods for performing

package/lib/util/URLAbsoluteSpecifier.js

@@ -17,6 +17,7 @@ const _0CharCode = "0".charCodeAt(0);
 const _9CharCode = "9".charCodeAt(0);
 const plusCharCode = "+".charCodeAt(0);
 const hyphenCharCode = "-".charCodeAt(0);
+const dotCharCode = ".".charCodeAt(0);
 const colonCharCode = ":".charCodeAt(0);
 const hashCharCode = "#".charCodeAt(0);
 const queryCharCode = "?".charCodeAt(0);
@@ -46,7 +47,8 @@ function getScheme(specifier) {
 		(ch >= aUpperCaseCharCode && ch <= zUpperCaseCharCode) ||
 		(ch >= _0CharCode && ch <= _9CharCode) ||
 		ch === plusCharCode ||
-		ch === hyphenCharCode
+		ch === hyphenCharCode ||
+		ch === dotCharCode
 	) {
 		if (++i === specifier.length) return;
 		ch = specifier.charCodeAt(i);

package/lib/util/chainedImports.js

@@ -5,10 +5,10 @@
 
 "use strict";
 
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import Dependency from "../Dependency" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { Range } from "../javascript/JavascriptParser" */
 
 /** @typedef {Range[]} IdRanges */
 
@@ -78,7 +78,11 @@ function trimIdsToThoseImported(ids, moduleGraph, dependency) {
 	);
 	for (let i = 0; i < ids.length; i++) {
 		if (i === 0 && ids[i] === "default") {
-			continue; // ExportInfo for the next level under default is still at the root ExportsInfo, so don't advance currentExportsInfo
+			const nestedInfo = currentExportsInfo
+				.getExportInfo(ids[i])
+				.getNestedExportsInfo();
+			if (nestedInfo) currentExportsInfo = nestedInfo;
+			continue;
 		}
 		const exportInfo = currentExportsInfo.getExportInfo(ids[i]);
 		if (exportInfo.provided === false) {

package/lib/util/cleverMerge.js

@@ -100,7 +100,7 @@ const cachedSetProperty = (obj, property, value) => {
  * @property {ByValues | undefined} byValues value depending on selector property, merged with base
  */
 
-/** @typedef {(function(...EXPECTED_ANY): object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
+/** @typedef {((...x: EXPECTED_ANY) => object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
 
 /**
  * Defines the parsed object static type used by this module.

package/lib/util/comparators.js

@@ -8,20 +8,17 @@
 const { getFullModuleName } = require("../ids/IdHelpers");
 const { compareRuntime } = require("./runtime");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Chunk").ChunkName} ChunkName */
-/** @typedef {import("../Chunk").ChunkId} ChunkId */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../dependencies/HarmonyImportSideEffectDependency")} HarmonyImportSideEffectDependency */
-/** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../dependencies/ModuleDependency")} ModuleDependency */
+/** @import Chunk, { ChunkName, ChunkId } from "../Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../ChunkGraph" */
+/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Compiler from "../Compiler" */
+/** @import Dependency, { DependencyLocation } from "../Dependency" */
+/** @import HarmonyImportSideEffectDependency from "../dependencies/HarmonyImportSideEffectDependency" */
+/** @import HarmonyImportSpecifierDependency from "../dependencies/HarmonyImportSpecifierDependency" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import WebpackErrorType from "../errors/WebpackError" */
+/** @import ModuleDependency from "../dependencies/ModuleDependency" */
 
 /**
  * Defines the dependency source order type used by this module.
@@ -501,6 +498,38 @@ const compareSelect = (getter, comparator) => {
 	return result;
 };
 
+// `compilation.errors`/`warnings`/`hints` are typed as plain `Error`s, so the
+// webpack-specific fields are read through a cast.
+const compareErrors = concatComparators(
+	compareSelect(
+		/**
+		 * @param {Error} err error
+		 * @returns {string} identifier of the module the error belongs to
+		 */
+		(err) => {
+			const { module } = /** @type {WebpackErrorType} */ (err);
+			return (module && module.identifier()) || "";
+		},
+		compareStringsNumeric
+	),
+	compareSelect(
+		/**
+		 * @param {Error} err error
+		 * @returns {DependencyLocation | undefined} location
+		 */
+		(err) => /** @type {WebpackErrorType} */ (err).loc,
+		compareLocations
+	),
+	compareSelect(
+		/**
+		 * @param {Error} err error
+		 * @returns {string} message
+		 */
+		(err) => `${err.message}`,
+		compareStringsNumeric
+	)
+);
+
 /** @type {WeakMap<Comparator<EXPECTED_ANY>, Comparator<Iterable<EXPECTED_ANY>>>} */
 const compareIteratorsCache = new WeakMap();
 
@@ -629,6 +658,8 @@ module.exports.compareChunksById = (a, b) =>
 	compareIds(/** @type {ChunkId} */ (a.id), /** @type {ChunkId} */ (b.id));
 module.exports.compareChunksNatural = compareChunksNatural;
 
+module.exports.compareErrors = compareErrors;
+
 module.exports.compareIds = compareIds;
 
 module.exports.compareIterables = compareIterables;

package/lib/util/concatenate.js

@@ -7,41 +7,199 @@
 
 const Template = require("../Template");
 
-/** @typedef {import("estree").Node} Node */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").Scope} Scope */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").Reference} Reference */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").Variable} Variable */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { Identifier, Node } from "estree" */
+/** @import { Optimization } from "../../declarations/WebpackOptions" */
+/**
+ * @import {
+ * 	Scope,
+ * 	Reference,
+ * 	Variable
+ * } from "../javascript/JavascriptModulesPlugin"
+ */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @typedef {Node & { start?: number, end?: number }} PositionedNode */
+/** @typedef {Exclude<keyof Node, "range" | "loc" | "leadingComments" | "trailingComments">} ChildKey */
 /** @typedef {Set<string>} UsedNames */
 
 const DEFAULT_EXPORT = "__WEBPACK_DEFAULT_EXPORT__";
 const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
 
+/**
+ * Whether CommonJS modules and require edges take part in concatenation.
+ * @param {Optimization["concatenateModules"]} concatenateModules the optimization.concatenateModules option
+ * @returns {boolean} true when CommonJS concatenation is enabled
+ */
+const isCommonJsConcatenationEnabled = (concatenateModules) =>
+	typeof concatenateModules === "object"
+		? concatenateModules.commonjs !== false
+		: concatenateModules === true;
+
+/** @type {WeakMap<Scope, Map<Identifier, Variable>>} */
+const sharedInnerBindingsCache = new WeakMap();
+
+/**
+ * The inner bindings sharing a declaring identifier with their own scope — a
+ * class name binds twice. Indexed once per scope; per binding it is quadratic.
+ * @param {Scope} scope the scope whose children to index
+ * @returns {Map<Identifier, Variable>} the inner binding sharing each identifier
+ */
+const getSharedInnerBindings = (scope) => {
+	const cached = sharedInnerBindingsCache.get(scope);
+	if (cached !== undefined) return cached;
+	/** @type {Map<Identifier, Variable>} */
+	const shared = new Map();
+	/** @type {Set<Identifier>} */
+	const declared = new Set();
+	for (const variable of scope.variables) {
+		for (const identifier of variable.identifiers) declared.add(identifier);
+	}
+	if (declared.size !== 0) {
+		for (const child of scope.childScopes) {
+			for (const innerVariable of child.variables) {
+				for (const identifier of innerVariable.identifiers) {
+					if (declared.has(identifier)) shared.set(identifier, innerVariable);
+				}
+			}
+		}
+	}
+	sharedInnerBindingsCache.set(scope, shared);
+	return shared;
+};
+
 /**
  * Gets all references.
  * @param {Variable} variable variable
  * @returns {Reference[]} references
  */
 const getAllReferences = (variable) => {
+	// the inner binding of `class Foo { t() { Foo } }` holds references to the
+	// same name, and renaming has to move them too
+	const shared = getSharedInnerBindings(variable.scope);
+	if (shared.size === 0) return variable.references;
 	let set = variable.references;
-	// Look for inner scope variables too (like in class Foo { t() { Foo } })
-	// identifiers is tiny (usually 1 declaration) — indexOf beats a Set here
-	const identifiers = variable.identifiers;
-	for (const scope of variable.scope.childScopes) {
-		for (const innerVar of scope.variables) {
-			if (innerVar.identifiers.some((id) => identifiers.includes(id))) {
-				// copy-on-write to keep the common no-match case allocation-free
-				if (set === variable.references) set = [...set];
-				for (const ref of innerVar.references) set.push(ref);
-				break;
+	/** @type {Variable | undefined} */
+	let last;
+	for (const identifier of variable.identifiers) {
+		const innerVariable = shared.get(identifier);
+		if (innerVariable === undefined || innerVariable === last) continue;
+		last = innerVariable;
+		// copy-on-write to keep the common no-match case allocation-free
+		if (set === variable.references) set = [...set];
+		for (const reference of innerVariable.references) set.push(reference);
+	}
+	return set;
+};
+
+/**
+ * Tests whether a node covers the searched range. `start`/`end` are read before
+ * `range`, because webpack's parser serves `range` from a lazy getter that
+ * allocates an array and transitions the node's shape on first access — reading
+ * it while walking would pay that for most nodes of the ast.
+ * @param {PositionedNode} node node
+ * @param {number} start start of the searched range
+ * @param {number} end end of the searched range
+ * @returns {boolean} whether the node covers the range
+ */
+const coversRange = (node, start, end) => {
+	const nodeStart = node.start;
+	if (typeof nodeStart === "number") {
+		return nodeStart <= start && /** @type {number} */ (node.end) >= end;
+	}
+	const range = node.range;
+	return range !== undefined && range[0] <= start && range[1] >= end;
+};
+
+/**
+ * Returns the single sibling covering the searched range.
+ * @param {Node[]} items sibling nodes
+ * @param {number} start start of the searched range
+ * @param {number} end end of the searched range
+ * @returns {Node | undefined} covering sibling
+ */
+const findCoveringItem = (items, start, end) => {
+	// sibling ranges are ordered and disjoint; binary search the container
+	let low = 0;
+	let high = items.length - 1;
+	while (low <= high) {
+		const middle = (low + high) >> 1;
+		const item = /** @type {PositionedNode} */ (items[middle]);
+		/** @type {number | undefined} */
+		let itemStart;
+		/** @type {number | undefined} */
+		let itemEnd;
+		if (item) {
+			itemStart = item.start;
+			if (typeof itemStart === "number") {
+				itemEnd = item.end;
+			} else {
+				const range = item.range;
+				if (range === undefined) {
+					itemStart = undefined;
+				} else {
+					itemStart = range[0];
+					itemEnd = range[1];
+				}
+			}
+		}
+		if (itemStart === undefined) {
+			// holes or range-less nodes: scan the remaining window linearly
+			for (let i = low; i <= high; i++) {
+				const candidate = items[i];
+				if (candidate && coversRange(candidate, start, end)) return candidate;
 			}
+			return undefined;
+		}
+		if (itemStart > start) {
+			high = middle - 1;
+		} else if (start >= /** @type {number} */ (itemEnd)) {
+			low = middle + 1;
+		} else {
+			return /** @type {number} */ (itemEnd) >= end ? item : undefined;
 		}
 	}
-	return set;
+	return undefined;
+};
+
+/**
+ * Collects the ancestors of `node` below `parent`, innermost first.
+ * Keeps scanning after a covering child turns out not to contain `node`:
+ * a shorthand `{ a }` holds two distinct identifiers with the same range.
+ * @param {Node} parent node to search in
+ * @param {number} start start of the searched range
+ * @param {number} end end of the searched range
+ * @param {Node} node node to find
+ * @param {Node[]} path collected ancestors
+ * @returns {boolean} whether the node was found
+ */
+const collectPathInNode = (parent, start, end, node, path) => {
+	for (const key in parent) {
+		// sit in front of the child keys on every node and never hold one, so
+		// skipping them by name is what keeps the per-level scan short
+		if (key === "type" || key === "start" || key === "end") continue;
+		const value = parent[/** @type {ChildKey} */ (key)];
+		if (value === null || typeof value !== "object") continue;
+		/** @type {Node | undefined} */
+		let child;
+		if (Array.isArray(value)) {
+			// `range` is a number pair on parsers that own the property
+			if (key === "range") continue;
+			child = findCoveringItem(value, start, end);
+		} else if (coversRange(value, start, end)) {
+			child = value;
+		}
+		if (
+			child !== undefined &&
+			(child === node || collectPathInNode(child, start, end, node, path))
+		) {
+			path.push(child);
+			return true;
+		}
+	}
+	return false;
 };
 
 /**
- * Returns result.
+ * Returns the ancestors of `node` up to (but excluding) `ast`, innermost first.
  * @param {Node | Node[]} ast ast
  * @param {Node} node node
  * @returns {undefined | Node[]} result
@@ -51,69 +209,25 @@ const getPathInAst = (ast, node) => {
 		return [];
 	}
 
-	const nr = /** @type {Range} */ (node.range);
-
-	/**
-	 * Returns result.
-	 * @param {Node} n node
-	 * @returns {Node[] | undefined} result
-	 */
-	const enterNode = (n) => {
-		if (!n) return;
-		const r = n.range;
-		if (r && r[0] <= nr[0] && r[1] >= nr[1]) {
-			const path = getPathInAst(n, node);
-			if (path) {
-				path.push(n);
-				return path;
-			}
-		}
-	};
+	const nodeRange = /** @type {Range} */ (node.range);
+	const start = nodeRange[0];
+	const end = nodeRange[1];
+	/** @type {Node[]} */
+	const path = [];
 
 	if (Array.isArray(ast)) {
-		// sibling ranges are ordered and disjoint; binary search the container
-		let lo = 0;
-		let hi = ast.length - 1;
-		while (lo <= hi) {
-			const mid = (lo + hi) >> 1;
-			const item = ast[mid];
-			const r = item && item.range;
-			if (!r) {
-				// holes or range-less nodes: scan the remaining window linearly
-				for (let i = lo; i <= hi; i++) {
-					const enterResult = enterNode(ast[i]);
-					if (enterResult !== undefined) return enterResult;
-				}
-				return;
-			}
-			if (r[0] > nr[0]) {
-				hi = mid - 1;
-			} else if (nr[0] >= r[1]) {
-				lo = mid + 1;
-			} else {
-				return r[1] >= nr[1] ? enterNode(item) : undefined;
-			}
-		}
-	} else if (ast && typeof ast === "object") {
-		const keys =
-			/** @type {(keyof Node)[]} */
-			(Object.keys(ast));
-		for (let i = 0; i < keys.length; i++) {
-			// We are making the faster check in `enterNode` using `n.range`
-			const value =
-				ast[
-					/** @type {Exclude<keyof Node, "range" | "loc" | "leadingComments" | "trailingComments">} */
-					(keys[i])
-				];
-			if (Array.isArray(value)) {
-				const pathResult = getPathInAst(value, node);
-				if (pathResult !== undefined) return pathResult;
-			} else if (value && typeof value === "object") {
-				const enterResult = enterNode(value);
-				if (enterResult !== undefined) return enterResult;
-			}
+		const item = findCoveringItem(ast, start, end);
+		if (item === undefined) return undefined;
+		if (item !== node && !collectPathInNode(item, start, end, node, path)) {
+			return undefined;
 		}
+		path.push(item);
+		return path;
 	}
+
+	if (!ast || typeof ast !== "object") return undefined;
+
+	return collectPathInNode(ast, start, end, node, path) ? path : undefined;
 };
 
 /** @type {Map<string, string[]>} */
@@ -210,11 +324,21 @@ const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 	}
 };
 
+// Declared by the chunk bootstrap in the scope module code is hoisted into.
+// Hit when a webpack bundle is bundled again, since its output declares exactly
+// these: the `const` one then fails to parse, the `var` one silently clobbers
+// the module table. CompatibilityPlugin renames the other two runtime names.
+const CHUNK_RUNTIME_DECLARATIONS = new Set([
+	"__webpack_modules__",
+	"__webpack_module_cache__"
+]);
+
 const RESERVED_NAMES = new Set(
 	[
 		// internal names (should always be renamed)
 		DEFAULT_EXPORT,
 		NAMESPACE_OBJECT_EXPORT,
+		...CHUNK_RUNTIME_DECLARATIONS,
 
 		// keywords
 		"abstract,arguments,async,await,boolean,break,byte,case,catch,char,class,const,continue",
@@ -277,6 +401,7 @@ const getUsedNamesInScopeInfo = (usedNamesInScopeInfo, module, id) => {
 };
 
 module.exports = {
+	CHUNK_RUNTIME_DECLARATIONS,
 	DEFAULT_EXPORT,
 	NAMESPACE_OBJECT_EXPORT,
 	RESERVED_NAMES,
@@ -284,5 +409,6 @@ module.exports = {
 	findNewName,
 	getAllReferences,
 	getPathInAst,
-	getUsedNamesInScopeInfo
+	getUsedNamesInScopeInfo,
+	isCommonJsConcatenationEnabled
 };

package/lib/util/conventions.js

@@ -5,7 +5,11 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+/**
+ * @import {
+ * 	CssGeneratorExportsConvention
+ * } from "../../declarations/WebpackOptions"
+ */
 // Copy from css-loader
 /**
  * Preserve camel case.
@@ -111,7 +115,11 @@ module.exports.cssExportConvention = (input, convention) => {
 	const set = new Set();
 	if (typeof convention === "function") {
 		const result = convention(input);
-		const validate = (/** @type {string} */ name) => {
+		/**
+		 * @param {string} name name returned by the convention function
+		 * @returns {void}
+		 */
+		const validate = (name) => {
 			if (typeof name !== "string" || name.length === 0) {
 				throw new Error(
 					`exportsConvention function must return a non-empty string or an array of non-empty strings, got ${safeStringify(result)}`

package/lib/util/createHash.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("./Hash")} Hash */
-/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
+/** @import Hash from "./Hash" */
+/** @import { HashFunction } from "../../declarations/WebpackOptions" */
 
 /** @type {typeof import("crypto") | undefined} */
 let crypto;

package/lib/util/createHooksRegistry.js

@@ -4,10 +4,6 @@
 
 "use strict";
 
-const memoize = require("./memoize");
-
-const getCompilation = memoize(() => require("../Compilation"));
-
 /**
  * @template T
  * @param {() => T} createHooks factory that returns a fresh hooks object
@@ -17,10 +13,15 @@ const createHooksRegistry = (createHooks) => {
 	/** @type {WeakMap<import("../Compilation"), T>} */
 	const map = new WeakMap();
 	return (compilation) => {
-		if (!(compilation instanceof getCompilation())) {
-			// a compilation from another webpack copy fails instanceof — match the class name
+		let hooks = map.get(compilation);
+		if (hooks === undefined) {
+			// validated once per compilation — this runs on every render and
+			// codegen. Matched by class name, not `instanceof`: a compilation from
+			// another webpack copy has to pass too, and importing `Compilation`
+			// here cycles.
 			const candidate =
-				/** @type {{ constructor?: { name: string } } | null} */ (compilation);
+				/** @type {{ constructor?: { name: string } } | null} */
+				(compilation);
 			if (
 				!candidate ||
 				!candidate.constructor ||
@@ -30,9 +31,6 @@ const createHooksRegistry = (createHooks) => {
 					"The 'compilation' argument must be an instance of Compilation"
 				);
 			}
-		}
-		let hooks = map.get(compilation);
-		if (hooks === undefined) {
 			hooks = createHooks();
 			map.set(compilation, hooks);
 		}

package/lib/util/createMappings.js

@@ -13,9 +13,9 @@
  * while richer call sites can pass arrays of segments.
  *
  * TODO move this encoder into `webpack-sources` and replace the body of this
- * file with re-exports. The public shape (`encodeVLQ`, `encodeMappings(lines)`,
- * `MappingSegment`, `LineMappings`) is intended to match what would land
- * upstream so call sites don't have to change.
+ * file with re-exports. The public shape (`encodeVLQ`, `decodeVLQ`,
+ * `encodeMappings(lines)`, `MappingSegment`, `LineMappings`) is intended to
+ * match what would land upstream so call sites don't have to change.
  */
 
 const VLQ_BASE64 =
@@ -38,6 +38,27 @@ const encodeVLQ = (value) => {
 	return result;
 };
 
+/**
+ * Decode one base64 VLQ value per the source-map V3 spec.
+ * @param {string} mappings a VLQ encoded `mappings` string
+ * @param {number} start index of the value's first character
+ * @returns {{ value: number, end: number }} the decoded value and the index just past it; `end` equals `start` when there is no valid value at `start`
+ */
+const decodeVLQ = (mappings, start) => {
+	let value = 0;
+	let shift = 0;
+	let index = start;
+	let digit;
+	do {
+		digit = index < mappings.length ? VLQ_BASE64.indexOf(mappings[index]) : -1;
+		if (digit < 0) return { value: 0, end: start };
+		value += (digit & 0x1f) << shift;
+		shift += 5;
+		index++;
+	} while (digit & 0x20);
+	return { value: value & 1 ? -(value >>> 1) : value >>> 1, end: index };
+};
+
 /**
  * @typedef {object} MappingSegment
  * @property {number=} generatedColumn 0-based generated column (defaults to 0)
@@ -114,5 +135,6 @@ const encodeMappings = (lines) => {
 	return encodedLines.join(";");
 };
 
+module.exports.decodeVLQ = decodeVLQ;
 module.exports.encodeMappings = encodeMappings;
 module.exports.encodeVLQ = encodeVLQ;