@catbee/utils 1.1.0 → 2.0.0-next.1

package/array/index.d.ts

@@ -0,0 +1,317 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * Splits an array into chunks of the specified size.
+ *
+ * @template T The type of array elements.
+ * @param {T[]} array - The array to split into chunks.
+ * @param {number} size - The number of elements per chunk.
+ * @returns {T[][]} A new array containing chunked arrays.
+ * @throws {TypeError} If array is not an array.
+ * @throws {Error} If chunk size is not a positive integer.
+ */
+declare function chunk<T>(array: readonly T[], size: number): T[][];
+/**
+ * Removes duplicate values from an array.
+ * Optionally enforces uniqueness by a key function.
+ *
+ * @template T The type of array elements.
+ * @param {T[]} array - The input array.
+ * @param {(item: T) => unknown} [keyFn] - Optional function to determine uniqueness by key.
+ * @returns {T[]} A new array with unique values.
+ */
+declare function unique<T>(array: readonly T[], keyFn?: (item: T) => unknown): T[];
+/**
+ * Deeply flattens a nested array to a single-level array (iterative, stack-based).
+ *
+ * @template T The leaf type of array elements.
+ * @param {readonly unknown[]} array - The (possibly deeply nested) input array.
+ * @returns {T[]} A deeply flattened array.
+ */
+declare function flattenDeep<T>(array: readonly unknown[]): T[];
+/**
+ * Returns a random element from an array, or undefined if empty. Uses crypto-secure randomness
+ *
+ * @template T The type of array elements.
+ * @param {T[]} array - The input array.
+ * @returns {T | undefined} A randomly selected item, or undefined if array is empty or not an array.
+ *
+ * @example
+ * ```ts
+ * securePick(['a','b','c']); // -> 'b'
+ * ```
+ */
+declare function random<T>(array: readonly T[]): T | undefined;
+/**
+ * Groups items in an array by a nested key or key function.
+ *
+ * @template T The type of array elements.
+ * @overload
+ * @param {T[]} array - The array to group.
+ * @param {keyof T} key - Property key to group by.
+ * @returns {Record<string, readonly T[]>}
+ * @overload
+ * @param {T[]} array - The array to group.
+ * @param {(item: T) => string | number | symbol} keyFn - Function to generate group key from item.
+ * @returns {Record<K, readonly T[]>}
+ * @param {T[]} array - The array to group.
+ * @param {keyof T | ((item: T) => string | number | symbol)} keyOrFn - Nested property key or key selector.
+ * @returns {Record<string | number | symbol, readonly T[]>} Grouped result object.
+ */
+declare function groupBy<T>(array: T[], key: keyof T): Record<string, readonly T[]>;
+declare function groupBy<T, K extends string | number | symbol>(array: T[], keyFn: (item: T) => K): Record<K, readonly T[]>;
+/**
+ * Shuffles an array using the Fisher-Yates algorithm. Uses crypto-secure randomness.
+ *
+ * @template T The type of array elements.
+ * @param {T[]} array - The input array.
+ * @returns {T[]} A new shuffled array.
+ * @throws {TypeError} If array is not an array.
+ */
+declare function shuffle<T>(array: readonly T[]): T[];
+/**
+ * Returns an array of property values from an array of objects. Returns undefined for missing properties.
+ *
+ * @template T The type of array elements.
+ * @template K The object property to pluck.
+ * @param {T[]} array - The input array.
+ * @param {K} key - The property name to pluck.
+ * @returns {T[K][]} Array of property values.
+ */
+declare function pluck<T, K extends keyof T>(array: readonly T[], key: K): T[K][];
+/**
+ * Returns values in array A that are not in array B.
+ *
+ * @template T The type of array elements.
+ * @param {T[]} a - First array.
+ * @param {T[]} b - Second array.
+ * @returns {T[]} Elements in A that are not in B.
+ */
+declare function difference<T>(a: readonly T[], b: readonly T[]): T[];
+/**
+ * Returns common values between arrays A and B.
+ *
+ * @template T The type of array elements.
+ * @param {T[]} a - First array.
+ * @param {T[]} b - Second array.
+ * @returns {T[]} Elements that exist in both arrays.
+ */
+declare function intersect<T>(a: readonly T[], b: readonly T[]): T[];
+/**
+ * Sorts an array of objects by a nested key using Merge Sort (O(n log n)).
+ * Missing/undefined keys are sorted to the "end" (asc) or "start" (desc").
+ * Optionally accepts a custom compare function or collator.
+ *
+ * @template T The type of array elements (objects).
+ * @param {T[]} array - Array of objects to sort.
+ * @param {string | ((item: T) => any)} key - Dot-notated key (e.g., "profile.age") or function.
+ * @param {"asc" | "desc"} [direction="asc"] - Sort direction: 'asc' or 'desc'.
+ * @param {(a: T, b: T) => number} [compareFn] - Optional custom compare function.
+ * @returns {T[]} A new sorted array.
+ * @throws {TypeError} If array is not an array.
+ */
+declare function mergeSort<T>(array: readonly T[], key: string | ((item: T) => unknown), direction?: 'asc' | 'desc', compareFn?: (a: T, b: T) => number): T[];
+/**
+ * Combines multiple arrays into a single array of grouped elements.
+ * Output length equals the length of the shortest input array.
+ *
+ * This implementation ensures type safety and avoids holes in output.
+ *
+ * @example
+ * ```ts
+ * zip([1, 2], ['a', 'b']) => [[1, 'a'], [2, 'b']]
+ * ```
+ * @param {...Array<T>[]} arrays - Two or more arrays to zip together.
+ * @returns {Array<T[]>} Array of grouped elements.
+ */
+declare function zip<T>(...arrays: ReadonlyArray<T>[]): T[][];
+/**
+ * Splits an array into two arrays based on a predicate function.
+ * Supports type-guard narrowing via overload.
+ *
+ * @template T The type of array elements.
+ * @overload
+ * @param {readonly T[]} array - The input array.
+ * @param {(item: T, index: number, array: readonly T[]) => item is U} predicate - Type guard predicate.
+ * @returns {[U[], Exclude<T, U>[]]} A tuple of two arrays: [matched, unmatched].
+ * @overload
+ * @param {readonly T[]} array - The input array.
+ * @param {(item: T, index: number, array: readonly T[]) => boolean} predicate - Boolean predicate.
+ * @returns {[T[], T[]]} A tuple of two arrays: [matched, unmatched].
+ */
+declare function partition<T, U extends T>(array: readonly T[], predicate: (item: T, index: number, array: readonly T[]) => item is U): [U[], Exclude<T, U>[]];
+declare function partition<T>(array: readonly T[], predicate: (item: T, index: number, array: readonly T[]) => boolean): [T[], T[]];
+/**
+ * Generates an array of numbers within a specified range.
+ *
+ * @param {number} start - Start of range (inclusive).
+ * @param {number} end - End of range (exclusive).
+ * @param {number} [step=1] - Step between numbers.
+ * @returns {number[]} Array of numbers in range.
+ */
+declare function range(start: number, end: number, step?: number): number[];
+/**
+ * Returns the first `n` elements from an array.
+ *
+ * @template T The type of array elements.
+ * @param {T[]} array - The input array.
+ * @param {number} [n=1] - Number of elements to take.
+ * @returns {T[]} New array with first n elements.
+ */
+declare function take<T>(array: readonly T[], n?: number): T[];
+/**
+ * Takes elements from an array while predicate returns true.
+ *
+ * @template T The type of array elements.
+ * @param {readonly T[]} array - Input array.
+ * @param {(item: T, index: number) => boolean} predicate - Condition function.
+ * @returns {T[]} New array with taken elements.
+ *
+ * @example
+ * ```ts
+ * takeWhile([1,2,3,4], (n) => n < 3); // -> [1,2]
+ * ```
+ */
+declare function takeWhile<T>(array: readonly T[], predicate: (item: T, index: number) => boolean): T[];
+/**
+ * Removes all falsy values from an array.
+ * `false`, `null`, `0`, `""`, `undefined`, and `NaN` are falsy.
+ *
+ * @template T The type of array elements.
+ * @param {T[]} array - The input array.
+ * @returns {NonNullable<T>[]} New array with falsy values removed.
+ */
+declare function compact<T>(array: readonly T[]): NonNullable<T>[];
+/**
+ * Counts array elements by a key function.
+ *
+ * @template T The type of array elements.
+ * @param {T[]} array - The input array.
+ * @param {(item: T) => string | number | symbol} keyFn - Function to generate count key.
+ * @returns {Record<string, number>} Object with counts by key.
+ */
+declare function countBy<T>(array: readonly T[], keyFn: (item: T) => string | number | symbol): Record<string, number>;
+/**
+ * Toggles an item in array (adds if not present, removes if present).
+ *
+ * @template T
+ * @param {readonly T[]} array
+ * @param {T} item
+ * @returns {T[]} New array with item toggled.
+ *
+ * @example
+ * ```ts
+ * toggle([1,2,3], 2); // -> [1,3]
+ * toggle([1,3], 2); // -> [1,3,2]
+ * ```
+ */
+declare function toggle<T>(array: readonly T[], item: T): T[];
+/**
+ * Returns a cryptographically secure random index for an array.
+ * Used internally for secure pick/shuffle operations.
+ *
+ * @param {number} max Upper bound (exclusive).
+ * @returns {number} A secure random integer in range `[0, max)`.
+ * @throws {RangeError} If `max` is not a positive number.
+ *
+ * @example
+ * ```ts
+ * secureIndex(10); // -> 3 (unpredictable)
+ * ```
+ */
+declare function secureIndex(max: number): number;
+/**
+ * Returns a secure random element from an array using Node crypto.
+ *
+ * @template T
+ * @param {readonly T[]} array
+ * @returns {T | undefined}
+ */
+declare const secureRandom: <T>(array: readonly T[]) => T | undefined;
+/**
+ * Returns the last element in the array that satisfies the provided testing function.
+ *
+ * @template T
+ * @param {readonly T[]} array - The input array.
+ * @param {(item: T, index: number, array: readonly T[]) => boolean} predicate - Function to test each element.
+ * @returns {T | undefined} The found element, or undefined if not found.
+ */
+declare function findLast<T>(array: readonly T[], predicate: (item: T, index: number, array: readonly T[]) => boolean): T | undefined;
+/**
+ * Returns the index of the last element in the array that satisfies the provided testing function.
+ *
+ * @template T
+ * @param {readonly T[]} array - The input array.
+ * @param {(item: T, index: number, array: readonly T[]) => boolean} predicate - Function to test each element.
+ * @returns {number} The index, or -1 if not found.
+ */
+declare function findLastIndex<T>(array: readonly T[], predicate: (item: T, index: number, array: readonly T[]) => boolean): number;
+/**
+ * Splits an array into chunks based on a predicate function.
+ * Each chunk starts when predicate returns true.
+ *
+ * @template T
+ * @param {readonly T[]} array - The input array.
+ * @param {(item: T, index: number, array: readonly T[]) => boolean} predicate - Function to determine chunk boundaries.
+ * @returns {T[][]} Array of chunked arrays.
+ */
+declare function chunkBy<T>(array: readonly T[], predicate: (item: T, index: number, array: readonly T[]) => boolean): T[][];
+/**
+ * Removes all occurrences of a value from an array.
+ *
+ * @template T
+ * @param {readonly T[]} array - The input array.
+ * @param {T} value - Value to remove.
+ * @returns {T[]} New array with value removed.
+ */
+declare function remove<T>(array: readonly T[], value: T): T[];
+/**
+ * Checks if an array is sorted in ascending or descending order.
+ *
+ * @template T
+ * @param {readonly T[]} array - The input array.
+ * @param {'asc' | 'desc'} [direction='asc'] - Sort direction.
+ * @param {(a: T, b: T) => number} [compareFn] - Optional compare function.
+ * @returns {boolean} True if sorted, false otherwise.
+ */
+declare function isSorted<T>(array: readonly T[], direction?: 'asc' | 'desc', compareFn?: (a: T, b: T) => number): boolean;
+/**
+ * Returns the first element of an array, or undefined if empty.
+ *
+ * @template T
+ * @param {readonly T[]} array
+ * @returns {T | undefined}
+ */
+declare function headOfArr<T>(array: readonly T[]): T | undefined;
+/**
+ * Returns the last element of an array, or undefined if empty.
+ *
+ * @template T
+ * @param {readonly T[]} array
+ * @returns {T | undefined}
+ */
+declare function lastOfArr<T>(array: readonly T[]): T | undefined;
+
+export { chunk, chunkBy, compact, countBy, difference, findLast, findLastIndex, flattenDeep, groupBy, headOfArr, intersect, isSorted, lastOfArr, mergeSort, partition, pluck, random, range, remove, secureIndex, secureRandom, shuffle, take, takeWhile, toggle, unique, zip };

