@stacksjs/arrays 0.59.11 → 0.61.0

package/dist/index.js

@@ -285,7 +285,16 @@ function avg(arr) {
   return average(arr);
 }
 function median(arr) {
-  return arr[Math.floor(arr.length / 2)];
+  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();
@@ -324,6 +333,8 @@ function interquartileRange(array) {
   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)));
@@ -380,10 +391,11 @@ var Arr = {
     return partition(array, filter);
   },
   random(arr, count = 1) {
-    return sample(arr, count);
+    return sample(arr, count).filter((item) => item != null);
   },
   sample(arr, count = 1) {
-    return sample(arr, count);
+    const sampleArr = sample(arr, count);
+    return sampleArr.filter((item) => item !== undefined);
   },
   unique(arr) {
     return uniq(arr);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/arrays",
   "type": "module",
-  "version": "0.59.11",
+  "version": "0.61.0",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
   "license": "MIT",

package/src/contains.ts

@@ -10,7 +10,7 @@
  * ```
  */
 export function contains(needle: string, haystack: string[]) {
-  return haystack.some(hay => needle.includes(hay))
+  return haystack.some((hay) => needle.includes(hay))
 }
 
 /**
@@ -24,7 +24,7 @@ export function contains(needle: string, haystack: string[]) {
  * ```
  */
 export function containsAll(needles: string[], haystack: string[]) {
-  return needles.every(needle => contains(needle, haystack))
+  return needles.every((needle) => contains(needle, haystack))
 }
 
 /**
@@ -39,7 +39,7 @@ export function containsAll(needles: string[], haystack: string[]) {
  * ```
  */
 export function containsAny(needles: string[], haystack: string[]) {
-  return needles.some(needle => contains(needle, haystack))
+  return needles.some((needle) => contains(needle, haystack))
 }
 
 /**

package/src/helpers.ts

@@ -45,7 +45,7 @@ export function flatten<T>(array?: Nullable<Arrayable<T | Array<T>>>): Array<T>
  * ```
  */
 export function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T> {
-  return args.flatMap(i => toArray(i))
+  return args.flatMap((i) => toArray(i))
 }
 
 export type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any
@@ -63,23 +63,51 @@ export type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any
  */
 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[],
+  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(() => [])
+  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]!.push(e)
+        ;(result[i] as T[]).push(e)
         return
       }
       i += 1
     }
-    result[i]!.push(e)
+    ;(result[i] as T[]).push(e)
   })
   return result
 }
@@ -122,8 +150,7 @@ export function unique<T>(array: readonly T[]): T[] {
 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)
+    if (index === -1) acc.push(cur)
     return acc
   }, [])
 }
@@ -155,8 +182,7 @@ export function last<T>(array: readonly T[]): T | undefined {
  * console.log(arr) // [1, 3]
  */
 export function remove<T>(array: T[], value: T) {
-  if (!array)
-    return false
+  if (!array) return false
 
   const index = array.indexOf(value)
   if (index >= 0) {
@@ -183,11 +209,9 @@ 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 (!len) return undefined
 
-  if (index < 0)
-    index += len
+  if (index < 0) index += len
 
   return array[index]
 }
@@ -210,17 +234,14 @@ export function at<T>(array: readonly T[] | [], index: number): T | undefined {
  */
 export function move<T>(array: T[], from: number, to: number): T[] {
   const len = array.length
-  if (!len)
-    return []
+  if (!len) return []
 
-  if (from < 0)
-    from += len
+  if (from < 0) from += len
 
-  if (to < 0)
-    to += len
+  if (to < 0) to += len
 
   const item = array.splice(from, 1)[0]
-  array.splice(to, 0, item!)
+  array.splice(to, 0, item as T)
   return array
 }
 
@@ -251,7 +272,7 @@ export function clampArrayRange(arr: readonly unknown[], n: number) {
  * ```
  */
 export function sample<T>(arr: T[], count: number) {
-  return Array.from({ length: count }, _ => arr[Math.round(Math.random() * (arr.length - 1))])
+  return Array.from({ length: count }, (_) => arr[Math.round(Math.random() * (arr.length - 1))])
 }
 
 /**
@@ -265,8 +286,8 @@ export function sample<T>(arr: T[], count: number) {
  */
 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]!, array[j]!] = [array[j]!, array[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/macro.ts

@@ -1,8 +1,22 @@
 import type { Arrayable, Nullable } from '@stacksjs/types'
+import { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from './contains'
 import type { PartitionFilter } from './helpers'
-import { at, clampArrayRange, flatten, last, mergeArrayable, move, partition, remove, sample, shuffle, toArray, uniq, uniqueBy } from './helpers'
+import {
+  at,
+  clampArrayRange,
+  flatten,
+  last,
+  mergeArrayable,
+  move,
+  partition,
+  remove,
+  sample,
+  shuffle,
+  toArray,
+  uniq,
+  uniqueBy,
+} from './helpers'
 import { average, median, mode, range, sum } from './math'
-import { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from './contains'
 
 export const Arr = {
   contains(needle: string, haystack: string[]) {
@@ -49,14 +63,18 @@ export const Arr = {
    * Returns a random item/s from the array
    */
   random<T>(arr: T[], count = 1): T[] {
-    return sample(arr, count)
+    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)
+    // Get the sample array (may contain undefined values)
+    const sampleArr = sample(arr, count)
+
+    // Filter out any undefined values
+    return sampleArr.filter((item): item is T => item !== undefined)
   },
 
   unique<T>(arr: T[]): T[] {

package/src/math.ts

@@ -34,7 +34,18 @@ export function avg(arr: number[]): number {
  * ```
  */
 export function median(arr: number[]): number {
-  return arr[Math.floor(arr.length / 2)]
+  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
 }
 
 /**
@@ -51,7 +62,7 @@ export function median(arr: number[]): number {
  * ```
  */
 export function mode(arr: number[]): number {
-  return arr.sort((a, b) => arr.filter(v => v === a).length - arr.filter(v => v === b).length).pop()!
+  return arr.sort((a, b) => arr.filter((v) => v === a).length - arr.filter((v) => v === b).length).pop() as number
 }
 
 /**
@@ -135,7 +146,7 @@ export function range(array: readonly number[]): number {
  */
 export function variance(array: number[]): number {
   const mean = average(array)
-  return average(array.map(num => (num - mean) ** 2))
+  return average(array.map((num) => (num - mean) ** 2))
 }
 
 /**
@@ -182,7 +193,7 @@ export function zScore(array: number[], num: number): number {
  * @see https://en.wikipedia.org/wiki/Percentile
  */
 export function percentile(array: number[], num: number): number {
-  return array.filter(n => n < num).length / array.length
+  return array.filter((n) => n < num).length / array.length
 }
 
 /**
@@ -214,7 +225,10 @@ export function interquartileRange(array: number[]): number {
  * ```
  */
 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] - mean2)))
