curvy 2.0.0-alpha.2 → 2.0.0-alpha.5

package/dist/path/rationalCubic2d.d.ts

@@ -0,0 +1,120 @@
+import type { RationalCubicCurve2d } from '../curve/rationalCubic2d';
+import type { Pipeable } from '../utils';
+import type { Vector2 } from '../vector/vector2';
+import type { CubicPath2d } from './cubic2d';
+
+declare const RationalCubicPath2dTypeId: unique symbol;
+type RationalCubicPath2dTypeId = typeof RationalCubicPath2dTypeId;
+
+
+/**
+ * A rational cubic path in 2D space.
+ *
+ * Holds a non-empty sequence of `RationalCubicCurve2d` segments; iteration
+ * yields the segments in order. The path parameter `u ∈ [0, 1]` is mapped
+ * uniformly across segments — `u = 0` is the start of the first segment,
+ * `u = 1` is the end of the last segment, and intermediate values pick a
+ * segment by index and a local parameter within it.
+ *
+ * Counterpart to `CubicPath2d` for curves whose evaluation includes the
+ * homogeneous-to-plane projection.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 2.0.0
+ */
+export interface RationalCubicPath2d extends Pipeable, Iterable<RationalCubicCurve2d> {
+    readonly [RationalCubicPath2dTypeId]: RationalCubicPath2dTypeId;
+}
+/**
+ * Checks if a value is a `RationalCubicPath2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `RationalCubicPath2d`, `false` otherwise.
+ * @since 2.0.0
+ */
+export declare const isRationalCubicPath2d: (p: unknown) => p is RationalCubicPath2d;
+/**
+ * Creates a new `RationalCubicPath2d` from a sequence of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `RationalCubicPath2d` instance.
+ * @since 2.0.0
+ */
+export declare const make: (...curves: ReadonlyArray<RationalCubicCurve2d>) => RationalCubicPath2d;
+/**
+ * Creates a new `RationalCubicPath2d` from an array of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `RationalCubicPath2d` instance.
+ * @since 2.0.0
+ */
+export declare const fromArray: (curves: ReadonlyArray<RationalCubicCurve2d>) => RationalCubicPath2d;
+export declare const append: {
+    /**
+     * Appends a curve to a `RationalCubicPath2d`.
+     *
+     * @param c - The curve to append.
+     * @returns A function that takes a path and returns a new path with the appended curve.
+     * @since 2.0.0
+     */
+    (c: RationalCubicCurve2d): (p: RationalCubicPath2d) => RationalCubicPath2d;
+    /**
+     * Appends a curve to a `RationalCubicPath2d`.
+     *
+     * @param p - The path to append to.
+     * @param c - The curve to append.
+     * @returns A new path with the appended curve.
+     * @since 2.0.0
+     */
+    (p: RationalCubicPath2d, c: RationalCubicCurve2d): RationalCubicPath2d;
+};
+export declare const solve: {
+    /**
+     * Evaluates the rational cubic path at parameter `u ∈ [0, 1]`.
+     *
+     * Picks the segment containing `u` (uniform mapping across segments) and
+     * delegates to `RationalCubicCurve2d.solve` on that segment with the local
+     * parameter.
+     *
+     * @param p - The path to evaluate.
+     * @param u - The path parameter in `[0, 1]`.
+     * @returns The point on the path at parameter `u`.
+     * @since 2.0.0
+     */
+    (p: RationalCubicPath2d, u: number): Vector2;
+    /**
+     * Evaluates the rational cubic path at parameter `u ∈ [0, 1]`.
+     *
+     * @param u - The path parameter in `[0, 1]`.
+     * @returns A function that takes a path and returns the point at `u`.
+     * @since 2.0.0
+     */
+    (u: number): (p: RationalCubicPath2d) => Vector2;
+};
+export declare const approximateAsCubicPath: {
+    /**
+     * Approximates the rational cubic path as a `CubicPath2d` via per-segment
+     * recursive subdivision. Each input segment is split until its midpoint
+     * deviates from a polynomial-cubic candidate by at most `tolerance`; the
+     * surviving candidates are concatenated into a new path.
+     *
+     * Lossy in general — only exact when every input segment has uniform
+     * weights, in which case segment count is preserved. Tighter tolerance
+     * produces more segments.
+     *
+     * @param p - The rational cubic path to approximate.
+     * @param tolerance - Maximum allowed midpoint deviation per segment; must be positive.
+     * @returns A new `CubicPath2d` approximating the input.
+     * @since 2.0.0
+     */
+    (p: RationalCubicPath2d, tolerance: number): CubicPath2d;
+    /**
+     * Approximates the rational cubic path as a `CubicPath2d`.
+     *
+     * @param tolerance - Maximum allowed midpoint deviation per segment; must be positive.
+     * @returns A function that takes a rational path and returns its approximation.
+     * @since 2.0.0
+     */
+    (tolerance: number): (p: RationalCubicPath2d) => CubicPath2d;
+};

