curvy 2.0.0-alpha.6 → 2.0.0-alpha.8

package/dist/characteristic/{index.d.mts → characteristic.d.ts}

@@ -1,11 +1,6 @@
-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 {
-  export { apply, cubicBasisSpline, cubicBezier, cubicCardinal, cubicCatmullRom, cubicHermite };
-}
+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.
  *
@@ -16,7 +11,7 @@ declare namespace characteristic_d_exports {
  *
  * @since 2.0.0
  */
-declare const cubicBezier: Matrix4x4;
+export declare const cubicBezier: Matrix4x4.Matrix4x4;
 /**
  * The cubic Hermite characteristic matrix.
  *
@@ -25,7 +20,7 @@ declare const cubicBezier: Matrix4x4;
  *
  * @since 2.0.0
  */
-declare const cubicHermite: Matrix4x4;
+export declare const cubicHermite: Matrix4x4.Matrix4x4;
 /**
  * The uniform cubic B-spline (basis spline) characteristic matrix.
  *
@@ -36,7 +31,7 @@ declare const cubicHermite: Matrix4x4;
  *
  * @since 2.0.0
  */
-declare const cubicBasisSpline: Matrix4x4;
+export declare const cubicBasisSpline: Matrix4x4.Matrix4x4;
 /**
  * The cubic Cardinal spline characteristic matrix, parameterized by tension.
  *
@@ -54,7 +49,7 @@ declare const cubicBasisSpline: Matrix4x4;
  * @returns The characteristic matrix for that tension.
  * @since 2.0.0
  */
-declare const cubicCardinal: (tension: number) => Matrix4x4;
+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
@@ -62,7 +57,7 @@ declare const cubicCardinal: (tension: number) => Matrix4x4;
  *
  * @since 2.0.0
  */
-declare const cubicCatmullRom: Matrix4x4;
+export declare const cubicCatmullRom: Matrix4x4.Matrix4x4;
 /**
  * Applies a characteristic matrix to N channels of control values, producing
  * N cubic polynomials in monomial form.
@@ -82,7 +77,4 @@ declare const cubicCatmullRom: Matrix4x4;
  * @returns A tuple of cubic polynomials, one per input channel.
  * @since 2.0.0
  */
-declare const apply: <const Channels extends ReadonlyArray<Vector4>>(matrix: Matrix4x4, ...channels: Channels) => { readonly [K in keyof Channels]: CubicPolynomial };
-//#endregion
-export { characteristic_d_exports as Characteristic };
-//# sourceMappingURL=index.d.mts.map
+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

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

package/dist/curve/cubic2d.d.ts

@@ -0,0 +1,215 @@
+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
+ */
+export interface CubicCurve2d<out XTraits = unknown, out YTraits = unknown> extends Pipeable, TwoDimensional<CubicPolynomial<XTraits>, CubicPolynomial<YTraits>> {
+    readonly [CubicCurve2dTypeId]: CubicCurve2dTypeId;
+}
+/**
+ * Creates a new `CubicCurve2d` instance from polynomial parameters.
+ *
+ * @param x - The x polynomial.
+ * @param y - The y polynomial.
+ * @returns A new `CubicCurve2d` instance.
+ * @since 1.0.0
+ */
+export declare const fromPolynomials: (x: CubicPolynomial, y: CubicPolynomial) => CubicCurve2d;
+/**
+ * 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 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 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
+ */
+export declare const fromBezierPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => CubicCurve2d;
+/**
+ * Checks if a value is a `CubicCurve2d`.
+ *
+ * @param c - The value to check.
+ * @returns `true` if the value is a `CubicCurve2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+export declare const isCubicCurve2d: (c: unknown) => c is CubicCurve2d;
+export declare const solve: {
+    /**
+     * Solves the cubic curve for a given parameter t.
+     *
+     * @param t - The parameter value.
+     * @returns A function that takes a cubic curve and returns the point on the curve at parameter t.
+     * @since 1.0.0
+     */
+    (t: number): (c: CubicCurve2d) => Vector2;
+    /**
+     * Solves the cubic curve for a given parameter t.
+     *
+     * @param c - The cubic curve to solve.
+     * @param t - The parameter value.
+     * @returns The point on the curve at parameter t.
+     * @since 1.0.0
+     */
+    (c: CubicCurve2d, t: number): Vector2;
+};
+export declare const length: {
+    /**
+     * Calculates (approximates) the length of a cubic curve.
+     *
+     * @param c - The cubic curve to calculate the length of.
+     * @param i - The interval over which to calculate the length.
+     * @returns The length of the cubic curve.
+     * @since 1.0.0
+     */
+    (c: CubicCurve2d, i: Interval): number;
+    /**
+     * Calculates (approximates) the length of a cubic curve.
+     *
+     * @param i - The interval over which to calculate the length.
+     * @returns A function that takes a cubic curve and returns the length of the cubic curve.
+     * @since 1.0.0
+     */
+    (i: Interval): (c: CubicCurve2d) => number;
+};
+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.
+     *
+     * @param c - The cubic curve to calculate the curvature for.
+     * @param t - The parameter value.
+     * @returns The curvature of the cubic curve at parameter t.
+     * @since 1.0.0
+     */
+    (c: CubicCurve2d, t: number): number;
+    /**
+     * Calculates the curvature of a cubic curve at a given parameter.
+     *
+     * @param t - The parameter value.
+     * @returns A function that takes a cubic curve and returns the curvature of the cubic curve at parameter t.
+     * @since 1.0.0
+     */
+    (t: number): (c: CubicCurve2d) => number;
+};
+/**
+ * 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

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

package/dist/curve/linear2d.d.ts

@@ -0,0 +1,195 @@
+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
+ */
+export interface LinearCurve2d<out XTraits = unknown, out YTraits = unknown> extends Pipeable, TwoDimensional<LinearPolynomial<XTraits>, LinearPolynomial<YTraits>> {
+    readonly [LinearCurve2dTypeId]: LinearCurve2dTypeId;
+}
+/**
+ * Creates a new `LinearCurve2d` instance from polynomial parameters.
+ *
+ * @param x - The x polynomial.
+ * @param y - The y polynomial.
+ * @returns A new `LinearCurve2d` instance.
+ * @since 1.0.0
+ */
+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 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 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
+ */
+export declare const fromEndpoints: (p0: Vector2, p1: Vector2) => LinearCurve2d;
+/**
+ * Checks if a value is a `LinearCurve2d`.
+ *
+ * @param c - The value to check.
+ * @returns `true` if the value is a `LinearCurve2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+export declare const isLinearCurve2d: (c: unknown) => c is LinearCurve2d;
+/**
+ * Gets the derivative of a linear curve as a vector
+ *
+ * @param c - The linear curve to get the derivative of.
+ * @returns The derivative of the linear curve as a vector.
+ * @since 1.0.0
+ */
+export declare const derivative: (c: LinearCurve2d) => Vector2;
+export declare const solve: {
+    /**
+     * Solves the linear curve for a given parameter t.
+     *
+     * @param t - The parameter value.
+     * @returns A function that takes a linear curve and returns the point on the curve at parameter t.
+     * @since 1.0.0
+     */
+    (t: number): (c: LinearCurve2d) => Vector2;
+    /**
+     * Solves the linear curve for a given parameter t.
+     *
+     * @param c - The linear curve to solve.
+     * @param t - The parameter value.
+     * @returns The point on the curve at parameter t.
+     * @since 1.0.0
+     */
+    (c: LinearCurve2d, t: number): Vector2;
+};
+export declare const length: {
+    /**
+     * Calculates (approximates) the length of a linear curve.
+     *
+     * @param c - The linear curve to calculate the length of.
+     * @param i - The interval to calculate the length over.
+     * @returns The length of the linear curve over the given interval.
+     * @since 1.0.0
+     */
+    (c: LinearCurve2d, i: Interval): number;
+    /**
+     * Calculates (approximates) the length of a linear curve.
+     *
+     * @param i - The interval to calculate the length over.
+     * @returns A function that takes a linear curve and returns the length of the linear curve over the given interval.
+     * @since 1.0.0
+     */
+    (i: Interval): (c: LinearCurve2d) => number;
+};
+/**
+ * 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;