@stacksjs/arrays 0.70.88 → 0.70.91

package/dist/arr.d.ts

@@ -0,0 +1,3 @@
+export * from './contains';
+export * from './helpers';
+export * from './math';

package/dist/arr.js

@@ -0,0 +1,3 @@
+export * from "./contains";
+export * from "./helpers";
+export * from "./math";

package/dist/contains.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Returns true if the needle is contained in the haystack.
+ *
+ * @param needle
+ * @param haystack
+ * @example
+ * ```ts
+ * contains('foo', ['foo', 'bar']) // true
+ * contains('foo', ['bar']) // false
+ * ```
+ */
+export declare function contains(needle: string, haystack: string[]): boolean;
+/**
+ * Returns true if all needles are contained in the haystack.
+ * @param needles
+ * @param haystack
+ * @example
+ * ```ts
+ * containsAll(['foo', 'bar'], ['foo', 'bar', 'baz']) // true
+ * containsAll(['foo', 'bar'], ['foo', 'baz']) // false
+ * ```
+ */
+export declare function containsAll(needles: string[], haystack: string[]): boolean;
+/**
+ * Returns true if any needle is contained in the haystack.
+ * @param needles
+ * @param haystack
+ * @example
+ * ```ts
+ * containsAny(['foo', 'bar'], ['foo', 'bar', 'baz']) // true
+ * containsAny(['foo', 'bar'], ['foo', 'baz']) // true
+ * containsAny(['foo', 'bar'], ['baz']) // false
+ * ```
+ */
+export declare function containsAny(needles: string[], haystack: string[]): boolean;
+/**
+ * Returns true if none of the needles are contained in the haystack.
+ * @param needles
+ * @param haystack
+ * @example
+ * ```ts
+ * containsNone(['foo', 'bar'], ['foo', 'bar', 'baz']) // false
+ * containsNone(['foo', 'bar'], ['foo', 'baz']) // false
+ * containsNone(['foo', 'bar'], ['baz']) // true
+ * ```
+ */
+export declare function containsNone(needles: string[], haystack: string[]): boolean;
+/**
+ * Returns true if all needles are contained in the haystack.
+ * @param needles
+ * @param haystack
+ * @example
+ * ```ts
+ * containsOnly(['foo', 'bar'], ['foo', 'bar', 'baz']) // false
+ * containsOnly(['foo', 'bar'], ['foo', 'baz']) // false
+ * containsOnly(['foo', 'bar'], ['foo', 'bar']) // true
+ * ```
+ */
+export declare function containsOnly(needles: string[], haystack: string[]): boolean;
+/**
+ * Returns true if the needle is not contained in the haystack.
+ * @param needle
+ * @param haystack
+ * @example
+ * ```ts
+ * doesNotContain('foo', ['foo', 'bar']) // false
+ * doesNotContain('foo', ['bar']) // true
+ * ```
+ */
+export declare function doesNotContain(needle: string, haystack: string[]): boolean;

package/dist/contains.js

@@ -0,0 +1,18 @@
+export function contains(needle, haystack) {
+  return haystack.some((hay) => needle.includes(hay));
+}
+export function containsAll(needles, haystack) {
+  return needles.every((needle) => contains(needle, haystack));
+}
+export function containsAny(needles, haystack) {
+  return needles.some((needle) => contains(needle, haystack));
+}
+export function containsNone(needles, haystack) {
+  return !containsAny(needles, haystack);
+}
+export function containsOnly(needles, haystack) {
+  return containsAll(haystack, needles);
+}
+export function doesNotContain(needle, haystack) {
+  return !contains(needle, haystack);
+}

package/dist/helpers.d.ts

