curvy 0.3.3 → 1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Tim Morris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/curve/cubic2d.d.mts

@@ -0,0 +1,27 @@
+import { e as TwoDimensional } from '../shared/curvy.CT38g_II.mjs';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+import { Interval } from '../interval.mjs';
+import { C as CubicPolynomial } from '../shared/curvy.Bxxwly94.mjs';
+import { Vector2 } from '../vector/vector2.mjs';
+import '../vector/vector3.mjs';
+import '../vector/vector4.mjs';
+
+declare const CubicCurve2dTypeId: unique symbol;
+type CubicCurve2dTypeId = typeof CubicCurve2dTypeId;
+
+interface CubicCurve2d extends Pipeable, TwoDimensional<CubicPolynomial> {
+    readonly [CubicCurve2dTypeId]: CubicCurve2dTypeId;
+}
+declare const fromPolynomials: (x: CubicPolynomial, y: CubicPolynomial) => CubicCurve2d;
+declare const fromPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => CubicCurve2d;
+declare const isCubicCurve2d: (c: unknown) => c is CubicCurve2d;
+declare const solve: {
+    (t: number): (c: CubicCurve2d) => Vector2;
+    (c: CubicCurve2d, t: number): Vector2;
+};
+declare const length: {
+    (c: CubicCurve2d, i: Interval): number;
+    (i: Interval): (c: CubicCurve2d) => number;
+};
+
+export { type CubicCurve2d, fromPoints, fromPolynomials, isCubicCurve2d, length, solve };

package/dist/curve/cubic2d.d.ts

@@ -0,0 +1,27 @@
+import { e as TwoDimensional } from '../shared/curvy.CT38g_II.js';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+import { Interval } from '../interval.js';
+import { C as CubicPolynomial } from '../shared/curvy.CO0Wclt0.js';
+import { Vector2 } from '../vector/vector2.js';
+import '../vector/vector3.js';
+import '../vector/vector4.js';
+
+declare const CubicCurve2dTypeId: unique symbol;
+type CubicCurve2dTypeId = typeof CubicCurve2dTypeId;
+
+interface CubicCurve2d extends Pipeable, TwoDimensional<CubicPolynomial> {
+    readonly [CubicCurve2dTypeId]: CubicCurve2dTypeId;
+}
+declare const fromPolynomials: (x: CubicPolynomial, y: CubicPolynomial) => CubicCurve2d;
+declare const fromPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => CubicCurve2d;
+declare const isCubicCurve2d: (c: unknown) => c is CubicCurve2d;
+declare const solve: {
+    (t: number): (c: CubicCurve2d) => Vector2;
+    (c: CubicCurve2d, t: number): Vector2;
+};
+declare const length: {
+    (c: CubicCurve2d, i: Interval): number;
+    (i: Interval): (c: CubicCurve2d) => number;
+};
+
+export { type CubicCurve2d, fromPoints, fromPolynomials, isCubicCurve2d, length, solve };

package/dist/curve/cubic2d.mjs

