@fedify/fedify 1.6.0-dev.814 → 1.6.0-experiment.0

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

@@ -1,18 +0,0 @@
-/**
- * Returns the first element of an array or `undefined` if the array is empty.
- *
- * This function takes an array and returns the first element of the array.
- * If the array is empty, the function returns `undefined`.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to get the first element.
- * @returns {T | undefined} The first element of the array, or `undefined` if the array is empty.
- *
- * @example
- * const emptyArr: number[] = [];
- * const noElement = head(emptyArr);
- * // noElement will be undefined
- */
-export function head(arr) {
-    return arr[0];
-}

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

@@ -1,60 +0,0 @@
-export { at } from './at.js';
-export { chunk } from './chunk.js';
-export { compact } from './compact.js';
-export { countBy } from './countBy.js';
-export { difference } from './difference.js';
-export { differenceBy } from './differenceBy.js';
-export { differenceWith } from './differenceWith.js';
-export { drop } from './drop.js';
-export { dropRight } from './dropRight.js';
-export { dropRightWhile } from './dropRightWhile.js';
-export { dropWhile } from './dropWhile.js';
-export { fill } from './fill.js';
-export { flatMap } from './flatMap.js';
-export { flatMapDeep } from './flatMapDeep.js';
-export { flatten } from './flatten.js';
-export { flattenDeep } from './flattenDeep.js';
-export { forEachRight } from './forEachRight.js';
-export { groupBy } from './groupBy.js';
-export { head } from './head.js';
-export { initial } from './initial.js';
-export { intersection } from './intersection.js';
-export { intersectionBy } from './intersectionBy.js';
-export { intersectionWith } from './intersectionWith.js';
-export { isSubset } from './isSubset.js';
-export { isSubsetWith } from './isSubsetWith.js';
-export { keyBy } from './keyBy.js';
-export { last } from './last.js';
-export { maxBy } from './maxBy.js';
-export { minBy } from './minBy.js';
-export { orderBy } from './orderBy.js';
-export { partition } from './partition.js';
-export { pull } from './pull.js';
-export { pullAt } from './pullAt.js';
-export { remove } from './remove.js';
-export { sample } from './sample.js';
-export { sampleSize } from './sampleSize.js';
-export { shuffle } from './shuffle.js';
-export { sortBy } from './sortBy.js';
-export { tail } from './tail.js';
-export { take } from './take.js';
-export { takeRight } from './takeRight.js';
-export { takeRightWhile } from './takeRightWhile.js';
-export { takeWhile } from './takeWhile.js';
-export { toFilled } from './toFilled.js';
-export { union } from './union.js';
-export { unionBy } from './unionBy.js';
-export { unionWith } from './unionWith.js';
-export { uniq } from './uniq.js';
-export { uniqBy } from './uniqBy.js';
-export { uniqWith } from './uniqWith.js';
-export { unzip } from './unzip.js';
-export { unzipWith } from './unzipWith.js';
-export { windowed } from './windowed.js';
-export { without } from './without.js';
-export { xor } from './xor.js';
-export { xorBy } from './xorBy.js';
-export { xorWith } from './xorWith.js';
-export { zip } from './zip.js';
-export { zipObject } from './zipObject.js';
-export { zipWith } from './zipWith.js';

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

@@ -1,16 +0,0 @@
-/**
- * Returns a new array containing all elements except the last one from the input array.
- * If the input array is empty or has only one element, the function returns an empty array.
- *
- * @template T The type of elements in the array.
- * @param {T[]} arr - The input array.
- * @returns {T[]} A new array containing all but the last element of the input array.
- *
- * @example
- * const arr = [1, 2, 3, 4];
- * const result = initial(arr);
- * // result will be [1, 2, 3]
- */
-export function initial(arr) {
-    return arr.slice(0, -1);
-}

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

@@ -1,24 +0,0 @@
-/**
- * Returns the intersection of two arrays.
- *
- * This function takes two arrays and returns a new array containing the elements that are
- * present in both arrays. It effectively filters out any elements from the first array that
- * are not found in the second array.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} firstArr - The first array to compare.
- * @param {T[]} secondArr - The second array to compare.
- * @returns {T[]} A new array containing the elements that are present in both arrays.
- *
- * @example
- * const array1 = [1, 2, 3, 4, 5];
- * const array2 = [3, 4, 5, 6, 7];
- * const result = intersection(array1, array2);
- * // result will be [3, 4, 5] since these elements are in both arrays.
- */
-export function intersection(firstArr, secondArr) {
-    const secondSet = new Set(secondArr);
-    return firstArr.filter(item => {
-        return secondSet.has(item);
-    });
-}

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

