@stacksjs/arrays 0.57.4 → 0.58.20

package/README.md

@@ -15,7 +15,7 @@ wip
 wip
 
 ```bash
-pnpm i -D @stacksjs/arrays
+bun install -d @stacksjs/arrays
 ```
 
 Now, you can use it in your project:
@@ -31,7 +31,7 @@ Learn more in the docs.
 ## 🧪 Testing
 
 ```bash
-pnpm test
+bun test
 ```
 
 ## 📈 Changelog
@@ -50,10 +50,10 @@ For help, discussion about best practices, or any other conversation that would
 
 For casual chit-chat with others using this package:
 
-[Join the Stacks Discord Server](https://discord.ow3.org)
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
 
 ## 📄 License
 
 The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
 
-Made with ❤️
+Made with 💙

package/dist/index.js

@@ -0,0 +1,469 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/arr.ts
+var exports_arr = {};
+__export(exports_arr, {
+  zScore: () => {
+    {
+      return zScore;
+    }
+  },
+  variance: () => {
+    {
+      return variance;
+    }
+  },
+  uniqueBy: () => {
+    {
+      return uniqueBy;
+    }
+  },
+  unique: () => {
+    {
+      return unique;
+    }
+  },
+  uniq: () => {
+    {
+      return uniq;
+    }
+  },
+  toArray: () => {
+    {
+      return toArray;
+    }
+  },
+  sum: () => {
+    {
+      return sum;
+    }
+  },
+  standardDeviation: () => {
+    {
+      return standardDeviation;
+    }
+  },
+  shuffle: () => {
+    {
+      return shuffle;
+    }
+  },
+  sample: () => {
+    {
+      return sample;
+    }
+  },
+  remove: () => {
+    {
+      return remove;
+    }
+  },
+  range: () => {
+    {
+      return range;
+    }
+  },
+  product: () => {
+    {
+      return product;
+    }
+  },
+  percentile: () => {
+    {
+      return percentile;
+    }
+  },
+  partition: () => {
+    {
+      return partition;
+    }
+  },
+  move: () => {
+    {
+      return move;
+    }
+  },
+  mode: () => {
+    {
+      return mode;
+    }
+  },
+  min: () => {
+    {
+      return min;
+    }
+  },
+  mergeArrayable: () => {
+    {
+      return mergeArrayable;
+    }
+  },
+  median: () => {
+    {
+      return median;
+    }
+  },
+  max: () => {
+    {
+      return max;
+    }
+  },
+  last: () => {
+    {
+      return last;
+    }
+  },
+  interquartileRange: () => {
+    {
+      return interquartileRange;
+    }
+  },
+  flatten: () => {
+    {
+      return flatten;
+    }
+  },
+  doesNotContain: () => {
+    {
+      return doesNotContain;
+    }
+  },
+  covariance: () => {
+    {
+      return covariance;
+    }
+  },
+  containsOnly: () => {
+    {
+      return containsOnly;
+    }
+  },
+  containsNone: () => {
+    {
+      return containsNone;
+    }
+  },
+  containsAny: () => {
+    {
+      return containsAny;
+    }
+  },
+  containsAll: () => {
+    {
+      return containsAll;
+    }
+  },
+  contains: () => {
+    {
+      return contains;
+    }
+  },
+  clampArrayRange: () => {
+    {
+      return clampArrayRange;
+    }
+  },
+  avg: () => {
+    {
+      return avg;
+    }
+  },
+  average: () => {
+    {
+      return average;
+    }
+  },
+  at: () => {
+    {
+      return at;
+    }
+  }
+});
+
+// src/helpers.ts
+import {clamp} from "@stacksjs/utils";
+function toArray(array) {
+  array = array ?? [];
+  return Array.isArray(array) ? array : [array];
+}
+function flatten(array) {
+  return toArray(array).flat(1);
+}
+function mergeArrayable(...args) {
+  return args.flatMap((i) => toArray(i));
+}
+function partition(array, ...filters) {
+  const result = Array.from({ length: filters.length + 1 }).fill(null).map(() => []);
+  array.forEach((e, idx, arr) => {
+    let i = 0;
+    for (const filter of filters) {
+      if (filter(e, idx, arr)) {
+        result[i].push(e);
+        return;
+      }
+      i += 1;
+    }
+    result[i].push(e);
+  });
+  return result;
+}
+function uniq(array) {
+  return Array.from(new Set(array));
+}
+function unique(array) {
+  return uniq(array);
+}
+function uniqueBy(array, equalFn) {
+  return array.reduce((acc, cur) => {
+    const index = acc.findIndex((item) => equalFn(cur, item));
+    if (index === -1)
+      acc.push(cur);
+    return acc;
+  }, []);
+}
+function last(array) {
+  return at(array, -1);
+}
+function remove(array, value) {
+  if (!array)
+    return false;
+  const index = array.indexOf(value);
+  if (index >= 0) {
+    array.splice(index, 1);
+    return true;
+  }
+  return false;
+}
+function at(array, index) {
+  const len = array.length;
+  if (!len)
+    return;
+  if (index < 0)
+    index += len;
+  return array[index];
+}
+function move(array, from, to) {
+  const len = array.length;
+  if (!len)
+    return [];
+  if (from < 0)
+    from += len;
+  if (to < 0)
+    to += len;
+  const item = array.splice(from, 1)[0];
+  array.splice(to, 0, item);
+  return array;
+}
+function clampArrayRange(arr, n) {
+  return clamp(n, 0, arr.length - 1);
+}
+function sample(arr, count) {
+  return Array.from({ length: count }, (_) => arr[Math.round(Math.random() * (arr.length - 1))]);
+}
+function shuffle(array) {
+  for (let i = array.length - 1;i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+}
+// src/math.ts
+function average(arr) {
+  return sum(arr) / arr.length;
+}
+function avg(arr) {
+  return average(arr);
+}
+function median(arr) {
+  return arr[Math.floor(arr.length / 2)];
+}
+function mode(arr) {
+  return arr.sort((a, b) => arr.filter((v) => v === a).length - arr.filter((v) => v === b).length).pop();
+}
+function sum(array) {
+  return array.reduce((acc, cur) => acc + cur, 0);
+}
+function product(array) {
+  return array.reduce((acc, cur) => acc * cur, 1);
+}
+function min(array) {
+  return Math.min(...array);
+}
+function max(array) {
+  return Math.max(...array);
+}
+function range(array) {
+  return max(array) - min(array);
+}
+function variance(array) {
+  const mean = average(array);
+  return average(array.map((num) => (num - mean) ** 2));
+}
+function standardDeviation(array) {
+  return Math.sqrt(variance(array));
+}
+function zScore(array, num) {
+  return (num - average(array)) / standardDeviation(array);
+}
+function percentile(array, num) {
+  return array.filter((n) => n < num).length / array.length;
+}
+function interquartileRange(array) {
+  const q1 = median(array.slice(0, Math.floor(array.length / 2)));
+  const q3 = median(array.slice(Math.ceil(array.length / 2)));
+  return q3 - q1;
+}
+function covariance(array1, array2) {
+  const mean1 = average(array1);
+  const mean2 = average(array2);
+  return average(array1.map((num1, i) => (num1 - mean1) * (array2[i] - mean2)));
+}
+// src/contains.ts
+function contains(needle, haystack) {
+  return haystack.some((hay) => needle.includes(hay));
+}
+function containsAll(needles, haystack) {
+  return needles.every((needle) => contains(needle, haystack));
+}
+function containsAny(needles, haystack) {
+  return needles.some((needle) => contains(needle, haystack));
+}
+function containsNone(needles, haystack) {
+  return !containsAny(needles, haystack);
+}
+function containsOnly(needles, haystack) {
+  return containsAll(haystack, needles);
+}
+function doesNotContain(needle, haystack) {
+  return !contains(needle, haystack);
+}
+// src/macro.ts
+var Arr = {
+  contains(needle, haystack) {
+    return contains(needle, haystack);
+  },
+  containsAll(needles, haystack) {
+    return containsAll(needles, haystack);
+  },
+  containsAny(needles, haystack) {
+    return containsAny(needles, haystack);
+  },
+  containsNone(needles, haystack) {
+    return containsNone(needles, haystack);
+  },
+  containsOnly(needles, haystack) {
+    return containsOnly(needles, haystack);
+  },
+  doesNotContain(needle, haystack) {
+    return doesNotContain(needle, haystack);
+  },
+  toArray(array) {
+    return toArray(array);
+  },
+  flatten(array) {
+    return flatten(array);
+  },
+  mergeArrayable(...args) {
+    return mergeArrayable(...args);
+  },
+  partition(array, filter) {
+    return partition(array, filter);
+  },
+  random(arr, count = 1) {
+    return sample(arr, count);
+  },
+  sample(arr, count = 1) {
+    return sample(arr, count);
+  },
+  unique(arr) {
+    return uniq(arr);
+  },
+  uniqueBy(arr, equalFn) {
+    return uniqueBy(arr, equalFn);
+  },
+  last(arr) {
+    return last(arr);
+  },
+  remove(arr, value) {
+    return remove(arr, value);
+  },
+  at(arr, index) {
+    return at(arr, index);
+  },
+  range(arr) {
+    return range(arr);
+  },
+  move(arr, from, to) {
+    return move(arr, from, to);
+  },
+  clampArrayRange(arr, n) {
+    return clampArrayRange(arr, n);
+  },
+  shuffle(arr) {
+    return shuffle(arr);
+  },
+  sum(arr) {
+    return sum(arr);
+  },
+  average(arr) {
+    return average(arr);
+  },
+  avg(arr) {
+    return average(arr);
+  },
+  median(arr) {
+    return median(arr);
+  },
+  mode(arr) {
+    return mode(arr);
+  }
+};
+export {
+  zScore,
+  variance,
+  uniqueBy,
+  unique,
+  uniq,
+  toArray,
+  sum,
+  standardDeviation,
+  shuffle,
+  sample,
+  remove,
+  range,
+  product,
+  percentile,
+  partition,
+  move,
+  mode,
+  min,
+  mergeArrayable,
+  median,
+  max,
+  last,
+  interquartileRange,
+  flatten,
+  doesNotContain,
+  covariance,
+  containsOnly,
+  containsNone,
+  containsAny,
+  containsAll,
+  contains,
+  clampArrayRange,
+  avg,
+  average,
+  at,
+  exports_arr as arr,
+  Arr
+};

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "@stacksjs/arrays",
   "type": "module",
-  "version": "0.57.4",
-  "packageManager": "pnpm@8.6.6",
+  "version": "0.58.20",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
-  "homepage": "https://github.com/stacksjs/stacks/tree/main/.stacks/core/arrays#readme",
+  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/src/arrays#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stacksjs/stacks.git",
-    "directory": "./.stacks/core/arrays"
+    "directory": "./storage/framework/core/src/arrays"
   },
   "bugs": {
     "url": "https://github.com/stacksjs/stacks/issues"
@@ -26,34 +25,35 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "bun": "./src/*",
+      "import": "./dist/*"
     }
   },
