curvy 1.0.9 → 2.0.0-alpha.0

package/dist/path/index.mjs

@@ -0,0 +1,292 @@
+import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
+import { Pipeable, dual, invariant } from "../utils.mjs";
+import { epsEquals } from "../number.mjs";
+import { u as unit } from "../shared/interval-CCEqzPgA.mjs";
+import { f as solve$5, h as solve$4, p as length$4, u as length$5 } from "../shared/rationalCubic2d-CP4oGpnk.mjs";
+import { n as rationalCubic2d_exports, r as cubic2d_exports } from "../shared/rationalCubic2d-CXa7Yren.mjs";
+//#region src/path/linear2d.internal.ts
+const LinearPath2dTypeId = Symbol("curvy/path/linear2d");
+var LinearPath2dImpl = class 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 make$3 = (...curves) => new LinearPath2dImpl(curves);
+const fromArray$3 = (curves) => new LinearPath2dImpl(curves);
+const append$3 = dual(2, (p, c) => fromArray$3([...p, c]));
+const length$3 = (p) => {
+	let total = 0;
+	for (const curve of p) total += length$4(curve, unit);
+	return total;
+};
+const solve$3 = dual(2, (p, u) => {
+	const curves = p instanceof LinearPath2dImpl ? p.curves : [...p];
+	if (u === 1) return solve$4(curves.at(-1), 1);
+	const t = u * curves.length;
+	const i = Math.floor(t);
+	const curve = curves[i];
+	return solve$4(curve, t - i);
+});
+const toPathData$3 = (p) => {
+	let result = "";
+	let prevEndX = NaN;
+	let prevEndY = NaN;
+	for (const curve of p) {
+		const startX = curve.x.c0;
+		const startY = curve.y.c0;
+		const endX = curve.x.c0 + curve.x.c1;
+		const endY = curve.y.c0 + curve.y.c1;
+		if (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY)) result += ` M ${startX},${startY}`;
+		result += ` L ${endX},${endY}`;
+		prevEndX = endX;
+		prevEndY = endY;
+	}
+	return result.slice(1);
+};
+const isContinuous$3 = (p) => {
+	let prevEndX = NaN;
+	let prevEndY = NaN;
+	let first = true;
+	for (const curve of p) {
+		const startX = curve.x.c0;
+		const startY = curve.y.c0;
+		if (!first && (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY))) return false;
+		prevEndX = curve.x.c0 + curve.x.c1;
+		prevEndY = curve.y.c0 + curve.y.c1;
+		first = false;
+	}
+	return true;
+};
+const asContinuous$3 = (p) => {
+	invariant(isContinuous$3(p), "linear path is not continuous");
+	return p;
+};
+//#endregion
+//#region src/path/linear2d.ts
+var linear2d_exports = /* @__PURE__ */ __exportAll({
+	append: () => append$2,
+	asContinuous: () => asContinuous$2,
+	fromArray: () => fromArray$2,
+	isContinuous: () => isContinuous$2,
+	isLinearPath2d: () => isLinearPath2d,
+	length: () => length$2,
+	make: () => make$2,
+	solve: () => solve$2,
+	toPathData: () => toPathData$2
+});
+/**
+* Creates a new `LinearPath2d` instance from a sequence of curves.
+*
+* @param curves - The curves to create the path from.
+* @returns A new `LinearPath2d` instance.
+* @since 2.0.0
+*/
+const make$2 = make$3;
+/**
+* Creates a new `LinearPath2d` instance from an array of curves.
+*
+* @param curves - The curves to create the path from.
+* @returns A new `LinearPath2d` instance.
+* @since 2.0.0
+*/
+const fromArray$2 = fromArray$3;
+/**
+* Checks if a value is a `LinearPath2d`.
+*
+* @param p - The value to check.
+* @returns `true` if the value is a `LinearPath2d`, `false` otherwise.
+* @since 1.0.0
+*/
+const isLinearPath2d = isLinearPath2d$1;
+const append$2 = append$3;
+/**
+* Calculates the length of a linear path.
+*
+* @param p - The linear path to calculate the length of.
+* @returns The length of the linear path.
+* @since 1.0.0
+*/
+const length$2 = length$3;
+const solve$2 = solve$3;
+/**
+* Serializes a linear path as an SVG path data string (the value of a `<path>`
+* element's `d` attribute), using `M` and `L` commands. Discontinuities between
+* curves emit a fresh `M` command.
+*
+* @param p - The linear path to serialize.
+* @returns The SVG path data string.
+* @since 2.0.0
+*/
+const toPathData$2 = toPathData$3;
+/**
+* Type-narrowing predicate: refines `LinearPath2d<T>` to
+* `LinearPath2d<T & Continuous>` when adjacent curves connect at their join
+* points.
+*
+* @param p - The linear path to check.
+* @returns `true` when the path is continuous (G⁰).
+* @since 2.0.0
+*/
+const isContinuous$2 = isContinuous$3;
+/**
+* Asserts that the linear path is continuous, throwing on failure.
+*
+* @param p - The linear path to assert against.
+* @returns The same path, typed with the `Continuous` brand.
+* @throws When the path has a discontinuity between adjacent curves.
+* @since 2.0.0
+*/
+const asContinuous$2 = asContinuous$3;
+//#endregion
+//#region src/path/quadratic2d.internal.ts
+const QuadraticPath2dTypeId = Symbol("curvy/path/quadratic2d");
+var QuadraticPath2dImpl = class 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 make$1 = (...curves) => new QuadraticPath2dImpl(curves);
+const fromArray$1 = (curves) => new QuadraticPath2dImpl(curves);
+const append$1 = dual(2, (p, c) => fromArray$1([...p, c]));
+const length$1 = (p) => {
+	let total = 0;
+	for (const curve of p) total += length$5(curve, unit);
+	return total;
+};
+const solve$1 = dual(2, (p, u) => {
+	const curves = p instanceof QuadraticPath2dImpl ? p.curves : [...p];
+	if (u === 1) return solve$5(curves.at(-1), 1);
+	const t = u * curves.length;
+	const i = Math.floor(t);
+	const curve = curves[i];
+	return solve$5(curve, t - i);
+});
+const toPathData$1 = (p) => {
+	let result = "";
+	let prevEndX = NaN;
+	let prevEndY = NaN;
+	for (const curve of p) {
+		const c0x = curve.x.c0;
+		const c0y = curve.y.c0;
+		const c1x = curve.x.c1;
+		const c1y = curve.y.c1;
+		const c2x = curve.x.c2;
+		const c2y = curve.y.c2;
+		const startX = c0x;
+		const startY = c0y;
+		const ctrlX = c0x + c1x / 2;
+		const ctrlY = c0y + c1y / 2;
+		const endX = c0x + c1x + c2x;
+		const endY = c0y + c1y + c2y;
+		if (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY)) result += ` M ${startX},${startY}`;
+		result += ` Q ${ctrlX},${ctrlY} ${endX},${endY}`;
+		prevEndX = endX;
+		prevEndY = endY;
+	}
+	return result.slice(1);
+};
+const isContinuous$1 = (p) => {
+	let prevEndX = NaN;
+	let prevEndY = NaN;
+	let first = true;
+	for (const curve of p) {
+		const startX = curve.x.c0;
+		const startY = curve.y.c0;
+		if (!first && (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY))) return false;
+		prevEndX = curve.x.c0 + curve.x.c1 + curve.x.c2;
+		prevEndY = curve.y.c0 + curve.y.c1 + curve.y.c2;
+		first = false;
+	}
+	return true;
+};
+const asContinuous$1 = (p) => {
+	invariant(isContinuous$1(p), "quadratic path is not continuous");
+	return p;
+};
+//#endregion
+//#region src/path/quadratic2d.ts
+var quadratic2d_exports = /* @__PURE__ */ __exportAll({
+	append: () => append,
+	asContinuous: () => asContinuous,
+	fromArray: () => fromArray,
+	isContinuous: () => isContinuous,
+	isQuadraticPath2d: () => isQuadraticPath2d,
+	length: () => length,
+	make: () => make,
+	solve: () => solve,
+	toPathData: () => toPathData
+});
+/**
+* Creates a new `QuadraticPath2d` instance from a sequence of curves.
+*
+* @param curves - The curves to create the path from.
+* @returns A new `QuadraticPath2d` instance.
+* @since 2.0.0
+*/
+const make = make$1;
+/**
+* Creates a new `QuadraticPath2d` instance from an array of curves.
+*
+* @param curves - The curves to create the path from.
+* @returns A new `QuadraticPath2d` instance.
+* @since 2.0.0
+*/
+const fromArray = fromArray$1;
+/**
+* Checks if a value is a `QuadraticPath2d`.
+*
+* @param p - The value to check.
+* @returns `true` if the value is a `QuadraticPath2d`, `false` otherwise.
+* @since 1.0.0
+*/
+const isQuadraticPath2d = isQuadraticPath2d$1;
+const append = append$1;
+/**
+* Calculates the length of a quadratic path.
+*
+* @param p - The quadratic path to calculate the length of.
+* @returns The length of the path.
+*/
+const length = length$1;
+const solve = solve$1;
+/**
+* Serializes a quadratic path as an SVG path data string (the value of a
+* `<path>` element's `d` attribute), using `M` and `Q` commands. Discontinuities
+* between curves emit a fresh `M` command.
+*
+* @param p - The quadratic path to serialize.
+* @returns The SVG path data string.
+* @since 2.0.0
+*/
+const toPathData = toPathData$1;
+/**
+* Type-narrowing predicate: refines `QuadraticPath2d<T>` to
+* `QuadraticPath2d<T & Continuous>` when adjacent curves connect.
+*
+* @since 2.0.0
+*/
+const isContinuous = isContinuous$1;
+/**
+* Asserts that the quadratic path is continuous, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asContinuous = asContinuous$1;
+//#endregion
+export { cubic2d_exports as CubicPath2d, linear2d_exports as LinearPath2d, quadratic2d_exports as QuadraticPath2d, rationalCubic2d_exports as RationalCubicPath2d };
+
+//# sourceMappingURL=index.mjs.map

package/dist/path/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["isLinearPath2d","make","fromArray","append","length","LinearCurve2d.length","Interval.unit","solve","LinearCurve2d.solve","toPathData","isContinuous","asContinuous","make","internal.make","fromArray","internal.fromArray","internal.isLinearPath2d","append","internal.append","length","internal.length","solve","internal.solve","toPathData","internal.toPathData","isContinuous","internal.isContinuous","asContinuous","internal.asContinuous","isQuadraticPath2d","make","fromArray","append","length","QuadraticCurve2d.length","Interval.unit","solve","QuadraticCurve2d.solve","toPathData","isContinuous","asContinuous","internal.make","internal.fromArray","internal.isQuadraticPath2d","internal.append","internal.length","internal.solve","internal.toPathData","internal.isContinuous","internal.asContinuous"],"sources":["../../src/path/linear2d.internal.ts","../../src/path/linear2d.ts","../../src/path/quadratic2d.internal.ts","../../src/path/quadratic2d.ts"],"sourcesContent":["import * as LinearCurve2d from '../curve/linear2d'\nimport * as Interval from '../interval/interval'\nimport { dual, Pipeable } from '../utils'\nimport { invariant } from '../utils'\nimport { epsEquals } from '../number'\nimport type { Vector2 } from '../vector/vector2'\nimport type { LinearPath2d } from './linear2d'\nimport { PathTraits, type Continuous } from './traits'\n\nexport const LinearPath2dTypeId: unique symbol = Symbol('curvy/path/linear2d')\nexport type LinearPath2dTypeId = typeof LinearPath2dTypeId\n\nexport class LinearPath2dImpl extends Pipeable implements LinearPath2d<unknown> {\n  readonly [LinearPath2dTypeId]: LinearPath2dTypeId = LinearPath2dTypeId\n  declare readonly [PathTraits]: unknown\n\n  readonly curves: ReadonlyArray<LinearCurve2d.LinearCurve2d>\n\n  constructor(curves: ReadonlyArray<LinearCurve2d.LinearCurve2d>) {\n    super()\n    this.curves = curves\n  }\n\n  [Symbol.iterator](): Iterator<LinearCurve2d.LinearCurve2d> {\n    return this.curves[Symbol.iterator]()\n  }\n}\n\nexport const isLinearPath2d = (p: unknown): p is LinearPath2d =>\n  typeof p === 'object' && p !== null && LinearPath2dTypeId in p\n\nexport const make = (...curves: ReadonlyArray<LinearCurve2d.LinearCurve2d>): LinearPath2d =>\n  new LinearPath2dImpl(curves)\n\nexport const fromArray = (curves: ReadonlyArray<LinearCurve2d.LinearCurve2d>) =>\n  new LinearPath2dImpl(curves)\n\nexport const append = dual<\n  (c: LinearCurve2d.LinearCurve2d) => (p: LinearPath2d) => LinearPath2d,\n  (p: LinearPath2d, c: LinearCurve2d.LinearCurve2d) => LinearPath2d\n>(2, (p: LinearPath2d, c: LinearCurve2d.LinearCurve2d) => fromArray([...p, c]))\n\nexport const length = (p: LinearPath2d) => {\n  let total = 0\n  for (const curve of p) {\n    total += LinearCurve2d.length(curve, Interval.unit)\n  }\n\n  return total\n}\n\nexport const solve = dual<\n  (u: number) => (p: LinearPath2d) => Vector2,\n  (p: LinearPath2d, u: number) => Vector2\n>(2, (p: LinearPath2d, u: number) => {\n  const curves = p instanceof LinearPath2dImpl ? p.curves : [...p]\n\n  if (u === 1) {\n    const last = curves.at(-1) as LinearCurve2d.LinearCurve2d\n    return LinearCurve2d.solve(last, 1)\n  }\n\n  const t = u * curves.length\n  const i = Math.floor(t)\n  const curve = curves[i] as LinearCurve2d.LinearCurve2d\n  return LinearCurve2d.solve(curve, t - i)\n})\n\nexport const toPathData = (p: LinearPath2d): string => {\n  let result = ''\n  let prevEndX = Number.NaN\n  let prevEndY = Number.NaN\n\n  for (const curve of p) {\n    const startX = curve.x.c0\n    const startY = curve.y.c0\n    const endX = curve.x.c0 + curve.x.c1\n    const endY = curve.y.c0 + curve.y.c1\n\n    if (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY)) {\n      result += ` M ${startX},${startY}`\n    }\n    result += ` L ${endX},${endY}`\n\n    prevEndX = endX\n    prevEndY = endY\n  }\n\n  return result.slice(1)\n}\n\nexport const isContinuous = <T>(p: LinearPath2d<T>): p is LinearPath2d<T & Continuous> => {\n  let prevEndX = Number.NaN\n  let prevEndY = Number.NaN\n  let first = true\n\n  for (const curve of p) {\n    const startX = curve.x.c0\n    const startY = curve.y.c0\n    if (!first && (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY))) {\n      return false\n    }\n    prevEndX = curve.x.c0 + curve.x.c1\n    prevEndY = curve.y.c0 + curve.y.c1\n    first = false\n  }\n  return true\n}\n\nexport const asContinuous = <T>(p: LinearPath2d<T>): LinearPath2d<T & Continuous> => {\n  invariant(isContinuous(p), 'linear path is not continuous')\n  return p\n}\n","import type { LinearCurve2d } from '../curve/linear2d'\nimport type { Pipeable } from '../utils'\nimport type { Vector2 } from '../vector/vector2'\nimport type { LinearPath2dTypeId } from './linear2d.internal'\nimport * as internal from './linear2d.internal'\nimport type { Continuous, PathTraits } from './traits'\n\nexport type { Continuous } from './traits'\n\n/**\n * A linear path in 2D space.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * The `Trait` type parameter accumulates trait brands as the path is refined\n * via `isContinuous` / `asContinuous`. A `Continuous` path's `toPathData`\n * skips the per-segment discontinuity check.\n *\n * @since 1.0.0\n */\nexport interface LinearPath2d<out Trait = unknown> extends Pipeable, Iterable<LinearCurve2d> {\n  readonly [LinearPath2dTypeId]: LinearPath2dTypeId\n  readonly [PathTraits]: Trait\n}\n\n/**\n * Creates a new `LinearPath2d` instance from a sequence of curves.\n *\n * @param curves - The curves to create the path from.\n * @returns A new `LinearPath2d` instance.\n * @since 2.0.0\n */\nexport const make: (...curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d = internal.make\n\n/**\n * Creates a new `LinearPath2d` instance from an array of curves.\n *\n * @param curves - The curves to create the path from.\n * @returns A new `LinearPath2d` instance.\n * @since 2.0.0\n */\nexport const fromArray: (curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d = internal.fromArray\n\n/**\n * Checks if a value is a `LinearPath2d`.\n *\n * @param p - The value to check.\n * @returns `true` if the value is a `LinearPath2d`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isLinearPath2d: (p: unknown) => p is LinearPath2d = internal.isLinearPath2d\n\nexport const append: {\n  /**\n   * Appends a linear curve to a linear path.\n   *\n   * @param c - The linear curve to append.\n   * @returns A function that takes a linear path and returns a new linear path.\n   * @since 1.0.0\n   */\n  (c: LinearCurve2d): (p: LinearPath2d) => LinearPath2d\n  /**\n   * Appends a linear curve to a linear path.\n   *\n   * @param p - The linear path to append to.\n   * @param c - The linear curve to append.\n   * @returns A new `LinearPath2d` instance with the appended curve.\n   * @since 1.0.0\n   */\n  (p: LinearPath2d, c: LinearCurve2d): LinearPath2d\n} = internal.append\n\n/**\n * Calculates the length of a linear path.\n *\n * @param p - The linear path to calculate the length of.\n * @returns The length of the linear path.\n * @since 1.0.0\n */\nexport const length: (p: LinearPath2d) => number = internal.length\n\nexport const solve: {\n  /**\n   * Solves a linear path for a given parameter.\n   *\n   * @param u - The parameter to solve for.\n   * @returns A function that takes a linear path and returns the solved point.\n   * @since 1.0.0\n   */\n  (u: number): (p: LinearPath2d) => Vector2\n  /**\n   * Solves a linear path for a given parameter.\n   *\n   * @param p - The linear path to solve.\n   * @param u - The parameter to solve for.\n   * @returns The solved point on the linear path.\n   * @since 1.0.0\n   */\n  (p: LinearPath2d, u: number): Vector2\n} = internal.solve\n\n/**\n * Serializes a linear path as an SVG path data string (the value of a `<path>`\n * element's `d` attribute), using `M` and `L` commands. Discontinuities between\n * curves emit a fresh `M` command.\n *\n * @param p - The linear path to serialize.\n * @returns The SVG path data string.\n * @since 2.0.0\n */\nexport const toPathData: (p: LinearPath2d) => string = internal.toPathData\n\n/**\n * Type-narrowing predicate: refines `LinearPath2d<T>` to\n * `LinearPath2d<T & Continuous>` when adjacent curves connect at their join\n * points.\n *\n * @param p - The linear path to check.\n * @returns `true` when the path is continuous (G⁰).\n * @since 2.0.0\n */\nexport const isContinuous: <T>(p: LinearPath2d<T>) => p is LinearPath2d<T & Continuous> =\n  internal.isContinuous\n\n/**\n * Asserts that the linear path is continuous, throwing on failure.\n *\n * @param p - The linear path to assert against.\n * @returns The same path, typed with the `Continuous` brand.\n * @throws When the path has a discontinuity between adjacent curves.\n * @since 2.0.0\n */\nexport const asContinuous: <T>(p: LinearPath2d<T>) => LinearPath2d<T & Continuous> =\n  internal.asContinuous\n","import * as QuadraticCurve2d from '../curve/quadratic2d'\nimport * as Interval from '../interval/interval'\nimport { dual, Pipeable } from '../utils'\nimport { invariant } from '../utils'\nimport { epsEquals } from '../number'\nimport type { Vector2 } from '../vector/vector2'\nimport type { QuadraticPath2d } from './quadratic2d'\nimport { PathTraits, type Continuous } from './traits'\n\nexport const QuadraticPath2dTypeId: unique symbol = Symbol('curvy/path/quadratic2d')\nexport type QuadraticPath2dTypeId = typeof QuadraticPath2dTypeId\n\nexport class QuadraticPath2dImpl extends Pipeable implements QuadraticPath2d<unknown> {\n  readonly [QuadraticPath2dTypeId]: QuadraticPath2dTypeId = QuadraticPath2dTypeId\n  declare readonly [PathTraits]: unknown\n\n  readonly curves: ReadonlyArray<QuadraticCurve2d.QuadraticCurve2d>\n\n  constructor(curves: ReadonlyArray<QuadraticCurve2d.QuadraticCurve2d>) {\n    super()\n    this.curves = curves\n  }\n\n  [Symbol.iterator](): Iterator<QuadraticCurve2d.QuadraticCurve2d> {\n    return this.curves[Symbol.iterator]()\n  }\n}\n\nexport const isQuadraticPath2d = (p: unknown): p is QuadraticPath2d =>\n  typeof p === 'object' && p !== null && QuadraticPath2dTypeId in p\n\nexport const make = (\n  ...curves: ReadonlyArray<QuadraticCurve2d.QuadraticCurve2d>\n): QuadraticPath2d => new QuadraticPath2dImpl(curves)\n\nexport const fromArray = (\n  curves: ReadonlyArray<QuadraticCurve2d.QuadraticCurve2d>,\n): QuadraticPath2d => new QuadraticPath2dImpl(curves)\n\nexport const append = dual<\n  (c: QuadraticCurve2d.QuadraticCurve2d) => (p: QuadraticPath2d) => QuadraticPath2d,\n  (p: QuadraticPath2d, c: QuadraticCurve2d.QuadraticCurve2d) => QuadraticPath2d\n>(2, (p: QuadraticPath2d, c: QuadraticCurve2d.QuadraticCurve2d) => fromArray([...p, c]))\n\nexport const length = (p: QuadraticPath2d) => {\n  let total = 0\n  for (const curve of p) {\n    total += QuadraticCurve2d.length(curve, Interval.unit)\n  }\n\n  return total\n}\n\nexport const solve = dual<\n  (u: number) => (p: QuadraticPath2d) => Vector2,\n  (p: QuadraticPath2d, u: number) => Vector2\n>(2, (p: QuadraticPath2d, u: number) => {\n  const curves = p instanceof QuadraticPath2dImpl ? p.curves : [...p]\n\n  if (u === 1) {\n    const last = curves.at(-1) as QuadraticCurve2d.QuadraticCurve2d\n    return QuadraticCurve2d.solve(last, 1)\n  }\n\n  const t = u * curves.length\n  const i = Math.floor(t)\n  const curve = curves[i] as QuadraticCurve2d.QuadraticCurve2d\n  return QuadraticCurve2d.solve(curve, t - i)\n})\n\n// Quadratic Bernstein basis: P(t) = (1-t)²·p0 + 2(1-t)t·p1 + t²·p2\n// expanded gives c0 = p0, c1 = -2p0 + 2p1, c2 = p0 - 2p1 + p2, so:\n//   p0 = c0, p1 = c0 + c1/2, p2 = c0 + c1 + c2.\nexport const toPathData = (p: QuadraticPath2d): string => {\n  let result = ''\n  let prevEndX = Number.NaN\n  let prevEndY = Number.NaN\n\n  for (const curve of p) {\n    const c0x = curve.x.c0\n    const c0y = curve.y.c0\n    const c1x = curve.x.c1\n    const c1y = curve.y.c1\n    const c2x = curve.x.c2\n    const c2y = curve.y.c2\n\n    const startX = c0x\n    const startY = c0y\n    const ctrlX = c0x + c1x / 2\n    const ctrlY = c0y + c1y / 2\n    const endX = c0x + c1x + c2x\n    const endY = c0y + c1y + c2y\n\n    if (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY)) {\n      result += ` M ${startX},${startY}`\n    }\n    result += ` Q ${ctrlX},${ctrlY} ${endX},${endY}`\n\n    prevEndX = endX\n    prevEndY = endY\n  }\n\n  return result.slice(1)\n}\n\nexport const isContinuous = <T>(p: QuadraticPath2d<T>): p is QuadraticPath2d<T & Continuous> => {\n  let prevEndX = Number.NaN\n  let prevEndY = Number.NaN\n  let first = true\n\n  for (const curve of p) {\n    const startX = curve.x.c0\n    const startY = curve.y.c0\n    if (!first && (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY))) {\n      return false\n    }\n    prevEndX = curve.x.c0 + curve.x.c1 + curve.x.c2\n    prevEndY = curve.y.c0 + curve.y.c1 + curve.y.c2\n    first = false\n  }\n  return true\n}\n\nexport const asContinuous = <T>(p: QuadraticPath2d<T>): QuadraticPath2d<T & Continuous> => {\n  invariant(isContinuous(p), 'quadratic path is not continuous')\n  return p\n}\n","import type { QuadraticCurve2d } from '../curve/quadratic2d'\nimport type { Pipeable } from '../utils'\nimport type { Vector2 } from '../vector/vector2'\nimport type { QuadraticPath2dTypeId } from './quadratic2d.internal'\nimport * as internal from './quadratic2d.internal'\nimport type { Continuous, PathTraits } from './traits'\n\nexport type { Continuous } from './traits'\n\n/**\n * A quadratic path in 2D space.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * The `Trait` type parameter accumulates trait brands as the path is refined\n * via `isContinuous` / `asContinuous`.\n *\n * @since 1.0.0\n */\nexport interface QuadraticPath2d<out Trait = unknown> extends Pipeable, Iterable<QuadraticCurve2d> {\n  readonly [QuadraticPath2dTypeId]: QuadraticPath2dTypeId\n  readonly [PathTraits]: Trait\n}\n\n/**\n * Creates a new `QuadraticPath2d` instance from a sequence of curves.\n *\n * @param curves - The curves to create the path from.\n * @returns A new `QuadraticPath2d` instance.\n * @since 2.0.0\n */\nexport const make: (...curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d = internal.make\n\n/**\n * Creates a new `QuadraticPath2d` instance from an array of curves.\n *\n * @param curves - The curves to create the path from.\n * @returns A new `QuadraticPath2d` instance.\n * @since 2.0.0\n */\nexport const fromArray: (curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d =\n  internal.fromArray\n\n/**\n * Checks if a value is a `QuadraticPath2d`.\n *\n * @param p - The value to check.\n * @returns `true` if the value is a `QuadraticPath2d`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isQuadraticPath2d: (p: unknown) => p is QuadraticPath2d = internal.isQuadraticPath2d\n\nexport const append: {\n  /**\n   * Appends a quadratic curve to a quadratic path.\n   *\n   * @param c - The quadratic curve to append.\n   * @returns A function that takes a quadratic path and returns a new quadratic path.\n   * @since 1.0.0\n   */\n  (c: QuadraticCurve2d): (p: QuadraticPath2d) => QuadraticPath2d\n  /**\n   * Appends a quadratic curve to a quadratic path.\n   *\n   * @param p - The quadratic path to append to.\n   * @param c - The quadratic curve to append.\n   * @returns A new `QuadraticPath2d` instance with the appended curve.\n   * @since 1.0.0\n   */\n  (p: QuadraticPath2d, c: QuadraticCurve2d): QuadraticPath2d\n} = internal.append\n\n/**\n * Calculates the length of a quadratic path.\n *\n * @param p - The quadratic path to calculate the length of.\n * @returns The length of the path.\n */\nexport const length: (p: QuadraticPath2d) => number = internal.length\n\nexport const solve: {\n  /**\n   * Solves a quadratic path at a given parameter.\n   *\n   * @param u - The parameter to solve for.\n   * @returns A function that takes a quadratic path and returns the solved point.\n   * @since 1.0.0\n   */\n  (u: number): (p: QuadraticPath2d) => Vector2\n  /**\n   * Solves a quadratic path at a given parameter.\n   *\n   * @param p - The quadratic path to solve.\n   * @param u - The parameter to solve for.\n   * @returns The solved point.\n   * @since 1.0.0\n   */\n  (p: QuadraticPath2d, u: number): Vector2\n} = internal.solve\n\n/**\n * Serializes a quadratic path as an SVG path data string (the value of a\n * `<path>` element's `d` attribute), using `M` and `Q` commands. Discontinuities\n * between curves emit a fresh `M` command.\n *\n * @param p - The quadratic path to serialize.\n * @returns The SVG path data string.\n * @since 2.0.0\n */\nexport const toPathData: (p: QuadraticPath2d) => string = internal.toPathData\n\n/**\n * Type-narrowing predicate: refines `QuadraticPath2d<T>` to\n * `QuadraticPath2d<T & Continuous>` when adjacent curves connect.\n *\n * @since 2.0.0\n */\nexport const isContinuous: <T>(p: QuadraticPath2d<T>) => p is QuadraticPath2d<T & Continuous> =\n  internal.isContinuous\n\n/**\n * Asserts that the quadratic path is continuous, throwing on failure.\n *\n * @since 2.0.0\n */\nexport const asContinuous: <T>(p: QuadraticPath2d<T>) => QuadraticPath2d<T & Continuous> =\n  internal.asContinuous\n"],"mappings":"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"}

package/dist/polynomial/index.d.mts

@@ -0,0 +1,2 @@
+import { i as quadratic_d_exports, n as cubic_d_exports, o as linear_d_exports } from "../shared/cubic-Dfn6DB02.mjs";
+export { cubic_d_exports as CubicPolynomial, linear_d_exports as LinearPolynomial, quadratic_d_exports as QuadraticPolynomial };

package/dist/polynomial/index.mjs

@@ -0,0 +1,3 @@
+import { t as cubic_exports } from "../shared/cubic-CYYEUHNm.mjs";
+import { f as linear_exports, o as quadratic_exports } from "../shared/quadratic-DEhuAKuE.mjs";
+export { cubic_exports as CubicPolynomial, linear_exports as LinearPolynomial, quadratic_exports as QuadraticPolynomial };

package/dist/shared/characteristic-BGRxcxUH.mjs

@@ -0,0 +1,104 @@
+import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
+import { roundDown } from "../number.mjs";
+import { a as vectorProductLeft, n as make } from "./matrix4x4-Ck2WROK-.mjs";
+import { r as fromVector } from "./cubic-CYYEUHNm.mjs";
+//#region src/characteristic/characteristic.ts
+var characteristic_exports = /* @__PURE__ */ __exportAll({
+	apply: () => apply,
+	cubicBasisSpline: () => cubicBasisSpline,
+	cubicBezier: () => cubicBezier,
+	cubicCardinal: () => cubicCardinal,
+	cubicCatmullRom: () => cubicCatmullRom,
+	cubicHermite: () => cubicHermite
+});
+/**
+* The cubic Bézier characteristic matrix.
+*
+* Maps Bernstein-basis control points `(P₀, P₁, P₂, P₃)` to monomial cubic
+* coefficients `(c₀, c₁, c₂, c₃)` for `c₀ + c₁·t + c₂·t² + c₃·t³`. The matrix
+* IS the Bézier spline family — combined with control points (via {@link apply}),
+* it produces the cubic polynomial that parameterizes the curve.
+*
+* @since 2.1.0
+*/
+const cubicBezier = make(1, 0, 0, 0, -3, 3, 0, 0, 3, -6, 3, 0, -1, 3, -3, 1);
+/**
+* The cubic Hermite characteristic matrix.
+*
+* Maps Hermite control data `(P₀, V₀, P₁, V₁)` — two endpoints and two
+* tangent vectors — to monomial cubic coefficients.
+*
+* @since 2.1.0
+*/
+const cubicHermite = make(1, 0, 0, 0, 0, 1, 0, 0, -3, -2, 3, -1, 2, 1, -2, 1);
+/**
+* The uniform cubic B-spline (basis spline) characteristic matrix.
+*
+* Maps a window of four control points to the monomial cubic coefficients
+* of one segment of the corresponding uniform cubic B-spline. Stride-1
+* application produces a C² piecewise spline; the curve does not generally
+* pass through the control points.
+*
+* @since 2.1.0
+*/
+const cubicBasisSpline = make(1 / 6, 4 / 6, roundDown(1 / 6), 0, -.5, 0, .5, 0, .5, -1, .5, 0, -1 / 6, .5, -.5, 1 / 6);
+const cardinalCache = /* @__PURE__ */ new Map();
+/**
+* The cubic Cardinal spline characteristic matrix, parameterized by tension.
+*
+* Maps four control points to the monomial cubic coefficients of one
+* Cardinal segment. The tension `s` controls how tightly the curve hugs
+* the control points: `s = 0` produces straight-line segments between
+* adjacent points, `s = 0.5` is the Catmull-Rom variant (see
+* {@link cubicCatmullRom}), and higher values produce looser, more curved
+* shapes.
+*
+* Cached per tension value — repeated calls with the same tension return
+* the same matrix instance.
+*
+* @param tension - The tension parameter.
+* @returns The characteristic matrix for that tension.
+* @since 2.1.0
+*/
+const cubicCardinal = (tension) => {
+	let m = cardinalCache.get(tension);
+	if (m === void 0) {
+		m = make(0, 1, 0, 0, -tension, 0, tension, 0, 2 * tension, tension - 3, 3 - 2 * tension, -tension, -tension, 2 - tension, tension - 2, tension);
+		cardinalCache.set(tension, m);
+	}
+	return m;
+};
+/**
+* The cubic Catmull-Rom characteristic matrix — Cardinal with tension `0.5`.
+* The most common Cardinal-family variant; reused widely enough to deserve
+* a constant.
+*
+* @since 2.1.0
+*/
+const cubicCatmullRom = cubicCardinal(.5);
+/**
+* Applies a characteristic matrix to N channels of control values, producing
+* N cubic polynomials in monomial form.
+*
+* Each channel is a `Vector4` packing one axis's values across the four
+* control points: `(v₀, v₁, v₂, v₃)`. The result tuple has the same arity
+* as the input.
+*
+* The polynomial 2D spline pipeline applies this with two channels (x, y);
+* the rational 2D pipeline uses three (x, y, w) where `w` is the projective
+* denominator. Higher channel counts generalize to 3D, rational 3D, and
+* beyond — the characteristic matrix doesn't care about the geometric
+* domain, only about how to combine four samples per channel.
+*
+* @param matrix - The characteristic matrix of the spline family.
+* @param channels - One `Vector4` per output polynomial, packing the four control values for that channel.
+* @returns A tuple of cubic polynomials, one per input channel.
+* @since 2.1.0
+*/
+const apply = (matrix, ...channels) => {
+	return channels.map((c) => fromVector(vectorProductLeft(matrix, c)));
+};
+//#endregion
+export { cubicCardinal as a, cubicBezier as i, characteristic_exports as n, cubicHermite as o, cubicBasisSpline as r, apply as t };
+
+//# sourceMappingURL=characteristic-BGRxcxUH.mjs.map

package/dist/shared/characteristic-BGRxcxUH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"characteristic-BGRxcxUH.mjs","names":["Matrix4x4.make","CubicPolynomial.fromVector","Matrix4x4.vectorProductLeft"],"sources":["../../src/characteristic/characteristic.ts"],"sourcesContent":["import * as Matrix4x4 from '../matrix/matrix4x4'\nimport * as CubicPolynomial from '../polynomial/cubic'\nimport { roundDown } from '../number'\nimport type * as Vector4 from '../vector/vector4'\n\n/**\n * The cubic Bézier characteristic matrix.\n *\n * Maps Bernstein-basis control points `(P₀, P₁, P₂, P₃)` to monomial cubic\n * coefficients `(c₀, c₁, c₂, c₃)` for `c₀ + c₁·t + c₂·t² + c₃·t³`. The matrix\n * IS the Bézier spline family — combined with control points (via {@link apply}),\n * it produces the cubic polynomial that parameterizes the curve.\n *\n * @since 2.1.0\n */\nexport const cubicBezier: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1,\n  0,\n  0,\n  0,\n  -3,\n  3,\n  0,\n  0,\n  3,\n  -6,\n  3,\n  0,\n  -1,\n  3,\n  -3,\n  1,\n)\n\n/**\n * The cubic Hermite characteristic matrix.\n *\n * Maps Hermite control data `(P₀, V₀, P₁, V₁)` — two endpoints and two\n * tangent vectors — to monomial cubic coefficients.\n *\n * @since 2.1.0\n */\nexport const cubicHermite: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1,\n  0,\n  0,\n  0,\n  0,\n  1,\n  0,\n  0,\n  -3,\n  -2,\n  3,\n  -1,\n  2,\n  1,\n  -2,\n  1,\n)\n\n/**\n * The uniform cubic B-spline (basis spline) characteristic matrix.\n *\n * Maps a window of four control points to the monomial cubic coefficients\n * of one segment of the corresponding uniform cubic B-spline. Stride-1\n * application produces a C² piecewise spline; the curve does not generally\n * pass through the control points.\n *\n * @since 2.1.0\n */\nexport const cubicBasisSpline: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1 / 6,\n  4 / 6,\n  roundDown(1 / 6),\n  0,\n  -0.5,\n  0,\n  0.5,\n  0,\n  0.5,\n  -1,\n  0.5,\n  0,\n  -1 / 6,\n  0.5,\n  -0.5,\n  1 / 6,\n)\n\nconst cardinalCache = new Map<number, Matrix4x4.Matrix4x4>()\n\n/**\n * The cubic Cardinal spline characteristic matrix, parameterized by tension.\n *\n * Maps four control points to the monomial cubic coefficients of one\n * Cardinal segment. The tension `s` controls how tightly the curve hugs\n * the control points: `s = 0` produces straight-line segments between\n * adjacent points, `s = 0.5` is the Catmull-Rom variant (see\n * {@link cubicCatmullRom}), and higher values produce looser, more curved\n * shapes.\n *\n * Cached per tension value — repeated calls with the same tension return\n * the same matrix instance.\n *\n * @param tension - The tension parameter.\n * @returns The characteristic matrix for that tension.\n * @since 2.1.0\n */\nexport const cubicCardinal = (tension: number): Matrix4x4.Matrix4x4 => {\n  let m = cardinalCache.get(tension)\n  if (m === undefined) {\n    m = Matrix4x4.make(\n      0,\n      1,\n      0,\n      0,\n      -tension,\n      0,\n      tension,\n      0,\n      2 * tension,\n      tension - 3,\n      3 - 2 * tension,\n      -tension,\n      -tension,\n      2 - tension,\n      tension - 2,\n      tension,\n    )\n    cardinalCache.set(tension, m)\n  }\n  return m\n}\n\n/**\n * The cubic Catmull-Rom characteristic matrix — Cardinal with tension `0.5`.\n * The most common Cardinal-family variant; reused widely enough to deserve\n * a constant.\n *\n * @since 2.1.0\n */\nexport const cubicCatmullRom: Matrix4x4.Matrix4x4 = cubicCardinal(0.5)\n\n/**\n * Applies a characteristic matrix to N channels of control values, producing\n * N cubic polynomials in monomial form.\n *\n * Each channel is a `Vector4` packing one axis's values across the four\n * control points: `(v₀, v₁, v₂, v₃)`. The result tuple has the same arity\n * as the input.\n *\n * The polynomial 2D spline pipeline applies this with two channels (x, y);\n * the rational 2D pipeline uses three (x, y, w) where `w` is the projective\n * denominator. Higher channel counts generalize to 3D, rational 3D, and\n * beyond — the characteristic matrix doesn't care about the geometric\n * domain, only about how to combine four samples per channel.\n *\n * @param matrix - The characteristic matrix of the spline family.\n * @param channels - One `Vector4` per output polynomial, packing the four control values for that channel.\n * @returns A tuple of cubic polynomials, one per input channel.\n * @since 2.1.0\n */\nexport const apply = <const Channels extends ReadonlyArray<Vector4.Vector4>>(\n  matrix: Matrix4x4.Matrix4x4,\n  ...channels: Channels\n): { readonly [K in keyof Channels]: CubicPolynomial.CubicPolynomial } => {\n  const result = channels.map((c) =>\n    CubicPolynomial.fromVector(Matrix4x4.vectorProductLeft(matrix, c)),\n  )\n  return result as { readonly [K in keyof Channels]: CubicPolynomial.CubicPolynomial }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAeA,MAAa,cAAmCA,KAC9C,GACA,GACA,GACA,GACA,IACA,GACA,GACA,GACA,GACA,IACA,GACA,GACA,IACA,GACA,IACA,EACD;;;;;;;;;AAUD,MAAa,eAAoCA,KAC/C,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IACA,IACA,GACA,IACA,GACA,GACA,IACA,EACD;;;;;;;;;;;AAYD,MAAa,mBAAwCA,KACnD,IAAI,GACJ,IAAI,GACJ,UAAU,IAAI,EAAE,EAChB,GACA,KACA,GACA,IACA,GACA,IACA,IACA,IACA,GACA,KAAK,GACL,IACA,KACA,IAAI,EACL;AAED,MAAM,gCAAgB,IAAI,KAAkC;;;;;;;;;;;;;;;;;;AAmB5D,MAAa,iBAAiB,YAAyC;CACrE,IAAI,IAAI,cAAc,IAAI,QAAQ;CAClC,IAAI,MAAM,KAAA,GAAW;EACnB,IAAIA,KACF,GACA,GACA,GACA,GACA,CAAC,SACD,GACA,SACA,GACA,IAAI,SACJ,UAAU,GACV,IAAI,IAAI,SACR,CAAC,SACD,CAAC,SACD,IAAI,SACJ,UAAU,GACV,QACD;EACD,cAAc,IAAI,SAAS,EAAE;;CAE/B,OAAO;;;;;;;;;AAUT,MAAa,kBAAuC,cAAc,GAAI;;;;;;;;;;;;;;;;;;;;AAqBtE,MAAa,SACX,QACA,GAAG,aACqE;CAIxE,OAHe,SAAS,KAAK,MAC3BC,WAA2BC,kBAA4B,QAAQ,EAAE,CAAC,CAEvD"}

package/dist/shared/chunk-25Hzd3z8.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };