curvy 0.3.3 → 1.0.0

package/dist/shared/curvy.ChkqgKuv.mjs

@@ -0,0 +1,119 @@
+const dual = (arity, body) => {
+  if (typeof arity === "function") {
+    return function(...args) {
+      if (arity(args)) {
+        return body.apply(this, args);
+      }
+      return (self) => body(self, ...args);
+    };
+  }
+  switch (arity) {
+    case 0:
+    case 1:
+      throw new RangeError(`Invalid arity ${arity}`);
+    case 2:
+      return (...args) => {
+        const [a, b] = args;
+        if (args.length >= 2) {
+          return body(a, b);
+        }
+        return (self) => body(self, a);
+      };
+    case 3:
+      return (...args) => {
+        const [a, b, c] = args;
+        if (args.length >= 3) {
+          return body(a, b, c);
+        }
+        return (self) => body(self, a, b);
+      };
+    case 4:
+      return (...args) => {
+        const [a, b, c, d] = args;
+        if (args.length >= 4) {
+          return body(a, b, c, d);
+        }
+        return (self) => body(self, a, b, c);
+      };
+    case 5:
+      return (...args) => {
+        const [a, b, c, d, e] = args;
+        if (args.length >= 5) {
+          return body(a, b, c, d, e);
+        }
+        return (self) => body(self, a, b, c, d);
+      };
+    default:
+      return function(...args) {
+        if (args.length >= arity) {
+          return body.apply(this, args);
+        }
+        return (self) => body(self, ...args);
+      };
+  }
+};
+function pipe(...args) {
+  const [a, ab, bc, cd, de, ef, fg, gh, hi] = args;
+  switch (args.length) {
+    case 1:
+      return a;
+    case 2:
+      return ab(a);
+    case 3:
+      return bc(ab(a));
+    case 4:
+      return cd(bc(ab(a)));
+    case 5:
+      return de(cd(bc(ab(a))));
+    case 6:
+      return ef(de(cd(bc(ab(a)))));
+    case 7:
+      return fg(ef(de(cd(bc(ab(a))))));
+    case 8:
+      return gh(fg(ef(de(cd(bc(ab(a)))))));
+    case 9:
+      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+    default: {
+      let ret = args[0];
+      for (let i = 1; i < args.length; i++) {
+        ret = args[i](ret);
+      }
+      return ret;
+    }
+  }
+}
+
+class Pipeable {
+  pipe(...args) {
+    return pipe(this, ...args);
+  }
+}
+
+const PRECISION = 8;
+function round(value, precision = PRECISION) {
+  const scale = 10 ** precision;
+  const result = Math.round(value * scale) / scale;
+  if (result === 0) {
+    return 0;
+  }
+  return result;
+}
+dual(
+  5,
+  (x, x1, x2, y1, y2) => {
+    return y1 + (x - x1) / (x2 - x1) * (y2 - y1);
+  }
+);
+dual(3, (value, min, max) => {
+  return value < min ? min : value > max ? max : value;
+});
+dual(4, (value, min, max, onClip) => {
+  return value < min ? onClip : value > max ? onClip : value;
+});
+function invariant(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+export { Pipeable as P, PRECISION as a, dual as d, invariant as i, round as r };

package/dist/shared/curvy.Cty3LrOR.mjs

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

package/dist/shared/curvy.D7bhnwZy.mjs

@@ -0,0 +1,52 @@
+import { d as dual, r as round, P as Pipeable } from './curvy.ChkqgKuv.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 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 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 make = (v0, v1 = v0, v2 = v1) => new Vector3Impl(v0, v1, v2);
+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));
+
+export { magnitude as a, add as b, components as c, dot as d, subtract as e, hadamard as h, isVector3 as i, make as m, normalize as n, softmax as s };

package/dist/shared/curvy.DOLqYbKE.mjs

@@ -0,0 +1,48 @@
+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 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, add as b, components as c, dot as d, subtract as e, hadamard as h, isVector2 as i, make as m, normalize as n, softmax as s };

