@limitlesspc/std 0.21.1 → 0.23.0

package/dist/{chunk-O3YCU3KN.js → chunk-SSSOLDLG.js}

@@ -1,7 +1,7 @@
 import {
   swap,
   unorderedRemove
-} from "./chunk-65SNM7MP.js";
+} from "./chunk-4POIKW4G.js";
 
 // src/random.ts
 function random(min, max) {
@@ -21,7 +21,7 @@ function randomInt(min = 0, max) {
   return Math.floor(random(min + 1));
 }
 function shuffle(array) {
-  for (let { length } = array, i = length - 1; i > 0; i--) {
+  for (let i = array.length - 1; i > 0; i--) {
     const j = randomInt(i);
     swap(array, i, j);
   }

package/dist/cmath/index.js

@@ -14,7 +14,7 @@ var Complex = class {
     return complex(this.r, this.i);
   }
   get conj() {
-    return complex(+this.r, -this.i);
+    return complex(this.r, -this.i);
   }
   static fromAngle(angle, mag = 1) {
     return complex(Math.cos(angle), Math.sin(angle)).mul(mag);

package/dist/events.js

@@ -1,15 +1,14 @@
 import {
   sum
-} from "./chunk-WNQNVZFS.js";
-import "./chunk-O3YCU3KN.js";
-import "./chunk-65SNM7MP.js";
+} from "./chunk-ONMV3ICF.js";
+import "./chunk-SSSOLDLG.js";
+import "./chunk-4POIKW4G.js";
 import {
   pick
-} from "./chunk-WBSY6KRH.js";
+} from "./chunk-CCBSTDYA.js";
 import {
   pipe
-} from "./chunk-MG5VQSTV.js";
-import "./chunk-6F4PWJZI.js";
+} from "./chunk-NXILTE26.js";
 import "./chunk-TMLWLR46.js";
 import "./chunk-LJSF3QBT.js";
 

package/dist/fn/index.d.ts

@@ -34,9 +34,22 @@ type ReverseCurry<Fn extends AnyFunction, Args = Parameters<Fn>> = Args extends
     (...rest: Rest): (first: First) => ReturnType<Fn>;
 } : never;
 /**
- * Create a function that takes in the first parameter of another, to be used in a pipe
+ * Create a function that takes in the first parameter of another
+ * In other words, it gives you a function that when called with every parameter other than the first, will output a function that takes the first parameter only
  * @param fn
  * @returns a functions a that takes in the rest of the arguments of `fn` and returns a function that takes the first argument of `fn` to finally return the result of `fn`
+ * @example
+ * ```ts
+ * // Fused multiply-add
+ * function fma(a: number, b: number, c: number) {
+ *   return a * b + c;
+ * }
+ * const curried = reverseCurry(fma);
+ *
+ * const times3Add2Fma = curried(3, 2);
+ * times3Add2Fma(4); // 4 * 3 + 2 = 14
+ * times3Add2Fma(0); // 0 * 3 + 2 = 2
+ * ```
  */
 declare const reverseCurry: <Fn extends AnyFunction>(fn: Fn) => ReverseCurry<Fn>;
 

package/dist/fn/index.js

