curvy 0.3.3 → 1.0.0

package/dist/path/cubic2d.mjs

@@ -0,0 +1,60 @@
+import { length as length$2, solve as solve$2 } from '../curve/cubic2d.mjs';
+import { d as dual, r as round, P as Pipeable } from '../shared/curvy.ChkqgKuv.mjs';
+import { unit } from '../interval.mjs';
+import '../shared/curvy.DmVFTi0N.mjs';
+import '../polynomial/cubic.mjs';
+import '../shared/curvy.CLzGuqek.mjs';
+import '../shared/curvy.DgRsieUW.mjs';
+import '../polynomial/quadratic.mjs';
+import '../vector/vector2.mjs';
+import '../shared/curvy.DOLqYbKE.mjs';
+import '../curve/quadratic2d.mjs';
+import '../polynomial/linear.mjs';
+import '../curve/linear2d.mjs';
+
+const CubicPath2dTypeId = Symbol("curvy/path/cubic2d");
+class CubicPath2dImpl extends Pipeable {
+  [CubicPath2dTypeId] = CubicPath2dTypeId;
+  curves;
+  constructor(curves) {
+    super();
+    this.curves = curves;
+  }
+  [Symbol.iterator]() {
+    return this.curves[Symbol.iterator]();
+  }
+}
+const isCubicPath2d$1 = (p) => typeof p === "object" && p !== null && CubicPath2dTypeId in p;
+const fromCurves$1 = (...curves) => new CubicPath2dImpl(curves);
+const fromCurveArray$1 = (curves) => new CubicPath2dImpl(curves);
+const append$1 = dual(
+  2,
+  (p, c) => fromCurveArray$1([...p, c])
+);
+const length$1 = (p) => {
+  let length2 = 0;
+  for (const curve of p) {
+    length2 += length$2(curve, unit);
+  }
+  return round(length2);
+};
+const solve$1 = dual(2, (p, u) => {
+  const curves = p instanceof CubicPath2dImpl ? p.curves : [...p];
+  if (u === 1) {
+    const last = curves.at(-1);
+    return solve$2(last, 1);
+  }
+  const t = u * curves.length;
+  const i = Math.floor(t);
+  const curve = curves[i];
+  return solve$2(curve, t - i);
+});
+
+const fromCurves = fromCurves$1;
+const fromCurveArray = fromCurveArray$1;
+const isCubicPath2d = isCubicPath2d$1;
+const append = append$1;
+const length = length$1;
+const solve = solve$1;
+
+export { append, fromCurveArray, fromCurves, isCubicPath2d, length, solve };

package/dist/path/linear2d.d.mts

