@limitlesspc/std 0.20.2

package/dist/cmath/index.js

@@ -0,0 +1,187 @@
+// src/cmath/complex.ts
+var Complex = class {
+  constructor(r = 0, i = 0) {
+    this.r = r;
+    this.i = i;
+  }
+  toString() {
+    return `${this.r} + ${this.i}i`;
+  }
+  valueOf() {
+    return this.mag();
+  }
+  copy() {
+    return complex(this.r, this.i);
+  }
+  get conj() {
+    return complex(+this.r, -this.i);
+  }
+  static fromAngle(angle, mag = 1) {
+    return complex(Math.cos(angle), Math.sin(angle)).mul(mag);
+  }
+  isReal() {
+    return !this.i;
+  }
+  add(c) {
+    if (typeof c === "number") {
+      this.r += c;
+    } else {
+      this.r += c.r;
+      this.i += c.i;
+    }
+    return this;
+  }
+  static add(c1, c2) {
+    return c1.copy().add(c2);
+  }
+  sub(c) {
+    if (typeof c === "number") {
+      this.r -= c;
+    } else {
+      this.r -= c.r;
+      this.i -= c.i;
+    }
+    return this;
+  }
+  static sub(c1, c2) {
+    return c1.copy().sub(c2);
+  }
+  mul(c) {
+    if (typeof c === "number") {
+      this.r *= c;
+      this.i *= c;
+    } else {
+      const { r, i } = this;
+      this.r = r * c.r - i * c.i;
+      this.i = r * c.i + i * c.r;
+    }
+    return this;
+  }
+  static mul(c1, c2) {
+    return c1.copy().mul(c2);
+  }
+  div(c) {
+    if (typeof c === "number") {
+      this.r /= c;
+      this.i /= c;
+    } else {
+      const { conj: conjugate } = c;
+      this.mul(conjugate).div(c.mul(conjugate).r);
+    }
+    return this;
+  }
+  static div(c1, c2) {
+    return c1.copy().div(c2);
+  }
+  sq() {
+    const { r, i } = this;
+    this.r = r * r - i * i;
+    const i2 = r * i;
+    this.i = i2 + i2;
+    return this;
+  }
+  mag() {
+    return Math.sqrt(this.magSq());
+  }
+  magSq() {
+    const { r, i } = this;
+    return r * r + i * i;
+  }
+  angle() {
+    return Math.atan2(this.i, this.r);
+  }
+  pow(z) {
+    const { r, i } = this;
+    const { r: r2, i: i2 } = z;
+    this.r = r ** r2 * i ** i2;
+    this.i = r ** i2 * i ** r2;
+    return this;
+  }
+};
+function complex(real, imaginary) {
+  return new Complex(real, imaginary);
+}
+
+// src/cmath/funcs.ts
+function csqrt(z) {
+  const { r, i } = z;
+  const mag = z.mag();
+  const r2 = Math.sqrt(0.5 * (mag + r));
+  const i2 = Math.sign(i) * Math.sqrt(0.5 * (mag - r));
+  return complex(r2, i2);
+}
+function clog(z) {
+  return complex(Math.log(z.mag()), z.angle());
+}
+var cln = clog;
+function cexp({ r, i }) {
+  const er = Math.exp(r);
+  return complex(er * Math.cos(i), er * Math.sin(i));
+}
+function csin({ r, i }) {
+  return complex(Math.sin(r) * Math.cosh(i), Math.cos(r) * Math.sinh(i));
+}
+function ccos({ r, i }) {
+  return complex(Math.cos(r) * Math.cosh(i), -Math.sin(r) * Math.sinh(i));
+}
+function ctan(z) {
+  return csin(z).div(ccos(z));
+}
+function casin({ r, i }) {
+  return complex(Math.asin(r) * Math.cosh(i), Math.acos(r) * Math.sinh(i));
+}
+function cacos({ r, i }) {
+  return complex(Math.acos(r) * Math.cosh(i), -Math.asin(r) * Math.sinh(i));
+}
+function catan({ r, i }) {
+  return complex(Math.atan(r) * Math.cosh(i), Math.atan(r) * Math.sinh(i));
+}
+function csinh({ r, i }) {
+  return complex(Math.sinh(r) * Math.cos(i), Math.cosh(r) * Math.sin(i));
+}
+function ccosh({ r, i }) {
+  return complex(Math.cosh(r) * Math.cos(i), Math.sinh(r) * Math.sin(i));
+}
+function ctanh(z) {
+  return csinh(z).div(ccosh(z));
+}
+function casinh({ r, i }) {
+  return complex(Math.asinh(r) * Math.cos(i), Math.acosh(r) * Math.sin(i));
+}
+function cacosh({ r, i }) {
+  return complex(Math.acosh(r) * Math.cos(i), Math.asinh(r) * Math.sin(i));
+}
+function catanh({ r, i }) {
+  return complex(Math.atanh(r) * Math.cos(i), Math.atanh(r) * Math.sin(i));
+}
+
+// src/cmath/algebra.ts
+function cquadraticRoots(a, b, c) {
+  const discriminant = b * b - 4 * a * c;
+  const d = csqrt(complex(discriminant));
+  return [
+    Complex.sub(d, b).div(2 * a),
+    Complex.sub(d, b).mul(-1).div(2 * a)
+  ];
+}
+export {
+  Complex,
+  cacos,
+  cacosh,
+  casin,
+  casinh,
+  catan,
+  catanh,
+  ccos,
+  ccosh,
+  cexp,
+  cln,
+  clog,
+  complex,
+  cquadraticRoots,
+  csin,
+  csinh,
+  csqrt,
+  ctan,
+  ctanh
+};

