@limitlesspc/std 0.21.0 → 0.22.0

package/dist/math/index.d.ts

@@ -1,6 +1,6 @@
 import { int, uint } from '../types.js';
-import { V as Vec } from '../vec3-S_YuL-W1.js';
-export { R as ReadonlyVec3Like, b as Vec3, a as Vec3Like, v as vec3 } from '../vec3-S_YuL-W1.js';
+import { a as Vec } from '../vec3-a5RuSVIr.js';
+export { R as ReadonlyVec3Like, V as Vec3, b as Vec3Like, v as vec3 } from '../vec3-a5RuSVIr.js';
 
 /**
  * Determines if a value is a number other than `NaN`
@@ -8,15 +8,14 @@ export { R as ReadonlyVec3Like, b as Vec3, a as Vec3Like, v as vec3 } from '../v
  */
 declare function isNumber(x: unknown): x is number;
 /**
- * Determines if a value is a finite number other than `NaN`
- * @param x
- */
-declare function isReal(x: unknown): x is number;
-/**
- * Determines if a value is an integer
- * @param x
+ * Squares a number, or multiplies it by itself
+ * @example
+ * ```ts
+ * sq(3) // 9
+ * sq(36) // 36
+ * ```
  */
-declare function isInteger(x: unknown): x is int;
+declare function sq(x: number): number;
 /**
  * Rounds `x` to the nearest multiple of `n`
  * @param x the number to round
@@ -37,7 +36,7 @@ declare function smootherstep(x: number, min: number, max: number): number;
 declare function clamp(n: number, min: number, max: number): number;
 declare function overlap(min1: number, max1: number, min2: number, max2: number): number;
 /** Returns which number (a or b) is closer to x */
-declare function closer(x: number, a: [number, number], b: [number, number]): number;
+declare function closer(x: number, a: number, b: number): number;
 declare function round(n: number, precision?: int): number;
 declare function floor(n: number, precision?: int): number;
 declare function ceil(n: number, precision?: int): number;
@@ -45,28 +44,31 @@ declare function trunc(n: number, precision?: int): number;
 declare function fract(x: number): number;
 declare function closeTo(n: number, target: number, precision?: int): boolean;
 declare function factorial(n: uint): number;
+/**
+ * Logarithm using any base
+ * @param base the logarithm's base
+ * @param x the number to take the logarithm of
+ * @returns the exponent which the base is raised to, to equal x
+ */
 declare function log(base: number, x: number): number;
+/**
+ * Natural logarithm, or log base e
+ * Simply an alias for `Math.log`
+ */
 declare const ln: (x: number) => number;
 /**
- * Calculates the greatest common factor between the numbers
+ * Calculates the greatest common factor between two numbers
  * a and b using the [Euclidean algorithm](https://www.wikiwand.com/en/Euclidean_algorithm)
  * @param a a number
  * @param b a number
  */
-declare function gcd(a: uint, b: uint): number;
+declare function gcd(a: uint, b: uint): uint;
+declare function gcd(a: bigint, b: bigint): bigint;
 declare function fibonacci(n: uint): number;
 /** Convert farhenheit to celsius */
 declare const celsius: (fahrenheit: number) => number;
 /** Convert celsius to farhenheit */
 declare const fahrenheit: (celsius: number) => number;
-/**
- * @param points a list of (x,y) points
- * @returns the line of best fit in terms of m and b in the form y = mx + b
- */
-declare function lineOfBestFit(points: Array<{
-    x: number;
-    y: number;
-}>): [m: number, b: number];
 /**
  * Calculates the number of ways to choose `k` items from `n` items without repeating and with ordering
  * @param n the number of items
@@ -79,7 +81,6 @@ declare function permutations(n: uint, k: uint): number;
  * @param k the number of choices being made
  */
 declare function combinations(n: uint, k: uint): number;
