curvy 0.3.2 → 1.0.0

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

@@ -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.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.Bxxwly94.d.mts

@@ -0,0 +1,144 @@
+import { P as Pipeable } from './curvy.BN-oFBsc.mjs';
+import { Interval } from '../interval.mjs';
+import { Vector2 } from '../vector/vector2.mjs';
+import { Vector3 } from '../vector/vector3.mjs';
+import { Vector4 } from '../vector/vector4.mjs';
+
+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$1: (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 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: (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 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 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 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 { domain$1 as A, range$1 as B, type CubicPolynomial as C, length$1 as D, isLinearPolynomial as E, make as F, fromVector as G, solve as H, toSolver as I, solveInverse as J, toInverseSolver as K, type LinearPolynomial as L, root as M, monotonicity as N, antiderivative as O, domain as P, type QuadraticPolynomial as Q, range as R, length as S, solveInverse$2 as a, toInverseSolver$2 as b, monotonicity$2 as c, derivative$1 as d, extrema as e, fromVector$2 as f, domain$2 as g, range$2 as h, isCubicPolynomial as i, isQuadraticPolynomial as j, make$1 as k, length$2 as l, make$2 as m, fromVector$1 as n, solve$1 as o, toSolver$1 as p, solveInverse$1 as q, roots$1 as r, solve$2 as s, toSolver$2 as t, toInverseSolver$1 as u, derivative as v, roots as w, extreme as x, monotonicity$1 as y, antiderivative$1 as z };

package/dist/shared/curvy.C-sUk7ux.mjs

@@ -0,0 +1,119 @@
+import { i as invariant, d as dual, r as round, P as Pipeable } from './curvy.ChkqgKuv.mjs';
+import { m as make$1, d as dot } from './curvy.DOLqYbKE.mjs';
+
+function toIndex(input) {
+  if (typeof input === "number") {
+    invariant(input >= 0 && input <= 3, "Index out of bounds");
+    return input;
+  }
+  if (input === "x") {
+    return 0;
+  }
+  if (input === "y") {
+    return 1;
+  }
+  if (input === "z") {
+    return 2;
+  }
+  if (input === "w") {
+    return 3;
+  }
+  invariant(false, "Invalid component");
+}
+const toTwoDimensionalIndex = toIndex;
+const toThreeDimensionalIndex = toIndex;
+const toFourDimensionalIndex = toIndex;
+
+const Matrix2x2TypeId = Symbol.for("curvy/matrix2x2");
+class Matrix2x2Impl extends Pipeable {
+  [Matrix2x2TypeId] = Matrix2x2TypeId;
+  m00;
+  m01;
+  m10;
+  m11;
+  constructor(m00 = 0, m01 = 0, m10 = 0, m11 = 0) {
+    super();
+    this.m00 = round(m00);
+    this.m01 = round(m01);
+    this.m10 = round(m10);
+    this.m11 = round(m11);
+  }
+  get [Symbol.toStringTag]() {
+    return `Matrix2x2(${this.m00}, ${this.m01}, ${this.m10}, ${this.m11})`;
+  }
+  get [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `Matrix2x2(${this.m00}, ${this.m01}, ${this.m10}, ${this.m11})`;
+  }
+  [Symbol.hasInstance](m) {
+    return isMatrix2x2(m);
+  }
+}
+const isMatrix2x2 = (m) => typeof m === "object" && m !== null && Matrix2x2TypeId in m;
+const make = (m00 = 0, m01 = m00, m10 = m01, m11 = m10) => new Matrix2x2Impl(m00, m01, m10, m11);
+const fromRows = (v0, v1) => new Matrix2x2Impl(v0.x, v0.y, v1.x, v1.y);
+const fromColumns = (v0, v1) => new Matrix2x2Impl(v0.x, v1.x, v0.y, v1.y);
+const setRow = dual(
+  3,
+  (m, row, v) => fromRows(
+    ...toRows(m).with(toTwoDimensionalIndex(row), v)
+  )
+);
+const setColumn = dual(
+  3,
+  (m, column, v) => fromColumns(
+    ...toColumns(m).with(toTwoDimensionalIndex(column), v)
+  )
+);
+const determinant = (m) => round(m.m00 * m.m11 - m.m01 * m.m10);
+const vectorProductLeft = dual(
+  2,
+  (m, v) => make$1(
+    dot(rowVector(m, 0), v),
+    dot(rowVector(m, 1), v)
+  )
+);
+const vectorProductRight = dual(
+  2,
+  (m, v) => make$1(
+    dot(columnVector(m, 0), v),
+    dot(columnVector(m, 1), v)
+  )
+);
+const solveSystem = dual(2, (m, v) => {
+  const inverseDeterminant = 1 / determinant(m);
+  invariant(
+    Number.isFinite(inverseDeterminant),
+    "cannot solve system when coefficient matrix determinant is zero"
+  );
+  return make$1(
+    determinant(setColumn(m, 0, v)) * inverseDeterminant,
+    determinant(setColumn(m, 1, v)) * inverseDeterminant
+  );
+});
+const toRows = (m) => [
+  make$1(m.m00, m.m01),
+  make$1(m.m10, m.m11)
+];
+const toColumns = (m) => [
+  make$1(m.m00, m.m10),
+  make$1(m.m01, m.m11)
+];
+const rowVector = dual(
+  2,
+  (m, row) => toRows(m)[toTwoDimensionalIndex(row)]
+);
+const columnVector = dual(
+  2,
+  (m, column) => toColumns(m)[toTwoDimensionalIndex(column)]
+);
+const transpose = (m) => fromColumns(...toRows(m));
+const reverseRows = (m) => {
+  const [r0, r1] = toRows(m);
+  return fromRows(r1, r0);
+};
+const reverseColumns = (m) => {
+  const [c0, c1] = toColumns(m);
+  return fromColumns(c1, c0);
+};
+
+export { fromColumns as a, setColumn as b, vectorProductRight as c, determinant as d, solveSystem as e, fromRows as f, toColumns as g, columnVector as h, isMatrix2x2 as i, transpose as j, reverseRows as k, reverseColumns as l, make as m, toFourDimensionalIndex as n, toThreeDimensionalIndex as o, rowVector as r, setRow as s, toRows as t, vectorProductLeft as v };

package/dist/shared/curvy.CLzGuqek.mjs

@@ -0,0 +1,124 @@
+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, s as solveInverse$1, m as monotonicity$1, r as range$1, l as length$1, c as solve$1 } from './curvy.DgRsieUW.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);
+});
+
+export { CubicPolynomialImpl as C, CubicPolynomialTypeId as a, monotonicity as b, solve as c, toInverseSolver as d, derivative 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, roots as r, solveInverse as s, toSolver as t };

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

@@ -0,0 +1,144 @@
+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$1: (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 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: (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 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 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 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 { domain$1 as A, range$1 as B, type CubicPolynomial as C, length$1 as D, isLinearPolynomial as E, make as F, fromVector as G, solve as H, toSolver as I, solveInverse as J, toInverseSolver as K, type LinearPolynomial as L, root as M, monotonicity as N, antiderivative as O, domain as P, type QuadraticPolynomial as Q, range as R, length as S, solveInverse$2 as a, toInverseSolver$2 as b, monotonicity$2 as c, derivative$1 as d, extrema as e, fromVector$2 as f, domain$2 as g, range$2 as h, isCubicPolynomial as i, isQuadraticPolynomial as j, make$1 as k, length$2 as l, make$2 as m, fromVector$1 as n, solve$1 as o, toSolver$1 as p, solveInverse$1 as q, roots$1 as r, solve$2 as s, toSolver$2 as t, toInverseSolver$1 as u, derivative as v, roots as w, extreme as x, monotonicity$1 as y, antiderivative$1 as z };

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 };