webpack 5.112.0 → 5.112.2

package/lib/template/RuntimeTemplate.js

@@ -414,11 +414,11 @@ function getGlobalObject(definition) {
 
 	if (
 		// identifier, we do not need real identifier regarding ECMAScript/Unicode
-		/^[_\p{L}][_0-9\p{L}]*$/iu.test(trimmed) ||
+		/^[_\p{L}][_0-9\p{L}]*$/u.test(trimmed) ||
 		// iife
 		// call expression
 		// expression in parentheses
-		/^(?:[_\p{L}][_0-9\p{L}]*)?\(.*\)$/iu.test(trimmed)
+		/^(?:[_\p{L}][_0-9\p{L}]*)?\(.*\)$/u.test(trimmed)
 	) {
 		return trimmed;
 	}
@@ -1386,7 +1386,7 @@ class RuntimeTemplate {
 				const spellable =
 					this._getAnalyzableFileSpecifier(
 						module,
-						/** @type {ChunkGraph} */ (chunkGraph),
+						chunkGraph,
 						[["literal", "x"]],
 						true
 					) !== null;
@@ -2888,7 +2888,7 @@ class RuntimeTemplate {
 	 * @returns {boolean} true when the hash exists by the time the target is hashed
 	 */
 	_hashRoundBefore(chunk, target) {
-		const chunkGraph = /** @type {ChunkGraph} */ (this.compilation.chunkGraph);
+		const chunkGraph = this.compilation.chunkGraph;
 		const round = hashRound(chunk, chunkGraph);
 		const targetRound = hashRound(target, chunkGraph);
 		if (round !== targetRound) return round < targetRound;
@@ -2956,8 +2956,7 @@ class RuntimeTemplate {
 	 */
 	_settlesLate(chunk) {
 		return (
-			/** @type {ChunkGraph} */
-			(this.compilation.chunkGraph).getChunkFullHashModulesIterable(chunk) !==
+			this.compilation.chunkGraph.getChunkFullHashModulesIterable(chunk) !==
 			undefined
 		);
 	}
@@ -2989,7 +2988,7 @@ class RuntimeTemplate {
 	_markChunksSettlingLate() {
 		this._chunksBakingFullHash = new Set();
 		const { compilation } = this;
-		const chunkGraph = /** @type {ChunkGraph} */ (compilation.chunkGraph);
+		const chunkGraph = compilation.chunkGraph;
 		const results = compilation.codeGenerationResults;
 		if (results === undefined) return;
 		/** @type {Map<Chunk, Set<string>>} */
@@ -3234,11 +3233,7 @@ class RuntimeTemplate {
 			const undo =
 				shape === undefined
 					? null
-					: getUndoPath(
-							`${shape}x`,
-							/** @type {string} */ (this.outputOptions.path),
-							true
-						);
+					: getUndoPath(`${shape}x`, this.outputOptions.path, true);
 			this._publicPathClimbText = undo === "./" ? "" : undo;
 		}
 		return this._publicPathClimbText;
@@ -3273,11 +3268,7 @@ class RuntimeTemplate {
 			undo:
 				chunkName === null
 					? null
-					: getUndoPath(
-							chunkName,
-							/** @type {string} */ (outputOptions.path),
-							true
-						),
+					: getUndoPath(chunkName, outputOptions.path, true),
 			// A chunk in an initial group and an async one both is served at two urls,
 			// one public path apart, so no one literal in it is right for both.
 			loaded: chunk.isOnlyInitial() ? false : chunk.canBeInitial() ? null : true
@@ -3338,11 +3329,7 @@ class RuntimeTemplate {
 				: shape,
 			{ chunk, contentHashType: JAVASCRIPT_TYPE }
 		);
-		return getUndoPath(
-			name,
-			/** @type {string} */ (this.outputOptions.path),
-			enforceRelative
-		);
+		return getUndoPath(name, this.outputOptions.path, enforceRelative);
 	}
 
 	/**
@@ -3495,7 +3482,7 @@ class RuntimeTemplate {
 		const filename =
 			deferred && !settled
 				? ""
-				: compilation.getPath(/** @type {string} */ (template), {
+				: compilation.getPath(template, {
 						chunk,
 						// Matches what names the asset, or a placeholder resolved here would
 						// not be the one on disk.
@@ -4113,7 +4100,7 @@ class RuntimeTemplate {
 		}
 		const undo = getUndoPath(
 			this.compilation.getPath(this._hotUpdateShapeText, { chunk }),
-			/** @type {string} */ (outputOptions.path),
+			outputOptions.path,
 			true
 		);
 		this._hotUpdateUndoByChunk.set(chunk, undo);
@@ -4131,9 +4118,7 @@ class RuntimeTemplate {
 	 */
 	getAnalyzableWasmUrl(module, chunkGraph, runtime, runtimeRequirements) {
 		const { compilation } = this;
-		const template = /** @type {string} */ (
-			this.outputOptions.webassemblyModuleFilename
-		);
+		const template = this.outputOptions.webassemblyModuleFilename;
 		// The module's own hash and id are settled here, the compilation's is not — and
 		// a placeholder nothing answers is left in the name, so what comes back is either
 		// the final name or a template carrying only `[fullhash]`.
@@ -4500,11 +4485,7 @@ class RuntimeTemplate {
 							} else if (kind === "literal") {
 								specifier += value;
 							} else if (kind === "undo") {
-								specifier += getUndoPath(
-									assetName,
-									/** @type {string} */ (outputOptions.path),
-									true
-								);
+								specifier += getUndoPath(assetName, outputOptions.path, true);
 							} else if (kind === "template") {
 								specifier += compilation.getPath(
 									/** @type {string} */ (value),

package/lib/template/Template.js

@@ -53,7 +53,7 @@ const LINE_SEPARATOR_REGEX = /\r?\n/g;
 const IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-z$_])/i;
 const IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-z0-9$]+/gi;
 const COMMENT_END_REGEX = /\*\//g;
-const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-z0-9_!§$()=\-^°]+/gi;
+const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g;
 const MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
 
 /**

package/lib/util/SourceProcessor.js

@@ -186,11 +186,11 @@ const declineDeferredWrites = (text, writes) =>
  */
 /**
  * What part `M` gives the node type `R` says it is; every part `D` when `R`
- * says none (a plain node reads `unknown` there).
+ * says none (a plain node reads `number` there).
  * @template R
  * @template {Record<number, number>} M
  * @template D
- * @typedef {number extends (R & { readonly __nodeType: unknown })["__nodeType"] ? D : M[(R & { readonly __nodeType: unknown })["__nodeType"] & number]} PartOf
+ * @typedef {number extends (R & { readonly __nodeType: number })["__nodeType"] ? D : M[(R & { readonly __nodeType: number })["__nodeType"]]} PartOf
  */
 /**
  * A language's parts, by node type: what its `Field`s and `Flag`s apply to.
@@ -281,7 +281,10 @@ const declineDeferredWrites = (text, writes) =>
 const deferredKey = (offer) => {
 	let key = "";
 	for (const name of Object.keys(offer).sort()) {
-		const value = /** @type {Record<string, unknown>} */ (offer)[name];
+		const value =
+			/** @type {Record<string, DeferredWrite[keyof DeferredWrite]>} */ (offer)[
+				name
+			];
 		if (typeof value !== "function") key += `${name}\0${value}\0`;
 	}
 	return key;
@@ -332,7 +335,7 @@ const FLATTEN_BLOCK = 64 * 1024;
 
 // Most prints do not ask for a source map. Sharing their permanently empty
 // mapping column avoids allocating an array for every inline CSS/HTML body.
-/** @type {[number, number, number, number][]} */
+/** @type {number[]} */
 const EMPTY_MAPPINGS = [];
 
 // Base64 VLQ, the source-map `mappings` encoding. Hand-rolled so producing a map
@@ -344,6 +347,28 @@ const _B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  * @returns {string} its Base64 VLQ encoding
  */
 const _vlq = (n) => {
+	// Most deltas are small, and each is spelled the same every time.
+	if (n > -_VLQ_CACHED && n < _VLQ_CACHED) {
+		if (_vlqCache === null) _vlqCache = Array.from({ length: _VLQ_CACHED * 2 });
+		const cached = _vlqCache[n + _VLQ_CACHED];
+		if (cached !== undefined) return cached;
+		return (_vlqCache[n + _VLQ_CACHED] = _encodeVlq(n));
+	}
+	return _encodeVlq(n);
+};
+
+// `_vlq` of every delta within this of zero, filled in as they are written,
+// and made only once a map is.
+const _VLQ_CACHED = 1024;
+/** @type {(string | undefined)[] | null} */
+let _vlqCache = null;
+
+/**
+ * One value as a Base64 VLQ, spelled out.
+ * @param {number} n the value
+ * @returns {string} its VLQ
+ */
+const _encodeVlq = (n) => {
 	let v = n < 0 ? (-n << 1) | 1 : n << 1;
 	let out = "";
 	do {
@@ -402,10 +427,13 @@ class PrintContext {
 		this._printer = printer;
 		// Printed text by node handle, in two columns rather than one `Map`: the
 		// handles are dense integers, and `_moveEpoch` keeps the live set small.
-		/** @type {string[]} each finished node's printed text */
+		/** @type {(string | null)[]} each finished node's printed text */
 		this._storeText = [];
 		/** @type {Int32Array} the epoch each slot was written in */
 		this._storeGen = new Int32Array(0);
+		// A slot holding `null` prints as its source, read only once asked for.
+		/** @type {((node: TNode) => string) | undefined} reads a `null` slot's text */
+		this._sourceText = undefined;
 		/** @type {number} current epoch; a slot from an older one reads as absent */
 		this._gen = 1;
 		/** @type {number} lowest slot written since the epoch last moved */
@@ -417,6 +445,8 @@ class PrintContext {
 		// for retractable text alone, so no other emit pays for that ability.
 		/** @type {string[]} pieces already cut off, in output order */
 		this._chunks = [];
+		/** @type {Map<number, { readonly text: string }> | null} pieces whose text is read only once the output is */
+		this._deferred = null;
 		/** @type {string} output after the last cut piece */
 		this._tail = "";
 		/** @type {number} characters in `_tail`, so its length is not read off a rope */
@@ -428,9 +458,11 @@ class PrintContext {
 		/** @type {boolean} whether {@link sourceMap} can still be asked for one */
 		this.mapWanted =
 			/** @type {{ source?: string }} */ (options).source !== undefined;
-		/** @type {[number, number, number, number][]} `[chunkIndex, offsetInChunk, srcLine, srcCol]`, output-ordered; a `srcLine` of -1 is one {@link retract} took back with its piece */
+		// Flat rather than one array per mapping: a stylesheet anchors every rule,
+		// and those arrays live as long as the print does.
+		/** @type {number[]} `chunkIndex, offsetInChunk, srcLine, srcCol` per mapping, output-ordered; a `srcLine` of -1 is one {@link retract} took back with its piece */
 		this._mappings = this.mapWanted ? [] : EMPTY_MAPPINGS;
-		/** @type {number[] | null} by retractable piece index, the mapping anchored to it, so taking the piece back takes its mapping too */
+		/** @type {number[] | null} by retractable piece index, the index in `_mappings` of the mapping anchored to it, so taking the piece back takes its mapping too */
 		this._retractableMappings = null;
 		/** @type {[number, string][]} source-anchored literals to keep (comments), source-ordered */
 		this._inserts = [];
@@ -593,6 +625,7 @@ class PrintContext {
 	 * @param {number} charCode the character to drop
 	 */
 	dropTrailing(from, charCode) {
+		this._settleDeferred();
 		const chunks = this._chunks;
 		for (let i = chunks.length; i >= from; i--) {
 			let text = i === chunks.length ? this._tail : chunks[i];
@@ -622,6 +655,7 @@ class PrintContext {
 	 * @returns {boolean} true when the output ended that way and was rewritten
 	 */
 	replaceEnd(printed, text, closer) {
+		this._settleDeferred();
 		this._cutTail();
 		const chunks = this._chunks;
 		// Joined once: this runs only where a value ran into the end of the input.
@@ -641,9 +675,14 @@ class PrintContext {
 			remove -= chunks[i].length - kept;
 			chunks[i] = chunks[i].slice(0, kept);
 			// A mapping into what went would point past its piece.
-			this._mappings = this._mappings.filter(
-				([chunk, offset]) => chunk !== i || offset <= kept
-			);
+			const mappings = this._mappings;
+			let to = 0;
+			for (let at = 0; at < mappings.length; at += 4) {
+				if (mappings[at] === i && mappings[at + 1] > kept) continue;
+				for (let k = 0; k < 4; k++) mappings[to + k] = mappings[at + k];
+				to += 4;
+			}
+			mappings.length = to;
 		}
 		this._emit(text);
 		return true;
@@ -656,7 +695,16 @@ class PrintContext {
 	 * @param {TPath} path the language accessor, positioned on `node`
 	 */
 	printNode(node, path) {
-		const text = this._printer(path, this);
+		this.printedAs(node, this._printer(path, this));
+	}
+
+	/**
+	 * Store `text` as what `node` printed, where the grammar already knows what
+	 * the node printer would return and so does not call it.
+	 * @param {TNode} node the finished node
+	 * @param {string} text its printed text
+	 */
+	printedAs(node, text) {
 		const n = /** @type {number} */ (node);
 		if (n >= this._storeText.length) this._growStore(n + 1);
 		this._storeText[n] = text;
@@ -665,6 +713,22 @@ class PrintContext {
 		if (n > this._storeHigh) this._storeHigh = n;
 	}
 
+	/**
+	 * Store that `node` printed as its source, which `sourceText` reads only once
+	 * something asks for its text.
+	 * @param {TNode} node the finished node
+	 * @param {(node: TNode) => string} sourceText reads a node's source
+	 */
+	printedSource(node, sourceText) {
+		const n = /** @type {number} */ (node);
+		if (n >= this._storeText.length) this._growStore(n + 1);
+		this._sourceText = sourceText;
+		this._storeText[n] = null;
+		this._storeGen[n] = this._gen;
+		if (n < this._storeLow) this._storeLow = n;
+		if (n > this._storeHigh) this._storeHigh = n;
+	}
+
 	/**
 	 * Print one node and hand its text straight back — for a node inside one being
 	 * printed in pieces, whose text is emitted as it is printed, so the store
@@ -682,9 +746,16 @@ class PrintContext {
 	 */
 	get(node) {
 		const n = /** @type {number} */ (node);
-		return /** @type {string} */ (
-			this._storeGen[n] === this._gen ? this._storeText[n] : undefined
+		if (this._storeGen[n] !== this._gen) {
+			return /** @type {string} */ (/** @type {unknown} */ (undefined));
+		}
+		const text = this._storeText[n];
+		if (text !== null) return text;
+		const source = /** @type {(node: TNode) => string} */ (this._sourceText)(
+			node
 		);
+		this._storeText[n] = source;
+		return source;
 	}
 
 	/**
@@ -742,10 +813,11 @@ class PrintContext {
 	 * @param {number} index the piece's index, from {@link emitRetractable}
 	 */
 	retract(index) {
+		if (this._deferred !== null) this._deferred.delete(index);
 		this._chunks[index] = "";
 		if (this._retractableMappings === null) return;
 		const mapping = this._retractableMappings[index];
-		if (mapping !== undefined) this._mappings[mapping][2] = -1;
+		if (mapping !== undefined) this._mappings[mapping + 2] = -1;
 	}
 
 	/**
@@ -755,6 +827,7 @@ class PrintContext {
 	 * @returns {boolean} true when it does
 	 */
 	writesNonAscii(index) {
+		this._settleDeferred();
 		const chunks = this._chunks;
 		for (let i = index + 1; i < chunks.length; i++) {
 			if (NON_ASCII_RE.test(chunks[i])) return true;
@@ -776,6 +849,7 @@ class PrintContext {
 	 * @param {string} text what to fold in, its own closer included
 	 */
 	foldIntoRetractable(index, text) {
+		this._settleDeferred();
 		const piece = this._chunks[index];
 		this._chunks[index] = `${piece.slice(0, -1)}${text}`;
 	}
@@ -788,9 +862,31 @@ class PrintContext {
 	 * @param {string} text what the piece says now
 	 */
 	rewriteRetractable(index, text) {
+		if (this._deferred !== null) this._deferred.delete(index);
 		this._chunks[index] = text;
 	}
 
+	/**
+	 * {@link rewriteRetractable} with text that is asked for only once the output
+	 * is read: a piece rewritten many times over is then built once, not each time.
+	 * @param {number} index the piece's index, from {@link emitRetractable}
+	 * @param {{ readonly text: string }} source what holds the piece's text
+	 */
+	deferRetractable(index, source) {
+		if (this._deferred === null) this._deferred = new Map();
+		this._deferred.set(index, source);
+	}
+
+	/**
+	 * Write every deferred piece's text in, before anything reads the pieces.
+	 */
+	_settleDeferred() {
+		const deferred = this._deferred;
+		if (deferred === null) return;
+		this._deferred = null;
+		for (const [index, source] of deferred) this._chunks[index] = source.text;
+	}
+
 	/**
 	 * {@link take} for a top-level node a later sibling may still make dead — the
 	 * unprefixed twin of a vendor-prefixed rule, which can stand anywhere after
@@ -856,12 +952,12 @@ class PrintContext {
 		if (srcLine !== undefined && this.mapWanted) {
 			// `_chunks.length` is where the tail will land once it is cut off, so
 			// this stays right whether or not a piece is cut after it.
-			this._mappings.push([
+			this._mappings.push(
 				this._chunks.length,
 				this._tailLength,
 				srcLine,
 				/** @type {number} */ (srcCol)
-			]);
+			);
 		}
 	}
 
@@ -953,6 +1049,7 @@ class PrintContext {
 	 * @returns {SourceMap} the input->output source map
 	 */
 	sourceMap(options, code) {
+		this._settleDeferred();
 		let out = "";
 		let genLine = 0;
 		let genCol = 0;
@@ -971,7 +1068,12 @@ class PrintContext {
 		// Offset of the next newline at or after the cursor, `-1` for none left.
 		// Carried rather than searched for per mapping: `indexOf` has no end bound.
 		let nextNewline = text.indexOf("\n");
-		for (const [chunkIndex, chunkOffset, sl, sc] of this._mappings) {
+		const mappings = this._mappings;
+		for (let at = 0; at < mappings.length; at += 4) {
+			const chunkIndex = mappings[at];
+			const chunkOffset = mappings[at + 1];
+			const sl = mappings[at + 2];
+			const sc = mappings[at + 3];
 			// Its piece was taken back, so there is no output left to anchor.
 			if (sl === -1) continue;
 			// A piece's length is stored, so summing them costs nothing per byte.
@@ -1024,6 +1126,7 @@ class PrintContext {
 	 * @returns {void}
 	 */
 	substitute(resolve, infix) {
+		this._settleDeferred();
 		const chunks = this._chunks;
 		const mappings = this._mappings;
 		// Both pieces and mappings are output-ordered, so one cursor walks them
@@ -1031,7 +1134,7 @@ class PrintContext {
 		let at = 0;
 		for (let i = 0; i <= chunks.length; i++) {
 			const text = i === chunks.length ? this._tail : chunks[i];
-			while (at < mappings.length && mappings[at][0] < i) at++;
+			while (at < mappings.length && mappings[at] < i) at += 4;
 			let start = text.indexOf(DEFERRED_MARKER);
 			if (start === -1) continue;
 			let out = "";
@@ -1070,9 +1173,9 @@ class PrintContext {
 				chunks[i] = out;
 			}
 			let s = 0;
-			for (let k = at; k < mappings.length && mappings[k][0] === i; k++) {
-				while (s < shifts.length && shifts[s][0] <= mappings[k][1]) s++;
-				if (s !== 0) mappings[k][1] += shifts[s - 1][1];
+			for (let k = at; k < mappings.length && mappings[k] === i; k += 4) {
+				while (s < shifts.length && shifts[s][0] <= mappings[k + 1]) s++;
+				if (s !== 0) mappings[k + 1] += shifts[s - 1][1];
 			}
 		}
 	}
@@ -1086,6 +1189,7 @@ class PrintContext {
 	 * @param {string} text the output to keep instead
 	 */
 	replaceAll(text) {
+		this._deferred = null;
 		this._chunks.length = 0;
 		this._tail = text;
 		this._tailLength = text.length;
@@ -1097,6 +1201,7 @@ class PrintContext {
 	}
 
 	result() {
+		this._settleDeferred();
 		// Trailing kept comments (after the last top-level node) flush here.
 		if (this._insertIdx < this._inserts.length) this._flushBefore(Infinity);
 		// Nothing was ever cut into its own piece, so there is nothing to join.
@@ -1175,8 +1280,8 @@ class SourceProcessor {
 	 * @returns {SourceProcessor<TPath, TNode, TProcessOptions, TPrintOptions, TParts, TState, TVisitors>} `this`, for chaining
 	 */
 	/**
-	 * @param {EXPECTED_ANY} map visitor map, or the node types `bucket` visits
-	 * @param {VisitorBucket<EXPECTED_ANY>=} bucket the visitor, with an array of types
+	 * @param {number[] | TVisitors | VisitorMap<TPath>} map visitor map, or the node types `bucket` visits
+	 * @param {VisitorBucket<TypedNodePath<TPath, TNode, TParts, number, TState>>=} bucket the visitor, with an array of types
 	 * @returns {SourceProcessor<TPath, TNode, TProcessOptions, TPrintOptions, TParts, TState, TVisitors>} `this`, for chaining
 	 */
 	use(map, bucket) {
@@ -1186,14 +1291,23 @@ class SourceProcessor {
 					"SourceProcessor.use(types, bucket): a visitor is required"
 				);
 			}
-			for (let i = 0; i < map.length; i++) this._add(map[i], bucket);
+			for (let i = 0; i < map.length; i++) {
+				this._add(
+					map[i],
+					/** @type {VisitorBucket<TPath>} */ (
+						/** @type {VisitorBucket<TPath> | VisitorBucket<TypedNodePath<TPath, TNode, TParts, number, TState>>} */ (
+							bucket
+						)
+					)
+				);
+			}
 			return this;
 		}
 		// `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)) {
+		for (const type of Object.keys(/** @type {VisitorMap<TPath>} */ (map))) {
 			const key = Number(type);
-			this._add(key, map[key]);
+			this._add(key, /** @type {VisitorMap<TPath>} */ (map)[key]);
 		}
 		return this;
 	}
@@ -1291,9 +1405,9 @@ class SourceProcessor {
 		// along is inert, since a printer reads only what its own type declares.
 		const ctx = new PrintContext(
 			/** @type {PrintOptions & TPrintOptions} */ (
-				/** @type {unknown} */ (opts)
+				/** @type {typeof opts | (PrintOptions & TPrintOptions)} */ (opts)
 			),
-			/** @type {NodePrinter<TPath, TNode, TPrintOptions>} */ (this._printer)
+			this._printer
 		);
 		this._run(input, ctx, opts);
 		const name = /** @type {{ source?: string, content?: string }} */ (opts);
@@ -1343,7 +1457,10 @@ class SourceProcessor {
 		// renderer's answer widened, which `Omit` cannot say and nothing reads.
 		const opts =
 			/** @type {TProcessOptions & { mode: PrintOptions["mode"] }} */
-			(/** @type {unknown} */ (options));
+			(
+				/** @type {typeof options | (TProcessOptions & { mode: PrintOptions["mode"] })} */
+				(options)
+			);
 
 		if (render === undefined) {
 			return /** @type {{ code: string, map: SourceMap | undefined }} */ (

package/lib/util/WeakTupleMap.js

@@ -5,10 +5,16 @@
 
 "use strict";
 
+/**
+ * A value one position of a tuple key may hold: a primitive kept in a `Map`, or
+ * an object (functions included) kept in a `WeakMap`.
+ * @typedef {string | number | bigint | boolean | symbol | EXPECTED_OBJECT | null | undefined} TupleElement
+ */
+
 /**
  * Strong-key child map used for tuple elements that cannot be stored in a
  * `WeakMap`.
- * @template {EXPECTED_ANY[]} T
+ * @template {TupleElement[]} T
  * @template V
  * @typedef {Map<ArrayElement<T>, WeakTupleMap<T, V>>} M
  */
@@ -16,7 +22,7 @@
 /**
  * Weak-key child map used for tuple elements that are objects and can be held
  * without preventing garbage collection.
- * @template {EXPECTED_ANY[]} T
+ * @template {TupleElement[]} T
  * @template V
  * @typedef {WeakMap<ArrayElement<T> & EXPECTED_OBJECT, WeakTupleMap<T, V>>} W
  */
@@ -31,14 +37,14 @@ const isWeakKey = (thing) => typeof thing === "object" && thing !== null;
 
 /**
  * Extracts the element type from a tuple-like array.
- * @template {unknown[]} T
+ * @template T
  * @typedef {T extends ReadonlyArray<infer ElementType> ? ElementType : never} ArrayElement
  */
 
 /**
  * Stores values by tuple keys while using `WeakMap` for object elements so the
  * cache can release entries when those objects are collected.
- * @template {EXPECTED_ANY[]} K
+ * @template {TupleElement[]} K
  * @template V
  */
 class WeakTupleMap {