package/dist/shared/curvy.DgRsieUW.mjs

@@ -0,0 +1,76 @@
+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 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 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, solve as c, toInverseSolver as d, antiderivative as e, fromVector as f, domain as g, isLinearPolynomial as i, length as l, monotonicity as m, range as r, solveInverse as s, toSolver as t };

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/splines/bezier2d.d.mts

@@ -0,0 +1,35 @@
+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.Bxxwly94.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 appendAligned: {
+    (ratio: number, p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, ratio: number, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendMirrored: {
+    (p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const toPath: (p: Bezier2d) => CubicPath2d;
+
+export { type Bezier2d, append, appendAligned, appendMirrored, fromArray, isCubicBezier2d, make, toPath };

package/dist/splines/bezier2d.d.ts

@@ -0,0 +1,35 @@
+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.CO0Wclt0.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 appendAligned: {
+    (ratio: number, p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, ratio: number, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendMirrored: {
+    (p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+    (p: Bezier2d, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const toPath: (p: Bezier2d) => CubicPath2d;
+
+export { type Bezier2d, append, appendAligned, appendMirrored, fromArray, isCubicBezier2d, make, toPath };

package/dist/splines/bezier2d.mjs

@@ -0,0 +1,122 @@
+import { fromPolynomials } from '../curve/cubic2d.mjs';
+import { d as dual, P as Pipeable, i as invariant } from '../shared/curvy.ChkqgKuv.mjs';
+import { make as make$2, vectorProductLeft } from '../matrix/matrix4x4.mjs';
+import { fromCurves } from '../path/cubic2d.mjs';
+import { fromVector } from '../polynomial/cubic.mjs';
+import { make as make$3 } from '../vector/vector2.mjs';
+import { make as make$4 } from '../vector/vector4.mjs';
+import '../interval.mjs';
+import '../shared/curvy.DmVFTi0N.mjs';
+import '../polynomial/quadratic.mjs';
+import '../shared/curvy.CLzGuqek.mjs';
+import '../shared/curvy.DgRsieUW.mjs';
+import '../curve/quadratic2d.mjs';
+import '../polynomial/linear.mjs';
+import '../curve/linear2d.mjs';
+import '../shared/curvy.C-sUk7ux.mjs';
+import '../shared/curvy.DOLqYbKE.mjs';
+import '../shared/curvy.Cty3LrOR.mjs';
+import '../shared/curvy.BAW_cKLu.mjs';
+import '../shared/curvy.D7bhnwZy.mjs';
+
+const characteristic = make$2(
+  1,
+  0,
+  0,
+  0,
+  -3,
+  3,
+  0,
+  0,
+  3,
+  -6,
+  3,
+  0,
+  -1,
+  3,
+  -3,
+  1
+);
+const Bezier2dTypeId = Symbol("curvy/splines/points");
+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 appendAligned$1 = dual(4, (p, ratio, 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$3((1 + ratio) * p3.x - p2.x, (1 + ratio) * p3.y - p2.y);
+  return append$1(p, p4, p5, p6);
+});
+const appendMirrored$1 = dual(
+  3,
+  (p, p5, p6) => appendAligned$1(p, 1, p5, p6)
+);
+function* toCurves(points) {
+  let p0;
+  let p1;
+  let p2;
+  let p3;
+  for (const point of points) {
+    if (p0 === void 0) {
+      p0 = point;
+    } else if (p1 === void 0) {
+      p1 = point;
+    } else if (p2 === void 0) {
+      p2 = point;
+    } else if (p3 === void 0) {
+      p3 = point;
+      yield fromPolynomials(
+        fromVector(
+          vectorProductLeft(
+            characteristic,
+            make$4(p0.x, p1.x, p2.x, p3.x)
+          )
+        ),
+        fromVector(
+          vectorProductLeft(
+            characteristic,
+            make$4(p0.y, p1.y, p2.y, p3.y)
+          )
+        )
+      );
+      p0 = p3;
+      p1 = void 0;
+      p2 = void 0;
+      p3 = void 0;
+    }
+  }
+}
+const toPath$1 = (p) => fromCurves(...toCurves(p));
+
+const make = make$1;
+const fromArray = fromArray$1;
+const isCubicBezier2d = isCubicBezier2d$1;
+const append = append$1;
+const appendAligned = appendAligned$1;
+const appendMirrored = appendMirrored$1;
+const toPath = toPath$1;
+
+export { append, appendAligned, appendMirrored, fromArray, isCubicBezier2d, make, toPath };

package/dist/vector/vector2.d.mts

@@ -0,0 +1,37 @@
+import { e as TwoDimensional } from '../shared/curvy.CT38g_II.mjs';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+
+declare const Vector2TypeId: unique symbol;
+type Vector2TypeId = typeof Vector2TypeId;
+
+interface Vector2 extends Pipeable, TwoDimensional<number> {
+    readonly [Vector2TypeId]: Vector2TypeId;
+}
+declare const isVector2: (v: unknown) => v is Vector2;
+declare const make: {
+    (xy: number): Vector2;
+    (x: number, y: number): Vector2;
+};
+declare const magnitude: (vector: Vector2) => number;
+declare const normalize: (vector: Vector2) => Vector2;
+declare const dot: {
+    (a: Vector2, b: Vector2): number;
+    (b: Vector2): (a: Vector2) => number;
+};
+declare const components: (v: Vector2) => [number, number];
+declare const softmax: (v: Vector2) => Vector2;
+declare const zero: Vector2;
+declare const add: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+declare const subtract: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+declare const hadamard: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+
+export { type Vector2, add, components, dot, hadamard, isVector2, magnitude, make, normalize, softmax, subtract, zero };

package/dist/vector/vector2.d.ts

@@ -0,0 +1,37 @@
+import { e as TwoDimensional } from '../shared/curvy.CT38g_II.js';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+
+declare const Vector2TypeId: unique symbol;
+type Vector2TypeId = typeof Vector2TypeId;
+
+interface Vector2 extends Pipeable, TwoDimensional<number> {
+    readonly [Vector2TypeId]: Vector2TypeId;
+}
+declare const isVector2: (v: unknown) => v is Vector2;
+declare const make: {
+    (xy: number): Vector2;
+    (x: number, y: number): Vector2;
+};
+declare const magnitude: (vector: Vector2) => number;
+declare const normalize: (vector: Vector2) => Vector2;
+declare const dot: {
+    (a: Vector2, b: Vector2): number;
+    (b: Vector2): (a: Vector2) => number;
+};
+declare const components: (v: Vector2) => [number, number];
+declare const softmax: (v: Vector2) => Vector2;
+declare const zero: Vector2;
+declare const add: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+declare const subtract: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+declare const hadamard: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+
+export { type Vector2, add, components, dot, hadamard, isVector2, magnitude, make, normalize, softmax, subtract, zero };

package/dist/vector/vector2.mjs

@@ -0,0 +1,16 @@
+import { i as isVector2$1, m as make$1, a as magnitude$1, n as normalize$1, d as dot$1, c as components$1, s as softmax$1, b as add$1, e as subtract$1, h as hadamard$1 } from '../shared/curvy.DOLqYbKE.mjs';
+import '../shared/curvy.ChkqgKuv.mjs';
+
+const isVector2 = isVector2$1;
+const make = make$1;
+const magnitude = magnitude$1;
+const normalize = normalize$1;
+const dot = dot$1;
+const components = components$1;
+const softmax = softmax$1;
+const zero = make(0);
+const add = add$1;
+const subtract = subtract$1;
+const hadamard = hadamard$1;
+
+export { add, components, dot, hadamard, isVector2, magnitude, make, normalize, softmax, subtract, zero };