@stacksjs/arrays 0.62.0 → 0.63.1

package/dist/index.js

@@ -1,341 +1,5 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
+var f=Object.defineProperty;var k=(z,E)=>{for(var G in E)f(z,G,{get:E[G],enumerable:!0,configurable:!0,set:(H)=>E[G]=()=>H})};var g={};k(g,{zScore:()=>d,variance:()=>x,uniqueBy:()=>D,unique:()=>m,uniq:()=>Q,toArray:()=>M,sum:()=>X,standardDeviation:()=>A,shuffle:()=>C,sample:()=>W,remove:()=>S,range:()=>F,product:()=>o,percentile:()=>l,partition:()=>B,move:()=>T,mode:()=>V,min:()=>b,mergeArrayable:()=>w,median:()=>P,max:()=>q,last:()=>O,interquartileRange:()=>i,flatten:()=>$,doesNotContain:()=>p,covariance:()=>c,containsOnly:()=>R,containsNone:()=>N,containsAny:()=>Z,containsAll:()=>Y,contains:()=>L,clampArrayRange:()=>j,avg:()=>u,average:()=>I,at:()=>U});import{clamp as h}from"@stacksjs/utils";function M(z){return z=z??[],Array.isArray(z)?z:[z]}function $(z){return M(z).flat(1)}function w(...z){return z.flatMap((E)=>M(E))}function B(z,...E){const G=Array.from({length:E.length+1}).fill(null).map(()=>[]);return z.forEach((H,J,K)=>{let _=0;for(let v of E){if(v(H,J,K)){G[_].push(H);return}_+=1}G[_].push(H)}),G}function Q(z){return Array.from(new Set(z))}function m(z){return Q(z)}function D(z,E){return z.reduce((G,H)=>{if(G.findIndex((K)=>E(H,K))===-1)G.push(H);return G},[])}function O(z){return U(z,-1)}function S(z,E){if(!z)return!1;const G=z.indexOf(E);if(G>=0)return z.splice(G,1),!0;return!1}function U(z,E){const G=z.length;if(!G)return;if(E<0)E+=G;return z[E]}function T(z,E,G){const H=z.length;if(!H)return[];if(E<0)E+=H;if(G<0)G+=H;const J=z.splice(E,1)[0];return z.splice(G,0,J),z}function j(z,E){return h(E,0,z.length-1)}function W(z,E){return Array.from({length:E},(G)=>z[Math.round(Math.random()*(z.length-1))])}function C(z){for(let E=z.length-1;E>0;E--){const G=Math.floor(Math.random()*(E+1));[z[E],z[G]]=[z[G],z[E]]}return z}function I(z){return X(z)/z.length}function u(z){return I(z)}function P(z){if(z.length===0)throw new Error("Cannot compute median of an empty array");const E=[...z].sort((J,K)=>J-K),G=Math.floor(E.length/2);let H;if(E.length%2!==0)H=E[G];else H=(E[G]+E[G-1])/2;return H}function V(z){return z.sort((E,G)=>z.filter((H)=>H===E).length-z.filter((H)=>H===G).length).pop()}function X(z){return z.reduce((E,G)=>E+G,0)}function o(z){return z.reduce((E,G)=>E*G,1)}function b(z){return Math.min(...z)}function q(z){return Math.max(...z)}function F(z){return q(z)-b(z)}function x(z){const E=I(z);return I(z.map((G)=>(G-E)**2))}function A(z){return Math.sqrt(x(z))}function d(z,E){return(E-I(z))/A(z)}function l(z,E){return z.filter((G)=>G<E).length/z.length}function i(z){const E=P(z.slice(0,Math.floor(z.length/2)));return P(z.slice(Math.ceil(z.length/2)))-E}function c(z,E){if(z.length!==E.length)throw new Error("Arrays must have the same length");const G=I(z),H=I(E);return I(z.map((J,K)=>(J-G)*(E[K]-H)))}function L(z,E){return E.some((G)=>z.includes(G))}function Y(z,E){return z.every((G)=>L(G,E))}function Z(z,E){return z.some((G)=>L(G,E))}function N(z,E){return!Z(z,E)}function R(z,E){return Y(E,z)}function p(z,E){return!L(z,E)}var Iz={contains(z,E){return L(z,E)},containsAll(z,E){return Y(z,E)},containsAny(z,E){return Z(z,E)},containsNone(z,E){return N(z,E)},containsOnly(z,E){return R(z,E)},doesNotContain(z,E){return p(z,E)},toArray(z){return M(z)},flatten(z){return $(z)},mergeArrayable(...z){return w(...z)},partition(z,E){return B(z,E)},random(z,E=1){return W(z,E).filter((G)=>G!=null)},sample(z,E=1){return W(z,E).filter((H)=>H!==void 0)},unique(z){return Q(z)},uniqueBy(z,E){return D(z,E)},last(z){return O(z)},remove(z,E){return S(z,E)},at(z,E){return U(z,E)},range(z){return F(z)},move(z,E,G){return T(z,E,G)},clampArrayRange(z,E){return j(z,E)},shuffle(z){return C(z)},sum(z){return X(z)},average(z){return I(z)},avg(z){return I(z)},median(z){return P(z)},mode(z){return V(z)}};export{d as zScore,x as variance,D as uniqueBy,m as unique,Q as uniq,M as toArray,X as sum,A as standardDeviation,C as shuffle,W as sample,S as remove,F as range,o as product,l as percentile,B as partition,T as move,V as mode,b as min,w as mergeArrayable,P as median,q as max,O as last,i as interquartileRange,$ as flatten,p as doesNotContain,c as covariance,R as containsOnly,N as containsNone,Z as containsAny,Y as containsAll,L as contains,j as clampArrayRange,u as avg,I as average,U as at,g as arr,Iz as Arr};
 