package/dist/path/traits.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Trait brands for paths.
+ *
+ * Brands are phantom types — they exist only at the type level and carry no
+ * runtime data. Refiners (`isContinuous`) and assertions (`asContinuous`) on
+ * each path module attach these brands to the path's `Trait` parameter at the
+ * type level.
+ *
+ * @since 2.0.0
+ */
+declare const ContinuousId: unique symbol;
+/**
+ * Brand for paths whose adjacent curves connect at their join points (G⁰
+ * continuity). Calling `toPathData` on a `Continuous` path skips the
+ * per-segment discontinuity check and emits a single `M` followed by drawing
+ * commands.
+ *
+ * @since 2.0.0
+ */
+export type Continuous = {
+    readonly [ContinuousId]: 'continuous';
+};
+/**
+ * Phantom property key used by path interfaces to hold their `Trait` type
+ * parameter. The runtime object never has a value at this key.
+ *
+ * @since 2.0.0
+ */
+export declare const PathTraits: unique symbol;
+export type PathTraits = typeof PathTraits;
+export {};

package/dist/polynomial/cubic.d.ts

@@ -0,0 +1,381 @@
+import type { Closed, Interval } from '../interval/interval';
+import type { Pipeable } from '../utils';
+import type * as Solution from '../solution/solution';
+import type { Vector2 } from '../vector/vector2';
+import type { Vector4 } from '../vector/vector4';
+
+import type { Monotonicity } from './monotonicity';
+import type { QuadraticPolynomial } from './quadratic';
+import type { Decreasing, Increasing, Monotonic, PolynomialTraits } from './traits';
+
+declare const CubicPolynomialTypeId: unique symbol;
+type CubicPolynomialTypeId = typeof CubicPolynomialTypeId;
+
+export type { Monotonic, Increasing, Decreasing } from './traits';
+/**
+ * A cubic polynomial.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The `Traits` type parameter is a phantom marker that accumulates trait
+ * brands as the polynomial is refined via `isMonotonic` / `asMonotonic` and
+ * friends. A cubic is monotonic only over an interval that avoids both of its
+ * extrema (or globally, when c2 = c3 = 0 and c1 ≠ 0).
+ *
+ * @since 1.0.0
+ */
+export interface CubicPolynomial<out Traits = unknown> extends Pipeable {
+    readonly [CubicPolynomialTypeId]: CubicPolynomialTypeId;
+    readonly [PolynomialTraits]: Traits;
+    /**
+     * The coefficient of the x^0 term.
+     */
+    readonly c0: number;
+    /**
+     * The coefficient of the x^1 term.
+     */
+    readonly c1: number;
+    /**
+     * The coefficient of the x^2 term.
+     */
+    readonly c2: number;
+    /**
+     * The coefficient of the x^3 term.
+     */
+    readonly c3: number;
+}
+/**
+ * Checks if a value is a `CubicPolynomial`.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a `CubicPolynomial`, `false` otherwise.
+ * @since 1.0.0
+ */
+export declare const isCubicPolynomial: (value: unknown) => value is CubicPolynomial;
+export declare const equals: {
+    /**
+     * Checks if two `CubicPolynomial` instances are approximately equal within
+     * the default absolute tolerance ({@link EPSILON}).
+     *
+     * @param a - The first polynomial.
+     * @param b - The second polynomial.
+     * @returns `true` when each pair of coefficients is within tolerance.
+     * @since 1.1.0
+     */
+    (a: CubicPolynomial, b: CubicPolynomial): boolean;
+    /**
+     * Checks if two `CubicPolynomial` instances are approximately equal within
+     * the default absolute tolerance ({@link EPSILON}).
+     *
+     * @param b - The second polynomial.
+     * @returns A function that takes the first polynomial and returns the comparison result.
+     * @since 1.1.0
+     */
+    (b: CubicPolynomial): (a: CubicPolynomial) => boolean;
+};
+/**
+ * Creates a new `CubicPolynomial` instance.
+ *
+ * @param c0 - The coefficient of the x^0 term.
+ * @param c1 - The coefficient of the x^1 term.
+ * @param c2 - The coefficient of the x^2 term.
+ * @param c3 - The coefficient of the x^3 term.
+ */
+export declare const make: (c0: number, c1: number, c2: number, c3: number) => CubicPolynomial;
+/**
+ * Creates a new `CubicPolynomial` instance from a vector.
+ *
+ * @param v - The vector to convert.
+ * @returns A new `CubicPolynomial` instance.
+ * @since 1.0.0
+ */
+export declare const fromVector: (v: Vector4) => CubicPolynomial;
+/**
+ * Creates a new `CubicPolynomial` that interpolates the four given points,
+ * treating each `Vector2` as an `(x, y)` pair. The four input `x` values must
+ * be distinct.
+ *
+ * @param p0 - The first point.
+ * @param p1 - The second point.
+ * @param p2 - The third point.
+ * @param p3 - The fourth point.
+ * @returns The unique cubic polynomial passing through the four points.
+ * @since 2.0.0
+ */
+export declare const fromPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => CubicPolynomial;
+export declare const solve: {
+    /**
+     * Solves a cubic polynomial for a given value of x.
+     *
+     * @param p - The cubic polynomial to solve.
+     * @param x - The value of x to solve for.
+     * @returns The result of the polynomial evaluation at x.
+     * @since 1.0.0
+     */
+    (p: CubicPolynomial, x: number): number;
+    /**
+     * Solves a cubic polynomial for a given value of x.
+     *
+     * @param x - The value of x to solve for.
+     * @returns A function that takes a cubic polynomial and returns the result of the polynomial evaluation at x.
+     * @since 1.0.0
+     */
+    (x: number): (p: CubicPolynomial) => number;
+};
+/**
+ * Converts a cubic polynomial to a solver function.
+ *
+ * @param p - The cubic polynomial to convert.
+ * @returns A function that takes a value of x and returns the result of the polynomial evaluation at x.
+ * @since 1.0.0
+ */
+export declare const toSolver: (p: CubicPolynomial) => (x: number) => number;
+export declare const solveInverse: {
+    /**
+     * Solves a monotonic cubic polynomial for a given value of y. Because the
+     * polynomial is strictly monotonic, the inverse has at most one solution.
+     *
+     * @param p - The monotonic cubic polynomial.
+     * @param y - The value of y to solve for.
+     * @returns Zero or one solutions.
+     * @since 2.0.0
+     */
+    <T extends Monotonic>(p: CubicPolynomial<T>, y: number): Solution.AtMostOne<number>;
+    /**
+     * Solves a cubic polynomial for a given value of y.
+     *
+     * @param p - The cubic polynomial to solve.
+     * @param y - The value of y to solve for.
+     * @returns The roots of the polynomial equation p(x) = y.
+     * @since 1.0.0
+     */
+    <T>(p: CubicPolynomial<T>, y: number): Solution.AtMostThree<number>;
+    /**
+     * Solves a cubic polynomial for a given value of y.
+     *
+     * @param y - The value of y to solve for.
+     * @returns A function that takes a cubic polynomial and returns the roots
+     *   of the polynomial equation p(x) = y. Tightens to `Solution.AtMostOne<number>` for
+     *   monotonic inputs.
+     * @since 1.0.0
+     */
+    (y: number): {
+        <T extends Monotonic>(p: CubicPolynomial<T>): Solution.AtMostOne<number>;
+        <T>(p: CubicPolynomial<T>): Solution.AtMostThree<number>;
+    };
+};
+/**
+ * Converts a cubic polynomial to an inverse solver function.
+ *
+ * @param p - The cubic polynomial to convert.
+ * @returns A function that takes a value of y and returns the roots of the polynomial equation p(x) = y.
+ * @since 1.0.0
+ */
+export declare const toInverseSolver: (p: CubicPolynomial) => (y: number) => Solution.AtMostThree<number>;
+/**
+ * Returns the polynomial's coefficients as a tuple `[c0, c1, c2, c3]`.
+ *
+ * @param p - The cubic polynomial.
+ * @returns The coefficients in monomial order.
+ * @since 2.0.0
+ */
+export declare const coefficients: (p: CubicPolynomial) => readonly [number, number, number, number];
+/**
+ * Calculates the derivative of a cubic polynomial.
+ *
+ * @param p - The cubic polynomial to differentiate.
+ * @returns The derivative of the cubic polynomial.
+ * @since 1.0.0
+ */
+export declare const derivative: (p: CubicPolynomial) => QuadraticPolynomial;
+export declare const subdivide: {
+    /**
+     * Subdivides a cubic polynomial at parameter `t ∈ (0, 1)` into two new
+     * cubic polynomials. The first polynomial's evaluation on `[0, 1]` matches
+     * the original's on `[0, t]`; the second matches the original's on
+     * `[t, 1]`. Equivalent to de Casteljau subdivision in Bernstein form,
+     * performed directly in monomial form.
+     *
+     * @param p - The cubic polynomial to subdivide.
+     * @param t - The split parameter; must be in the open interval `(0, 1)`.
+     * @returns A `[left, right]` tuple of cubic polynomials.
+     * @since 2.0.0
+     */
+    (p: CubicPolynomial, t: number): [CubicPolynomial, CubicPolynomial];
+    /**
+     * Subdivides a cubic polynomial at parameter `t ∈ (0, 1)`.
+     *
+     * @param t - The split parameter; must be in the open interval `(0, 1)`.
+     * @returns A function that takes a polynomial and returns its `[left, right]` halves.
+     * @since 2.0.0
+     */
+    (t: number): (p: CubicPolynomial) => [CubicPolynomial, CubicPolynomial];
+};
+/**
+ * Calculates the roots of a cubic polynomial.
+ *
+ * @param p - The cubic polynomial to find the roots of.
+ * @returns The roots of the cubic polynomial.
+ * @since 1.0.0
+ */
+export declare const roots: (p: CubicPolynomial) => Solution.AtMostThree<number>;
+/**
+ * Calculates the extrema of a cubic polynomial.
+ *
+ * @param p - The cubic polynomial to find the extrema of.
+ * @returns The extrema of the cubic polynomial.
+ * @since 1.0.0
+ */
+export declare const extrema: (p: CubicPolynomial) => Solution.AtMostTwo<number>;
+export declare const monotonicity: {
+    /**
+     * Calculates the monotonicity of a cubic polynomial. Throws when the
+     * interval has zero width — the question is undefined at a single point.
+     *
+     * @param p - The cubic polynomial to analyze.
+     * @param i - The interval to restrict the analysis to.
+     * @returns The monotonicity of the cubic polynomial in the specified interval.
+     * @since 1.0.0
+     */
+    (p: CubicPolynomial, i?: Interval): Monotonicity;
+    /**
+     * Calculates the monotonicity of a cubic polynomial. Throws when the
+     * interval has zero width.
+     *
+     * @param i - The interval to restrict the analysis to.
+     * @returns A function that takes a cubic polynomial and returns the
+     *   monotonicity of the cubic polynomial in the specified interval.
+     * @since 1.0.0
+     */
+    (i: Interval): (p: CubicPolynomial) => Monotonicity;
+};
+/**
+ * Type-narrowing predicate: refines a `CubicPolynomial<T>` to
+ * `CubicPolynomial<T & Monotonic>` when the polynomial is strictly monotonic
+ * over the given interval (or globally, when no interval is given).
+ *
+ * @param p - The cubic polynomial to check.
+ * @param i - Optional interval over which to check monotonicity.
+ * @returns `true` when monotonicity is `'increasing'` or `'decreasing'`.
+ * @since 2.0.0
+ */
+export declare const isMonotonic: {
+    <T>(p: CubicPolynomial<T>, i?: Interval): p is CubicPolynomial<T & Monotonic>;
+    (i: Interval): <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Monotonic>;
+};
+/**
+ * Type-narrowing predicate: refines to `CubicPolynomial<T & Increasing>`.
+ *
+ * @since 2.0.0
+ */
+export declare const isIncreasing: {
+    <T>(p: CubicPolynomial<T>, i?: Interval): p is CubicPolynomial<T & Increasing>;
+    (i: Interval): <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Increasing>;
+};
+/**
+ * Type-narrowing predicate: refines to `CubicPolynomial<T & Decreasing>`.
+ *
+ * @since 2.0.0
+ */
+export declare const isDecreasing: {
+    <T>(p: CubicPolynomial<T>, i?: Interval): p is CubicPolynomial<T & Decreasing>;
+    (i: Interval): <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Decreasing>;
+};
+/**
+ * Asserts that the cubic polynomial is monotonic, throwing on failure.
+ *
+ * @param p - The cubic polynomial to assert against.
+ * @param i - Optional interval over which to check monotonicity.
+ * @returns The same polynomial, typed with the `Monotonic` brand.
+ * @throws When the polynomial is not monotonic over the given (or global) interval.
+ * @since 2.0.0
+ */
+export declare const asMonotonic: <T>(p: CubicPolynomial<T>, i?: Interval) => CubicPolynomial<T & Monotonic>;
+/**
+ * Asserts that the cubic polynomial is increasing, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+export declare const asIncreasing: <T>(p: CubicPolynomial<T>, i?: Interval) => CubicPolynomial<T & Increasing>;
+/**
+ * Asserts that the cubic polynomial is decreasing, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+export declare const asDecreasing: <T>(p: CubicPolynomial<T>, i?: Interval) => CubicPolynomial<T & Decreasing>;
+export declare const domain: {
+    /**
+     * Calculates the domain of a cubic polynomial.
+     *
+     * @param p - The cubic polynomial to analyze.
+     * @param range - The range to restrict the analysis to.
+     * @returns The domain of the cubic polynomial in the specified range.
+     * @since 1.0.0
+     */
+    (p: CubicPolynomial, range: Interval): Interval;
+    /**
+     * Calculates the domain of a cubic polynomial.
+     *
+     * @param range - The range to restrict the analysis to.
+     * @returns A function that takes a cubic polynomial and returns the domain of the cubic polynomial in the specified range.
+     * @since 1.0.0
+     */
+    (range: Interval): (p: CubicPolynomial) => Interval;
+};
+export declare const range: {
+    /**
+     * Calculates the range of a cubic polynomial.
+     *
+     * @param p - The cubic polynomial to analyze.
+     * @param domain - The domain to restrict the analysis to.
+     * @returns The range of the cubic polynomial in the specified domain.
+     * @since 1.0.0
+     */
+    (p: CubicPolynomial, domain: Interval): Closed;
+    /**
+     * Calculates the range of a cubic polynomial.
+     *
+     * @param domain - The domain to restrict the analysis to.
+     * @returns A function that takes a cubic polynomial and returns the range of the cubic polynomial in the specified domain.
+     * @since 1.0.0
+     */
+    (domain: Interval): (p: CubicPolynomial) => Closed;
+};
+export declare const length: {
+    /**
+     * Calculates the length of a cubic polynomial.
+     *
+     * @param p - The cubic polynomial to analyze.
+     * @param domain - The domain to restrict the analysis to.
+     * @returns The length of the cubic polynomial in the specified domain.
+     * @since 1.0.0
+     */
+    (p: CubicPolynomial, domain: Interval): number;
+    /**
+     * Calculates the length of a cubic polynomial.
+     *
+     * @param domain - The domain to restrict the analysis to.
+     * @returns A function that takes a cubic polynomial and returns the length of the cubic polynomial in the specified domain.
+     * @since 1.0.0
+     */
+    (domain: Interval): (p: CubicPolynomial) => number;
+};
+export declare const curvature: {
+    /**
+     * Calculates the curvature of a cubic polynomial.
+     *
+     * @param p - The cubic polynomial to analyze.
+     * @param x - The value of x to calculate the curvature at.
+     * @returns The curvature of the cubic polynomial at the specified value of x.
+     * @since 1.0.0
+     */
+    (p: CubicPolynomial, x: number): number;
+    /**
+     * Calculates the curvature of a cubic polynomial.
+     *
+     * @param x - The value of x to calculate the curvature at.
+     * @returns A function that takes a cubic polynomial and returns the curvature of the cubic polynomial at the specified value of x.
+     * @since 1.0.0
+     */
+    (x: number): (p: CubicPolynomial) => number;
+};

