curvy 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/characteristic/index.d.mts

@@ -1,6 +1,6 @@
-import { n as Vector4 } from "../shared/vector3-3Xx7GVk7.mjs";
-import { t as Matrix4x4 } from "../shared/matrix4x4-CaytTaB_.mjs";
-import { t as CubicPolynomial } from "../shared/cubic-DkBqcZf-.mjs";
+import { r as Vector4 } from "../shared/vector3-BfOPFZEn.mjs";
+import { t as Matrix4x4 } from "../shared/matrix4x4-gy9ejrX2.mjs";
+import { t as CubicPolynomial } from "../shared/cubic-C3ZMAoGj.mjs";
 
 //#region src/characteristic/characteristic.d.ts
 declare namespace characteristic_d_exports {

package/dist/curve/index.d.mts

@@ -1,10 +1,2 @@
-import { i as LinearCurve2d$1, n as CubicCurve2d$1, r as QuadraticCurve2d$1, t as RationalCubicCurve2d$1 } from "../shared/rationalCubic2d-MgMSJaAU.mjs";
-
-//#region src/curve/index.d.ts
-type LinearCurve2d = LinearCurve2d$1;
-type QuadraticCurve2d = QuadraticCurve2d$1;
-type CubicCurve2d = CubicCurve2d$1;
-type RationalCubicCurve2d = RationalCubicCurve2d$1;
-//#endregion
-export { CubicCurve2d, LinearCurve2d, QuadraticCurve2d, RationalCubicCurve2d };
-//# sourceMappingURL=index.d.mts.map
+import { c as linear2d_d_exports, i as cubic2d_d_exports, n as rationalCubic2d_d_exports, o as quadratic2d_d_exports } from "../shared/rationalCubic2d-C1RBShBF.mjs";
+export { cubic2d_d_exports as CubicCurve2d, linear2d_d_exports as LinearCurve2d, quadratic2d_d_exports as QuadraticCurve2d, rationalCubic2d_d_exports as RationalCubicCurve2d };

package/dist/interval/index.d.mts

@@ -1,9 +1,3 @@
-import { t as Interval$1 } from "../shared/interval-Bhzeqp8M.mjs";
-import { t as Interval2d$1 } from "../shared/interval2d-BMk5UYXD.mjs";
-
-//#region src/interval/index.d.ts
-type Interval = Interval$1;
-type Interval2d = Interval2d$1;
-//#endregion
-export { Interval, Interval2d };
-//# sourceMappingURL=index.d.mts.map
+import { i as interval_d_exports } from "../shared/interval-CSntLeSX.mjs";
+import { n as interval2d_d_exports } from "../shared/interval2d-D42_0ka1.mjs";
+export { interval_d_exports as Interval, interval2d_d_exports as Interval2d };

package/dist/matrix/index.d.mts

@@ -1,9 +1,2 @@
-import { n as Matrix3x3$1, r as Matrix2x2$1, t as Matrix4x4$1 } from "../shared/matrix4x4-CaytTaB_.mjs";
-
-//#region src/matrix/index.d.ts
-type Matrix2x2 = Matrix2x2$1;
-type Matrix3x3 = Matrix3x3$1;
-type Matrix4x4 = Matrix4x4$1;
-//#endregion
-export { Matrix2x2, Matrix3x3, Matrix4x4 };
-//# sourceMappingURL=index.d.mts.map
+import { i as matrix2x2_d_exports, n as matrix4x4_d_exports, r as matrix3x3_d_exports } from "../shared/matrix4x4-gy9ejrX2.mjs";
+export { matrix2x2_d_exports as Matrix2x2, matrix3x3_d_exports as Matrix3x3, matrix4x4_d_exports as Matrix4x4 };

package/dist/path/index.d.mts

@@ -1,12 +1,16 @@
+import { t as Vector2 } from "../shared/vector2-5GyA0jBj.mjs";
 import { t as Pipeable } from "../shared/utils-MCckigYk.mjs";
-import { i as LinearCurve2d, r as QuadraticCurve2d } from "../shared/rationalCubic2d-MgMSJaAU.mjs";
-import { n as CubicPath2d$1, r as PathTraits, t as RationalCubicPath2d$1 } from "../shared/rationalCubic2d-D-UevGKu.mjs";
+import { n as Closed } from "../shared/interval-CSntLeSX.mjs";
+import { t as Interval2d } from "../shared/interval2d-D42_0ka1.mjs";
+import { a as QuadraticCurve2d, s as LinearCurve2d } from "../shared/rationalCubic2d-C1RBShBF.mjs";
+import { a as Continuous, i as cubic2d_d_exports, n as rationalCubic2d_d_exports, o as PathTraits } from "../shared/rationalCubic2d-DFFvp5S1.mjs";
 
 //#region src/path/linear2d.internal.d.ts
 declare const LinearPath2dTypeId: unique symbol;
 type LinearPath2dTypeId = typeof LinearPath2dTypeId;
-//#endregion
-//#region src/path/linear2d.d.ts
+declare namespace linear2d_d_exports {
+  export { Continuous, LinearPath2d, append$1 as append, asContinuous$1 as asContinuous, boundingBox$1 as boundingBox, fromArray$1 as fromArray, isContinuous$1 as isContinuous, isLinearPath2d, length$1 as length, make$1 as make, solve$1 as solve, toPathData$1 as toPathData };
+}
 /**
  * A linear path in 2D space.
  *
@@ -18,16 +22,125 @@ type LinearPath2dTypeId = typeof LinearPath2dTypeId;
  *
  * @since 1.0.0
  */
-interface LinearPath2d$1<out Trait = unknown> extends Pipeable, Iterable<LinearCurve2d> {
+interface LinearPath2d<out Trait = unknown> extends Pipeable, Iterable<LinearCurve2d> {
   readonly [LinearPath2dTypeId]: LinearPath2dTypeId;
   readonly [PathTraits]: Trait;
 }
+/**
+ * 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
+ */
+declare const make$1: (...curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+/**
+ * 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
+ */
+declare const fromArray$1: (curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+/**
+ * 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
+ */
+declare const isLinearPath2d: (p: unknown) => p is LinearPath2d;
+declare const append$1: {
+  /**
+   * Appends a linear curve to a linear path.
+   *
+   * @param c - The linear curve to append.
+   * @returns A function that takes a linear path and returns a new linear path.
+   * @since 1.0.0
+   */
+  (c: LinearCurve2d): (p: LinearPath2d) => LinearPath2d;
+  /**
+   * Appends a linear curve to a linear path.
+   *
+   * @param p - The linear path to append to.
+   * @param c - The linear curve to append.
+   * @returns A new `LinearPath2d` instance with the appended curve.
+   * @since 1.0.0
+   */
+  (p: LinearPath2d, c: LinearCurve2d): LinearPath2d;
+};
+/**
+ * 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
+ */
+declare const length$1: (p: LinearPath2d) => number;
+declare const solve$1: {
+  /**
+   * Solves a linear path for a given parameter.
+   *
+   * @param u - The parameter to solve for.
+   * @returns A function that takes a linear path and returns the solved point.
+   * @since 1.0.0
+   */
+  (u: number): (p: LinearPath2d) => Vector2;
+  /**
+   * Solves a linear path for a given parameter.
+   *
+   * @param p - The linear path to solve.
+   * @param u - The parameter to solve for.
+   * @returns The solved point on the linear path.
+   * @since 1.0.0
+   */
+  (p: LinearPath2d, u: number): Vector2;
+};
+/**
+ * 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
+ */
+declare const toPathData$1: (p: LinearPath2d) => string;
+/**
+ * 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
+ */
+declare const isContinuous$1: <T>(p: LinearPath2d<T>) => p is LinearPath2d<T & Continuous>;
+/**
+ * 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
+ */
+declare const asContinuous$1: <T>(p: LinearPath2d<T>) => LinearPath2d<T & Continuous>;
+/**
+ * Computes the axis-aligned bounding box of the path — the smallest closed
+ * `Box2d` enclosing every segment.
+ *
+ * @param p - The linear path.
+ * @returns A closed `Box2d` enclosing the path.
+ * @since 2.0.0
+ */
+declare const boundingBox$1: (p: LinearPath2d) => Interval2d<Closed, Closed>;
 //#endregion
 //#region src/path/quadratic2d.internal.d.ts
 declare const QuadraticPath2dTypeId: unique symbol;
 type QuadraticPath2dTypeId = typeof QuadraticPath2dTypeId;
-//#endregion
-//#region src/path/quadratic2d.d.ts
+declare namespace quadratic2d_d_exports {
+  export { Continuous, QuadraticPath2d, append, asContinuous, boundingBox, fromArray, isContinuous, isQuadraticPath2d, length, make, solve, toPathData };
+}
 /**
  * A quadratic path in 2D space.
  *
@@ -38,16 +151,111 @@ type QuadraticPath2dTypeId = typeof QuadraticPath2dTypeId;
  *
  * @since 1.0.0
  */
-interface QuadraticPath2d$1<out Trait = unknown> extends Pipeable, Iterable<QuadraticCurve2d> {
+interface QuadraticPath2d<out Trait = unknown> extends Pipeable, Iterable<QuadraticCurve2d> {
   readonly [QuadraticPath2dTypeId]: QuadraticPath2dTypeId;
   readonly [PathTraits]: Trait;
 }
+/**
+ * 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
+ */
+declare const make: (...curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d;
+/**
+ * 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
+ */
+declare const fromArray: (curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d;
+/**
+ * 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
+ */
+declare const isQuadraticPath2d: (p: unknown) => p is QuadraticPath2d;
+declare const append: {
+  /**
+   * Appends a quadratic curve to a quadratic path.
+   *
+   * @param c - The quadratic curve to append.
+   * @returns A function that takes a quadratic path and returns a new quadratic path.
+   * @since 1.0.0
+   */
+  (c: QuadraticCurve2d): (p: QuadraticPath2d) => QuadraticPath2d;
+  /**
+   * Appends a quadratic curve to a quadratic path.
+   *
+   * @param p - The quadratic path to append to.
+   * @param c - The quadratic curve to append.
+   * @returns A new `QuadraticPath2d` instance with the appended curve.
+   * @since 1.0.0
+   */
+  (p: QuadraticPath2d, c: QuadraticCurve2d): QuadraticPath2d;
+};
+/**
+ * Calculates the length of a quadratic path.
+ *
+ * @param p - The quadratic path to calculate the length of.
+ * @returns The length of the path.
+ */
+declare const length: (p: QuadraticPath2d) => number;
+declare const solve: {
+  /**
+   * Solves a quadratic path at a given parameter.
+   *
+   * @param u - The parameter to solve for.
+   * @returns A function that takes a quadratic path and returns the solved point.
+   * @since 1.0.0
+   */
+  (u: number): (p: QuadraticPath2d) => Vector2;
+  /**
+   * Solves a quadratic path at a given parameter.
+   *
+   * @param p - The quadratic path to solve.
+   * @param u - The parameter to solve for.
+   * @returns The solved point.
+   * @since 1.0.0
+   */
+  (p: QuadraticPath2d, u: number): Vector2;
+};
+/**
+ * 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
+ */
+declare const toPathData: (p: QuadraticPath2d) => string;
+/**
+ * Type-narrowing predicate: refines `QuadraticPath2d<T>` to
+ * `QuadraticPath2d<T & Continuous>` when adjacent curves connect.
+ *
+ * @since 2.0.0
+ */
+declare const isContinuous: <T>(p: QuadraticPath2d<T>) => p is QuadraticPath2d<T & Continuous>;
+/**
+ * Asserts that the quadratic path is continuous, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+declare const asContinuous: <T>(p: QuadraticPath2d<T>) => QuadraticPath2d<T & Continuous>;
+/**
+ * Computes the axis-aligned bounding box of the path — the smallest closed
+ * `Box2d` enclosing every segment.
+ *
+ * @param p - The quadratic path.
+ * @returns A closed `Box2d` enclosing the path.
+ * @since 2.0.0
+ */
+declare const boundingBox: (p: QuadraticPath2d) => Interval2d<Closed, Closed>;
 //#endregion
-//#region src/path/index.d.ts
-type LinearPath2d = LinearPath2d$1;
-type QuadraticPath2d = QuadraticPath2d$1;
-type CubicPath2d = CubicPath2d$1;
-type RationalCubicPath2d = RationalCubicPath2d$1;
-//#endregion
-export { CubicPath2d, LinearPath2d, QuadraticPath2d, RationalCubicPath2d };
+export { cubic2d_d_exports as CubicPath2d, linear2d_d_exports as LinearPath2d, quadratic2d_d_exports as QuadraticPath2d, rationalCubic2d_d_exports as RationalCubicPath2d };
 //# sourceMappingURL=index.d.mts.map

package/dist/polynomial/index.d.mts

@@ -1,9 +1,2 @@
-import { n as QuadraticPolynomial$1, r as LinearPolynomial$1, t as CubicPolynomial$1 } from "../shared/cubic-DkBqcZf-.mjs";
-
-//#region src/polynomial/index.d.ts
-type LinearPolynomial = LinearPolynomial$1;
-type QuadraticPolynomial = QuadraticPolynomial$1;
-type CubicPolynomial = CubicPolynomial$1;
-//#endregion
-export { CubicPolynomial, LinearPolynomial, QuadraticPolynomial };
-//# sourceMappingURL=index.d.mts.map
+import { i as quadratic_d_exports, n as cubic_d_exports, o as linear_d_exports } from "../shared/cubic-C3ZMAoGj.mjs";
+export { cubic_d_exports as CubicPolynomial, linear_d_exports as LinearPolynomial, quadratic_d_exports as QuadraticPolynomial };