-// src/arr.ts
-var exports_arr = {};
-__export(exports_arr, {
-  zScore: () => zScore,
-  variance: () => variance,
-  uniqueBy: () => uniqueBy,
-  unique: () => unique,
-  uniq: () => uniq,
-  toArray: () => toArray,
-  sum: () => sum,
-  standardDeviation: () => standardDeviation,
-  shuffle: () => shuffle,
-  sample: () => sample,
-  remove: () => remove,
-  range: () => range,
-  product: () => product,
-  percentile: () => percentile,
-  partition: () => partition,
-  move: () => move,
-  mode: () => mode,
-  min: () => min,
-  mergeArrayable: () => mergeArrayable,
-  median: () => median,
-  max: () => max,
-  last: () => last,
-  interquartileRange: () => interquartileRange,
-  flatten: () => flatten,
-  doesNotContain: () => doesNotContain,
-  covariance: () => covariance,
-  containsOnly: () => containsOnly,
-  containsNone: () => containsNone,
-  containsAny: () => containsAny,
-  containsAll: () => containsAll,
-  contains: () => contains,
-  clampArrayRange: () => clampArrayRange,
-  avg: () => avg,
-  average: () => average,
-  at: () => at
-});
-
-// src/helpers.ts
-import {clamp} from "@stacksjs/utils";
-function toArray(array) {
-  array = array ?? [];
-  return Array.isArray(array) ? array : [array];
-}
-function flatten(array) {
-  return toArray(array).flat(1);
-}
-function mergeArrayable(...args) {
-  return args.flatMap((i) => toArray(i));
-}
-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;
-}
-function uniq(array) {
-  return Array.from(new Set(array));
-}
-function unique(array) {
-  return uniq(array);
-}
-function uniqueBy(array, equalFn) {
-  return array.reduce((acc, cur) => {
-    const index = acc.findIndex((item) => equalFn(cur, item));
-    if (index === -1)
-      acc.push(cur);
-    return acc;
-  }, []);
-}
-function last(array) {
-  return at(array, -1);
-}
-function remove(array, value) {
-  if (!array)
-    return false;
-  const index = array.indexOf(value);
-  if (index >= 0) {
-    array.splice(index, 1);
-    return true;
-  }
-  return false;
-}
-function at(array, index) {
-  const len = array.length;
-  if (!len)
-    return;
-  if (index < 0)
-    index += len;
-  return array[index];
-}
-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;
-}
-function clampArrayRange(arr, n) {
-  return clamp(n, 0, arr.length - 1);
-}
-function sample(arr, count) {
-  return Array.from({ length: count }, (_) => arr[Math.round(Math.random() * (arr.length - 1))]);
-}
-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;
-}
-// src/math.ts
-function average(arr) {
-  return sum(arr) / arr.length;
-}
-function avg(arr) {
-  return average(arr);
-}
-function median(arr) {
-  if (arr.length === 0)
-    throw new Error("Cannot compute median of an empty array");
-  const sorted = [...arr].sort((a, b) => a - b);
-  const 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;
-}
-function mode(arr) {
-  return arr.sort((a, b) => arr.filter((v) => v === a).length - arr.filter((v) => v === b).length).pop();
-}
-function sum(array) {
-  return array.reduce((acc, cur) => acc + cur, 0);
-}
-function product(array) {
-  return array.reduce((acc, cur) => acc * cur, 1);
-}
-function min(array) {
-  return Math.min(...array);
-}
-function max(array) {
-  return Math.max(...array);
-}
-function range(array) {
-  return max(array) - min(array);
-}
-function variance(array) {
-  const mean = average(array);
-  return average(array.map((num) => (num - mean) ** 2));
-}
-function standardDeviation(array) {
-  return Math.sqrt(variance(array));
-}
-function zScore(array, num) {
-  return (num - average(array)) / standardDeviation(array);
-}
-function percentile(array, num) {
-  return array.filter((n) => n < num).length / array.length;
-}
-function interquartileRange(array) {
-  const q1 = median(array.slice(0, Math.floor(array.length / 2)));
-  const q3 = median(array.slice(Math.ceil(array.length / 2)));
-  return q3 - q1;
-}
-function covariance(array1, array2) {
-  if (array1.length !== array2.length)
-    throw new Error("Arrays must have the same length");
-  const mean1 = average(array1);
-  const mean2 = average(array2);
-  return average(array1.map((num1, i) => (num1 - mean1) * (array2[i] - mean2)));
-}
-// src/contains.ts
-function contains(needle, haystack) {
-  return haystack.some((hay) => needle.includes(hay));
-}
-function containsAll(needles, haystack) {
-  return needles.every((needle) => contains(needle, haystack));
-}
-function containsAny(needles, haystack) {
-  return needles.some((needle) => contains(needle, haystack));
-}
-function containsNone(needles, haystack) {
-  return !containsAny(needles, haystack);
-}
-function containsOnly(needles, haystack) {
-  return containsAll(haystack, needles);
-}
-function doesNotContain(needle, haystack) {
-  return !contains(needle, haystack);
-}
-// src/macro.ts
-var 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) {
-    const sampleArr = sample(arr, count);
-    return sampleArr.filter((item) => item !== undefined);
-  },
-  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);
-  }
-};
-export {
-  zScore,
-  variance,
-  uniqueBy,
-  unique,
-  uniq,
-  toArray,
-  sum,
-  standardDeviation,
-  shuffle,
-  sample,
-  remove,
-  range,
-  product,
-  percentile,
-  partition,
-  move,
-  mode,
-  min,
-  mergeArrayable,
-  median,
-  max,
-  last,
-  interquartileRange,
-  flatten,
-  doesNotContain,
-  covariance,
-  containsOnly,
-  containsNone,
-  containsAny,
-  containsAll,
-  contains,
-  clampArrayRange,
-  avg,
-  average,
-  at,
-  exports_arr as arr,
-  Arr
-};
+//# debugId=02C254EE35F1DAD964756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/helpers.ts", "../src/math.ts", "../src/contains.ts", "../src/macro.ts"],
+  "sourcesContent": [
+    "import type { Arrayable, Nullable } from '@stacksjs/types'\nimport { clamp } from '@stacksjs/utils'\n\n/**\n * Convert `Arrayable<T>` to `Array<T>`\n *\n * @category Array\n * @example\n * ```ts\n * toArray('foo') // ['foo']\n * toArray(['foo']) // ['foo']\n * toArray(null) // []\n * toArray(undefined) // []\n * toArray(1) // [1]\n * toArray([1]) // [1]\n * toArray({ foo: 'bar' }) // [{ foo: 'bar' }]\n * toArray([{ foo: 'bar' }]) // [{ foo: 'bar' }]\n * ```\n */\nexport function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T> {\n  array = array ?? []\n  return Array.isArray(array) ? array : [array]\n}\n\n/**\n * Flatten `Arrayable<T>` to `Array<T>`\n *\n * @category Array\n * @example\n * ```ts\n * flatten([1, [2, [3, [4, [5]]]]]) // [1, 2, 3, 4, 5]\n * ```\n */\nexport function flatten<T>(array?: Nullable<Arrayable<T | Array<T>>>): Array<T> {\n  return toArray(array).flat(1) as Array<T>\n}\n\n/**\n * Use rest arguments to merge arrays\n *\n * @category Array\n * @example\n * ```ts\n * mergeArrayable([1, 2], [3, 4], [5, 6]) // [1, 2, 3, 4, 5, 6]\n * ```\n */\nexport function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T> {\n  return args.flatMap((i) => toArray(i))\n}\n\nexport type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any\n\n/**\n * Divide an array into two parts by a filter function\n *\n * @category Array\n * @example\n * ```ts\n * const [odd, even] = partition([1, 2, 3, 4], i => i % 2 != 0)\n * console.log(odd) // [1, 3]\n * console.log(even) // [2, 4]\n * ```\n */\nexport function partition<T>(array: readonly T[], f1: PartitionFilter<T>): [T[], T[]]\nexport function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>): [T[], T[], T[]]\nexport function partition<T>(\n  array: readonly T[],\n  f1: PartitionFilter<T>,\n  f2: PartitionFilter<T>,\n  f3: PartitionFilter<T>,\n): [T[], T[], T[], T[]]\nexport function partition<T>(\n  array: readonly T[],\n  f1: PartitionFilter<T>,\n  f2: PartitionFilter<T>,\n  f3: PartitionFilter<T>,\n  f4: PartitionFilter<T>,\n): [T[], T[], T[], T[], T[]]\nexport function partition<T>(\n  array: readonly T[],\n  f1: PartitionFilter<T>,\n  f2: PartitionFilter<T>,\n  f3: PartitionFilter<T>,\n  f4: PartitionFilter<T>,\n  f5: PartitionFilter<T>,\n): [T[], T[], T[], T[], T[], T[]]\nexport function partition<T>(\n  array: readonly T[],\n  f1: PartitionFilter<T>,\n  f2: PartitionFilter<T>,\n  f3: PartitionFilter<T>,\n  f4: PartitionFilter<T>,\n  f5: PartitionFilter<T>,\n  f6: PartitionFilter<T>,\n): [T[], T[], T[], T[], T[], T[], T[]]\nexport function partition<T>(array: readonly T[], ...filters: PartitionFilter<T>[]): any {\n  const result: T[][] = Array.from({ length: filters.length + 1 })\n    .fill(null)\n    .map(() => [])\n\n  array.forEach((e, idx, arr) => {\n    let i = 0\n    for (const filter of filters) {\n      if (filter(e, idx, arr)) {\n        ;(result[i] as T[]).push(e)\n        return\n      }\n      i += 1\n    }\n    ;(result[i] as T[]).push(e)\n  })\n  return result\n}\n\n/**\n * Unique an Array\n *\n * @category Array\n * @example\n * ```ts\n * uniq([1, 2, 3, 3, 2, 1]) // [1, 2, 3]\n * ```\n */\nexport function uniq<T>(array: readonly T[]): T[] {\n  return Array.from(new Set(array))\n}\n\n/**\n * Unique an Array\n *\n * @param array\n * @example\n * ```ts\n * unique([1, 2, 3, 3, 2, 1]) // [1, 2, 3]\n * ```\n */\nexport function unique<T>(array: readonly T[]): T[] {\n  return uniq(array)\n}\n\n/**\n * Unique an Array by a custom equality function\n *\n * @category Array\n * @example\n * ```ts\n * uniqueBy([1, 2, 3, 3, 2, 1], (a, b) => a === b) // [1, 2, 3]\n * ```\n */\nexport function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[] {\n  return array.reduce((acc: T[], cur: any) => {\n    const index = acc.findIndex((item: any) => equalFn(cur, item))\n    if (index === -1) acc.push(cur)\n    return acc\n  }, [])\n}\n\n/**\n * Get last item\n *\n * @category Array\n * @example\n * ```ts\n * last([1, 2, 3]) // 3\n * ```\n */\nexport function last(array: readonly []): undefined\nexport function last<T>(array: readonly T[]): T\nexport function last<T>(array: readonly T[]): T | undefined {\n  return at(array, -1)\n}\n\n/**\n * Remove an item from Array\n *\n * @category Array\n * @example\n * ```ts\n * const arr = [1, 2, 3]\n * remove(arr, 2) // true\n * Arr.remove(arr, 4) // false\n * console.log(arr) // [1, 3]\n */\nexport function remove<T>(array: T[], value: T) {\n  if (!array) return false\n\n  const index = array.indexOf(value)\n  if (index >= 0) {\n    array.splice(index, 1)\n    return true\n  }\n\n  return false\n}\n\n/**\n * Get nth item of Array. Negative for backward\n *\n * @category Array\n * @example\n * ```ts\n * at([1, 2, 3], 1) // 2\n * at([1, 2, 3], -1) // 3\n * at([1, 2, 3], 3) // undefined\n * at([1, 2, 3], -4) // undefined\n * ```\n */\nexport function at(array: readonly [], index: number): undefined\nexport function at<T>(array: readonly T[], index: number): T\nexport function at<T>(array: readonly T[] | [], index: number): T | undefined {\n  const len = array.length\n  if (!len) return undefined\n\n  if (index < 0) index += len\n\n  return array[index]\n}\n\n/**\n * Move an item from one index to another\n * @param array\n * @param from\n * @param to\n *\n * @category Array\n * @example\n * ```ts\n * move([1, 2, 3, 4], 0, 2) // [2, 3, 1, 4]\n * move([1, 2, 3, 4], 0, -1) // [2, 3, 4, 1]\n * move([1, 2, 3, 4], -1, 0) // [4, 1, 2, 3]\n * move([1, 2, 3, 4], -1, -2) // [1, 4, 2, 3]\n * move([1, 2, 3, 4], 1, 1) // [1, 2, 3, 4]\n * ```\n */\nexport function move<T>(array: T[], from: number, to: number): T[] {\n  const len = array.length\n  if (!len) return []\n\n  if (from < 0) from += len\n\n  if (to < 0) to += len\n\n  const item = array.splice(from, 1)[0]\n  array.splice(to, 0, item as T)\n  return array\n}\n\n/**\n * Clamp a number to the index range of an array.\n *\n * @category Array\n * @example\n * ```ts\n * clampArrayRange([1, 2, 3], 0) // 0\n * clampArrayRange([1, 2, 3], 1) // 1\n * clampArrayRange([1, 2, 3], 2) // 2\n * clampArrayRange([1, 2, 3], 3) // 2\n * clampArrayRange([1, 2, 3], 4) // 2\n * clampArrayRange([1, 2, 3], -1) // 0\n */\nexport function clampArrayRange(arr: readonly unknown[], n: number) {\n  return clamp(n, 0, arr.length - 1)\n}\n\n/**\n * Get random items from an array\n *\n * @category Array\n * @example\n * ```ts\n * sample([1, 2, 3, 4], 2) // [2, 3]\n * ```\n */\nexport function sample<T>(arr: T[], count: number) {\n  return Array.from({ length: count }, (_) => arr[Math.round(Math.random() * (arr.length - 1))])\n}\n\n/**\n * Shuffle an array. This function mutates the array.\n *\n * @category Array\n * @example\n * ```ts\n * shuffle([1, 2, 3, 4]) // [2, 4, 1, 3]\n * ```\n */\nexport function shuffle<T>(array: T[]): T[] {\n  for (let i = array.length - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1))\n    ;[array[i] as T, array[j] as T] = [array[j] as T, array[i] as T]\n  }\n  return array\n}\n",
+    "/**\n * Returns the average of an array of numbers\n * @param arr\n * @category Array\n * @example\n * ```ts\n * average([1, 2, 3, 4]) // 2.5\n * ```\n */\nexport function average(arr: number[]): number {\n  return sum(arr) / arr.length\n}\n\n/**\n * Returns the average of an array of numbers\n * @param arr\n * @category Array\n * @example\n * ```ts\n * avg([1, 2, 3, 4]) // 2.5\n * ```\n */\nexport function avg(arr: number[]): number {\n  return average(arr)\n}\n\n/**\n * Returns the median of an array of numbers\n * @param arr\n * @category Array\n * @example\n * ```ts\n * median([1, 2, 3, 4]) // 2.5\n * ```\n */\nexport function median(arr: number[]): number {\n  if (arr.length === 0) throw new Error('Cannot compute median of an empty array')\n\n  const sorted = [...arr].sort((a, b) => a - b)\n\n  const mid = Math.floor(sorted.length / 2)\n\n  let medianValue: number\n\n  if (sorted.length % 2 !== 0) medianValue = sorted[mid] as number\n  else medianValue = ((sorted[mid] as number) + (sorted[mid - 1] as number)) / 2 // or (sorted[mid - 1] + sorted[mid]) / 2\n\n  return medianValue\n}\n\n/**\n * Returns the mode of an array of numbers\n * @param arr\n * @category Array\n * @example\n * ```ts\n * mode([1, 2, 3, 4]) // 1\n * mode([1, 2, 2, 3, 4]) // 2\n * mode([1, 2, 2, 3, 3, 4]) // 2\n * mode([1, 2, 2, 3, 3, 4, 4]) // 2\n * mode([1, 2, 2, 3, 3, 4, 4, 4]) // 4\n * ```\n */\nexport function mode(arr: number[]): number {\n  return arr.sort((a, b) => arr.filter((v) => v === a).length - arr.filter((v) => v === b).length).pop() as number\n}\n\n/**\n * Returns the sum of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * sum([1, 2, 3, 4]) // 10\n * ```\n */\nexport function sum(array: readonly number[]): number {\n  return array.reduce((acc, cur) => acc + cur, 0)\n}\n\n/**\n * Returns the product of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * product([1, 2, 3, 4]) // 24\n * ```\n */\nexport function product(array: readonly number[]): number {\n  return array.reduce((acc, cur) => acc * cur, 1)\n}\n\n/**\n * Returns the minimum value of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * min([1, 2, 3, 4]) // 1\n * min([1, 2, 3, 4, -1]) // -1\n * ```\n */\nexport function min(array: readonly number[]): number {\n  return Math.min(...array)\n}\n\n/**\n * Returns the maximum value of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * max([1, 2, 3, 4]) // 4\n * max([1, 2, 3, 4, -1]) // 4\n * ```\n */\nexport function max(array: readonly number[]): number {\n  return Math.max(...array)\n}\n\n/**\n * Returns the range of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * range([1, 2, 3, 4]) // 3\n * range([1, 2, 3, 4, -1]) // 5\n * range([1, 2, 3, 4, -1, 10]) // 11\n * ```\n */\nexport function range(array: readonly number[]): number {\n  return max(array) - min(array)\n}\n\n/**\n * Returns the variance of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * variance([1, 2, 3, 4]) // 1.25\n * ```\n * @see https://en.wikipedia.org/wiki/Variance\n */\nexport function variance(array: number[]): number {\n  const mean = average(array)\n  return average(array.map((num) => (num - mean) ** 2))\n}\n\n/**\n * Returns the standard deviation of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * standardDeviation([1, 2, 3, 4]) // 1.118033988749895\n * ```\n * @see https://en.wikipedia.org/wiki/Standard_deviation\n * @see https://stackoverflow.com/questions/7343890/standard-deviation-javascript\n */\nexport function standardDeviation(array: number[]): number {\n  return Math.sqrt(variance(array))\n}\n\n/**\n * Returns the z-score of a number in an array of numbers\n * @param array\n * @param num\n * @category Array\n * @example\n * ```ts\n * zScore([1, 2, 3, 4], 2) // 0\n * zScore([1, 2, 3, 4], 3) // 0.7071067811865475\n * ```\n * @see https://en.wikipedia.org/wiki/Standard_score\n */\nexport function zScore(array: number[], num: number): number {\n  return (num - average(array)) / standardDeviation(array)\n}\n\n/**\n * Returns the percentile of a number in an array of numbers\n * @param array\n * @param num\n * @category Array\n * @example\n * ```ts\n * percentile([1, 2, 3, 4], 2) // 0.25\n * percentile([1, 2, 3, 4], 3) // 0.75\n * ```\n * @see https://en.wikipedia.org/wiki/Percentile\n */\nexport function percentile(array: number[], num: number): number {\n  return array.filter((n) => n < num).length / array.length\n}\n\n/**\n * Returns the interquartile range of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * interquartileRange([1, 2, 3, 4]) // 1.5\n * ```\n * @see https://en.wikipedia.org/wiki/Interquartile_range\n * @see https://stackoverflow.com/questions/48719873/how-to-calculate-interquartile-range-in-javascript\n */\nexport function interquartileRange(array: number[]): number {\n  const q1 = median(array.slice(0, Math.floor(array.length / 2)))\n  const q3 = median(array.slice(Math.ceil(array.length / 2)))\n  return q3 - q1\n}\n\n/**\n * Returns the covariance of two arrays of numbers\n * @param array1\n * @param array2\n * @category Array\n * @example\n * ```ts\n * covariance([1, 2, 3, 4], [1, 2, 3, 4]) // 1.25\n * covariance([1, 2, 3, 4], [4, 3, 2, 1]) // -1.25\n * ```\n */\nexport function covariance(array1: number[], array2: number[]): number {\n  if (array1.length !== array2.length) throw new Error('Arrays must have the same length')\n\n  const mean1 = average(array1)\n  const mean2 = average(array2)\n\n  return average(array1.map((num1, i) => (num1 - mean1) * ((array2[i] as number) - mean2)))\n}\n",
+    "/**\n * Returns true if the needle is contained in the haystack.\n *\n * @param needle\n * @param haystack\n * @example\n * ```ts\n * contains('foo', ['foo', 'bar']) // true\n * contains('foo', ['bar']) // false\n * ```\n */\nexport function contains(needle: string, haystack: string[]) {\n  return haystack.some((hay) => needle.includes(hay))\n}\n\n/**\n * Returns true if all needles are contained in the haystack.\n * @param needles\n * @param haystack\n * @example\n * ```ts\n * containsAll(['foo', 'bar'], ['foo', 'bar', 'baz']) // true\n * containsAll(['foo', 'bar'], ['foo', 'baz']) // false\n * ```\n */\nexport function containsAll(needles: string[], haystack: string[]) {\n  return needles.every((needle) => contains(needle, haystack))\n}\n\n/**\n * Returns true if any needle is contained in the haystack.\n * @param needles\n * @param haystack\n * @example\n * ```ts\n * containsAny(['foo', 'bar'], ['foo', 'bar', 'baz']) // true\n * containsAny(['foo', 'bar'], ['foo', 'baz']) // true\n * containsAny(['foo', 'bar'], ['baz']) // false\n * ```\n */\nexport function containsAny(needles: string[], haystack: string[]) {\n  return needles.some((needle) => contains(needle, haystack))\n}\n\n/**\n * Returns true if none of the needles are contained in the haystack.\n * @param needles\n * @param haystack\n * @example\n * ```ts\n * containsNone(['foo', 'bar'], ['foo', 'bar', 'baz']) // false\n * containsNone(['foo', 'bar'], ['foo', 'baz']) // false\n * containsNone(['foo', 'bar'], ['baz']) // true\n * ```\n */\nexport function containsNone(needles: string[], haystack: string[]) {\n  return !containsAny(needles, haystack)\n}\n\n/**\n * Returns true if all needles are contained in the haystack.\n * @param needles\n * @param haystack\n * @example\n * ```ts\n * containsOnly(['foo', 'bar'], ['foo', 'bar', 'baz']) // false\n * containsOnly(['foo', 'bar'], ['foo', 'baz']) // false\n * containsOnly(['foo', 'bar'], ['foo', 'bar']) // true\n * ```\n */\nexport function containsOnly(needles: string[], haystack: string[]) {\n  return containsAll(haystack, needles)\n}\n\n/**\n * Returns true if the needle is not contained in the haystack.\n * @param needle\n * @param haystack\n * @example\n * ```ts\n * doesNotContain('foo', ['foo', 'bar']) // false\n * doesNotContain('foo', ['bar']) // true\n * ```\n */\nexport function doesNotContain(needle: string, haystack: string[]) {\n  return !contains(needle, haystack)\n}\n",
+    "import type { Arrayable, Nullable } from '@stacksjs/types'\nimport { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from './contains'\nimport type { PartitionFilter } from './helpers'\nimport {\n  at,\n  clampArrayRange,\n  flatten,\n  last,\n  mergeArrayable,\n  move,\n  partition,\n  remove,\n  sample,\n  shuffle,\n  toArray,\n  uniq,\n  uniqueBy,\n} from './helpers'\nimport { average, median, mode, range, sum } from './math'\n\nexport const Arr = {\n  contains(needle: string, haystack: string[]) {\n    return contains(needle, haystack)\n  },\n\n  containsAll(needles: string[], haystack: string[]) {\n    return containsAll(needles, haystack)\n  },\n\n  containsAny(needles: string[], haystack: string[]) {\n    return containsAny(needles, haystack)\n  },\n\n  containsNone(needles: string[], haystack: string[]) {\n    return containsNone(needles, haystack)\n  },\n\n  containsOnly(needles: string[], haystack: string[]) {\n    return containsOnly(needles, haystack)\n  },\n\n  doesNotContain(needle: string, haystack: string[]) {\n    return doesNotContain(needle, haystack)\n  },\n\n  toArray<T>(array?: Nullable<Arrayable<T>>): Array<T> {\n    return toArray(array)\n  },\n\n  flatten<T>(array?: Nullable<Arrayable<T | Array<T>>>): Array<T> {\n    return flatten(array)\n  },\n\n  mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T> {\n    return mergeArrayable(...args)\n  },\n\n  partition<T>(array: readonly T[], filter: PartitionFilter<T>): [T[], T[]] {\n    return partition(array, filter)\n  },\n\n  /**\n   * Returns a random item/s from the array\n   */\n  random<T>(arr: T[], count = 1): T[] {\n    return sample(arr, count).filter((item): item is T => item != null)\n  },\n\n  /**\n   * Returns random item/s from the array\n   */\n  sample<T>(arr: T[], count = 1): T[] {\n    // Get the sample array (may contain undefined values)\n    const sampleArr = sample(arr, count)\n\n    // Filter out any undefined values\n    return sampleArr.filter((item): item is T => item !== undefined)\n  },\n\n  unique<T>(arr: T[]): T[] {\n    return uniq(arr)\n  },\n\n  uniqueBy<T>(arr: readonly T[], equalFn: (a: any, b: any) => boolean): T[] {\n    return uniqueBy(arr, equalFn)\n  },\n\n  last<T>(arr: T[]): T | undefined {\n    return last(arr)\n  },\n\n  remove<T>(arr: T[], value: T) {\n    return remove(arr, value)\n  },\n\n  at(arr: any[], index: number): any {\n    return at(arr, index)\n  },\n\n  range(arr: readonly number[]): number {\n    return range(arr)\n  },\n\n  move<T>(arr: T[], from: number, to: number): T[] {\n    return move(arr, from, to)\n  },\n\n  clampArrayRange(arr: readonly unknown[], n: number) {\n    return clampArrayRange(arr, n)\n  },\n\n  shuffle<T>(arr: T[]): T[] {\n    return shuffle(arr)\n  },\n\n  /**\n   * Returns the sum of all items in the array\n   */\n  sum(arr: number[]): number {\n    return sum(arr)\n  },\n\n  /**\n   * Returns the average of all items in the array\n   */\n  average(arr: number[]): number {\n    return average(arr)\n  },\n\n  avg(arr: number[]): number {\n    return average(arr)\n  },\n\n  /**\n   * Returns the median of all items in the array\n   */\n  median(arr: number[]): number {\n    return median(arr)\n  },\n\n  /**\n   * Returns the mode of all items in the array\n   */\n  mode(arr: number[]): number {\n    return mode(arr)\n  },\n}\n\nexport const arr = Arr\n"
+  ],
+  "mappings": "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",
+  "debugId": "02C254EE35F1DAD964756E2164756E21",
+  "names": []
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/arrays",
   "type": "module",
-  "version": "0.62.0",
+  "version": "0.63.1",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -48,9 +48,6 @@
     "typecheck": "bun --bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
-  "peerDependencies": {
-    "@stacksjs/utils": "latest"
-  },
   "dependencies": {
     "@stacksjs/utils": "latest"
   },