curvy 1.0.9 → 2.0.0-alpha.2

package/dist/splines/index.d.mts

@@ -0,0 +1,701 @@
+import { n as Weighted, t as Vector2 } from "../shared/vector2-DPUY3_eA.mjs";
+import { t as Pipeable } from "../shared/utils-MCckigYk.mjs";
+import { t as AtMostOne } from "../shared/solution-sNQ-ZVhN.mjs";
+import { r as CubicPath2d, t as RationalCubicPath2d } from "../shared/rationalCubic2d-B6g97ryJ.mjs";
+
+//#region src/splines/rationalBezier2d.internal.d.ts
+declare const RationalBezier2dTypeId: unique symbol;
+type RationalBezier2dTypeId = typeof RationalBezier2dTypeId;
+declare namespace rationalBezier2d_d_exports {
+  export { RationalBezier2d, fromArray$4 as fromArray, fromBezier, fromPoints, isRationalBezier2d, make$4 as make, subdivide$1 as subdivide, toPath$4 as toPath };
+}
+/**
+ * A piecewise rational cubic Bézier curve in 2D space.
+ *
+ * Each control point is a `Vector2.Weighted` carrying a positive scalar
+ * weight; the curve evaluates to `Σ w_i · N_i(t) · P_i / Σ w_i · N_i(t)`,
+ * where `N_i` are the cubic Bernstein basis functions. With all weights
+ * equal, the curve coincides with a non-rational `Bezier2d`. With unequal
+ * weights, the curve can exactly represent conic sections — circles,
+ * ellipses, parabolas, and hyperbolas — that polynomial Béziers can only
+ * approximate.
+ *
+ * Internally each control point is stored in homogeneous form `(w·x, w·y, w)`,
+ * so de Casteljau evaluation is three independent linear interpolations
+ * followed by a single division. Iteration projects back to `Vector2.Weighted`
+ * — the same shape accepted by {@link make}.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 2.1.0
+ */
+interface RationalBezier2d extends Pipeable {
+  readonly [RationalBezier2dTypeId]: RationalBezier2dTypeId;
+  [Symbol.iterator](): IterableIterator<Weighted>;
+}
+/**
+ * Checks if a value is a `RationalBezier2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `RationalBezier2d`, `false` otherwise.
+ * @since 2.1.0
+ */
+declare const isRationalBezier2d: (p: unknown) => p is RationalBezier2d;
+/**
+ * Creates a new single-segment `RationalBezier2d` from four weighted control points.
+ *
+ * Equal weights produce a curve coincident with the corresponding polynomial
+ * cubic Bézier; unequal weights produce a true rational curve capable of
+ * representing conics exactly.
+ *
+ * @param p0 - The first weighted control point (curve start).
+ * @param p1 - The second weighted control point (start handle).
+ * @param p2 - The third weighted control point (end handle).
+ * @param p3 - The fourth weighted control point (curve end).
+ * @returns A new `RationalBezier2d` instance.
+ * @since 2.1.0
+ */
+declare const make$4: (p0: Weighted, p1: Weighted, p2: Weighted, p3: Weighted) => RationalBezier2d;
+/**
+ * Creates a new `RationalBezier2d` from an array of weighted control points.
+ *
+ * The array must contain `(n * 3) + 1` entries to describe `n` joined cubic
+ * segments.
+ *
+ * @param points - The weighted control points.
+ * @returns A new `RationalBezier2d` instance.
+ * @since 2.1.0
+ */
+declare const fromArray$4: (points: ReadonlyArray<Weighted>) => RationalBezier2d;
+/**
+ * Creates a new single-segment `RationalBezier2d` from four points with all
+ * weights equal to one.
+ *
+ * Convenience constructor for callers who want the rational evaluator but
+ * don't yet have non-unit weights — the resulting curve is mathematically
+ * equivalent to the corresponding `Bezier2d.make(p0, p1, p2, p3)` and can
+ * later be subdivided or recombined using the rational machinery without
+ * conversion overhead.
+ *
+ * @param p0 - The first control point (curve start).
+ * @param p1 - The second control point (start handle).
+ * @param p2 - The third control point (end handle).
+ * @param p3 - The fourth control point (curve end).
+ * @returns A new `RationalBezier2d` with unit weights.
+ * @since 2.1.0
+ */
+declare const fromPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => RationalBezier2d;
+/**
+ * Lifts a non-rational `Bezier2d` into a `RationalBezier2d` by assigning
+ * unit weight to every control point. The two curves trace the same path.
+ *
+ * @param b - The non-rational bezier to lift.
+ * @returns A new `RationalBezier2d` with unit weights.
+ * @since 2.1.0
+ */
+declare const fromBezier: (b: Bezier2d) => RationalBezier2d;
+/**
+ * Converts a `RationalBezier2d` to a `RationalCubicPath2d`.
+ *
+ * Each segment's four homogeneous control points are expanded into three
+ * per-segment monomial cubic polynomials — `x`, `y`, and the shared
+ * denominator `w` — yielding a path whose evaluator is three Horner passes
+ * plus two divisions per call.
+ *
+ * Mirrors `Bezier2d.toPath`: spline construction is converted to path
+ * evaluation form, and forward evaluation thereafter routes through the
+ * path's `solve`.
+ *
+ * @param r - The rational bezier to convert.
+ * @returns A new `RationalCubicPath2d` instance representing the same curve.
+ * @since 2.1.0
+ */
+declare const toPath$4: (r: RationalBezier2d) => RationalCubicPath2d;
+declare const subdivide$1: {
+  /**
+   * Splits a `RationalBezier2d` at the given global parameter `u ∈ (0, 1)`
+   * using de Casteljau's algorithm in homogeneous coordinates. The two
+   * returned beziers together trace the same curve as the input — the left
+   * covers `[0, u]`, the right covers `[u, 1]`.
+   *
+   * The subdivided halves' control-point weights generally differ from the
+   * original's even at unit input weights; this is expected and preserves
+   * the curve shape exactly.
+   *
+   * @param r - The rational bezier to split.
+   * @param u - The split parameter in the open interval `(0, 1)`.
+   * @returns A two-element tuple of the left and right halves.
+   * @since 2.1.0
+   */
+  (r: RationalBezier2d, u: number): [RationalBezier2d, RationalBezier2d];
+  /**
+   * Splits a `RationalBezier2d` at the given global parameter `u ∈ (0, 1)`.
+   *
+   * @param u - The split parameter in the open interval `(0, 1)`.
+   * @returns A function that takes a rational bezier and returns the halves.
+   * @since 2.1.0
+   */
+  (u: number): (r: RationalBezier2d) => [RationalBezier2d, RationalBezier2d];
+};
+//#endregion
+//#region src/splines/bezier2d.internal.d.ts
+declare const Bezier2dTypeId: unique symbol;
+type Bezier2dTypeId = typeof Bezier2dTypeId;
+declare namespace bezier2d_d_exports {
+  export { Bezier2d, append$3 as append, appendAccelerationAligned, appendCurvatureAligned, appendTangentAligned, appendVelocityAligned, fromArray$3 as fromArray, fromRational, isCubicBezier2d, make$3 as make, subdivide, toPath$3 as toPath };
+}
+/**
+ * A Bézier curve in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The characteristic matrix that identifies this spline family lives in the
+ * `characteristic` module as `Characteristic.cubicBezier`.
+ *
+ * @since 1.0.0
+ */
+interface Bezier2d extends Pipeable {
+  readonly [Bezier2dTypeId]: Bezier2dTypeId;
+  [Symbol.iterator](): IterableIterator<Vector2>;
+}
+/**
+ * Creates a new `Bezier2d` instance.
+ *
+ * @param p0 - The first control point.
+ * @param p1 - The second control point.
+ * @param p2 - The third control point.
+ * @param p3 - The fourth control point.
+ * @returns A new `Bezier2d` instance.
+ * @since 1.0.0
+ */
+declare const make$3: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => Bezier2d;
+/**
+ * Creates a new `Bezier2d` instance from an array of control points.
+ *
+ * @param points - The control points.
+ * @returns A new `Bezier2d` instance.
+ * @since 1.0.0
+ */
+declare const fromArray$3: (points: ReadonlyArray<Vector2>) => Bezier2d;
+/**
+ * Checks if a value is a `Bezier2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `Bezier2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isCubicBezier2d: (p: unknown) => p is Bezier2d;
+declare const append$3: {
+  /**
+   * Appends control points to a `Bezier2d`.
+   *
+   * @param p1 - The second control point (first tangent).
+   * @param p2 - The third control point (second tangent).
+   * @param p3 - The fourth control point (end point).
+   * @returns A function that takes a `Bezier2d` and returns a new `Bezier2d` instance with the appended control points.
+   */
+  (p1: Vector2, p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+  /**
+   * Appends control points to a `Bezier2d`.
+   *
+   * @param p - The `Bezier2d` to append the control points to.
+   * @param p1 - The second control point (first tangent).
+   * @param p2 - The third control point (second tangent).
+   * @param p3 - The fourth control point (end point).
+   * @returns A new `Bezier2d` instance with the appended control points.
+   */
+  (p: Bezier2d, p1: Vector2, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendTangentAligned: {
+  /**
+   * Appends control points to a `Bezier2d` with aligned tangents.
+   *
+   * @param ratio - The ratio of the tangents.
+   * @param p2 - The third control point (second tangent).
+   * @param p3 - The fourth control point (end point).
+   * @returns A function that takes a `Bezier2d` and returns a new `Bezier2d` instance with the appended control points.
+   */
+  (ratio: number, p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+  /**
+   * Appends control points to a `Bezier2d` with aligned tangents.
+   *
+   * @param p - The `Bezier2d` to append the control points to.
+   * @param ratio - The ratio of the tangents.
+   * @param p2 - The third control point (second tangent).
+   * @param p3 - The fourth control point (end point).
+   * @returns A new `Bezier2d` instance with the appended control points.
+   */
+  (p: Bezier2d, ratio: number, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendCurvatureAligned: {
+  /**
+   * Appends control points to a `Bezier2d` with aligned curvature (G² continuity).
+   *
+   * @param a - The first curvature parameter.
+   * @param b - The second curvature parameter.
+   * @param p6 - The sixth control point (end point).
+   * @returns A function that takes a `Bezier2d` and returns a new `Bezier2d` instance with the appended control points.
+   */
+  (a: number, b: number, p6: Vector2): (p: Bezier2d) => Bezier2d;
+  /**
+   * Appends control points to a `Bezier2d` with aligned curvature (G² continuity).
+   *
+   * @param p - The `Bezier2d` to append the control points to.
+   * @param a - The first curvature parameter.
+   * @param b - The second curvature parameter.
+   * @param p6 - The sixth control point (end point).
+   * @returns A new `Bezier2d` instance with the appended control points.
+   */
+  (p: Bezier2d, a: number, b: number, p6: Vector2): Bezier2d;
+};
+declare const appendVelocityAligned: {
+  /**
+   * Appends control points to a `Bezier2d` with aligned velocity.
+   *
+   * @param p2 - The second control point (first tangent).
+   * @param p3 - The third control point (second tangent).
+   * @returns A function that takes a `Bezier2d` and returns a new `Bezier2d` instance with the appended control points.
+   */
+  (p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
+  /**
+   * Appends control points to a `Bezier2d` with aligned velocity.
+   *
+   * @param p - The `Bezier2d` to append the control points to.
+   * @param p2 - The second control point (first tangent).
+   * @param p3 - The third control point (second tangent).
+   * @returns A new `Bezier2d` instance with the appended control points.
+   */
+  (p: Bezier2d, p2: Vector2, p3: Vector2): Bezier2d;
+};
+declare const appendAccelerationAligned: {
+  /**
+   * Appends control points to a `Bezier2d` with aligned acceleration.
+   *
+   * @param p3 - The third control point (second tangent).
+   * @returns A function that takes a `Bezier2d` and returns a new `Bezier2d` instance with the appended control points.
+   */
+  (p3: Vector2): (p: Bezier2d) => Bezier2d;
+  /**
+   * Appends control points to a `Bezier2d` with aligned acceleration.
+   *
+   * @param p - The `Bezier2d` to append the control points to.
+   * @param p3 - The third control point (second tangent).
+   * @returns A new `Bezier2d` instance with the appended control points.
+   */
+  (p: Bezier2d, p3: Vector2): Bezier2d;
+};
+/**
+ * Converts a `Bezier2d` to a `CubicPath2d`.
+ *
+ * @param p - The `Bezier2d` to convert.
+ * @returns A new `CubicPath2d` instance representing the same curve as the `Bezier2d`.
+ * @since 1.0.0
+ */
+declare const toPath$3: (p: Bezier2d) => CubicPath2d;
+/**
+ * Attempts to lower a `RationalBezier2d` to a non-rational `Bezier2d`.
+ *
+ * Succeeds with `Solution.one(bezier)` when the rational curve's weights are
+ * uniform (the curve is mathematically a polynomial Bézier) and returns
+ * `Solution.none` otherwise — the rational curve cannot be represented
+ * exactly by a non-rational cubic Bézier.
+ *
+ * @param r - The rational bezier to convert.
+ * @returns Either a `Bezier2d` instance or `Solution.none`.
+ * @since 2.1.0
+ */
+declare const fromRational: (r: RationalBezier2d) => AtMostOne<Bezier2d>;
+declare const subdivide: {
+  /**
+   * Splits a `Bezier2d` at the given global parameter `u ∈ (0, 1)` using
+   * de Casteljau's algorithm. The two returned beziers together trace the
+   * same curve as the input — the left covers `[0, u]`, the right covers
+   * `[u, 1]`.
+   *
+   * @param b - The bezier to split.
+   * @param u - The split parameter in the open interval `(0, 1)`.
+   * @returns A two-element tuple of the left and right halves.
+   * @since 1.1.0
+   */
+  (b: Bezier2d, u: number): [Bezier2d, Bezier2d];
+  /**
+   * Splits a `Bezier2d` at the given global parameter `u ∈ (0, 1)`.
+   *
+   * @param u - The split parameter in the open interval `(0, 1)`.
+   * @returns A function that takes a bezier and returns the two halves.
+   * @since 1.1.0
+   */
+  (u: number): (b: Bezier2d) => [Bezier2d, Bezier2d];
+};
+//#endregion
+//#region src/splines/cardinal2d.internal.d.ts
+declare const Cardinal2dTypeId: unique symbol;
+type Cardinal2dTypeId = typeof Cardinal2dTypeId;
+declare namespace cardinal2d_d_exports {
+  export { Cardinal2d, append$2 as append, fromArray$2 as fromArray, isCardinal2d, make$2 as make, prepend$2 as prepend, toBezier$2 as toBezier, toPath$2 as toPath, withDuplicatedEndpoints, withReflectedEndpoints };
+}
+/**
+ * A Cardinal spline in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The characteristic matrix that identifies this spline family lives in the
+ * `characteristic` module as `Characteristic.cubicCardinal(tension)` (and
+ * the Catmull-Rom variant as `Characteristic.cubicCatmullRom`).
+ *
+ * @since 1.0.0
+ */
+interface Cardinal2d extends Pipeable {
+  readonly [Cardinal2dTypeId]: Cardinal2dTypeId;
+  [Symbol.iterator](): IterableIterator<Vector2>;
+}
+/**
+ * Checks if a value is a `Cardinal2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `Cardinal2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isCardinal2d: (p: unknown) => p is Cardinal2d;
+/**
+ * Creates a new `Cardinal2d` instance.
+ *
+ * @param p0 - The first control point.
+ * @param p1 - The second control point.
+ * @param points - The remaining control points.
+ * @returns A new `Cardinal2d` instance.
+ * @since 1.0.0
+ */
+declare const make$2: (p0: Vector2, p1: Vector2, ...points: ReadonlyArray<Vector2>) => Cardinal2d;
+/**
+ * Creates a new `Cardinal2d` instance from an array of control points.
+ *
+ * @param points - The control points.
+ * @returns A new `Cardinal2d` instance.
+ * @since 1.0.0
+ */
+declare const fromArray$2: (points: ReadonlyArray<Vector2>) => Cardinal2d;
+declare const append$2: {
+  /**
+   * Appends control points to a `Cardinal2d`.
+   *
+   * @param points - The control points to append.
+   * @returns A function that takes a `Cardinal2d` and returns a new `Cardinal2d` instance with the appended control points.
+   * @since 1.0.0
+   */
+  (...points: ReadonlyArray<Vector2>): (c: Cardinal2d) => Cardinal2d;
+  /**
+   * Appends control points to a `Cardinal2d`.
+   *
+   * @param c - The `Cardinal2d` to append the control points to.
+   * @param points - The control points to append.
+   * @returns A new `Cardinal2d` instance with the appended control points.
+   * @since 1.0.0
+   */
+  (c: Cardinal2d, ...points: ReadonlyArray<Vector2>): Cardinal2d;
+};
+declare const prepend$2: {
+  /**
+   * Prepends control points to a `Cardinal2d`.
+   *
+   * @param points - The control points to prepend.
+   * @returns A function that takes a `Cardinal2d` and returns a new `Cardinal2d` instance with the prepended control points.
+   * @since 1.0.0
+   */
+  (...points: ReadonlyArray<Vector2>): (c: Cardinal2d) => Cardinal2d;
+  /**
+   * Prepends control points to a `Cardinal2d`.
+   *
+   * @param c - The `Cardinal2d` to prepend the control points to.
+   * @param points - The control points to prepend.
+   * @returns A new `Cardinal2d` instance with the prepended control points.
+   * @since 1.0.0
+   */
+  (c: Cardinal2d, ...points: ReadonlyArray<Vector2>): Cardinal2d;
+};
+/**
+ * Doubles the endpoints of a `Cardinal2d` spline.
+ *
+ * @param c - The `Cardinal2d` to duplicate the endpoints of.
+ * @returns A new `Cardinal2d` instance with the duplicated endpoints.
+ * @since 1.0.0
+ */
+declare const withDuplicatedEndpoints: (c: Cardinal2d) => Cardinal2d;
+declare const withReflectedEndpoints: {
+  /**
+   * Reflects the endpoints of a `Cardinal2d` spline.
+   *
+   * @param scale - The scale factor for the reflection.
+   * @returns A function that takes a `Cardinal2d` and returns a new `Cardinal2d` instance with the reflected endpoints.
+   * @since 1.0.0
+   */
+  (scale: number): (c: Cardinal2d) => Cardinal2d;
+  /**
+   * Reflects the endpoints of a `Cardinal2d` spline.
+   *
+   * @param c - The `Cardinal2d` to reflect the endpoints of.
+   * @param scale - The scale factor for the reflection.
+   * @returns A new `Cardinal2d` instance with the reflected endpoints.
+   * @since 1.0.0
+   */
+  (c: Cardinal2d, scale?: number): Cardinal2d;
+};
+declare const toPath$2: {
+  /**
+   * Converts a `Cardinal2d` to a `CubicPath2d`.
+   *
+   * @param scale - The scale factor for the conversion.
+   * @returns A Function that takes a `Cardinal2d` and returns a new `CubicPath2d` instance.
+   * @since 1.0.0
+   */
+  (scale: number): (c: Cardinal2d) => CubicPath2d;
+  /**
+   * Converts a `Cardinal2d` to a `CubicPath2d`.
+   *
+   * @param c - The `Cardinal2d` to convert.
+   * @param scale - The scale factor for the conversion.
+   * @returns A new `CubicPath2d` instance representing the same curve as the `Cardinal2d`.
+   * @since 1.0.0
+   */
+  (c: Cardinal2d, scale?: number): CubicPath2d;
+};
+declare const toBezier$2: {
+  /**
+   * Converts a `Cardinal2d` to a `Bezier2d`.
+   *
+   * @param p - The `Cardinal2d` to convert.
+   * @returns A new `Bezier2d` instance representing the same curve as the `Cardinal2d`.
+   * @since 1.0.0
+   */
+  (p: Cardinal2d): Bezier2d;
+  /**
+   * Converts a `Cardinal2d` to a `Bezier2d`.
+   *
+   * @param p - The `Cardinal2d` to convert.
+   * @param scale - The scale factor for the conversion.
+   * @returns A new `Bezier2d` instance representing the same curve as the `Cardinal2d`.
+   * @since 1.0.0
+   */
+  (p: Cardinal2d, scale: number): Bezier2d;
+};
+//#endregion
+//#region src/splines/hermite2d.internal.d.ts
+declare const Hermite2dTypeId: unique symbol;
+type Hermite2dTypeId = typeof Hermite2dTypeId;
+declare namespace hermite2d_d_exports {
+  export { Hermite2d, append$1 as append, fromArray$1 as fromArray, isHermite2d, make$1 as make, prepend$1 as prepend, toBezier$1 as toBezier, toPath$1 as toPath };
+}
+/**
+ * A Hermite spline in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The characteristic matrix that identifies this spline family lives in the
+ * `characteristic` module as `Characteristic.cubicHermite`.
+ *
+ * @since 1.0.0
+ */
+interface Hermite2d extends Pipeable {
+  readonly [Hermite2dTypeId]: Hermite2dTypeId;
+  [Symbol.iterator](): IterableIterator<Vector2>;
+}
+/**
+ * Checks if a value is a `Hermite2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `Hermite2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isHermite2d: (p: unknown) => p is Hermite2d;
+/**
+ * Creates a new `Hermite2d` instance.
+ *
+ * @param p0 - The first control point.
+ * @param v0 - The first tangent vector.
+ * @param p1 - The second control point.
+ * @param v1 - The second tangent vector.
+ * @returns A new `Hermite2d` instance.
+ * @since 1.0.0
+ */
+declare const make$1: (p0: Vector2, v0: Vector2, p1: Vector2, v1: Vector2) => Hermite2d;
+/**
+ * Creates a new `Hermite2d` instance from an array of control points.
+ *
+ * @param points - The control points.
+ * @returns A new `Hermite2d` instance.
+ * @since 1.0.0
+ */
+declare const fromArray$1: (points: ReadonlyArray<Vector2>) => Hermite2d;
+declare const append$1: {
+  /**
+   * Appends a new control point and tangent vector to the Hermite spline.
+   *
+   * @param p1 - The new control point.
+   * @param v1 - The new tangent vector.
+   * @returns A new `Hermite2d` instance with the appended control point and tangent vector.
+   * @since 1.0.0
+   */
+  (p1: Vector2, v1: Vector2): (p: Hermite2d) => Hermite2d;
+  /**
+   * Appends a new control point and tangent vector to the Hermite spline.
+   *
+   * @param p - The `Hermite2d` to append the control point and tangent vector to.
+   * @param p1 - The new control point.
+   * @param v1 - The new tangent vector.
+   * @returns A new `Hermite2d` instance with the appended control point and tangent vector.
+   * @since 1.0.0
+   */
+  (p: Hermite2d, p1: Vector2, v1: Vector2): Hermite2d;
+};
+declare const prepend$1: {
+  /**
+   * Prepends a new control point and tangent vector to the Hermite spline.
+   *
+   * @param p0 - The new control point.
+   * @param v0 - The new tangent vector.
+   * @returns A new `Hermite2d` instance with the prepended control point and tangent vector.
+   * @since 1.0.0
+   */
+  (p0: Vector2, v0: Vector2): (p: Hermite2d) => Hermite2d;
+  /**
+   * Prepends a new control point and tangent vector to the Hermite spline.
+   *
+   * @param p - The `Hermite2d` to prepend the control point and tangent vector to.
+   * @param p0 - The new control point.
+   * @param v0 - The new tangent vector.
+   * @returns A new `Hermite2d` instance with the prepended control point and tangent vector.
+   * @since 1.0.0
+   */
+  (p: Hermite2d, p0: Vector2, v0: Vector2): Hermite2d;
+};
+/**
+ * Creates a new `CubicPath2d` instance from a `Hermite2d`.
+ *
+ * @param p - The `Hermite2d` to convert.
+ * @returns A new `CubicPath2d` instance.
+ * @since 1.0.0
+ */
+declare const toPath$1: (p: Hermite2d) => CubicPath2d;
+/**
+ * Converts a `Hermite2d` to a `Bezier2d`.
+ *
+ * @param p - The `Hermite2d` to convert.
+ * @returns A new `Bezier2d` instance.
+ * @since 1.0.0
+ */
+declare const toBezier$1: (p: Hermite2d) => Bezier2d;
+//#endregion
+//#region src/splines/basis2d.internal.d.ts
+declare const Basis2dTypeId: unique symbol;
+type Basis2dTypeId = typeof Basis2dTypeId;
+declare namespace basis2d_d_exports {
+  export { Basis2d, append, fromArray, isBasis2d, make, prepend, toBezier, toPath, withTriplicatedEndpoints };
+}
+/**
+ * A Basis Spline (uniform cubic B-spline) in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The characteristic matrix that identifies this spline family lives in the
+ * `characteristic` module as `Characteristic.cubicBasisSpline`.
+ *
+ * @since 1.0.0
+ */
+interface Basis2d extends Pipeable {
+  readonly [Basis2dTypeId]: Basis2dTypeId;
+  [Symbol.iterator](): Iterator<Vector2>;
+}
+/**
+ * Checks if a value is a `Basis2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `Basis2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isBasis2d: (p: unknown) => p is Basis2d;
+/**
+ * Creates a new `Basis2d` instance.
+ *
+ * @param p0 - The first control point.
+ * @param p1 - The second control point.
+ * @param p2 - The third control point.
+ * @param p3 - The fourth control point.
+ * @returns A new `Basis2d` instance.
+ * @since 1.0.0
+ */
+declare const make: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => Basis2d;
+/**
+ * Creates a new `Basis2d` instance from an array of control points.
+ *
+ * @param points - The control points.
+ * @returns A new `Basis2d` instance.
+ * @since 1.0.0
+ */
+declare const fromArray: (points: ReadonlyArray<Vector2>) => Basis2d;
+declare const append: {
+  /**
+   * Appends control points to a `Basis2d`.
+   *
+   * @param points - The control points to append.
+   * @returns A function that takes a `Basis2d` and returns a new `Basis2d` instance with the appended control points.
+   * @since 1.0.0
+   */
+  (...points: ReadonlyArray<Vector2>): (p: Basis2d) => Basis2d;
+  /**
+   * Appends control points to a `Basis2d`.
+   *
+   * @param p - The `Basis2d` to append the control points to.
+   * @param points - The control points to append.
+   * @returns A new `Basis2d` instance with the appended control points.
+   * @since 1.0.0
+   */
+  (p: Basis2d, ...points: ReadonlyArray<Vector2>): Basis2d;
+};
+declare const prepend: {
+  /**
+   * Prepends control points to a `Basis2d`.
+   *
+   * @param points - The control points to prepend.
+   * @returns A function that takes a `Basis2d` and returns a new `Basis2d` instance with the prepended control points.
+   * @since 1.0.0
+   */
+  (...points: ReadonlyArray<Vector2>): (p: Basis2d) => Basis2d;
+  /**
+   * Prepends control points to a `Basis2d`.
+   *
+   * @param p - The `Basis2d` to prepend the control points to.
+   * @param points - The control points to prepend.
+   * @returns A new `Basis2d` instance with the prepended control points.
+   * @since 1.0.0
+   */
+  (p: Basis2d, ...points: ReadonlyArray<Vector2>): Basis2d;
+};
+/**
+ * Triplicates the endpoints of a `Basis2d`.
+ *
+ * This is useful for creating a closed loop spline.
+ *
+ * @param p - The `Basis2d` to triplicate the endpoints of.
+ * @returns A new `Basis2d` instance with the triplicated endpoints.
+ * @since 1.0.0
+ */
+declare const withTriplicatedEndpoints: (p: Basis2d) => Basis2d;
+/**
+ * Creates a new `Path2d` from a `Basis2d`.
+ *
+ * @param p - The `Basis2d` to convert to a `Path2d`.
+ * @returns A new `Path2d` instance.
+ * @since 1.0.0
+ */
+declare const toPath: (p: Basis2d) => CubicPath2d;
+/**
+ * Converts a `Basis2d` to a `Bezier2d`.
+ *
+ * @param p - The `Basis2d` to convert.
+ * @returns A new `Bezier2d` instance.
+ * @since 1.0.0
+ */
+declare const toBezier: (p: Basis2d) => Bezier2d;
+//#endregion
+export { basis2d_d_exports as Basis2d, bezier2d_d_exports as Bezier2d, cardinal2d_d_exports as Cardinal2d, hermite2d_d_exports as Hermite2d, rationalBezier2d_d_exports as RationalBezier2d };
+//# sourceMappingURL=index.d.mts.map