@@ -1,37 +0,0 @@
-/**
- * Returns the intersection of two arrays based on a mapping function.
- *
- * This function takes two arrays and a mapping function. It returns a new array containing
- * the elements from the first array that, when mapped using the provided function, have matching
- * mapped elements in the second array. It effectively filters out any elements from the first array
- * that do not have corresponding mapped values in the second array.
- *
- * @template T - The type of elements in the first array.
- * @template U - The type of elements in the second array.
- * @param {T[]} firstArr - The first array to compare.
- * @param {U[]} secondArr - The second array to compare.
- * @param {(item: T | U) => unknown} mapper - A function to map the elements of both arrays for comparison.
- * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array.
- *
- * @example
- * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const array2 = [{ id: 2 }, { id: 4 }];
- * const mapper = item => item.id;
- * const result = intersectionBy(array1, array2, mapper);
- * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.
- *
- * @example
- * const array1 = [
- *   { id: 1, name: 'jane' },
- *   { id: 2, name: 'amy' },
- *   { id: 3, name: 'michael' },
- * ];
- * const array2 = [2, 4];
- * const mapper = item => (typeof item === 'object' ? item.id : item);
- * const result = intersectionBy(array1, array2, mapper);
- * // result will be [{ id: 2, name: 'amy' }] since only this element has a matching id that is equal to seconds array's element.
- */
-export function intersectionBy(firstArr, secondArr, mapper) {
-    const mappedSecondSet = new Set(secondArr.map(mapper));
-    return firstArr.filter(item => mappedSecondSet.has(mapper(item)));
-}

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

@@ -1,41 +0,0 @@
-/**
- * Returns the intersection of two arrays based on a custom equality function.
- *
- * This function takes two arrays and a custom equality function. It returns a new array containing
- * the elements from the first array that have matching elements in the second array, as determined
- * by the custom equality function. It effectively filters out any elements from the first array that
- * do not have corresponding matches in the second array according to the equality function.
- *
- * @template T - The type of elements in the first array.
- * @template U - The type of elements in the second array.
- * @param {T[]} firstArr - The first array to compare.
- * @param {U[]} secondArr - The second array to compare.
- * @param {(x: T, y: U) => boolean} areItemsEqual - A custom function to determine if two elements are equal.
- * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.
- * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.
- *
- * @example
- * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const array2 = [{ id: 2 }, { id: 4 }];
- * const areItemsEqual = (a, b) => a.id === b.id;
- * const result = intersectionWith(array1, array2, areItemsEqual);
- * // result will be [{ id: 2 }] since this element has a matching id in both arrays.
- *
- * @example
- * const array1 = [
- *   { id: 1, name: 'jane' },
- *   { id: 2, name: 'amy' },
- *   { id: 3, name: 'michael' },
- * ];
- * const array2 = [2, 4];
- * const areItemsEqual = (a, b) => a.id === b;
- * const result = intersectionWith(array1, array2, areItemsEqual);
- * // result will be [{ id: 2, name: 'amy' }] since this element has a matching id that is equal to seconds array's element.
- */
-export function intersectionWith(firstArr, secondArr, areItemsEqual) {
-    return firstArr.filter(firstItem => {
-        return secondArr.some(secondItem => {
-            return areItemsEqual(firstItem, secondItem);
-        });
-    });
-}

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

@@ -1,27 +0,0 @@
-import { difference } from './difference.js';
-/**
- * Checks if the `subset` array is entirely contained within the `superset` array.
- *
- *
- * @template T - The type of elements contained in the arrays.
- * @param {T[]} superset - The array that may contain all elements of the subset.
- * @param {T[]} subset - The array to check against the superset.
- * @returns {boolean} - Returns `true` if all elements of the `subset` are present in the `superset`, otherwise returns `false`.
- *
- * @example
- * ```typescript
- * const superset = [1, 2, 3, 4, 5];
- * const subset = [2, 3, 4];
- * isSubset(superset, subset); // true
- * ```
- *
- * @example
- * ```typescript
- * const superset = ['a', 'b', 'c'];
- * const subset = ['a', 'd'];
- * isSubset(superset, subset); // false
- * ```
- */
-export function isSubset(superset, subset) {
-    return difference(subset, superset).length === 0;
-}

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

