webpack 5.107.2 → 5.108.0

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -1689,8 +1689,8 @@ class DefaultStatsPrinterPlugin {
 					Object.keys(COMPILATION_SIMPLE_PRINTERS)
 				)) {
 					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {EXPECTED_ANY} */
-						(COMPILATION_SIMPLE_PRINTERS)[key](
+						/** @type {NonNullable<CompilationSimplePrinters[keyof CompilationSimplePrinters]>} */
+						(COMPILATION_SIMPLE_PRINTERS[key])(
 							obj,
 							/** @type {DefineStatsPrinterContext<"compilation">} */
 							(ctx),
@@ -1717,8 +1717,8 @@ class DefaultStatsPrinterPlugin {
 					Object.keys(MODULE_SIMPLE_PRINTERS)
 				)) {
 					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {EXPECTED_ANY} */
-						(MODULE_SIMPLE_PRINTERS)[key](
+						/** @type {SimplePrinter<EXPECTED_ANY, "module">} */
+						(MODULE_SIMPLE_PRINTERS[key])(
 							obj,
 							/** @type {DefineStatsPrinterContext<"module">} */
 							(ctx),
@@ -1745,8 +1745,8 @@ class DefaultStatsPrinterPlugin {
 					Object.keys(MODULE_REASON_PRINTERS)
 				)) {
 					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {EXPECTED_ANY} */
-						(MODULE_REASON_PRINTERS)[key](
+						/** @type {SimplePrinter<EXPECTED_ANY, "moduleReason">} */
+						(MODULE_REASON_PRINTERS[key])(
 							obj,
 							/** @type {DefineStatsPrinterContext<"moduleReason">} */
 							(ctx),
@@ -1773,8 +1773,8 @@ class DefaultStatsPrinterPlugin {
 					Object.keys(CHUNK_GROUP_PRINTERS)
 				)) {
 					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {EXPECTED_ANY} */
-						(CHUNK_GROUP_PRINTERS)[key](
+						/** @type {SimplePrinter<EXPECTED_ANY, "chunkGroupKind" | "chunkGroup">} */
+						(CHUNK_GROUP_PRINTERS[key])(
 							obj,
 							/** @type {DefineStatsPrinterContext<"chunkGroupKind" | "chunkGroup">} */
 							(ctx),
@@ -1787,8 +1787,8 @@ class DefaultStatsPrinterPlugin {
 					Object.keys(CHUNK_PRINTERS)
 				)) {
 					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {EXPECTED_ANY} */
-						(CHUNK_PRINTERS)[key](
+						/** @type {SimplePrinter<EXPECTED_ANY, "chunk">} */
+						(CHUNK_PRINTERS[key])(
 							obj,
 							/** @type {DefineStatsPrinterContext<"chunk">} */
 							(ctx),
@@ -1801,8 +1801,8 @@ class DefaultStatsPrinterPlugin {
 					Object.keys(ERROR_PRINTERS)
 				)) {
 					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {EXPECTED_ANY} */
-						(ERROR_PRINTERS)[key](
+						/** @type {SimplePrinter<EXPECTED_ANY, "error">} */
+						(ERROR_PRINTERS[key])(
 							obj,
 							/** @type {DefineStatsPrinterContext<"error">} */
 							(ctx),
@@ -1815,8 +1815,8 @@ class DefaultStatsPrinterPlugin {
 					Object.keys(LOG_ENTRY_PRINTERS)
 				)) {
 					stats.hooks.print.for(key).tap(PLUGIN_NAME, (obj, ctx) =>
-						/** @type {EXPECTED_ANY} */
-						(LOG_ENTRY_PRINTERS)[key](
+						/** @type {SimplePrinter<EXPECTED_ANY, "logging">} */
+						(LOG_ENTRY_PRINTERS[key])(
 							obj,
 							/** @type {DefineStatsPrinterContext<"logging">} */
 							(ctx),

package/lib/stats/StatsFactory.js

@@ -131,10 +131,11 @@ class StatsFactory {
 		});
 		const hooks = this.hooks;
 		this._caches =
-			/** @type {{ [Key in keyof StatsFactoryHooks]: Map<string, SyncBailHook<EXPECTED_ANY, EXPECTED_ANY>[]> }} */ ({});
+			/** @type {{ [Key in keyof StatsFactoryHooks]: StatsFactoryHooks[Key] extends HookMap<infer H> ? Map<string, H[]> : never }} */ ({});
 		for (const key of Object.keys(hooks)) {
 			this._caches[/** @type {keyof StatsFactoryHooks} */ (key)] = new Map();
 		}
+		/** @type {boolean} */
 		this._inCreate = false;
 	}
 
@@ -169,7 +170,7 @@ class StatsFactory {
 	 * Returns hook.
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} HM
 	 * @template {HM extends HookMap<infer H> ? H : never} H
-	 * @template {H extends import("tapable").Hook<EXPECTED_ANY, infer R> ? R : never} R
+	 * @template {H extends import("tapable").Hook<infer A, infer R> ? R : never} R
 	 * @param {HM} hookMap hook map
 	 * @param {Caches<H>} cache cache
 	 * @param {string} type type
@@ -188,12 +189,13 @@ class StatsFactory {
 	 * For each level waterfall.
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} HM
 	 * @template {HM extends HookMap<infer H> ? H : never} H
+	 * @template [D=EXPECTED_ANY]
 	 * @param {HM} hookMap hook map
 	 * @param {Caches<H>} cache cache
 	 * @param {string} type type
-	 * @param {FactoryData} data data
-	 * @param {(hook: H, factoryData: FactoryData) => FactoryData} fn fn
-	 * @returns {FactoryData} data
+	 * @param {D} data data
+	 * @param {(hook: H, data: D) => D} fn fn
+	 * @returns {D} data
 	 * @private
 	 */
 	_forEachLevelWaterfall(hookMap, cache, type, data, fn) {
@@ -207,14 +209,14 @@ class StatsFactory {
 	 * For each level filter.
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} T
 	 * @template {T extends HookMap<infer H> ? H : never} H
-	 * @template {H extends import("tapable").Hook<EXPECTED_ANY, infer R> ? R : never} R
+	 * @template [D=EXPECTED_ANY]
 	 * @param {T} hookMap hook map
 	 * @param {Caches<H>} cache cache
 	 * @param {string} type type
-	 * @param {FactoryData[]} items items
-	 * @param {(hook: H, item: R, idx: number, i: number) => R | undefined} fn fn
+	 * @param {D[]} items items
+	 * @param {(hook: H, item: D, idx: number, i: number) => boolean | void} fn fn
 	 * @param {boolean} forceClone force clone
-	 * @returns {R[]} result for each level
+	 * @returns {D[]} result for each level
 	 * @private
 	 */
 	_forEachLevelFilter(hookMap, cache, type, items, fn, forceClone) {

package/lib/stats/StatsPrinter.js

@@ -73,6 +73,12 @@ const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
  * @property {(message: string) => string=} formatError
  */
 
+/**
+ * Extracts the inner hook type held by a `HookMap`.
+ * @template T
+ * @typedef {T extends HookMap<infer H> ? H : never} HookMapHook
+ */
+
 /** @typedef {KnownStatsPrinterColorFunctions & KnownStatsPrinterFormatters & KnownStatsPrinterContext & Record<string, EXPECTED_ANY>} StatsPrinterContext */
 /** @typedef {StatsPrinterContext & Required<KnownStatsPrinterColorFunctions> & Required<KnownStatsPrinterFormatters> & { type: string }} StatsPrinterContextWithExtra */
 /** @typedef {EXPECTED_ANY} PrintObject */
@@ -107,8 +113,9 @@ class StatsPrinter {
 			print: new HookMap(() => new SyncBailHook(["object", "context"])),
 			result: new HookMap(() => new SyncWaterfallHook(["result", "context"]))
 		});
-		/** @type {Map<StatsPrintHooks[keyof StatsPrintHooks], Map<string, import("tapable").Hook<EXPECTED_ANY, EXPECTED_ANY>[]>>} */
+		/** @type {Map<StatsPrintHooks[keyof StatsPrintHooks], Map<string, HookMapHook<StatsPrintHooks[keyof StatsPrintHooks]>[]>>} */
 		this._levelHookCache = new Map();
+		/** @type {boolean} */
 		this._inPrint = false;
 	}
 
@@ -149,7 +156,7 @@ class StatsPrinter {
 	 * @private
 	 * @template {StatsPrintHooks[keyof StatsPrintHooks]} HM
 	 * @template {HM extends HookMap<infer H> ? H : never} H
-	 * @template {H extends import("tapable").Hook<EXPECTED_ANY, infer R> ? R : never} R
+	 * @template {H extends import("tapable").Hook<infer A, infer R> ? R : never} R
 	 * @param {HM} hookMap hook map
 	 * @param {string} type type
 	 * @param {(hooK: H) => R | undefined | void} fn fn

package/lib/url/URLParserPlugin.js

@@ -15,7 +15,7 @@ const CommentCompilationWarning = require("../errors/CommentCompilationWarning")
 const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
-const InnerGraph = require("../optimize/InnerGraph");
+const { getInnerGraphUtils } = require("../optimize/InnerGraph");
 
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
@@ -189,7 +189,10 @@ class URLParserPlugin {
 				);
 				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.current.addDependency(dep);
-				InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+				getInnerGraphUtils(parser.state.compilation).onUsage(
+					parser.state,
+					(e) => (dep.usedByExports = e)
+				);
 				return true;
 			}
 

package/lib/util/AsyncQueue.js

@@ -38,6 +38,7 @@ class AsyncQueueEntry {
 	 * @param {Callback<R>} callback the callback
 	 */
 	constructor(item, callback) {
+		/** @type {T} */
 		this.item = item;
 		/** @type {typeof QUEUED_STATE | typeof PROCESSING_STATE | typeof DONE_STATE} */
 		this.state = QUEUED_STATE;
@@ -82,10 +83,15 @@ class AsyncQueue {
 	 * @param {Processor<T, R>} options.processor async function to process items
 	 */
 	constructor({ name, context, parallelism, parent, processor, getKey }) {
+		/** @type {string | undefined} */
 		this._name = name;
+		/** @type {string} */
 		this._context = context || "normal";
+		/** @type {number} */
 		this._parallelism = parallelism || 1;
+		/** @type {Processor<T, R>} */
 		this._processor = processor;
+		/** @type {getKey<T, K>} */
 		this._getKey =
 			getKey ||
 			/** @type {getKey<T, K>} */ ((item) => /** @type {T & K} */ (item));
@@ -95,9 +101,13 @@ class AsyncQueue {
 		this._queued = new ArrayQueue();
 		/** @type {AsyncQueue<T, K, R>[] | undefined} */
 		this._children = undefined;
+		/** @type {number} */
 		this._activeTasks = 0;
+		/** @type {boolean} */
 		this._willEnsureProcessing = false;
+		/** @type {boolean} */
 		this._needProcessing = false;
+		/** @type {boolean} */
 		this._stopped = false;
 		/** @type {AsyncQueue<T, K, R>} */
 		this._root = parent ? parent._root : this;

package/lib/util/LazyBucketSortedSet.js

@@ -57,14 +57,19 @@ class LazyBucketSortedSet {
 	 * @param {...Arg<T, K>} args more pairs of getKey and comparator plus optional final comparator for the last layer
 	 */
 	constructor(getKey, comparator, ...args) {
+		/** @type {GetKey<T, K>} */
 		this._getKey = getKey;
+		/** @type {Arg<T, K>[]} */
 		this._innerArgs = args;
+		/** @type {boolean} */
 		this._leaf = args.length <= 1;
+		/** @type {SortableSet<K>} */
 		this._keys = new SortableSet(undefined, comparator);
 		/** @type {Map<K, Entry<T, K>>} */
 		this._map = new Map();
 		/** @type {Set<T>} */
 		this._unsortedItems = new Set();
+		/** @type {number} */
 		this.size = 0;
 	}
 

package/lib/util/LazySet.js

@@ -67,7 +67,9 @@ class LazySet {
 		this._toMerge = new Set();
 		/** @type {LazySet<T>[]} */
 		this._toDeepMerge = [];
+		/** @type {boolean} */
 		this._needMerge = false;
+		/** @type {boolean} */
 		this._deopt = false;
 	}
 
@@ -245,7 +247,7 @@ class LazySet {
 	/**
 	 * Serializes the fully materialized set contents into webpack's object
 	 * serialization stream.
-	 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext} context context
+	 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext<(number | T)[]>} context context
 	 */
 	serialize({ write }) {
 		if (this._needMerge) this._merge();
@@ -256,15 +258,15 @@ class LazySet {
 	/**
 	 * Restores a `LazySet` from serialized item data.
 	 * @template T
-	 * @param {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} context context
+	 * @param {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<(number | T)[]>} context context
 	 * @returns {LazySet<T>} lazy set
 	 */
 	static deserialize({ read }) {
-		const count = read();
+		const count = /** @type {number} */ (read());
 		/** @type {T[]} */
 		const items = [];
 		for (let i = 0; i < count; i++) {
-			items.push(read());
+			items.push(/** @type {T} */ (read()));
 		}
 		return new LazySet(items);
 	}

package/lib/util/LocConverter.js

@@ -11,9 +11,13 @@ class LocConverter {
 	 * @param {string} input input
 	 */
 	constructor(input) {
+		/** @type {string} */
 		this._input = input;
+		/** @type {number} */
 		this.line = 1;
+		/** @type {number} */
 		this.column = 0;
+		/** @type {number} */
 		this.pos = 0;
 	}
 
@@ -37,7 +41,13 @@ class LocConverter {
 					}
 				}
 			} else {
-				let i = this._input.lastIndexOf("\n", this.pos);
+				// 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);
 				while (i >= pos) {
 					this.line--;
 					i = i > 0 ? this._input.lastIndexOf("\n", i - 1) : -1;

package/lib/util/Semaphore.js

@@ -17,6 +17,7 @@ class Semaphore {
 	 * in the Semaphore
 	 */
 	constructor(available) {
+		/** @type {number} */
 		this.available = available;
 		/** @type {(() => void)[]} */
 		this.waiters = [];

package/lib/util/SourceProcessor.js

@@ -0,0 +1,106 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/**
+ * Babel-style visitor map keyed by a numeric node-type discriminator; a bucket
+ * is a function (enter-only) or `{ enter?, exit? }`. `ctx.skipChildren()`
+ * (enter only) stops the walker descending into the node's children.
+ * @typedef {{ skipChildren(): void }} VisitorContext
+ */
+/**
+ * @template TNode
+ * @typedef {(node: TNode, parent: TNode | null, ctx: VisitorContext) => void} VisitorFn
+ */
+/**
+ * @template TNode
+ * @typedef {VisitorFn<TNode> | { enter?: VisitorFn<TNode>, exit?: VisitorFn<TNode> }} VisitorBucket
+ */
+/**
+ * @template TNode
+ * @typedef {{ [nodeType: number]: VisitorBucket<TNode> }} VisitorMap
+ */
+/**
+ * @template TNode
+ * @typedef {{ enter: VisitorFn<TNode>[], exit: VisitorFn<TNode>[] }} CompiledVisitorBucket
+ */
+/**
+ * @template TNode
+ * @typedef {CompiledVisitorBucket<TNode>[]} CompiledVisitorMap a sparse array indexed by node type
+ */
+/**
+ * A language grammar: parse `input` and fire the compiled visitors in source
+ * order (the grammar owns tokenizing, parsing, and walking).
+ * @template TNode
+ * @template TProcessOptions
+ * @typedef {(input: string, visitors: CompiledVisitorMap<TNode>, options: TProcessOptions) => void} Grammar
+ */
+
+/**
+ * Visitor coordinator: owns the visitor registry and drives a language
+ * `grammar` over the source. Language-agnostic — each syntax (CSS, HTML, …)
+ * binds its own grammar and node-type enum. Babel-style usage:
+ *
+ * ```
+ * processor.use({ [NodeType.X]: (node) => {}, [NodeType.Y]: { enter, exit } });
+ * processor.process(source);
+ * ```
+ * @template TNode
+ * @template [TProcessOptions=object]
+ */
+class SourceProcessor {
+	/**
+	 * @param {Grammar<TNode, TProcessOptions>} grammar the grammar to drive over the source
+	 */
+	constructor(grammar) {
+		/** @type {Grammar<TNode, TProcessOptions>} */
+		this._grammar = grammar;
+		/** @type {CompiledVisitorMap<TNode>} */
+		this._visitors = [];
+	}
+
+	/**
+	 * Register a Babel-style visitor map; calls accumulate per node type.
+	 * A bucket is a function (= `{ enter }`) or `{ enter?, exit? }`.
+	 * @param {VisitorMap<TNode>} map visitor map keyed by node type
+	 * @returns {SourceProcessor<TNode, TProcessOptions>} `this`, for chaining
+	 */
+	use(map) {
+		// `map`'s keys are node-type enum members; `Object.keys` stringifies them,
+		// so index the compiled array by the number to match the numeric `node.type`.
+		for (const type of Object.keys(map)) {
+			const key = Number(type);
+			const v = map[key];
+			let bucket = this._visitors[key];
+			if (!bucket) {
+				bucket = { enter: [], exit: [] };
+				this._visitors[key] = bucket;
+			}
+			if (typeof v === "function") {
+				bucket.enter.push(v);
+			} else {
+				if (v.enter) bucket.enter.push(v.enter);
+				if (v.exit) bucket.exit.push(v.exit);
+			}
+		}
+		return this;
+	}
+
+	/**
+	 * Run the grammar over `input`, firing visitors in source order. No
+	 * AST retained.
+	 * @param {string} input source text
+	 * @param {TProcessOptions=} options grammar-specific options
+	 */
+	process(input, options) {
+		this._grammar(
+			input,
+			this._visitors,
+			options || /** @type {TProcessOptions} */ ({})
+		);
+	}
+}
+
+module.exports = SourceProcessor;

package/lib/util/TupleSet.js

@@ -27,6 +27,7 @@ class TupleSet {
 	constructor(init) {
 		/** @type {InnerMap<T, V>} */
 		this._map = new Map();
+		/** @type {number} */
 		this.size = 0;
 		if (init) {
 			for (const tuple of init) {

package/lib/util/WeakTupleMap.js

@@ -45,7 +45,10 @@ class WeakTupleMap {
 	 * Initializes an empty tuple trie node with optional value and child maps.
 	 */
 	constructor() {
-		/** @private */
+		/**
+		 * @private
+		 * @type {number}
+		 */
 		this.f = 0;
 		/**
 		 * @private
@@ -127,6 +130,29 @@ class WeakTupleMap {
 		return newValue;
 	}
 
+	/**
+	 * Memoizes `compute(thisArg, ...args)` under the tuple key `[compute,
+	 * ...args]`, computing it on a miss. Equivalent to `provide(compute, ...args,
+	 * () => 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`
+	 * @param {K} args remaining key elements, also passed to `compute`
+	 * @returns {V} the value
+	 */
+	cachedProvide(compute, thisArg, args) {
+		/** @type {WeakTupleMap<K, V>} */
+		let node = this._get(/** @type {ArrayElement<K>} */ (compute));
+		for (let i = 0; i < args.length; i++) {
+			node = node._get(/** @type {ArrayElement<K>} */ (args[i]));
+		}
+		if (node._hasValue()) return /** @type {V} */ (node._getValue());
+		const newValue = compute(thisArg, ...args);
+		node._setValue(newValue);
+		return newValue;
+	}
+
 	/**
 	 * Removes the value stored for the tuple key without pruning the trie.
 	 * @param {K} args tuple

package/lib/util/chainedImports.js

@@ -71,8 +71,8 @@ module.exports.getTrimmedIdsAndRange = (
  * @returns {string[]} trimmed ids
  */
 function trimIdsToThoseImported(ids, moduleGraph, dependency) {
-	/** @type {string[]} */
-	let trimmedIds = [];
+	/** @type {string[] | undefined} */
+	let trimmedIds;
 	let currentExportsInfo = moduleGraph.getExportsInfo(
 		/** @type {Module} */ (moduleGraph.getModule(dependency))
 	);
@@ -95,5 +95,5 @@ function trimIdsToThoseImported(ids, moduleGraph, dependency) {
 		currentExportsInfo = nestedInfo;
 	}
 	// Never trim to nothing.  This can happen for invalid imports (e.g. import { notThere } from "./module", or import { anything } from "./missingModule")
-	return trimmedIds.length ? trimmedIds : ids;
+	return trimmedIds !== undefined && trimmedIds.length ? trimmedIds : ids;
 }

package/lib/util/comparators.js

@@ -61,13 +61,13 @@ const createCachedParameterizedComparator = (fn) => {
 	return (arg) => {
 		const cachedResult = map.get(arg);
 		if (cachedResult !== undefined) return cachedResult;
+		// arrow closure dispatches faster than a bound function on the sort hot path
 		/**
-		 * Returns compare result.
 		 * @param {T} a first item
 		 * @param {T} b second item
 		 * @returns {-1 | 0 | 1} compare result
 		 */
-		const result = fn.bind(null, arg);
+		const result = (a, b) => fn(arg, a, b);
 		map.set(arg, result);
 		return result;
 	};

package/lib/util/concatenate.js

@@ -68,9 +68,28 @@ const getPathInAst = (ast, node) => {
 	};
 
 	if (Array.isArray(ast)) {
-		for (let i = 0; i < ast.length; i++) {
-			const enterResult = enterNode(ast[i]);
-			if (enterResult !== undefined) return enterResult;
+		// 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 =
@@ -204,7 +223,7 @@ const RESERVED_NAMES = new Set(
 );
 
 /** @typedef {{ usedNames: UsedNames, alreadyCheckedScopes: ScopeSet }} ScopeInfo */
-/** @typedef {Map<string, ScopeInfo>} UsedNamesInScopeInfo */
+/** @typedef {Map<string, Map<string, ScopeInfo>>} UsedNamesInScopeInfo */
 
 /**
  * Gets used names in scope info.
@@ -214,14 +233,19 @@ const RESERVED_NAMES = new Set(
  * @returns {ScopeInfo} info
  */
 const getUsedNamesInScopeInfo = (usedNamesInScopeInfo, module, id) => {
-	const key = `${module}-${id}`;
-	let info = usedNamesInScopeInfo.get(key);
+	// nested maps avoid building a `${module}-${id}` key string per lookup
+	let byId = usedNamesInScopeInfo.get(module);
+	if (byId === undefined) {
+		byId = new Map();
+		usedNamesInScopeInfo.set(module, byId);
+	}
+	let info = byId.get(id);
 	if (info === undefined) {
 		info = {
 			usedNames: new Set(),
 			alreadyCheckedScopes: new Set()
 		};
-		usedNamesInScopeInfo.set(key, info);
+		byId.set(id, info);
 	}
 	return info;
 };

package/lib/util/createHash.js

@@ -35,7 +35,6 @@ module.exports = (algorithm) => {
 		return new BulkUpdateHash(() => new algorithm());
 	}
 	switch (algorithm) {
-		// TODO add non-cryptographic algorithm here
 		case "debug":
 			if (DebugHash === undefined) {
 				DebugHash = require("./hash/DebugHash");