curvy 0.3.3 → 1.0.1

package/dist/shared/curvy.BN-oFBsc.d.ts

@@ -0,0 +1,26 @@
+declare class Pipeable {
+    pipe<A>(this: A): A;
+    pipe<A, B = never>(this: A, ab: (_: A) => B): B;
+    pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+    pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+    pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+    pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+    pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+}
+
+export { Pipeable as P };

package/dist/shared/curvy.CT38g_II.d.mts

@@ -0,0 +1,22 @@
+type TwoDimensionalIndex = 0 | 1;
+type TwoDimensionalComponent = 'x' | 'y';
+interface TwoDimensional<T> {
+    readonly x: T;
+    readonly y: T;
+    readonly 0: T;
+    readonly 1: T;
+}
+type ThreeDimensionalIndex = TwoDimensionalIndex | 2;
+type ThreeDimensionalComponent = TwoDimensionalComponent | 'z';
+interface ThreeDimensional<T> extends TwoDimensional<T> {
+    readonly z: T;
+    readonly 2: T;
+}
+type FourDimensionalIndex = ThreeDimensionalIndex | 3;
+type FourDimensionalComponent = ThreeDimensionalComponent | 'w';
+interface FourDimensional<T> extends ThreeDimensional<T> {
+    readonly w: T;
+    readonly 3: T;
+}
+
+export type { FourDimensionalIndex as F, ThreeDimensionalIndex as T, FourDimensionalComponent as a, ThreeDimensionalComponent as b, TwoDimensionalIndex as c, TwoDimensionalComponent as d, TwoDimensional as e, FourDimensional as f, ThreeDimensional as g };

package/dist/shared/curvy.CT38g_II.d.ts

@@ -0,0 +1,22 @@
+type TwoDimensionalIndex = 0 | 1;
+type TwoDimensionalComponent = 'x' | 'y';
+interface TwoDimensional<T> {
+    readonly x: T;
+    readonly y: T;
+    readonly 0: T;
+    readonly 1: T;
+}
+type ThreeDimensionalIndex = TwoDimensionalIndex | 2;
+type ThreeDimensionalComponent = TwoDimensionalComponent | 'z';
+interface ThreeDimensional<T> extends TwoDimensional<T> {
+    readonly z: T;
+    readonly 2: T;
+}
+type FourDimensionalIndex = ThreeDimensionalIndex | 3;
+type FourDimensionalComponent = ThreeDimensionalComponent | 'w';
+interface FourDimensional<T> extends ThreeDimensional<T> {
+    readonly w: T;
+    readonly 3: T;
+}
+
+export type { FourDimensionalIndex as F, ThreeDimensionalIndex as T, FourDimensionalComponent as a, ThreeDimensionalComponent as b, TwoDimensionalIndex as c, TwoDimensionalComponent as d, TwoDimensional as e, FourDimensional as f, ThreeDimensional as g };

package/dist/shared/curvy.ChkqgKuv.mjs