@@ -0,0 +1,29 @@
+import { LinearCurve2d } from '../curve/linear2d.mjs';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+import { Vector2 } from '../vector/vector2.mjs';
+import '../shared/curvy.CT38g_II.mjs';
+import '../interval.mjs';
+import '../shared/curvy.Bxxwly94.mjs';
+import '../vector/vector3.mjs';
+import '../vector/vector4.mjs';
+
+declare const LinearPath2dTypeId: unique symbol;
+type LinearPath2dTypeId = typeof LinearPath2dTypeId;
+
+interface LinearPath2d extends Pipeable, Iterable<LinearCurve2d> {
+    readonly [LinearPath2dTypeId]: LinearPath2dTypeId;
+}
+declare const fromCurves: (...curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+declare const fromCurveArray: (curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+declare const isLinearPath2d: (p: unknown) => p is LinearPath2d;
+declare const append: {
+    (c: LinearCurve2d): (p: LinearPath2d) => LinearPath2d;
+    (p: LinearPath2d, c: LinearCurve2d): LinearPath2d;
+};
+declare const length: (p: LinearPath2d) => number;
+declare const solve: {
+    (u: number): (p: LinearPath2d) => Vector2;
+    (p: LinearPath2d, u: number): Vector2;
+};
+
+export { type LinearPath2d, append, fromCurveArray, fromCurves, isLinearPath2d, length, solve };

package/dist/path/linear2d.d.ts

@@ -0,0 +1,29 @@
+import { LinearCurve2d } from '../curve/linear2d.js';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+import { Vector2 } from '../vector/vector2.js';
+import '../shared/curvy.CT38g_II.js';
+import '../interval.js';
+import '../shared/curvy.CO0Wclt0.js';
+import '../vector/vector3.js';
+import '../vector/vector4.js';
+
+declare const LinearPath2dTypeId: unique symbol;
+type LinearPath2dTypeId = typeof LinearPath2dTypeId;
+
+interface LinearPath2d extends Pipeable, Iterable<LinearCurve2d> {
+    readonly [LinearPath2dTypeId]: LinearPath2dTypeId;
+}
+declare const fromCurves: (...curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+declare const fromCurveArray: (curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+declare const isLinearPath2d: (p: unknown) => p is LinearPath2d;
+declare const append: {
+    (c: LinearCurve2d): (p: LinearPath2d) => LinearPath2d;
+    (p: LinearPath2d, c: LinearCurve2d): LinearPath2d;
+};
+declare const length: (p: LinearPath2d) => number;
+declare const solve: {
+    (u: number): (p: LinearPath2d) => Vector2;
+    (p: LinearPath2d, u: number): Vector2;
+};
+
+export { type LinearPath2d, append, fromCurveArray, fromCurves, isLinearPath2d, length, solve };

package/dist/path/linear2d.mjs

@@ -0,0 +1,54 @@
+import { length as length$2, solve as solve$2 } from '../curve/linear2d.mjs';
+import { d as dual, r as round, P as Pipeable } from '../shared/curvy.ChkqgKuv.mjs';
+import { unit } from '../interval.mjs';
+import '../polynomial/linear.mjs';
+import '../shared/curvy.DgRsieUW.mjs';
+import '../vector/vector2.mjs';
+import '../shared/curvy.DOLqYbKE.mjs';
+
+const LinearPath2dTypeId = Symbol("curvy/path/linear2d");
+class LinearPath2dImpl extends Pipeable {
+  [LinearPath2dTypeId] = LinearPath2dTypeId;
+  curves;
+  constructor(curves) {
+    super();
+    this.curves = curves;
+  }
+  [Symbol.iterator]() {
+    return this.curves[Symbol.iterator]();
+  }
+}
+const isLinearPath2d$1 = (p) => typeof p === "object" && p !== null && LinearPath2dTypeId in p;
+const fromCurves$1 = (...curves) => new LinearPath2dImpl(curves);
+const fromCurveArray$1 = (curves) => new LinearPath2dImpl(curves);
+const append$1 = dual(
+  2,
+  (p, c) => fromCurveArray$1([...p, c])
+);
+const length$1 = (p) => {
+  let length2 = 0;
+  for (const curve of p) {
+    length2 += length$2(curve, unit);
+  }
+  return round(length2);
+};
+const solve$1 = dual(2, (p, u) => {
+  const curves = p instanceof LinearPath2dImpl ? p.curves : [...p];
+  if (u === 1) {
+    const last = curves.at(-1);
+    return solve$2(last, 1);
+  }
+  const t = u * curves.length;
+  const i = Math.floor(t);
+  const curve = curves[i];
+  return solve$2(curve, t - i);
+});
+
+const fromCurves = fromCurves$1;
+const fromCurveArray = fromCurveArray$1;
+const isLinearPath2d = isLinearPath2d$1;
+const append = append$1;
+const length = length$1;
+const solve = solve$1;
+
+export { append, fromCurveArray, fromCurves, isLinearPath2d, length, solve };

package/dist/path/quadratic2d.d.mts

@@ -0,0 +1,29 @@
+import { QuadraticCurve2d } from '../curve/quadratic2d.mjs';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+import { Vector2 } from '../vector/vector2.mjs';
+import '../shared/curvy.CT38g_II.mjs';
+import '../interval.mjs';
+import '../shared/curvy.Bxxwly94.mjs';
+import '../vector/vector3.mjs';
+import '../vector/vector4.mjs';
+
+declare const QuadraticPath2dTypeId: unique symbol;
+type QuadraticPath2dTypeId = typeof QuadraticPath2dTypeId;
+
+interface QuadraticPath2d extends Pipeable, Iterable<QuadraticCurve2d> {
+    readonly [QuadraticPath2dTypeId]: QuadraticPath2dTypeId;
+}
+declare const fromCurves: (...curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d;
+declare const fromCurveArray: (curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d;
+declare const isQuadraticPath2d: (p: unknown) => p is QuadraticPath2d;
+declare const append: {
+    (c: QuadraticCurve2d): (p: QuadraticPath2d) => QuadraticPath2d;
+    (p: QuadraticPath2d, c: QuadraticCurve2d): QuadraticPath2d;
+};
+declare const length: (p: QuadraticPath2d) => number;
+declare const solve: {
+    (u: number): (p: QuadraticPath2d) => Vector2;
+    (p: QuadraticPath2d, u: number): Vector2;
+};
+
+export { type QuadraticPath2d, append, fromCurveArray, fromCurves, isQuadraticPath2d, length, solve };

package/dist/path/quadratic2d.d.ts

@@ -0,0 +1,29 @@
+import { QuadraticCurve2d } from '../curve/quadratic2d.js';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+import { Vector2 } from '../vector/vector2.js';
+import '../shared/curvy.CT38g_II.js';
+import '../interval.js';
+import '../shared/curvy.CO0Wclt0.js';
+import '../vector/vector3.js';
+import '../vector/vector4.js';
+
+declare const QuadraticPath2dTypeId: unique symbol;
+type QuadraticPath2dTypeId = typeof QuadraticPath2dTypeId;
+
+interface QuadraticPath2d extends Pipeable, Iterable<QuadraticCurve2d> {
+    readonly [QuadraticPath2dTypeId]: QuadraticPath2dTypeId;
+}
+declare const fromCurves: (...curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d;
+declare const fromCurveArray: (curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d;
+declare const isQuadraticPath2d: (p: unknown) => p is QuadraticPath2d;
+declare const append: {
+    (c: QuadraticCurve2d): (p: QuadraticPath2d) => QuadraticPath2d;
+    (p: QuadraticPath2d, c: QuadraticCurve2d): QuadraticPath2d;
+};
+declare const length: (p: QuadraticPath2d) => number;
+declare const solve: {
+    (u: number): (p: QuadraticPath2d) => Vector2;
+    (p: QuadraticPath2d, u: number): Vector2;
+};
+
+export { type QuadraticPath2d, append, fromCurveArray, fromCurves, isQuadraticPath2d, length, solve };

package/dist/path/quadratic2d.mjs

@@ -0,0 +1,60 @@
+import { length as length$2, solve as solve$2 } from '../curve/quadratic2d.mjs';
+import { d as dual, r as round, P as Pipeable } from '../shared/curvy.ChkqgKuv.mjs';
+import { unit } from '../interval.mjs';
+import '../shared/curvy.DmVFTi0N.mjs';
+import '../polynomial/linear.mjs';
+import '../shared/curvy.DgRsieUW.mjs';
+import '../polynomial/quadratic.mjs';
+import '../shared/curvy.CLzGuqek.mjs';
+import '../vector/vector2.mjs';
+import '../shared/curvy.DOLqYbKE.mjs';
+import '../curve/linear2d.mjs';
+
+const QuadraticPath2dTypeId = Symbol(
+  "curvy/path/quadratic2d"
+);
+class QuadraticPath2dImpl extends Pipeable {
+  [QuadraticPath2dTypeId] = QuadraticPath2dTypeId;
+  curves;
+  constructor(curves) {
+    super();
+    this.curves = curves;
+  }
+  [Symbol.iterator]() {
+    return this.curves[Symbol.iterator]();
+  }
+}
+const isQuadraticPath2d$1 = (p) => typeof p === "object" && p !== null && QuadraticPath2dTypeId in p;
+const fromCurves$1 = (...curves) => new QuadraticPath2dImpl(curves);
+const fromCurveArray$1 = (curves) => new QuadraticPath2dImpl(curves);
+const append$1 = dual(
+  2,
+  (p, c) => fromCurveArray$1([...p, c])
+);
+const length$1 = (p) => {
+  let length2 = 0;
+  for (const curve of p) {
+    length2 += length$2(curve, unit);
+  }
+  return round(length2);
+};
+const solve$1 = dual(2, (p, u) => {
+  const curves = p instanceof QuadraticPath2dImpl ? p.curves : [...p];
+  if (u === 1) {
+    const last = curves.at(-1);
+    return solve$2(last, 1);
+  }
+  const t = u * curves.length;
+  const i = Math.floor(t);
+  const curve = curves[i];
+  return solve$2(curve, t - i);
+});
+
+const fromCurves = fromCurves$1;
+const fromCurveArray = fromCurveArray$1;
+const isQuadraticPath2d = isQuadraticPath2d$1;
+const append = append$1;
+const length = length$1;
+const solve = solve$1;
+
+export { append, fromCurveArray, fromCurves, isQuadraticPath2d, length, solve };

package/dist/polynomial/cubic.d.mts

@@ -0,0 +1,7 @@
+import '../shared/curvy.BN-oFBsc.mjs';
+import '../interval.mjs';
+import '../vector/vector4.mjs';
+export { C as CubicPolynomial, d as derivative, g as domain, e as extrema, f as fromVector, i as isCubicPolynomial, l as length, m as make, c as monotonicity, h as range, r as roots, s as solve, a as solveInverse, b as toInverseSolver, t as toSolver } from '../shared/curvy.Bxxwly94.mjs';
+import '../shared/curvy.CT38g_II.mjs';
+import '../vector/vector2.mjs';
+import '../vector/vector3.mjs';

package/dist/polynomial/cubic.d.ts

@@ -0,0 +1,7 @@
+import '../shared/curvy.BN-oFBsc.js';
+import '../interval.js';
+import '../vector/vector4.js';
+export { C as CubicPolynomial, d as derivative, g as domain, e as extrema, f as fromVector, i as isCubicPolynomial, l as length, m as make, c as monotonicity, h as range, r as roots, s as solve, a as solveInverse, b as toInverseSolver, t as toSolver } from '../shared/curvy.CO0Wclt0.js';
+import '../shared/curvy.CT38g_II.js';
+import '../vector/vector2.js';
+import '../vector/vector3.js';

package/dist/polynomial/cubic.mjs

@@ -0,0 +1,139 @@
+import { d as dual, r as round } from '../shared/curvy.ChkqgKuv.mjs';
+import { size, filter, fromMinMax, 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 { C as CubicPolynomialImpl, a as CubicPolynomialTypeId, s as solveInverse$2, m as make$2, r as roots$2, b as monotonicity$3, g as guaranteedMonotonicityFromComparison, l as length$3, c as solve$2 } from '../shared/curvy.CLzGuqek.mjs';
+import { m as monotonicity$2, a as make$3, l as length$2 } from '../shared/curvy.DgRsieUW.mjs';
+
+const make$1 = (c0 = 0, c1 = 0, c2 = 0, c3 = 0) => new CubicPolynomialImpl(c0, c1, c2, c3);
+const isCubicPolynomial$1 = (v) => typeof v === "object" && v !== null && CubicPolynomialTypeId in v;
+const fromVector$1 = (v) => new CubicPolynomialImpl(v.x, v.y, v.z, v.w);
+const solve$1 = dual(
+  2,
+  (p, x) => round(p.c0 + x * p.c1 + x ** 2 * p.c2 + x ** 3 * p.c3)
+);
+const toSolver$1 = (p) => (x) => solve$1(p, x);
+const solveInverse$1 = dual(2, (self, y) => {
+  if (self.c3 === 0) {
+    return solveInverse$2(
+      make$2(self.c0, self.c1, self.c2),
+      0
+    );
+  }
+  const shift = self.c2 / (3 * self.c3);
+  const d0 = self.c2 ** 2 - 3 * self.c3 * self.c1;
+  const d1 = 2 * self.c2 ** 3 - 9 * self.c3 * self.c2 * self.c1 + 27 * self.c3 ** 2 * (self.c0 - y);
+  const p = -d0 / (3 * self.c3 ** 2);
+  const q = d1 / (27 * self.c3 ** 3);
+  const discriminant = round(-(4 * p ** 3 + 27 * q ** 2), 12);
+  const roots2 = /* @__PURE__ */ new Set();
+  if (discriminant > 0) {
+    const r = 2 * Math.sqrt(-p / 3);
+    const theta = Math.acos(3 * q / (2 * p) * Math.sqrt(-3 / p)) / 3;
+    const offset = 2 * Math.PI / 3;
+    roots2.add(round(r * Math.cos(theta + offset) - shift));
+    roots2.add(round(r * Math.cos(theta) - shift));
+    roots2.add(round(r * Math.cos(theta - offset) - shift));
+  } else if (discriminant < 0) {
+    const u = Math.sqrt(q ** 2 / 4 + p ** 3 / 27);
+    const u1 = Math.cbrt(-q / 2 + u);
+    const u2 = Math.cbrt(-q / 2 - u);
+    roots2.add(round(u1 + u2 - shift));
+  } else if (d0 === 0) {
+    roots2.add(round(-shift));
+  } else {
+    roots2.add(
+      round((9 * self.c3 * (self.c0 - y) - self.c2 * self.c1) / (2 * d0))
+    );
+    roots2.add(
+      round(
+        (4 * self.c3 * self.c2 * self.c1 - 9 * self.c3 ** 2 * (self.c0 - y) - self.c2 ** 3) / (self.c3 * d0)
+      )
+    );
+  }
+  return Array.from(roots2).toSorted(
+    (a, b) => a - b
+  );
+});
+const toInverseSolver$1 = (p) => (y) => solveInverse$1(p, y);
+const derivative$1 = (p) => make$2(p.c1, p.c2 * 2, p.c3 * 3);
+const roots$1 = (p) => solveInverse$1(p, 0);
+const extrema$1 = (p) => roots$2(derivative$1(p));
+const monotonicity$1 = dual(
+  (args) => isCubicPolynomial$1(args[0]),
+  (p, i) => {
+    if (p.c3 === 0 && p.c2 === 0 && p.c1 === 0) {
+      return "constant";
+    }
+    if (p.c3 === 0 && p.c2 === 0) {
+      return monotonicity$2(make$3(p.c0, p.c1));
+    }
+    if (i === void 0) {
+      return "none";
+    }
+    if (size(i) === 0) {
+      return "constant";
+    }
+    if (p.c3 === 0) {
+      return monotonicity$3(make$2(p.c0, p.c1, p.c2), i);
+    }
+    const e = filter(i, extrema$1(p), {
+      includeStart: false,
+      includeEnd: false
+    });
+    if (e.length > 0) {
+      return "none";
+    }
+    return guaranteedMonotonicityFromComparison(
+      solve$1(p, i.start),
+      solve$1(p, i.end)
+    );
+  }
+);
+const domain$1 = dual(
+  2,
+  (p, range2) => fromMinMax(
+    ...solveInverse$1(p, range2.start),
+    ...solveInverse$1(p, range2.end)
+  )
+);
+const range$1 = dual(
+  2,
+  (p, domain2) => fromMinMax(
+    solve$1(p, domain2.start),
+    solve$1(p, domain2.end),
+    ...filter(domain2, extrema$1(p)).map((e) => solve$1(p, e))
+  )
+);
+const length$1 = dual(2, (p, domain2) => {
+  if (size(domain2) === 0) {
+    return 0;
+  }
+  if (p.c3 === 0) {
+    if (p.c2 === 0) {
+      return length$2(make$3(p.c0, p.c1), domain2);
+    }
+    return length$3(make$2(p.c0, p.c1, p.c2), domain2);
+  }
+  const d = derivative$1(p);
+  const { scale, shift } = scaleShift(biunit, domain2);
+  return round(
+    (GL32_W0 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X0) ** 2) + GL32_W0 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X0) ** 2) + GL32_W1 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X1) ** 2) + GL32_W1 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X1) ** 2) + GL32_W2 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X2) ** 2) + GL32_W2 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X2) ** 2) + GL32_W3 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X3) ** 2) + GL32_W3 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X3) ** 2) + GL32_W4 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X4) ** 2) + GL32_W4 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X4) ** 2) + GL32_W5 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X5) ** 2) + GL32_W5 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X5) ** 2) + GL32_W6 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X6) ** 2) + GL32_W6 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X6) ** 2) + GL32_W7 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X7) ** 2) + GL32_W7 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X7) ** 2) + GL32_W8 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X8) ** 2) + GL32_W8 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X8) ** 2) + GL32_W9 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X9) ** 2) + GL32_W9 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X9) ** 2) + GL32_W10 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X10) ** 2) + GL32_W10 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X10) ** 2) + GL32_W11 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X11) ** 2) + GL32_W11 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X11) ** 2) + GL32_W12 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X12) ** 2) + GL32_W12 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X12) ** 2) + GL32_W13 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X13) ** 2) + GL32_W13 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X13) ** 2) + GL32_W14 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X14) ** 2) + GL32_W14 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X14) ** 2) + GL32_W15 * Math.sqrt(1 + solve$2(d, shift + scale * -GL32_X15) ** 2) + GL32_W15 * Math.sqrt(1 + solve$2(d, shift + scale * GL32_X15) ** 2)) * scale
+  );
+});
+
+const isCubicPolynomial = isCubicPolynomial$1;
+const make = make$1;
+const fromVector = fromVector$1;
+const solve = solve$1;
+const toSolver = toSolver$1;
+const solveInverse = solveInverse$1;
+const toInverseSolver = toInverseSolver$1;
+const derivative = derivative$1;
+const roots = roots$1;
+const extrema = extrema$1;
+const monotonicity = monotonicity$1;
+const domain = domain$1;
+const range = range$1;
+const length = length$1;
+
+export { derivative, domain, extrema, fromVector, isCubicPolynomial, length, make, monotonicity, range, roots, solve, solveInverse, toInverseSolver, toSolver };

