webpack 5.111.0 → 5.112.0

package/lib/{util → optimize}/TupleQueue.js

@@ -5,28 +5,28 @@
 
 "use strict";
 
-const TupleSet = require("./TupleSet");
+const TupleSet = require("../util/TupleSet");
 
 /**
  * FIFO queue for tuples that preserves uniqueness by delegating membership
  * tracking to `TupleSet`.
- * @template T
+ * @template {EXPECTED_ANY[]} K
  * @template V
  */
 class TupleQueue {
 	/**
 	 * Seeds the queue with an optional iterable of tuples to visit.
-	 * @param {Iterable<[T, V, ...EXPECTED_ANY]>=} items The initial elements.
+	 * @param {Iterable<[...K, V]>=} items The initial elements.
 	 */
 	constructor(items) {
 		/**
 		 * @private
-		 * @type {TupleSet<T, V>}
+		 * @type {TupleSet<K, V>}
 		 */
 		this._set = new TupleSet(items);
 		/**
 		 * @private
-		 * @type {Iterator<[T, V, ...EXPECTED_ANY]>}
+		 * @type {Iterator<[...K, V]>}
 		 */
 		this._iterator = this._set[Symbol.iterator]();
 	}
@@ -41,7 +41,7 @@ class TupleQueue {
 
 	/**
 	 * Enqueues a tuple if it is not already present in the underlying set.
-	 * @param {[T, V, ...EXPECTED_ANY]} item The element to add.
+	 * @param {[...K, V]} item The element to add.
 	 * @returns {void}
 	 */
 	enqueue(...item) {
@@ -51,7 +51,7 @@ class TupleQueue {
 	/**
 	 * Removes and returns the next queued tuple, rebuilding the iterator when
 	 * the underlying tuple set has changed since the last full pass.
-	 * @returns {[T, V, ...EXPECTED_ANY] | undefined} The head of the queue of `undefined` if this queue is empty.
+	 * @returns {[...K, V] | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
 	dequeue() {
 		const result = this._iterator.next();
@@ -59,14 +59,14 @@ class TupleQueue {
 			if (this._set.size > 0) {
 				this._iterator = this._set[Symbol.iterator]();
 				const value =
-					/** @type {[T, V, ...EXPECTED_ANY]} */
+					/** @type {[...K, V]} */
 					(this._iterator.next().value);
 				this._set.delete(...value);
 				return value;
 			}
 			return;
 		}
-		this._set.delete(.../** @type {[T, V, ...EXPECTED_ANY]} */ (result.value));
+		this._set.delete(.../** @type {[...K, V]} */ (result.value));
 		return result.value;
 	}
 }

package/lib/optimize/chunkSetIntersections.js

