curvy 0.3.3 → 1.0.1

package/dist/path/cubic2d.d.ts

@@ -0,0 +1,29 @@
+import { CubicCurve2d } from '../curve/cubic2d.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.CkJRVnqj.js';
+import '../vector/vector3.js';
+import '../vector/vector4.js';
+
+declare const CubicPath2dTypeId: unique symbol;
+type CubicPath2dTypeId = typeof CubicPath2dTypeId;
+
+interface CubicPath2d extends Pipeable, Iterable<CubicCurve2d> {
+    readonly [CubicPath2dTypeId]: CubicPath2dTypeId;
+}
+declare const fromCurves: (...curves: ReadonlyArray<CubicCurve2d>) => CubicPath2d;
+declare const fromCurveArray: (curves: ReadonlyArray<CubicCurve2d>) => CubicPath2d;
+declare const isCubicPath2d: (p: unknown) => p is CubicPath2d;
+declare const append: {
+    (c: CubicCurve2d): (p: CubicPath2d) => CubicPath2d;
+    (p: CubicPath2d, c: CubicCurve2d): CubicPath2d;
+};
+declare const length: (p: CubicPath2d) => number;
+declare const solve: {
+    (u: number): (p: CubicPath2d) => Vector2;
+    (p: CubicPath2d, u: number): Vector2;
+};
+
+export { type CubicPath2d, append, fromCurveArray, fromCurves, isCubicPath2d, length, solve };

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.D7MEXd5g.mjs';
+import '../shared/curvy.DB7nQmVs.mjs';
+import '../polynomial/quadratic.mjs';
+import '../vector/vector2.mjs';
+import '../shared/curvy.DOSsf40r.mjs';
+import '../curve/linear2d.mjs';
+import '../polynomial/linear.mjs';
+import '../curve/quadratic2d.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.DwHW5Fqt.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.CkJRVnqj.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.DB7nQmVs.mjs';
+import '../vector/vector2.mjs';
+import '../shared/curvy.DOSsf40r.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,30 @@
+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.DwHW5Fqt.mjs';
+import '../vector/vector3.mjs';
+import '../vector/vector4.mjs';
+import '../curve/linear2d.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,30 @@
+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.CkJRVnqj.js';
+import '../vector/vector3.js';
+import '../vector/vector4.js';
+import '../curve/linear2d.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.DB7nQmVs.mjs';
+import '../polynomial/quadratic.mjs';
+import '../shared/curvy.D7MEXd5g.mjs';
+import '../vector/vector2.mjs';
+import '../shared/curvy.DOSsf40r.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, j as curvature, 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.DwHW5Fqt.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, j as curvature, 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.CkJRVnqj.js';
+import '../shared/curvy.CT38g_II.js';
+import '../vector/vector2.js';
+import '../vector/vector3.js';

package/dist/polynomial/cubic.mjs

@@ -0,0 +1,147 @@
+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, d as derivative$2 } from '../shared/curvy.D7MEXd5g.mjs';
+import { m as monotonicity$2, a as make$3, l as length$2, s as solve$3 } from '../shared/curvy.DB7nQmVs.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 curvature$1 = dual(2, (p, x) => {
+  const d = derivative$1(p);
+  const dd = derivative$2(d);
+  return round(
+    Math.abs(solve$3(dd, x)) / (1 + solve$2(d, x) ** 2) ** 1.5
+  );
+});
+
+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;
+const curvature = curvature$1;
+
+export { curvature, 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, U as antiderivative, T as derivative, V as domain, J as fromPointSlope, K as fromPoints, I as fromVector, G as isLinearPolynomial, X as length, H as make, S as monotonicity, W as range, R as root, M as solve, O as solveInverse, P as toInverseSolver, N as toSolver } from '../shared/curvy.DwHW5Fqt.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, U as antiderivative, T as derivative, V as domain, J as fromPointSlope, K as fromPoints, I as fromVector, G as isLinearPolynomial, X as length, H as make, S as monotonicity, W as range, R as root, M as solve, O as solveInverse, P as toInverseSolver, N as toSolver } from '../shared/curvy.CkJRVnqj.js';
+import '../shared/curvy.CT38g_II.js';
+import '../vector/vector3.js';
+import '../vector/vector4.js';

package/dist/polynomial/linear.mjs

@@ -0,0 +1,22 @@
+import { i as isLinearPolynomial$1, a as make$1, f as fromVector$1, d as fromPointSlope$1, e as fromPoints$1, s as solve$1, t as toSolver$1, c as solveInverse$1, g as toInverseSolver$1, m as monotonicity$1, h as derivative$1, j as antiderivative$1, k as domain$1, r as range$1, l as length$1 } from '../shared/curvy.DB7nQmVs.mjs';
+import '../shared/curvy.ChkqgKuv.mjs';
+import '../interval.mjs';
+
+const isLinearPolynomial = isLinearPolynomial$1;
+const make = make$1;
+const fromVector = fromVector$1;
+const fromPointSlope = fromPointSlope$1;
+const fromPoints = fromPoints$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 derivative = derivative$1;
+const antiderivative = antiderivative$1;
+const domain = domain$1;
+const range = range$1;
+const length = length$1;
+
+export { antiderivative, derivative, domain, fromPointSlope, fromPoints, 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, A as antiderivative, F as curvature, w as derivative, B as domain, y as extreme, o as fromVector, k as isQuadraticPolynomial, E as length, n as make, z as monotonicity, D as range, x as roots, p as solve, u as solveInverse, v as toInverseSolver, q as toSolver } from '../shared/curvy.DwHW5Fqt.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, A as antiderivative, F as curvature, w as derivative, B as domain, y as extreme, o as fromVector, k as isQuadraticPolynomial, E as length, n as make, z as monotonicity, D as range, x as roots, p as solve, u as solveInverse, v as toInverseSolver, q as toSolver } from '../shared/curvy.CkJRVnqj.js';
+import '../shared/curvy.CT38g_II.js';
+import '../vector/vector2.js';
+import '../vector/vector4.js';

package/dist/polynomial/quadratic.mjs

@@ -0,0 +1,23 @@
+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, e as toInverseSolver$1, d 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, o as curvature$1 } from '../shared/curvy.D7MEXd5g.mjs';
+import '../shared/curvy.ChkqgKuv.mjs';
+import '../interval.mjs';
+import '../shared/curvy.DB7nQmVs.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;
+const curvature = curvature$1;
+
+export { antiderivative, curvature, derivative, domain, extreme, fromVector, isQuadraticPolynomial, length, make, monotonicity, range, roots, solve, solveInverse, toInverseSolver, toSolver };

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