-  "module": "dist/index.mjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "contributors": [
-    "Chris Breuer <chris@ow3.org>"
+    "Chris Breuer <chris@stacksjs.org>"
   ],
   "files": [
-    "dist",
-    "README.md"
+    "README.md",
+    "dist"
   ],
+  "scripts": {
+    "build": "bun --bun build.ts",
+    "typecheck": "bun --bun tsc --noEmit",
+    "prepublishOnly": "bun --bun run build"
+  },
   "peerDependencies": {
-    "macroable": "^7.0.2",
-    "@stacksjs/types": "0.57.4",
-    "@stacksjs/utils": "0.57.4"
+    "@stacksjs/utils": "workspace:*"
   },
   "dependencies": {
-    "macroable": "^7.0.2"
+    "@stacksjs/utils": "workspace:*"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.57.4",
-    "@stacksjs/types": "0.57.4"
-  },
-  "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub",
-    "typecheck": "tsc --noEmit"
+    "@stacksjs/development": "workspace:*"
   }
-}
+}

package/LICENSE.md

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2022 Open Web Foundation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

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/contains.mjs

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

package/dist/helpers.d.ts

@@ -1,99 +0,0 @@
-import type { Arrayable, Nullable } from '@stacksjs/types';
-/**
- * Convert `Arrayable<T>` to `Array<T>`
- *
- * @category Array
- */
-export declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
-/**
- * Convert `Arrayable<T>` to `Array<T>` and flatten it
- *
- * @category Array
- */
-export declare function flatten<T>(array?: Nullable<Arrayable<T | Array<T>>>): Array<T>;
-/**
- * Use rest arguments to merge arrays
- *
- * @category Array
- */
-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 const [odd, even] = partition([1, 2, 3, 4], i => i % 2 != 0)
- */
-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
- */
-export declare function uniq<T>(array: readonly T[]): T[];
-export declare function unique<T>(array: readonly T[]): T[];
-/**
- * Unique an Array by a custom equality function
- *
- * @category Array
- */
-export declare function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[];
-/**
- * Get last item
- *
- * @category Array
- */
-export declare function last(array: readonly []): undefined;
-export declare function last<T>(array: readonly T[]): T;
-/**
- * Remove an item from Array
- *
- * @category Array
- */
-export declare function remove<T>(array: T[], value: T): boolean;
-/**
- * Get nth item of Array. Negative for backward
- *
- * @category Array
- */
-export declare function at(array: readonly [], index: number): undefined;
-export declare function at<T>(array: readonly T[], index: number): T;
-/**
- * Generate a range array of numbers. The `stop` is exclusive.
- *
- * @category Array
- */
-export declare function range(stop: number): number[];
-export declare function range(start: number, stop: number, step?: number): number[];
-/**
- * Move element in an Array
- *
- * @category Array
- * @param arr
- * @param from
- * @param to
- */
-export declare function move<T>(arr: T[], from: number, to: number): T[];
-/**
- * Clamp a number to the index range of an array.
- *
- * @category Array
- */
-export declare function clampArrayRange(arr: readonly unknown[], n: number): number;
-/**
- * Get random items from an array
- *
- * @category Array
- */
-export declare function sample<T>(arr: T[], count: number): T[];
-/**
- * Shuffle an array. This function mutates the array.
- *
- * @category Array
- */
-export declare function shuffle<T>(array: T[]): T[];

