curvy 1.0.9 → 2.0.0-alpha.10

package/dist/characteristic/characteristic.d.ts

@@ -0,0 +1,80 @@
+import * as Matrix4x4 from '../matrix/matrix4x4.ts';
+import * as CubicPolynomial from '../polynomial/cubic.ts';
+import type * as Vector4 from '../vector/vector4.ts';
+/**
+ * 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.0.0
+ */
+export declare const cubicBezier: Matrix4x4.Matrix4x4;
+/**
+ * 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.0.0
+ */
+export declare const cubicHermite: Matrix4x4.Matrix4x4;
+/**
+ * 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.0.0
+ */
+export declare const cubicBasisSpline: Matrix4x4.Matrix4x4;
+/**
+ * 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.0.0
+ */
+export declare const cubicCardinal: (tension: number) => Matrix4x4.Matrix4x4;
+/**
+ * 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.0.0
+ */
+export declare const cubicCatmullRom: Matrix4x4.Matrix4x4;
+/**
+ * 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.0.0
+ */
+export declare const apply: <const Channels extends ReadonlyArray<Vector4.Vector4>>(matrix: Matrix4x4.Matrix4x4, ...channels: Channels) => { readonly [K in keyof Channels]: CubicPolynomial.CubicPolynomial; };

package/dist/characteristic/index.d.ts

@@ -0,0 +1 @@
+export * as Characteristic from './characteristic.ts';

package/dist/characteristic/index.mjs

@@ -0,0 +1,2 @@
+import { n as characteristic_exports } from "../shared/characteristic-B0VEB_OA.mjs";
+export { characteristic_exports as Characteristic };

package/dist/curve/cubic2d.d.ts

@@ -1,22 +1,25 @@
-import { T as TwoDimensional } from '../shared/curvy.Bf5TIk31.js';
-import { Interval } from '../interval.js';
-import { Pipeable } from '../pipe.js';
-import { C as CubicPolynomial } from '../shared/curvy.Cg8lZVUz.js';
-import { Vector2 } from '../vector/vector2.js';
-import '../vector/vector3.js';
-import '../vector/vector4.js';
-
-declare const CubicCurve2dTypeId: unique symbol;
-type CubicCurve2dTypeId = typeof CubicCurve2dTypeId;
-
+import type { Interval2d } from '../interval/interval2d.ts';
+import type { TwoDimensional } from '../dimensions.ts';
+import type { Closed, Interval } from '../interval/interval.ts';
+import type { Pipeable } from '../utils.ts';
+import type { CubicPolynomial } from '../polynomial/cubic.ts';
+import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
+import type * as Solution from '../solution/solution.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+import type { CubicCurve2dTypeId } from './cubic2d.internal.ts';
+export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts';
 /**
  * A cubic curve in 2D space.
  *
  * All fields are readonly and immutable, and all operations create new instances.
  *
+ * The two type parameters carry the trait sets of the curve's per-axis
+ * polynomials. Refiners check monotonicity over the unit interval `[0, 1]` —
+ * the curve's natural parameter domain.
+ *
  * @since 1.0.0
  */
