curvy 0.3.3 → 1.0.1

package/dist/shared/curvy.DB7nQmVs.mjs

@@ -0,0 +1,79 @@
+import { P as Pipeable, r as round, d as dual } from './curvy.ChkqgKuv.mjs';
+import { make as make$1, size } from '../interval.mjs';
+
+const QuadraticPolynomialTypeId = Symbol.for(
+  "curvy/polynomial/quadratic"
+);
+class QuadraticPolynomialImpl extends Pipeable {
+  [QuadraticPolynomialTypeId] = QuadraticPolynomialTypeId;
+  c0;
+  c1;
+  c2;
+  constructor(c0 = 0, c1 = 0, c2 = 0) {
+    super();
+    this.c0 = round(c0);
+    this.c1 = round(c1);
+    this.c2 = round(c2);
+  }
+}
+
+const LinearPolynomialTypeId = Symbol.for("curvy/linear");
+class LinearPolynomialImpl extends Pipeable {
+  [LinearPolynomialTypeId] = LinearPolynomialTypeId;
+  c0;
+  c1;
+  constructor(c0 = 0, c1 = 0) {
+    super();
+    this.c0 = round(c0);
+    this.c1 = round(c1);
+  }
+}
+const isLinearPolynomial = (v) => typeof v === "object" && v !== null && LinearPolynomialTypeId in v;
+const make = (c0 = 0, c1 = 0) => new LinearPolynomialImpl(c0, c1);
+const fromVector = (v) => new LinearPolynomialImpl(v.x, v.y);
+const fromPointSlope = (p, slope) => new LinearPolynomialImpl(p.y - slope * p.x, slope);
+const fromPoints = (p1, p2) => fromPointSlope(p1, (p2.y - p1.y) / (p2.x - p1.x));
+const solve = dual(2, (p, x) => round(p.c0 + x * p.c1));
+const toSolver = (p) => (x) => solve(p, x);
+const solveInverse = dual(2, (p, y) => {
+  if (p.c1 === 0) {
+    return null;
+  }
+  return round((y - p.c0) / p.c1);
+});
+const toInverseSolver = (p) => (y) => solveInverse(p, y);
+const monotonicity = (p) => p.c1 === 0 ? "constant" : p.c1 > 0 ? "increasing" : "decreasing";
+const derivative = (p) => p.c1;
+const antiderivative = dual(
+  (args) => isLinearPolynomial(args[0]),
+  (p, integrationConstant = 0) => new QuadraticPolynomialImpl(integrationConstant, p.c0, p.c1 / 2)
+);
+const domain = dual(2, (p, range2) => {
+  if (p.c1 === 0) {
+    if (range2.start === p.c0 && range2.end === p.c0) {
+      return make$1(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY);
+    }
+    return null;
+  }
+  const start = solveInverse(p, range2.start);
+  const end = solveInverse(p, range2.end);
+  if (start === null || end === null) {
+    return null;
+  }
+  return make$1(start, end);
+});
+const range = dual(
+  2,
+  (p, domain2) => make$1(solve(p, domain2.start), solve(p, domain2.end))
+);
+const length = dual(2, (p, domain2) => {
+  if (size(domain2) === 0) {
+    return 0;
+  }
+  if (p.c1 === 0) {
+    return round(size(domain2));
+  }
+  return round(Math.sqrt(1 + p.c1 ** 2) * size(domain2));
+});
+
+export { QuadraticPolynomialImpl as Q, make as a, QuadraticPolynomialTypeId as b, solveInverse as c, fromPointSlope as d, fromPoints as e, fromVector as f, toInverseSolver as g, derivative as h, isLinearPolynomial as i, antiderivative as j, domain as k, length as l, monotonicity as m, range as r, solve as s, toSolver as t };

package/dist/shared/curvy.DM6AiKbn.mjs

