@depup/webpack 5.111.1-depup.2 → 5.112.0-depup.0

package/lib/util/TupleSet.js

@@ -16,16 +16,16 @@
 /**
  * Stores tuples of arbitrary length while preserving efficient prefix lookups
  * through a tree of maps that ends in a set of final values.
- * @template T
+ * @template {EXPECTED_ANY[]} K
  * @template V
  */
 class TupleSet {
 	/**
 	 * Seeds the tuple set with an optional iterable of tuples.
-	 * @param {Iterable<[T, V, ...EXPECTED_ANY]>=} init init
+	 * @param {Iterable<[...K, V]>=} init init
 	 */
 	constructor(init) {
-		/** @type {InnerMap<T, V>} */
+		/** @type {InnerMap<K[number], V>} */
 		this._map = new Map();
 		/** @type {number} */
 		this.size = 0;
@@ -38,28 +38,28 @@ class TupleSet {
 
 	/**
 	 * Adds a tuple to the set, creating any missing prefix maps along the way.
-	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
+	 * @param {[...K, V]} args tuple
 	 * @returns {void}
 	 */
 	add(...args) {
 		let map = this._map;
 		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
+			const arg = /** @type {K[number]} */ (args[i]);
 			const innerMap = map.get(arg);
 			if (innerMap === undefined) {
 				map.set(arg, (map = new Map()));
 			} else {
-				map = /** @type {InnerMap<T, V>} */ (innerMap);
+				map = /** @type {InnerMap<K[number], V>} */ (innerMap);
 			}
 		}
 
-		const beforeLast = args[args.length - 2];
+		const beforeLast = /** @type {K[number]} */ (args[args.length - 2]);
 		let set = /** @type {Set<V>} */ (map.get(beforeLast));
 		if (set === undefined) {
 			map.set(beforeLast, (set = new Set()));
 		}
 
-		const last = args[args.length - 1];
+		const last = /** @type {V} */ (args[args.length - 1]);
 		this.size -= set.size;
 		set.add(last);
 		this.size += set.size;
@@ -67,51 +67,51 @@ class TupleSet {
 
 	/**
 	 * Checks whether the exact tuple is already present in the set.
-	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
+	 * @param {[...K, V]} args tuple
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
 	has(...args) {
 		let map = this._map;
 		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
-			map = /** @type {InnerMap<T, V>} */ (map.get(arg));
+			const arg = /** @type {K[number]} */ (args[i]);
+			map = /** @type {InnerMap<K[number], V>} */ (map.get(arg));
 			if (map === undefined) {
 				return false;
 			}
 		}
 
-		const beforeLast = args[args.length - 2];
-		const set = map.get(beforeLast);
+		const beforeLast = /** @type {K[number]} */ (args[args.length - 2]);
+		const set = /** @type {Set<V> | undefined} */ (map.get(beforeLast));
 		if (set === undefined) {
 			return false;
 		}
 
-		const last = args[args.length - 1];
+		const last = /** @type {V} */ (args[args.length - 1]);
 		return set.has(last);
 	}
 
 	/**
 	 * Removes a tuple from the set when it is present.
-	 * @param {[T, V, ...EXPECTED_ANY]} args tuple
+	 * @param {[...K, V]} args tuple
 	 * @returns {void}
 	 */
 	delete(...args) {
 		let map = this._map;
 		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
-			map = /** @type {InnerMap<T, V>} */ (map.get(arg));
+			const arg = /** @type {K[number]} */ (args[i]);
+			map = /** @type {InnerMap<K[number], V>} */ (map.get(arg));
 			if (map === undefined) {
 				return;
 			}
 		}
 
-		const beforeLast = args[args.length - 2];
-		const set = map.get(beforeLast);
+		const beforeLast = /** @type {K[number]} */ (args[args.length - 2]);
+		const set = /** @type {Set<V> | undefined} */ (map.get(beforeLast));
 		if (set === undefined) {
 			return;
 		}
 
-		const last = args[args.length - 1];
+		const last = /** @type {V} */ (args[args.length - 1]);
 		this.size -= set.size;
 		set.delete(last);
 		this.size += set.size;
@@ -120,7 +120,7 @@ class TupleSet {
 	/**
 	 * Iterates over every stored tuple by walking the nested map structure and
 	 * yielding each complete prefix plus its terminal set value.
-	 * @returns {Iterator<[T, V, ...EXPECTED_ANY]>} iterator
+	 * @returns {Iterator<[...K, V]>} iterator
 	 */
 	[Symbol.iterator]() {
 		/**
@@ -131,9 +131,9 @@ class TupleSet {
 
 		// This is difficult to type because we can have a map inside a map inside a map, etc. where the end is a set (each key is an argument)
 		// But in basic use we only have 2 arguments in our methods, so we have `Map<K, Set<V>>`
-		/** @type {IteratorStack<T, V>[]} */
+		/** @type {IteratorStack<K[number], V>[]} */
 		const iteratorStack = [];
-		/** @type {[T?, V?, ...EXPECTED_ANY]} */
+		/** @type {(K[number] | V)[]} */
 		const tuple = [];
 		/** @type {SetIterator<V> | undefined} */
 		let currentSetIterator;
@@ -141,7 +141,7 @@ class TupleSet {
 		/**
 		 * Advances through nested maps until a terminal value set is reached or
 		 * every remaining branch has been exhausted.
-		 * @param {IteratorStack<T, V>} it iterator
+		 * @param {IteratorStack<K[number], V>} it iterator
 		 * @returns {boolean} result
 		 */
 		const next = (it) => {
@@ -150,7 +150,7 @@ class TupleSet {
 				if (iteratorStack.length === 0) return false;
 				tuple.pop();
 				return next(
-					/** @type {IteratorStack<T, V>} */
+					/** @type {IteratorStack<K[number], V>} */
 					(iteratorStack.pop())
 				);
 			}
@@ -174,7 +174,7 @@ class TupleSet {
 						tuple.pop();
 						if (
 							!next(
-								/** @type {IteratorStack<T, V>} */
+								/** @type {IteratorStack<K[number], V>} */
 								(iteratorStack.pop())
 							)
 						) {
@@ -185,7 +185,7 @@ class TupleSet {
 							done: false,
 							value:
 								/* eslint-disable unicorn/prefer-spread */
-								/** @type {[T, V, ...EXPECTED_ANY]} */
+								/** @type {[...K, V]} */
 								(tuple.concat(result.value))
 						};
 					}

package/lib/util/WeakTupleMap.js

@@ -10,7 +10,7 @@
  * `WeakMap`.
  * @template {EXPECTED_ANY[]} T
  * @template V
- * @typedef {Map<EXPECTED_ANY, WeakTupleMap<T, V>>} M
+ * @typedef {Map<ArrayElement<T>, WeakTupleMap<T, V>>} M
  */
 
 /**
@@ -18,13 +18,14 @@
  * without preventing garbage collection.
  * @template {EXPECTED_ANY[]} T
  * @template V
- * @typedef {WeakMap<EXPECTED_OBJECT, WeakTupleMap<T, V>>} W
+ * @typedef {WeakMap<ArrayElement<T> & EXPECTED_OBJECT, WeakTupleMap<T, V>>} W
  */
 
 /**
  * Reports whether a tuple element can be stored in a `WeakMap`.
- * @param {EXPECTED_ANY} thing thing
- * @returns {boolean} true if is weak
+ * @template T
+ * @param {T} thing thing
+ * @returns {thing is T & EXPECTED_OBJECT} true if is weak
  */
 const isWeakKey = (thing) => typeof thing === "object" && thing !== null;
 
@@ -136,8 +137,9 @@ class WeakTupleMap {
 	 * () => compute(thisArg, ...args))` but without allocating that closure (or an
 	 * extra rest array) on every call — `ModuleGraph#cached` runs this on hot
 	 * paths where most calls hit the cache and the closure would be pure waste.
-	 * @param {(thisArg: EXPECTED_ANY, ...args: K) => V} compute computer, also the first key element
-	 * @param {EXPECTED_ANY} thisArg first argument passed to `compute`
+	 * @template This
+	 * @param {(thisArg: This, ...args: K) => V} compute computer, also the first key element
+	 * @param {This} thisArg first argument passed to `compute`
 	 * @param {K} args remaining key elements, also passed to `compute`
 	 * @returns {V} the value
 	 */
@@ -222,14 +224,10 @@ class WeakTupleMap {
 	_peek(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) return;
-			return /** @type {WeakMap<ArrayElement<K>, WeakTupleMap<K, V>>} */ (
-				this.w
-			).get(thing);
+			return /** @type {W<K, V>} */ (this.w).get(thing);
 		}
 		if ((this.f & 2) !== 2) return;
-		return /** @type {Map<ArrayElement<K>, WeakTupleMap<K, V>>} */ (this.m).get(
-			thing
-		);
+		return /** @type {M<K, V>} */ (this.m).get(thing);
 	}
 
 	/**

package/lib/util/buildDiagnostics.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @import Module, { BuildDiagnostics, BuildInfo } from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import Module, { BuildDiagnostics, BuildInfo } from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 
 /**
  * The diagnostics record of a build info, created on first use so a module nothing reports about carries none.

package/lib/util/comparators.js

@@ -8,17 +8,17 @@
 const { getFullModuleName } = require("../ids/IdHelpers");
 const { compareRuntime } = require("./runtime");
 
-/** @import Chunk, { ChunkName, ChunkId } from "../Chunk" */
-/** @import ChunkGraph, { ModuleId } from "../ChunkGraph" */
-/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Chunk, { ChunkName, ChunkId } from "../graph/Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../graph/ChunkGraph" */
+/** @import ChunkGroup from "../graph/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 Dependency, { DependencyLocation } from "../graph/Dependency" */
+/** @import ESMImportSideEffectDependency from "../dependencies/esm/ESMImportSideEffectDependency" */
+/** @import ESMImportSpecifierDependency from "../dependencies/esm/ESMImportSpecifierDependency" */
+/** @import Module from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 /** @import WebpackErrorType from "../errors/WebpackError" */
-/** @import ModuleDependency from "../dependencies/ModuleDependency" */
+/** @import ModuleDependency from "../dependencies/core/ModuleDependency" */
 
 /**
  * Defines the dependency source order type used by this module.
@@ -579,7 +579,7 @@ const compareChunksNatural = (chunkGraph) => {
 };
 
 /**
- * For HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency, we should prioritize import order to match the behavior of running modules directly in a JS engine without a bundler.
+ * For ESMImportSideEffectDependency and ESMImportSpecifierDependency, we should prioritize import order to match the behavior of running modules directly in a JS engine without a bundler.
  * For other types like ConstDependency, we can instead prioritize usage order.
  * https://github.com/webpack/webpack/pull/19686
  * @param {Dependency[]} dependencies dependencies

package/lib/util/concatenate.js

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const Template = require("../Template");
+const Template = require("../template/Template");
 
-/** @import { Identifier, Node } from "estree" */
+/** @import { Identifier } from "estree" */
 /** @import { Optimization } from "../../declarations/WebpackOptions" */
 /**
  * @import {
@@ -16,9 +16,6 @@ const Template = require("../Template");
  * 	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__";
@@ -90,146 +87,6 @@ const getAllReferences = (variable) => {
 	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 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 the ancestors of `node` up to (but excluding) `ast`, innermost first.
- * @param {Node | Node[]} ast ast
- * @param {Node} node node
- * @returns {undefined | Node[]} result
- */
-const getPathInAst = (ast, node) => {
-	if (ast === node) {
-		return [];
-	}
-
-	const nodeRange = /** @type {Range} */ (node.range);
-	const start = nodeRange[0];
-	const end = nodeRange[1];
-	/** @type {Node[]} */
-	const path = [];
-
-	if (Array.isArray(ast)) {
-		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[]>} */
 const splittedInfoCache = new Map();
 
@@ -302,6 +159,30 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 	return nameWithNumber;
 }
 
+// A string literal, kept whole, or an identifier that is not a property name;
+const IDENTIFIER_OR_STRING_REGEXP =
+	/"(?:[^"\\]|\\.)*"|(?<![.\w$])[A-Za-z_$][\w$]*/g;
+
+/**
+ * Renames every identifier of a printed expression that the map names, keeping
+ * property names and string contents as they are.
+ * @param {string} expression the expression as printed
+ * @param {Map<string, string>} renames original to new name
+ * @returns {string} the expression over the new names
+ * @example
+ * const renames = new Map([["store", "entry_store"], ["x", "entry_x"]]);
+ * renameIdentifiers("store.x", renames) === "entry_store.x"
+ * renameIdentifiers('store["a-b"]', renames) === 'entry_store["a-b"]'
+ * renameIdentifiers("store/* .x *\/.c", renames) === "entry_store/* .x *\/.c"
+ * renameIdentifiers("(store_default())", renames) === "(store_default())"
+ * renameIdentifiers("/* reads x *\/ x", renames) === "/* reads entry_x *\/ entry_x"
+ */
+const renameIdentifiers = (expression, renames) =>
+	expression.replace(IDENTIFIER_OR_STRING_REGEXP, (token) => {
+		const renamed = renames.get(token);
+		return renamed === undefined ? token : renamed;
+	});
+
 /** @typedef {Set<Scope>} ScopeSet */
 
 /**
@@ -408,7 +289,7 @@ module.exports = {
 	addScopeSymbols,
 	findNewName,
 	getAllReferences,
-	getPathInAst,
 	getUsedNamesInScopeInfo,
-	isCommonJsConcatenationEnabled
+	isCommonJsConcatenationEnabled,
+	renameIdentifiers
 };

package/lib/util/createMappings.js

@@ -135,6 +135,117 @@ const encodeMappings = (lines) => {
 	return encodedLines.join(";");
 };
 
+/** @typedef {[number] | [number, number, number, number] | [number, number, number, number, number]} DecodedSegment generated column, then source index, original line and column, then name index, all 0-based */
+
+/**
+ * Decode a V3 `mappings` string into one array of segments per generated line,
+ * each sorted by generated column.
+ * @param {string} mappings a VLQ encoded `mappings` string
+ * @returns {DecodedSegment[][]} the segments of each generated line
+ */
+const decodeMappings = (mappings) => {
+	const { length } = mappings;
+	/** @type {DecodedSegment[][]} */
+	const lines = [];
+	let position = 0;
+	let sourceIndex = 0;
+	let originalLine = 0;
+	let originalColumn = 0;
+	let nameIndex = 0;
+
+	/**
+	 * @returns {number} the value at `position`, which moves past it
+	 */
+	const read = () => {
+		const { value, end } = decodeVLQ(mappings, position);
+		// An invalid character reads as 0 and is skipped, so decoding ends.
+		position = end === position ? position + 1 : end;
+		// `B`, a negative zero, reads as -2^31 as source-map readers decode it,
+		// which sorts it before every column on its line.
+		return Object.is(value, -0) ? -2147483648 : value;
+	};
+
+	do {
+		let lineEnd = mappings.indexOf(";", position);
+		if (lineEnd === -1) lineEnd = length;
+		/** @type {DecodedSegment[]} */
+		const line = [];
+		let sorted = true;
+		let generatedColumn = 0;
+		while (position < lineEnd) {
+			const previousColumn = generatedColumn;
+			generatedColumn += read();
+			if (generatedColumn < previousColumn) sorted = false;
+			if (position < lineEnd && mappings[position] !== ",") {
+				sourceIndex += read();
+				originalLine += read();
+				originalColumn += read();
+				if (position < lineEnd && mappings[position] !== ",") {
+					nameIndex += read();
+					line.push([
+						generatedColumn,
+						sourceIndex,
+						originalLine,
+						originalColumn,
+						nameIndex
+					]);
+				} else {
+					line.push([
+						generatedColumn,
+						sourceIndex,
+						originalLine,
+						originalColumn
+					]);
+				}
+			} else {
+				line.push([generatedColumn]);
+			}
+			position++;
+		}
+		if (!sorted) line.sort((a, b) => a[0] - b[0]);
+		lines.push(line);
+		position = lineEnd + 1;
+	} while (position <= length);
+	return lines;
+};
+
+/**
+ * Encode the segments `decodeMappings` reads back into a V3 `mappings` string.
+ * @param {DecodedSegment[][]} lines the segments of each generated line
+ * @returns {string} VLQ-encoded V3 mappings string
+ */
+const encodeDecodedMappings = (lines) => {
+	let sourceIndex = 0;
+	let originalLine = 0;
+	let originalColumn = 0;
+	let nameIndex = 0;
+	let result = "";
+	for (let i = 0; i < lines.length; i++) {
+		if (i > 0) result += ";";
+		const line = lines[i];
+		let generatedColumn = 0;
+		for (let j = 0; j < line.length; j++) {
+			const segment = line[j];
+			if (j > 0) result += ",";
+			result += encodeVLQ(segment[0] - generatedColumn);
+			generatedColumn = segment[0];
+			if (segment.length === 1) continue;
+			result += encodeVLQ(segment[1] - sourceIndex);
+			result += encodeVLQ(segment[2] - originalLine);
+			result += encodeVLQ(segment[3] - originalColumn);
+			sourceIndex = segment[1];
+			originalLine = segment[2];
+			originalColumn = segment[3];
+			if (segment.length === 4) continue;
+			result += encodeVLQ(segment[4] - nameIndex);
+			nameIndex = segment[4];
+		}
+	}
+	return result;
+};
+
+module.exports.decodeMappings = decodeMappings;
 module.exports.decodeVLQ = decodeVLQ;
+module.exports.encodeDecodedMappings = encodeDecodedMappings;
 module.exports.encodeMappings = encodeMappings;
 module.exports.encodeVLQ = encodeVLQ;