curvy 1.0.8 → 2.0.0-alpha.0

package/dist/shared/curvy.CE4X6_Is.mjs

@@ -1,181 +0,0 @@
-import { vectorProductLeft, make as make$3, solveSystem } from '../matrix/matrix4x4.mjs';
-import { fromCurves } from '../path/cubic2d.mjs';
-import { dual, Pipeable } from '../pipe.mjs';
-import { invariant } from '../utils.mjs';
-import { make as make$4 } from '../vector/vector2.mjs';
-import { make as make$2 } from '../vector/vector4.mjs';
-import { fromPolynomials } from '../curve/cubic2d.mjs';
-import { fromVector } from '../polynomial/cubic.mjs';
-
-function* toPointQuads(points, stride) {
-  let p0;
-  let p1;
-  let p2;
-  let p3;
-  for (const point of points) {
-    if (p0 === void 0) {
-      p0 = point;
-      continue;
-    }
-    if (p1 === void 0) {
-      p1 = point;
-      continue;
-    }
-    if (p2 === void 0) {
-      p2 = point;
-      continue;
-    }
-    p3 = point;
-    yield [p0, p1, p2, p3];
-    if (stride === 1) {
-      p0 = p1;
-      p1 = p2;
-      p2 = p3;
-    } else if (stride === 2) {
-      p0 = p2;
-      p1 = p3;
-      p2 = void 0;
-    } else if (stride === 3) {
-      p0 = p3;
-      p1 = void 0;
-      p2 = void 0;
-    }
-  }
-}
-function* toCurves(points, matrix, stride) {
-  for (const [p0, p1, p2, p3] of toPointQuads(points, stride)) {
-    yield fromPolynomials(
-      fromVector(
-        vectorProductLeft(
-          matrix,
-          make$2(p0.x, p1.x, p2.x, p3.x)
-        )
-      ),
-      fromVector(
-        vectorProductLeft(
-          matrix,
-          make$2(p0.y, p1.y, p2.y, p3.y)
-        )
-      )
-    );
-  }
-}
-
-const characteristic$1 = make$3(
-  1,
-  0,
-  0,
-  0,
-  -3,
-  3,
-  0,
-  0,
-  3,
-  -6,
-  3,
-  0,
-  -1,
-  3,
-  -3,
-  1
-);
-const Bezier2dTypeId = Symbol("curvy/splines/bezier2d");
-class Bezier2dImpl extends Pipeable {
-  [Bezier2dTypeId] = Bezier2dTypeId;
-  points;
-  constructor(points) {
-    invariant(points.length >= 4, "cubic splines requires 4 or more points");
-    invariant(
-      points.length % 3 === 1,
-      "cubic splines requires (n * 3) + 1 points"
-    );
-    super();
-    this.points = points;
-  }
-  [Symbol.iterator]() {
-    return this.points[Symbol.iterator]();
-  }
-}
-const isCubicBezier2d$1 = (p) => typeof p === "object" && p !== null && Bezier2dTypeId in p;
-const make$1 = (p0, p1, p2, p3) => new Bezier2dImpl([p0, p1, p2, p3]);
-const fromArray$1 = (points) => new Bezier2dImpl(points);
-const append$1 = dual(
-  4,
-  (p, p1, p2, p3) => new Bezier2dImpl(
-    (p instanceof Bezier2dImpl ? p.points : Array.from(p)).concat(p1, p2, p3)
-  )
-);
-const fromSpline$1 = (p, matrix, stride) => {
-  const points = [];
-  let x;
-  let y;
-  for (const [p0, p1, p2, p3] of toPointQuads(p, stride)) {
-    x = solveSystem(
-      characteristic$1,
-      vectorProductLeft(matrix, make$2(p0.x, p1.x, p2.x, p3.x))
-    );
-    y = solveSystem(
-      characteristic$1,
-      vectorProductLeft(matrix, make$2(p0.y, p1.y, p2.y, p3.y))
-    );
-    points.push(
-      make$4(x.x, y.x),
-      make$4(x.y, y.y),
-      make$4(x.z, y.z)
-    );
-  }
-  if (x && y) {
-    points.push(make$4(x.w, y.w));
-  }
-  return fromArray$1(points);
-};
-const appendTangentAligned$1 = dual(4, (p, a, p5, p6) => {
-  const points = p instanceof Bezier2dImpl ? p.points : Array.from(p);
-  const p2 = points[points.length - 2];
-  const p3 = points[points.length - 1];
-  const p4 = make$4(p3.x + (p3.x - p2.x) * a, p3.y + (p3.y - p2.y) * a);
-  return append$1(p, p4, p5, p6);
-});
-const appendCurvatureAligned = dual(
-  4,
-  (p, a, b, p6) => {
-    const points = p instanceof Bezier2dImpl ? p.points : Array.from(p);
-    const p1 = points[points.length - 3];
-    const p2 = points[points.length - 2];
-    const p3 = points[points.length - 1];
-    const p4 = make$4(p3.x + (p3.x - p2.x) * a, p3.y + (p3.y - p2.y) * a);
-    const p5 = make$4(
-      p3.x + (p3.x - p2.x) * (2 * a + a ** 2 + b / 2) + (p1.x - p2.x) * a ** 2,
-      p3.y + (p3.y - p2.y) * (2 * a + a ** 2 + b / 2) + (p1.y - p2.y) * a ** 2
-    );
-    return append$1(p, p4, p5, p6);
-  }
-);
-const appendVelocityAligned$1 = dual(
-  3,
-  (p, p5, p6) => appendTangentAligned$1(p, 1, p5, p6)
-);
-const appendAccelerationAligned$1 = dual(2, (p, p6) => {
-  const points = p instanceof Bezier2dImpl ? p.points : Array.from(p);
-  const p1 = points[points.length - 3];
-  const p2 = points[points.length - 2];
-  const p3 = points[points.length - 1];
-  const p4 = make$4(2 * p3.x - p2.x, 2 * p3.y - p2.y);
-  const p5 = make$4(p1.x + 4 * (p3.x - p2.x), p1.y + 4 * (p3.y - p2.y));
-  return append$1(p, p4, p5, p6);
-});
-const toPath$1 = (p) => fromCurves(...toCurves(p, characteristic$1, 3));
-
-const characteristic = characteristic$1;
-const make = make$1;
-const fromArray = fromArray$1;
-const fromSpline = fromSpline$1;
-const isCubicBezier2d = isCubicBezier2d$1;
-const append = append$1;
-const appendTangentAligned = appendTangentAligned$1;
-const appendCurvatureMirrored = appendCurvatureAligned;
-const appendVelocityAligned = appendVelocityAligned$1;
-const appendAccelerationAligned = appendAccelerationAligned$1;
-const toPath = toPath$1;
-
-export { fromArray as a, append as b, characteristic as c, appendTangentAligned as d, appendCurvatureMirrored as e, fromSpline as f, appendVelocityAligned as g, appendAccelerationAligned as h, isCubicBezier2d as i, toPath as j, make as m, toCurves as t };