package/dist/cmp.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module
+ * Simple comparison functions
+ */
+type Compare<T> = (a: T, b: T) => number;
+declare const ascend: <T>(a: T, b: T) => number;
+declare const descend: <T>(a: T, b: T) => number;
+declare const ascendBy: <T, U>(f: (x: T) => U) => Compare<T>;
+declare const descendBy: <T, U>(f: (x: T) => U) => Compare<T>;
+
+export { type Compare, ascend, ascendBy, descend, descendBy };

package/dist/cmp.js

@@ -0,0 +1,12 @@
+import {
+  ascend,
+  ascendBy,
+  descend,
+  descendBy
+} from "./chunk-TMLWLR46.js";
+export {
+  ascend,
+  ascendBy,
+  descend,
+  descendBy
+};

package/dist/csv.d.ts

@@ -0,0 +1,3 @@
+declare function formatCsv(rows: any[][]): string;
+
+export { formatCsv };

package/dist/csv.js

@@ -0,0 +1,16 @@
+// src/csv.ts
+var specialCharRegex = /",\n/;
+function formatCsv(rows) {
+  return rows.map(
+    (row) => row.map((value) => {
+      const str = `${value}`;
+      if (specialCharRegex.test(str)) {
+        return `"${str.replaceAll('"', '""')}"`;
+      }
+      return str;
+    }).join(",")
+  ).join("\n");
+}
+export {
+  formatCsv
+};

package/dist/easing.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @module
+ * Easing functions
+ */
+declare function linear(t: number): number;
+declare function easeInQuad(t: number): number;
+declare function easeOutQuad(t: number): number;
+declare function easeInOutQuad(t: number): number;
+declare function easeInCubic(t: number): number;
+declare function easeOutCubic(t: number): number;
+declare function easeInOutCubic(t: number): number;
+declare function easeInQuart(t: number): number;
+declare function easeOutQuart(t: number): number;
+declare function easeInOutQuart(t: number): number;
+declare function easeInQuint(t: number): number;
+declare function easeOutQuint(t: number): number;
+declare function easeInOutQuint(t: number): number;
+declare function easeInSine(t: number): number;
+declare function easeOutSine(t: number): number;
+declare function easeInOutSine(t: number): number;
+declare function easeInExpo(t: number): number;
+declare function easeOutExpo(t: number): number;
+declare function easeInOutExpo(t: number): number;
+declare function easeInCirc(t: number): number;
+declare function easeOutCirc(t: number): number;
+declare function easeInOutCirc(t: number): number;
+declare function easeInElastic(t: number): number;
+declare function easeOutElastic(t: number): number;
+declare function easeInOutElastic(t: number): number;
+declare function easeInBack(t: number): number;
+declare function easeOutBack(t: number): number;
+declare function easeInOutBack(t: number): number;
+declare function easeInBounce(t: number): number;
+declare function easeOutBounce(t: number): number;
+declare function easeInOutBounce(t: number): number;
+
+export { easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, linear };