@@ -0,0 +1,85 @@
+import { d as dual, r as round, P as Pipeable } from '../shared/curvy.ChkqgKuv.mjs';
+import { size, scaleShift, biunit } from '../interval.mjs';
+import { G as GL32_W0, a as GL32_X0, b as GL32_W1, c as GL32_X1, d as GL32_W2, e as GL32_X2, f as GL32_W3, g as GL32_X3, h as GL32_W4, i as GL32_X4, j as GL32_W5, k as GL32_X5, l as GL32_W6, m as GL32_X6, n as GL32_W7, o as GL32_X7, p as GL32_W8, q as GL32_X8, r as GL32_W9, s as GL32_X9, t as GL32_W10, u as GL32_X10, v as GL32_W11, w as GL32_X11, x as GL32_W12, y as GL32_X12, z as GL32_W13, A as GL32_X13, B as GL32_W14, C as GL32_X14, D as GL32_W15, E as GL32_X15 } from '../shared/curvy.DmVFTi0N.mjs';
+import { make, solve as solve$2, derivative as derivative$1 } from '../polynomial/cubic.mjs';
+import { make as make$2 } from '../polynomial/quadratic.mjs';
+import { make as make$1, magnitude } from '../vector/vector2.mjs';
+import { length as length$2, fromPolynomials as fromPolynomials$2, solve as solve$3 } from './quadratic2d.mjs';
+import '../shared/curvy.CLzGuqek.mjs';
+import '../shared/curvy.DgRsieUW.mjs';
+import '../shared/curvy.DOLqYbKE.mjs';
+import '../polynomial/linear.mjs';
+import './linear2d.mjs';
+
+const CubicCurve2dTypeId = Symbol("curvy/curve/cubic2d");
+class CubicCurve2dImpl extends Pipeable {
+  [CubicCurve2dTypeId] = CubicCurve2dTypeId;
+  x;
+  y;
+  constructor(c0, c1) {
+    super();
+    this.x = c0;
+    this.y = c1;
+  }
+  get [0]() {
+    return this.x;
+  }
+  get [1]() {
+    return this.y;
+  }
+}
+const fromPolynomials$1 = (c0, c1) => new CubicCurve2dImpl(c0, c1);
+const fromPoints$1 = (p0, p1, p2, p3) => new CubicCurve2dImpl(
+  make(p0.x, p1.x, p2.x, p3.x),
+  make(p0.y, p1.y, p2.y, p3.y)
+);
+const isCubicCurve2d$1 = (c) => typeof c === "object" && c !== null && CubicCurve2dTypeId in c;
+const solve$1 = dual(
+  2,
+  (c, t) => make$1(solve$2(c.x, t), solve$2(c.y, t))
+);
+const derivative = (c) => fromPolynomials$2(
+  derivative$1(c.x),
+  derivative$1(c.y)
+);
+const length$1 = dual(2, (c, i) => {
+  if (size(i) === 0) {
+    return 0;
+  }
+  if (c.x.c3 === 0 && c.y.c3 === 0) {
+    return length$2(
+      fromPolynomials$2(
+        make$2(c.x.c0, c.x.c1, c.x.c2),
+        make$2(c.y.c0, c.y.c1, c.y.c2)
+      ),
+      i
+    );
+  }
+  const d = derivative(c);
+  const { scale, shift } = scaleShift(biunit, i);
+  return round(
+    (GL32_W0 * magnitude(solve$3(d, shift + scale * -GL32_X0)) + GL32_W0 * magnitude(solve$3(d, shift + scale * GL32_X0)) + GL32_W1 * magnitude(solve$3(d, shift + scale * -GL32_X1)) + GL32_W1 * magnitude(solve$3(d, shift + scale * GL32_X1)) + GL32_W2 * magnitude(solve$3(d, shift + scale * -GL32_X2)) + GL32_W2 * magnitude(solve$3(d, shift + scale * GL32_X2)) + GL32_W3 * magnitude(solve$3(d, shift + scale * -GL32_X3)) + GL32_W3 * magnitude(solve$3(d, shift + scale * GL32_X3)) + GL32_W4 * magnitude(solve$3(d, shift + scale * -GL32_X4)) + GL32_W4 * magnitude(solve$3(d, shift + scale * GL32_X4)) + GL32_W5 * magnitude(solve$3(d, shift + scale * -GL32_X5)) + GL32_W5 * magnitude(solve$3(d, shift + scale * GL32_X5)) + GL32_W6 * magnitude(solve$3(d, shift + scale * -GL32_X6)) + GL32_W6 * magnitude(solve$3(d, shift + scale * GL32_X6)) + GL32_W7 * magnitude(solve$3(d, shift + scale * -GL32_X7)) + GL32_W7 * magnitude(solve$3(d, shift + scale * GL32_X7)) + GL32_W8 * magnitude(solve$3(d, shift + scale * -GL32_X8)) + GL32_W8 * magnitude(solve$3(d, shift + scale * GL32_X8)) + GL32_W9 * magnitude(solve$3(d, shift + scale * -GL32_X9)) + GL32_W9 * magnitude(solve$3(d, shift + scale * GL32_X9)) + GL32_W10 * magnitude(
+      solve$3(d, shift + scale * -GL32_X10)
+    ) + GL32_W10 * magnitude(solve$3(d, shift + scale * GL32_X10)) + GL32_W11 * magnitude(
+      solve$3(d, shift + scale * -GL32_X11)
+    ) + GL32_W11 * magnitude(solve$3(d, shift + scale * GL32_X11)) + GL32_W12 * magnitude(
+      solve$3(d, shift + scale * -GL32_X12)
+    ) + GL32_W12 * magnitude(solve$3(d, shift + scale * GL32_X12)) + GL32_W13 * magnitude(
+      solve$3(d, shift + scale * -GL32_X13)
+    ) + GL32_W13 * magnitude(solve$3(d, shift + scale * GL32_X13)) + GL32_W14 * magnitude(
+      solve$3(d, shift + scale * -GL32_X14)
+    ) + GL32_W14 * magnitude(solve$3(d, shift + scale * GL32_X14)) + GL32_W15 * magnitude(
+      solve$3(d, shift + scale * -GL32_X15)
+    ) + GL32_W15 * magnitude(
+      solve$3(d, shift + scale * GL32_X15)
+    )) * scale
+  );
+});
+
+const fromPolynomials = fromPolynomials$1;
+const fromPoints = fromPoints$1;
+const isCubicCurve2d = isCubicCurve2d$1;
+const solve = solve$1;
+const length = length$1;
+
+export { fromPoints, fromPolynomials, isCubicCurve2d, length, solve };

