nhb-toolbox 4.11.6 → 4.11.7-alpha.2

package/dist/cjs/array/Finder.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Finder = void 0;
+/**
+ * The `Finder` class performs optimized searching on arrays.
+ * It supports binary search, fuzzy search, and smart caching with TTL.
+ */
+class Finder {
+    static #DEFAULT_TTL = 1000 * 60 * 5;
+    #cachedResult = new Map();
+    #sortedCache = new Map();
+    #ttl;
+    #items;
+    /**
+     * * Creates a new `Finder` instance.
+     *
+     * @param data The initial array of items or a callback returning them.
+     * @param ttl Time-to-live (in milliseconds) for cached search results. Defaults to {@link Finder.#DEFAULT_TTL 5 Minutes}.
+     */
+    constructor(data, ttl = Finder.#DEFAULT_TTL) {
+        this.#ttl = ttl;
+        this.#items = typeof data === 'function' ? data() : data;
+    }
+    /**
+     * @instance Clears cache globally or for a specific key.
+     * @param key Optional key to clear only a specific cache entry.
+     */
+    clearCache(key) {
+        if (key) {
+            this.#cachedResult.delete(key);
+        }
+        else {
+            this.#cachedResult.clear();
+        }
+    }
+    /**
+     * @instance Finds all items that match the provided matcher using optional caching or fuzzy logic.
+     * @param matcher The value to match against.
+     * @param keySelector Property key or selector function.
+     * @param options Optional settings for search behavior and source list.
+     */
+    findAll(matcher, keySelector, options) {
+        const { fuzzy = false, needSorting = true, cacheKey = 'finder-cache', forceBinary = false, caseInsensitive = true, data, } = options ?? {};
+        const source = typeof data === 'function' ? data() : (data ?? this.#items);
+        if (!source?.length)
+            return [];
+        const rawGetKey = typeof keySelector === 'function' ? keySelector : ((item) => item[keySelector]);
+        const getKey = Finder.#createMemoizedKeyGetter(rawGetKey);
+        const normalizedMatcher = caseInsensitive && typeof matcher === 'string' ?
+            matcher.toLowerCase()
+            : matcher;
+        if (cacheKey) {
+            const entry = this.#cachedResult.get(cacheKey);
+            if (entry && Date.now() - entry.timestamp < this.#ttl) {
+                return entry.result;
+            }
+            else {
+                this.#cachedResult.delete(cacheKey);
+            }
+        }
+        let results = [];
+        if (source.length < 100 && !forceBinary) {
+            results = source.filter((item) => {
+                const key = getKey(item);
+                const value = caseInsensitive && typeof key === 'string' ?
+                    key.toLowerCase()
+                    : key;
+                return value === normalizedMatcher;
+            });
+        }
+        else {
+            const sorted = needSorting ?
+                this.#sortAndCache(source, getKey, cacheKey)
+                : source;
+            const firstMatch = this.binarySearch(sorted, normalizedMatcher, getKey, caseInsensitive);
+            if (firstMatch) {
+                const baseKey = getKey(firstMatch);
+                const base = caseInsensitive && typeof baseKey === 'string' ?
+                    baseKey.toLowerCase()
+                    : baseKey;
+                results = sorted.filter((item) => {
+                    const key = getKey(item);
+                    const value = caseInsensitive && typeof key === 'string' ?
+                        key.toLowerCase()
+                        : key;
+                    return value === base;
+                });
+            }
+        }
+        if (!results.length && fuzzy && typeof normalizedMatcher === 'string') {
+            results = source.filter((item) => {
+                const rawKey = getKey(item);
+                const key = caseInsensitive && typeof rawKey === 'string' ?
+                    rawKey.toLowerCase()
+                    : String(rawKey);
+                return this.#match(key, normalizedMatcher);
+            });
+        }
+        if (cacheKey) {
+            this.#cachedResult.set(cacheKey, {
+                result: results,
+                timestamp: Date.now(),
+            });
+        }
+        return results;
+    }
+    /**
+     * @instance Finds first matching item that matches the provided matcher using optional caching or fuzzy logic.
+     * @param matcher The value to match.
+     * @param keySelector Property key or selector function.
+     * @param options Optional behavior flags and item source.
+     */
+    findOne(matcher, keySelector, options) {
+        const { fuzzy = false, needSorting = true, cacheKey = 'finder-cache', forceBinary = false, caseInsensitive = true, data, } = options ?? {};
+        const source = typeof data === 'function' ? data() : (data ?? this.#items);
+        if (!source?.length)
+            return undefined;
+        const rawGetKey = typeof keySelector === 'function' ? keySelector : ((item) => item[keySelector]);
+        const getKey = Finder.#createMemoizedKeyGetter(rawGetKey);
+        const normalizedMatcher = caseInsensitive && typeof matcher === 'string' ?
+            matcher.toLowerCase()
+            : matcher;
+        if (cacheKey) {
+            const entry = this.#cachedResult.get(cacheKey);
+            if (entry && Date.now() - entry.timestamp < this.#ttl) {
+                return entry.result[0];
+            }
+            else {
+                this.#cachedResult.delete(cacheKey);
+            }
+        }
+        let result;
+        if (source?.length < 100 && !forceBinary) {
+            result = source?.find((item) => {
+                const key = getKey(item);
+                const value = caseInsensitive && typeof key === 'string' ?
+                    key.toLowerCase()
+                    : key;
+                return value === normalizedMatcher;
+            });
+        }
+        else {
+            result = this.binarySearch(needSorting ?
+                this.#sortAndCache(source, getKey, cacheKey)
+                : source, normalizedMatcher, getKey, caseInsensitive);
+        }
+        if (!result && fuzzy && typeof normalizedMatcher === 'string') {
+            return this.fuzzySearch(source, normalizedMatcher, getKey, caseInsensitive);
+        }
+        if (cacheKey && result) {
+            this.#cachedResult.set(cacheKey, {
+                result: [result],
+                timestamp: Date.now(),
+            });
+        }
+        return result;
+    }
+    /**
+     * @instance Asynchronous variant of `findAll` that accepts a promise-based data supplier.
+     * @param supplier Async function resolving the items list.
+     * @param matcher The value to match.
+     * @param keySelector Property key or selector function.
+     * @param options Optional settings for search behavior and cache.
+     */
+    async findAllAsync(supplier, matcher, keySelector, options) {
+        const items = await supplier();
+        return this.findAll(matcher, keySelector, { ...options, data: items });
+    }
+    /**
+     * @instance Asynchronous variant of `findOne`.
+     * @param supplier Async function resolving the items list.
+     * @param matcher The value to match.
+     * @param keySelector Property key or selector function.
+     * @param options Optional settings for behavior and cache.
+     */
+    async findOneAsync(supplier, matcher, keySelector, options) {
+        const items = await supplier();
+        return this.findOne(matcher, keySelector, { ...options, data: items });
+    }
+    /**
+     * @instance Performs a binary search on a sorted array using a custom key selector.
+     *
+     * @param sorted - The sorted array of items to search.
+     * @param matcher - The value to search for.
+     * @param keySelector - A function that extracts the comparable key from each item.
+     * @param caseInsensitive - Whether to compare string keys ignoring case.
+     * @returns The first matching item if found; otherwise, undefined.
+     */
+    binarySearch(sorted, matcher, keySelector, caseInsensitive) {
+        let min = 0, max = sorted?.length - 1;
+        while (min <= max) {
+            const mid = Math.floor((min + max) / 2);
+            const midKey = keySelector(sorted[mid]);
+            const key = caseInsensitive && typeof midKey === 'string' ?
+                midKey.toLowerCase()
+                : midKey;
+            if (key === matcher)
+                return sorted[mid];
+            if (key < matcher)
+                min = mid + 1;
+            else
+                max = mid - 1;
+        }
+        return undefined;
+    }
+    /**
+     * @instance Performs a fuzzy search on an array by matching characters in sequence.
+     *
+     * @param array - The array of items to search.
+     * @param matcher - The fuzzy search string to match against.
+     * @param keySelector - A function that extracts the key to search from each item.
+     * @param caseInsensitive - Whether to compare ignoring case for string values.
+     * @returns The first fuzzy-matching item if found; otherwise, undefined.
+     */
+    fuzzySearch(array, matcher, keySelector, caseInsensitive) {
+        for (const item of array) {
+            const rawKey = keySelector(item);
+            const key = caseInsensitive && typeof rawKey === 'string' ?
+                rawKey.toLowerCase()
+                : String(rawKey);
+            if (this.#match(key, matcher))
+                return item;
+        }
+        return undefined;
+    }
+    /**
+     * @private Checks if the characters in the target string appear in order within the source string.
+     * @param source Source string to search within.
+     * @param target Target string to match against the source string.
+     * @returns True if the target string is a fuzzy match within the source string; otherwise, false.
+     */
+    #match(source, target) {
+        let i = 0;
+        for (const char of target) {
+            i = source?.indexOf(char, i);
+            if (i === -1)
+                return false;
+            i++;
+        }
+        return true;
+    }
+    /**
+     * @private Sorts an array and caches the result for a specified time-to-live (TTL).
+     * @param data Data to sort and cache.
+     * @param getKey Key extraction function.
+     * @param cacheKey Optional cache key for storing the result.
+     * @returns
+     */
+    #sortAndCache(data, getKey, cacheKey) {
+        if (cacheKey) {
+            const entry = this.#sortedCache.get(cacheKey);
+            if (entry && Date.now() - entry.timestamp < this.#ttl) {
+                return entry.result;
+            }
+            else {
+                this.#sortedCache.delete(cacheKey);
+            }
+        }
+        const sorted = [...data].sort((a, b) => {
+            const keyA = getKey(a);
+            const keyB = getKey(b);
+            return (keyA < keyB ? -1
+                : keyA > keyB ? 1
+                    : 0);
+        });
+        if (cacheKey) {
+            this.#sortedCache.set(cacheKey, {
+                result: sorted,
+                timestamp: Date.now(),
+            });
+        }
+        return sorted;
+    }
+    /**
+     * @static @private Creates a memoized version of a key extractor.
+     * @param getKey Original key extraction function
+     */
+    static #createMemoizedKeyGetter(getKey) {
+        const cache = new Map();
+        return (item) => {
+            if (cache.has(item))
+                return cache.get(item);
+            const key = getKey(item);
+            cache.set(item, key);
+            return key;
+        };
+    }
+}
+exports.Finder = Finder;