@@ -0,0 +1,119 @@
+const dual = (arity, body) => {
+  if (typeof arity === "function") {
+    return function(...args) {
+      if (arity(args)) {
+        return body.apply(this, args);
+      }
+      return (self) => body(self, ...args);
+    };
+  }
+  switch (arity) {
+    case 0:
+    case 1:
+      throw new RangeError(`Invalid arity ${arity}`);
+    case 2:
+      return (...args) => {
+        const [a, b] = args;
+        if (args.length >= 2) {
+          return body(a, b);
+        }
+        return (self) => body(self, a);
+      };
+    case 3:
+      return (...args) => {
+        const [a, b, c] = args;
+        if (args.length >= 3) {
+          return body(a, b, c);
+        }
+        return (self) => body(self, a, b);
+      };
+    case 4:
+      return (...args) => {
+        const [a, b, c, d] = args;
+        if (args.length >= 4) {
+          return body(a, b, c, d);
+        }
+        return (self) => body(self, a, b, c);
+      };
+    case 5:
+      return (...args) => {
+        const [a, b, c, d, e] = args;
+        if (args.length >= 5) {
+          return body(a, b, c, d, e);
+        }
+        return (self) => body(self, a, b, c, d);
+      };
+    default:
+      return function(...args) {
+        if (args.length >= arity) {
+          return body.apply(this, args);
+        }
+        return (self) => body(self, ...args);
+      };
+  }
+};
+function pipe(...args) {
+  const [a, ab, bc, cd, de, ef, fg, gh, hi] = args;
+  switch (args.length) {
+    case 1:
+      return a;
+    case 2:
+      return ab(a);
+    case 3:
+      return bc(ab(a));
+    case 4:
+      return cd(bc(ab(a)));
+    case 5:
+      return de(cd(bc(ab(a))));
+    case 6:
+      return ef(de(cd(bc(ab(a)))));
+    case 7:
+      return fg(ef(de(cd(bc(ab(a))))));
+    case 8:
+      return gh(fg(ef(de(cd(bc(ab(a)))))));
+    case 9:
+      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+    default: {
+      let ret = args[0];
+      for (let i = 1; i < args.length; i++) {
+        ret = args[i](ret);
+      }
+      return ret;
+    }
+  }
+}
+
+class Pipeable {
+  pipe(...args) {
+    return pipe(this, ...args);
+  }
+}
+
+const PRECISION = 8;
+function round(value, precision = PRECISION) {
+  const scale = 10 ** precision;
+  const result = Math.round(value * scale) / scale;
+  if (result === 0) {
+    return 0;
+  }
+  return result;
+}
+dual(
+  5,
+  (x, x1, x2, y1, y2) => {
+    return y1 + (x - x1) / (x2 - x1) * (y2 - y1);
+  }
+);
+dual(3, (value, min, max) => {
+  return value < min ? min : value > max ? max : value;
+});
+dual(4, (value, min, max, onClip) => {
+  return value < min ? onClip : value > max ? onClip : value;
+});
+function invariant(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+export { Pipeable as P, PRECISION as a, dual as d, invariant as i, round as r };

package/dist/shared/curvy.CkJRVnqj.d.ts

@@ -0,0 +1,155 @@
+import { P as Pipeable } from './curvy.BN-oFBsc.js';
+import { Interval } from '../interval.js';
+import { Vector2 } from '../vector/vector2.js';
+import { Vector3 } from '../vector/vector3.js';
+import { Vector4 } from '../vector/vector4.js';
+
+declare const CubicPolynomialTypeId: unique symbol;
+type CubicPolynomialTypeId = typeof CubicPolynomialTypeId;
+
+type Monotonicity = 'none' | 'increasing' | 'decreasing' | 'constant';
+type GuaranteedMonotonicity = 'increasing' | 'decreasing' | 'constant';
+
+type ZeroOrOneSolution = number | null;
+type ZeroOrOneInterval = Interval | null;
+type ZeroToTwoSolutions = readonly [] | readonly [number] | readonly [number, number];
+type ZeroToThreeSolutions = readonly [] | readonly [number] | readonly [number, number] | readonly [number, number, number];
+
+interface CubicPolynomial extends Pipeable {
+    readonly [CubicPolynomialTypeId]: CubicPolynomialTypeId;
+    readonly c0: number;
+    readonly c1: number;
+    readonly c2: number;
+    readonly c3: number;
+}
+declare const isCubicPolynomial: (value: unknown) => value is CubicPolynomial;
+declare const make$2: (c0: number, c1: number, c2: number, c3: number) => CubicPolynomial;
+declare const fromVector$2: (v: Vector4) => CubicPolynomial;
+declare const solve$2: {
+    (p: CubicPolynomial, x: number): number;
+    (x: number): (p: CubicPolynomial) => number;
+};
+declare const toSolver$2: (p: CubicPolynomial) => (x: number) => number;
+declare const solveInverse$2: {
+    (p: CubicPolynomial, y: number): ZeroToThreeSolutions;
+    (y: number): (p: CubicPolynomial) => ZeroToThreeSolutions;
+};
+declare const toInverseSolver$2: (p: CubicPolynomial) => (y: number) => ZeroToThreeSolutions;
+declare const derivative$2: (p: CubicPolynomial) => QuadraticPolynomial;
+declare const roots$1: (p: CubicPolynomial) => ZeroToThreeSolutions;
+declare const extrema: (p: CubicPolynomial) => ZeroToTwoSolutions;
+declare const monotonicity$2: {
+    (p: CubicPolynomial, i?: Interval): Monotonicity;
+    (i: Interval): (p: CubicPolynomial) => Monotonicity;
+};
+declare const domain$2: {
+    (p: CubicPolynomial, range: Interval): Interval;
+    (range: Interval): (p: CubicPolynomial) => Interval;
+};
+declare const range$2: {
+    (p: CubicPolynomial, domain: Interval): Interval;
+    (domain: Interval): (p: CubicPolynomial) => Interval;
+};
+declare const length$2: {
+    (p: CubicPolynomial, domain: Interval): number;
+    (domain: Interval): (p: CubicPolynomial) => number;
+};
+declare const curvature$1: {
+    (p: CubicPolynomial, x: number): number;
+    (x: number): (p: CubicPolynomial) => number;
+};
+
+declare const QuadraticPolynomialTypeId: unique symbol;
+type QuadraticPolynomialTypeId = typeof QuadraticPolynomialTypeId;
+
+interface QuadraticPolynomial extends Pipeable {
+    readonly [QuadraticPolynomialTypeId]: QuadraticPolynomialTypeId;
+    readonly c0: number;
+    readonly c1: number;
+    readonly c2: number;
+}
+declare const isQuadraticPolynomial: (v: unknown) => v is QuadraticPolynomial;
+declare const make$1: (c0?: number, c1?: number, c2?: number) => QuadraticPolynomial;
+declare const fromVector$1: (v: Vector3) => QuadraticPolynomial;
+declare const solve$1: {
+    (p: QuadraticPolynomial, x: number): number;
+    (x: number): (p: QuadraticPolynomial) => number;
+};
+declare const toSolver$1: (p: QuadraticPolynomial) => (x: number) => number;
+declare const solveInverse$1: {
+    (p: QuadraticPolynomial, y: number): ZeroToTwoSolutions;
+    (y: number): (p: QuadraticPolynomial) => ZeroToTwoSolutions;
+};
+declare const toInverseSolver$1: (p: QuadraticPolynomial) => (y: number) => ZeroToTwoSolutions;
+declare const derivative$1: (p: QuadraticPolynomial) => LinearPolynomial;
+declare const roots: (p: QuadraticPolynomial) => ZeroToTwoSolutions;
+declare const extreme: (p: QuadraticPolynomial) => ZeroOrOneSolution;
+declare const monotonicity$1: {
+    (p: QuadraticPolynomial, i?: Interval): Monotonicity;
+    (i: Interval): (p: QuadraticPolynomial) => Monotonicity;
+};
+declare const antiderivative$1: {
+    (p: QuadraticPolynomial, constant?: number): CubicPolynomial;
+    (constant: number): (p: QuadraticPolynomial) => CubicPolynomial;
+};
+declare const domain$1: {
+    (p: QuadraticPolynomial, range: Interval): Interval | null;
+    (range: Interval): (p: QuadraticPolynomial) => Interval | null;
+};
+declare const range$1: {
+    (p: QuadraticPolynomial, domain: Interval): Interval;
+    (domain: Interval): (p: QuadraticPolynomial) => Interval;
+};
+declare const length$1: {
+    (p: QuadraticPolynomial, i: Interval): number;
+    (i: Interval): (p: QuadraticPolynomial) => number;
+};
+declare const curvature: {
+    (p: QuadraticPolynomial, x: number): number;
+    (x: number): (p: QuadraticPolynomial) => number;
+};
+
+declare const LinearPolynomialTypeId: unique symbol;
+type LinearPolynomialTypeId = typeof LinearPolynomialTypeId;
+
+interface LinearPolynomial extends Pipeable {
+    readonly [LinearPolynomialTypeId]: LinearPolynomialTypeId;
+    readonly c0: number;
+    readonly c1: number;
+}
+declare const isLinearPolynomial: (v: unknown) => v is LinearPolynomial;
+declare const make: (c0?: number, c1?: number) => LinearPolynomial;
+declare const fromVector: (v: Vector2) => LinearPolynomial;
+declare const fromPointSlope: (p: Vector2, slope: number) => LinearPolynomial;
+declare const fromPoints: (p1: Vector2, p2: Vector2) => LinearPolynomial;
+declare const solve: {
+    (p: LinearPolynomial, x: number): number;
+    (x: number): (p: LinearPolynomial) => number;
+};
+declare const toSolver: (p: LinearPolynomial) => (x: number) => number;
+declare const solveInverse: {
+    (p: LinearPolynomial, y: number): ZeroOrOneSolution;
+    (y: number): (p: LinearPolynomial) => ZeroOrOneSolution;
+};
+declare const toInverseSolver: (p: LinearPolynomial) => (y: number) => ZeroOrOneSolution;
+declare const root: (p: LinearPolynomial) => ZeroOrOneSolution;
+declare const monotonicity: (p: LinearPolynomial) => GuaranteedMonotonicity;
+declare const derivative: (p: LinearPolynomial) => number;
+declare const antiderivative: {
+    (p: LinearPolynomial, constant?: number): QuadraticPolynomial;
+    (constant: number): (p: LinearPolynomial) => QuadraticPolynomial;
+};
+declare const domain: {
+    (p: LinearPolynomial, range: Interval): ZeroOrOneInterval;
+    (range: Interval): (p: LinearPolynomial) => ZeroOrOneInterval;
+};
+declare const range: {
+    (p: LinearPolynomial, domain: Interval): Interval;
+    (domain: Interval): (p: LinearPolynomial) => Interval;
+};
+declare const length: {
+    (p: LinearPolynomial, domain: Interval): number;
+    (domain: Interval): (p: LinearPolynomial) => number;
+};
+
+export { antiderivative$1 as A, domain$1 as B, type CubicPolynomial as C, range$1 as D, length$1 as E, curvature as F, isLinearPolynomial as G, make as H, fromVector as I, fromPointSlope as J, fromPoints as K, type LinearPolynomial as L, solve as M, toSolver as N, solveInverse as O, toInverseSolver as P, type QuadraticPolynomial as Q, root as R, monotonicity as S, derivative as T, antiderivative as U, domain as V, range as W, length as X, solveInverse$2 as a, toInverseSolver$2 as b, monotonicity$2 as c, derivative$2 as d, extrema as e, fromVector$2 as f, domain$2 as g, range$2 as h, isCubicPolynomial as i, curvature$1 as j, isQuadraticPolynomial as k, length$2 as l, make$2 as m, make$1 as n, fromVector$1 as o, solve$1 as p, toSolver$1 as q, roots$1 as r, solve$2 as s, toSolver$2 as t, solveInverse$1 as u, toInverseSolver$1 as v, derivative$1 as w, roots as x, extreme as y, monotonicity$1 as z };

package/dist/shared/curvy.Cty3LrOR.mjs

@@ -0,0 +1,70 @@
+import { d as dual, r as round, P as Pipeable } from './curvy.ChkqgKuv.mjs';
+
+const Vector4TypeId = Symbol.for("curvy/vector4");
+class Vector4Impl extends Pipeable {
+  [Vector4TypeId] = Vector4TypeId;
+  x;
+  y;
+  z;
+  w;
+  constructor(v0 = 0, v1 = 0, v2 = 0, v3 = 0) {
+    super();
+    this.x = round(v0);
+    this.y = round(v1);
+    this.z = round(v2);
+    this.w = round(v3);
+  }
+  get [0]() {
+    return this.x;
+  }
+  get [1]() {
+    return this.y;
+  }
+  get [2]() {
+    return this.z;
+  }
+  get [3]() {
+    return this.w;
+  }
+  get [Symbol.toStringTag]() {
+    return `Vector4(${this.x}, ${this.y}, ${this.z}, ${this.w})`;
+  }
+  get [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this[Symbol.toStringTag];
+  }
+}
+const isVector4 = (v) => typeof v === "object" && v !== null && Vector4TypeId in v;
+const make = (v0, v1 = v0, v2 = v1, v3 = v2) => new Vector4Impl(v0, v1, v2, v3);
+const magnitude = (vector) => round(Math.hypot(vector.x, vector.y, vector.z, vector.w));
+const normalize = (vector) => {
+  const m = magnitude(vector);
+  return make(vector.x / m, vector.y / m, vector.z / m, vector.w / m);
+};
+const dot = dual(
+  2,
+  (a, b) => round(a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w)
+);
+const components = (v) => [v.x, v.y, v.z, v.w];
+const softmax = (v) => {
+  const max = Math.max(v.x, v.y, v.z, v.w);
+  const v0 = Math.exp(v.x - max);
+  const v1 = Math.exp(v.y - max);
+  const v2 = Math.exp(v.z - max);
+  const v3 = Math.exp(v.w - max);
+  const sum = v0 + v1 + v2 + v3;
+  return make(v0 / sum, v1 / sum, v2 / sum, v3 / sum);
+};
+const add = dual(
+  2,
+  (a, b) => make(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w)
+);
+const subtract = dual(
+  2,
+  (a, b) => make(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w)
+);
+const hadamard = dual(
+  2,
+  (a, b) => make(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w)
+);
+
+export { magnitude as a, add as b, components as c, dot as d, subtract as e, hadamard as h, isVector4 as i, make as m, normalize as n, softmax as s };

package/dist/shared/curvy.D7MEXd5g.mjs

@@ -0,0 +1,130 @@
+import { P as Pipeable, r as round, d as dual } from './curvy.ChkqgKuv.mjs';
+import { size, contains, fromMinMax } from '../interval.mjs';
+import { Q as QuadraticPolynomialImpl, b as QuadraticPolynomialTypeId, a as make$1, c as solveInverse$1, m as monotonicity$1, r as range$1, l as length$1, s as solve$1 } from './curvy.DB7nQmVs.mjs';
+
+const CubicPolynomialTypeId = Symbol.for(
+  "curvy/polynomial/cubic"
+);
+class CubicPolynomialImpl extends Pipeable {
+  [CubicPolynomialTypeId] = CubicPolynomialTypeId;
+  c0;
+  c1;
+  c2;
+  c3;
+  constructor(c0 = 0, c1 = 0, c2 = 0, c3 = 0) {
+    super();
+    this.c0 = round(c0);
+    this.c1 = round(c1);
+    this.c2 = round(c2);
+    this.c3 = round(c3);
+  }
+}
+
+function guaranteedMonotonicityFromComparison(s0, s1) {
+  if (s0 < s1) {
+    return "increasing";
+  }
+  if (s0 > s1) {
+    return "decreasing";
+  }
+  return "constant";
+}
+
+const make = (c0 = 0, c1 = 0, c2 = 0) => new QuadraticPolynomialImpl(c0, c1, c2);
+const isQuadraticPolynomial = (v) => typeof v === "object" && v !== null && QuadraticPolynomialTypeId in v;
+const fromVector = (v) => new QuadraticPolynomialImpl(v.x, v.y, v.z);
+const solve = dual(
+  2,
+  (p, x) => round(p.c0 + x * p.c1 + x ** 2 * p.c2)
+);
+const toSolver = (p) => (x) => solve(p, x);
+const solveInverse = dual(2, (p, y) => {
+  const discriminant = p.c1 ** 2 - 4 * p.c2 * (p.c0 - y);
+  if (discriminant < 0) {
+    return [];
+  }
+  if (discriminant === 0) {
+    return [round(-p.c1 / (2 * p.c2))];
+  }
+  const sqrtDiscriminant = Math.sqrt(discriminant);
+  return [
+    round((-p.c1 + sqrtDiscriminant) / (2 * p.c2)),
+    round((-p.c1 - sqrtDiscriminant) / (2 * p.c2))
+  ].toSorted((a, b) => a - b);
+});
+const toInverseSolver = (p) => (y) => solveInverse(p, y);
+const derivative = (p) => make$1(p.c1, p.c2 * 2);
+const roots = (p) => solveInverse(p, 0);
+const extreme = (p) => derivative(p).pipe(solveInverse$1(0)) ?? (p.c2 === 0 ? null : 0);
+const monotonicity = dual(
+  (args) => isQuadraticPolynomial(args[0]),
+  (p, i) => {
+    if (p.c2 === 0 && p.c1 === 0) {
+      return "constant";
+    }
+    if (p.c2 === 0) {
+      return monotonicity$1(make$1(p.c0, p.c1));
+    }
+    const e = extreme(p);
+    if (i && size(i) === 0) {
+      return "constant";
+    }
+    if (i === void 0 || contains(i, e, { includeStart: false, includeEnd: false })) {
+      return "none";
+    }
+    return guaranteedMonotonicityFromComparison(
+      solve(p, i.start),
+      solve(p, i.end)
+    );
+  }
+);
+const antiderivative = dual(
+  2,
+  (p, integrationConstant = 0) => new CubicPolynomialImpl(integrationConstant, p.c0, p.c1 / 2, p.c2 / 3)
+);
+const domain = dual(2, (p, range2) => {
+  const start = solveInverse(p, range2.start);
+  const end = solveInverse(p, range2.end);
+  if (start.length === 0 && end.length === 0) {
+    return null;
+  }
+  return fromMinMax(
+    ...solveInverse(p, range2.start),
+    ...solveInverse(p, range2.end)
+  );
+});
+const range = dual(2, (p, domain2) => {
+  if (p.c2 === 0) {
+    return range$1(make$1(p.c0, p.c1), domain2);
+  }
+  const e = extreme(p);
+  return e !== null && contains(domain2, e) ? fromMinMax(
+    solve(p, domain2.start),
+    solve(p, domain2.end),
+    solve(p, e)
+  ) : fromMinMax(solve(p, domain2.start), solve(p, domain2.end));
+});
+const length = dual(2, (p, domain2) => {
+  if (size(domain2) === 0) {
+    return 0;
+  }
+  if (p.c2 === 0) {
+    return length$1(make$1(p.c0, p.c1), domain2);
+  }
+  const d = derivative(p);
+  const derivativeStart = solve$1(d, domain2.start);
+  const sqrtStart = Math.sqrt(1 + derivativeStart ** 2);
+  const evalStart = (derivativeStart * sqrtStart + Math.log(Math.abs(derivativeStart + sqrtStart))) / (4 * p.c2);
+  const derivativeEnd = solve$1(d, domain2.end);
+  const sqrtEnd = Math.sqrt(1 + derivativeEnd ** 2);
+  const evalEnd = (derivativeEnd * sqrtEnd + Math.log(Math.abs(derivativeEnd + sqrtEnd))) / (4 * p.c2);
+  return round(evalEnd - evalStart);
+});
+const curvature = dual(
+  2,
+  (p, x) => round(
+    Math.abs(2 * p.c2) / (1 + (solve$1(derivative(p), x) ** 2) ** 1.5)
+  )
+);
+
+export { CubicPolynomialImpl as C, CubicPolynomialTypeId as a, monotonicity as b, solve as c, derivative as d, toInverseSolver as e, fromVector as f, guaranteedMonotonicityFromComparison as g, extreme as h, isQuadraticPolynomial as i, antiderivative as j, domain as k, length as l, make as m, range as n, curvature as o, roots as r, solveInverse as s, toSolver as t };

package/dist/shared/curvy.D7bhnwZy.mjs

@@ -0,0 +1,52 @@
+import { d as dual, r as round, P as Pipeable } from './curvy.ChkqgKuv.mjs';
+
+const Vector3TypeId = Symbol.for("curvy/vector3");
+class Vector3Impl extends Pipeable {
+  [Vector3TypeId] = Vector3TypeId;
+  x;
+  y;
+  z;
+  constructor(v0 = 0, v1 = 0, v2 = 0) {
+    super();
+    this.x = round(v0);
+    this.y = round(v1);
+    this.z = round(v2);
+  }
+  get [0]() {
+    return this.x;
+  }
+  get [1]() {
+    return this.y;
+  }
+  get [2]() {
+    return this.z;
+  }
+  get [Symbol.toStringTag]() {
+    return `Vector3(${this.x}, ${this.y}, ${this.z})`;
+  }
+  get [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this[Symbol.toStringTag];
+  }
+}
+const isVector3 = (v) => typeof v === "object" && v !== null && Vector3TypeId in v;
+const magnitude = (vector) => round(Math.hypot(vector.x, vector.y, vector.z));
+const normalize = (vector) => {
+  const m = magnitude(vector);
+  return make(vector.x / m, vector.y / m, vector.z / m);
+};
+const dot = dual(2, (a, b) => round(a.x * b.x + a.y * b.y + a.z * b.z));
+const components = (v) => [v.x, v.y, v.z];
+const softmax = (v) => {
+  const max = Math.max(v.x, v.y, v.z);
+  const v0 = Math.exp(v.x - max);
+  const v1 = Math.exp(v.y - max);
+  const v2 = Math.exp(v.z - max);
+  const sum = v0 + v1 + v2;
+  return make(v0 / sum, v1 / sum, v2 / sum);
+};
+const make = (v0, v1 = v0, v2 = v1) => new Vector3Impl(v0, v1, v2);
+const add = dual(2, (a, b) => make(a.x + b.x, a.y + b.y, a.z + b.z));
+const subtract = dual(2, (a, b) => make(a.x - b.x, a.y - b.y, a.z - b.z));
+const hadamard = dual(2, (a, b) => make(a.x * b.x, a.y * b.y, a.z * b.z));
+
+export { magnitude as a, add as b, components as c, dot as d, subtract as e, hadamard as h, isVector3 as i, make as m, normalize as n, softmax as s };