@@ -0,0 +1,178 @@
+import type { Arrayable, Nullable } from '@stacksjs/types';
+/**
+ * Convert `Arrayable<T>` to `Array<T>`
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * toArray('foo') // ['foo']
+ * toArray(['foo']) // ['foo']
+ * toArray(null) // []
+ * toArray(undefined) // []
+ * toArray(1) // [1]
+ * toArray([1]) // [1]
+ * toArray({ foo: 'bar' }) // [{ foo: 'bar' }]
+ * toArray([{ foo: 'bar' }]) // [{ foo: 'bar' }]
+ * ```
+ */
+export declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
+/**
+ * Flatten `Arrayable<T>` to `Array<T>`
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * flatten([1, [2, [3, [4, [5]]]]]) // [1, 2, 3, 4, 5]
+ * ```
+ */
+export declare function flatten<T>(array?: Nullable<Arrayable<T | T[]>>): T[];
+/**
+ * Use rest arguments to merge arrays
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * mergeArrayable([1, 2], [3, 4], [5, 6]) // [1, 2, 3, 4, 5, 6]
+ * ```
+ */
+export declare function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T>;
+/**
+ * Divide an array into two parts by a filter function
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * const [odd, even] = partition([1, 2, 3, 4], i => i % 2 != 0)
+ * console.log(odd) // [1, 3]
+ * console.log(even) // [2, 4]
+ * ```
+ */
+export declare function partition<T>(array: readonly T[], _f1: PartitionFilter<T>): [T[], T[]];
+export declare function partition<T>(array: readonly T[], _f1: PartitionFilter<T>, _f2: PartitionFilter<T>): [T[], T[], T[]];
+export declare function partition<T>(array: readonly T[], _f1: PartitionFilter<T>, _f2: PartitionFilter<T>, _f3: PartitionFilter<T>): [T[], T[], T[], T[]];
+export declare function partition<T>(array: readonly T[], _f1: PartitionFilter<T>, _f2: PartitionFilter<T>, _f3: PartitionFilter<T>, _f4: PartitionFilter<T>): [T[], T[], T[], T[], T[]];
+export declare function partition<T>(array: readonly T[], _f1: PartitionFilter<T>, _f2: PartitionFilter<T>, _f3: PartitionFilter<T>, _f4: PartitionFilter<T>, _f5: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[]];
+export declare function partition<T>(array: readonly T[], _f1: PartitionFilter<T>, _f2: PartitionFilter<T>, _f3: PartitionFilter<T>, _f4: PartitionFilter<T>, _f5: PartitionFilter<T>, _f6: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[], T[]];
+/**
+ * Unique an Array
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * uniq([1, 2, 3, 3, 2, 1]) // [1, 2, 3]
+ * ```
+ */
+export declare function uniq<T>(array: readonly T[]): T[];
+/**
+ * Unique an Array
+ *
+ * @param array
+ * @example
+ * ```ts
+ * unique([1, 2, 3, 3, 2, 1]) // [1, 2, 3]
+ * ```
+ */
+export declare function unique<T>(array: readonly T[]): T[];
+/**
+ * Unique an Array by a custom equality function
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * uniqueBy([1, 2, 3, 3, 2, 1], (a, b) => a === b) // [1, 2, 3]
+ * ```
+ */
+export declare function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[];
+/**
+ * Get last item
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * last([1, 2, 3]) // 3
+ * ```
+ */
+export declare function last(array: readonly []): undefined;
+export declare function last<T>(array: readonly T[]): T;
+/**
+ * Remove an item from Array.
+ *
+ * **Mutates the input array** via splice — the original reference shrinks
+ * by one element. If you need a non-destructive version, use
+ * `array.filter(x => x !== value)` instead.
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3]
+ * remove(arr, 2) // true
+ * Arr.remove(arr, 4) // false
+ * console.log(arr) // [1, 3]
+ */
+export declare function remove<T>(array: T[], value: T): boolean;
+/**
+ * Get nth item of Array. Negative for backward
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * at([1, 2, 3], 1) // 2
+ * at([1, 2, 3], -1) // 3
+ * at([1, 2, 3], 3) // undefined
+ * at([1, 2, 3], -4) // undefined
+ * ```
+ */
+export declare function at(array: readonly [], index: number): undefined;
+export declare function at<T>(array: readonly T[], index: number): T;
+/**
+ * Move an item from one index to another
+ * @param array
+ * @param from
+ * @param to
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * move([1, 2, 3, 4], 0, 2) // [2, 3, 1, 4]
+ * move([1, 2, 3, 4], 0, -1) // [2, 3, 4, 1]
+ * move([1, 2, 3, 4], -1, 0) // [4, 1, 2, 3]
+ * move([1, 2, 3, 4], -1, -2) // [1, 4, 2, 3]
+ * move([1, 2, 3, 4], 1, 1) // [1, 2, 3, 4]
+ * ```
+ */
+export declare function move<T>(array: T[], from: number, to: number): T[];
+/**
+ * Clamp a number to the index range of an array.
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * clampArrayRange([1, 2, 3], 0) // 0
+ * clampArrayRange([1, 2, 3], 1) // 1
+ * clampArrayRange([1, 2, 3], 2) // 2
+ * clampArrayRange([1, 2, 3], 3) // 2
+ * clampArrayRange([1, 2, 3], 4) // 2
+ * clampArrayRange([1, 2, 3], -1) // 0
+ */
+export declare function clampArrayRange(arr: readonly unknown[], n: number): number;
+/**
+ * Get random items from an array
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * sample([1, 2, 3, 4], 2) // [2, 3]
+ * ```
+ */
+export declare function sample<T>(arr: T[], count: number): T[];
+/**
+ * Shuffle an array. This function mutates the array.
+ *
+ * @category Array
+ * @example
+ * ```ts
+ * shuffle([1, 2, 3, 4]) // [2, 4, 1, 3]
+ * ```
+ */
+export declare function shuffle<T>(array: T[]): T[];
+export type PartitionFilter<T> = (_i: T, _idx: number, _arr: readonly T[]) => any;