package/dist/helpers.mjs

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

package/dist/index.d.ts

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

package/dist/index.mjs

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

package/dist/macro.d.ts

@@ -1,52 +0,0 @@
-import { Macroable } from 'macroable';
-import type { Arrayable, Nullable } from '@stacksjs/types';
-import type { PartitionFilter } from './helpers';
-export declare class Arr extends Macroable {
-    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 | Array<T>>>): Array<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(start: number, end: number, step?: 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;
-    static macros: {};
-    static getters: {};
-}
-export declare const arr: Arr;

package/dist/macro.mjs

@@ -1,105 +0,0 @@
-import { Macroable } from "macroable";
-import { at, clampArrayRange, flatten, last, mergeArrayable, move, partition, range, remove, sample, shuffle, toArray, uniq, uniqueBy } from "./helpers.mjs";
-import { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from "./contains.mjs";
-import { average, median, mode, sum } from "./math.mjs";
-export class Arr extends Macroable {
-  contains(needle, haystack) {
-    return contains(needle, haystack);
-  }
-  containsAll(needles, haystack) {
-    return containsAll(needles, haystack);
-  }
-  containsAny(needles, haystack) {
-    return containsAny(needles, haystack);
-  }
-  containsNone(needles, haystack) {
-    return containsNone(needles, haystack);
-  }
-  containsOnly(needles, haystack) {
-    return containsOnly(needles, haystack);
-  }
-  doesNotContain(needle, haystack) {
-    return doesNotContain(needle, haystack);
-  }
-  toArray(array) {
-    return toArray(array);
-  }
-  flatten(array) {
-    return flatten(array);
-  }
-  mergeArrayable(...args) {
-    return mergeArrayable(...args);
-  }
-  partition(array, filter) {
-    return partition(array, filter);
-  }
-  /**
-   * Returns a random item/s from the array
-   */
-  random(arr2, count = 1) {
-    return sample(arr2, count);
-  }
-  /**
-   * Returns random item/s from the array
-   */
-  sample(arr2, count = 1) {
-    return sample(arr2, count);
-  }
-  unique(arr2) {
-    return uniq(arr2);
-  }
-  uniqueBy(arr2, equalFn) {
-    return uniqueBy(arr2, equalFn);
-  }
-  last(arr2) {
-    return last(arr2);
-  }
-  remove(arr2, value) {
-    return remove(arr2, value);
-  }
-  at(arr2, index) {
-    return at(arr2, index);
-  }
-  range(start, end, step = 1) {
-    return range(start, end, step);
-  }
-  move(arr2, from, to) {
-    return move(arr2, from, to);
-  }
-  clampArrayRange(arr2, n) {
-    return clampArrayRange(arr2, n);
-  }
-  shuffle(arr2) {
-    return shuffle(arr2);
-  }
-  /**
-   * Returns the sum of all items in the array
-   */
-  sum(arr2) {
-    return sum(arr2);
-  }
-  /**
-   * Returns the average of all items in the array
-   */
-  average(arr2) {
-    return average(arr2);
-  }
-  avg(arr2) {
-    return average(arr2);
-  }
-  /**
-   * Returns the median of all items in the array
-   */
-  median(arr2) {
-    return median(arr2);
-  }
-  /**
-   * Returns the mode of all items in the array
-   */
-  mode(arr2) {
-    return mode(arr2);
-  }
-}
-Arr.macros = {};
-Arr.getters = {};
-export const arr = new Arr();

package/dist/math.d.ts

@@ -1,5 +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;

package/dist/math.mjs

@@ -1,15 +0,0 @@
-export function average(arr) {
-  return sum(arr) / arr.length;
-}
-export function avg(arr) {
-  return average(arr);
-}
-export function median(arr) {
-  return arr[Math.floor(arr.length / 2)];
-}
-export function mode(arr) {
-  return arr.sort((a, b) => arr.filter((v) => v === a).length - arr.filter((v) => v === b).length).pop();
-}
-export function sum(array) {
-  return array.reduce((acc, cur) => acc + cur, 0);
-}