@stacksjs/arrays 0.70.23 → 0.70.25

package/dist/index.js

@@ -1,2 +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){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};
+function M(z,E){return E.some((G)=>z.includes(G))}function W(z,E){return z.every((G)=>M(G,E))}function X(z,E){return z.some((G)=>M(G,E))}function D(z,E){return!X(z,E)}function O(z,E){return W(E,z)}function S(z,E){return!M(z,E)}import{clamp as p}from"@stacksjs/utils";function P(z){return z=z??[],Array.isArray(z)?z:[z]}function Y(z){return P(z).reduce((E,G)=>E.concat(Array.isArray(G)?Y(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,J)=>{let L=0;for(let U of E){if(U(H,I,J)){G[L].push(H);return}L+=1}G[L].push(H)}),G}function Z(z){return Array.from(new Set(z))}function m(z){return Z(z)}function V(z,E){return z.reduce((G,H)=>{if(G.findIndex((J)=>E(H,J))===-1)G.push(H);return G},[])}function F(z){return _(z,-1)}function N(z,E){if(!z)return!1;let G=z.indexOf(E);if(G>=0)return z.splice(G,1),!0;return!1}function _(z,E){let G=z.length;if(!G)return;if(E<0)E+=G;return z[E]}function R(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 C(z,E){return p(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 K(z){if(z.length===0)throw Error("Cannot compute average of an empty array");return B(z)/z.length}function d(z){return K(z)}function Q(z){if(z.length===0)throw Error("Cannot compute median of an empty array");let E=[...z].sort((I,J)=>I-J),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 b(z){if(z.length===0)throw Error("Cannot compute mode of an empty array");let E=new Map;for(let I of z)E.set(I,(E.get(I)||0)+1);let G=0,H=z[0];for(let[I,J]of E)if(J>G)G=J,H=I;return H}function B(z){return z.reduce((E,G)=>E+G,0)}function o(z){let E=1;for(let G of z)if(E*=G,Number.isFinite(E)&&Math.abs(E)>Number.MAX_SAFE_INTEGER)throw RangeError(`[arrays.product] Result exceeds Number.MAX_SAFE_INTEGER (${Number.MAX_SAFE_INTEGER}); use BigInt for large products.`);return E}function x(z){if(z.length===0)throw Error("Cannot compute min of an empty array");return Math.min(...z)}function g(z){if(z.length===0)throw Error("Cannot compute max of an empty array");return Math.max(...z)}function q(z){return g(z)-x(z)}function k(z){let E=K(z);return K(z.map((G)=>(G-E)**2))}function f(z){return Math.sqrt(k(z))}function i(z,E){return(E-K(z))/f(z)}function l(z,E){let G=[...z].sort((U,A)=>U-A),H=E/100*(G.length-1),I=Math.floor(H),J=Math.ceil(H),L=H-I;if(J===I)return G[H]??0;return(1-L)*(G[I]??0)+L*(G[J]??0)}function c(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 Error("Arrays must have the same length");let G=K(z),H=K(E);return K(z.map((I,J)=>(I-G)*(E[J]-H)))}var r={contains(z,E){return M(z,E)},containsAll(z,E){return W(z,E)},containsAny(z,E){return X(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 Y(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 Z(z)},uniqueBy(z,E){return V(z,E)},last(z){return F(z)},remove(z,E){return N(z,E)},at(z,E){return _(z,E)},range(z){return q(z)},move(z,E,G){return R(z,E,G)},clampArrayRange(z,E){return C(z,E)},shuffle(z){return w(z)},sum(z){return B(z)},average(z){return K(z)},avg(z){return K(z)},median(z){return Q(z)},mode(z){return b(z)}};export{i as zScore,k as variance,V as uniqueBy,m as unique,Z as uniq,P as toArray,B as sum,f as standardDeviation,w as shuffle,$ as sample,N as remove,q as range,o as product,l as percentile,j as partition,R as move,b as mode,x as min,T as mergeArrayable,Q as median,g as max,F as last,c as interquartileRange,Y as flatten,S as doesNotContain,s as covariance,O as containsOnly,D as containsNone,X as containsAny,W as containsAll,M as contains,C as clampArrayRange,d as avg,K as average,_ as at,Gz as arr,r as Arr};

package/dist/src/arr.d.ts

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

package/dist/src/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/src/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/src/index.d.ts

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

package/dist/src/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/src/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/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@stacksjs/arrays",
   "type": "module",
-  "version": "0.70.23",
+  "version": "0.70.25",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
-  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
+  "contributors": [
+    "Chris Breuer <chris@stacksjs.com>"
+  ],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/arrays#readme",
@@ -26,15 +28,21 @@
   ],
   "exports": {
     ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
     "./*": {
+      "bun": "./src/*",
       "import": "./dist/*"
     }
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["README.md", "dist"],
+  "files": [
+    "README.md",
+    "dist"
+  ],
   "scripts": {
     "build": "bun build.ts",
     "typecheck": "bun tsc --noEmit",
@@ -42,7 +50,8 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.70.22",
-    "@stacksjs/utils": "0.70.22"
-  }
+    "better-dx": "^0.2.12",
+    "@stacksjs/utils": "0.70.23"
+  },
+  "sideEffects": false
 }

package/dist/arr.d.ts

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

package/dist/contains.d.ts

@@ -1,6 +0,0 @@
-export declare function contains(needle: string, haystack: string[]): boolean;
-export declare function containsAll(needles: string[], haystack: string[]): boolean;
-export declare function containsAny(needles: string[], haystack: string[]): boolean;
-export declare function containsNone(needles: string[], haystack: string[]): boolean;
-export declare function containsOnly(needles: string[], haystack: string[]): boolean;
-export declare function doesNotContain(needle: string, haystack: string[]): boolean;

package/dist/helpers.d.ts

@@ -1,27 +0,0 @@
-import type { Nullable } from '@stacksjs/types';
-
-export declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
-export declare function flatten<T>(array?: Nullable<Arrayable<T | T[]>>): T[];
-export declare function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T>;
-export declare type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any
-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[]];
-export declare function partition<T>(array: readonly T[], ...filters: PartitionFilter<T>[]): any;
-export declare function uniq<T>(array: readonly T[]): T[];
-export declare function unique<T>(array: readonly T[]): T[];
-export declare function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any)): T[];
-export declare function last(array: readonly []): undefined;
-export declare function last<T>(array: readonly T[]): T;
-export declare function last<T>(array: readonly T[]): T | undefined;
-export declare function remove<T>(array: T[], value: T): boolean;
-export declare function at(array: readonly [], index: number): undefined;
-export declare function at<T>(array: readonly T[], index: number): T;
-export declare function at<T>(array: readonly T[] | [], index: number): T | undefined;
-export declare function move<T>(array: T[], from: number, to: number): T[];
-export declare function clampArrayRange(arr: readonly unknown[], n: number): number;
-export declare function sample<T>(arr: T[], count: number): T[];
-export declare function shuffle<T>(array: T[]): T[];

package/dist/index.d.ts

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

package/dist/macro.d.ts

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

package/dist/math.d.ts

@@ -1,15 +0,0 @@
-export declare function average(arr: number[]): number;
-export declare function avg(arr: number[]): number;
-export declare function median(arr: number[]): number;
-export declare function mode(arr: number[]): number;
-export declare function sum(array: readonly number[]): number;
-export declare function product(array: readonly number[]): number;
-export declare function min(array: readonly number[]): number;
-export declare function max(array: readonly number[]): number;
-export declare function range(array: readonly number[]): number;
-export declare function variance(array: number[]): number;
-export declare function standardDeviation(array: number[]): number;
-export declare function zScore(array: number[], num: number): number;
-export declare function percentile(array: number[], num: number): number;
-export declare function interquartileRange(array: number[]): number;
-export declare function covariance(array1: number[], array2: number[]): number;