@@ -0,0 +1,119 @@
+import { i as invariant, d as dual, r as round, P as Pipeable } from './curvy.ChkqgKuv.mjs';
+import { m as make$1, d as dot } from './curvy.DOSsf40r.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.DOSsf40r.mjs

@@ -0,0 +1,49 @@
+import { d as dual, a as PRECISION, r as round, P as Pipeable } from './curvy.ChkqgKuv.mjs';
+
+const Vector2TypeId = Symbol.for("curvy/vector2");
+class Vector2Impl extends Pipeable {
+  [Vector2TypeId] = Vector2TypeId;
+  x;
+  y;
+  precision;
+  constructor(v0 = 0, v1 = 0, precision = PRECISION) {
+    super();
+    this.x = round(v0, precision);
+    this.y = round(v1, precision);
+    this.precision = precision;
+  }
+  get [0]() {
+    return this.x;
+  }
+  get [1]() {
+    return this.y;
+  }
+  get [Symbol.toStringTag]() {
+    return `Vector2(${this.x}, ${this.y})`;
+  }
+  get [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this[Symbol.toStringTag];
+  }
+}
+const isVector2 = (v) => typeof v === "object" && v !== null && Vector2TypeId in v;
+const make = (v0, v1 = v0, precision = PRECISION) => new Vector2Impl(v0, v1, precision);
+const components = (v) => [v.x, v.y];
+const magnitude = (vector) => round(Math.hypot(vector.x, vector.y));
+const normalize = (vector) => {
+  const m = magnitude(vector);
+  return make(vector.x / m, vector.y / m);
+};
+const dot = dual(2, (a, b) => round(a.x * b.x + a.y * b.y));
+const cross = dual(2, (a, b) => round(a.x * b.y - a.y * b.x));
+const softmax = (v) => {
+  const max = Math.max(v.x, v.y);
+  const v0 = Math.exp(v.x - max);
+  const v1 = Math.exp(v.y - max);
+  const sum = v0 + v1;
+  return make(v0 / sum, v1 / sum);
+};
+const add = dual(2, (a, b) => make(a.x + b.x, a.y + b.y));
+const subtract = dual(2, (a, b) => make(a.x - b.x, a.y - b.y));
+const hadamard = dual(2, (a, b) => make(a.x * b.x, a.y * b.y));
+
+export { magnitude as a, components as b, cross as c, dot as d, add as e, subtract as f, hadamard as h, isVector2 as i, make as m, normalize as n, softmax as s };

package/dist/shared/curvy.DmVFTi0N.mjs

@@ -0,0 +1,34 @@
+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.DwHW5Fqt.d.mts

@@ -0,0 +1,155 @@
+import { P as Pipeable } from './curvy.BN-oFBsc.mjs';
+import { Interval } from '../interval.mjs';
+import { Vector2 } from '../vector/vector2.mjs';
+import { Vector3 } from '../vector/vector3.mjs';
+import { Vector4 } from '../vector/vector4.mjs';
+
+declare const CubicPolynomialTypeId: unique symbol;
+type CubicPolynomialTypeId = typeof CubicPolynomialTypeId;
+
+type Monotonicity = 'none' | 'increasing' | 'decreasing' | 'constant';
+type GuaranteedMonotonicity = 'increasing' | 'decreasing' | 'constant';
+
+type ZeroOrOneSolution = number | null;
+type ZeroOrOneInterval = Interval | null;
+type ZeroToTwoSolutions = readonly [] | readonly [number] | readonly [number, number];
+type ZeroToThreeSolutions = readonly [] | readonly [number] | readonly [number, number] | readonly [number, number, number];
+
+interface CubicPolynomial extends Pipeable {
+    readonly [CubicPolynomialTypeId]: CubicPolynomialTypeId;
+    readonly c0: number;
+    readonly c1: number;
+    readonly c2: number;
+    readonly c3: number;
+}
+declare const isCubicPolynomial: (value: unknown) => value is CubicPolynomial;
+declare const make$2: (c0: number, c1: number, c2: number, c3: number) => CubicPolynomial;
+declare const fromVector$2: (v: Vector4) => CubicPolynomial;
+declare const solve$2: {
+    (p: CubicPolynomial, x: number): number;
+    (x: number): (p: CubicPolynomial) => number;
+};
+declare const toSolver$2: (p: CubicPolynomial) => (x: number) => number;
+declare const solveInverse$2: {
+    (p: CubicPolynomial, y: number): ZeroToThreeSolutions;
+    (y: number): (p: CubicPolynomial) => ZeroToThreeSolutions;
+};
+declare const toInverseSolver$2: (p: CubicPolynomial) => (y: number) => ZeroToThreeSolutions;
+declare const derivative$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.bvP77ZZm.mjs