package/dist/helpers.js

@@ -0,0 +1,85 @@
+import { clamp } from "@stacksjs/utils";
+export function toArray(array) {
+  array = array ?? [];
+  return Array.isArray(array) ? array : [array];
+}
+export function flatten(array) {
+  return toArray(array).reduce((acc, val) => acc.concat(Array.isArray(val) ? flatten(val) : val), []);
+}
+export function mergeArrayable(...args) {
+  return args.flatMap((i) => toArray(i));
+}
+export function partition(array, ...filters) {
+  const result = Array.from({ length: filters.length + 1 }).fill(null).map(() => []);
+  array.forEach((e, idx, arr) => {
+    let i = 0;
+    for (const filter of filters) {
+      if (filter(e, idx, arr)) {
+        result[i].push(e);
+        return;
+      }
+      i += 1;
+    }
+    result[i].push(e);
+  });
+  return result;
+}
+export function uniq(array) {
+  return Array.from(new Set(array));
+}
+export function unique(array) {
+  return uniq(array);
+}
+export function uniqueBy(array, equalFn) {
+  return array.reduce((acc, cur) => {
+    if (acc.findIndex((item) => equalFn(cur, item)) === -1)
+      acc.push(cur);
+    return acc;
+  }, []);
+}
+export function last(array) {
+  return at(array, -1);
+}
+export function remove(array, value) {
+  if (!array)
+    return !1;
+  const index = array.indexOf(value);
+  if (index >= 0) {
+    array.splice(index, 1);
+    return !0;
+  }
+  return !1;
+}
+export function at(array, index) {
+  const len = array.length;
+  if (!len)
+    return;
+  if (index < 0)
+    index += len;
+  return array[index];
+}
+export function move(array, from, to) {
+  const len = array.length;
+  if (!len)
+    return [];
+  if (from < 0)
+    from += len;
+  if (to < 0)
+    to += len;
+  const item = array.splice(from, 1)[0];
+  array.splice(to, 0, item);
+  return array;
+}
+export function clampArrayRange(arr, n) {
+  return clamp(n, 0, arr.length - 1);
+}
+export function sample(arr, count) {
+  return Array.from({ length: count }, () => arr[Math.floor(Math.random() * arr.length)]);
+}
+export function shuffle(array) {
+  for (let i = array.length - 1;i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './arr';
+export * as arr from './arr';
+export * from './macro';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./arr";
+export * as arr from "./arr";
+export * from "./macro";

package/dist/macro.d.ts

@@ -0,0 +1,48 @@
+/** @defaultValue `{ random<T>: () => unknown, uniqueBy<T>: () => unknown }` */
+export declare const Arr: {
+  contains: (needle: string, haystack: string[]) => boolean;
+  containsAll: (needles: string[], haystack: string[]) => boolean;
+  containsAny: (needles: string[], haystack: string[]) => boolean;
+  containsNone: (needles: string[], haystack: string[]) => boolean;
+  containsOnly: (needles: string[], haystack: string[]) => boolean;
+  doesNotContain: (needle: string, haystack: string[]) => boolean;
+  toArray<T>: (array?: Nullable<Arrayable<T>>) => Array<T>;
+  flatten<T>: (array?: Nullable<Arrayable<T | T[]>>) => T[];
+  mergeArrayable<T>: (...args: Nullable<Arrayable<T>>[]) => Array<T>;
+  partition<T>: (array: readonly T[], filter: PartitionFilter<T>) => [T[], T[]];
+  /**
+   * Returns a random item/s from the array
+   */
+  random<T>: (arr: T[], count?: number) => T[];
+  /**
+   * Returns random item/s from the array
+   */
+  sample<T>: (arr: T[], count?: number) => T[];
+  unique<T>: (arr: T[]) => T[];
+  uniqueBy<T>: (arr: readonly T[], equalFn: (a: any, b: any) => boolean) => T[];
+  last<T>: (arr: T[]) => T | undefined;
+  remove<T>: (arr: T[], value: T) => boolean;
+  at: (arr: any[], index: number) => any;
+  range: (arr: readonly number[]) => number;
+  move<T>: (arr: T[], from: number, to: number) => T[];
+  clampArrayRange: (arr: readonly unknown[], n: number) => number;
+  shuffle<T>: (arr: T[]) => T[];
+  /**
+   * Returns the sum of all items in the array
+   */
+  sum: (arr: number[]) => number;
+  /**
+   * Returns the average of all items in the array
+   */
+  average: (arr: number[]) => number;
+  avg: (arr: number[]) => number;
+  /**
+   * Returns the median of all items in the array
+   */
+  median: (arr: number[]) => number;
+  /**
+   * Returns the mode of all items in the array
+   */
+  mode: (arr: number[]) => number
+};
+export declare const arr: typeof Arr;

package/dist/macro.js

@@ -0,0 +1,97 @@
+import { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from "./contains";
+import {
+  at,
+  clampArrayRange,
+  flatten,
+  last,
+  mergeArrayable,
+  move,
+  partition,
+  remove,
+  sample,
+  shuffle,
+  toArray,
+  uniq,
+  uniqueBy
+} from "./helpers";
+import { average, median, mode, range, sum } from "./math";
+export const Arr = {
+  contains(needle, haystack) {
+    return contains(needle, haystack);
+  },
+  containsAll(needles, haystack) {
+    return containsAll(needles, haystack);
+  },
+  containsAny(needles, haystack) {
+    return containsAny(needles, haystack);
+  },
+  containsNone(needles, haystack) {
+    return containsNone(needles, haystack);
+  },
+  containsOnly(needles, haystack) {
+    return containsOnly(needles, haystack);
+  },
+  doesNotContain(needle, haystack) {
+    return doesNotContain(needle, haystack);
+  },
+  toArray(array) {
+    return toArray(array);
+  },
+  flatten(array) {
+    return flatten(array);
+  },
+  mergeArrayable(...args) {
+    return mergeArrayable(...args);
+  },
+  partition(array, filter) {
+    return partition(array, filter);
+  },
+  random(arr, count = 1) {
+    return sample(arr, count).filter((item) => item != null);
+  },
+  sample(arr, count = 1) {
+    return sample(arr, count);
+  },
+  unique(arr) {
+    return uniq(arr);
+  },
+  uniqueBy(arr, equalFn) {
+    return uniqueBy(arr, equalFn);
+  },
+  last(arr) {
+    return last(arr);
+  },
+  remove(arr, value) {
+    return remove(arr, value);
+  },
+  at(arr, index) {
+    return at(arr, index);
+  },
+  range(arr) {
+    return range(arr);
+  },
+  move(arr, from, to) {
+    return move(arr, from, to);
+  },
+  clampArrayRange(arr, n) {
+    return clampArrayRange(arr, n);
+  },
+  shuffle(arr) {
+    return shuffle(arr);
+  },
+  sum(arr) {
+    return sum(arr);
+  },
+  average(arr) {
+    return average(arr);
+  },
+  avg(arr) {
+    return average(arr);
+  },
+  median(arr) {
+    return median(arr);
+  },
+  mode(arr) {
+    return mode(arr);
+  }
+}, arr = Arr;

package/dist/math.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Returns the average of an array of numbers
+ * @param arr
+ * @category Array
+ * @example
+ * ```ts
+ * average([1, 2, 3, 4]) // 2.5
+ * ```
+ */
+export declare function average(arr: number[]): number;
+/**
+ * Returns the average of an array of numbers
+ * @param arr
+ * @category Array
+ * @example
+ * ```ts
+ * avg([1, 2, 3, 4]) // 2.5
+ * ```
+ */
+export declare function avg(arr: number[]): number;
+/**
+ * Returns the median of an array of numbers
+ * @param arr
+ * @category Array
+ * @example
+ * ```ts
+ * median([1, 2, 3, 4]) // 2.5
+ * ```
+ */
+export declare function median(arr: number[]): number;
+/**
+ * Returns the mode of an array of numbers
+ * @param arr
+ * @category Array
+ * @example
+ * ```ts
+ * mode([1, 2, 3, 4]) // 1
+ * mode([1, 2, 2, 3, 4]) // 2
+ * mode([1, 2, 2, 3, 3, 4]) // 2
+ * mode([1, 2, 2, 3, 3, 4, 4]) // 2
+ * mode([1, 2, 2, 3, 3, 4, 4, 4]) // 4
+ * ```
+ */
+export declare function mode(arr: number[]): number;
+/**
+ * Returns the sum of an array of numbers
+ * @param array
+ * @category Array
+ * @example
+ * ```ts
+ * sum([1, 2, 3, 4]) // 10
+ * ```
+ */
+export declare function sum(array: readonly number[]): number;
+/**
+ * Returns the product of an array of numbers.
+ *
+ * Throws when an intermediate product exceeds `Number.MAX_SAFE_INTEGER` —
+ * silently returning a precision-lossy float made downstream comparisons
+ * (e.g. inventory totals, distance calcs) lie without any signal that
+ * the result was unreliable.
+ *
+ * @param array
+ * @category Array
+ * @example
+ * ```ts
+ * product([1, 2, 3, 4]) // 24
+ * ```
+ */
+export declare function product(array: readonly number[]): number;
+/**
+ * Returns the minimum value of an array of numbers
+ * @param array
+ * @category Array
+ * @example
+ * ```ts
+ * min([1, 2, 3, 4]) // 1
+ * min([1, 2, 3, 4, -1]) // -1
+ * ```
+ */
+export declare function min(array: readonly number[]): number;
+/**
+ * Returns the maximum value of an array of numbers
+ * @param array
+ * @category Array
+ * @example
+ * ```ts
+ * max([1, 2, 3, 4]) // 4
+ * max([1, 2, 3, 4, -1]) // 4
+ * ```
+ */
+export declare function max(array: readonly number[]): number;
+/**
+ * Returns the range of an array of numbers
+ * @param array
+ * @category Array
+ * @example
+ * ```ts
+ * range([1, 2, 3, 4]) // 3
+ * range([1, 2, 3, 4, -1]) // 5
+ * range([1, 2, 3, 4, -1, 10]) // 11
+ * ```
+ */
+export declare function range(array: readonly number[]): number;
+/**
+ * Returns the variance of an array of numbers
+ * @param array
+ * @category Array
+ * @example
+ * ```ts
+ * variance([1, 2, 3, 4]) // 1.25
+ * ```
+ * @see https://en.wikipedia.org/wiki/Variance
+ */
+export declare function variance(array: number[]): number;
+/**
+ * Returns the standard deviation of an array of numbers
+ * @param array
+ * @category Array
+ * @example
+ * ```ts
+ * standardDeviation([1, 2, 3, 4]) // 1.118033988749895
+ * ```
+ * @see https://en.wikipedia.org/wiki/Standard_deviation
+ * @see https://stackoverflow.com/questions/7343890/standard-deviation-javascript
+ */
+export declare function standardDeviation(array: number[]): number;
+/**
+ * Returns the z-score of a number in an array of numbers
+ * @param array
+ * @param num
+ * @category Array
+ * @example
+ * ```ts
+ * zScore([1, 2, 3, 4], 2) // 0
+ * zScore([1, 2, 3, 4], 3) // 0.7071067811865475
+ * ```
+ * @see https://en.wikipedia.org/wiki/Standard_score
+ */
+export declare function zScore(array: number[], num: number): number;
+/**
+ * Returns the percentile of a number in an array of numbers
+ * @param array
+ * @param num
+ * @category Array
+ * @example
+ * ```ts
+ * percentile([1, 2, 3, 4], 2) // 0.25
+ * percentile([1, 2, 3, 4], 3) // 0.75
+ * ```
+ * @see https://en.wikipedia.org/wiki/Percentile
+ */
+export declare function percentile(array: number[], num: number): number;
+/**
+ * Returns the interquartile range of an array of numbers
+ * @param array
+ * @category Array
+ * @example
+ * ```ts
+ * interquartileRange([1, 2, 3, 4]) // 1.5
+ * ```
+ * @see https://en.wikipedia.org/wiki/Interquartile_range
+ * @see https://stackoverflow.com/questions/48719873/how-to-calculate-interquartile-range-in-javascript
+ */
+export declare function interquartileRange(array: number[]): number;
+/**
+ * Returns the covariance of two arrays of numbers
+ * @param array1
+ * @param array2
+ * @category Array
+ * @example
+ * ```ts
+ * covariance([1, 2, 3, 4], [1, 2, 3, 4]) // 1.25
+ * covariance([1, 2, 3, 4], [4, 3, 2, 1]) // -1.25
+ * ```
+ */
+export declare function covariance(array1: number[], array2: number[]): number;

package/dist/math.js

@@ -0,0 +1,84 @@
+export function average(arr) {
+  if (arr.length === 0)
+    throw Error("Cannot compute average of an empty array");
+  return sum(arr) / arr.length;
+}
+export function avg(arr) {
+  return average(arr);
+}
+export function median(arr) {
+  if (arr.length === 0)
+    throw Error("Cannot compute median of an empty array");
+  const sorted = [...arr].sort((a, b) => a - b), mid = Math.floor(sorted.length / 2);
+  let medianValue;
+  if (sorted.length % 2 !== 0)
+    medianValue = sorted[mid];
+  else
+    medianValue = (sorted[mid] + sorted[mid - 1]) / 2;
+  return medianValue;
+}
+export function mode(arr) {
+  if (arr.length === 0)
+    throw Error("Cannot compute mode of an empty array");
+  const counts = new Map;
+  for (const v of arr)
+    counts.set(v, (counts.get(v) || 0) + 1);
+  let maxCount = 0, result = arr[0];
+  for (const [value, count] of counts)
+    if (count > maxCount) {
+      maxCount = count;
+      result = value;
+    }
+  return result;
+}
+export function sum(array) {
+  return array.reduce((acc, cur) => acc + cur, 0);
+}
+export function product(array) {
+  let acc = 1;
+  for (const cur of array) {
+    acc *= cur;
+    if (Number.isFinite(acc) && Math.abs(acc) > Number.MAX_SAFE_INTEGER)
+      throw RangeError(`[arrays.product] Result exceeds Number.MAX_SAFE_INTEGER (${Number.MAX_SAFE_INTEGER}); use BigInt for large products.`);
+  }
+  return acc;
+}
+export function min(array) {
+  if (array.length === 0)
+    throw Error("Cannot compute min of an empty array");
+  return Math.min(...array);
+}
+export function max(array) {
+  if (array.length === 0)
+    throw Error("Cannot compute max of an empty array");
+  return Math.max(...array);
+}
+export function range(array) {
+  return max(array) - min(array);
+}
+export function variance(array) {
+  const mean = average(array);
+  return average(array.map((num) => (num - mean) ** 2));
+}
+export function standardDeviation(array) {
+  return Math.sqrt(variance(array));
+}
+export function zScore(array, num) {
+  return (num - average(array)) / standardDeviation(array);
+}
+export function percentile(array, num) {
+  const sorted = [...array].sort((a, b) => a - b), index = num / 100 * (sorted.length - 1), lower = Math.floor(index), upper = Math.ceil(index), weight = index - lower;
+  if (upper === lower)
+    return sorted[index] ?? 0;
+  return (1 - weight) * (sorted[lower] ?? 0) + weight * (sorted[upper] ?? 0);
+}
+export function interquartileRange(array) {
+  const q1 = median(array.slice(0, Math.floor(array.length / 2)));
+  return median(array.slice(Math.ceil(array.length / 2))) - q1;
+}
+export function covariance(array1, array2) {
+  if (array1.length !== array2.length)
+    throw Error("Arrays must have the same length");
+  const mean1 = average(array1), mean2 = average(array2);
+  return average(array1.map((num1, i) => (num1 - mean1) * (array2[i] - mean2)));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/arrays",
   "type": "module",
-  "version": "0.70.88",
+  "version": "0.70.91",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
   "contributors": [
@@ -55,7 +55,7 @@
   },
   "devDependencies": {
     "better-dx": "^0.2.16",
-    "@stacksjs/utils": "0.70.88"
+    "@stacksjs/utils": "0.70.91"
   },
   "sideEffects": false
 }