package/dist/easing.js

@@ -0,0 +1,157 @@
+// src/easing.ts
+function linear(t) {
+  return t;
+}
+function easeInQuad(t) {
+  return t * t;
+}
+function easeOutQuad(t) {
+  return t * (2 - t);
+}
+function easeInOutQuad(t) {
+  const t2 = 2 * t;
+  return t < 0.5 ? t2 * t : -1 + (4 - t2) * t;
+}
+function easeInCubic(t) {
+  return t * t * t;
+}
+function easeOutCubic(t) {
+  return 1 + --t * t * t;
+}
+function easeInOutCubic(t) {
+  const a = 2 * t - 2;
+  return t < 0.5 ? 4 * t * t * t : (t - 1) * a * a + 1;
+}
+function easeInQuart(t) {
+  const tt = t * t;
+  return tt * tt;
+}
+function easeOutQuart(t) {
+  const tt = --t * t;
+  return 1 - tt * tt;
+}
+function easeInOutQuart(t) {
+  const firstHalf = t < 0.5;
+  const tt = t * t;
+  const a = --t * t;
+  return firstHalf ? 8 * tt * tt : 1 - 8 * a * a;
+}
+function easeInQuint(t) {
+  const tt = t * t;
+  return tt * tt * t;
+}
+function easeOutQuint(t) {
+  const tt = --t * t;
+  return 1 + tt * tt * t;
+}
+function easeInOutQuint(t) {
+  const firstHalf = t < 0.5;
+  const tt = t * t;
+  const a = --t * t;
+  return firstHalf ? 16 * tt * tt * t : 1 + 16 * a * a * t;
+}
+function easeInSine(t) {
+  return 1 - Math.cos(t * Math.PI / 2);
+}
+function easeOutSine(t) {
+  return Math.sin(t * Math.PI / 2);
+}
+function easeInOutSine(t) {
+  return -(Math.cos(t * Math.PI) - 1) / 2;
+}
+function easeInExpo(t) {
+  return t === 0 ? 0 : 2 ** (10 * (t - 1));
+}
+function easeOutExpo(t) {
+  return t === 1 ? 1 : -(2 ** (-10 * t)) + 1;
+}
+function easeInOutExpo(t) {
+  if (t === 0 || t === 1) {
+    return t;
+  }
+  return t < 0.5 ? 2 ** (20 * (t - 1)) / 2 : -(2 ** (-20 * t)) / 2 + 1;
+}
+function easeInCirc(t) {
+  return 1 - Math.sqrt(1 - t * t);
+}
+function easeOutCirc(t) {
+  return Math.sqrt(1 - --t * t);
+}
+function easeInOutCirc(t) {
+  return t < 0.5 ? (1 - Math.sqrt(1 - 2 * t)) / 2 : (Math.sqrt(1 - (t -= 2) * t) + 1) / 2;
+}
+function easeInElastic(t) {
+  if (t === 0 || t === 1) {
+    return t;
+  }
+  return -(2 ** (10 * (t - 1))) * Math.sin((t - 1.1) * 5 * Math.PI);
+}
+function easeOutElastic(t) {
+  if (t === 0 || t === 1) {
+    return t;
+  }
+  return 2 ** (-10 * t) * Math.sin((t - 0.1) * 5 * Math.PI) + 1;
+}
+function easeInOutElastic(t) {
+  if (t === 0 || t === 1) {
+    return t;
+  }
+  return t < 0.5 ? -(2 ** (20 * (t - 1)) * Math.sin((t - 1.1) * 5 * Math.PI)) / 2 : 2 ** (-20 * t) * Math.sin((t - 1.1) * 5 * Math.PI) / 2 + 1;
+}
+function easeInBack(t) {
+  return t * t * (2.70158 * t - 1.70158);
+}
+function easeOutBack(t) {
+  return --t * t * (2.70158 * t + 1.70158) + 1;
+}
+function easeInOutBack(t) {
+  return t < 0.5 ? (2.70158 * t * t * t + 2) / 2 : (1.70158 * (t - 1) * (t - 1) * (t - 1) + 2) / 2;
+}
+function easeInBounce(t) {
+  return 1 - easeOutBounce(1 - t);
+}
+function easeOutBounce(t) {
+  if (t < 1 / 2.75) {
+    return 7.5625 * t * t;
+  }
+  if (t < 2 / 2.75) {
+    return 7.5625 * (t -= 1.5 / 2.75) * t + 0.75;
+  }
+  return t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + 0.9375 : 7.5625 * (t -= 2.625 / 2.75) * t + 0.984375;
+}
+function easeInOutBounce(t) {
+  return t < 0.5 ? (1 - easeOutBounce(1 - t * 2)) / 2 : (easeOutBounce(t * 2 - 1) + 1) / 2;
+}
+export {
+  easeInBack,
+  easeInBounce,
+  easeInCirc,
+  easeInCubic,
+  easeInElastic,
+  easeInExpo,
+  easeInOutBack,
+  easeInOutBounce,
+  easeInOutCirc,
+  easeInOutCubic,
+  easeInOutElastic,
+  easeInOutExpo,
+  easeInOutQuad,
+  easeInOutQuart,
+  easeInOutQuint,
+  easeInOutSine,
+  easeInQuad,
+  easeInQuart,
+  easeInQuint,
+  easeInSine,
+  easeOutBack,
+  easeOutBounce,
+  easeOutCirc,
+  easeOutCubic,
+  easeOutElastic,
+  easeOutExpo,
+  easeOutQuad,
+  easeOutQuart,
+  easeOutQuint,
+  easeOutSine,
+  linear
+};