package/dist/curve/linear2d.d.mts

@@ -0,0 +1,27 @@
+import { e as TwoDimensional } from '../shared/curvy.CT38g_II.mjs';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+import { Interval } from '../interval.mjs';
+import { L as LinearPolynomial } from '../shared/curvy.Bxxwly94.mjs';
+import { Vector2 } from '../vector/vector2.mjs';
+import '../vector/vector3.mjs';
+import '../vector/vector4.mjs';
+
+declare const LinearCurve2dTypeId: unique symbol;
+type LinearCurve2dTypeId = typeof LinearCurve2dTypeId;
+
+interface LinearCurve2d extends Pipeable, TwoDimensional<LinearPolynomial> {
+    readonly [LinearCurve2dTypeId]: LinearCurve2dTypeId;
+}
+declare const fromPolynomials: (x: LinearPolynomial, y: LinearPolynomial) => LinearCurve2d;
+declare const fromPoints: (p0: Vector2, p1: Vector2) => LinearCurve2d;
+declare const isLinearCurve2d: (c: unknown) => c is LinearCurve2d;
+declare const solve: {
+    (t: number): (c: LinearCurve2d) => Vector2;
+    (c: LinearCurve2d, t: number): Vector2;
+};
+declare const length: {
+    (c: LinearCurve2d, i: Interval): number;
+    (i: Interval): (c: LinearCurve2d) => number;
+};
+
+export { type LinearCurve2d, fromPoints, fromPolynomials, isLinearCurve2d, length, solve };

package/dist/curve/linear2d.d.ts

@@ -0,0 +1,27 @@
+import { e as TwoDimensional } from '../shared/curvy.CT38g_II.js';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+import { Interval } from '../interval.js';
+import { L as LinearPolynomial } from '../shared/curvy.CO0Wclt0.js';
+import { Vector2 } from '../vector/vector2.js';
+import '../vector/vector3.js';
+import '../vector/vector4.js';
+
+declare const LinearCurve2dTypeId: unique symbol;
+type LinearCurve2dTypeId = typeof LinearCurve2dTypeId;
+
+interface LinearCurve2d extends Pipeable, TwoDimensional<LinearPolynomial> {
+    readonly [LinearCurve2dTypeId]: LinearCurve2dTypeId;
+}
+declare const fromPolynomials: (x: LinearPolynomial, y: LinearPolynomial) => LinearCurve2d;
+declare const fromPoints: (p0: Vector2, p1: Vector2) => LinearCurve2d;
+declare const isLinearCurve2d: (c: unknown) => c is LinearCurve2d;
+declare const solve: {
+    (t: number): (c: LinearCurve2d) => Vector2;
+    (c: LinearCurve2d, t: number): Vector2;
+};
+declare const length: {
+    (c: LinearCurve2d, i: Interval): number;
+    (i: Interval): (c: LinearCurve2d) => number;
+};
+
+export { type LinearCurve2d, fromPoints, fromPolynomials, isLinearCurve2d, length, solve };

package/dist/curve/linear2d.mjs