package/dist/shared/curvy.Cps2R_RU.mjs

@@ -1,120 +0,0 @@
-import { invariant, round } from '../utils.mjs';
-import { dual, Pipeable } from '../pipe.mjs';
-import { m as make$1, d as dot } from './curvy.BZ_mTkJe.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.Cv-wIzDr.mjs

@@ -1,124 +0,0 @@
-import { o as toThreeDimensionalIndex, d as determinant$1, m as make$1 } from './curvy.Cps2R_RU.mjs';
-import { dual, Pipeable } from '../pipe.mjs';
-import { round, invariant } from '../utils.mjs';
-import { b as components, m as make$2, d as dot } from './curvy.wYJQhFW-.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 };

package/dist/shared/curvy.DmVFTi0N.mjs

@@ -1,34 +0,0 @@
-const GL32_X0 = 0.9972638618494816;
-const GL32_X1 = 0.9856115115452684;
-const GL32_X2 = 0.9647622555875064;
-const GL32_X3 = 0.9349060759377397;
-const GL32_X4 = 0.8963211557660521;
-const GL32_X5 = 0.84936761373257;
-const GL32_X6 = 0.7944837959679424;
-const GL32_X7 = 0.7321821187402897;
-const GL32_X8 = 0.6630442669302152;
-const GL32_X9 = 0.5877157572407623;
-const GL32_X10 = 0.5068999089322294;
-const GL32_X11 = 0.42135127613063533;
-const GL32_X12 = 0.33186860228212767;
-const GL32_X13 = 0.23928736225213706;
-const GL32_X14 = 0.1444719615827965;
-const GL32_X15 = 0.04830766568773831;
-const GL32_W0 = 0.007018610009470136;
-const GL32_W1 = 0.01627439473090571;
-const GL32_W2 = 0.02539206530926214;
-const GL32_W3 = 0.03427386291302141;
-const GL32_W4 = 0.042835898022226704;
-const GL32_W5 = 0.050998059262376154;
-const GL32_W6 = 0.05868409347853558;
-const GL32_W7 = 0.06582222277636195;
-const GL32_W8 = 0.07234579410884862;
-const GL32_W9 = 0.07819389578707044;
-const GL32_W10 = 0.08331192422694672;
-const GL32_W11 = 0.08765209300440374;
-const GL32_W12 = 0.0911738786957639;
-const GL32_W13 = 0.09384439908080454;
-const GL32_W14 = 0.09563872007927485;
-const GL32_W15 = 0.09654008851472785;
-
-export { GL32_X13 as A, GL32_W14 as B, GL32_X14 as C, GL32_W15 as D, GL32_X15 as E, GL32_W0 as G, GL32_X0 as a, GL32_W1 as b, GL32_X1 as c, GL32_W2 as d, GL32_X2 as e, GL32_W3 as f, GL32_X3 as g, GL32_W4 as h, GL32_X4 as i, GL32_W5 as j, GL32_X5 as k, GL32_W6 as l, GL32_X6 as m, GL32_W7 as n, GL32_X7 as o, GL32_W8 as p, GL32_X8 as q, GL32_W9 as r, GL32_X9 as s, GL32_W10 as t, GL32_X10 as u, GL32_W11 as v, GL32_X11 as w, GL32_W12 as x, GL32_X12 as y, GL32_W13 as z };

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

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