@@ -1,34 +0,0 @@
-import { differenceWith } from './differenceWith.js';
-/**
- * Checks if the `subset` array is entirely contained within the `superset` array based on a custom equality function.
- *
- * This function takes two arrays and a custom comparison function. It returns a boolean indicating
- * whether all elements in the subset array are present in the superset array, as determined by the provided
- * custom equality function.
- *
- * @template T - The type of elements contained in the arrays.
- * @param {T[]} superset - The array that may contain all elements of the subset.
- * @param {T[]} subset - The array to check against the superset.
- * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal.
- * @returns {boolean} - Returns `true` if all elements of the subset are present in the superset
- * according to the custom equality function, otherwise returns `false`.
- *
- * @example
- * ```typescript
- * const superset = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const subset = [{ id: 2 }, { id: 1 }];
- * const areItemsEqual = (a, b) => a.id === b.id;
- * isSubsetWith(superset, subset, areItemsEqual); // true
- * ```
- *
- * @example
- * ```typescript
- * const superset = [{ id: 1 }, { id: 2 }, { id: 3 }];
- * const subset = [{ id: 4 }];
- * const areItemsEqual = (a, b) => a.id === b.id;
- * isSubsetWith(superset, subset, areItemsEqual); // false
- * ```
- */
-export function isSubsetWith(superset, subset, areItemsEqual) {
-    return differenceWith(subset, superset, areItemsEqual).length === 0;
-}

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

@@ -1,36 +0,0 @@
-/**
- * Maps each element of an array based on a provided key-generating function.
- *
- * This function takes an array and a function that generates a key from each element. It returns
- * an object where the keys are the generated keys and the values are the corresponding elements.
- * If there are multiple elements generating the same key, the last element among them is used
- * as the value.
- *
- * @template T - The type of elements in the array.
- * @template K - The type of keys.
- * @param {T[]} arr - The array of elements to be mapped.
- * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
- * @returns {Record<K, T>} An object where keys are mapped to each element of an array.
- *
- * @example
- * const array = [
- *   { category: 'fruit', name: 'apple' },
- *   { category: 'fruit', name: 'banana' },
- *   { category: 'vegetable', name: 'carrot' }
- * ];
- * const result = keyBy(array, item => item.category);
- * // result will be:
- * // {
- * //   fruit: { category: 'fruit', name: 'banana' },
- * //   vegetable: { category: 'vegetable', name: 'carrot' }
- * // }
- */
-export function keyBy(arr, getKeyFromItem) {
-    const result = {};
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        const key = getKeyFromItem(item);
-        result[key] = item;
-    }
-    return result;
-}

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

@@ -1,25 +0,0 @@
-/**
- * Returns the last element of an array.
- *
- * This function takes an array and returns the last element of the array.
- * If the array is empty, the function returns `undefined`.
- *
- * Unlike some implementations, this function is optimized for performance
- * by directly accessing the last index of the array.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array from which to get the last element.
- * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty.
- *
- * @example
- * const arr = [1, 2, 3];
- * const lastElement = last(arr);
- * // lastElement will be 3
- *
- * const emptyArr: number[] = [];
- * const noElement = last(emptyArr);
- * // noElement will be undefined
- */
-export function last(arr) {
-    return arr[arr.length - 1];
-}

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

@@ -1,37 +0,0 @@
-/**
- * Finds the element in an array that has the maximum value when applying
- * the `getValue` function to each element.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} items The array of elements to search.
- * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
- * @returns {T | undefined} The element with the maximum value as determined by the `getValue` function,
- * or `undefined` if the array is empty.
- * @example
- * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
- * maxBy([], x => x.a); // Returns: undefined
- * maxBy(
- *   [
- *     { name: 'john', age: 30 },
- *     { name: 'jane', age: 28 },
- *     { name: 'joe', age: 26 },
- *   ],
- *   x => x.age
- * ); // Returns: { name: 'john', age: 30 }
- */
-export function maxBy(items, getValue) {
-    if (items.length === 0) {
-        return undefined;
-    }
-    let maxElement = items[0];
-    let max = getValue(maxElement);
-    for (let i = 1; i < items.length; i++) {
-        const element = items[i];
-        const value = getValue(element);
-        if (value > max) {
-            max = value;
-            maxElement = element;
-        }
-    }
-    return maxElement;
-}

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