@@ -0,0 +1,46 @@
+import { d as dual, r as round, P as Pipeable } from '../shared/curvy.ChkqgKuv.mjs';
+import { make, solve as solve$2 } from '../polynomial/linear.mjs';
+import { make as make$1 } from '../vector/vector2.mjs';
+import '../shared/curvy.DgRsieUW.mjs';
+import '../interval.mjs';
+import '../shared/curvy.DOLqYbKE.mjs';
+
+const LinearCurve2dTypeId = Symbol("curvy/curve/linear2d");
+class LinearCurve2dImpl extends Pipeable {
+  [LinearCurve2dTypeId] = LinearCurve2dTypeId;
+  x;
+  y;
+  constructor(c0, c1) {
+    super();
+    this.x = c0;
+    this.y = c1;
+  }
+  get [0]() {
+    return this.x;
+  }
+  get [1]() {
+    return this.y;
+  }
+}
+const fromPolynomials$1 = (c0, c1) => new LinearCurve2dImpl(c0, c1);
+const fromPoints$1 = (p0, p1) => new LinearCurve2dImpl(
+  make(p0.x, p1.x),
+  make(p0.y, p1.y)
+);
+const isLinearCurve2d$1 = (c) => typeof c === "object" && c !== null && LinearCurve2dTypeId in c;
+const solve$1 = dual(
+  2,
+  (c, t) => make$1(solve$2(c.x, t), solve$2(c.y, t))
+);
+const length$1 = dual(
+  2,
+  (c, i) => round(Math.sqrt(c.x.c1 ** 2 + c.y.c1 ** 2) * Math.abs(i.end - i.start))
+);
+
+const fromPolynomials = fromPolynomials$1;
+const fromPoints = fromPoints$1;
+const isLinearCurve2d = isLinearCurve2d$1;
+const solve = solve$1;
+const length = length$1;
+
+export { fromPoints, fromPolynomials, isLinearCurve2d, length, solve };

package/dist/curve/quadratic2d.d.mts

@@ -0,0 +1,27 @@
+import { e as TwoDimensional } from '../shared/curvy.CT38g_II.mjs';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+import { Interval } from '../interval.mjs';
+import { Q as QuadraticPolynomial } from '../shared/curvy.Bxxwly94.mjs';
+import { Vector2 } from '../vector/vector2.mjs';
+import '../vector/vector3.mjs';
+import '../vector/vector4.mjs';
+
+declare const QuadraticCurve2dTypeId: unique symbol;
+type QuadraticCurve2dTypeId = typeof QuadraticCurve2dTypeId;
+
+interface QuadraticCurve2d extends Pipeable, TwoDimensional<QuadraticPolynomial> {
+    readonly [QuadraticCurve2dTypeId]: QuadraticCurve2dTypeId;
+}
+declare const fromPolynomials: (c0: QuadraticPolynomial, c1: QuadraticPolynomial) => QuadraticCurve2d;
+declare const fromPoints: (p0: Vector2, p1: Vector2, p2: Vector2) => QuadraticCurve2d;
+declare const isQuadraticCurve2d: (c: unknown) => c is QuadraticCurve2d;
+declare const solve: {
+    (t: number): (c: QuadraticCurve2d) => Vector2;
+    (c: QuadraticCurve2d, t: number): Vector2;
+};
+declare const length: {
+    (c: QuadraticCurve2d, i: Interval): number;
+    (i: Interval): (c: QuadraticCurve2d) => number;
+};
+
+export { type QuadraticCurve2d, fromPoints, fromPolynomials, isQuadraticCurve2d, length, solve };

package/dist/curve/quadratic2d.d.ts

@@ -0,0 +1,27 @@
+import { e as TwoDimensional } from '../shared/curvy.CT38g_II.js';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+import { Interval } from '../interval.js';
+import { Q as QuadraticPolynomial } from '../shared/curvy.CO0Wclt0.js';
+import { Vector2 } from '../vector/vector2.js';
+import '../vector/vector3.js';
+import '../vector/vector4.js';
+
+declare const QuadraticCurve2dTypeId: unique symbol;
+type QuadraticCurve2dTypeId = typeof QuadraticCurve2dTypeId;
+
+interface QuadraticCurve2d extends Pipeable, TwoDimensional<QuadraticPolynomial> {
+    readonly [QuadraticCurve2dTypeId]: QuadraticCurve2dTypeId;
+}
+declare const fromPolynomials: (c0: QuadraticPolynomial, c1: QuadraticPolynomial) => QuadraticCurve2d;
+declare const fromPoints: (p0: Vector2, p1: Vector2, p2: Vector2) => QuadraticCurve2d;
+declare const isQuadraticCurve2d: (c: unknown) => c is QuadraticCurve2d;
+declare const solve: {
+    (t: number): (c: QuadraticCurve2d) => Vector2;
+    (c: QuadraticCurve2d, t: number): Vector2;
+};
+declare const length: {
+    (c: QuadraticCurve2d, i: Interval): number;
+    (i: Interval): (c: QuadraticCurve2d) => number;
+};
+
+export { type QuadraticCurve2d, fromPoints, fromPolynomials, isQuadraticCurve2d, length, solve };

package/dist/curve/quadratic2d.mjs