package/array/index.mjs

@@ -0,0 +1,327 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { getValueByPath } from '@catbee/utils/obj';
+import { randomBytes } from 'crypto';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function chunk(array, size) {
+  if (!Array.isArray(array)) throw new TypeError("Expected an array");
+  if (array.length === 0) return [];
+  if (!Number.isInteger(size) || size <= 0) throw new Error("Chunk size must be a positive integer");
+  const result = [];
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+}
+__name(chunk, "chunk");
+function unique(array, keyFn) {
+  if (!Array.isArray(array) || array.length === 0) return [];
+  if (!keyFn) return Array.from(new Set(array));
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const item of array) {
+    const key = keyFn(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(item);
+    }
+  }
+  return result;
+}
+__name(unique, "unique");
+function flattenDeep(array) {
+  if (!Array.isArray(array)) return [];
+  const result = [];
+  const stack = [
+    ...array
+  ];
+  while (stack.length) {
+    const val = stack.pop();
+    if (Array.isArray(val)) {
+      stack.push(...val);
+    } else {
+      result.push(val);
+    }
+  }
+  return result.reverse();
+}
+__name(flattenDeep, "flattenDeep");
+function random(array) {
+  if (!Array.isArray(array) || array.length === 0) return void 0;
+  return array[secureIndex(array.length)];
+}
+__name(random, "random");
+function groupBy(array, keyOrFn) {
+  if (!Array.isArray(array) || array.length === 0) return {};
+  const keyFn = typeof keyOrFn === "function" ? keyOrFn : (item) => String(getValueByPath(item, keyOrFn));
+  const result = {};
+  for (const item of array) {
+    const key = String(keyFn(item));
+    if (Object.hasOwn?.(result, key) ?? Object.prototype.hasOwnProperty.call(result, key)) {
+      result[key].push(item);
+    } else {
+      result[key] = [
+        item
+      ];
+    }
+  }
+  return Object.fromEntries(Object.entries(result).map(([k, v]) => [
+    k,
+    v
+  ]));
+}
+__name(groupBy, "groupBy");
+function shuffle(array) {
+  if (!Array.isArray(array)) throw new TypeError("Expected an array");
+  const copy = array.slice();
+  for (let i = copy.length - 1; i > 0; i--) {
+    const j = secureIndex(i + 1);
+    [copy[i], copy[j]] = [
+      copy[j],
+      copy[i]
+    ];
+  }
+  return copy;
+}
+__name(shuffle, "shuffle");
+function pluck(array, key) {
+  if (!Array.isArray(array)) return [];
+  return array.map((item) => item?.[key]);
+}
+__name(pluck, "pluck");
+function difference(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) return [];
+  const setB = new Set(b);
+  return a.filter((item) => !setB.has(item));
+}
+__name(difference, "difference");
+function intersect(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) return [];
+  const setB = new Set(b);
+  return a.filter((item) => setB.has(item));
+}
+__name(intersect, "intersect");
+function mergeSort(array, key, direction = "asc", compareFn) {
+  if (!Array.isArray(array)) throw new TypeError("Expected array");
+  const arr = array.slice();
+  if (arr.length <= 1) return arr;
+  const keyFn = typeof key === "function" ? key : (item) => getValueByPath(item, key);
+  const collator = new Intl.Collator("en", {
+    numeric: true
+  });
+  const compare = compareFn ?? function(a, b) {
+    const aVal = keyFn(a);
+    const bVal = keyFn(b);
+    if (aVal === bVal) return 0;
+    if (aVal == null) return direction === "asc" ? 1 : -1;
+    if (bVal == null) return direction === "asc" ? -1 : 1;
+    return direction === "asc" ? collator.compare(String(aVal), String(bVal)) : collator.compare(String(bVal), String(aVal));
+  };
+  const merge = /* @__PURE__ */ __name((left, right) => {
+    const result = [];
+    let i = 0, j = 0;
+    while (i < left.length && j < right.length) {
+      result.push(compare(left[i], right[j]) <= 0 ? left[i++] : right[j++]);
+    }
+    while (i < left.length) result.push(left[i++]);
+    while (j < right.length) result.push(right[j++]);
+    return result;
+  }, "merge");
+  const sort = /* @__PURE__ */ __name((input) => {
+    const len = input.length;
+    if (len <= 1) return input;
+    const mid = len >> 1;
+    const left = sort(input.slice(0, mid));
+    const right = sort(input.slice(mid));
+    return merge(left, right);
+  }, "sort");
+  return sort(arr);
+}
+__name(mergeSort, "mergeSort");
+function zip(...arrays) {
+  if (arrays.length === 0) return [];
+  if (arrays.some((arr) => !Array.isArray(arr))) {
+    throw new TypeError("All arguments must be arrays");
+  }
+  const minLength = Math.min(...arrays.map((arr) => arr.length));
+  const result = [];
+  for (let i = 0; i < minLength; i++) {
+    result.push(arrays.map((arr) => arr[i]));
+  }
+  return result;
+}
+__name(zip, "zip");
+function partition(array, predicate) {
+  const pass = [];
+  const fail = [];
+  if (!Array.isArray(array)) return [
+    pass,
+    fail
+  ];
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+    (predicate(item, i, array) ? pass : fail).push(item);
+  }
+  return [
+    pass,
+    fail
+  ];
+}
+__name(partition, "partition");
+function range(start, end, step = 1) {
+  if (!Number.isFinite(start) || !Number.isFinite(end) || !Number.isFinite(step)) {
+    throw new TypeError("Arguments must be finite numbers");
+  }
+  if (step === 0) throw new Error("Step cannot be zero");
+  const result = [];
+  if (step > 0) {
+    for (let i = start; i < end; i += step) result.push(i);
+  } else {
+    for (let i = start; i > end; i += step) result.push(i);
+  }
+  return result;
+}
+__name(range, "range");
+function take(array, n = 1) {
+  if (!Array.isArray(array) || n <= 0) return [];
+  return n >= array.length ? array.slice() : array.slice(0, n);
+}
+__name(take, "take");
+function takeWhile(array, predicate) {
+  const result = [];
+  if (!Array.isArray(array)) return result;
+  const len = array.length;
+  for (let i = 0; i < len; i++) {
+    const item = array[i];
+    if (!predicate(item, i)) break;
+    result.push(item);
+  }
+  return result;
+}
+__name(takeWhile, "takeWhile");
+function compact(array) {
+  if (!Array.isArray(array)) return [];
+  const result = [];
+  for (const v of array) {
+    if (v) result.push(v);
+  }
+  return result;
+}
+__name(compact, "compact");
+function countBy(array, keyFn) {
+  if (!Array.isArray(array)) return {};
+  const result = {};
+  for (const item of array) {
+    const key = String(keyFn(item));
+    result[key] = (result[key] ?? 0) + 1;
+  }
+  return result;
+}
+__name(countBy, "countBy");
+function toggle(array, item) {
+  if (!Array.isArray(array)) return [
+    item
+  ];
+  const exists = array.includes(item);
+  if (exists) return array.filter((x) => x !== item);
+  return [
+    ...array,
+    item
+  ];
+}
+__name(toggle, "toggle");
+function secureIndex(max) {
+  if (!Number.isInteger(max) || max <= 0) throw new RangeError("Max must be a positive integer");
+  const limit = 4294967295 - 4294967295 % max;
+  let rand;
+  do {
+    rand = randomBytes(4).readUInt32BE(0);
+  } while (rand >= limit);
+  return rand % max;
+}
+__name(secureIndex, "secureIndex");
+var secureRandom = /* @__PURE__ */ __name((array) => {
+  if (!Array.isArray(array) || array.length === 0) return void 0;
+  const idx = secureIndex(array.length);
+  return array[idx];
+}, "secureRandom");
+function findLast(array, predicate) {
+  if (!Array.isArray(array)) return void 0;
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i], i, array)) return array[i];
+  }
+  return void 0;
+}
+__name(findLast, "findLast");
+function findLastIndex(array, predicate) {
+  if (!Array.isArray(array)) return -1;
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i], i, array)) return i;
+  }
+  return -1;
+}
+__name(findLastIndex, "findLastIndex");
+function chunkBy(array, predicate) {
+  if (!Array.isArray(array) || array.length === 0) return [];
+  const result = [];
+  let chunk2 = [];
+  for (let i = 0; i < array.length; i++) {
+    if (predicate(array[i], i, array) && chunk2.length) {
+      result.push(chunk2);
+      chunk2 = [];
+    }
+    chunk2.push(array[i]);
+  }
+  if (chunk2.length) result.push(chunk2);
+  return result;
+}
+__name(chunkBy, "chunkBy");
+function remove(array, value) {
+  if (!Array.isArray(array)) return [];
+  return array.filter((item) => item !== value);
+}
+__name(remove, "remove");
+function isSorted(array, direction = "asc", compareFn) {
+  if (!Array.isArray(array) || array.length <= 1) return true;
+  const cmp = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  for (let i = 1; i < array.length; i++) {
+    const res = cmp(array[i - 1], array[i]);
+    if (direction === "asc" && res > 0 || direction === "desc" && res < 0) return false;
+  }
+  return true;
+}
+__name(isSorted, "isSorted");
+function headOfArr(array) {
+  return Array.isArray(array) && array.length > 0 ? array[0] : void 0;
+}
+__name(headOfArr, "headOfArr");
+function lastOfArr(array) {
+  return Array.isArray(array) && array.length > 0 ? array.at(-1) : void 0;
+}
+__name(lastOfArr, "lastOfArr");
+
+export { chunk, chunkBy, compact, countBy, difference, findLast, findLastIndex, flattenDeep, groupBy, headOfArr, intersect, isSorted, lastOfArr, mergeSort, partition, pluck, random, range, remove, secureIndex, secureRandom, shuffle, take, takeWhile, toggle, unique, zip };