package/dist/polynomial/linear.d.mts

@@ -0,0 +1,7 @@
+import '../shared/curvy.BN-oFBsc.mjs';
+import '../interval.mjs';
+import '../vector/vector2.mjs';
+export { L as LinearPolynomial, O as antiderivative, P as domain, G as fromVector, E as isLinearPolynomial, S as length, F as make, N as monotonicity, R as range, M as root, H as solve, J as solveInverse, K as toInverseSolver, I as toSolver } from '../shared/curvy.Bxxwly94.mjs';
+import '../shared/curvy.CT38g_II.mjs';
+import '../vector/vector3.mjs';
+import '../vector/vector4.mjs';

package/dist/polynomial/linear.d.ts

@@ -0,0 +1,7 @@
+import '../shared/curvy.BN-oFBsc.js';
+import '../interval.js';
+import '../vector/vector2.js';
+export { L as LinearPolynomial, O as antiderivative, P as domain, G as fromVector, E as isLinearPolynomial, S as length, F as make, N as monotonicity, R as range, M as root, H as solve, J as solveInverse, K as toInverseSolver, I as toSolver } from '../shared/curvy.CO0Wclt0.js';
+import '../shared/curvy.CT38g_II.js';
+import '../vector/vector3.js';
+import '../vector/vector4.js';