package/dist/cjs/array/basics.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastArrayElement = exports.shuffleArray = exports.isInvalidOrEmptyArray = exports.filterArrayOfObjects = exports.flattenArray = void 0;
+/**
+ * * Flattens a nested array recursively or wraps any non-array data type in an array.
+ *
+ * @param input - The input value, which can be a nested array or a non-array value.
+ * @returns A fully flattened array of type `Flatten<T>`. If the input is not an array, it wraps it in a single-element array.
+ */
+const flattenArray = (input) => {
+    if (!Array.isArray(input))
+        return [input];
+    return input.reduce((acc, item) => {
+        // If item is an array, recursively flatten it; otherwise, add it directly.
+        return acc.concat(Array.isArray(item) ? (0, exports.flattenArray)(item) : [item]);
+    }, []);
+};
+exports.flattenArray = flattenArray;
+/**
+ * @deprecated _Please, use `findAll` instance method from `Finder` class for **more advanced filtering and searching.**_
+ *
+ * * Filters an array of objects based on multiple conditions for specified keys.
+ * @param array - The array of objects to filter.
+ * @param conditions - An object where keys represent the property names and values represent filter conditions.
+ *                     The conditions can be a function `(value: T[K]) => boolean`.
+ * @returns The filtered array of objects.
+ * @throws `Error` If the input is not a valid array.
+ */
+const filterArrayOfObjects = (array, conditions) => {
+    if (!Array.isArray(array)) {
+        throw new Error('The provided input is not a valid array!');
+    }
+    return array?.filter((item) => Object.entries(conditions)?.every(([key, conditionFn]) => {
+        if (typeof conditionFn === 'function') {
+            return conditionFn(item[key]);
+        }
+        return true;
+    }));
+};
+exports.filterArrayOfObjects = filterArrayOfObjects;
+/**
+ * * Checks if a value is an empty array or an array with only empty values.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is not an array, an empty array, or an array containing only `null`, `undefined`, empty objects, or empty arrays.
+ */
+const isInvalidOrEmptyArray = (value) => {
+    if (!Array.isArray(value))
+        return true;
+    if (value?.length === 0)
+        return true;
+    return value?.every((item) => item == null ||
+        (Array.isArray(item) && item?.length === 0) ||
+        (typeof item === 'object' && Object.keys(item || {})?.length === 0));
+};
+exports.isInvalidOrEmptyArray = isInvalidOrEmptyArray;
+/**
+ * * Shuffle the elements of an array.
+ *
+ * @param array Array to shuffle.
+ * @returns Shuffled array.
+ */
+const shuffleArray = (array) => {
+    if ((0, exports.isInvalidOrEmptyArray)(array))
+        return array;
+    const shuffled = structuredClone(array);
+    for (let i = shuffled?.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    return shuffled;
+};
+exports.shuffleArray = shuffleArray;
+/**
+ * * Get the last element of an array.
+ *
+ * @param array Array to get the last element from.
+ * @returns The last element or `undefined` if the array is empty.
+ */
+const getLastArrayElement = (array) => {
+    return array?.length > 0 ? array[array?.length - 1] : undefined;
+};
+exports.getLastArrayElement = getLastArrayElement;

package/dist/cjs/array/sort.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortAnArray = sortAnArray;
+const non_primitives_1 = require("../guards/non-primitives");
+const primitives_1 = require("../guards/primitives");
+const utils_1 = require("./utils");
+/**
+ * * Sorts an array of strings, numbers, booleans, or objects based on the provided options.
+ *
+ * - If the array contains strings, it sorts them alphabetically.
+ * - If the array contains numbers, it sorts them numerically.
+ * - If the array contains booleans, it sorts them by their boolean value.
+ * - If the array contains objects, it sorts them by the specified field in the options `sortByField`.
+ *
+ * @param array - The array to sort.
+ * @param options - Sorting options for objects.
+ * @returns The sorted array.
+ */
+function sortAnArray(array, options) {
+    if (!(0, non_primitives_1.isValidArray)(array))
+        return array;
+    // Check if the array contains strings
+    if ((0, non_primitives_1.isArrayOfType)(array, primitives_1.isString)) {
+        return [...array].sort((a, b) => options?.sortOrder === 'desc' ?
+            (0, utils_1.naturalSort)(b, a)
+            : (0, utils_1.naturalSort)(a, b));
+    }
+    // Check if the array contains numbers
+    if ((0, non_primitives_1.isArrayOfType)(array, primitives_1.isNumber)) {
+        return [...array].sort((a, b) => options?.sortOrder === 'desc' ? b - a : a - b);
+    }
+    // Check if the array contains booleans
+    if ((0, non_primitives_1.isArrayOfType)(array, primitives_1.isBoolean)) {
+        return [...array].sort((a, b) => options?.sortOrder === 'desc' ?
+            Number(b) - Number(a)
+            : Number(a) - Number(b));
+    }
+    // Handle array of objects
+    if ((0, non_primitives_1.isArrayOfType)(array, non_primitives_1.isObject) && options && 'sortByField' in options) {
+        return [...array].sort((a, b) => {
+            const _getKeyValue = (obj, path) => {
+                return path
+                    .split('.')
+                    .reduce((acc, key) => acc?.[key], obj);
+            };
+            const keyA = _getKeyValue(a, options?.sortByField);
+            const keyB = _getKeyValue(b, options?.sortByField);
+            if (keyA == null || keyB == null) {
+                return keyA == null ? 1 : -1;
+            }
+            if (typeof keyA === 'string' && typeof keyB === 'string') {
+                return options?.sortOrder === 'desc' ?
+                    (0, utils_1.naturalSort)(keyB, keyA)
+                    : (0, utils_1.naturalSort)(keyA, keyB);
+            }
+            if (typeof keyA === 'number' && typeof keyB === 'number') {
+                return options?.sortOrder === 'desc' ?
+                    keyB - keyA
+                    : keyA - keyB;
+            }
+            if (typeof keyA === 'boolean' && typeof keyB === 'boolean') {
+                return options?.sortOrder === 'desc' ?
+                    Number(keyB) - Number(keyA)
+                    : Number(keyA) - Number(keyB);
+            }
+            return 0;
+        });
+    }
+    return array;
+}

package/dist/cjs/array/transform.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOptionsArray = createOptionsArray;
+exports.removeDuplicatesFromArray = removeDuplicatesFromArray;
+exports.getDuplicates = getDuplicates;
+exports.findMissingElements = findMissingElements;
+exports.splitArray = splitArray;
+exports.rotateArray = rotateArray;
+exports.moveArrayElement = moveArrayElement;
+const primitives_1 = require("../guards/primitives");
+const utils_1 = require("../utils");
+/**
+ * * Converts an array of objects into a formatted array of options.
+ *
+ * @param data - An array of objects to convert into options.
+ * @param config - The configuration object to specify the keys for the `value` (firstFieldName) and `label` (secondFieldName) fields and rename as needed.
+ * @returns An array of options, where each option has `value` and `label` fields as default or as specified by user in the config options.
+ */
+function createOptionsArray(data, config) {
+    const { firstFieldKey, secondFieldKey, firstFieldName = 'value', secondFieldName = 'label', retainNumberValue = false, } = config || {};
+    if (data && data?.length) {
+        return data?.map((datum) => {
+            const firstValue = retainNumberValue && (0, primitives_1.isNumber)(datum[firstFieldKey]) ?
+                datum[firstFieldKey]
+                : String(datum[firstFieldKey] ?? '');
+            return {
+                [firstFieldName]: firstValue,
+                [secondFieldName]: String(datum[secondFieldKey] ?? ''),
+            };
+        });
+    }
+    else {
+        return [];
+    }
+}
+/**
+ * * Removes duplicate values from an array, supporting deep comparison for objects and arrays.
+ *
+ * @param array - The array from which duplicates need to be removed.
+ * @returns A new array with duplicates removed.
+ */
+function removeDuplicatesFromArray(array) {
+    return array?.filter((item, index, self) => index === self?.findIndex((el) => (0, utils_1.isDeepEqual)(el, item)));
+}
+/**
+ * * Finds duplicate values in an array, runs deep comparison for objects and arrays.
+ *
+ * @param array - The array in which to find duplicates.
+ * @returns An array containing all duplicate entries (each one only once).
+ */
+function getDuplicates(array) {
+    const seen = [];
+    const duplicates = [];
+    for (const item of array) {
+        const hasSeen = seen?.find((el) => (0, utils_1.isDeepEqual)(el, item));
+        const hasDuplicate = duplicates?.find((el) => (0, utils_1.isDeepEqual)(el, item));
+        if (hasSeen && !hasDuplicate) {
+            duplicates?.push(item);
+        }
+        else if (!hasSeen) {
+            seen?.push(item);
+        }
+    }
+    return duplicates;
+}
+/**
+ * * Finds elements missing from one array compared to another using deep comparison.
+ *
+ * @param options - Configuration to specify which array to compare and direction of check.
+ * @returns An array of missing elements based on the comparison direction.
+ */
+/**
+ * * Finds elements missing from one array compared to another using deep comparison.
+ *
+ * @param array1 The first array to compare.
+ * @param array2 The second array to compare.
+ * @param missingFrom Which direction to compare for missing values:.
+ *					  - `'from-first'` → values in `array1` missing in `array2`.
+ *					  - `'from-second'` → values in `array2` missing in `array1`.
+ * @returns An array of missing elements based on the comparison direction.
+ */
+function findMissingElements(array1, array2, missingFrom) {
+    const source = (missingFrom === 'from-first' ? array1 : array2) ?? [];
+    const target = (missingFrom === 'from-first' ? array2 : array1) ?? [];
+    return source.filter((s) => !target?.some((t) => (0, utils_1.isDeepEqual)(t, s)));
+}
+/**
+ * * Splits an array into chunks of a given size.
+ *
+ * @param arr The array to split.
+ * @param chunkSize The size of each chunk.
+ * @returns An array of chunked arrays.
+ */
+function splitArray(arr, chunkSize) {
+    const result = [];
+    for (let i = 0; i < arr?.length; i += chunkSize) {
+        result.push(arr.slice(i, i + chunkSize));
+    }
+    return result;
+}
+/**
+ * * Rotates an array left or right by a given number of steps.
+ *
+ * @param arr The array to rotate.
+ * @param steps The number of positions to rotate (positive: right, negative: left).
+ * @returns The rotated array.
+ */
+function rotateArray(arr, steps) {
+    const length = arr?.length;
+    if (length === 0)
+        return arr;
+    const offset = ((steps % length) + length) % length;
+    return arr.slice(-offset).concat(arr.slice(0, -offset));
+}
+/**
+ * * Moves an element within an array from one index to another.
+ *
+ * @param arr The array to modify.
+ * @param fromIndex The index of the element to move.
+ * @param toIndex The new index for the element.
+ * @returns A new array with the element moved.
+ */
+function moveArrayElement(arr, fromIndex, toIndex) {
+    const newArr = [...arr];
+    const [item] = newArr.splice(fromIndex, 1);
+    newArr.splice(toIndex, 0, item);
+    return newArr;
+}

package/dist/cjs/array/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/array/utils.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.naturalSort = naturalSort;
+/**
+ * * Compare two strings using natural sorting (e.g., "file2" < "file10").
+ * Optionally supports case-insensitive and locale-aware string chunk comparisons.
+ *
+ * @param a - The first string to compare.
+ * @param b - The second string to compare.
+ * @param options - Optional settings to configure comparison behavior.
+ * @param options.caseInsensitive - If true, compares string chunks without case sensitivity. Defaults to `true`.
+ * @param options.localeAware - If true, uses localeCompare for string chunk comparisons. Defaults to `false`.
+ * @returns A negative number if `a` comes before `b`, a positive number if `a` comes after `b`, or 0 if equal.
+ */
+function naturalSort(a, b, options) {
+    const { caseInsensitive = true, localeAware = false } = options || {};
+    /**
+     * * Splits a string into an array of number and non-number chunks.
+     * @param str - The string to split.
+     * @returns An array of string and number parts.
+     */
+    const _createChunks = (str) => {
+        const chunks = [];
+        let current = '';
+        let isNumeric = false;
+        for (const char of str) {
+            const charIsNum = !Number.isNaN(Number(char));
+            if (current?.length === 0) {
+                current = char;
+                isNumeric = charIsNum;
+                continue;
+            }
+            if (charIsNum === isNumeric) {
+                current += char;
+            }
+            else {
+                chunks?.push(isNumeric ? Number(current) : current);
+                current = char;
+                isNumeric = charIsNum;
+            }
+        }
+        if (current?.length > 0) {
+            chunks?.push(isNumeric ? Number(current) : current);
+        }
+        return chunks;
+    };
+    const aChunks = _createChunks(a);
+    const bChunks = _createChunks(b);
+    for (let i = 0; i < Math.min(aChunks?.length, bChunks?.length); i++) {
+        let aChunk = aChunks[i];
+        let bChunk = bChunks[i];
+        // Normalize string chunks if case-insensitive
+        if (caseInsensitive &&
+            typeof aChunk === 'string' &&
+            typeof bChunk === 'string') {
+            aChunk = aChunk?.toLowerCase();
+            bChunk = bChunk?.toLowerCase();
+        }
+        // Compare types: number vs string
+        if (typeof aChunk !== typeof bChunk) {
+            return typeof aChunk === 'string' ? 1 : -1;
+        }
+        // Compare same-type chunks
+        if (aChunk !== bChunk) {
+            if (typeof aChunk === 'number' && typeof bChunk === 'number') {
+                return aChunk - bChunk;
+            }
+            if (typeof aChunk === 'string' && typeof bChunk === 'string') {
+                if (localeAware) {
+                    const cmp = aChunk.localeCompare(bChunk, undefined, {
+                        sensitivity: caseInsensitive ? 'accent' : 'variant',
+                    });
+                    if (cmp !== 0)
+                        return cmp;
+                }
+                return aChunk < bChunk ? -1 : 1;
+            }
+        }
+    }
+    return aChunks?.length - bChunks?.length;
+}