@limitlesspc/std 0.20.2

package/dist/random.d.ts

@@ -0,0 +1,68 @@
+import { int, uint } from './types.js';
+
+/**
+ * @module
+ * Random number and array utilities
+ */
+
+/**
+ * Returns a random number from 0 to a maximum non-inclusive
+ * @param max default 1
+ */
+declare function random(max?: number): number;
+/**
+ * Returns a random number from a minimum inclusive to a maximum non-inclusive
+ * @param min
+ * @param max
+ */
+declare function random(min?: number, max?: number): number;
+/**
+ * Returns a random number from 0 to a maximum inclusive
+ * @param max default 1
+ */
+declare function randomInt(max?: int): int;
+/**
+ * Returns a random number from a minimum inclusive to a maximum inclusive
+ * @param min
+ * @param max
+ */
+declare function randomInt(min: int, max: int): int;
+/**
+ * Randomizes the order of items in an array in-place
+ * @param array
+ * @returns the original array
+ */
+declare function shuffle<T extends ArrayLike<unknown>>(array: T): T;
+/**
+ * Chooses a random character from a string
+ * @param string
+ */
+declare function choice(string: string): string;
+/**
+ * Chooses a random item from an array
+ * @param array
+ */
+declare function choice<T>(array: ArrayLike<T>): T | undefined;
+/**
+ * Get random characters from a string
+ * @param string
+ * @param n number of characters to pick
+ * @returns a string of the random chars
+ */
+declare function choices(string: string, n: uint): string;
+/**
+ * Get random items from an array
+ * @param array
+ * @param n number of items to pick
+ * @returns an array containing the random items
+ */
+declare function choices<T>(array: ArrayLike<T>, n: uint): T[];
+/**
+ * Chooses unique random items from an array
+ * @param array
+ * @param n number of items to pick
+ * @returns an array containing the random items
+ */
+declare function sample<T>(array: ArrayLike<T> & Iterable<T>, n: uint): T[];
+
+export { choice, choices, random, randomInt, sample, shuffle };

package/dist/random.js

@@ -0,0 +1,22 @@
+import {
+  choice,
+  choices,
+  random,
+  randomInt,
+  sample,
+  shuffle
+} from "./chunk-EWSJTMH2.js";
+import "./chunk-ILLWUQPY.js";
+import "./chunk-WBSY6KRH.js";
+import "./chunk-MG5VQSTV.js";
+import "./chunk-6F4PWJZI.js";
+import "./chunk-TMLWLR46.js";
+import "./chunk-LJSF3QBT.js";
+export {
+  choice,
+  choices,
+  random,
+  randomInt,
+  sample,
+  shuffle
+};

package/dist/string/index.d.ts

@@ -0,0 +1,62 @@
+declare const lowercase = "abcdefghijklmnopqrstuvwxyz";
+declare const uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+declare const letters: string;
+declare const digits = "0123456789";
+declare const hexdigits: `0123456789abcdefABCDEF`;
+declare const octdigits = "01234567";
+
+/**
+ * Joins a list of strings into a single string, using a conjunction before the last item.
+ * @param items an array of strings
+ * @param conjunction the word to use before the last item
+ * @example
+ * ```ts
+ * listItems(["apples", "oranges", "bananas"]); // "apples, oranges, and bananas"
+ * listItems(["apples", "oranges", "bananas"], "or"); // "apples, oranges, or bananas"
+ * ```
+ */
+declare function listItems(items: string[], conjunction?: string): string;
+
+/**
+ * Capitalizes the first character in the word
+ * @param word a string
+ */
+declare function capitalize<T extends string>(word: T): Capitalize<T>;
+declare function pluralize<S extends string>(word: S, n: number): S | `${S}s`;
+declare function pluralize<S extends string, P extends string>(word: S, n: number, plural: P): S | P;
+declare function quantify<S extends string>(word: S, n: number): string;
+declare function quantify<S extends string, P extends string>(word: S, quantity: number, plural: P): string;
+/**
+ * Capitalizes the first character in each word
+ * @exmaple
+ * ```ts
+ * titalize("hello world"); // "Hello World"
+ * ```
+ */
+declare function titalize(str: string): string;
+
+/**
+ * @module
+ * String utility functions
+ */
+
+/**
+ * Splits a string only one time
+ * @param str the string to split
+ * @param separator a string to search for
+ * @return a tuple containing a substring before the separator and a substring after the separator
+ * the return tuple will always have at least 1 item, which will just be the str if no separator was found
+ * @example
+ * ```ts
+ * const str = "abc_def_ghi";
+ * console.log(splitOnce(str, '_')); // ["abc", "def_ghi"]
+ * console.log(splitOnce(str, '+')); // ["abc_def_ghi"]
+ * ```
+ */
+declare function splitOnce(str: string, separator: string): [before: string, after?: string];
+declare function reverse(str: string): string;
+declare function replace(str: string, replacements: Record<string, string>): string;
+declare const escapeInRegexRegex: RegExp;
+declare function escapeRegex(regexStr: string): string;
+
+export { capitalize, digits, escapeInRegexRegex, escapeRegex, hexdigits, letters, listItems, lowercase, octdigits, pluralize, quantify, replace, reverse, splitOnce, titalize, uppercase };