package/dist/polynomial/index.d.ts

@@ -0,0 +1,9 @@
+import * as LinearPolynomialNs from './linear';
+import * as QuadraticPolynomialNs from './quadratic';
+import * as CubicPolynomialNs from './cubic';
+export { LinearPolynomialNs as LinearPolynomial };
+export type LinearPolynomial = LinearPolynomialNs.LinearPolynomial;
+export { QuadraticPolynomialNs as QuadraticPolynomial };
+export type QuadraticPolynomial = QuadraticPolynomialNs.QuadraticPolynomial;
+export { CubicPolynomialNs as CubicPolynomial };
+export type CubicPolynomial = CubicPolynomialNs.CubicPolynomial;

package/dist/polynomial/index.mjs

@@ -1,3 +1,3 @@
-import { t as cubic_exports } from "../shared/cubic-CpHAx8cC.mjs";
-import { o as quadratic_exports, p as linear_exports } from "../shared/quadratic-CamozcFc.mjs";
+import { t as cubic_exports } from "../shared/cubic-CMonq6bg.mjs";
+import { o as quadratic_exports, p as linear_exports } from "../shared/quadratic-DyeMtvET.mjs";
 export { cubic_exports as CubicPolynomial, linear_exports as LinearPolynomial, quadratic_exports as QuadraticPolynomial };