package/dist/events.d.ts

@@ -0,0 +1,20 @@
+import { AnyRecord, uint } from './types.js';
+
+/**
+ * @module
+ * EventEmitter implementation
+ */
+
+type Unsubscribe = () => void;
+declare class EventEmitter<Events extends AnyRecord = AnyRecord> {
+    private readonly events;
+    listenersCount(event?: keyof Events): uint;
+    listeners(event: keyof Events): Array<(data: Events[keyof Events]) => any>;
+    on<EventName extends keyof Events>(event: EventName, listener: (data: Events[EventName]) => any): Unsubscribe;
+    once<EventName extends keyof Events>(event: EventName, listener: (data: Events[EventName]) => any): Unsubscribe;
+    emit<EventName extends keyof Events>(event: EventName, data: Events[EventName]): this;
+    off<EventName extends keyof Events>(event: EventName, listener: (data: Events[EventName]) => any): boolean;
+    removeAllListeners(event?: keyof Events): this;
+}
+
+export { EventEmitter };

package/dist/events.js

@@ -0,0 +1,67 @@
+import {
+  sum
+} from "./chunk-C2DS6YRJ.js";
+import "./chunk-EWSJTMH2.js";
+import "./chunk-ILLWUQPY.js";
+import {
+  pick
+} from "./chunk-WBSY6KRH.js";
+import {
+  pipe
+} from "./chunk-MG5VQSTV.js";
+import "./chunk-6F4PWJZI.js";
+import "./chunk-TMLWLR46.js";
+import "./chunk-LJSF3QBT.js";
+
+// src/events.ts
+var EventEmitter = class {
+  events = /* @__PURE__ */ new Map();
+  listenersCount(event) {
+    if (event) {
+      return this.events.get(event)?.size || 0;
+    }
+    return pipe(this.events.values(), pick("size"), sum);
+  }
+  listeners(event) {
+    return [...this.events.get(event) || []];
+  }
+  on(event, listener) {
+    const listeners = this.events.get(event) || /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.events.set(event, listeners);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  once(event, listener) {
+    const unsubscribe = this.on(event, (data) => {
+      unsubscribe();
+      listener(data);
+    });
+    return unsubscribe;
+  }
+  emit(event, data) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(data);
+      }
+    }
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.events.get(event);
+    return listeners?.delete(listener) || false;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+    return this;
+  }
+};
+export {
+  EventEmitter
+};