package/dist/polynomial/linear.mjs

@@ -0,0 +1,19 @@
+import { i as isLinearPolynomial$1, a as make$1, f as fromVector$1, c as solve$1, t as toSolver$1, s as solveInverse$1, d as toInverseSolver$1, m as monotonicity$1, e as antiderivative$1, g as domain$1, r as range$1, l as length$1 } from '../shared/curvy.DgRsieUW.mjs';
+import '../shared/curvy.ChkqgKuv.mjs';
+import '../interval.mjs';
+
+const isLinearPolynomial = isLinearPolynomial$1;
+const make = make$1;
+const fromVector = fromVector$1;
+const solve = solve$1;
+const toSolver = toSolver$1;
+const solveInverse = solveInverse$1;
+const toInverseSolver = toInverseSolver$1;
+const root = (p) => solveInverse$1(p, 0);
+const monotonicity = monotonicity$1;
+const antiderivative = antiderivative$1;
+const domain = domain$1;
+const range = range$1;
+const length = length$1;
+
+export { antiderivative, domain, fromVector, isLinearPolynomial, length, make, monotonicity, range, root, solve, solveInverse, toInverseSolver, toSolver };

package/dist/polynomial/quadratic.d.mts

@@ -0,0 +1,7 @@
+import '../shared/curvy.BN-oFBsc.mjs';
+import '../interval.mjs';
+import '../vector/vector3.mjs';
+export { Q as QuadraticPolynomial, z as antiderivative, v as derivative, A as domain, x as extreme, n as fromVector, j as isQuadraticPolynomial, D as length, k as make, y as monotonicity, B as range, w as roots, o as solve, q as solveInverse, u as toInverseSolver, p as toSolver } from '../shared/curvy.Bxxwly94.mjs';
+import '../shared/curvy.CT38g_II.mjs';
+import '../vector/vector2.mjs';
+import '../vector/vector4.mjs';