package/dist/string/index.js

@@ -0,0 +1,98 @@
+// src/string/constants.ts
+var lowercase = "abcdefghijklmnopqrstuvwxyz";
+var uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var letters = lowercase + uppercase;
+var digits = "0123456789";
+var hexdigits = `${digits}abcdefABCDEF`;
+var octdigits = "01234567";
+
+// src/string/list.ts
+function listItems(items, conjunction = "and") {
+  switch (items.length) {
+    case 0: {
+      return "";
+    }
+    case 1: {
+      return items[0] || "";
+    }
+    case 2: {
+      return items.join(` ${conjunction} `);
+    }
+    default: {
+      return `${items.slice(0, -1).join(", ")}, ${conjunction} ${items.at(-1)}`;
+    }
+  }
+}
+
+// src/string/word.ts
+function capitalize(word) {
+  const first = word[0] || "";
+  return first.toUpperCase() + word.slice(1);
+}
+function pluralize(word, n, plural) {
+  if (n === 1) {
+    return word;
+  }
+  if (plural) {
+    return plural;
+  }
+  return `${word}s`;
+}
+function quantify(word, quantity, plural) {
+  return `${quantity} ${plural ? pluralize(word, quantity, plural) : pluralize(word, quantity)}`;
+}
+function titalize(str) {
+  return str.split(" ").map((word) => capitalize(word)).join(" ");
+}
+
+// src/string/index.ts
+function splitOnce(str, separator) {
+  if (!str) {
+    return [""];
+  }
+  if (!separator) {
+    if (str.length < 2) {
+      return [str];
+    }
+    return [str[0], str.slice(1)];
+  }
+  const index = str.indexOf(separator);
+  if (index === -1) {
+    return [str];
+  }
+  const before = str.slice(0, index);
+  const after = str.slice(index + separator.length);
+  return [before, after];
+}
+function reverse(str) {
+  return [...str].reverse().join("");
+}
+function replace(str, replacements) {
+  const regex = new RegExp(
+    Object.keys(replacements).map(escapeRegex).join("|"),
+    "g"
+  );
+  return str.replace(regex, (matched) => replacements[matched] || "");
+}
+var escapeInRegexRegex = /[$()*+./?[\\\]^{|}-]/g;
+function escapeRegex(regexStr) {
+  return regexStr.replaceAll(escapeInRegexRegex, "\\$&");
+}
+export {
+  capitalize,
+  digits,
+  escapeInRegexRegex,
+  escapeRegex,
+  hexdigits,
+  letters,
+  listItems,
+  lowercase,
+  octdigits,
+  pluralize,
+  quantify,
+  replace,
+  reverse,
+  splitOnce,
+  titalize,
+  uppercase
+};

package/dist/structs/index.d.ts