@@ -0,0 +1,437 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+// Discovers the proper intersections of a family of sets in bounded rounds.
+// Sets and intersections live as dense bit words in one growing buffer, so a
+// round costs word-wise AND and popcount per pair and allocates nothing.
+
+/** A set of members, as bit words at `index * words` in the buffer. */
+/** @typedef {number} SetIndex */
+
+/**
+ * An intersection of at least two of the input sets.
+ * @typedef {object} Intersection
+ * @property {number[]} members the members it holds
+ * @property {number[]} support the input sets holding all of them
+ */
+
+/**
+ * Options of a discovery run.
+ * @typedef {object} DiscoveryOptions
+ * @property {number} setCount number of input sets
+ * @property {number} memberCount number of distinct members
+ * @property {Int32Array} offsets start of each set in `members`, plus its end
+ * @property {Int32Array} members members of every set, ordered by set
+ * @property {number} depth rounds of discovery, `1` intersects the input sets
+ * @property {number} minMembers smallest intersection worth discovering
+ * @property {Float64Array | undefined} sizes size of each input set, when a size bound applies
+ * @property {number} minSize size an intersection's support must reach
+ * @property {number} maxIntersections most intersections a run may discover
+ * @property {number} maxWork most words a run may intersect, one per word of every pair it reaches
+ */
+
+/**
+ * What a discovery run found, and whether a limit cut it short.
+ * @typedef {object} DiscoveryResult
+ * @property {Intersection[]} intersections the intersections, largest first
+ * @property {boolean} capped true when `maxIntersections` or `maxWork` stopped the run
+ */
+
+/** @type {Intersection[]} */
+const NO_INTERSECTIONS = [];
+
+/** Reported when nothing was discovered, so callers skip every later step. */
+const EMPTY_RESULT = { intersections: NO_INTERSECTIONS, capped: false };
+
+/**
+ * Counts the bits of a word.
+ * @param {number} word the word
+ * @returns {number} number of bits set
+ */
+const popcount = (word) => {
+	word -= (word >>> 1) & 0x55555555;
+	word = (word & 0x33333333) + ((word >>> 2) & 0x33333333);
+	word = (word + (word >>> 4)) & 0x0f0f0f0f;
+	return (word * 0x01010101) >>> 24;
+};
+
+/**
+ * An open addressed set of bit patterns. Entries are indices into the buffer
+ * the patterns live in, so nothing is copied and rehashing stays cheap.
+ */
+class BitPatternSet {
+	/**
+	 * @param {number} capacity number of patterns to make room for
+	 */
+	constructor(capacity) {
+		let slots = 16;
+		while (slots < capacity * 2) slots *= 2;
+		/** @type {Int32Array} */
+		this._slots = new Int32Array(slots);
+		this._mask = slots - 1;
+		this._size = 0;
+	}
+
+	/**
+	 * Adds a pattern unless an equal one is already known.
+	 * @param {Uint32Array} words the buffer holding both the pattern and the entries
+	 * @param {number} offset first word of the pattern
+	 * @param {number} length number of words per pattern
+	 * @param {number} entry value to store for the pattern, added to `1`
+	 * @returns {boolean} true when the pattern was added
+	 */
+	add(words, offset, length, entry) {
+		let hash = 0x811c9dc5;
+		for (let i = 0; i < length; i++) {
+			hash = (hash ^ words[offset + i]) >>> 0;
+			hash = (Math.imul(hash, 0x01000193) + (hash >>> 24)) >>> 0;
+		}
+		const slots = this._slots;
+		let slot = hash & this._mask;
+		while (slots[slot] !== 0) {
+			const other = (slots[slot] - 1) * length;
+			let equal = true;
+			for (let i = 0; i < length; i++) {
+				if (words[other + i] !== words[offset + i]) {
+					equal = false;
+					break;
+				}
+			}
+			if (equal) return false;
+			slot = (slot + 1) & this._mask;
+		}
+		slots[slot] = entry + 1;
+		this._size++;
+		if (this._size * 2 > slots.length) this._grow(words, length);
+		return true;
+	}
+
+	/**
+	 * Doubles the table and reinserts every entry.
+	 * @param {Uint32Array} words the buffer holding the patterns
+	 * @param {number} length number of words per pattern
+	 * @returns {void}
+	 */
+	_grow(words, length) {
+		const previous = this._slots;
+		const slots = new Int32Array(previous.length * 2);
+		const mask = slots.length - 1;
+		for (const value of previous) {
+			if (value === 0) continue;
+			const offset = (value - 1) * length;
+			let hash = 0x811c9dc5;
+			for (let i = 0; i < length; i++) {
+				hash = (hash ^ words[offset + i]) >>> 0;
+				hash = (Math.imul(hash, 0x01000193) + (hash >>> 24)) >>> 0;
+			}
+			let slot = hash & mask;
+			while (slots[slot] !== 0) slot = (slot + 1) & mask;
+			slots[slot] = value;
+		}
+		this._slots = slots;
+		this._mask = mask;
+	}
+}
+
+/**
+ * Discovers intersections of the input sets that are not input sets themselves.
+ *
+ * Each round freezes its inputs: the first intersects the input sets, and every
+ * later one also intersects what the round before it found, so `depth` bounds
+ * how deep the discovery goes. Only proper intersections of at least
+ * `minMembers` members are kept, and an intersection is reported only with the
+ * input sets that hold all of its members. When `sizes` is given, the last round
+ * skips a pair sharing a member no set reaches `minSize` through, and an
+ * intersection whose support cannot reach `minSize` is not reported at all.
+ * @param {DiscoveryOptions} options what to discover
+ * @returns {DiscoveryResult} the intersections, largest first
+ */
+const discoverIntersections = ({
+	setCount,
+	memberCount,
+	offsets,
+	members,
+	depth,
+	minMembers,
+	sizes,
+	minSize,
+	maxIntersections,
+	maxWork
+}) => {
+	if (depth < 1 || setCount < 2 || memberCount < minMembers) {
+		return EMPTY_RESULT;
+	}
+	const words = Math.ceil(memberCount / 32);
+	// One size bound per member, and the number of sets holding it. The rarest
+	// member of an intersection drives the support scan below.
+	const memberCounts = new Int32Array(memberCount);
+	const memberSizes =
+		sizes === undefined ? undefined : new Float64Array(memberCount);
+	let totalSize = 0;
+	let capacity = setCount + Math.min(setCount, maxIntersections);
+	let patterns = new Uint32Array(capacity * words);
+	let lengths = new Int32Array(capacity);
+	let count = setCount;
+	for (let set = 0; set < setCount; set++) {
+		const end = offsets[set + 1];
+		const size = sizes === undefined ? 0 : sizes[set];
+		totalSize += size;
+		const offset = set * words;
+		for (let i = offsets[set]; i < end; i++) {
+			const member = members[i];
+			patterns[offset + (member >>> 5)] |= 1 << (member & 31);
+			memberCounts[member]++;
+			if (memberSizes !== undefined) memberSizes[member] += size;
+		}
+		lengths[set] = end - offsets[set];
+	}
+	if (sizes !== undefined && totalSize < minSize) return EMPTY_RESULT;
+	// An intersection holding a member no set reaches `minSize` through cannot
+	// carry a split, so the last round drops the pair rather than the member: a
+	// round before it may still find a descendant that leaves the member behind.
+	const excluded = new Uint32Array(words);
+	let hasExcluded = false;
+	if (memberSizes !== undefined) {
+		for (let member = 0; member < memberCount; member++) {
+			if (memberSizes[member] >= minSize) continue;
+			excluded[member >>> 5] |= 1 << (member & 31);
+			hasExcluded = true;
+		}
+	}
+	const known = new BitPatternSet(setCount * 2);
+	for (let set = 0; set < setCount; set++) {
+		known.add(patterns, set * words, words, set);
+	}
+	const scratch = new Uint32Array(words);
+	let work = maxWork;
+	let capped = false;
+	let first = 0;
+	// Postings of the sets holding each member, rebuilt for every round. A pair
+	// of sets sharing no member intersects to nothing, so the postings of the
+	// sparse sets of a real graph reach far fewer pairs than every pair does.
+	const roundPostingOffsets = new Int32Array(memberCount + 1);
+	/** @type {Int32Array} */
+	let roundPostings = new Int32Array(0);
+
+	/**
+	 * Writes the postings of the sets discovered so far.
+	 * @returns {void}
+	 */
+	const writeRoundPostings = () => {
+		roundPostingOffsets.fill(0);
+		for (let set = 0; set < count; set++) {
+			const offset = set * words;
+			for (let word = 0; word < words; word++) {
+				let value = patterns[offset + word];
+				while (value !== 0) {
+					roundPostingOffsets[
+						word * 32 + (31 - Math.clz32(value & -value)) + 1
+					]++;
+					value &= value - 1;
+				}
+			}
+		}
+		for (let member = 0; member < memberCount; member++) {
+			roundPostingOffsets[member + 1] += roundPostingOffsets[member];
+		}
+		if (roundPostings.length < roundPostingOffsets[memberCount]) {
+			roundPostings = new Int32Array(roundPostingOffsets[memberCount]);
+		}
+		const cursors = roundPostingOffsets.slice(0, memberCount);
+		for (let set = 0; set < count; set++) {
+			const offset = set * words;
+			for (let word = 0; word < words; word++) {
+				let value = patterns[offset + word];
+				while (value !== 0) {
+					const member = word * 32 + (31 - Math.clz32(value & -value));
+					value &= value - 1;
+					roundPostings[cursors[member]++] = set;
+				}
+			}
+		}
+	};
+
+	/**
+	 * Intersects two sets, keeping what they share when it is new.
+	 * @param {number} i one set
+	 * @param {number} j the other set
+	 * @param {boolean} applyExcluded whether to skip a pair sharing an excluded member
+	 * @param {number} atMember the member the pair is being intersected at, or `-1`
+	 * @returns {boolean} false when a limit was reached
+	 */
+	const intersectPair = (i, j, applyExcluded, atMember) => {
+		const iOffset = i * words;
+		const jOffset = j * words;
+		let intersected = 0;
+		let lowest = -1;
+		for (let word = 0; word < words; word++) {
+			const value = patterns[iOffset + word] & patterns[jOffset + word];
+			if (applyExcluded && (value & excluded[word]) !== 0) return true;
+			scratch[word] = value;
+			if (value !== 0) {
+				if (lowest === -1) {
+					lowest = word * 32 + (31 - Math.clz32(value & -value));
+				}
+				intersected += popcount(value);
+			}
+		}
+		// Reached through its lowest member alone, so a pair sharing several
+		// members is intersected once
+		if (atMember !== -1 && lowest !== atMember) return true;
+		// Anything as large as a side is that side, and a set already holding
+		// every member needs no intersection to be found.
+		if (
+			intersected < minMembers ||
+			intersected >= lengths[i] ||
+			intersected >= lengths[j]
+		) {
+			return true;
+		}
+		if (count - setCount >= maxIntersections) {
+			capped = true;
+			return false;
+		}
+		if (count === capacity) {
+			capacity = Math.min(capacity * 2, setCount + maxIntersections);
+			const grownPatterns = new Uint32Array(capacity * words);
+			grownPatterns.set(patterns);
+			patterns = grownPatterns;
+			const grownLengths = new Int32Array(capacity);
+			grownLengths.set(lengths);
+			lengths = grownLengths;
+		}
+		const offset = count * words;
+		patterns.set(scratch, offset);
+		if (!known.add(patterns, offset, words, count)) return true;
+		lengths[count] = intersected;
+		count++;
+		return true;
+	};
+
+	// Every pair costs the same to intersect, so the cheaper way to reach them
+	// is the one reaching fewer.
+	let pairsThroughMembers = 0;
+	for (let member = 0; member < memberCount; member++) {
+		const holders = memberCounts[member];
+		pairsThroughMembers += (holders * (holders - 1)) / 2;
+	}
+	const throughMembers = pairsThroughMembers < (setCount * (setCount - 1)) / 2;
+
+	discovery: for (let round = 0; round < depth; round++) {
+		const end = count;
+		const applyExcluded = hasExcluded && round + 1 === depth;
+		if (throughMembers) {
+			writeRoundPostings();
+			for (let member = 0; member < memberCount; member++) {
+				const to = roundPostingOffsets[member + 1];
+				for (let a = roundPostingOffsets[member]; a < to; a++) {
+					const i = roundPostings[a];
+					if (lengths[i] <= minMembers) continue;
+					for (let b = roundPostingOffsets[member]; b < a; b++) {
+						const j = roundPostings[b];
+						// A pair of sets an earlier round already intersected holds
+						// nothing new
+						if (lengths[j] <= minMembers || (i < first && j < first)) {
+							continue;
+						}
+						work -= words;
+						if (work < 0) {
+							capped = true;
+							break discovery;
+						}
+						if (!intersectPair(i, j, applyExcluded, member)) break discovery;
+					}
+				}
+			}
+		} else {
+			for (let i = first; i < end; i++) {
+				if (lengths[i] <= minMembers) continue;
+				for (let j = 0; j < i; j++) {
+					if (lengths[j] <= minMembers) continue;
+					work -= words;
+					if (work < 0) {
+						capped = true;
+						break discovery;
+					}
+					if (!intersectPair(i, j, applyExcluded, -1)) break discovery;
+				}
+			}
+		}
+		if (count === end) break;
+		first = end;
+	}
+
+	if (count === setCount) return { intersections: NO_INTERSECTIONS, capped };
+	// Postings of the sets holding each member, to scan an intersection's
+	// support from its rarest member instead of every set.
+	const postingOffsets = new Int32Array(memberCount + 1);
+	for (let member = 0; member < memberCount; member++) {
+		postingOffsets[member + 1] = postingOffsets[member] + memberCounts[member];
+	}
+	const postings = new Int32Array(postingOffsets[memberCount]);
+	const cursors = postingOffsets.slice(0, memberCount);
+	for (let set = 0; set < setCount; set++) {
+		const end = offsets[set + 1];
+		for (let i = offsets[set]; i < end; i++) {
+			postings[cursors[members[i]]++] = set;
+		}
+	}
+	/** @type {Intersection[]} */
+	const intersections = [];
+	for (let candidate = setCount; candidate < count; candidate++) {
+		const offset = candidate * words;
+		/** @type {number[]} */
+		const candidateMembers = [];
+		let anchor = -1;
+		for (let word = 0; word < words; word++) {
+			let value = patterns[offset + word];
+			while (value !== 0) {
+				const bit = 31 - Math.clz32(value & -value);
+				const member = word * 32 + bit;
+				value &= value - 1;
+				candidateMembers.push(member);
+				if (anchor === -1 || memberCounts[member] < memberCounts[anchor]) {
+					anchor = member;
+				}
+			}
+		}
+		/** @type {number[]} */
+		const support = [];
+		let size = 0;
+		const postingsEnd = postingOffsets[anchor + 1];
+		for (let i = postingOffsets[anchor]; i < postingsEnd; i++) {
+			const set = postings[i];
+			const setOffset = set * words;
+			let holdsAll = true;
+			for (let word = 0; word < words; word++) {
+				if ((patterns[offset + word] & ~patterns[setOffset + word]) !== 0) {
+					holdsAll = false;
+					break;
+				}
+			}
+			if (!holdsAll) continue;
+			support.push(set);
+			if (sizes !== undefined) size += sizes[set];
+		}
+		if (sizes !== undefined && size < minSize) continue;
+		intersections.push({ members: candidateMembers, support });
+	}
+	// Largest first, as the combinations they extend are ordered, and by members
+	// so that discovery order never reaches the output.
+	intersections.sort((a, b) => {
+		if (a.members.length !== b.members.length) {
+			return b.members.length - a.members.length;
+		}
+		for (let i = 0; i < a.members.length; i++) {
+			if (a.members[i] !== b.members[i]) return a.members[i] - b.members[i];
+		}
+		return 0;
+	});
+	return { intersections, capped };
+};
+
+module.exports.discoverIntersections = discoverIntersections;