-interface CubicCurve2d extends Pipeable, TwoDimensional<CubicPolynomial> {
+export interface CubicCurve2d<out XTraits = unknown, out YTraits = unknown> extends Pipeable, TwoDimensional<CubicPolynomial<XTraits>, CubicPolynomial<YTraits>> {
     readonly [CubicCurve2dTypeId]: CubicCurve2dTypeId;
 }
 /**
@@ -27,18 +30,38 @@ interface CubicCurve2d extends Pipeable, TwoDimensional<CubicPolynomial> {
  * @returns A new `CubicCurve2d` instance.
  * @since 1.0.0
  */
-declare const fromPolynomials: (x: CubicPolynomial, y: CubicPolynomial) => CubicCurve2d;
+export declare const fromPolynomials: (x: CubicPolynomial, y: CubicPolynomial) => CubicCurve2d;
 /**
- * Creates a new `CubicCurve2d` instance from pairs of coefficients.
+ * Creates a new `CubicCurve2d` instance from monomial coefficient vectors.
+ *
+ * Each argument bundles the per-axis coefficient at the given power: `c0`
+ * holds the x⁰ term, `c1` holds the x¹ term, and so on. The resulting curve
+ * evaluates to `c0 + c1·t + c2·t² + c3·t³` per axis.
  *
- * @param p0 - The x^0 coefficients for the x and y polynomials.
- * @param p1 - The x^1 coefficients for the x and y polynomials.
- * @param p2 - The x^2 coefficients for the x and y polynomials.
- * @param p3 - The x^3 coefficients for the x and y polynomials.
+ * @param c0 - The x⁰ coefficients (x and y).
+ * @param c1 - The x¹ coefficients (x and y).
+ * @param c2 - The x² coefficients (x and y).
+ * @param c3 - The x³ coefficients (x and y).
  * @returns A new `CubicCurve2d` instance.
- * @since 1.0.0
+ * @since 2.0.0
+ */
+export declare const fromCoefficients: (c0: Vector2, c1: Vector2, c2: Vector2, c3: Vector2) => CubicCurve2d;
+/**
+ * Creates a new `CubicCurve2d` instance from cubic Bézier control points.
+ *
+ * The four arguments are the Bernstein-basis control points: `p0` and `p3` are
+ * the curve's endpoints and `p1` and `p2` are the off-curve control handles.
+ * The implementation converts to the curve's internal monomial form in closed
+ * form.
+ *
+ * @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 `CubicCurve2d` instance whose curve matches the given Bézier.
+ * @since 2.0.0
  */
-declare const fromPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => CubicCurve2d;
+export declare const fromBezierPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => CubicCurve2d;
 /**
  * Checks if a value is a `CubicCurve2d`.
  *
@@ -46,8 +69,8 @@ declare const fromPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) =
  * @returns `true` if the value is a `CubicCurve2d`, `false` otherwise.
  * @since 1.0.0
  */
-declare const isCubicCurve2d: (c: unknown) => c is CubicCurve2d;
-declare const solve: {
+export declare const isCubicCurve2d: (c: unknown) => c is CubicCurve2d;
+export declare const solve: {
     /**
      * Solves the cubic curve for a given parameter t.
      *
@@ -66,7 +89,7 @@ declare const solve: {
      */
     (c: CubicCurve2d, t: number): Vector2;
 };
-declare const length: {
+export declare const length: {
     /**
      * Calculates (approximates) the length of a cubic curve.
      *
@@ -85,7 +108,63 @@ declare const length: {
      */
     (i: Interval): (c: CubicCurve2d) => number;
 };
-declare const curvature: {
+export declare const solveAtX: {
+    /**
+     * Evaluates the curve's y values at a given x. Because the x polynomial is
+     * `Monotonic`, the inverse has at most one solution — at most one y value.
+     *
+     * @param c - The cubic curve.
+     * @param x - The x coordinate.
+     * @returns Zero or one y values, in t-ascending order.
+     * @since 2.0.0
+     */
+    <XT extends Monotonic, YT>(c: CubicCurve2d<XT, YT>, x: number): Solution.AtMostOne<number>;
+    /**
+     * Evaluates the curve's y values at a given x. The result is the y values
+     * the curve passes through where x(t) = the given x — up to three solutions
+     * for a cubic curve.
+     *
+     * @param c - The cubic curve.
+     * @param x - The x coordinate.
+     * @returns The y values at x, in t-ascending order.
+     * @since 2.0.0
+     */
+    <XT, YT>(c: CubicCurve2d<XT, YT>, x: number): Solution.AtMostThree<number>;
+    /** @since 2.0.0 */
+    (x: number): {
+        <XT extends Monotonic, YT>(c: CubicCurve2d<XT, YT>): Solution.AtMostOne<number>;
+        <XT, YT>(c: CubicCurve2d<XT, YT>): Solution.AtMostThree<number>;
+    };
+};
+export declare const solveAtY: {
+    /**
+     * Evaluates the curve's x values at a given y. Because the y polynomial is
+     * `Monotonic`, the inverse has at most one solution.
+     *
+     * @param c - The cubic curve.
+     * @param y - The y coordinate.
+     * @returns Zero or one x values, in t-ascending order.
+     * @since 2.0.0
+     */
+    <XT, YT extends Monotonic>(c: CubicCurve2d<XT, YT>, y: number): Solution.AtMostOne<number>;
+    /**
+     * Evaluates the curve's x values at a given y. The result is the x values
+     * the curve passes through where y(t) = the given y — up to three solutions
+     * for a cubic curve.
+     *
+     * @param c - The cubic curve.
+     * @param y - The y coordinate.
+     * @returns The x values at y, in t-ascending order.
+     * @since 2.0.0
+     */
+    <XT, YT>(c: CubicCurve2d<XT, YT>, y: number): Solution.AtMostThree<number>;
+    /** @since 2.0.0 */
+    (y: number): {
+        <XT, YT extends Monotonic>(c: CubicCurve2d<XT, YT>): Solution.AtMostOne<number>;
+        <XT, YT>(c: CubicCurve2d<XT, YT>): Solution.AtMostThree<number>;
+    };
+};
+export declare const curvature: {
     /**
      * Calculates the curvature of a cubic curve at a given parameter.
      *
@@ -104,6 +183,33 @@ declare const curvature: {
      */
     (t: number): (c: CubicCurve2d) => number;
 };
-
-export { curvature, fromPoints, fromPolynomials, isCubicCurve2d, length, solve };
-export type { CubicCurve2d };
+/**
+ * Computes the axis-aligned bounding box of the curve over its parameter
+ * domain `[0, 1]`. Accounts for up to two interior extrema per axis, so the
+ * box is tight against the curve and not just the control polygon.
+ *
+ * @param c - The cubic curve.
+ * @returns A closed `Box2d` enclosing the curve.
+ * @since 2.0.0
+ */
+export declare const boundingBox: (c: CubicCurve2d) => Interval2d<Closed, Closed>;
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Monotonic`
+ * when both x and y polynomials are monotonic over the unit interval `[0, 1]`.
+ *
+ * For checking only one axis, call the polynomial-level refiner directly:
+ * `CubicPolynomial.isMonotonic(curve.x, Interval.unit)`.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonic: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Monotonic, YT & Monotonic>;
+/** @since 2.0.0 */
+export declare const isIncreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Increasing, YT & Increasing>;
+/** @since 2.0.0 */
+export declare const isDecreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Decreasing, YT & Decreasing>;
+/** @since 2.0.0 */
+export declare const asMonotonic: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Monotonic, YT & Monotonic>;
+/** @since 2.0.0 */
+export declare const asIncreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Increasing, YT & Increasing>;
+/** @since 2.0.0 */
+export declare const asDecreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Decreasing, YT & Decreasing>;

package/dist/curve/cubic2d.internal.d.ts

@@ -0,0 +1,2 @@
+export declare const CubicCurve2dTypeId: unique symbol;
+export type CubicCurve2dTypeId = typeof CubicCurve2dTypeId;

package/dist/curve/index.d.ts

@@ -0,0 +1,12 @@
+import * as LinearCurve2dNs from './linear2d.ts';
+import * as QuadraticCurve2dNs from './quadratic2d.ts';
+import * as CubicCurve2dNs from './cubic2d.ts';
+import * as RationalCubicCurve2dNs from './rationalCubic2d.ts';
+export type LinearCurve2d<XTraits = unknown, YTraits = unknown> = LinearCurve2dNs.LinearCurve2d<XTraits, YTraits>;
+export { LinearCurve2dNs as LinearCurve2d };
+export type QuadraticCurve2d<XTraits = unknown, YTraits = unknown> = QuadraticCurve2dNs.QuadraticCurve2d<XTraits, YTraits>;
+export { QuadraticCurve2dNs as QuadraticCurve2d };
+export type CubicCurve2d<XTraits = unknown, YTraits = unknown> = CubicCurve2dNs.CubicCurve2d<XTraits, YTraits>;
+export { CubicCurve2dNs as CubicCurve2d };
+export type RationalCubicCurve2d<XTraits = unknown, YTraits = unknown> = RationalCubicCurve2dNs.RationalCubicCurve2d<XTraits, YTraits>;
+export { RationalCubicCurve2dNs as RationalCubicCurve2d };

package/dist/curve/index.mjs

@@ -0,0 +1,2 @@
+import { S as linear2d_exports, g as quadratic2d_exports, o as cubic2d_exports, r as rationalCubic2d_exports } from "../shared/rationalCubic2d-3S5K69Jy.mjs";
+export { cubic2d_exports as CubicCurve2d, linear2d_exports as LinearCurve2d, quadratic2d_exports as QuadraticCurve2d, rationalCubic2d_exports as RationalCubicCurve2d };

package/dist/curve/linear2d.d.ts

@@ -1,22 +1,25 @@
-import { T as TwoDimensional } from '../shared/curvy.Bf5TIk31.js';
-import { Interval } from '../interval.js';
-import { Pipeable } from '../pipe.js';
-import { L as LinearPolynomial } from '../shared/curvy.Cg8lZVUz.js';
-import { Vector2 } from '../vector/vector2.js';
-import '../vector/vector3.js';
-import '../vector/vector4.js';
-
-declare const LinearCurve2dTypeId: unique symbol;
-type LinearCurve2dTypeId = typeof LinearCurve2dTypeId;
-
+import type { Interval2d } from '../interval/interval2d.ts';
+import type { TwoDimensional } from '../dimensions.ts';
+import type { Closed, Interval } from '../interval/interval.ts';
+import type { Pipeable } from '../utils.ts';
+import type { LinearPolynomial } from '../polynomial/linear.ts';
+import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
+import type * as Solution from '../solution/solution.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+import type { LinearCurve2dTypeId } from './linear2d.internal.ts';
+export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts';
 /**
  * A linear curve in 2D space.
  *
  * All fields are readonly and immutable, and all operations create new instances.
  *
+ * The two type parameters carry the trait sets of the curve's per-axis
+ * polynomials. Refiners like `isMonotonic` lift each axis's monotonicity into
+ * the curve's combined trait set.
+ *
  * @since 1.0.0
  */
-interface LinearCurve2d extends Pipeable, TwoDimensional<LinearPolynomial> {
+export interface LinearCurve2d<out XTraits = unknown, out YTraits = unknown> extends Pipeable, TwoDimensional<LinearPolynomial<XTraits>, LinearPolynomial<YTraits>> {
     readonly [LinearCurve2dTypeId]: LinearCurve2dTypeId;
 }
 /**
@@ -27,14 +30,33 @@ interface LinearCurve2d extends Pipeable, TwoDimensional<LinearPolynomial> {
  * @returns A new `LinearCurve2d` instance.
  * @since 1.0.0
  */
-declare const fromPolynomials: (x: LinearPolynomial, y: LinearPolynomial) => LinearCurve2d;
+export declare const fromPolynomials: (x: LinearPolynomial, y: LinearPolynomial) => LinearCurve2d;
+/**
+ * Creates a new `LinearCurve2d` instance from monomial coefficient vectors.
+ *
+ * Each argument bundles the per-axis coefficient at the given power: `c0`
+ * holds the x⁰ term, `c1` holds the x¹ term. The resulting curve evaluates to
+ * `c0 + c1·t` per axis.
+ *
+ * @param c0 - The x⁰ coefficients (x and y).
+ * @param c1 - The x¹ coefficients (x and y).
+ * @returns A new `LinearCurve2d` instance.
+ * @since 2.0.0
+ */
+export declare const fromCoefficients: (c0: Vector2, c1: Vector2) => LinearCurve2d;
 /**
- * Creates a new `LinearCurve2d` instance from pairs of coefficients.
+ * Creates a new `LinearCurve2d` instance from a pair of endpoints.
+ *
+ * `p0` is the curve at `t = 0`, `p1` is the curve at `t = 1`. The
+ * implementation converts to the curve's internal monomial form (slope-form
+ * polynomial in `t`) in closed form.
  *
- * @param p0 - The x^0 coefficients for the x and y polynomials.
- * @param p1 - The x^1 coefficients for the x and y polynomials.
+ * @param p0 - The curve's start point.
+ * @param p1 - The curve's end point.
+ * @returns A new `LinearCurve2d` instance whose curve matches the line from `p0` to `p1`.
+ * @since 2.0.0
  */
-declare const fromPoints: (p0: Vector2, p1: Vector2) => LinearCurve2d;
+export declare const fromEndpoints: (p0: Vector2, p1: Vector2) => LinearCurve2d;
 /**
  * Checks if a value is a `LinearCurve2d`.
  *
@@ -42,7 +64,7 @@ declare const fromPoints: (p0: Vector2, p1: Vector2) => LinearCurve2d;
  * @returns `true` if the value is a `LinearCurve2d`, `false` otherwise.
  * @since 1.0.0
  */
-declare const isLinearCurve2d: (c: unknown) => c is LinearCurve2d;
+export declare const isLinearCurve2d: (c: unknown) => c is LinearCurve2d;
 /**
  * Gets the derivative of a linear curve as a vector
  *
@@ -50,8 +72,8 @@ declare const isLinearCurve2d: (c: unknown) => c is LinearCurve2d;
  * @returns The derivative of the linear curve as a vector.
  * @since 1.0.0
  */
-declare const derivative: (c: LinearCurve2d) => Vector2;
-declare const solve: {
+export declare const derivative: (c: LinearCurve2d) => Vector2;
+export declare const solve: {
     /**
      * Solves the linear curve for a given parameter t.
      *
@@ -70,7 +92,7 @@ declare const solve: {
      */
     (c: LinearCurve2d, t: number): Vector2;
 };
-declare const length: {
+export declare const length: {
     /**
      * Calculates (approximates) the length of a linear curve.
      *
@@ -89,6 +111,85 @@ declare const length: {
      */
     (i: Interval): (c: LinearCurve2d) => number;
 };
-
-export { derivative, fromPoints, fromPolynomials, isLinearCurve2d, length, solve };
-export type { LinearCurve2d };
+/**
+ * Computes the axis-aligned bounding box of the curve over its parameter
+ * domain `[0, 1]`. For a linear curve this is the closed box enclosing the
+ * two endpoints.
+ *
+ * @param c - The linear curve.
+ * @returns A closed `Box2d` enclosing the curve.
+ * @since 2.0.0
+ */
+export declare const boundingBox: (c: LinearCurve2d) => Interval2d<Closed, Closed>;
+export declare const solveAtX: {
+    /**
+     * Evaluates the curve's y value at a given x. A linear curve crosses any
+     * vertical line at most once (within the curve's parameter domain `[0, 1]`),
+     * so the result is at most one y. Returns the empty tuple when x is outside
+     * the curve's range or when the curve's x polynomial is constant.
+     *
+     * @param c - The linear curve.
+     * @param x - The x coordinate.
+     * @returns The y value at x, or empty when x is undefined for this curve.
+     * @since 2.0.0
+     */
+    <XT, YT>(c: LinearCurve2d<XT, YT>, x: number): Solution.AtMostOne<number>;
+    /** @since 2.0.0 */
+    (x: number): <XT, YT>(c: LinearCurve2d<XT, YT>) => Solution.AtMostOne<number>;
+};
+export declare const solveAtY: {
+    /**
+     * Evaluates the curve's x value at a given y. A linear curve crosses any
+     * horizontal line at most once (within the curve's parameter domain
+     * `[0, 1]`), so the result is at most one x.
+     *
+     * @param c - The linear curve.
+     * @param y - The y coordinate.
+     * @returns The x value at y, or empty when y is undefined for this curve.
+     * @since 2.0.0
+     */
+    <XT, YT>(c: LinearCurve2d<XT, YT>, y: number): Solution.AtMostOne<number>;
+    /** @since 2.0.0 */
+    (y: number): <XT, YT>(c: LinearCurve2d<XT, YT>) => Solution.AtMostOne<number>;
+};
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Monotonic`
+ * when both the x and y polynomials are strictly monotonic. When both axes
+ * are monotonic, the curve is invertible in either direction.
+ *
+ * For checking only one axis, call the polynomial-level refiner directly:
+ * `LinearPolynomial.isMonotonic(curve.x)`.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonic: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Monotonic, YT & Monotonic>;
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Increasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isIncreasing: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Increasing, YT & Increasing>;
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Decreasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isDecreasing: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Decreasing, YT & Decreasing>;
+/**
+ * Asserts monotonicity in both axes, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+export declare const asMonotonic: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearCurve2d<XT & Monotonic, YT & Monotonic>;
+/**
+ * Asserts that both axes are strictly increasing, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+export declare const asIncreasing: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearCurve2d<XT & Increasing, YT & Increasing>;
+/**
+ * Asserts that both axes are strictly decreasing, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+export declare const asDecreasing: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearCurve2d<XT & Decreasing, YT & Decreasing>;

package/dist/curve/linear2d.internal.d.ts

@@ -0,0 +1,2 @@
+export declare const LinearCurve2dTypeId: unique symbol;
+export type LinearCurve2dTypeId = typeof LinearCurve2dTypeId;