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

package/lib/util/cleverMerge.js

@@ -51,6 +51,7 @@ const cachedCleverMerge = (first, second) => {
 };
 
 /**
+ * Caches d set property.
  * @template T
  * @param {Partial<T>} obj object
  * @param {string} property property
@@ -86,10 +87,12 @@ const cachedSetProperty = (obj, property, value) => {
 };
 
 /**
+ * Defines the by values type used by this module.
  * @typedef {Map<string, EXPECTED_ANY>} ByValues
  */
 
 /**
+ * Defines the object parsed property entry type used by this module.
  * @template T
  * @typedef {object} ObjectParsedPropertyEntry
  * @property {T[keyof T] | undefined} base base value
@@ -100,16 +103,19 @@ const cachedSetProperty = (obj, property, value) => {
 /** @typedef {(function(...EXPECTED_ANY): object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
 
 /**
+ * Defines the parsed object static type used by this module.
  * @template {object} T
  * @typedef {Map<keyof T, ObjectParsedPropertyEntry<T>>} ParsedObjectStatic
  */
 
 /**
+ * Defines the parsed object dynamic type used by this module.
  * @template {object} T
  * @typedef {{ byProperty: `by${string}`, fn: DynamicFunction }} ParsedObjectDynamic
  */
 
 /**
+ * Defines the parsed object type used by this module.
  * @template {object} T
  * @typedef {object} ParsedObject
  * @property {ParsedObjectStatic<T>} static static properties (key is property name)
@@ -120,21 +126,23 @@ const cachedSetProperty = (obj, property, value) => {
 const parseCache = new WeakMap();
 
 /**
+ * Caches d parse object.
  * @template {object} T
  * @param {T} obj the object
  * @returns {ParsedObject<T>} parsed object
  */
 const cachedParseObject = (obj) => {
-	const entry = parseCache.get(/** @type {EXPECTED_OBJECT} */ (obj));
+	const entry = parseCache.get(obj);
 	if (entry !== undefined) return entry;
 	const result = parseObject(obj);
-	parseCache.set(/** @type {EXPECTED_OBJECT} */ (obj), result);
+	parseCache.set(obj, result);
 	return result;
 };
 
 /** @typedef {{ [p: string]: { [p: string]: EXPECTED_ANY } } | DynamicFunction} ByObject */
 
 /**
+ * Returns parsed object.
  * @template {object} T
  * @param {T} obj the object
  * @returns {ParsedObject<T>} parsed object
@@ -145,6 +153,7 @@ const parseObject = (obj) => {
 	/** @type {ParsedObjectDynamic<T> | undefined} */
 	let dynamicInfo;
 	/**
+	 * Returns object parsed property entry.
 	 * @param {keyof T} p path
 	 * @returns {Partial<ObjectParsedPropertyEntry<T>>} object parsed property entry
 	 */