@@ -0,0 +1,74 @@
+import { d as dual, r as round, P as Pipeable } from '../shared/curvy.ChkqgKuv.mjs';
+import { size, scaleShift, biunit } from '../interval.mjs';
+import { G as GL32_W0, a as GL32_X0, b as GL32_W1, c as GL32_X1, d as GL32_W2, e as GL32_X2, f as GL32_W3, g as GL32_X3, h as GL32_W4, i as GL32_X4, j as GL32_W5, k as GL32_X5, l as GL32_W6, m as GL32_X6, n as GL32_W7, o as GL32_X7, p as GL32_W8, q as GL32_X8, r as GL32_W9, s as GL32_X9, t as GL32_W10, u as GL32_X10, v as GL32_W11, w as GL32_X11, x as GL32_W12, y as GL32_X12, z as GL32_W13, A as GL32_X13, B as GL32_W14, C as GL32_X14, D as GL32_W15, E as GL32_X15 } from '../shared/curvy.DmVFTi0N.mjs';
+import { make as make$2 } from '../polynomial/linear.mjs';
+import { make, solve as solve$2, derivative as derivative$1 } from '../polynomial/quadratic.mjs';
+import { make as make$1, magnitude } from '../vector/vector2.mjs';
+import { length as length$2, fromPolynomials as fromPolynomials$2, solve as solve$3 } from './linear2d.mjs';
+import '../shared/curvy.DgRsieUW.mjs';
+import '../shared/curvy.CLzGuqek.mjs';
+import '../shared/curvy.DOLqYbKE.mjs';
+
+const QuadraticCurve2dTypeId = Symbol(
+  "curvy/curve/quadratic2d"
+);
+class QuadraticCurve2dImpl extends Pipeable {
+  [QuadraticCurve2dTypeId] = QuadraticCurve2dTypeId;
+  x;
+  y;
+  constructor(c0, c1) {
+    super();
+    this.x = c0;
+    this.y = c1;
+  }
+  get [0]() {
+    return this.x;
+  }
+  get [1]() {
+    return this.y;
+  }
+}
+const fromPolynomials$1 = (c0, c1) => new QuadraticCurve2dImpl(c0, c1);
+const fromPoints$1 = (p0, p1, p2) => new QuadraticCurve2dImpl(
+  make(p0.x, p1.x, p2.x),
+  make(p0.y, p1.y, p2.y)
+);
+const isQuadraticCurve2d$1 = (c) => typeof c === "object" && c !== null && QuadraticCurve2dTypeId in c;
+const solve$1 = dual(
+  2,
+  (c, t) => make$1(
+    solve$2(c.x, t),
+    solve$2(c.y, t)
+  )
+);
+const derivative = (c) => fromPolynomials$2(
+  derivative$1(c.x),
+  derivative$1(c.y)
+);
+const length$1 = dual(2, (c, i) => {
+  if (size(i) === 0) {
+    return 0;
+  }
+  if (c.x.c2 === 0 && c.y.c2 === 0) {
+    return length$2(
+      fromPolynomials$2(
+        make$2(c.x.c0, c.x.c1),
+        make$2(c.y.c0, c.y.c1)
+      ),
+      i
+    );
+  }
+  const d = derivative(c);
+  const { scale, shift } = scaleShift(biunit, i);
+  return round(
+    (GL32_W0 * magnitude(solve$3(d, shift + scale * -GL32_X0)) + GL32_W0 * magnitude(solve$3(d, shift + scale * GL32_X0)) + GL32_W1 * magnitude(solve$3(d, shift + scale * -GL32_X1)) + GL32_W1 * magnitude(solve$3(d, shift + scale * GL32_X1)) + GL32_W2 * magnitude(solve$3(d, shift + scale * -GL32_X2)) + GL32_W2 * magnitude(solve$3(d, shift + scale * GL32_X2)) + GL32_W3 * magnitude(solve$3(d, shift + scale * -GL32_X3)) + GL32_W3 * magnitude(solve$3(d, shift + scale * GL32_X3)) + GL32_W4 * magnitude(solve$3(d, shift + scale * -GL32_X4)) + GL32_W4 * magnitude(solve$3(d, shift + scale * GL32_X4)) + GL32_W5 * magnitude(solve$3(d, shift + scale * -GL32_X5)) + GL32_W5 * magnitude(solve$3(d, shift + scale * GL32_X5)) + GL32_W6 * magnitude(solve$3(d, shift + scale * -GL32_X6)) + GL32_W6 * magnitude(solve$3(d, shift + scale * GL32_X6)) + GL32_W7 * magnitude(solve$3(d, shift + scale * -GL32_X7)) + GL32_W7 * magnitude(solve$3(d, shift + scale * GL32_X7)) + GL32_W8 * magnitude(solve$3(d, shift + scale * -GL32_X8)) + GL32_W8 * magnitude(solve$3(d, shift + scale * GL32_X8)) + GL32_W9 * magnitude(solve$3(d, shift + scale * -GL32_X9)) + GL32_W9 * magnitude(solve$3(d, shift + scale * GL32_X9)) + GL32_W10 * magnitude(solve$3(d, shift + scale * -GL32_X10)) + GL32_W10 * magnitude(solve$3(d, shift + scale * GL32_X10)) + GL32_W11 * magnitude(solve$3(d, shift + scale * -GL32_X11)) + GL32_W11 * magnitude(solve$3(d, shift + scale * GL32_X11)) + GL32_W12 * magnitude(solve$3(d, shift + scale * -GL32_X12)) + GL32_W12 * magnitude(solve$3(d, shift + scale * GL32_X12)) + GL32_W13 * magnitude(solve$3(d, shift + scale * -GL32_X13)) + GL32_W13 * magnitude(solve$3(d, shift + scale * GL32_X13)) + GL32_W14 * magnitude(solve$3(d, shift + scale * -GL32_X14)) + GL32_W14 * magnitude(solve$3(d, shift + scale * GL32_X14)) + GL32_W15 * magnitude(solve$3(d, shift + scale * -GL32_X15)) + GL32_W15 * magnitude(solve$3(d, shift + scale * GL32_X15))) * scale
+  );
+});
+
+const fromPolynomials = fromPolynomials$1;
+const fromPoints = fromPoints$1;
+const isQuadraticCurve2d = isQuadraticCurve2d$1;
+const solve = solve$1;
+const length = length$1;
+
+export { fromPoints, fromPolynomials, isQuadraticCurve2d, length, solve };

