@stacksjs/arrays 0.65.0 → 0.67.0

package/dist/index.js

@@ -1,5 +1,2 @@
 // @bun
-var v=Object.defineProperty;var h=(z,E)=>{for(var G in E)v(z,G,{get:E[G],enumerable:!0,configurable:!0,set:(H)=>E[G]=()=>H})};var f={};h(f,{zScore:()=>i,variance:()=>x,uniqueBy:()=>C,unique:()=>u,uniq:()=>Y,toArray:()=>P,sum:()=>$,standardDeviation:()=>g,shuffle:()=>w,sample:()=>_,remove:()=>F,range:()=>b,product:()=>d,percentile:()=>c,partition:()=>j,move:()=>N,mode:()=>q,min:()=>p,mergeArrayable:()=>T,median:()=>Q,max:()=>A,last:()=>V,interquartileRange:()=>l,flatten:()=>X,doesNotContain:()=>S,covariance:()=>s,containsOnly:()=>O,containsNone:()=>D,containsAny:()=>W,containsAll:()=>U,contains:()=>M,clampArrayRange:()=>R,avg:()=>o,average:()=>J,at:()=>Z});function M(z,E){return E.some((G)=>z.includes(G))}function U(z,E){return z.every((G)=>M(G,E))}function W(z,E){return z.some((G)=>M(G,E))}function D(z,E){return!W(z,E)}function O(z,E){return U(E,z)}function S(z,E){return!M(z,E)}import{clamp as m}from"@stacksjs/utils";function P(z){return z=z??[],Array.isArray(z)?z:[z]}function X(z){return P(z).reduce((E,G)=>E.concat(Array.isArray(G)?X(G):G),[])}function T(...z){return z.flatMap((E)=>P(E))}function j(z,...E){const G=Array.from({length:E.length+1}).fill(null).map(()=>[]);return z.forEach((H,I,K)=>{let L=0;for(let B of E){if(B(H,I,K)){G[L].push(H);return}L+=1}G[L].push(H)}),G}function Y(z){return Array.from(new Set(z))}function u(z){return Y(z)}function C(z,E){return z.reduce((G,H)=>{if(G.findIndex((K)=>E(H,K))===-1)G.push(H);return G},[])}function V(z){return Z(z,-1)}function F(z,E){if(!z)return!1;const G=z.indexOf(E);if(G>=0)return z.splice(G,1),!0;return!1}function Z(z,E){const G=z.length;if(!G)return;if(E<0)E+=G;return z[E]}function N(z,E,G){const H=z.length;if(!H)return[];if(E<0)E+=H;if(G<0)G+=H;const I=z.splice(E,1)[0];return z.splice(G,0,I),z}function R(z,E){return m(E,0,z.length-1)}function _(z,E){return Array.from({length:E},()=>z[Math.floor(Math.random()*z.length)])}function w(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 J(z){return $(z)/z.length}function o(z){return J(z)}function Q(z){if(z.length===0)throw new Error("Cannot compute median of an empty array");const E=[...z].sort((I,K)=>I-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 q(z){return z.sort((E,G)=>z.filter((H)=>H===E).length-z.filter((H)=>H===G).length).pop()}function $(z){return z.reduce((E,G)=>E+G,0)}function d(z){return z.reduce((E,G)=>E*G,1)}function p(z){return Math.min(...z)}function A(z){return Math.max(...z)}function b(z){return A(z)-p(z)}function x(z){const E=J(z);return J(z.map((G)=>(G-E)**2))}function g(z){return Math.sqrt(x(z))}function i(z,E){return(E-J(z))/g(z)}function c(z,E){const G=[...z].sort((B,k)=>B-k),H=E/100*(G.length-1),I=Math.floor(H),K=Math.ceil(H),L=H-I;if(K===I)return G[H]??0;return(1-L)*(G[I]??0)+L*(G[K]??0)}function l(z){const E=Q(z.slice(0,Math.floor(z.length/2)));return Q(z.slice(Math.ceil(z.length/2)))-E}function s(z,E){if(z.length!==E.length)throw new Error("Arrays must have the same length");const G=J(z),H=J(E);return J(z.map((I,K)=>(I-G)*(E[K]-H)))}var Jz={contains(z,E){return M(z,E)},containsAll(z,E){return U(z,E)},containsAny(z,E){return W(z,E)},containsNone(z,E){return D(z,E)},containsOnly(z,E){return O(z,E)},doesNotContain(z,E){return S(z,E)},toArray(z){return P(z)},flatten(z){return X(z)},mergeArrayable(...z){return T(...z)},partition(z,E){return j(z,E)},random(z,E=1){return _(z,E).filter((G)=>G!=null)},sample(z,E=1){return _(z,E)},unique(z){return Y(z)},uniqueBy(z,E){return C(z,E)},last(z){return V(z)},remove(z,E){return F(z,E)},at(z,E){return Z(z,E)},range(z){return b(z)},move(z,E,G){return N(z,E,G)},clampArrayRange(z,E){return R(z,E)},shuffle(z){return w(z)},sum(z){return $(z)},average(z){return J(z)},avg(z){return J(z)},median(z){return Q(z)},mode(z){return q(z)}};export{i as zScore,x as variance,C as uniqueBy,u as unique,Y as uniq,P as toArray,$ as sum,g as standardDeviation,w as shuffle,_ as sample,F as remove,b as range,d as product,c as percentile,j as partition,N as move,q as mode,p as min,T as mergeArrayable,Q as median,A as max,V as last,l as interquartileRange,X as flatten,S as doesNotContain,s as covariance,O as containsOnly,D as containsNone,W as containsAny,U as containsAll,M as contains,R as clampArrayRange,o as avg,J as average,Z as at,f as arr,Jz as Arr};
-
-//# debugId=B6B872CC06F3654D64756E2164756E21
-//# sourceMappingURL=index.js.map
+var v=Object.defineProperty;var h=(z,E)=>{for(var G in E)v(z,G,{get:E[G],enumerable:!0,configurable:!0,set:(H)=>E[G]=()=>H})};var f={};h(f,{zScore:()=>i,variance:()=>x,uniqueBy:()=>C,unique:()=>u,uniq:()=>Y,toArray:()=>P,sum:()=>$,standardDeviation:()=>g,shuffle:()=>w,sample:()=>_,remove:()=>F,range:()=>b,product:()=>d,percentile:()=>c,partition:()=>j,move:()=>N,mode:()=>q,min:()=>p,mergeArrayable:()=>T,median:()=>Q,max:()=>A,last:()=>V,interquartileRange:()=>l,flatten:()=>X,doesNotContain:()=>S,covariance:()=>s,containsOnly:()=>O,containsNone:()=>D,containsAny:()=>W,containsAll:()=>U,contains:()=>M,clampArrayRange:()=>R,avg:()=>o,average:()=>J,at:()=>Z});function M(z,E){return E.some((G)=>z.includes(G))}function U(z,E){return z.every((G)=>M(G,E))}function W(z,E){return z.some((G)=>M(G,E))}function D(z,E){return!W(z,E)}function O(z,E){return U(E,z)}function S(z,E){return!M(z,E)}import{clamp as m}from"@stacksjs/utils";function P(z){return z=z??[],Array.isArray(z)?z:[z]}function X(z){return P(z).reduce((E,G)=>E.concat(Array.isArray(G)?X(G):G),[])}function T(...z){return z.flatMap((E)=>P(E))}function j(z,...E){let G=Array.from({length:E.length+1}).fill(null).map(()=>[]);return z.forEach((H,I,K)=>{let L=0;for(let B of E){if(B(H,I,K)){G[L].push(H);return}L+=1}G[L].push(H)}),G}function Y(z){return Array.from(new Set(z))}function u(z){return Y(z)}function C(z,E){return z.reduce((G,H)=>{if(G.findIndex((K)=>E(H,K))===-1)G.push(H);return G},[])}function V(z){return Z(z,-1)}function F(z,E){if(!z)return!1;let G=z.indexOf(E);if(G>=0)return z.splice(G,1),!0;return!1}function Z(z,E){let G=z.length;if(!G)return;if(E<0)E+=G;return z[E]}function N(z,E,G){let H=z.length;if(!H)return[];if(E<0)E+=H;if(G<0)G+=H;let I=z.splice(E,1)[0];return z.splice(G,0,I),z}function R(z,E){return m(E,0,z.length-1)}function _(z,E){return Array.from({length:E},()=>z[Math.floor(Math.random()*z.length)])}function w(z){for(let E=z.length-1;E>0;E--){let G=Math.floor(Math.random()*(E+1));[z[E],z[G]]=[z[G],z[E]]}return z}function J(z){return $(z)/z.length}function o(z){return J(z)}function Q(z){if(z.length===0)throw new Error("Cannot compute median of an empty array");let E=[...z].sort((I,K)=>I-K),G=Math.floor(E.length/2),H;if(E.length%2!==0)H=E[G];else H=(E[G]+E[G-1])/2;return H}function q(z){return z.sort((E,G)=>z.filter((H)=>H===E).length-z.filter((H)=>H===G).length).pop()}function $(z){return z.reduce((E,G)=>E+G,0)}function d(z){return z.reduce((E,G)=>E*G,1)}function p(z){return Math.min(...z)}function A(z){return Math.max(...z)}function b(z){return A(z)-p(z)}function x(z){let E=J(z);return J(z.map((G)=>(G-E)**2))}function g(z){return Math.sqrt(x(z))}function i(z,E){return(E-J(z))/g(z)}function c(z,E){let G=[...z].sort((B,k)=>B-k),H=E/100*(G.length-1),I=Math.floor(H),K=Math.ceil(H),L=H-I;if(K===I)return G[H]??0;return(1-L)*(G[I]??0)+L*(G[K]??0)}function l(z){let E=Q(z.slice(0,Math.floor(z.length/2)));return Q(z.slice(Math.ceil(z.length/2)))-E}function s(z,E){if(z.length!==E.length)throw new Error("Arrays must have the same length");let G=J(z),H=J(E);return J(z.map((I,K)=>(I-G)*(E[K]-H)))}var Jz={contains(z,E){return M(z,E)},containsAll(z,E){return U(z,E)},containsAny(z,E){return W(z,E)},containsNone(z,E){return D(z,E)},containsOnly(z,E){return O(z,E)},doesNotContain(z,E){return S(z,E)},toArray(z){return P(z)},flatten(z){return X(z)},mergeArrayable(...z){return T(...z)},partition(z,E){return j(z,E)},random(z,E=1){return _(z,E).filter((G)=>G!=null)},sample(z,E=1){return _(z,E)},unique(z){return Y(z)},uniqueBy(z,E){return C(z,E)},last(z){return V(z)},remove(z,E){return F(z,E)},at(z,E){return Z(z,E)},range(z){return b(z)},move(z,E,G){return N(z,E,G)},clampArrayRange(z,E){return R(z,E)},shuffle(z){return w(z)},sum(z){return $(z)},average(z){return J(z)},avg(z){return J(z)},median(z){return Q(z)},mode(z){return q(z)}};export{i as zScore,x as variance,C as uniqueBy,u as unique,Y as uniq,P as toArray,$ as sum,g as standardDeviation,w as shuffle,_ as sample,F as remove,b as range,d as product,c as percentile,j as partition,N as move,q as mode,p as min,T as mergeArrayable,Q as median,A as max,V as last,l as interquartileRange,X as flatten,S as doesNotContain,s as covariance,O as containsOnly,D as containsNone,W as containsAny,U as containsAll,M as contains,R as clampArrayRange,o as avg,J as average,Z as at,f as arr,Jz as Arr};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/arrays",
   "type": "module",
-  "version": "0.65.0",
+  "version": "0.67.0",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
   "contributors": ["Chris Breuer <chris@stacksjs.org>"],
@@ -26,17 +26,15 @@
   ],
   "exports": {
     ".": {
-      "bun": "./src/index.ts",
       "import": "./dist/index.js"
     },
     "./*": {
-      "bun": "./src/*",
       "import": "./dist/*"
     }
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["README.md", "dist", "src"],
+  "files": ["README.md", "dist"],
   "scripts": {
     "build": "bun build.ts",
     "typecheck": "bun tsc --noEmit",
@@ -44,9 +42,9 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/utils": "0.64.6"
+    "@stacksjs/utils": "0.67.0"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.64.6"
+    "@stacksjs/development": "0.67.0"
   }
 }

package/dist/index.js.map

@@ -1,13 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/contains.ts", "../src/helpers.ts", "../src/math.ts", "../src/macro.ts"],
-  "sourcesContent": [
-    "/**\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[]): boolean {\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[]): boolean {\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[]): boolean {\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[]): boolean {\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[]): boolean {\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[]): boolean {\n  return !contains(needle, haystack)\n}\n",
-    "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 | T[]>>): T[] {\n  return toArray(array).reduce((acc: T[], val) => acc.concat(Array.isArray(val) ? flatten(val) : (val as 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)\n      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): boolean {\n  if (!array)\n    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)\n    return undefined\n\n  if (index < 0)\n    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)\n    return []\n\n  if (from < 0)\n    from += len\n\n  if (to < 0)\n    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): 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): T[] {\n  return Array.from({ length: count }, () => arr[Math.floor(Math.random() * arr.length)]!)\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)\n    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)\n    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  const sorted = [...array].sort((a, b) => a - b)\n  const index = (num / 100) * (sorted.length - 1)\n  const lower = Math.floor(index)\n  const upper = Math.ceil(index)\n  const weight = index - lower\n\n  if (upper === lower)\n    return sorted[index] ?? 0\n  return (1 - weight) * (sorted[lower] ?? 0) + weight * (sorted[upper] ?? 0)\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)\n    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",
-    "import type { Arrayable, Nullable } from '@stacksjs/types'\nimport type { PartitionFilter } from './helpers'\nimport { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from './contains'\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[]): boolean {\n    return contains(needle, haystack)\n  },\n\n  containsAll(needles: string[], haystack: string[]): boolean {\n    return containsAll(needles, haystack)\n  },\n\n  containsAny(needles: string[], haystack: string[]): boolean {\n    return containsAny(needles, haystack)\n  },\n\n  containsNone(needles: string[], haystack: string[]): boolean {\n    return containsNone(needles, haystack)\n  },\n\n  containsOnly(needles: string[], haystack: string[]): boolean {\n    return containsOnly(needles, haystack)\n  },\n\n  doesNotContain(needle: string, haystack: string[]): boolean {\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 | T[]>>): 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    return sample(arr, count)\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): boolean {\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): 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: typeof Arr = Arr\n"
-  ],
-  "mappings": "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",
-  "debugId": "B6B872CC06F3654D64756E2164756E21",
-  "names": []
-}

package/src/arr.ts

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

package/src/contains.ts

@@ -1,87 +0,0 @@
-/**
- * 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 function contains(needle: string, haystack: string[]): boolean {
-  return haystack.some(hay => needle.includes(hay))
-}
-
-/**
- * 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 function containsAll(needles: string[], haystack: string[]): boolean {
-  return needles.every(needle => contains(needle, haystack))
-}
-
-/**
- * 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 function containsAny(needles: string[], haystack: string[]): boolean {
-  return needles.some(needle => contains(needle, haystack))
-}
-
-/**
- * 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 function containsNone(needles: string[], haystack: string[]): boolean {
-  return !containsAny(needles, haystack)
-}
-
-/**
- * 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 function containsOnly(needles: string[], haystack: string[]): boolean {
-  return containsAll(haystack, needles)
-}
-
-/**
- * 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 function doesNotContain(needle: string, haystack: string[]): boolean {
-  return !contains(needle, haystack)
-}

package/src/helpers.ts

@@ -1,300 +0,0 @@
-import type { Arrayable, Nullable } from '@stacksjs/types'
-import { clamp } from '@stacksjs/utils'
-
-/**
- * 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 function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T> {
-  array = array ?? []
-  return Array.isArray(array) ? array : [array]
-}
-
-/**
- * Flatten `Arrayable<T>` to `Array<T>`
- *
- * @category Array
- * @example
- * ```ts
- * flatten([1, [2, [3, [4, [5]]]]]) // [1, 2, 3, 4, 5]
- * ```
- */
-export function flatten<T>(array?: Nullable<Arrayable<T | T[]>>): T[] {
-  return toArray(array).reduce((acc: T[], val) => acc.concat(Array.isArray(val) ? flatten(val) : (val as 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 function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T> {
-  return args.flatMap(i => toArray(i))
-}
-
-export type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any
-
-/**
- * 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 function partition<T>(array: readonly T[], f1: PartitionFilter<T>): [T[], T[]]
-export function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>): [T[], T[], T[]]
-export function partition<T>(
-  array: readonly T[],
-  f1: PartitionFilter<T>,
-  f2: PartitionFilter<T>,
-  f3: PartitionFilter<T>,
-): [T[], T[], T[], T[]]
-export function partition<T>(
-  array: readonly T[],
-  f1: PartitionFilter<T>,
-  f2: PartitionFilter<T>,
-  f3: PartitionFilter<T>,
-  f4: PartitionFilter<T>,
-): [T[], T[], T[], T[], T[]]
-export 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 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[]]
-export function partition<T>(array: readonly T[], ...filters: PartitionFilter<T>[]): any {
-  const result: T[][] = 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] as T[]).push(e)
-        return
-      }
-      i += 1
-    }
-    ;(result[i] as T[]).push(e)
-  })
-  return result
-}
-
-/**
- * Unique an Array
- *
- * @category Array
- * @example
- * ```ts
- * uniq([1, 2, 3, 3, 2, 1]) // [1, 2, 3]
- * ```
- */
-export function uniq<T>(array: readonly T[]): T[] {
-  return Array.from(new Set(array))
-}
-
-/**
- * Unique an Array
- *
- * @param array
- * @example
- * ```ts
- * unique([1, 2, 3, 3, 2, 1]) // [1, 2, 3]
- * ```
- */
-export function unique<T>(array: readonly T[]): T[] {
-  return uniq(array)
-}
-
-/**
- * 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 function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[] {
-  return array.reduce((acc: T[], cur: any) => {
-    const index = acc.findIndex((item: any) => equalFn(cur, item))
-    if (index === -1)
-      acc.push(cur)
-    return acc
-  }, [])
-}
-
-/**
- * Get last item
- *
- * @category Array
- * @example
- * ```ts
- * last([1, 2, 3]) // 3
- * ```
- */
-export function last(array: readonly []): undefined
-export function last<T>(array: readonly T[]): T
-export function last<T>(array: readonly T[]): T | undefined {
-  return at(array, -1)
-}
-
-/**
- * Remove an item from Array
- *
- * @category Array
- * @example
- * ```ts
- * const arr = [1, 2, 3]
- * remove(arr, 2) // true
- * Arr.remove(arr, 4) // false
- * console.log(arr) // [1, 3]
- */
-export function remove<T>(array: T[], value: T): boolean {
-  if (!array)
-    return false
-
-  const index = array.indexOf(value)
-  if (index >= 0) {
-    array.splice(index, 1)
-    return true
-  }
-
-  return false
-}
-
-/**
- * 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 function at(array: readonly [], index: number): undefined
-export function at<T>(array: readonly T[], index: number): T
-export function at<T>(array: readonly T[] | [], index: number): T | undefined {
-  const len = array.length
-  if (!len)
-    return undefined
-
-  if (index < 0)
-    index += len
-
-  return array[index]
-}
-
-/**
- * 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 function move<T>(array: T[], from: number, to: number): T[] {
-  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 as T)
-  return array
-}
-
-/**
- * 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 function clampArrayRange(arr: readonly unknown[], n: number): number {
-  return clamp(n, 0, arr.length - 1)
-}
-
-/**
- * Get random items from an array
- *
- * @category Array
- * @example
- * ```ts
- * sample([1, 2, 3, 4], 2) // [2, 3]
- * ```
- */
-export function sample<T>(arr: T[], count: number): T[] {
-  return Array.from({ length: count }, () => arr[Math.floor(Math.random() * arr.length)]!)
-}
-
-/**
- * Shuffle an array. This function mutates the array.
- *
- * @category Array
- * @example
- * ```ts
- * shuffle([1, 2, 3, 4]) // [2, 4, 1, 3]
- * ```
- */
-export function shuffle<T>(array: T[]): T[] {
-  for (let i = array.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1))
-    ;[array[i] as T, array[j] as T] = [array[j] as T, array[i] as T]
-  }
-  return array
-}

package/src/index.ts

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

package/src/macro.ts

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

package/src/math.ts

@@ -1,245 +0,0 @@
-/**
- * Returns the average of an array of numbers
- * @param arr
- * @category Array
- * @example
- * ```ts
- * average([1, 2, 3, 4]) // 2.5
- * ```
- */
-export function average(arr: number[]): number {
-  return sum(arr) / arr.length
-}
-
-/**
- * Returns the average of an array of numbers
- * @param arr
- * @category Array
- * @example
- * ```ts
- * avg([1, 2, 3, 4]) // 2.5
- * ```
- */
-export function avg(arr: number[]): number {
-  return average(arr)
-}
-
-/**
- * Returns the median of an array of numbers
- * @param arr
- * @category Array
- * @example
- * ```ts
- * median([1, 2, 3, 4]) // 2.5
- * ```
- */
-export function median(arr: number[]): number {
-  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: number
-
-  if (sorted.length % 2 !== 0)
-    medianValue = sorted[mid] as number
-  else medianValue = ((sorted[mid] as number) + (sorted[mid - 1] as number)) / 2 // or (sorted[mid - 1] + sorted[mid]) / 2
-
-  return medianValue
-}
-
-/**
- * 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 function mode(arr: number[]): number {
-  return arr.sort((a, b) => arr.filter(v => v === a).length - arr.filter(v => v === b).length).pop() as number
-}
-
-/**
- * Returns the sum of an array of numbers
- * @param array
- * @category Array
- * @example
- * ```ts
- * sum([1, 2, 3, 4]) // 10
- * ```
- */
-export function sum(array: readonly number[]): number {
-  return array.reduce((acc, cur) => acc + cur, 0)
-}
-
-/**
- * Returns the product of an array of numbers
- * @param array
- * @category Array
- * @example
- * ```ts
- * product([1, 2, 3, 4]) // 24
- * ```
- */
-export function product(array: readonly number[]): number {
-  return array.reduce((acc, cur) => acc * cur, 1)
-}
-
-/**
- * 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 function min(array: readonly number[]): number {
-  return Math.min(...array)
-}
-
-/**
- * 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 function max(array: readonly number[]): number {
-  return Math.max(...array)
-}
-
-/**
- * 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 function range(array: readonly number[]): number {
-  return max(array) - min(array)
-}
-
-/**
- * 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 function variance(array: number[]): number {
-  const mean = average(array)
-  return average(array.map(num => (num - mean) ** 2))
-}
-
-/**
- * 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 function standardDeviation(array: number[]): number {
-  return Math.sqrt(variance(array))
-}
-
-/**
- * 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 function zScore(array: number[], num: number): number {
-  return (num - average(array)) / standardDeviation(array)
-}
-
-/**
- * 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 function percentile(array: number[], num: number): number {
-  const sorted = [...array].sort((a, b) => a - b)
-  const index = (num / 100) * (sorted.length - 1)
-  const lower = Math.floor(index)
-  const upper = Math.ceil(index)
-  const weight = index - lower
-
-  if (upper === lower)
-    return sorted[index] ?? 0
-  return (1 - weight) * (sorted[lower] ?? 0) + weight * (sorted[upper] ?? 0)
-}
-
-/**
- * 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 function interquartileRange(array: number[]): number {
-  const q1 = median(array.slice(0, Math.floor(array.length / 2)))
-  const q3 = median(array.slice(Math.ceil(array.length / 2)))
-  return q3 - q1
-}
-
-/**
- * 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 function covariance(array1: number[], array2: number[]): number {
-  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] as number) - mean2)))
-}