@@ -1,37 +0,0 @@
-/**
- * Finds the element in an array that has the minimum value when applying
- * the `getValue` function to each element.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} items The array of elements to search.
- * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
- * @returns {T | undefined} The element with the minimum value as determined by the `getValue` function,
- * or `undefined` if the array is empty.
- * @example
- * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }
- * minBy([], x => x.a); // Returns: undefined
- * minBy(
- *   [
- *     { name: 'john', age: 30 },
- *     { name: 'jane', age: 28 },
- *     { name: 'joe', age: 26 },
- *   ],
- *   x => x.age
- * ); // Returns: { name: 'joe', age: 26 }
- */
-export function minBy(items, getValue) {
-    if (items.length === 0) {
-        return undefined;
-    }
-    let minElement = items[0];
-    let min = getValue(minElement);
-    for (let i = 1; i < items.length; i++) {
-        const element = items[i];
-        const value = getValue(element);
-        if (value < min) {
-            min = value;
-            minElement = element;
-        }
-    }
-    return minElement;
-}

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

@@ -1,52 +0,0 @@
-import { compareValues } from '../_internal/compareValues.js';
-/**
- * Sorts an array of objects based on the given `criteria` and their corresponding order directions.
- *
- * - 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 corresponding order directions.
- * If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
- * If the number of orders is less than the number of criteria, it uses the last order for the rest of the criteria.
- *
- * @template T - The type of elements 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.
- * @param {Array<'asc' | 'desc'>} orders - An array of order directions ('asc' for ascending or 'desc' for descending).
- * @returns {T[]} - The sorted array.
- *
- * @example
- * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.
- * const users = [
- *   { user: 'fred', age: 48 },
- *   { user: 'barney', age: 34 },
- *   { user: 'fred', age: 40 },
- *   { user: 'barney', age: 36 },
- * ];
- *
- * const result = orderBy(users, [obj => obj.user, 'age'], ['asc', 'desc']);
- * // result will be:
- * // [
- * //   { user: 'barney', age: 36 },
- * //   { user: 'barney', age: 34 },
- * //   { user: 'fred', age: 48 },
- * //   { user: 'fred', age: 40 },
- * // ]
- */
-export function orderBy(arr, criteria, orders) {
-    return arr.slice().sort((a, b) => {
-        const ordersLength = orders.length;
-        for (let i = 0; i < criteria.length; i++) {
-            const order = ordersLength > i ? orders[i] : orders[ordersLength - 1];
-            const criterion = criteria[i];
-            const criterionIsFunction = typeof criterion === 'function';
-            const valueA = criterionIsFunction ? criterion(a) : a[criterion];
-            const valueB = criterionIsFunction ? criterion(b) : b[criterion];
-            const result = compareValues(valueA, valueB, order);
-            if (result !== 0) {
-                return result;
-            }
-        }
-        return 0;
-    });
-}

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

@@ -1,36 +0,0 @@
-/**
- * Splits an array into two groups based on a predicate function.
- *
- * This function takes an array and a predicate function. It returns a tuple of two arrays:
- * the first array contains elements for which the predicate function returns true, and
- * the second array contains elements for which the predicate function returns false.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to partition.
- * @param {(value: T) => boolean} isInTruthy - A predicate function that determines
- * whether an element should be placed in the truthy array. The function is called with each
- * element of the array.
- * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for
- * which the predicate returned true, and the second array contains elements for which the
- * predicate returned false.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const isEven = x => x % 2 === 0;
- * const [even, odd] = partition(array, isEven);
- * // even will be [2, 4], and odd will be [1, 3, 5]
- */
-export function partition(arr, isInTruthy) {
-    const truthy = [];
-    const falsy = [];
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        if (isInTruthy(item)) {
-            truthy.push(item);
-        }
-        else {
-            falsy.push(item);
-        }
-    }
-    return [truthy, falsy];
-}

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

@@ -1,33 +0,0 @@
-/**
- * Removes all specified values from an array.
- *
- * This function changes `arr` in place.
- * If you want to remove values without modifying the original array, use `difference`.
- *
- * @template T, U
- * @param {T[]} arr - The array to modify.
- * @param {unknown[]} valuesToRemove - The values to remove from the array.
- * @returns {T[]} The modified array with the specified values removed.
- *
- * @example
- * const numbers = [1, 2, 3, 4, 5, 2, 4];
- * pull(numbers, [2, 4]);
- * console.log(numbers); // [1, 3, 5]
- */
-export function pull(arr, valuesToRemove) {
-    const valuesSet = new Set(valuesToRemove);
-    let resultIndex = 0;
-    for (let i = 0; i < arr.length; i++) {
-        if (valuesSet.has(arr[i])) {
-            continue;
-        }
-        // For handling sparse arrays
-        if (!Object.hasOwn(arr, i)) {
-            delete arr[resultIndex++];
-            continue;
-        }
-        arr[resultIndex++] = arr[i];
-    }
-    arr.length = resultIndex;
-    return arr;
-}

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