@@ -221,6 +230,7 @@ const parseObject = (obj) => {
 };
 
 /**
+ * Returns the object.
  * @template {object} T
  * @param {ParsedObjectStatic<T>} info static properties (key is property name)
  * @param {{ byProperty: `by${string}`, fn: DynamicFunction } | undefined} dynamicInfo dynamic part
@@ -269,6 +279,7 @@ const VALUE_TYPE_OBJECT = 3;
 const VALUE_TYPE_DELETE = 4;
 
 /**
+ * Returns value type.
  * @template T
  * @param {T} value a single value
  * @returns {VALUE_TYPE_UNDEFINED | VALUE_TYPE_ATOM | VALUE_TYPE_ARRAY_EXTEND | VALUE_TYPE_OBJECT | VALUE_TYPE_DELETE} value type
@@ -311,6 +322,7 @@ const cleverMerge = (first, second) => {
 };
 
 /**
+ * Returns merged object of first and second object.
  * @template {object} T
  * @template {object} O
  * Merges two objects. Objects are deeply clever merged.
@@ -378,6 +390,7 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 };
 
 /**
+ * Merges the provided values into a single result.
  * @template T, O
  * @param {ObjectParsedPropertyEntry<T>} firstEntry a
  * @param {ObjectParsedPropertyEntry<O>} secondEntry b
@@ -510,6 +523,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 };
 
 /**
+ * Gets from by values.
  * @template V
  * @param {ByValues} byValues all values
  * @param {string} key value of the selector
@@ -523,6 +537,7 @@ const getFromByValues = (byValues, key) => {
 };
 
 /**
+ * Merges single value.
  * @template A
  * @template B
  * @param {A | A[]} a value
@@ -585,6 +600,7 @@ const mergeSingleValue = (a, b, internalCaching) => {
 };
 
 /**
+ * Removes operations.
  * @template {object} T
  * @param {T} obj the object
  * @param {(keyof T)[]=} keysToKeepOriginalValue keys to keep original value
@@ -632,6 +648,7 @@ const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 };
 
 /**
+ * Resolves by property.
  * @template T
  * @template {keyof T} P
  * @template V

package/lib/util/comparators.js

@@ -24,50 +24,57 @@ const { compareRuntime } = require("./runtime");
 /** @typedef {import("../dependencies/ModuleDependency")} ModuleDependency */
 
 /**
+ * Defines the dependency source order type used by this module.
  * @typedef {object} DependencySourceOrder
  * @property {number} main the main source order
  * @property {number} sub the sub source order
  */
 
 /**
+ * Defines the comparator type used by this module.
  * @template T
  * @typedef {(a: T, b: T) => -1 | 0 | 1} Comparator
  */
 /**
+ * Defines the raw parameterized comparator type used by this module.
  * @template {object} TArg
  * @template T
  * @typedef {(tArg: TArg, a: T, b: T) => -1 | 0 | 1} RawParameterizedComparator
  */
 /**
+ * Defines the parameterized comparator type used by this module.
  * @template {object} TArg
  * @template T
  * @typedef {(tArg: TArg) => Comparator<T>} ParameterizedComparator
  */
 
 /**
+ * Creates a cached parameterized comparator.
  * @template {object} TArg
  * @template {object} T
  * @param {RawParameterizedComparator<TArg, T>} fn comparator with argument
  * @returns {ParameterizedComparator<TArg, T>} comparator
  */
 const createCachedParameterizedComparator = (fn) => {
-	/** @type {WeakMap<EXPECTED_OBJECT, Comparator<T>>} */
+	/** @type {WeakMap<TArg, Comparator<T>>} */
 	const map = new WeakMap();
 	return (arg) => {
-		const cachedResult = map.get(/** @type {EXPECTED_OBJECT} */ (arg));
+		const cachedResult = map.get(arg);
 		if (cachedResult !== undefined) return cachedResult;
+		// arrow closure dispatches faster than a bound function on the sort hot path
 		/**
 		 * @param {T} a first item
 		 * @param {T} b second item
 		 * @returns {-1 | 0 | 1} compare result
 		 */
-		const result = fn.bind(null, arg);
-		map.set(/** @type {EXPECTED_OBJECT} */ (arg), result);
+		const result = (a, b) => fn(arg, a, b);
+		map.set(arg, result);
 		return result;
 	};
 };
 
 /**
+ * Compares the provided values and returns their ordering.
  * @param {string | number} a first id
  * @param {string | number} b second id
  * @returns {-1 | 0 | 1} compare result
@@ -82,6 +89,7 @@ const compareIds = (a, b) => {
 };
 
 /**
+ * Compares iterables.
  * @template T
  * @param {Comparator<T>} elementComparator comparator for elements
  * @returns {Comparator<Iterable<T>>} comparator for iterables of elements
@@ -90,6 +98,7 @@ const compareIterables = (elementComparator) => {
 	const cacheEntry = compareIteratorsCache.get(elementComparator);
 	if (cacheEntry !== undefined) return cacheEntry;
 	/**
+	 * Returns compare result.
 	 * @param {Iterable<T>} a first value
 	 * @param {Iterable<T>} b second value
 	 * @returns {-1 | 0 | 1} compare result
@@ -177,6 +186,7 @@ const compareLocations = (a, b) => {
 };
 
 /**
+ * Compares modules by id.
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Module} a module
  * @param {Module} b module
@@ -189,6 +199,7 @@ const compareModulesById = (chunkGraph, a, b) =>
 	);
 
 /**
+ * Compares the provided values and returns their ordering.
  * @param {number} a number
  * @param {number} b number
  * @returns {-1 | 0 | 1} compare result
@@ -203,6 +214,7 @@ const compareNumbers = (a, b) => {
 };
 
 /**
+ * Compares strings numeric.
  * @param {string} a string
  * @param {string} b string
  * @returns {-1 | 0 | 1} compare result
@@ -274,6 +286,7 @@ const compareStringsNumeric = (a, b) => {
 };
 
 /**
+ * Compares modules by post order index or identifier.
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} a module
  * @param {Module} b module
@@ -289,6 +302,7 @@ const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 };
 
 /**
+ * Compares modules by pre order index or identifier.
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} a module
  * @param {Module} b module
@@ -304,6 +318,7 @@ const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 };
 
 /**
+ * Compares modules by id or identifier.
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Module} a module
  * @param {Module} b module
@@ -332,6 +347,7 @@ const compareModulesByFullName = (compiler, a, b) => {
 };
 
 /**
+ * Compares the provided values and returns their ordering.
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Chunk} a chunk
  * @param {Chunk} b chunk
@@ -340,6 +356,7 @@ const compareModulesByFullName = (compiler, a, b) => {
 const compareChunks = (chunkGraph, a, b) => chunkGraph.compareChunks(a, b);
 
 /**
+ * Compares the provided values and returns their ordering.
  * @param {string} a first string
  * @param {string} b second string
  * @returns {-1 | 0 | 1} compare result
@@ -351,6 +368,7 @@ const compareStrings = (a, b) => {
 };
 
 /**
+ * Compares chunk groups by index.
  * @param {ChunkGroup} a first chunk group
  * @param {ChunkGroup} b second chunk group
  * @returns {-1 | 0 | 1} compare result
@@ -359,6 +377,7 @@ const compareChunkGroupsByIndex = (a, b) =>
 	/** @type {number} */ (a.index) < /** @type {number} */ (b.index) ? -1 : 1;
 
 /**
+ * Represents TwoKeyWeakMap.
  * @template {EXPECTED_OBJECT} K1
  * @template {EXPECTED_OBJECT} K2
  * @template T
@@ -373,6 +392,7 @@ class TwoKeyWeakMap {
 	}
 
 	/**
+	 * Returns value.
 	 * @param {K1} key1 first key
 	 * @param {K2} key2 second key
 	 * @returns {T | undefined} value
@@ -386,6 +406,7 @@ class TwoKeyWeakMap {
 	}
 
 	/**
+	 * Updates value using the provided key1.
 	 * @param {K1} key1 first key
 	 * @param {K2} key2 second key
 	 * @param {T | undefined} value new value
@@ -405,6 +426,7 @@ class TwoKeyWeakMap {
 const concatComparatorsCache = new TwoKeyWeakMap();
 
 /**
+ * Concat comparators.
  * @template T
  * @param {Comparator<T>} c1 comparator
  * @param {Comparator<T>} c2 comparator
@@ -421,6 +443,7 @@ const concatComparators = (c1, c2, ...cRest) => {
 	);
 	if (cacheEntry !== undefined) return cacheEntry;
 	/**
+	 * Returns compare result.
 	 * @param {T} a first value
 	 * @param {T} b second value
 	 * @returns {-1 | 0 | 1} compare result
@@ -435,6 +458,7 @@ const concatComparators = (c1, c2, ...cRest) => {
 };
 
 /**
+ * Defines the selector type used by this module.
  * @template A, B
  * @typedef {(input: A) => B | undefined | null} Selector
  */