package/dist/interval.d.mts

@@ -0,0 +1,58 @@
+import { P as Pipeable } from './shared/curvy.BN-oFBsc.mjs';
+
+interface Interval extends Pipeable {
+    readonly start: number;
+    readonly end: number;
+}
+declare const isInterval: (v: unknown) => v is Interval;
+declare const make: {
+    (point: number): Interval;
+    (start: number, end: number): Interval;
+};
+declare const fromSize: {
+    (size: number): Interval;
+    (start: number, size: number): Interval;
+};
+declare const fromMinMax: (...values: ReadonlyArray<number>) => Interval;
+declare const size: (i: Interval) => number;
+declare const contains: {
+    (interval: Interval, value: number, options?: {
+        includeStart?: boolean;
+        includeEnd?: boolean;
+    }): boolean;
+    (value: number, options?: {
+        includeStart?: boolean;
+        includeEnd?: boolean;
+    }): (interval: Interval) => boolean;
+};
+declare const filter: {
+    <V extends ReadonlyArray<number>>(interval: Interval, value: V, options?: {
+        includeStart?: boolean;
+        includeEnd?: boolean;
+    }): V;
+    <V extends ReadonlyArray<number>>(value: V, options?: {
+        includeStart?: boolean;
+        includeEnd?: boolean;
+    }): (interval: Interval) => V;
+};
+declare const clamp: {
+    (interval: Interval, value: number): number;
+    (value: number): (interval: Interval) => number;
+    (interval: Interval, value: ReadonlyArray<number>): ReadonlyArray<number>;
+    (value: ReadonlyArray<number>): (interval: Interval) => ReadonlyArray<number>;
+};
+declare const unit: Interval;
+declare const biunit: Interval;
+declare const lerp: (interval: Interval, t: number) => number;
+declare const toLerpFn: (interval: Interval) => (t: number) => number;
+declare const normalize: (interval: Interval, x: number) => number;
+declare const toNormalizeFn: (interval: Interval) => (x: number) => number;
+declare const remap: (source: Interval, target: Interval, x: number) => number;
+declare const toRemapFn: (source: Interval, target: Interval) => (x: number) => number;
+interface ScaleShift {
+    readonly scale: number;
+    readonly shift: number;
+}
+declare const scaleShift: (source: Interval, target: Interval) => ScaleShift;
+
+export { type Interval, type ScaleShift, biunit, clamp, contains, filter, fromMinMax, fromSize, isInterval, lerp, make, normalize, remap, scaleShift, size, toLerpFn, toNormalizeFn, toRemapFn, unit };

package/dist/interval.d.ts