@@ -9,8 +9,7 @@ import {
   pipe,
   reverseCurry,
   ttlCache
-} from "../chunk-MG5VQSTV.js";
-import "../chunk-6F4PWJZI.js";
+} from "../chunk-NXILTE26.js";
 export {
   asyncPipe,
   constant,

package/dist/gfx/index.d.ts

@@ -1,4 +1,4 @@
-import { b as Vec3 } from '../vec3-S_YuL-W1.js';
+import { V as Vec3 } from '../vec3-BQ6mZ-wg.js';
 
 declare function hsv2rgb(h: number, s: number, v: number): Vec3;
 /**

package/dist/gfx/index.js

@@ -1,11 +1,10 @@
 import {
   vec3
-} from "../chunk-WNQNVZFS.js";
-import "../chunk-O3YCU3KN.js";
-import "../chunk-65SNM7MP.js";
-import "../chunk-WBSY6KRH.js";
-import "../chunk-MG5VQSTV.js";
-import "../chunk-6F4PWJZI.js";
+} from "../chunk-ONMV3ICF.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";
 

package/dist/iter/index.js

@@ -28,9 +28,8 @@ import {
   uniqueBy,
   unzip,
   zip
-} from "../chunk-WBSY6KRH.js";
-import "../chunk-MG5VQSTV.js";
-import "../chunk-6F4PWJZI.js";
+} from "../chunk-CCBSTDYA.js";
+import "../chunk-NXILTE26.js";
 import "../chunk-LJSF3QBT.js";
 export {
   associateBy,

package/dist/math/index.d.ts

@@ -1,6 +1,5 @@
 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';
+export { R as ReadonlyVec3Like, V as Vec3, v as vec3 } from '../vec3-BQ6mZ-wg.js';
 
 /**
  * Determines if a value is a number other than `NaN`
@@ -8,15 +7,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 +35,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 +43,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 +80,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 +268,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 +307,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 +326,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,25 +345,25 @@ 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>;
+interface ReadonlyVec2Like {
+    readonly x: number;
+    readonly y: number;
+}
 type First$1 = ReadonlyVec2Like | number;
-declare class Vec2 extends Float32Array implements Vec {
-    static readonly BYTE_LENGTH: number;
+declare class Vec2 {
+    x: number;
+    y: number;
     constructor(x?: First$1, y?: number);
-    get x(): number;
-    set x(value: number);
-    get y(): number;
-    set y(value: number);
     toString(): string;
     copy(): Vec2;
     static random(mag?: number): Vec2;
     eq(x: First$1, y?: number): boolean;
+    set(x: First$1, y?: number): this;
     add(x: First$1, y?: number): this;
     static add(v1: Vec2, x: First$1, y?: number): Vec2;
     sub(x: First$1, y?: number): this;
@@ -373,10 +373,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;
@@ -403,20 +403,19 @@ declare class Vec2 extends Float32Array implements Vec {
 }
 declare function vec2(x?: First$1, y?: number): Vec2;
 
-type Vec4Like = [x: number, y: number, z: number, w: number] | Float32Array;
-type ReadonlyVec4Like = Readonly<Vec4Like>;
+interface ReadonlyVec4Like {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly w: number;
+}
 type First = ReadonlyVec4Like | number;
-declare class Vec4 extends Float32Array implements Vec {
-    static readonly BYTE_LENGTH: number;
+declare class Vec4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
     constructor(x?: First, y?: number, z?: number, w?: number);
-    get x(): number;
-    set x(value: number);
-    get y(): number;
-    set y(value: number);
-    get z(): number;
-    set z(value: number);
-    get w(): number;
-    set w(value: number);
     get r(): number;
     set r(value: number);
     get g(): number;
@@ -428,6 +427,7 @@ declare class Vec4 extends Float32Array implements Vec {
     toString(): string;
     copy(): Vec4;
     eq(x: First, y?: number, z?: number, w?: number): boolean;
+    set(x: First, y?: number, z?: number, w?: number): this;
     add(x: First, y?: number, z?: number, w?: number): this;
     static add(v1: Vec4, x: First, y?: number, z?: number, w?: number): Vec4;
     sub(x: First, y?: number, z?: number, w?: number): this;
@@ -437,10 +437,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 +460,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, Vec2, Vec4, 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-WNQNVZFS.js";
-import "../chunk-O3YCU3KN.js";
-import "../chunk-65SNM7MP.js";
-import "../chunk-WBSY6KRH.js";
-import "../chunk-MG5VQSTV.js";
-import "../chunk-6F4PWJZI.js";
+} from "../chunk-ONMV3ICF.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 };