@@ -1,25 +0,0 @@
-import { at } from './at.js';
-/**
- * Removes elements from an array at specified indices and returns the removed elements.
- *
- * This function supports negative indices, which count from the end of the array.
- *
- * @template T
- * @param {T[]} arr - The array from which elements will be removed.
- * @param {number[]} indicesToRemove - An array of indices specifying the positions of elements to remove.
- * @returns {Array<T | undefined>} An array containing the elements that were removed from the original array.
- *
- * @example
- * const numbers = [10, 20, 30, 40, 50];
- * const removed = pullAt(numbers, [1, 3, 4]);
- * console.log(removed); // [20, 40, 50]
- * console.log(numbers); // [10, 30]
- */
-export function pullAt(arr, indicesToRemove) {
-    const removed = at(arr, indicesToRemove);
-    const indices = new Set(indicesToRemove.slice().sort((x, y) => y - x));
-    for (const index of indices) {
-        arr.splice(index, 1);
-    }
-    return removed;
-}

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

@@ -1,35 +0,0 @@
-/**
- * Removes elements from an array based on a predicate function.
- *
- * This function changes `arr` in place.
- * If you want to remove elements without modifying the original array, use `filter`.
- *
- * @template T
- * @param {T[]} arr - The array to modify.
- * @param {(value: T, index: number, array: T[]) => boolean} shouldRemoveElement - The function invoked per iteration to determine if an element should be removed.
- * @returns {T[]} The modified array with the specified elements removed.
- *
- * @example
- * const numbers = [1, 2, 3, 4, 5];
- * remove(numbers, (value) => value % 2 === 0);
- * console.log(numbers); // [1, 3, 5]
- */
-export function remove(arr, shouldRemoveElement) {
-    const originalArr = arr.slice();
-    const removed = [];
-    let resultIndex = 0;
-    for (let i = 0; i < arr.length; i++) {
-        if (shouldRemoveElement(arr[i], i, originalArr)) {
-            removed.push(arr[i]);
-            continue;
-        }
-        // For handling sparse arrays
-        if (!Object.hasOwn(arr, i)) {
-            delete arr[resultIndex++];
-            continue;
-        }
-        arr[resultIndex++] = arr[i];
-    }
-    arr.length = resultIndex;
-    return removed;
-}

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

@@ -1,18 +0,0 @@
-/**
- * Returns a random element from an array.
- *
- * This function takes an array and returns a single element selected randomly from the array.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The array to sample from.
- * @returns {T} A random element from the array.
- *
- * @example
- * const array = [1, 2, 3, 4, 5];
- * const randomElement = sample(array);
- * // randomElement will be one of the elements from the array, selected randomly.
- */
-export function sample(arr) {
-    const randomIndex = Math.floor(Math.random() * arr.length);
-    return arr[randomIndex];
-}

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

@@ -1,35 +0,0 @@
-import { randomInt } from '../math/randomInt.js';
-/**
- * Returns a sample element array of a specified `size`.
- *
- * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm.
- *
- * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algorithm}
- *
- * @template T - The type of elements in the array.
- * @param {T[]} array - The array to sample from.
- * @param {number} size - The size of sample.
- * @returns {T[]} A new array with sample size applied.
- * @throws {Error} Throws an error if `size` is greater than the length of `array`.
- *
- * @example
- * const result = sampleSize([1, 2, 3], 2)
- * // result will be an array containing two of the elements from the array.
- * // [1, 2] or [1, 3] or [2, 3]
- */
-export function sampleSize(array, size) {
-    if (size > array.length) {
-        throw new Error('Size must be less than or equal to the length of array.');
-    }
-    const result = new Array(size);
-    const selected = new Set();
-    for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) {
-        let index = randomInt(0, step + 1);
-        if (selected.has(index)) {
-            index = step;
-        }
-        selected.add(index);
-        result[resultIndex] = array[index];
-    }
-    return result;
-}