package/dist/shared/curvy.wYJQhFW-.mjs

@@ -1,87 +0,0 @@
-import { dual, Pipeable } from '../pipe.mjs';
-import { round } from '../utils.mjs';
-
-const Vector3TypeId = Symbol.for("curvy/vector3");
-class Vector3Impl extends Pipeable {
-  [Vector3TypeId] = Vector3TypeId;
-  x;
-  y;
-  z;
-  constructor(v0 = 0, v1 = 0, v2 = 0) {
-    super();
-    this.x = round(v0);
-    this.y = round(v1);
-    this.z = round(v2);
-  }
-  get [0]() {
-    return this.x;
-  }
-  get [1]() {
-    return this.y;
-  }
-  get [2]() {
-    return this.z;
-  }
-  get [Symbol.toStringTag]() {
-    return `Vector3(${this.x}, ${this.y}, ${this.z})`;
-  }
-  get [Symbol.for("nodejs.util.inspect.custom")]() {
-    return this[Symbol.toStringTag];
-  }
-}
-const isVector3 = (v) => typeof v === "object" && v !== null && Vector3TypeId in v;
-const make = (v0, v1 = v0, v2 = v1) => new Vector3Impl(v0, v1, v2);
-const fromSpherical = (r, theta, phi) => make(
-  r * Math.sin(phi) * Math.cos(theta),
-  r * Math.sin(phi) * Math.sin(theta),
-  r * Math.cos(phi)
-);
-const magnitude = (vector) => round(Math.hypot(vector.x, vector.y, vector.z));
-const normalize = (vector) => {
-  const m = magnitude(vector);
-  return make(vector.x / m, vector.y / m, vector.z / m);
-};
-const dot = dual(2, (a, b) => round(a.x * b.x + a.y * b.y + a.z * b.z));
-const cross = dual(2, (a, b) => {
-  const x = a.y * b.z - a.z * b.y;
-  const y = a.z * b.x - a.x * b.z;
-  const z = a.x * b.y - a.y * b.x;
-  return make(x, y, z);
-});
-const components = (v) => [v.x, v.y, v.z];
-const softmax = (v) => {
-  const max = Math.max(v.x, v.y, v.z);
-  const v0 = Math.exp(v.x - max);
-  const v1 = Math.exp(v.y - max);
-  const v2 = Math.exp(v.z - max);
-  const sum = v0 + v1 + v2;
-  return make(v0 / sum, v1 / sum, v2 / sum);
-};
-const add = dual(2, (a, b) => make(a.x + b.x, a.y + b.y, a.z + b.z));
-const subtract = dual(2, (a, b) => make(a.x - b.x, a.y - b.y, a.z - b.z));
-const hadamard = dual(2, (a, b) => make(a.x * b.x, a.y * b.y, a.z * b.z));
-const scale = dual(2, (v, s) => s === 1 ? v : make(v.x * s, v.y * s, v.z * s));
-const getX = (v) => v.x;
-const setX = dual(2, (v, x) => make(x, v.y, v.z));
-const getY = (v) => v.y;
-const setY = dual(2, (v, y) => make(v.x, y, v.z));
-const getZ = (v) => v.z;
-const setZ = dual(2, (v, z) => make(v.x, v.y, z));
-const setR = dual(2, (v, r) => scale(r / magnitude(v))(v));
-const getTheta = (v) => Math.acos(v.z / magnitude(v));
-const setTheta = dual(2, (v, phi) => {
-  const m = magnitude(v);
-  const sinTheta = Math.sin(phi);
-  return make(
-    m * sinTheta * Math.cos(v.y),
-    m * sinTheta * Math.sin(v.y),
-    m * Math.cos(phi)
-  );
-});
-const getPhi = (v) => round(Math.atan2(v.y, v.x));
-const setPhi = dual(2, (v, theta) => {
-  const m = magnitude(v);
-  return make(m * Math.cos(theta), m * Math.sin(theta), v.z);
-});
-
-export { magnitude as a, components as b, cross as c, dot as d, add as e, fromSpherical as f, subtract as g, hadamard as h, isVector3 as i, scale as j, getX as k, setX as l, make as m, normalize as n, getY as o, setY as p, getZ as q, setZ as r, softmax as s, setR as t, getTheta as u, setTheta as v, getPhi as w, setPhi as x };