@@ -0,0 +1,58 @@
+import { P as Pipeable } from './shared/curvy.BN-oFBsc.js';
+
+interface Interval extends Pipeable {
+    readonly start: number;
+    readonly end: number;
+}
+declare const isInterval: (v: unknown) => v is Interval;
+declare const make: {
+    (point: number): Interval;
+    (start: number, end: number): Interval;
+};
+declare const fromSize: {
+    (size: number): Interval;
+    (start: number, size: number): Interval;
+};
+declare const fromMinMax: (...values: ReadonlyArray<number>) => Interval;
+declare const size: (i: Interval) => number;
+declare const contains: {
+    (interval: Interval, value: number, options?: {
+        includeStart?: boolean;
+        includeEnd?: boolean;
+    }): boolean;
+    (value: number, options?: {
+        includeStart?: boolean;
+        includeEnd?: boolean;
+    }): (interval: Interval) => boolean;
+};
+declare const filter: {
+    <V extends ReadonlyArray<number>>(interval: Interval, value: V, options?: {
+        includeStart?: boolean;
+        includeEnd?: boolean;
+    }): V;
+    <V extends ReadonlyArray<number>>(value: V, options?: {
+        includeStart?: boolean;
+        includeEnd?: boolean;
+    }): (interval: Interval) => V;
+};
+declare const clamp: {
+    (interval: Interval, value: number): number;
+    (value: number): (interval: Interval) => number;
+    (interval: Interval, value: ReadonlyArray<number>): ReadonlyArray<number>;
+    (value: ReadonlyArray<number>): (interval: Interval) => ReadonlyArray<number>;
+};
+declare const unit: Interval;
+declare const biunit: Interval;
+declare const lerp: (interval: Interval, t: number) => number;
+declare const toLerpFn: (interval: Interval) => (t: number) => number;
+declare const normalize: (interval: Interval, x: number) => number;
+declare const toNormalizeFn: (interval: Interval) => (x: number) => number;
+declare const remap: (source: Interval, target: Interval, x: number) => number;
+declare const toRemapFn: (source: Interval, target: Interval) => (x: number) => number;
+interface ScaleShift {
+    readonly scale: number;
+    readonly shift: number;
+}
+declare const scaleShift: (source: Interval, target: Interval) => ScaleShift;
+
+export { type Interval, type ScaleShift, biunit, clamp, contains, filter, fromMinMax, fromSize, isInterval, lerp, make, normalize, remap, scaleShift, size, toLerpFn, toNormalizeFn, toRemapFn, unit };

package/dist/interval.mjs

@@ -0,0 +1,88 @@
+import { d as dual, P as Pipeable, r as round } from './shared/curvy.ChkqgKuv.mjs';
+
+const TypeId = Symbol.for("curvy/interval");
+class IntervalImpl extends Pipeable {
+  [TypeId] = TypeId;
+  start;
+  end;
+  constructor(start = 0, end = start) {
+    super();
+    if (end < start) {
+      throw new Error("Interval end must be greater than or equal to start");
+    }
+    this.start = round(start);
+    this.end = round(end);
+  }
+  get [Symbol.toStringTag]() {
+    return `Interval [${this.start}, ${this.end}]`;
+  }
+  get [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this[Symbol.toStringTag];
+  }
+}
+const isInterval$1 = (v) => typeof v === "object" && v !== null && TypeId in v;
+const make$1 = (start, end) => new IntervalImpl(start, end ?? start);
+const fromSize$1 = (a, b) => {
+  if (b === void 0) {
+    return new IntervalImpl(0, a);
+  }
+  return new IntervalImpl(a, a + b);
+};
+const fromMinMax$1 = (...values) => new IntervalImpl(Math.min(...values), Math.max(...values));
+const size$1 = (i) => Math.abs(i.end - i.start);
+const contains$1 = dual(
+  (args) => isInterval$1(args[0]),
+  (interval, value, { includeStart = true, includeEnd = true } = {}) => value > interval.start && value < interval.end || includeStart && value === interval.start || includeEnd && value === interval.end
+);
+const filter$1 = dual(
+  (args) => isInterval$1(args[0]),
+  (interval, value, options) => {
+    return value.filter((v) => contains$1(interval, v, options));
+  }
+);
+const clamp$1 = dual(
+  2,
+  (interval, value) => {
+    if (Array.isArray(value)) {
+      return value.map((v) => clamp$1(interval, v));
+    }
+    return contains$1(interval, value) ? value : value < interval.start ? interval.start : interval.end;
+  }
+);
+const unit$1 = make$1(0, 1);
+const biunit$1 = make$1(-1, 1);
+const lerp$1 = (interval, t) => (1 - t) * interval.start + t * interval.end;
+const toLerpFn$1 = (interval) => (t) => lerp$1(interval, t);
+const normalize$1 = (interval, x) => (x - interval.start) / size$1(interval);
+const toNormalizeFn$1 = (interval) => (x) => normalize$1(interval, x);
+const remap$1 = (source, target, x) => {
+  return target.start + (x - source.start) * size$1(target) / size$1(source);
+};
+const toRemapFn$1 = (source, target) => (x) => remap$1(source, target, x);
+const scaleShift$1 = (source, target) => {
+  const scale = size$1(target) / size$1(source);
+  return {
+    scale,
+    shift: target.start - source.start * scale
+  };
+};
+
+const isInterval = isInterval$1;
+const make = make$1;
+const fromSize = fromSize$1;
+const fromMinMax = fromMinMax$1;
+const size = size$1;
+const contains = contains$1;
+const filter = filter$1;
+const clamp = clamp$1;
+const unit = unit$1;
+const biunit = biunit$1;
+const lerp = lerp$1;
+const toLerpFn = toLerpFn$1;
+const normalize = normalize$1;
+const toNormalizeFn = toNormalizeFn$1;
+const remap = remap$1;
+const toRemapFn = toRemapFn$1;
+const scaleShift = scaleShift$1;
+
+export { biunit, clamp, contains, filter, fromMinMax, fromSize, isInterval, lerp, make, normalize, remap, scaleShift, size, toLerpFn, toNormalizeFn, toRemapFn, unit };