+
+  return average(array1.map((num1, i) => (num1 - mean1) * ((array2[i] as number) - mean2)))
 }

package/dist/arr.d.ts

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

package/dist/contains.d.ts

@@ -1,70 +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 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/helpers.d.ts

@@ -1,174 +0,0 @@
-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 | Array<T>>>): Array<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>;
-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 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
- *
- * @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 | undefined)[];
-/**
- * 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[];

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,94 +0,0 @@
-import type { Arrayable, Nullable } from '@stacksjs/types';
-import type { PartitionFilter } from './helpers';
-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?: any): Array<T>;
-    flatten<T_1>(array?: any): T_1[];
-    mergeArrayable<T_2>(...args: Nullable<Arrayable<T_2>>[]): T_2[];
-    partition<T_3>(array: readonly T_3[], filter: PartitionFilter<T_3>): [T_3[], T_3[]];
-    /**
-     * Returns a random item/s from the array
-     */
-    random<T_4>(arr: T_4[], count?: number): T_4[];
-    /**
-     * Returns random item/s from the array
-     */
-    sample<T_5>(arr: T_5[], count?: number): T_5[];
-    unique<T_6>(arr: T_6[]): T_6[];
-    uniqueBy<T_7>(arr: readonly T_7[], equalFn: (a: any, b: any) => boolean): T_7[];
-    last<T_8>(arr: T_8[]): T_8 | undefined;
-    remove<T_9>(arr: T_9[], value: T_9): boolean;
-    at(arr: any[], index: number): any;
-    range(arr: readonly number[]): number;
-    move<T_10>(arr: T_10[], from: number, to: number): T_10[];
-    clampArrayRange(arr: readonly unknown[], n: number): number;
-    shuffle<T_11>(arr: T_11[]): T_11[];
-    /**
-     * 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: {
-    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?: any): Array<T>;
-    flatten<T_1>(array?: any): T_1[];
-    mergeArrayable<T_2>(...args: Nullable<Arrayable<T_2>>[]): T_2[];
-    partition<T_3>(array: readonly T_3[], filter: PartitionFilter<T_3>): [T_3[], T_3[]];
-    /**
-     * Returns a random item/s from the array
-     */
-    random<T_4>(arr: T_4[], count?: number): T_4[];
-    /**
-     * Returns random item/s from the array
-     */
-    sample<T_5>(arr: T_5[], count?: number): T_5[];
-    unique<T_6>(arr: T_6[]): T_6[];
-    uniqueBy<T_7>(arr: readonly T_7[], equalFn: (a: any, b: any) => boolean): T_7[];
-    last<T_8>(arr: T_8[]): T_8 | undefined;
-    remove<T_9>(arr: T_9[], value: T_9): boolean;
-    at(arr: any[], index: number): any;
-    range(arr: readonly number[]): number;
-    move<T_10>(arr: T_10[], from: number, to: number): T_10[];
-    clampArrayRange(arr: readonly unknown[], n: number): number;
-    shuffle<T_11>(arr: T_11[]): T_11[];
-    /**
-     * 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;
-};

package/dist/math.d.ts

@@ -1,171 +0,0 @@
-/**
- * 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
- * @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;