package/dist/polynomial/quadratic.d.ts

@@ -0,0 +1,7 @@
+import '../shared/curvy.BN-oFBsc.js';
+import '../interval.js';
+import '../vector/vector3.js';
+export { Q as QuadraticPolynomial, z as antiderivative, v as derivative, A as domain, x as extreme, n as fromVector, j as isQuadraticPolynomial, D as length, k as make, y as monotonicity, B as range, w as roots, o as solve, q as solveInverse, u as toInverseSolver, p as toSolver } from '../shared/curvy.CO0Wclt0.js';
+import '../shared/curvy.CT38g_II.js';
+import '../vector/vector2.js';
+import '../vector/vector4.js';

package/dist/polynomial/quadratic.mjs

@@ -0,0 +1,22 @@
+import { i as isQuadraticPolynomial$1, m as make$1, f as fromVector$1, c as solve$1, t as toSolver$1, s as solveInverse$1, d as toInverseSolver$1, e as derivative$1, r as roots$1, h as extreme$1, b as monotonicity$1, j as antiderivative$1, k as domain$1, n as range$1, l as length$1 } from '../shared/curvy.CLzGuqek.mjs';
+import '../shared/curvy.ChkqgKuv.mjs';
+import '../interval.mjs';
+import '../shared/curvy.DgRsieUW.mjs';
+
+const isQuadraticPolynomial = isQuadraticPolynomial$1;
+const make = make$1;
+const fromVector = fromVector$1;
+const solve = solve$1;
+const toSolver = toSolver$1;
+const solveInverse = solveInverse$1;
+const toInverseSolver = toInverseSolver$1;
+const derivative = derivative$1;
+const roots = roots$1;
+const extreme = extreme$1;
+const monotonicity = monotonicity$1;
+const antiderivative = antiderivative$1;
+const domain = domain$1;
+const range = range$1;
+const length = length$1;
+
+export { antiderivative, derivative, domain, extreme, fromVector, isQuadraticPolynomial, length, make, monotonicity, range, roots, solve, solveInverse, toInverseSolver, toSolver };