package/dist/fn/index.d.ts

@@ -0,0 +1,66 @@
+import { Awaitable, AnyFunction, Maybe } from '../types.js';
+
+interface Pipe {
+    <T>(x: T): T;
+    <T, R0>(x: T, fn0: (x: T) => R0): R0;
+    <T, R0, R1>(x: T, fn0: (x: T) => R0, fn1: (x: R0) => R1): R1;
+    <T, R0, R1, R2>(x: T, fn0: (x: T) => R0, fn1: (x: R0) => R1, fn2: (x: R1) => R2): R2;
+    <T, R0, R1, R2, R3>(x: T, fn0: (x: T) => R0, fn1: (x: R0) => R1, fn2: (x: R1) => R2, fn3: (x: R2) => R3): R3;
+    <T, R0, R1, R2, R3, R4>(x: T, fn0: (x: T) => R0, fn1: (x: R0) => R1, fn2: (x: R1) => R2, fn3: (x: R2) => R3, fn4: (x: R3) => R4): R4;
+    <T, R0, R1, R2, R3, R4, R5>(x: T, fn0: (x: T) => R0, fn1: (x: R0) => R1, fn2: (x: R1) => R2, fn3: (x: R2) => R3, fn4: (x: R3) => R4, fn5: (x: R4) => R5): R5;
+    <T, R0, R1, R2, R3, R4, R5, R6>(x: T, fn0: (x: T) => R0, fn1: (x: R0) => R1, fn2: (x: R1) => R2, fn3: (x: R2) => R3, fn4: (x: R3) => R4, fn5: (x: R4) => R5, fn6: (x: R5) => R6): R6;
+    <T, R0, R1, R2, R3, R4, R5, R6, R7>(x: T, fn0: (x: T) => R0, fn1: (x: R0) => R1, fn2: (x: R1) => R2, fn3: (x: R2) => R3, fn4: (x: R3) => R4, fn5: (x: R4) => R5, fn6: (x: R5) => R6, fn7: (x: R6) => R7): R7;
+    <T, R0, R1, R2, R3, R4, R5, R6, R7, R8>(x: T, fn0: (x: T) => R0, fn1: (x: R0) => R1, fn2: (x: R1) => R2, fn3: (x: R2) => R3, fn4: (x: R3) => R4, fn5: (x: R4) => R5, fn6: (x: R5) => R6, fn7: (x: R6) => R7, fn8: (x: R7) => R8): R8;
+    <T, R0, R1, R2, R3, R4, R5, R6, R7, R8, R9>(x: T, fn0: (x: T) => R0, fn1: (x: R0) => R1, fn2: (x: R1) => R2, fn3: (x: R2) => R3, fn4: (x: R3) => R4, fn5: (x: R4) => R5, fn6: (x: R5) => R6, fn7: (x: R6) => R7, fn8: (x: R7) => R8, fn9: (x: R8) => R9): R9;
+}
+declare const pipe: Pipe;
+interface AsyncPipe {
+    <T>(x: Awaitable<T>): Promise<T>;
+    <T, R0>(x: Awaitable<T>, fn0: (x: T) => Awaitable<R0>): Promise<R0>;
+    <T, R0, R1>(x: Awaitable<T>, fn0: (x: Awaited<T>) => Awaitable<R0>, fn1: (x: Awaited<R0>) => Awaitable<R1>): Promise<R1>;
+    <T, R0, R1, R2>(x: Awaitable<T>, fn0: (x: Awaited<T>) => Awaitable<R0>, fn1: (x: Awaited<R0>) => Awaitable<R1>, fn2: (x: Awaited<R1>) => Awaitable<R2>): Promise<R2>;
+    <T, R0, R1, R2, R3>(x: Awaitable<T>, fn0: (x: Awaited<T>) => Awaitable<R0>, fn1: (x: Awaited<R0>) => Awaitable<R1>, fn2: (x: Awaited<R1>) => Awaitable<R2>, fn3: (x: Awaited<R2>) => Awaitable<R3>): Promise<R3>;
+    <T, R0, R1, R2, R3, R4>(x: Awaitable<T>, fn0: (x: Awaited<T>) => Awaitable<R0>, fn1: (x: Awaited<R0>) => Awaitable<R1>, fn2: (x: Awaited<R1>) => Awaitable<R2>, fn3: (x: Awaited<R2>) => Awaitable<R3>, fn4: (x: Awaited<R3>) => Awaitable<R4>): Promise<R4>;
+    <T, R0, R1, R2, R3, R4, R5>(x: Awaitable<T>, fn0: (x: Awaited<T>) => Awaitable<R0>, fn1: (x: Awaited<R0>) => Awaitable<R1>, fn2: (x: Awaited<R1>) => Awaitable<R2>, fn3: (x: Awaited<R2>) => Awaitable<R3>, fn4: (x: Awaited<R3>) => Awaitable<R4>, fn5: (x: Awaited<R4>) => Awaitable<R5>): Promise<R5>;
+    <T, R0, R1, R2, R3, R4, R5, R6>(x: Awaitable<T>, fn0: (x: Awaited<T>) => Awaitable<R0>, fn1: (x: Awaited<R0>) => Awaitable<R1>, fn2: (x: Awaited<R1>) => Awaitable<R2>, fn3: (x: Awaited<R2>) => Awaitable<R3>, fn4: (x: Awaited<R3>) => Awaitable<R4>, fn5: (x: Awaited<R4>) => Awaitable<R5>, fn6: (x: Awaited<R5>) => Awaitable<R6>): Promise<R6>;
+    <T, R0, R1, R2, R3, R4, R5, R6, R7>(x: Awaitable<T>, fn0: (x: Awaited<T>) => Awaitable<R0>, fn1: (x: Awaited<R0>) => Awaitable<R1>, fn2: (x: Awaited<R1>) => Awaitable<R2>, fn3: (x: Awaited<R2>) => Awaitable<R3>, fn4: (x: Awaited<R3>) => Awaitable<R4>, fn5: (x: Awaited<R4>) => Awaitable<R5>, fn6: (x: Awaited<R5>) => Awaitable<R6>, fn7: (x: Awaited<R6>) => Awaitable<R7>): Promise<R7>;
+    <T, R0, R1, R2, R3, R4, R5, R6, R7, R8>(x: Awaitable<T>, fn0: (x: Awaited<T>) => Awaitable<R0>, fn1: (x: Awaited<R0>) => Awaitable<R1>, fn2: (x: Awaited<R1>) => Awaitable<R2>, fn3: (x: Awaited<R2>) => Awaitable<R3>, fn4: (x: Awaited<R3>) => Awaitable<R4>, fn5: (x: Awaited<R4>) => Awaitable<R5>, fn6: (x: Awaited<R5>) => Awaitable<R6>, fn7: (x: Awaited<R6>) => Awaitable<R7>, fn8: (x: Awaited<R7>) => Awaitable<R8>): Promise<R8>;
+    <T, R0, R1, R2, R3, R4, R5, R6, R7, R8, R9>(x: Awaitable<T>, fn0: (x: Awaited<T>) => Awaitable<R0>, fn1: (x: Awaited<R0>) => Awaitable<R1>, fn2: (x: Awaited<R1>) => Awaitable<R2>, fn3: (x: Awaited<R2>) => Awaitable<R3>, fn4: (x: Awaited<R3>) => Awaitable<R4>, fn5: (x: Awaited<R4>) => Awaitable<R5>, fn6: (x: Awaited<R5>) => Awaitable<R6>, fn7: (x: Awaited<R6>) => Awaitable<R7>, fn8: (x: Awaited<R7>) => Awaitable<R8>, fn9: (x: Awaited<R8>) => Awaitable<R9>): Promise<R9>;
+}
+declare const asyncPipe: AsyncPipe;
+
+type ReverseCurry<Fn extends AnyFunction, Args = Parameters<Fn>> = Args extends [infer First, ...infer Rest] ? {
+    (first: First, ...rest: Rest): ReturnType<Fn>;
+    (...rest: Rest): (first: First) => ReturnType<Fn>;
+} : never;
+/**
+ * Create a function that takes in the first parameter of another, to be used in a pipe
+ * @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`
+ */
+declare const reverseCurry: <Fn extends AnyFunction>(fn: Fn) => ReverseCurry<Fn>;
+
+/**
+ * @module
+ * Common function wrappers and utilities
+ */
+
+declare const noop: () => void;
+declare const identity: <T>(x: T) => T;
+declare const constant: <T>(x: T) => (() => T);
+/**
+ * Allows a function to be called only once
+ */
+declare function once<T>(fn: () => T): () => Maybe<T>;
+/**
+ * Caches the result of a function for each given parameter
+ */
+declare function memoize<P, R>(func: (arg: P) => R): (arg: P) => R;
+interface Memo<Return> {
+    (): Return;
+    invalidate: () => void;
+}
+declare function memo<T>(fn: () => T): Memo<T>;
+declare function ttlCache<T>(fn: () => T, ttl: number): () => T;
+
+export { type AsyncPipe, type Memo, type Pipe, type ReverseCurry, asyncPipe, constant, identity, memo, memoize, noop, once, pipe, reverseCurry, ttlCache };