-declare function dot(a: Iterable<number>, b: Iterable<number>): number;
 
 /** @unstable */
 declare class Mat extends Float32Array {
@@ -268,9 +269,9 @@ declare function product(iter: Iterable<number>): number;
  * @returns The average
  * @example
  * ```ts
- * const numbers = [1, 2, 3, 4, 5];
+ * const numbers = [1, 2, 3, 4];
  * const average = avg(numbers);
- * console.log(average); // 3
+ * console.log(average); // 2.5
  * ```
  */
 declare function avg(iter: Iterable<number>): number;
@@ -307,14 +308,14 @@ declare function median(array: number[]): number;
  */
 declare function mode<T>(iter: Iterable<T>): T[];
 /**
- * Returns the variance of an iterable of numbers
+ * Returns the variance of an array of numbers
  * @param iter The iterable of numbers
  * @returns The variance
  * @example
  * ```ts
  * const numbers = [1, 2, 3, 4, 5];
  * const variance = variance(numbers);
- * console.log(variance); // 2.5
+ * console.log(variance); // 2
  * ```
  */
 declare function variance(iter: Iterable<number>): number;
@@ -326,7 +327,7 @@ declare function variance(iter: Iterable<number>): number;
  * ```ts
  * const numbers = [1, 2, 3, 4, 5];
  * const stddev = stddev(numbers);
- * console.log(stddev); // 1.5811388300841898
+ * console.log(stddev); // 1.414
  * ```
  */
 declare function stddev(iter: Iterable<number>): number;
@@ -345,10 +346,10 @@ declare function meanAbsDev(iter: Iterable<number>): number;
 
 /** The ratio to convert degrees to radians */
 declare const DEG2RAD: number;
-/** Converts radians to degrees */
-declare const degrees: (radians: number) => number;
 /** Converts degrees to radians */
 declare const radians: (degrees: number) => number;
+/** Converts radians to degrees */
+declare const degrees: (radians: number) => number;
 
 type Vec2Like = [x: number, y: number] | Float32Array;
 type ReadonlyVec2Like = Readonly<Vec2Like>;
@@ -373,10 +374,10 @@ declare class Vec2 extends Float32Array implements Vec {
     div(x: First$1, y?: number): this;
     static div(v1: Vec2, x: First$1, y?: number): Vec2;
     static fma(a: ReadonlyVec2Like, b: ReadonlyVec2Like, c: ReadonlyVec2Like): Vec2;
-    lt(x: ReadonlyVec2Like): Vec2;
-    lte(x: ReadonlyVec2Like): Vec2;
-    gt(x: ReadonlyVec2Like): Vec2;
-    gte(x: ReadonlyVec2Like): Vec2;
+    lt(v: ReadonlyVec2Like): Vec2;
+    lte(v: ReadonlyVec2Like): Vec2;
+    gt(v: ReadonlyVec2Like): Vec2;
+    gte(v: ReadonlyVec2Like): Vec2;
     mag(): number;
     setMag(n: number): this;
     magSq(): number;
@@ -437,10 +438,10 @@ declare class Vec4 extends Float32Array implements Vec {
     div(x: First, y?: number, z?: number, w?: number): this;
     static div(v1: Vec4, x: First, y?: number, z?: number, w?: number): Vec4;
     static fma(a: ReadonlyVec4Like, b: ReadonlyVec4Like, c: ReadonlyVec4Like): Vec4;
-    lt(x: ReadonlyVec4Like): Vec4;
-    lte(x: ReadonlyVec4Like): Vec4;
-    gt(x: ReadonlyVec4Like): Vec4;
-    gte(x: ReadonlyVec4Like): Vec4;
+    lt(v: ReadonlyVec4Like): Vec4;
+    lte(v: ReadonlyVec4Like): Vec4;
+    gt(v: ReadonlyVec4Like): Vec4;
+    gte(v: ReadonlyVec4Like): Vec4;
     limit(max: number): this;
     normalize(): this;
     static normalize(v: Vec4): Vec4;
@@ -460,4 +461,4 @@ declare class Vec4 extends Float32Array implements Vec {
 }
 declare function vec4(x?: First, y?: number, z?: number, w?: number): Vec4;
 
-export { DEG2RAD, Mat, Mat2, type Mat2Like, Mat3, type Mat3Like, Mat4, type Mat4Like, type ReadonlyMat2Like, type ReadonlyMat3Like, type ReadonlyMat4Like, type ReadonlyVec2Like, type ReadonlyVec4Like, Vec, Vec2, type Vec2Like, Vec4, type Vec4Like, avg, ceil, celsius, clamp, closeTo, closer, combinations, degrees, dot, factorial, fahrenheit, fibonacci, floor, fract, gcd, isInteger, isNumber, isReal, lerp, lineOfBestFit, ln, log, map, mat, mat2, mat3, mat4, max, meanAbsDev, median, min, minmax, mode, norm, overlap, permutations, product, radians, round, roundToEven, roundToMultiple, smootherstep, smoothstep, stddev, step, sum, trunc, variance, vec2, vec4 };
+export { DEG2RAD, Mat, Mat2, type Mat2Like, Mat3, type Mat3Like, Mat4, type Mat4Like, type ReadonlyMat2Like, type ReadonlyMat3Like, type ReadonlyMat4Like, type ReadonlyVec2Like, type ReadonlyVec4Like, Vec, Vec2, type Vec2Like, Vec4, type Vec4Like, avg, ceil, celsius, clamp, closeTo, closer, combinations, degrees, factorial, fahrenheit, fibonacci, floor, fract, gcd, isNumber, lerp, ln, log, map, mat, mat2, mat3, mat4, max, meanAbsDev, median, min, minmax, mode, norm, overlap, permutations, product, radians, round, roundToEven, roundToMultiple, smootherstep, smoothstep, sq, stddev, step, sum, trunc, variance, vec2, vec4 };

package/dist/math/index.js

@@ -15,18 +15,14 @@ import {
   closer,
   combinations,
   degrees,
-  dot,
   factorial,
   fahrenheit,
   fibonacci,
   floor,
   fract,
   gcd,
-  isInteger,
   isNumber,
-  isReal,
   lerp,
-  lineOfBestFit,
   ln,
   log,
   map,
@@ -50,6 +46,7 @@ import {
   roundToMultiple,
   smootherstep,
   smoothstep,
+  sq,
   stddev,
   step,
   sum,
@@ -58,12 +55,11 @@ import {
   vec2,
   vec3,
   vec4
-} from "../chunk-AZEZMYQ5.js";
-import "../chunk-O3YCU3KN.js";
-import "../chunk-65SNM7MP.js";
-import "../chunk-WBSY6KRH.js";
-import "../chunk-MG5VQSTV.js";
-import "../chunk-6F4PWJZI.js";
+} from "../chunk-BSIDYYJX.js";
+import "../chunk-SSSOLDLG.js";
+import "../chunk-4POIKW4G.js";
+import "../chunk-CCBSTDYA.js";
+import "../chunk-NXILTE26.js";
 import "../chunk-TMLWLR46.js";
 import "../chunk-LJSF3QBT.js";
 export {
@@ -83,18 +79,14 @@ export {
   closer,
   combinations,
   degrees,
-  dot,
   factorial,
   fahrenheit,
   fibonacci,
   floor,
   fract,
   gcd,
-  isInteger,
   isNumber,
-  isReal,
   lerp,
-  lineOfBestFit,
   ln,
   log,
   map,
@@ -118,6 +110,7 @@ export {
   roundToMultiple,
   smootherstep,
   smoothstep,
+  sq,
   stddev,
   step,
   sum,

package/dist/random.js

@@ -5,11 +5,10 @@ import {
   randomInt,
   sample,
   shuffle
-} from "./chunk-O3YCU3KN.js";
-import "./chunk-65SNM7MP.js";
-import "./chunk-WBSY6KRH.js";
-import "./chunk-MG5VQSTV.js";
-import "./chunk-6F4PWJZI.js";
+} from "./chunk-SSSOLDLG.js";
+import "./chunk-4POIKW4G.js";
+import "./chunk-CCBSTDYA.js";
+import "./chunk-NXILTE26.js";
 import "./chunk-TMLWLR46.js";
 import "./chunk-LJSF3QBT.js";
 export {

package/dist/string/index.js

@@ -13,7 +13,7 @@ function listItems(items, conjunction = "and") {
       return "";
     }
     case 1: {
-      return items[0] || "";
+      return items[0];
     }
     case 2: {
       return items.join(` ${conjunction} `);
@@ -65,14 +65,16 @@ function splitOnce(str, separator) {
   return [before, after];
 }
 function reverse(str) {
-  return [...str].reverse().join("");
+  const chars = [...str];
+  chars.reverse();
+  return chars.join("");
 }
 function replace(str, replacements) {
   const regex = new RegExp(
     Object.keys(replacements).map(escapeRegex).join("|"),
     "g"
   );
-  return str.replace(regex, (matched) => replacements[matched] || "");
+  return str.replace(regex, (matched) => replacements[matched]);
 }
 var escapeInRegexRegex = /[$()*+./?[\\\]^{|}-]/g;
 function escapeRegex(regexStr) {

package/dist/structs/index.d.ts

@@ -1,29 +1,5 @@
-import { uint, int } from '../types.js';
 import { Compare } from '../cmp.js';
-
-interface Node$1<T> {
-    value: T;
-    next?: Node$1<T>;
-    prev?: Node$1<T>;
-}
-declare class DoublyLinkedList<T> implements Iterable<T> {
-    private head?;
-    private tail?;
-    private size;
-    static from<T>(values: Iterable<T>): DoublyLinkedList<T>;
-    get length(): uint;
-    [Symbol.iterator](): Iterator<T>;
-    getNode(index: uint): Node$1<T> | undefined;
-    get(index: uint): T | undefined;
-    set(index: uint, value: T): T | undefined;
-    push(value: T): uint;
-    pop(): T | undefined;
-    unshift(value: T): uint;
-    shift(): T | undefined;
-    reverse(): this;
-    remove(index: uint): T | undefined;
-    splice(index: uint, count: uint, ...values: T[]): T[];
-}
+import { uint, int } from '../types.js';
 
 /**
  * ## Binary Heap
@@ -64,55 +40,6 @@ declare class Heap<T> implements Iterable<T> {
     protected heapify(i?: number): void;
 }
 
-declare class MaxHeap<T> extends Heap<T> {
-    constructor(data?: T[], heapify?: boolean);
-    copy(): MaxHeap<T>;
-}
-
-declare class MinHeap<T> extends Heap<T> {
-    constructor(data?: T[], heapify?: boolean);
-    copy(): MinHeap<T>;
-}
-
-interface Node<T> {
-    value: T;
-    next?: Node<T>;
-}
-declare class LinkedList<T> implements Iterable<T> {
-    node?: Node<T>;
-    static from<T>(values: Iterable<T>): LinkedList<T>;
-    get length(): uint;
-    [Symbol.iterator](): Iterator<T>;
-    get tail(): Node<T> | undefined;
-    getNode(index: uint): Node<T> | undefined;
-    get(index: uint): T | undefined;
-    set(index: uint, value: T): T | undefined;
-    push(value: T): void;
-    pop(): Node<T> | undefined;
-    unshift(value: T): void;
-    shift(): Node<T> | undefined;
-}
-
-/**
- * ## Queue
- * A data structure that follows a first-in-first-out (FIFO) order
- *
- * | Method      | Average Case | Worst Case |
- * | ----------- | ------------ | ---------- |
- * | enqueue()   | O(1)         | O(1)       |
- * | dequeue()   | O(1)         | O(1)       |
- *
- * @see https://en.wikipedia.org/wiki/Queue_(abstract_data_type)
- */
-declare class Queue<T> implements Iterable<T> {
-    protected items: T[];
-    constructor(items?: T[]);
-    get size(): uint;
-    enqueue(item: T): uint;
-    dequeue(): T | undefined;
-    [Symbol.iterator](): Iterator<T>;
-}
-
 /**
  * ## Sorted Array
  * An array that maintains sorted order
@@ -181,4 +108,4 @@ declare class UnorderedArray<T> extends Array<T> {
     toSpliced(start: uint, deleteCount?: number, ...items: T[]): T[];
 }
 
-export { DoublyLinkedList, LinkedList, MaxHeap, MinHeap, Queue, SortedArray, UnorderedArray };
+export { Heap, SortedArray, UnorderedArray };

package/dist/structs/index.js

@@ -1,24 +1,238 @@
 import {
-  DoublyLinkedList,
-  LinkedList,
-  MaxHeap,
-  MinHeap,
-  Queue,
-  SortedArray,
-  UnorderedArray
-} from "../chunk-DYKZK6B5.js";
-import "../chunk-65SNM7MP.js";
-import "../chunk-WBSY6KRH.js";
-import "../chunk-MG5VQSTV.js";
-import "../chunk-6F4PWJZI.js";
-import "../chunk-TMLWLR46.js";
+  swap
+} from "../chunk-4POIKW4G.js";
+import "../chunk-CCBSTDYA.js";
+import "../chunk-NXILTE26.js";
+import {
+  ascend
+} from "../chunk-TMLWLR46.js";
 import "../chunk-LJSF3QBT.js";
+
+// src/structs/heap.ts
+var Heap = class _Heap {
+  constructor(compare, data = [], heapify = true) {
+    this.compare = compare;
+    if (heapify) {
+      this.data = [];
+      this.push(...data);
+    } else {
+      this.data = data;
+    }
+  }
+  data;
+  get length() {
+    return this.data.length;
+  }
+  get height() {
+    return Math.floor(Math.log2(this.length)) + 1;
+  }
+  valueOf() {
+    return this.peek();
+  }
+  copy() {
+    return new _Heap(this.compare, [...this.data], false);
+  }
+  /**
+   * Returns the first value in the heap
+   */
+  peek() {
+    return this.data[0];
+  }
+  /**
+   * Removes the first value from the heap and returns it
+   */
+  pop() {
+    const first = this.data[0];
+    swap(this.data, 0, this.length - 1);
+    this.data.pop();
+    this.heapify();
+    return first;
+  }
+  /**
+   * Inserts values into the heap and makes sure the first value is the min/max
+   * @param values
+   * @returns The new length of the heap
+   */
+  push(...values) {
+    const { data, compare } = this;
+    for (const value of values) {
+      data.push(value);
+      let i = data.length - 1;
+      let parent = Math.floor((i - 1) / 2);
+      while (i > 0 && compare(data[i], data[parent]) < 0) {
+        swap(data, i, parent);
+        i = parent;
+        parent = Math.floor((i - 1) / 2);
+      }
+    }
+    return data.length;
+  }
+  *drain() {
+    while (this.length) {
+      yield this.pop();
+    }
+  }
+  [Symbol.iterator]() {
+    return this.data.values();
+  }
+  heapify(i = 0) {
+    const { length, compare, data } = this;
+    const left = 2 * i + 1;
+    const right = 2 * i + 2;
+    let largest = i;
+    if (left < length && compare(data[left], data[largest]) < 0) {
+      largest = left;
+    }
+    if (right < length && compare(data[right], data[largest]) < 0) {
+      largest = right;
+    }
+    if (largest !== i) {
+      swap(data, i, largest);
+      this.heapify(largest);
+    }
+  }
+};
+
+// src/structs/sorted-array.ts
+var SortedArray = class _SortedArray {
+  constructor(data = [], compare = ascend, sort = true) {
+    this.data = data;
+    this.compare = compare;
+    if (sort) {
+      this.data.sort(compare);
+    }
+  }
+  valueOf() {
+    return this.at(0);
+  }
+  keys() {
+    return this.data.keys();
+  }
+  values() {
+    return this.data.values();
+  }
+  entries() {
+    return this.data.entries();
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  length() {
+    return this.data.length;
+  }
+  at(index) {
+    return this.data[index];
+  }
+  copy() {
+    return new _SortedArray([...this.data], this.compare, false);
+  }
+  /**
+   * Returns the index of the value if it exists, otherwise -1
+   * @param value
+   */
+  indexOf(value) {
+    const { data } = this;
+    let low = 0;
+    let high = data.length - 1;
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const cmp = this.compare(value, data[mid]);
+      if (cmp < 0) {
+        high = mid - 1;
+      } else if (cmp > 0) {
+        low = mid + 1;
+      } else {
+        return mid;
+      }
+    }
+    return -1;
+  }
+  /**
+   * Returns if the array has the value
+   * @param value
+   */
+  has(value) {
+    return this.indexOf(value) !== -1;
+  }
+  /**
+   * Binary inserts a value into the array while maintaining sorted order
+   * @param value
+   * @returns the index of where the value was inserted
+   */
+  push(value) {
+    const { data, compare } = this;
+    let low = 0;
+    let high = data.length - 1;
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const cmp = compare(value, data[mid]);
+      if (cmp < 0) {
+        high = mid - 1;
+      } else if (cmp > 0) {
+        low = mid + 1;
+      } else {
+        data.splice(mid, 0, value);
+        return mid;
+      }
+    }
+    data.splice(low, 0, value);
+    return low;
+  }
+};
+
+// src/structs/unordered-array.ts
+var UnorderedArray = class _UnorderedArray extends Array {
+  copy() {
+    return new _UnorderedArray(...this);
+  }
+  /**
+   * Inserts new elements at the end of an unordered array, and returns the new length of the unordered array.
+   * @param items Elements to insert at the end of the array.
+   */
+  unshift(...items) {
+    return super.push(...items);
+  }
+  /**
+   * Removes the last element from an array and returns it.
+   * If the array is empty, undefined is returned and the array is not modified.
+   */
+  shift() {
+    return super.pop();
+  }
+  /**
+   * Removes an item by index
+   * @param index the index of the item to remove
+   * @returns the removed item, if it exists
+   */
+  removeIndex(index) {
+    swap(this, index, this.length - 1);
+    return this.pop();
+  }
+  splice(start, deleteCount = this.length - start, ...items) {
+    const spliced = [];
+    for (let i = 0; i < deleteCount; i++) {
+      const replacement = items[i];
+      let removed;
+      if (replacement) {
+        removed = this[start + i];
+        this[start + i] = replacement;
+      } else {
+        removed = this.removeIndex(start);
+      }
+      if (removed) {
+        spliced.push(removed);
+      }
+    }
+    return spliced;
+  }
+  toSpliced(start, deleteCount = this.length - start, ...items) {
+    const copy = this.copy();
+    copy.splice(start, deleteCount, ...items);
+    return copy;
+  }
+};
 export {
-  DoublyLinkedList,
-  LinkedList,
-  MaxHeap,
-  MinHeap,
-  Queue,
+  Heap,
   SortedArray,
   UnorderedArray
 };

package/dist/types.js

@@ -1 +0,0 @@
-import "./chunk-6F4PWJZI.js";

package/dist/{vec3-S_YuL-W1.d.ts → vec3-a5RuSVIr.d.ts}

@@ -40,10 +40,10 @@ declare class Vec3 extends Float32Array implements Vec {
     div(x: First, y?: number, z?: number): this;
     static div(v1: Vec3, x: First, y?: number, z?: number): Vec3;
     static fma(a: ReadonlyVec3Like, b: ReadonlyVec3Like, c: ReadonlyVec3Like): Vec3;
-    lt(x: ReadonlyVec3Like): Vec3;
-    lte(x: ReadonlyVec3Like): Vec3;
-    gt(x: ReadonlyVec3Like): Vec3;
-    gte(x: ReadonlyVec3Like): Vec3;
+    lt(v: ReadonlyVec3Like): Vec3;
+    lte(v: ReadonlyVec3Like): Vec3;
+    gt(v: ReadonlyVec3Like): Vec3;
+    gte(v: ReadonlyVec3Like): Vec3;
     limit(max: number): this;
     normalize(): this;
     static normalize(v: Vec3): Vec3;
@@ -67,4 +67,4 @@ declare class Vec3 extends Float32Array implements Vec {
 }
 declare function vec3(x?: First, y?: number, z?: number): Vec3;
 
-export { type ReadonlyVec3Like as R, type Vec as V, type Vec3Like as a, Vec3 as b, vec3 as v };
+export { type ReadonlyVec3Like as R, Vec3 as V, type Vec as a, type Vec3Like as b, vec3 as v };