package/dist/shared/curvy.BAW_cKLu.mjs

@@ -0,0 +1,123 @@
+import { o as toThreeDimensionalIndex, d as determinant$1, m as make$1 } from './curvy.C-sUk7ux.mjs';
+import { d as dual, r as round, i as invariant, P as Pipeable } from './curvy.ChkqgKuv.mjs';
+import { c as components, m as make$2, d as dot } from './curvy.D7bhnwZy.mjs';
+
+const Matrix3x3TypeId = Symbol.for("curvy/matrix3x3");
+class Matrix3x3Impl extends Pipeable {
+  [Matrix3x3TypeId] = Matrix3x3TypeId;
+  m00;
+  m01;
+  m02;
+  m10;
+  m11;
+  m12;
+  m20;
+  m21;
+  m22;
+  constructor(m00 = 0, m01 = 0, m02 = 0, m10 = 0, m11 = 0, m12 = 0, m20 = 0, m21 = 0, m22 = 0) {
+    super();
+    this.m00 = round(m00);
+    this.m01 = round(m01);
+    this.m02 = round(m02);
+    this.m10 = round(m10);
+    this.m11 = round(m11);
+    this.m12 = round(m12);
+    this.m20 = round(m20);
+    this.m21 = round(m21);
+    this.m22 = round(m22);
+  }
+  get [Symbol.toStringTag]() {
+    return `Matrix3x3(${this.m00}, ${this.m01}, ${this.m02}, ${this.m10}, ${this.m11}, ${this.m12}, ${this.m20}, ${this.m21}, ${this.m22})`;
+  }
+  get [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `Matrix3x3(${this.m00}, ${this.m01}, ${this.m02}, ${this.m10}, ${this.m11}, ${this.m12}, ${this.m20}, ${this.m21}, ${this.m22})`;
+  }
+  [Symbol.hasInstance](m) {
+    return isMatrix3x3(m);
+  }
+}
+const isMatrix3x3 = (m) => typeof m === "object" && m !== null && Matrix3x3TypeId in m;
+const make = (m00 = 0, m01 = m00, m02 = m01, m10 = m02, m11 = m10, m12 = m11, m20 = m12, m21 = m20, m22 = m21) => {
+  return new Matrix3x3Impl(m00, m01, m02, m10, m11, m12, m20, m21, m22);
+};
+const fromRows = (v0, v1, v2) => new Matrix3x3Impl(v0.x, v0.y, v0.z, v1.x, v1.y, v1.z, v2.x, v2.y, v2.z);
+const fromColumns = (v0, v1, v2) => new Matrix3x3Impl(v0.x, v1.x, v2.x, v0.y, v1.y, v2.y, v0.z, v1.z, v2.z);
+const setRow = dual(
+  3,
+  (m, row, v) => fromRows(
+    ...toRows(m).with(toThreeDimensionalIndex(row), v)
+  )
+);
+const setColumn = dual(
+  3,
+  (m, column, v) => fromColumns(
+    ...toColumns(m).with(toThreeDimensionalIndex(column), v)
+  )
+);
+const determinant = (m) => round(
+  m.m00 * determinant$1(minor(m, 0, 0)) - m.m01 * determinant$1(minor(m, 0, 1)) + m.m02 * determinant$1(minor(m, 0, 2))
+);
+const minor = dual(3, (m, row, column) => {
+  const [v0, v1] = toRows(m).toSpliced(toThreeDimensionalIndex(row), 1);
+  const columnIndex = toThreeDimensionalIndex(column);
+  const [m00, m01] = components(v0).toSpliced(columnIndex, 1);
+  const [m10, m11] = components(v1).toSpliced(columnIndex, 1);
+  return make$1(m00, m01, m10, m11);
+});
+const vectorProductLeft = dual(2, (m, v) => {
+  const [v0, v1, v2] = toRows(m);
+  return make$2(
+    dot(v0, v),
+    dot(v1, v),
+    dot(v2, v)
+  );
+});
+const vectorProductRight = dual(2, (m, v) => {
+  const [v0, v1, v2] = toColumns(m);
+  return make$2(
+    dot(v, v0),
+    dot(v, v1),
+    dot(v, v2)
+  );
+});
+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$2(
+    determinant(setColumn(m, 0, v)) * inverseDeterminant,
+    determinant(setColumn(m, 1, v)) * inverseDeterminant,
+    determinant(setColumn(m, 2, v)) * inverseDeterminant
+  );
+});
+const toRows = (m) => [
+  make$2(m.m00, m.m01, m.m02),
+  make$2(m.m10, m.m11, m.m12),
+  make$2(m.m20, m.m21, m.m22)
+];
+const toColumns = (m) => [
+  make$2(m.m00, m.m10, m.m20),
+  make$2(m.m01, m.m11, m.m21),
+  make$2(m.m02, m.m12, m.m22)
+];
+const rowVector = dual(
+  2,
+  (m, row) => toRows(m)[toThreeDimensionalIndex(row)]
+);
+const columnVector = dual(
+  2,
+  (m, column) => toColumns(m)[toThreeDimensionalIndex(column)]
+);
+const transpose = (m) => fromColumns(...toRows(m));
+const reverseRows = (m) => {
+  const [v0, v1, v2] = toRows(m);
+  return fromRows(v2, v1, v0);
+};
+const reverseColumns = (m) => {
+  const [v0, v1, v2] = toColumns(m);
+  return fromColumns(v2, v1, v0);
+};
+
+export { fromColumns as a, setColumn as b, minor as c, determinant as d, vectorProductRight as e, fromRows as f, solveSystem as g, toColumns as h, isMatrix3x3 as i, columnVector as j, transpose as k, reverseRows as l, make as m, reverseColumns as n, rowVector as r, setRow as s, toRows as t, vectorProductLeft as v };