package/dist/matrix/matrix2x2.d.mts

@@ -0,0 +1,49 @@
+import { c as TwoDimensionalIndex, d as TwoDimensionalComponent } from '../shared/curvy.CT38g_II.mjs';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+import { Vector2 } from '../vector/vector2.mjs';
+
+declare const Matrix2x2TypeId: unique symbol;
+type Matrix2x2TypeId = typeof Matrix2x2TypeId;
+
+type Matrix2x2Coordinate = TwoDimensionalIndex | TwoDimensionalComponent;
+interface Matrix2x2 extends Pipeable {
+    readonly [Matrix2x2TypeId]: Matrix2x2TypeId;
+    readonly m00: number;
+    readonly m01: number;
+    readonly m10: number;
+    readonly m11: number;
+}
+declare const isMatrix2x2: (m: unknown) => m is Matrix2x2;
+declare const matrix2x2: (m00?: number, m01?: number, m10?: number, m11?: number) => Matrix2x2;
+declare const fromRows: (v0: Vector2, v1: Vector2) => Matrix2x2;
+declare const fromColumns: (v0: Vector2, v1: Vector2) => Matrix2x2;
+declare const setRow: {
+    (m: Matrix2x2, row: Matrix2x2Coordinate, v: Vector2): Matrix2x2;
+    (row: Matrix2x2Coordinate, v: Vector2): (m: Matrix2x2) => Matrix2x2;
+};
+declare const setColumn: {
+    (m: Matrix2x2, column: Matrix2x2Coordinate, v: Vector2): Matrix2x2;
+    (column: Matrix2x2Coordinate, v: Vector2): (m: Matrix2x2) => Matrix2x2;
+};
+declare const determinant: (m: Matrix2x2) => number;
+declare const vectorProductLeft: {
+    (m: Matrix2x2, v: Vector2): Vector2;
+    (v: Vector2): (m: Matrix2x2) => Vector2;
+};
+declare const vectorProductRight: {
+    (m: Matrix2x2, v: Vector2): Vector2;
+    (v: Vector2): (m: Matrix2x2) => Vector2;
+};
+declare const solveSystem: {
+    (m: Matrix2x2, v: Vector2): Vector2;
+    (v: Vector2): (m: Matrix2x2) => Vector2;
+};
+declare const toRows: (m: Matrix2x2) => [Vector2, Vector2];
+declare const toColumns: (m: Matrix2x2) => [Vector2, Vector2];
+declare const rowVector: (m: Matrix2x2, row: Matrix2x2Coordinate) => Vector2;
+declare const columnVector: (m: Matrix2x2, column: Matrix2x2Coordinate) => Vector2;
+declare const transpose: (m: Matrix2x2) => Matrix2x2;
+declare const reverseRows: (m: Matrix2x2) => Matrix2x2;
+declare const reverseColumns: (m: Matrix2x2) => Matrix2x2;
+
+export { type Matrix2x2, type Matrix2x2Coordinate, columnVector, determinant, fromColumns, fromRows, isMatrix2x2, matrix2x2, reverseColumns, reverseRows, rowVector, setColumn, setRow, solveSystem, toColumns, toRows, transpose, vectorProductLeft, vectorProductRight };