webpack 5.59.0 → 5.94.0

package/lib/util/StackedCacheMap.js

@@ -6,6 +6,27 @@
 "use strict";
 
 /**
+ * The StackedCacheMap is a data structure designed as an alternative to a Map
+ * in situations where you need to handle multiple item additions and
+ * frequently access the largest map.
+ *
+ * It is particularly optimized for efficiently adding multiple items
+ * at once, which can be achieved using the `addAll` method.
+ *
+ * It has a fallback Map that is used when the map to be added is mutable.
+ *
+ * Note: `delete` and `has` are not supported for performance reasons.
+ * @example
+ * ```js
+ * const map = new StackedCacheMap();
+ * map.addAll(new Map([["a", 1], ["b", 2]]), true);
+ * map.addAll(new Map([["c", 3], ["d", 4]]), true);
+ * map.get("a"); // 1
+ * map.get("d"); // 4
+ * for (const [key, value] of map) {
+ * 		console.log(key, value);
+ * }
+ * ```
  * @template K
  * @template V
  */
@@ -18,8 +39,11 @@ class StackedCacheMap {
 	}
 
 	/**
+	 * If `immutable` is true, the map can be referenced by the StackedCacheMap
+	 * and should not be changed afterwards. If the map is mutable, all items
+	 * are copied into a fallback Map.
 	 * @param {ReadonlyMap<K, V>} map map to add
-	 * @param {boolean} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
+	 * @param {boolean=} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
 	 */
 	addAll(map, immutable) {
 		if (immutable) {
@@ -68,7 +92,7 @@ class StackedCacheMap {
 
 	/**
 	 * @param {K} item the key of the element to return
-	 * @returns {V} the value of the element
+	 * @returns {V | undefined} the value of the element
 	 */
 	get(item) {
 		for (const map of this.stack) {
@@ -83,6 +107,9 @@ class StackedCacheMap {
 		this.map.clear();
 	}
 
+	/**
+	 * @returns {number} size of the map
+	 */
 	get size() {
 		let size = this.map.size;
 		for (const map of this.stack) {
@@ -91,6 +118,9 @@ class StackedCacheMap {
 		return size;
 	}
 
+	/**
+	 * @returns {Iterator<[K, V]>} iterator
+	 */
 	[Symbol.iterator]() {
 		const iterators = this.stack.map(map => map[Symbol.iterator]());
 		let current = this.map[Symbol.iterator]();
@@ -98,7 +128,7 @@ class StackedCacheMap {
 			next() {
 				let result = current.next();
 				while (result.done && iterators.length > 0) {
-					current = iterators.pop();
+					current = /** @type {IterableIterator<[K, V]>} */ (iterators.pop());
 					result = current.next();
 				}
 				return result;

package/lib/util/StackedMap.js

@@ -29,9 +29,8 @@ const extractPair = pair => {
 	const val = pair[1];
 	if (val === UNDEFINED_MARKER || val === TOMBSTONE) {
 		return [key, undefined];
-	} else {
-		return /** @type {[K, Cell<V>]} */ (pair);
 	}
+	return /** @type {[K, Cell<V>]} */ (pair);
 };
 
 /**
@@ -116,7 +115,6 @@ class StackedMap {
 			}
 			this.map.set(item, TOMBSTONE);
 		}
-		return undefined;
 	}
 
 	_compress() {

package/lib/util/StringXor.js

@@ -5,12 +5,43 @@
 
 "use strict";
 
+/** @typedef {import("../util/Hash")} Hash */
+
+/**
+ * StringXor class provides methods for performing
+ * [XOR operations](https://en.wikipedia.org/wiki/Exclusive_or) on strings. In this context
+ * we operating on the character codes of two strings, which are represented as
+ * [Buffer](https://nodejs.org/api/buffer.html) objects.
+ *
+ * We use [StringXor in webpack](https://github.com/webpack/webpack/commit/41a8e2ea483a544c4ccd3e6217bdfb80daffca39)
+ * to create a hash of the current state of the compilation. By XOR'ing the Module hashes, it
+ * doesn't matter if the Module hashes are sorted or not. This is useful because it allows us to avoid sorting the
+ * Module hashes.
+ * @example
+ * ```js
+ * const xor = new StringXor();
+ * xor.add('hello');
+ * xor.add('world');
+ * console.log(xor.toString());
+ * ```
+ * @example
+ * ```js
+ * const xor = new StringXor();
+ * xor.add('foo');
+ * xor.add('bar');
+ * const hash = createHash('sha256');
+ * hash.update(xor.toString());
+ * console.log(hash.digest('hex'));
+ * ```
+ */
 class StringXor {
 	constructor() {
+		/** @type {Buffer|undefined} */
 		this._value = undefined;
 	}
 
 	/**
+	 * Adds a string to the current StringXor object.
 	 * @param {string} str string
 	 * @returns {void}
 	 */
@@ -18,6 +49,10 @@ class StringXor {
 		const len = str.length;
 		const value = this._value;
 		if (value === undefined) {
+			/**
+			 * We are choosing to use Buffer.allocUnsafe() because it is often faster than Buffer.alloc() because
+			 * it allocates a new buffer of the specified size without initializing the memory.
+			 */
 			const newValue = (this._value = Buffer.allocUnsafe(len));
 			for (let i = 0; i < len; i++) {
 				newValue[i] = str.charCodeAt(i);
@@ -41,11 +76,22 @@ class StringXor {
 		}
 	}
 
+	/**
+	 * Returns a string that represents the current state of the StringXor object. We chose to use "latin1" encoding
+	 * here because "latin1" encoding is a single-byte encoding that can represent all characters in the
+	 * [ISO-8859-1 character set](https://en.wikipedia.org/wiki/ISO/IEC_8859-1). This is useful when working
+	 * with binary data that needs to be represented as a string.
+	 * @returns {string} Returns a string that represents the current state of the StringXor object.
+	 */
 	toString() {
 		const value = this._value;
 		return value === undefined ? "" : value.toString("latin1");
 	}
 
+	/**
+	 * Updates the hash with the current state of the StringXor object.
+	 * @param {Hash} hash Hash instance
+	 */
 	updateHash(hash) {
 		const value = this._value;
 		if (value !== undefined) hash.update(value);

package/lib/util/TupleQueue.js

@@ -15,9 +15,15 @@ class TupleQueue {
 	 * @param {Iterable<T>=} items The initial elements.
 	 */
 	constructor(items) {
-		/** @private @type {TupleSet<T>} */
+		/**
+		 * @private
+		 * @type {TupleSet<T>}
+		 */
 		this._set = new TupleSet(items);
-		/** @private @type {Iterator<T>} */
+		/**
+		 * @private
+		 * @type {Iterator<T>}
+		 */
 		this._iterator = this._set[Symbol.iterator]();
 	}
 
@@ -51,7 +57,7 @@ class TupleQueue {
 				this._set.delete(...value);
 				return value;
 			}
-			return undefined;
+			return;
 		}
 		this._set.delete(...result.value);
 		return result.value;

package/lib/util/TupleSet.js

@@ -9,7 +9,11 @@
  * @template {any[]} T
  */
 class TupleSet {
+	/**
+	 * @param {Iterable<T>=} init init
+	 */
 	constructor(init) {
+		/** @type {Map<T, TODO>} */
 		this._map = new Map();
 		this.size = 0;
 		if (init) {
@@ -62,7 +66,7 @@ class TupleSet {
 		}
 
 		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
+		const set = map.get(beforeLast);
 		if (set === undefined) {
 			return false;
 		}
@@ -86,7 +90,7 @@ class TupleSet {
 		}
 
 		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
+		const set = map.get(beforeLast);
 		if (set === undefined) {
 			return;
 		}
@@ -101,10 +105,17 @@ class TupleSet {
 	 * @returns {Iterator<T>} iterator
 	 */
 	[Symbol.iterator]() {
+		/** @type {TODO[]} */
 		const iteratorStack = [];
+		/** @type {T[]} */
 		const tuple = [];
-		let currentSetIterator = undefined;
+		/** @type {Iterator<T> | undefined} */
+		let currentSetIterator;
 
+		/**
+		 * @param {TODO} it iterator
+		 * @returns {boolean} result
+		 */
 		const next = it => {
 			const result = it.next();
 			if (result.done) {
@@ -118,9 +129,8 @@ class TupleSet {
 			if (value instanceof Set) {
 				currentSetIterator = value[Symbol.iterator]();
 				return true;
-			} else {
-				return next(value[Symbol.iterator]());
 			}
+			return next(value[Symbol.iterator]());
 		};
 
 		next(this._map[Symbol.iterator]());

package/lib/util/URLAbsoluteSpecifier.js

@@ -36,7 +36,7 @@ function getScheme(specifier) {
 		(start < aLowerCaseCharCode || start > zLowerCaseCharCode) &&
 		(start < aUpperCaseCharCode || start > zUpperCaseCharCode)
 	) {
-		return undefined;
+		return;
 	}
 
 	let i = 1;
@@ -49,12 +49,12 @@ function getScheme(specifier) {
 		ch === plusCharCode ||
 		ch === hyphenCharCode
 	) {
-		if (++i === specifier.length) return undefined;
+		if (++i === specifier.length) return;
 		ch = specifier.charCodeAt(i);
 	}
 
 	// Scheme must end with colon
-	if (ch !== colonCharCode) return undefined;
+	if (ch !== colonCharCode) return;
 
 	// Check for Windows absolute path
 	// https://url.spec.whatwg.org/#url-miscellaneous
@@ -67,7 +67,7 @@ function getScheme(specifier) {
 			nextChar === hashCharCode ||
 			nextChar === queryCharCode
 		) {
-			return undefined;
+			return;
 		}
 	}
 
@@ -76,12 +76,12 @@ function getScheme(specifier) {
 
 /**
  * @param {string} specifier specifier
- * @returns {string|null} protocol if absolute URL specifier provided
+ * @returns {string | null | undefined} protocol if absolute URL specifier provided
  */
 function getProtocol(specifier) {
 	const scheme = getScheme(specifier);
-	return scheme === undefined ? undefined : scheme + ":";
+	return scheme === undefined ? undefined : `${scheme}:`;
 }
 
-exports.getScheme = getScheme;
-exports.getProtocol = getProtocol;
+module.exports.getScheme = getScheme;
+module.exports.getProtocol = getProtocol;

package/lib/util/WeakTupleMap.js

@@ -5,6 +5,21 @@
 
 "use strict";
 
+/**
+ * @template {any[]} T
+ * @template V
+ * @typedef {Map<object, WeakTupleMap<T, V>>} M
+ */
+/**
+ * @template {any[]} T
+ * @template V
+ * @typedef {WeakMap<object, WeakTupleMap<T, V>>} W
+ */
+
+/**
+ * @param {any} thing thing
+ * @returns {boolean} true if is weak
+ */
 const isWeakKey = thing => typeof thing === "object" && thing !== null;
 
 /**
@@ -15,11 +30,20 @@ class WeakTupleMap {
 	constructor() {
 		/** @private */
 		this.f = 0;
-		/** @private @type {any} */
+		/**
+		 * @private
+		 * @type {any}
+		 */
 		this.v = undefined;
-		/** @private @type {Map<object, WeakTupleMap<T, V>> | undefined} */
+		/**
+		 * @private
+		 * @type {M<T, V> | undefined}
+		 */
 		this.m = undefined;
-		/** @private @type {WeakMap<object, WeakTupleMap<T, V>> | undefined} */
+		/**
+		 * @private
+		 * @type {W<T, V> | undefined}
+		 */
 		this.w = undefined;
 	}
 
@@ -41,7 +65,7 @@ class WeakTupleMap {
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
 	has(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<T, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
 			node = node._peek(args[i]);
@@ -52,14 +76,14 @@ class WeakTupleMap {
 
 	/**
 	 * @param {T} args tuple
-	 * @returns {V} the value
+	 * @returns {V | undefined} the value
 	 */
 	get(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<T, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
 			node = node._peek(args[i]);
-			if (node === undefined) return undefined;
+			if (node === undefined) return;
 		}
 		return node._getValue();
 	}
@@ -86,7 +110,7 @@ class WeakTupleMap {
 	 * @returns {void}
 	 */
 	delete(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<T, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
 			node = node._peek(args[i]);
@@ -113,6 +137,10 @@ class WeakTupleMap {
 		return (this.f & 1) === 1;
 	}
 
+	/**
+	 * @param {any} v value
+	 * @private
+	 */
 	_setValue(v) {
 		this.f |= 1;
 		this.v = v;
@@ -123,16 +151,25 @@ class WeakTupleMap {
 		this.v = undefined;
 	}
 
+	/**
+	 * @param {any} thing thing
+	 * @returns {WeakTupleMap<T, V> | undefined} thing
+	 * @private
+	 */
 	_peek(thing) {
 		if (isWeakKey(thing)) {
-			if ((this.f & 4) !== 4) return undefined;
-			return this.w.get(thing);
-		} else {
-			if ((this.f & 2) !== 2) return undefined;
-			return this.m.get(thing);
+			if ((this.f & 4) !== 4) return;
+			return /** @type {W<T, V>} */ (this.w).get(thing);
 		}
+		if ((this.f & 2) !== 2) return;
+		return /** @type {M<T, V>} */ (this.m).get(thing);
 	}
 
+	/**
+	 * @private
+	 * @param {any} thing thing
+	 * @returns {WeakTupleMap<T, V>} value
+	 */
 	_get(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) {
@@ -142,29 +179,34 @@ class WeakTupleMap {
 				(this.w = newMap).set(thing, newNode);
 				return newNode;
 			}
-			const entry = this.w.get(thing);
+			const entry =
+				/** @type {W<T, V>} */
+				(this.w).get(thing);
 			if (entry !== undefined) {
 				return entry;
 			}
 			const newNode = new WeakTupleMap();
-			this.w.set(thing, newNode);
+			/** @type {W<T, V>} */
+			(this.w).set(thing, newNode);
 			return newNode;
-		} else {
-			if ((this.f & 2) !== 2) {
-				const newMap = new Map();
-				this.f |= 2;
-				const newNode = new WeakTupleMap();
-				(this.m = newMap).set(thing, newNode);
-				return newNode;
-			}
-			const entry = this.m.get(thing);
-			if (entry !== undefined) {
-				return entry;
-			}
+		}
+		if ((this.f & 2) !== 2) {
+			const newMap = new Map();
+			this.f |= 2;
 			const newNode = new WeakTupleMap();
-			this.m.set(thing, newNode);
+			(this.m = newMap).set(thing, newNode);
 			return newNode;
 		}
+		const entry =
+			/** @type {M<T, V>} */
+			(this.m).get(thing);
+		if (entry !== undefined) {
+			return entry;
+		}
+		const newNode = new WeakTupleMap();
+		/** @type {M<T, V>} */
+		(this.m).set(thing, newNode);
+		return newNode;
 	}
 }
 

package/lib/util/binarySearchBounds.js

@@ -8,6 +8,27 @@
 /* cspell:disable-next-line */
 // Refactor: Peter Somogyvari @petermetz
 
+/** @typedef {">=" | "<=" | "<" | ">" | "-" } BinarySearchPredicate */
+/** @typedef {"GE" | "GT" | "LT" | "LE" | "EQ" } SearchPredicateSuffix */
+
+/**
+ * Helper function for compiling binary search functions.
+ *
+ * The generated code uses a while loop to repeatedly divide the search interval
+ * in half until the desired element is found, or the search interval is empty.
+ *
+ * The following is an example of a generated function for calling `compileSearch("P", "c(x,y)<=0", true, ["y", "c"], false)`:
+ *
+ * ```js
+ * function P(a,l,h,y,c){var i=l-1;while(l<=h){var m=(l+h)>>>1,x=a[m];if(c(x,y)<=0){i=m;l=m+1}else{h=m-1}}return i};
+ * ```
+ * @param {string} funcName The name of the function to be compiled.
+ * @param {string} predicate The predicate / comparison operator to be used in the binary search.
+ * @param {boolean} reversed Whether the search should be reversed.
+ * @param {string[]} extraArgs Extra arguments to be passed to the function.
+ * @param {boolean=} earlyOut Whether the search should return as soon as a match is found.
+ * @returns {string} The compiled binary search function.
+ */
 const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
 	const code = [
 		"function ",
@@ -21,7 +42,7 @@ const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
 	];
 
 	if (earlyOut) {
-		if (predicate.indexOf("c") < 0) {
+		if (!predicate.includes("c")) {
 			code.push(";if(x===y){return m}else if(x<=y){");
 		} else {
 			code.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){");
@@ -43,18 +64,23 @@ const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
 	return code.join("");
 };
 
+/**
+ * This helper functions generate code for two binary search functions:
+ * A(): Performs a binary search on an array using the comparison operator specified.
+ * P(): Performs a binary search on an array using a _custom comparison function_
+ * `c(x,y)` **and** comparison operator specified by `predicate`.
+ * @param {BinarySearchPredicate} predicate The predicate / comparison operator to be used in the binary search.
+ * @param {boolean} reversed Whether the search should be reversed.
+ * @param {SearchPredicateSuffix} suffix The suffix to be used in the function name.
+ * @param {boolean=} earlyOut Whether the search should return as soon as a match is found.
+ * @returns {Function} The compiled binary search function.
+ */
 const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
-	const arg1 = compileSearch(
-		"A",
-		"x" + predicate + "y",
-		reversed,
-		["y"],
-		earlyOut
-	);
+	const arg1 = compileSearch("A", `x${predicate}y`, reversed, ["y"], earlyOut);
 
 	const arg2 = compileSearch(
 		"P",
-		"c(x,y)" + predicate + "0",
+		`c(x,y)${predicate}0`,
 		reversed,
 		["y", "c"],
 		earlyOut
@@ -63,6 +89,7 @@ const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
 	const fnHeader = "function dispatchBinarySearch";
 
 	const fnBody =
+		// eslint-disable-next-line no-multi-str
 		"(a,y,c,l,h){\
 if(typeof(c)==='function'){\
 return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)\
@@ -73,10 +100,25 @@ return dispatchBinarySearch";
 
 	const fnArgList = [arg1, arg2, fnHeader, suffix, fnBody, suffix];
 	const fnSource = fnArgList.join("");
+	// eslint-disable-next-line no-new-func
 	const result = new Function(fnSource);
 	return result();
 };
 
+/**
+ * These functions are used to perform binary searches on arrays.
+ * @example
+ * ```js
+ * const { gt, le} = require("./binarySearchBounds");
+ * const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+ *
+ * // Find the index of the first element greater than 5
+ * const index1 = gt(arr, 5); // index1 === 3
+ *
+ * // Find the index of the first element less than or equal to 5
+ * const index2 = le(arr, 5); // index2 === 4
+ * ```
+ */
 module.exports = {
 	ge: compileBoundsSearch(">=", false, "GE"),
 	gt: compileBoundsSearch(">", false, "GT"),

package/lib/util/chainedImports.js

@@ -0,0 +1,97 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+/**
+ * @summary Get the subset of ids and their corresponding range in an id chain that should be re-rendered by webpack.
+ * Only those in the chain that are actually referring to namespaces or imports should be re-rendered.
+ * Deeper member accessors on the imported object should not be re-rendered.  If deeper member accessors are re-rendered,
+ * there is a potential loss of meaning with rendering a quoted accessor as an unquoted accessor, or vice versa,
+ * because minifiers treat quoted accessors differently.  e.g. import { a } from "./module"; a["b"] vs a.b
+ * @param {string[]} untrimmedIds chained ids
+ * @param {Range} untrimmedRange range encompassing allIds
+ * @param {Range[] | undefined} ranges cumulative range of ids for each of allIds
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {Dependency} dependency dependency
+ * @returns {{trimmedIds: string[], trimmedRange: Range}} computed trimmed ids and cumulative range of those ids
+ */
+module.exports.getTrimmedIdsAndRange = (
+	untrimmedIds,
+	untrimmedRange,
+	ranges,
+	moduleGraph,
+	dependency
+) => {
+	let trimmedIds = trimIdsToThoseImported(
+		untrimmedIds,
+		moduleGraph,
+		dependency
+	);
+	let trimmedRange = untrimmedRange;
+	if (trimmedIds.length !== untrimmedIds.length) {
+		// The array returned from dep.idRanges is right-aligned with the array returned from dep.names.
+		// Meaning, the two arrays may not always have the same number of elements, but the last element of
+		// dep.idRanges corresponds to [the expression fragment to the left of] the last element of dep.names.
+		// Use this to find the correct replacement range based on the number of ids that were trimmed.
+		const idx =
+			ranges === undefined
+				? -1 /* trigger failure case below */
+				: ranges.length + (trimmedIds.length - untrimmedIds.length);
+		if (idx < 0 || idx >= /** @type {Range[]} */ (ranges).length) {
+			// cspell:ignore minifiers
+			// Should not happen but we can't throw an error here because of backward compatibility with
+			// external plugins in wp5.  Instead, we just disable trimming for now.  This may break some minifiers.
+			trimmedIds = untrimmedIds;
+			// TODO webpack 6 remove the "trimmedIds = ids" above and uncomment the following line instead.
+			// throw new Error("Missing range starts data for id replacement trimming.");
+		} else {
+			trimmedRange = /** @type {Range[]} */ (ranges)[idx];
+		}
+	}
+
+	return { trimmedIds, trimmedRange };
+};
+
+/**
+ * @summary Determine which IDs in the id chain are actually referring to namespaces or imports,
+ * and which are deeper member accessors on the imported object.
+ * @param {string[]} ids untrimmed ids
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {Dependency} dependency dependency
+ * @returns {string[]} trimmed ids
+ */
+function trimIdsToThoseImported(ids, moduleGraph, dependency) {
+	/** @type {string[]} */
+	let trimmedIds = [];
+	let currentExportsInfo = moduleGraph.getExportsInfo(
+		/** @type {Module} */ (moduleGraph.getModule(dependency))
+	);
+	for (let i = 0; i < ids.length; i++) {
+		if (i === 0 && ids[i] === "default") {
+			continue; // ExportInfo for the next level under default is still at the root ExportsInfo, so don't advance currentExportsInfo
+		}
+		const exportInfo = currentExportsInfo.getExportInfo(ids[i]);
+		if (exportInfo.provided === false) {
+			// json imports have nested ExportInfo for elements that things that are not actually exported, so check .provided
+			trimmedIds = ids.slice(0, i);
+			break;
+		}
+		const nestedInfo = exportInfo.getNestedExportsInfo();
+		if (!nestedInfo) {
+			// once all nested exports are traversed, the next item is the actual import so stop there
+			trimmedIds = ids.slice(0, i + 1);
+			break;
+		}
+		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;
+}