package/lib/{util → optimize}/deterministicGrouping.js

@@ -101,7 +101,7 @@ const subtractSizeFrom = (total, size) => {
 /**
  * Returns total size.
  * @template T
- * @param {Node<T>[]} nodes some nodes
+ * @param {GroupNode<T>[]} nodes some nodes
  * @param {number=} start start index
  * @returns {Sizes} total size
  */
@@ -198,9 +198,9 @@ const selectiveSizeSum = (size, types) => {
  * Represents the node runtime component.
  * @template T
  */
-class Node {
+class GroupNode {
 	/**
-	 * Creates an instance of Node.
+	 * Creates an instance of GroupNode.
 	 * @param {T} item item
 	 * @param {string} key key
 	 * @param {Sizes} size size
@@ -224,12 +224,12 @@ class Node {
 class Group {
 	/**
 	 * Creates an instance of Group.
-	 * @param {Node<T>[]} nodes nodes
+	 * @param {GroupNode<T>[]} nodes nodes
 	 * @param {Similarities | null} similarities similarities between the nodes (length = nodes.length - 1)
 	 * @param {Sizes=} size size of the group
 	 */
 	constructor(nodes, similarities, size) {
-		/** @type {Node<T>[]} */
+		/** @type {GroupNode<T>[]} */
 		this.nodes = nodes;
 		/** @type {Similarities | null} */
 		this.similarities = similarities;
@@ -241,17 +241,17 @@ class Group {
 
 	/**
 	 * Returns removed nodes.
-	 * @param {(node: Node<T>) => boolean} filter filter function
-	 * @returns {Node<T>[] | undefined} removed nodes
+	 * @param {(node: GroupNode<T>) => boolean} filter filter function
+	 * @returns {GroupNode<T>[] | undefined} removed nodes
 	 */
 	popNodes(filter) {
-		/** @type {Node<T>[]} */
+		/** @type {GroupNode<T>[]} */
 		const newNodes = [];
 		/** @type {Similarities} */
 		const newSimilarities = [];
-		/** @type {Node<T>[]} */
+		/** @type {GroupNode<T>[]} */
 		const resultNodes = [];
-		/** @type {undefined | Node<T>} */
+		/** @type {undefined | GroupNode<T>} */
 		let lastNode;
 		for (let i = 0; i < this.nodes.length; i++) {
 			const node = this.nodes[i];
@@ -262,7 +262,7 @@ class Group {
 					newSimilarities.push(
 						lastNode === this.nodes[i - 1]
 							? /** @type {Similarities} */ (this.similarities)[i - 1]
-							: similarity(/** @type {Node<T>} */ (lastNode).key, node.key)
+							: similarity(/** @type {GroupNode<T>} */ (lastNode).key, node.key)
 					);
 				}
 				newNodes.push(node);
@@ -280,14 +280,14 @@ class Group {
 /**
  * Returns similarities.
  * @template T
- * @param {Iterable<Node<T>>} nodes nodes
+ * @param {Iterable<GroupNode<T>>} nodes nodes
  * @returns {Similarities} similarities
  */
 const getSimilarities = (nodes) => {
 	// calculate similarities between lexically adjacent nodes
 	/** @type {Similarities} */
 	const similarities = [];
-	/** @type {undefined | Node<T>} */
+	/** @type {undefined | GroupNode<T>} */
 	let last;
 	for (const node of nodes) {
 		if (last !== undefined) {
@@ -330,10 +330,10 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 
 	const nodes = Array.from(
 		items,
-		(item) => new Node(item, getKey(item), getSize(item))
+		(item) => new GroupNode(item, getKey(item), getSize(item))
 	);
 
-	/** @type {Node<T>[]} */
+	/** @type {GroupNode<T>[]} */
 	const initialNodes = [];
 
 	// lexically ordering of keys
@@ -450,12 +450,11 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					right--;
 				}
 
+				// WHY: both sides already clear minSize here.
 				//      left v   v right
 				// [ O O O ] O O O [ O O O ]
 				// ^^^^^^^^^ leftSize
 				//       rightSize ^^^^^^^^^
-				// leftSize > minSize
-				// rightSize > minSize
 
 				// Perfect split: [ O O O ] [ O O O ]
 				//                right === left - 1
@@ -476,26 +475,22 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 						queue.push(group);
 						continue;
 					}
-					// can't split group while holding minSize
-					// because minSize is preferred of maxSize we return
-					// the problematic nodes as result here even while it's too big
-					// To avoid this make sure maxSize > minSize * 3
+					// No split holds minSize, which is preferred over maxSize, so these
+					// nodes are returned oversized. Keeping maxSize > minSize * 3
+					// avoids it.
 					result.push(group);
 					continue;
 				}
 				if (left <= right) {
-					// when there is a area between left and right
-					// we look for best split point
-					// we split at the minimum similarity
-					// here key space is separated the most
-					// But we also need to make sure to not create too small groups
+					// In the area between left and right, split at the minimum
+					// similarity, where the key space is separated the most — without
+					// creating groups that are too small.
 					let best = -1;
 					let bestSimilarity = Infinity;
 					let pos = left;
 					const rightSize = sumSize(group.nodes, pos);
 
-					//       pos v   v right
-					// [ O O O ] O O O [ O O O ]
+					// [ O O O ] O O O [ O O O ]   pos, then right
 					// ^^^^^^^^^ leftSize
 					// rightSize ^^^^^^^^^^^^^^^
 
@@ -528,7 +523,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 
 				// create two new groups for left and right area
 				// and queue them up
-				/** @type {Node<T>[]} */
+				/** @type {GroupNode<T>[]} */
 				const rightNodes = [group.nodes[right + 1]];
 				/** @type {Similarities} */
 				const rightSimilarities = [];
@@ -540,7 +535,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				}
 				queue.push(new Group(rightNodes, rightSimilarities));
 
-				/** @type {Node<T>[]} */
+				/** @type {GroupNode<T>[]} */
 				const leftNodes = [group.nodes[0]];
 				/** @type {Similarities} */
 				const leftSimilarities = [];