@@ -443,6 +467,7 @@ const concatComparators = (c1, c2, ...cRest) => {
 const compareSelectCache = new TwoKeyWeakMap();
 
 /**
+ * Compares the provided values and returns their ordering.
  * @template T
  * @template R
  * @param {Selector<T, R>} getter getter for value
@@ -453,6 +478,7 @@ const compareSelect = (getter, comparator) => {
 	const cacheEntry = compareSelectCache.get(getter, comparator);
 	if (cacheEntry !== undefined) return cacheEntry;
 	/**
+	 * Returns compare result.
 	 * @param {T} a first value
 	 * @param {T} b second value
 	 * @returns {-1 | 0 | 1} compare result
@@ -481,6 +507,7 @@ const compareIteratorsCache = new WeakMap();
 // TODO this is no longer needed when minimum node.js version is >= 12
 // since these versions ship with a stable sort function
 /**
+ * Keep original order.
  * @template T
  * @param {Iterable<T>} iterable original ordered list
  * @returns {Comparator<T>} comparator
@@ -500,6 +527,7 @@ const keepOriginalOrder = (iterable) => {
 };
 
 /**
+ * Compares chunks natural.
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {Comparator<Chunk>} comparator
  */
@@ -511,6 +539,7 @@ const compareChunksNatural = (chunkGraph) => {
 		compareSelect((chunk) => chunk.runtime, compareRuntime),
 		compareSelect(
 			/**
+			 * Handles the callback logic for this hook.
 			 * @param {Chunk} chunk a chunk
 			 * @returns {Iterable<Module>} modules
 			 */
@@ -591,6 +620,7 @@ module.exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
 module.exports.compareChunks =
 	createCachedParameterizedComparator(compareChunks);
 /**
+ * Returns compare result.
  * @param {Chunk} a chunk
  * @param {Chunk} b chunk
  * @returns {-1 | 0 | 1} compare result
@@ -617,6 +647,7 @@ module.exports.compareModulesById =
 module.exports.compareModulesByIdOrIdentifier =
 	createCachedParameterizedComparator(compareModulesByIdOrIdentifier);
 /**
+ * Returns compare result.
  * @param {Module} a module
  * @param {Module} b module
  * @returns {-1 | 0 | 1} compare result

package/lib/util/compileBooleanMatcher.js

@@ -6,12 +6,14 @@
 "use strict";
 
 /**
+ * Returns quoted meta.
  * @param {string} str string
  * @returns {string} quoted meta
  */
 const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 
 /**
+ * Quote meta in char class.
  * @param {string} char character to escape for use in character class
  * @returns {string} escaped character
  */
@@ -85,6 +87,7 @@ const formatRange = (start, end) => {
 };
 
 /**
+ * Returns string.
  * @param {string} str string
  * @returns {string} string
  */
@@ -96,6 +99,7 @@ const toSimpleString = (str) => {
 };
 
 /**
+ * Compile boolean matcher.
  * @param {Record<string | number, boolean>} map value map
  * @returns {boolean | ((value: string) => string)} true/false, when unconditionally true/false, or a template function to determine the value at runtime
  */
@@ -108,6 +112,7 @@ const compileBooleanMatcher = (map) => {
 };
 
 /**
+ * Compile boolean matcher from lists.
  * @param {string[]} positiveItems positive items
  * @param {string[]} negativeItems negative items
  * @returns {(value: string) => string} a template function to determine the value at runtime
@@ -132,6 +137,7 @@ const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
 /** @typedef {string[][]} ListOfCommonItems */
 
 /**
+ * Returns list of common items.
  * @param {Set<string>} itemsSet items set
  * @param {(str: string) => string | false} getKey get key function
  * @param {(str: string[]) => boolean} condition condition
@@ -166,6 +172,7 @@ const popCommonItems = (itemsSet, getKey, condition) => {
 };
 
 /**
+ * Gets common prefix.
  * @param {string[]} items items
  * @returns {string} common prefix
  */
@@ -184,6 +191,7 @@ const getCommonPrefix = (items) => {
 };
 
 /**
+ * Gets common suffix.
  * @param {string[]} items items
  * @returns {string} common suffix
  */
@@ -202,6 +210,7 @@ const getCommonSuffix = (items) => {
 };
 
 /**
+ * Returns regexp.
  * @param {string[]} itemsArr array of items
  * @returns {string} regexp
  */

package/lib/util/concatenate.js

@@ -7,10 +7,10 @@
 
 const Template = require("../Template");
 
-/** @typedef {import("eslint-scope").Scope} Scope */
-/** @typedef {import("eslint-scope").Reference} Reference */
-/** @typedef {import("eslint-scope").Variable} Variable */
 /** @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 */
 /** @typedef {Set<string>} UsedNames */
 
@@ -18,17 +18,21 @@ const DEFAULT_EXPORT = "__WEBPACK_DEFAULT_EXPORT__";
 const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
 
 /**
+ * Gets all references.
  * @param {Variable} variable variable
  * @returns {Reference[]} references
  */
 const getAllReferences = (variable) => {
 	let set = variable.references;
 	// Look for inner scope variables too (like in class Foo { t() { Foo } })
-	const identifiers = new Set(variable.identifiers);
+	// 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.has(id))) {
-				set = [...set, ...innerVar.references];
+			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;
 			}
 		}
@@ -37,6 +41,7 @@ const getAllReferences = (variable) => {
 };
 
 /**
+ * Returns result.
  * @param {Node | Node[]} ast ast
  * @param {Node} node node
  * @returns {undefined | Node[]} result
@@ -49,6 +54,7 @@ const getPathInAst = (ast, node) => {
 	const nr = /** @type {Range} */ (node.range);
 
 	/**
+	 * Returns result.
 	 * @param {Node} n node
 	 * @returns {Node[] | undefined} result
 	 */
@@ -65,9 +71,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 =
@@ -91,7 +116,34 @@ const getPathInAst = (ast, node) => {
 	}
 };
 
+/** @type {Map<string, string[]>} */
+const splittedInfoCache = new Map();
+
 /**
+ * Returns path segments of the cleaned extra info.
+ * @param {string} extraInfo extra info
+ * @returns {string[]} cleaned path segments
+ */
+const getSplittedInfo = (extraInfo) => {
+	let splittedInfo = splittedInfoCache.get(extraInfo);
+	if (splittedInfo === undefined) {
+		// bound the cache — extraInfo repeats for every renamed binding of a
+		// module, but distinct values grow with project size
+		if (splittedInfoCache.size >= 4096) splittedInfoCache.clear();
+		// Remove uncool stuff
+		splittedInfo = extraInfo
+			.replace(
+				/\.+\/|(?:\/index)?\.[a-zA-Z0-9]{1,4}(?:$|\s|\?)|\s*\+\s*\d+\s*modules/g,
+				""
+			)
+			.split("/");
+		splittedInfoCache.set(extraInfo, splittedInfo);
+	}
+	return splittedInfo;
+};
+
+/**
+ * Returns found new name.
  * @param {string} oldName old name
  * @param {UsedNames} usedNamed1 used named 1
  * @param {UsedNames} usedNamed2 used named 2
@@ -108,15 +160,9 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 		name = "namespaceObject";
 	}
 
-	// Remove uncool stuff
-	extraInfo = extraInfo.replace(
-		/\.+\/|(?:\/index)?\.[a-zA-Z0-9]{1,4}(?:$|\s|\?)|\s*\+\s*\d+\s*modules/g,
-		""
-	);
-
-	const splittedInfo = extraInfo.split("/");
-	while (splittedInfo.length) {
-		name = splittedInfo.pop() + (name ? `_${name}` : "");
+	const splittedInfo = getSplittedInfo(extraInfo);
+	for (let i = splittedInfo.length - 1; i >= 0; i--) {
+		name = splittedInfo[i] + (name ? `_${name}` : "");
 		const nameIdent = Template.toIdentifier(name);
 		if (
 			!usedNamed1.has(nameIdent) &&
@@ -126,15 +172,18 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 		}
 	}
 
+	// `_${i}` is identifier-safe, so escaping the base once is equivalent to
+	// escaping every candidate — avoids two regexes per collision
+	const nameIdent = Template.toIdentifier(name);
 	let i = 0;
-	let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+	let nameWithNumber = `${nameIdent}_${i}`;
 	while (
 		usedNamed1.has(nameWithNumber) ||
 		// eslint-disable-next-line no-unmodified-loop-condition
 		(usedNamed2 && usedNamed2.has(nameWithNumber))
 	) {
 		i++;
-		nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+		nameWithNumber = `${nameIdent}_${i}`;
 	}
 	return nameWithNumber;
 }
@@ -142,6 +191,7 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 /** @typedef {Set<Scope>} ScopeSet */
 
 /**
+ * Adds scope symbols.
  * @param {Scope | null} s scope
  * @param {UsedNames} nameSet name set
  * @param {ScopeSet} scopeSet1 scope set 1
@@ -199,23 +249,29 @@ 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.
  * @param {UsedNamesInScopeInfo} usedNamesInScopeInfo used names in scope info
  * @param {string} module module identifier
  * @param {string} id export id
  * @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;
 };