@@ -0,0 +1,184 @@
+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[];
+}
+
+/**
+ * ## Binary Heap
+ * A tree in which any given node is the max or min of its children
+ *
+ * | Method      | Average Case | Worst Case |
+ * | ----------- | ------------ | ---------- |
+ * | peek()      | O(1)         | O(1)       |
+ * | pop()       | O(log n)     | O(log n)   |
+ * | push(value) | O(1)         | O(log n)   |
+ *
+ * @see https://en.wikipedia.org/wiki/Heap_(data_structure)
+ */
+declare class Heap<T> implements Iterable<T> {
+    readonly compare: Compare<T>;
+    data: T[];
+    constructor(compare: Compare<T>, data?: T[], heapify?: boolean);
+    get length(): uint;
+    get height(): uint;
+    valueOf(): T | undefined;
+    copy(): Heap<T>;
+    /**
+     * Returns the first value in the heap
+     */
+    peek(): T | undefined;
+    /**
+     * Removes the first value from the heap and returns it
+     */
+    pop(): T | undefined;
+    /**
+     * 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: T[]): uint;
+    drain(): Generator<T>;
+    [Symbol.iterator](): Iterator<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
+ *
+ * | Method         | Average Case | Worst Case |
+ * | -------------- | ------------ | ---------- |
+ * | indexOf(value) | O(log n)     | O(log n)   |
+ * | has(value)     | O(log n)     | O(log n)   |
+ * | push(value)    | O(n)         | O(n)       |
+ *
+ * @see https://en.wikipedia.org/wiki/Sorted_array
+ */
+declare class SortedArray<T> implements Iterable<T> {
+    private readonly data;
+    readonly compare: Compare<T>;
+    constructor(data?: T[], compare?: Compare<T>, sort?: boolean);
+    valueOf(): T | undefined;
+    keys(): IterableIterator<uint>;
+    values(): IterableIterator<T>;
+    entries(): IterableIterator<[uint, T]>;
+    [Symbol.iterator](): IterableIterator<T>;
+    length(): uint;
+    at(index: uint): T | undefined;
+    copy(): SortedArray<T>;
+    /**
+     * Returns the index of the value if it exists, otherwise -1
+     * @param value
+     */
+    indexOf(value: T): int;
+    /**
+     * Returns if the array has the value
+     * @param value
+     */
+    has(value: T): boolean;
+    /**
+     * Binary inserts a value into the array while maintaining sorted order
+     * @param value
+     * @returns the index of where the value was inserted
+     */
+    push(value: T): uint;
+}
+
+/**
+ * ## Unordered Array
+ * An array that maintains no order
+ */
+declare class UnorderedArray<T> extends Array<T> {
+    copy(): UnorderedArray<T>;
+    /**
+     * 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: T[]): uint;
+    /**
+     * 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(): T | undefined;
+    /**
+     * Removes an item by index
+     * @param index the index of the item to remove
+     * @returns the removed item, if it exists
+     */
+    removeIndex(index: uint): T | undefined;
+    splice(start: uint, deleteCount?: number, ...items: T[]): T[];
+    toSpliced(start: uint, deleteCount?: number, ...items: T[]): T[];
+}
+
+export { DoublyLinkedList, LinkedList, MaxHeap, MinHeap, Queue, SortedArray, UnorderedArray };

package/dist/structs/index.js

@@ -0,0 +1,24 @@
+import {
+  DoublyLinkedList,
+  LinkedList,
+  MaxHeap,
+  MinHeap,
+  Queue,
+  SortedArray,
+  UnorderedArray
+} from "../chunk-DO4NH5XG.js";
+import "../chunk-ILLWUQPY.js";
+import "../chunk-WBSY6KRH.js";
+import "../chunk-MG5VQSTV.js";
+import "../chunk-6F4PWJZI.js";
+import "../chunk-TMLWLR46.js";
+import "../chunk-LJSF3QBT.js";
+export {
+  DoublyLinkedList,
+  LinkedList,
+  MaxHeap,
+  MinHeap,
+  Queue,
+  SortedArray,
+  UnorderedArray
+};

package/dist/time/index.d.ts

@@ -0,0 +1,35 @@
+declare const SECOND = 1000;
+declare const MINUTE: number;
+declare const HOUR: number;
+declare const DAY: number;
+declare const WEEK: number;
+
+interface DurationLike {
+    readonly years?: number;
+    readonly months?: number;
+    readonly weeks?: number;
+    readonly days?: number;
+    readonly hours?: number;
+    readonly minutes?: number;
+    readonly seconds?: number;
+    readonly milliseconds?: number;
+}
+declare function addDuration(date: Date, { years, days, months, hours, minutes, seconds, milliseconds }: DurationLike): Date;
+declare function subtractDuration(date: Date, { years, days, months, hours, minutes, seconds, milliseconds }: DurationLike): Date;
+declare const stripTime: (date: Date) => Date;
+declare const getToday: () => Date;
+declare const getTomorrow: () => Date;
+declare const getYesterday: () => Date;
+/**
+ * Determines if two dates are the same day, ignoring time
+ * @param a
+ * @param b
+ */
+declare function sameDay(a: Date, b: Date): boolean;
+/**
+ * Checks if a date is valid
+ * @param date
+ */
+declare function validDate(date: Date): boolean;
+
+export { DAY, type DurationLike, HOUR, MINUTE, SECOND, WEEK, addDuration, getToday, getTomorrow, getYesterday, sameDay, stripTime, subtractDuration, validDate };

package/dist/time/index.js

@@ -0,0 +1,84 @@
+// src/time/consts.ts
+var SECOND = 1e3;
+var MINUTE = 60 * SECOND;
+var HOUR = 60 * MINUTE;
+var DAY = 24 * HOUR;
+var WEEK = 7 * DAY;
+
+// src/time/date.ts
+function addDuration(date, { years, days, months, hours, minutes, seconds, milliseconds }) {
+  const newDate = new Date(date);
+  if (years) {
+    newDate.setFullYear(newDate.getFullYear() + years);
+  }
+  if (months) {
+    newDate.setMonth(newDate.getMonth() + months);
+  }
+  if (days) {
+    newDate.setDate(newDate.getDate() + days);
+  }
+  if (hours) {
+    newDate.setHours(newDate.getHours() + hours);
+  }
+  if (minutes) {
+    newDate.setMinutes(newDate.getMinutes() + minutes);
+  }
+  if (seconds) {
+    newDate.setSeconds(newDate.getSeconds() + seconds);
+  }
+  if (milliseconds) {
+    newDate.setMilliseconds(newDate.getMilliseconds() + milliseconds);
+  }
+  return newDate;
+}
+function subtractDuration(date, { years, days, months, hours, minutes, seconds, milliseconds }) {
+  const newDate = new Date(date);
+  if (years) {
+    newDate.setFullYear(newDate.getFullYear() - years);
+  }
+  if (days) {
+    newDate.setDate(newDate.getDate() - days);
+  }
+  if (months) {
+    newDate.setMonth(newDate.getMonth() - months);
+  }
+  if (hours) {
+    newDate.setHours(newDate.getHours() - hours);
+  }
+  if (minutes) {
+    newDate.setMinutes(newDate.getMinutes() - minutes);
+  }
+  if (seconds) {
+    newDate.setSeconds(newDate.getSeconds() - seconds);
+  }
+  if (milliseconds) {
+    newDate.setMilliseconds(newDate.getMilliseconds() - milliseconds);
+  }
+  return newDate;
+}
+var stripTime = (date) => new Date(date.getFullYear(), date.getMonth(), date.getDate());
+var getToday = () => stripTime(/* @__PURE__ */ new Date());
+var getTomorrow = () => addDuration(getToday(), { days: 1 });
+var getYesterday = () => subtractDuration(getToday(), { days: 1 });
+function sameDay(a, b) {
+  return a.getDate() === b.getDate() && a.getMonth() === b.getMonth() && a.getFullYear() === b.getFullYear();
+}
+function validDate(date) {
+  const millis = date.getTime();
+  return !Number.isNaN(millis);
+}
+export {
+  DAY,
+  HOUR,
+  MINUTE,
+  SECOND,
+  WEEK,
+  addDuration,
+  getToday,
+  getTomorrow,
+  getYesterday,
+  sameDay,
+  stripTime,
+  subtractDuration,
+  validDate
+};

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module
+ * Useful utility types for Typescript
+ */
+type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+type int = number;
+type uint = number;
+type Maybe<T> = T | undefined;
+type Nullish<T> = Maybe<T> | null;
+type AnyRecord = Record<PropertyKey, any>;
+type AnyFunction = (...args: any[]) => any;
+type MaybeArray<T> = T | T[];
+type MaybeReadonlyArray<T> = T | readonly T[];
+type Dict<T> = Record<string, T>;
+type Indexable<T> = Record<number, T>;
+type Result<T, E = Error> = [T, undefined] | [undefined, E];
+type Awaitable<T> = T | Promise<T>;
+type NonFalsy<T> = T extends false | 0 | "" | null | undefined | 0n ? never : T;
+type Repeat<T, N extends number> = N extends 0 ? [] : N extends 1 ? [T] : N extends 2 ? [T, T] : N extends 3 ? [T, T, T] : N extends 4 ? [T, T, T, T] : N extends 5 ? [T, T, T, T, T] : N extends 6 ? [T, T, T, T, T, T] : N extends 7 ? [T, T, T, T, T, T, T] : N extends 8 ? [T, T, T, T, T, T, T, T] : N extends 9 ? [T, T, T, T, T, T, T, T, T] : N extends 10 ? [T, T, T, T, T, T, T, T, T, T] : T[];
+
+export type { AnyFunction, AnyRecord, Awaitable, Dict, Indexable, Maybe, MaybeArray, MaybeReadonlyArray, NonFalsy, Nullish, Primitive, Repeat, Result, int, uint };

package/dist/types.js

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

package/dist/vec3-D7Wuy2AZ.d.ts

@@ -0,0 +1,70 @@
+interface Vec extends Float32Array {
+    toString: () => string;
+    copy: () => Vec;
+    mag: () => number;
+    setMag: (n: number) => this;
+    magSq: () => number;
+    limit: (max: number) => this;
+    normalize: () => this;
+}
+
+type Vec3Like = [x: number, y: number, z: number] | Float32Array;
+type ReadonlyVec3Like = Readonly<Vec3Like>;
+type First = ReadonlyVec3Like | number;
+declare class Vec3 extends Float32Array implements Vec {
+    static readonly BYTE_LENGTH: number;
+    constructor(x?: First, y?: number, z?: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get r(): number;
+    set r(value: number);
+    get g(): number;
+    set g(value: number);
+    get b(): number;
+    set b(value: number);
+    toString(): string;
+    copy(): Vec3;
+    static random(mag?: number): Vec3;
+    eq(x: First, y?: number, z?: number): boolean;
+    neg(): Vec3;
+    add(x: First, y?: number, z?: number): this;
+    static add(v1: Vec3, x: First, y?: number, z?: number): Vec3;
+    sub(x: First, y?: number, z?: number): this;
+    static sub(v1: Vec3, x: First, y?: number, z?: number): Vec3;
+    mul(x: First, y?: number, z?: number): this;
+    static mul(v1: Vec3, x: First, y?: number, z?: number): Vec3;
+    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;
+    limit(max: number): this;
+    normalize(): this;
+    static normalize(v: Vec3): Vec3;
+    mag(): number;
+    setMag(n: number): this;
+    magSq(): number;
+    dist(v: Vec3): number;
+    distSq(v: Vec3): number;
+    dot(v: ReadonlyVec3Like): number;
+    cross(v: ReadonlyVec3Like): Vec3;
+    lerp(v: ReadonlyVec3Like, norm: number): this;
+    static lerp(v1: Vec3, v2: ReadonlyVec3Like, norm: number): Vec3;
+    clamp(min: ReadonlyVec3Like, max: ReadonlyVec3Like): this;
+    static clamp(v: Vec3, min: ReadonlyVec3Like, max: ReadonlyVec3Like): Vec3;
+    rotateX(angle: number): this;
+    rotateY(angle: number): this;
+    rotateZ(angle: number): this;
+    reflect(normal: Vec3): this;
+    static reflect(v: Vec3, normal: Vec3): Vec3;
+    refract(normal: Vec3, eta: number): this;
+}
+declare function vec3(x?: First, y?: number, z?: number): Vec3;
+
+export { type ReadonlyVec3Like as R, Vec3 as V, type Vec as a, type Vec3Like as b, vec3 as v };