@@ -0,0 +1,123 @@
+import { o as toThreeDimensionalIndex, d as determinant$1, m as make$1 } from './curvy.DM6AiKbn.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 };

package/dist/splines/bezier2d.d.mts

@@ -0,0 +1,43 @@
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+import { CubicPath2d } from '../path/cubic2d.mjs';
+import { Vector2 } from '../vector/vector2.mjs';
+import '../curve/cubic2d.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 Bezier2dTypeId: unique symbol;
+type Bezier2dTypeId = typeof Bezier2dTypeId;
+
+interface Bezier2d extends Pipeable {
+    readonly [Bezier2dTypeId]: Bezier2dTypeId;
+    [Symbol.iterator](): IterableIterator<Vector2>;
+}
+declare const make: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => Bezier2d;
+declare const fromArray: (points: ReadonlyArray<Vector2>) => Bezier2d;
+declare const isCubicBezier2d: (p: unknown) => p is Bezier2d;
+declare const append: {
+    (p1: Vector2, p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, p1: Vector2, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendTangentAligned: {
+    (ratio: number, p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, ratio: number, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendCurvatureMirrored: {
+    (a: number, b: number, p6: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, a: number, b: number, p6: Vector2): Bezier2d;
+};
+declare const appendVelocityAligned: {
+    (p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendAccelerationAligned: {
+    (p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, p3: Vector2): Bezier2d;
+};
+declare const toPath: (p: Bezier2d) => CubicPath2d;
+
+export { type Bezier2d, append, appendAccelerationAligned, appendCurvatureMirrored, appendTangentAligned, appendVelocityAligned, fromArray, isCubicBezier2d, make, toPath };

package/dist/splines/bezier2d.d.ts

@@ -0,0 +1,43 @@
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+import { CubicPath2d } from '../path/cubic2d.js';
+import { Vector2 } from '../vector/vector2.js';
+import '../curve/cubic2d.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 Bezier2dTypeId: unique symbol;
+type Bezier2dTypeId = typeof Bezier2dTypeId;
+
+interface Bezier2d extends Pipeable {
+    readonly [Bezier2dTypeId]: Bezier2dTypeId;
+    [Symbol.iterator](): IterableIterator<Vector2>;
+}
+declare const make: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => Bezier2d;
+declare const fromArray: (points: ReadonlyArray<Vector2>) => Bezier2d;
+declare const isCubicBezier2d: (p: unknown) => p is Bezier2d;
+declare const append: {
+    (p1: Vector2, p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, p1: Vector2, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendTangentAligned: {
+    (ratio: number, p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, ratio: number, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendCurvatureMirrored: {
+    (a: number, b: number, p6: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, a: number, b: number, p6: Vector2): Bezier2d;
+};
+declare const appendVelocityAligned: {
+    (p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendAccelerationAligned: {
+    (p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, p3: Vector2): Bezier2d;
+};
+declare const toPath: (p: Bezier2d) => CubicPath2d;
+
+export { type Bezier2d, append, appendAccelerationAligned, appendCurvatureMirrored, appendTangentAligned, appendVelocityAligned, fromArray, isCubicBezier2d, make, toPath };