package/dist/fn/index.js

@@ -0,0 +1,25 @@
+import {
+  asyncPipe,
+  constant,
+  identity,
+  memo,
+  memoize,
+  noop,
+  once,
+  pipe,
+  reverseCurry,
+  ttlCache
+} from "../chunk-MG5VQSTV.js";
+import "../chunk-6F4PWJZI.js";
+export {
+  asyncPipe,
+  constant,
+  identity,
+  memo,
+  memoize,
+  noop,
+  once,
+  pipe,
+  reverseCurry,
+  ttlCache
+};

package/dist/gfx/index.d.ts

@@ -0,0 +1,13 @@
+import { V as Vec3 } from '../vec3-D7Wuy2AZ.js';
+
+declare function hsv2rgb(h: number, s: number, v: number): Vec3;
+/**
+ * Calculates the CIE luminance of a color
+ * @param r red
+ * @param g green
+ * @param b blue
+ * @returns the luminance of the color
+ */
+declare function luminance(r: number, g: number, b: number): number;
+
+export { hsv2rgb, luminance };

package/dist/gfx/index.js

@@ -0,0 +1,68 @@
+import {
+  vec3
+} from "../chunk-C2DS6YRJ.js";
+import "../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";
+
+// src/gfx/color.ts
+function hsv2rgb(h, s, v) {
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  const i = Math.floor(h * 6);
+  const f = h * 6 - i;
+  const p = v * (1 - s);
+  const q = v * (1 - f * s);
+  const t = v * (1 - (1 - f) * s);
+  switch (i % 6) {
+    case 0: {
+      r = v;
+      g = t;
+      b = p;
+      break;
+    }
+    case 1: {
+      r = q;
+      g = v;
+      b = p;
+      break;
+    }
+    case 2: {
+      r = p;
+      g = v;
+      b = t;
+      break;
+    }
+    case 3: {
+      r = p;
+      g = q;
+      b = v;
+      break;
+    }
+    case 4: {
+      r = t;
+      g = p;
+      b = v;
+      break;
+    }
+    case 5: {
+      r = v;
+      g = p;
+      b = q;
+      break;
+    }
+  }
+  return vec3(Math.floor(r * 256), Math.floor(g * 256), Math.floor(b * 256));
+}
+function luminance(r, g, b) {
+  return (0.2126 * r + 0.7152 * g + 0.0722 * b) / 256;
+}
+export {
+  hsv2rgb,
+  luminance
+};