@fedify/fedify 1.6.0-dev.814 → 1.6.0

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/shuffle.js

@@ -1,25 +0,0 @@
-/**
- * Randomizes the order of elements in an array using the Fisher-Yates algorithm.
- *
- * This function takes an array and returns a new array with its elements shuffled in a random order.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to shuffle.
- * @returns {T[]} A new array with its elements shuffled in random order.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const shuffledArray = shuffle(array);
- * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]
- */
-export function shuffle(arr) {
-    const result = arr.slice();
-    /**
-     * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm
-     */
-    for (let i = result.length - 1; i >= 1; i--) {
-        const j = Math.floor(Math.random() * (i + 1));
-        [result[i], result[j]] = [result[j], result[i]];
-    }
-    return result;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/sortBy.js

@@ -1,36 +0,0 @@
-import { orderBy } from './orderBy.js';
-/**
- * Sorts an array of objects based on the given `criteria`.
- *
- * - If you provide keys, it sorts the objects by the values of those keys.
- * - If you provide functions, it sorts based on the values returned by those functions.
- *
- * The function returns the array of objects sorted in ascending order.
- * If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
- *
- * @template T - The type of the objects in the array.
- * @param {T[]} arr - The array of objects to be sorted.
- * @param {Array<((item: T) => unknown) | keyof T>} criteria - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting.
- * @returns {T[]} - The sorted array.
- *
- * @example
- * const users = [
- *  { user: 'foo', age: 24 },
- *  { user: 'bar', age: 7 },
- *  { user: 'foo ', age: 8 },
- *  { user: 'bar ', age: 29 },
- * ];
- *
- * sortBy(users, ['user', 'age']);
- * sortBy(users, [obj => obj.user, 'age']);
- * // results will be:
- * // [
- * //   { user : 'bar', age: 7 },
- * //   { user : 'bar', age: 29 },
- * //   { user : 'foo', age: 8 },
- * //   { user : 'foo', age: 24 },
- * // ]
- */
-export function sortBy(arr, criteria) {
-    return orderBy(arr, criteria, ['asc']);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/tail.js

@@ -1,27 +0,0 @@
-/**
- * Returns a new array with all elements except for the first.
- *
- * This function takes an array and returns a new array containing all the elements
- * except for the first one. If the input array is empty or has only one element,
- * an empty array is returned.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to get the tail of.
- * @returns {T[]} A new array containing all elements of the input array except for the first one.
- *
- * @example
- * const arr1 = [1, 2, 3];
- * const result = tail(arr1);
- * // result will be [2, 3]
- *
- * const arr2 = [1];
- * const result2 = tail(arr2);
- * // result2 will be []
- *
- * const arr3 = [];
- * const result3 = tail(arr3);
- * // result3 will be []
- */
-export function tail(arr) {
-    return arr.slice(1);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/take.js

@@ -1,27 +0,0 @@
-import { toInteger } from '../compat/util/toInteger.js';
-/**
- * Returns a new array containing the first `count` elements from the input array `arr`.
- * If `count` is greater than the length of `arr`, the entire array is returned.
- *
- * @template T - Type of elements in the input array.
- *
- * @param {T[]} arr - The array to take elements from.
- * @param {number} count - The number of elements to take.
- * @returns {T[]} A new array containing the first `count` elements from `arr`.
- *
- * @example
- * // Returns [1, 2, 3]
- * take([1, 2, 3, 4, 5], 3);
- *
- * @example
- * // Returns ['a', 'b']
- * take(['a', 'b', 'c'], 2);
- *
- * @example
- * // Returns [1, 2, 3]
- * take([1, 2, 3], 5);
- */
-export function take(arr, count, guard) {
-    count = guard || count === undefined ? 1 : toInteger(count);
-    return arr.slice(0, count);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/takeRight.js

@@ -1,29 +0,0 @@
-import { toInteger } from '../compat/util/toInteger.js';
-/**
- * Returns a new array containing the last `count` elements from the input array `arr`.
- * If `count` is greater than the length of `arr`, the entire array is returned.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to take elements from.
- * @param {number} [count=1] - The number of elements to take.
- * @returns {T[]} A new array containing the last `count` elements from `arr`.
- *
- * @example
- * // Returns [4, 5]
- * takeRight([1, 2, 3, 4, 5], 2);
- *
- * @example
- * // Returns ['b', 'c']
- * takeRight(['a', 'b', 'c'], 2);
- *
- * @example
- * // Returns [1, 2, 3]
- * takeRight([1, 2, 3], 5);
- */
-export function takeRight(arr, count = 1, guard) {
-    count = guard || count === undefined ? 1 : toInteger(count);
-    if (count <= 0 || arr == null || arr.length === 0) {
-        return [];
-    }
-    return arr.slice(-count);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/takeRightWhile.js

@@ -1,25 +0,0 @@
-/**
- * Takes elements from the end of the array while the predicate function returns `true`.
- *
- * @template T - Type of elements in the input array.
- *
- * @param {T[]} arr - The array to take elements from.
- * @param {(item: T) => boolean} shouldContinueTaking - The function invoked per element.
- * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`.
- *
- * @example
- * // Returns [3, 2, 1]
- * takeRightWhile([5, 4, 3, 2, 1], n => n < 4);
- *
- * @example
- * // Returns []
- * takeRightWhile([1, 2, 3], n => n > 3);
- */
-export function takeRightWhile(arr, shouldContinueTaking) {
-    for (let i = arr.length - 1; i >= 0; i--) {
-        if (!shouldContinueTaking(arr[i])) {
-            return arr.slice(i + 1);
-        }
-    }
-    return arr.slice();
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/takeWhile.js

@@ -1,29 +0,0 @@
-/**
- * Returns a new array containing the leading elements of the provided array
- * that satisfy the provided predicate function. It stops taking elements as soon
- * as an element does not satisfy the predicate.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to process.
- * @param {(element: T) => boolean} shouldContinueTaking - The predicate function that is called with each element. Elements are included in the result as long as this function returns true.
- * @returns {T[]} A new array containing the leading elements that satisfy the predicate.
- *
- * @example
- * // Returns [1, 2]
- * takeWhile([1, 2, 3, 4], x => x < 3);
- *
- * @example
- * // Returns []
- * takeWhile([1, 2, 3, 4], x => x > 3);
- */
-export function takeWhile(arr, shouldContinueTaking) {
-    const result = [];
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        if (!shouldContinueTaking(item)) {
-            break;
-        }
-        result.push(item);
-    }
-    return result;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/toFilled.js

@@ -1,22 +0,0 @@
-/**
- * Creates a new array filled with the specified value from the start position up to, but not including, the end position.
- * This function does not mutate the original array.
- *
- * @template T - The type of elements in the original array.
- * @template U - The type of the value to fill the new array with.
- * @param {Array<T>} arr - The array to base the new array on.
- * @param {U} value - The value to fill the new array with.
- * @param {number} [start=0] - The start position. Defaults to 0.
- * @param {number} [end=arr.length] - The end position. Defaults to the array's length.
- * @returns {Array<T | U>} The new array with the filled values.
- */
-export function toFilled(arr, value, start = 0, end = arr.length) {
-    const length = arr.length;
-    const finalStart = Math.max(start >= 0 ? start : length + start, 0);
-    const finalEnd = Math.min(end >= 0 ? end : length + end, length);
-    const newArr = arr.slice();
-    for (let i = finalStart; i < finalEnd; i++) {
-        newArr[i] = value;
-    }
-    return newArr;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/union.js

@@ -1,21 +0,0 @@
-import { uniq } from './uniq.js';
-/**
- * Creates an array of unique values from all given arrays.
- *
- * This function takes two arrays, merges them into a single array, and returns a new array
- * containing only the unique values from the merged array.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr1 - The first array to merge and filter for unique values.
- * @param {T[]} arr2 - The second array to merge and filter for unique values.
- * @returns {T[]} A new array of unique values.
- *
- * @example
- * const array1 = [1, 2, 3];
- * const array2 = [3, 4, 5];
- * const result = union(array1, array2);
- * // result will be [1, 2, 3, 4, 5]
- */
-export function union(arr1, arr2) {
-    return uniq(arr1.concat(arr2));
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/unionBy.js

@@ -1,26 +0,0 @@
-import { uniqBy } from './uniqBy.js';
-/**
- * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality.
- *
- * @template T - The type of elements in the array.
- * @template U - The type of mapped elements.
- * @param {T[]} arr1 - The first array.
- * @param {T[]} arr2 - The second array.
- * @param {(item: T) => U} mapper - The function to map array elements to comparison values.
- * @returns {T[]} A new array containing the union of unique elements from `arr1` and `arr2`, based on the values returned by the mapping function.
- *
- * @example
- * // Custom mapping function for numbers (modulo comparison)
- * const moduloMapper = (x) => x % 3;
- * unionBy([1, 2, 3], [4, 5, 6], moduloMapper);
- * // Returns [1, 2, 3]
- *
- * @example
- * // Custom mapping function for objects with an 'id' property
- * const idMapper = (obj) => obj.id;
- * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
- * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }]
- */
-export function unionBy(arr1, arr2, mapper) {
-    return uniqBy(arr1.concat(arr2), mapper);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/unionWith.js

@@ -1,24 +0,0 @@
-import { uniqWith } from './uniqWith.js';
-/**
- * Creates an array of unique values from two given arrays based on a custom equality function.
- *
- * This function takes two arrays and a custom equality function, merges the arrays, and returns
- * a new array containing only the unique values as determined by the custom equality function.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr1 - The first array to merge and filter for unique values.
- * @param {T[]} arr2 - The second array to merge and filter for unique values.
- * @param {(item1: T, item2: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
- * It takes two arguments and returns `true` if the elements are considered equal, and `false` otherwise.
- * @returns {T[]} A new array of unique values based on the custom equality function.
- *
- * @example
- * const array1 = [{ id: 1 }, { id: 2 }];
- * const array2 = [{ id: 2 }, { id: 3 }];
- * const areItemsEqual = (a, b) => a.id === b.id;
- * const result = unionWith(array1, array2, areItemsEqual);
- * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays
- */
-export function unionWith(arr1, arr2, areItemsEqual) {
-    return uniqWith(arr1.concat(arr2), areItemsEqual);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/uniq.js

@@ -1,18 +0,0 @@
-/**
- * Creates a duplicate-free version of an array.
- *
- * This function takes an array and returns a new array containing only the unique values
- * from the original array, preserving the order of first occurrence.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to process.
- * @returns {T[]} A new array with only unique values from the original array.
- *
- * @example
- * const array = [1, 2, 2, 3, 4, 4, 5];
- * const result = uniq(array);
- * // result will be [1, 2, 3, 4, 5]
- */
-export function uniq(arr) {
-    return Array.from(new Set(arr));
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/uniqBy.js

@@ -1,37 +0,0 @@
-/**
- * Returns a new array containing only the unique elements from the original array,
- * based on the values returned by the mapper function.
- *
- * @template T - The type of elements in the array.
- * @template U - The type of mapped elements.
- * @param {T[]} arr - The array to process.
- * @param {(item: T) => U} mapper - The function used to convert the array elements.
- * @returns {T[]} A new array containing only the unique elements from the original array, based on the values returned by the mapper function.
- *
- * @example
- * ```ts
- * uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);
- * // [1.2, 2.1, 3.2, 5.7, 7.19]
- * ```
- *
- * @example
- * const array = [
- *   { category: 'fruit', name: 'apple' },
- *   { category: 'fruit', name: 'banana' },
- *   { category: 'vegetable', name: 'carrot' },
- * ];
- * uniqBy(array, item => item.category).length
- * // 2
- * ```
- */
-export function uniqBy(arr, mapper) {
-    const map = new Map();
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        const key = mapper(item);
-        if (!map.has(key)) {
-            map.set(key, item);
-        }
-    }
-    return Array.from(map.values());
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/uniqWith.js

@@ -1,26 +0,0 @@
-/**
- * Returns a new array containing only the unique elements from the original array,
- * based on the values returned by the comparator function.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to process.
- * @param {(item1: T, item2: T) => boolean} areItemsEqual - The function used to compare the array elements.
- * @returns {T[]} A new array containing only the unique elements from the original array, based on the values returned by the comparator function.
- *
- * @example
- * ```ts
- * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1);
- * // [1.2, 3.2, 5.7, 7.19]
- * ```
- */
-export function uniqWith(arr, areItemsEqual) {
-    const result = [];
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        const isUniq = result.every(v => !areItemsEqual(v, item));
-        if (isUniq) {
-            result.push(item);
-        }
-    }
-    return result;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/unzip.js

@@ -1,31 +0,0 @@
-/**
- * Gathers elements in the same position in an internal array
- * from a grouped array of elements and returns them as a new array.
- *
- * @template T - The type of elements in the nested array.
- * @param {Array<[...T]>} zipped - The nested array to unzip.
- * @returns {Unzip<T>} A new array of unzipped elements.
- *
- * @example
- * const zipped = [['a', true, 1],['b', false, 2]];
- * const result = unzip(zipped);
- * // result will be [['a', 'b'], [true, false], [1, 2]]
- */
-export function unzip(zipped) {
-    // For performance reasons, use this implementation instead of
-    // const maxLen = Math.max(...zipped.map(arr => arr.length));
-    let maxLen = 0;
-    for (let i = 0; i < zipped.length; i++) {
-        if (zipped[i].length > maxLen) {
-            maxLen = zipped[i].length;
-        }
-    }
-    const result = new Array(maxLen);
-    for (let i = 0; i < maxLen; i++) {
-        result[i] = new Array(zipped.length);
-        for (let j = 0; j < zipped.length; j++) {
-            result[i][j] = zipped[j][i];
-        }
-    }
-    return result;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/unzipWith.js

@@ -1,26 +0,0 @@
-/**
- * Unzips an array of arrays, applying an `iteratee` function to regrouped elements.
- *
- * @template T, R
- * @param {T[][]} target - The nested array to unzip. This is an array of arrays,
- * where each inner array contains elements to be unzipped.
- * @param {(...args: T[]) => R} iteratee - A function to transform the unzipped elements.
- * @returns {R[]} A new array of unzipped and transformed elements.
- *
- * @example
- * const nestedArray = [[1, 2], [3, 4], [5, 6]];
- * const result = unzipWith(nestedArray, (item, item2, item3) => item + item2 + item3);
- * // result will be [9, 12]
- */
-export function unzipWith(target, iteratee) {
-    const maxLength = Math.max(...target.map(innerArray => innerArray.length));
-    const result = new Array(maxLength);
-    for (let i = 0; i < maxLength; i++) {
-        const group = new Array(target.length);
-        for (let j = 0; j < target.length; j++) {
-            group[j] = target[j][i];
-        }
-        result[i] = iteratee(...group);
-    }
-    return result;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/windowed.js

@@ -1,44 +0,0 @@
-/**
- * Creates an array of sub-arrays (windows) from the input array, each of the specified size.
- * The windows can overlap depending on the step size provided.
- *
- * By default, only full windows are included in the result, and any leftover elements that can't form a full window are ignored.
- *
- * If the `partialWindows` option is set to true in the options object, the function will also include partial windows at the end of the result.
- * Partial windows are smaller sub-arrays created when there aren't enough elements left in the input array to form a full window.
- *
- * @template T
- * @param {readonly T[]} arr - The input array to create windows from.
- * @param {number} size - The size of each window. Must be a positive integer.
- * @param {number} [step=1] - The step size between the start of each window. Must be a positive integer.
- * @param {WindowedOptions} [options={}] - Options object to configure the behavior of the function.
- * @param {boolean} [options.partialWindows=false] - Whether to include partial windows at the end of the array.
- * @returns {T[][]} An array of windows (sub-arrays) created from the input array.
- * @throws {Error} If the size or step is not a positive integer.
- *
- * @example
- * windowed([1, 2, 3, 4], 2);
- * // => [[1, 2], [2, 3], [3, 4]]
- *
- * @example
- * windowed([1, 2, 3, 4, 5, 6], 3, 2);
- * // => [[1, 2, 3], [3, 4, 5]]
- *
- * @example
- * windowed([1, 2, 3, 4, 5, 6], 3, 2, { partialWindows: true });
- * // => [[1, 2, 3], [3, 4, 5], [5, 6]]
- */
-export function windowed(arr, size, step = 1, { partialWindows = false } = {}) {
-    if (size <= 0 || !Number.isInteger(size)) {
-        throw new Error('Size must be a positive integer.');
-    }
-    if (step <= 0 || !Number.isInteger(step)) {
-        throw new Error('Step must be a positive integer.');
-    }
-    const result = [];
-    const end = partialWindows ? arr.length : arr.length - size + 1;
-    for (let i = 0; i < end; i += step) {
-        result.push(arr.slice(i, i + size));
-    }
-    return result;
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/without.js

@@ -1,24 +0,0 @@
-import { difference } from './difference.js';
-/**
- * Creates an array that excludes all specified values.
- *
- * It correctly excludes `NaN`, as it compares values using [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero).
- *
- * @template T The type of elements in the array.
- * @param {T[]} array - The array to filter.
- * @param {...T[]} values - The values to exclude.
- * @returns {T[]} A new array without the specified values.
- *
- * @example
- * // Removes the specified values from the array
- * without([1, 2, 3, 4, 5], 2, 4);
- * // Returns: [1, 3, 5]
- *
- * @example
- * // Removes specified string values from the array
- * without(['a', 'b', 'c', 'a'], 'a');
- * // Returns: ['b', 'c']
- */
-export function without(array, ...values) {
-    return difference(array, values);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/xor.js

@@ -1,23 +0,0 @@
-import { difference } from './difference.js';
-import { intersection } from './intersection.js';
-import { union } from './union.js';
-/**
- * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements
- * which are in either of the arrays, but not in their intersection.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr1 - The first array.
- * @param {T[]} arr2 - The second array.
- * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both.
- *
- * @example
- * // Returns [1, 2, 5, 6]
- * xor([1, 2, 3, 4], [3, 4, 5, 6]);
- *
- * @example
- * // Returns ['a', 'c']
- * xor(['a', 'b'], ['b', 'c']);
- */
-export function xor(arr1, arr2) {
-    return difference(union(arr1, arr2), intersection(arr1, arr2));
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/xorBy.js

@@ -1,27 +0,0 @@
-import { differenceBy } from './differenceBy.js';
-import { intersectionBy } from './intersectionBy.js';
-import { unionBy } from './unionBy.js';
-/**
- * Computes the symmetric difference between two arrays using a custom mapping function.
- * The symmetric difference is the set of elements which are in either of the arrays,
- * but not in their intersection, determined by the result of the mapping function.
- *
- * @template T - Type of elements in the input arrays.
- * @template U - Type of the values returned by the mapping function.
- *
- * @param {T[]} arr1 - The first array.
- * @param {T[]} arr2 - The second array.
- * @param {(item: T) => U} mapper - The function to map array elements to comparison values.
- * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function.
- *
- * @example
- * // Custom mapping function for objects with an 'id' property
- * const idMapper = obj => obj.id;
- * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);
- * // Returns [{ id: 1 }, { id: 3 }]
- */
-export function xorBy(arr1, arr2, mapper) {
-    const union = unionBy(arr1, arr2, mapper);
-    const intersection = intersectionBy(arr1, arr2, mapper);
-    return differenceBy(union, intersection, mapper);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/xorWith.js

@@ -1,26 +0,0 @@
-import { differenceWith } from './differenceWith.js';
-import { intersectionWith } from './intersectionWith.js';
-import { unionWith } from './unionWith.js';
-/**
- * Computes the symmetric difference between two arrays using a custom equality function.
- * The symmetric difference is the set of elements which are in either of the arrays,
- * but not in their intersection.
- *
- * @template T - Type of elements in the input arrays.
- *
- * @param {T[]} arr1 - The first array.
- * @param {T[]} arr2 - The second array.
- * @param {(item1: T, item2: T) => boolean} areElementsEqual - The custom equality function to compare elements.
- * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the custom equality function.
- *
- * @example
- * // Custom equality function for objects with an 'id' property
- * const areObjectsEqual = (a, b) => a.id === b.id;
- * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual);
- * // Returns [{ id: 1 }, { id: 3 }]
- */
-export function xorWith(arr1, arr2, areElementsEqual) {
-    const union = unionWith(arr1, arr2, areElementsEqual);
-    const intersection = intersectionWith(arr1, arr2, areElementsEqual);
-    return differenceWith(union, intersection, areElementsEqual);
-}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/array/zip.js

@@ -1,39 +0,0 @@
-/**
- * Combines multiple arrays into a single array of tuples.
- *
- * This function takes multiple arrays and returns a new array where each element is a tuple
- * containing the corresponding elements from the input arrays. If the input arrays are of
- * different lengths, the resulting array will have the length of the longest input array,
- * with undefined values for missing elements.
- *
- * @template T
- * @param {...Array<readonly T[]>} arrs - The arrays to zip together.
- * @returns {T[][]} A new array of tuples containing the corresponding elements from the input arrays.
- *
- * @example
- * const arr1 = [1, 2, 3];
- * const arr2 = ['a', 'b', 'c'];
- * const arr3 = [true, false];
- * const result = zip(arr1, arr2, arr3);
- * // result will be [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]]
- */
-export function zip(...arrs) {
-    // For performance reasons, use this implementation instead of
-    // const rowCount = Math.max(...arrs.map(x => x.length));
-    let rowCount = 0;
-    for (let i = 0; i < arrs.length; i++) {
-        if (arrs[i].length > rowCount) {
-            rowCount = arrs[i].length;
-        }
-    }
-    const columnCount = arrs.length;
-    const result = Array(rowCount);
-    for (let i = 0; i < rowCount; ++i) {
-        const row = Array(columnCount);
-        for (let j = 0; j < columnCount; ++j) {
-            row[j] = arrs[j][i];
-        }
-        result[i] = row;
-    }
-    return result;
-}