curvy 2.0.0-alpha.13 → 2.0.0-alpha.14

package/dist/characteristic/index.mjs

@@ -1,2 +1,2 @@
-import { n as characteristic_exports } from "../shared/characteristic-BkEr-rr8.mjs";
+import { n as characteristic_exports } from "../shared/characteristic--7nC4Q_a.mjs";
 export { characteristic_exports as Characteristic };

package/dist/curve/cubic2d.d.ts

@@ -5,8 +5,10 @@ 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 { Affine2d } from '../transform/affine2d.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { CubicCurve2dTypeId } from './cubic2d.internal.ts';
+import type { Curve2dOps } from './curve2d.ts';
 export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts';
 /**
  * A cubic curve in 2D space.
@@ -193,13 +195,79 @@ export declare const curvature: {
  * @since 2.0.0
  */
 export declare const boundingBox: (c: CubicCurve2d) => Interval2d<Closed, Closed>;
+/**
+ * Evaluates the curve at `t = 0` in closed form — `(c.x.c0, c.y.c0)`.
+ *
+ * @param c - The cubic curve.
+ * @returns The point at the start of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const startPoint: (c: CubicCurve2d) => Vector2;
+/**
+ * Evaluates the curve at `t = 1` in closed form — the sum of the per-axis
+ * monomial coefficients.
+ *
+ * @param c - The cubic curve.
+ * @returns The point at the end of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const endPoint: (c: CubicCurve2d) => Vector2;
+/**
+ * The tight `[min, max]` range of x over the curve's parameter domain `[0, 1]`,
+ * accounting for up to two interior extrema.
+ *
+ * @param c - The cubic curve.
+ * @returns The closed range of x over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const xRange: (c: CubicCurve2d) => Closed;
+/**
+ * The tight `[min, max]` range of y over the curve's parameter domain `[0, 1]`,
+ * accounting for up to two interior extrema.
+ *
+ * @param c - The cubic curve.
+ * @returns The closed range of y over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const yRange: (c: CubicCurve2d) => Closed;
+/**
+ * Renders the curve as a single SVG path-data drawing command — for a cubic
+ * curve, `C ctrl1X,ctrl1Y ctrl2X,ctrl2Y endX,endY`. Bernstein control points
+ * are recovered from the monomial coefficients in closed form. Does not
+ * include a leading `M`.
+ *
+ * @param c - The cubic curve.
+ * @returns The SVG drawing command for this segment, without a leading `M`.
+ * @since 2.0.0
+ */
+export declare const toPathDataSegment: (c: CubicCurve2d) => string;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Monotonic` when the x polynomial is strictly monotonic on the unit
+ * interval `[0, 1]`. The y-axis trait is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicX: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Monotonic, YT>;
+/** @since 2.0.0 */
+export declare const isIncreasingX: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Increasing, YT>;
+/** @since 2.0.0 */
+export declare const isDecreasingX: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Decreasing, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Monotonic`. The x-axis trait is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicY: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT, YT & Monotonic>;
+/** @since 2.0.0 */
+export declare const isIncreasingY: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT, YT & Increasing>;
+/** @since 2.0.0 */
+export declare const isDecreasingY: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT, YT & Decreasing>;
 /**
  * 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>;
@@ -213,3 +281,34 @@ export declare const asMonotonic: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurv
 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>;
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to a `CubicCurve2d`, returning a new
+     * curve whose image is the affine image of the original. Internally the
+     * transformation works directly on monomial coefficients — `c0` receives
+     * the full affine, `c1`/`c2`/`c3` receive only the linear part.
+     *
+     * @param c - The cubic curve.
+     * @param a - The affine transform.
+     * @returns The transformed cubic curve.
+     * @since 2.0.0
+     */
+    (c: CubicCurve2d, a: Affine2d): CubicCurve2d;
+    /**
+     * Applies an `Affine2d` transform to a `CubicCurve2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `CubicCurve2d` and returns the transformed curve.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (c: CubicCurve2d) => CubicCurve2d;
+};
+/**
+ * The {@link Curve2dOps} bundle for `CubicCurve2d`. Used by `CubicPath2d`
+ * to wire up the path-level operation surface. The `solveAtX` / `solveAtY`
+ * entries narrow the curve's potentially-3-element result to `AtMostOne` —
+ * path callers enforce that via the path's `MonotonicX`/`MonotonicY` brand.
+ *
+ * @since 2.0.0
+ */
+export declare const Ops: Curve2dOps<CubicCurve2d>;

package/dist/curve/curve2d.d.ts

@@ -0,0 +1,81 @@
+import type { Closed, Interval } from '../interval/interval.ts';
+import type { Interval2d } from '../interval/interval2d.ts';
+import type * as Solution from '../solution/solution.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+/**
+ * The minimal operation bundle a curve module must provide for the generic
+ * `Path2d` to be built over it. Each polynomial curve module
+ * (`LinearCurve2d`, `QuadraticCurve2d`, `CubicCurve2d`) exports an `Ops`
+ * instance which the corresponding path module passes to
+ * `Path2d.make(ops)` to derive its operation surface.
+ *
+ * The interface is intentionally small — anything that isn't shared
+ * structurally across curve degrees stays on the per-degree module.
+ *
+ * @since 2.0.0
+ */
+export interface Curve2dOps<C> {
+    /**
+     * Evaluate the curve at parameter `t ∈ [0, 1]`.
+     */
+    solve(c: C, t: number): Vector2;
+    /**
+     * Closed-form value at `t = 0`.
+     */
+    startPoint(c: C): Vector2;
+    /**
+     * Closed-form value at `t = 1`.
+     */
+    endPoint(c: C): Vector2;
+    /**
+     * Arc length over an interval of the curve's domain.
+     */
+    length(c: C, interval: Interval): number;
+    /**
+     * Axis-aligned bounding box over the unit interval `[0, 1]`.
+     */
+    boundingBox(c: C): Interval2d<Closed, Closed>;
+    /**
+     * Inverse solve for x. Path-level callers enforce single-valuedness via
+     * the path's `MonotonicX` brand, so the result is narrowed to `AtMostOne`.
+     */
+    solveAtX(c: C, x: number): Solution.AtMostOne<number>;
+    /**
+     * y-axis analog of {@link solveAtX}.
+     */
+    solveAtY(c: C, y: number): Solution.AtMostOne<number>;
+    /**
+     * SVG path-data drawing command for one segment (`L …`, `Q …`, `C …`),
+     * without a leading `M`. Move-insertion is decided by the path-level
+     * `toPathData` based on continuity with the previous segment.
+     */
+    toPathDataSegment(c: C): string;
+    /**
+     * Whether the curve's x is strictly increasing on `[0, 1]`.
+     */
+    isIncreasingX(c: C): boolean;
+    /**
+     * Whether the curve's x is strictly decreasing on `[0, 1]`.
+     */
+    isDecreasingX(c: C): boolean;
+    /**
+     * Whether the curve's y is strictly increasing on `[0, 1]`.
+     */
+    isIncreasingY(c: C): boolean;
+    /**
+     * Whether the curve's y is strictly decreasing on `[0, 1]`.
+     */
+    isDecreasingY(c: C): boolean;
+    /**
+     * Apply an affine transform to the curve, returning a new curve whose
+     * geometric image is the affine image of the original.
+     *
+     * For non-rational coefficient-form curves this is per-coefficient: the
+     * constant coefficient receives the full affine, and all higher-degree
+     * coefficients receive only the linear part. For rational curves the
+     * translation is folded into the numerator polynomials weighted by the
+     * denominator. Path-level callers route through this op per curve.
+     */
+    transform(c: C, a: Affine2d): C;
+}

package/dist/curve/index.mjs

@@ -1,2 +1,2 @@
-import { _ as quadratic2d_exports, i as rationalCubic2d_exports, s as cubic2d_exports, w as linear2d_exports } from "../shared/rationalCubic2d-CeHgpNht.mjs";
+import { c as cubic2d_exports, h as quadratic2d_exports, i as rationalCubic2d_exports, y as linear2d_exports } from "../shared/rationalCubic2d-CZSwwKtS.mjs";
 export { cubic2d_exports as CubicCurve2d, linear2d_exports as LinearCurve2d, quadratic2d_exports as QuadraticCurve2d, rationalCubic2d_exports as RationalCubicCurve2d };

package/dist/curve/linear2d.d.ts

@@ -5,7 +5,9 @@ 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 { Affine2d } from '../transform/affine2d.ts';
 import type { Vector2 } from '../vector/vector2.ts';
+import type { Curve2dOps } from './curve2d.ts';
 import type { LinearCurve2dTypeId } from './linear2d.internal.ts';
 export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts';
 /**
@@ -121,6 +123,53 @@ export declare const length: {
  * @since 2.0.0
  */
 export declare const boundingBox: (c: LinearCurve2d) => Interval2d<Closed, Closed>;
+/**
+ * Evaluates the curve at `t = 0` in closed form — `(c.x.c0, c.y.c0)`.
+ *
+ * @param c - The linear curve.
+ * @returns The point at the start of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const startPoint: (c: LinearCurve2d) => Vector2;
+/**
+ * Evaluates the curve at `t = 1` in closed form — `(c.x.c0 + c.x.c1, c.y.c0 + c.y.c1)`.
+ *
+ * @param c - The linear curve.
+ * @returns The point at the end of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const endPoint: (c: LinearCurve2d) => Vector2;
+/**
+ * The tight `[min, max]` range of x over the curve's parameter domain `[0, 1]`.
+ * For a linear curve this is the closed interval bounded by the two endpoints'
+ * x coordinates.
+ *
+ * @param c - The linear curve.
+ * @returns The closed range of x over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const xRange: (c: LinearCurve2d) => Closed;
+/**
+ * The tight `[min, max]` range of y over the curve's parameter domain `[0, 1]`.
+ * For a linear curve this is the closed interval bounded by the two endpoints'
+ * y coordinates.
+ *
+ * @param c - The linear curve.
+ * @returns The closed range of y over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const yRange: (c: LinearCurve2d) => Closed;
+/**
+ * Renders the curve as a single SVG path-data drawing command — for a linear
+ * curve, `L endX,endY`. Does not include a leading `M`; callers (typically a
+ * path-level `toPathData`) decide whether to emit a move based on continuity
+ * with the previous segment.
+ *
+ * @param c - The linear curve.
+ * @returns The SVG drawing command for this segment, without a leading `M`.
+ * @since 2.0.0
+ */
+export declare const toPathDataSegment: (c: LinearCurve2d) => string;
 export declare const solveAtX: {
     /**
      * Evaluates the curve's y value at a given x. A linear curve crosses any
@@ -152,14 +201,54 @@ export declare const solveAtY: {
     /** @since 2.0.0 */
     (y: number): <XT, YT>(c: LinearCurve2d<XT, YT>) => Solution.AtMostOne<number>;
 };
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Monotonic` when the x polynomial is strictly monotonic. The y-axis trait
+ * is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicX: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Monotonic, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Increasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isIncreasingX: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Increasing, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Decreasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isDecreasingX: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Decreasing, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Monotonic`. The x-axis trait is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicY: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT, YT & Monotonic>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Increasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isIncreasingY: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT, YT & Increasing>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Decreasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isDecreasingY: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT, YT & Decreasing>;
 /**
  * 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>;
@@ -193,3 +282,33 @@ export declare const asIncreasing: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearC
  * @since 2.0.0
  */
 export declare const asDecreasing: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearCurve2d<XT & Decreasing, YT & Decreasing>;
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to a `LinearCurve2d`, returning a new
+     * curve whose image is the affine image of the original. The transformation
+     * is exact: linear curves are degree-1 in every basis, and affine maps
+     * commute with the basis.
+     *
+     * @param c - The linear curve.
+     * @param a - The affine transform.
+     * @returns The transformed linear curve.
+     * @since 2.0.0
+     */
+    (c: LinearCurve2d, a: Affine2d): LinearCurve2d;
+    /**
+     * Applies an `Affine2d` transform to a `LinearCurve2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `LinearCurve2d` and returns the transformed curve.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (c: LinearCurve2d) => LinearCurve2d;
+};
+/**
+ * The {@link Curve2dOps} bundle for `LinearCurve2d`. Used by
+ * `LinearPath2d` (and any user code building a generic `Path2d` over linear
+ * curves) to wire up the path-level operation surface.
+ *
+ * @since 2.0.0
+ */
+export declare const Ops: Curve2dOps<LinearCurve2d>;

package/dist/curve/quadratic2d.d.ts

@@ -5,7 +5,9 @@ import type { Pipeable } from '../utils.ts';
 import type { QuadraticPolynomial } from '../polynomial/quadratic.ts';
 import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
 import type * as Solution from '../solution/solution.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Vector2 } from '../vector/vector2.ts';
+import type { Curve2dOps } from './curve2d.ts';
 import type { LinearCurve2d } from './linear2d.ts';
 import type { QuadraticCurve2dTypeId } from './quadratic2d.internal.ts';
 export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts';
@@ -201,13 +203,79 @@ export declare const curvature: {
  * @since 2.0.0
  */
 export declare const boundingBox: (c: QuadraticCurve2d) => Interval2d<Closed, Closed>;
+/**
+ * Evaluates the curve at `t = 0` in closed form — `(c.x.c0, c.y.c0)`.
+ *
+ * @param c - The quadratic curve.
+ * @returns The point at the start of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const startPoint: (c: QuadraticCurve2d) => Vector2;
+/**
+ * Evaluates the curve at `t = 1` in closed form — the sum of the per-axis
+ * monomial coefficients.
+ *
+ * @param c - The quadratic curve.
+ * @returns The point at the end of the curve's parameter domain.
+ * @since 2.0.0
+ */
+export declare const endPoint: (c: QuadraticCurve2d) => Vector2;
+/**
+ * The tight `[min, max]` range of x over the curve's parameter domain `[0, 1]`,
+ * accounting for an interior extremum if one exists.
+ *
+ * @param c - The quadratic curve.
+ * @returns The closed range of x over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const xRange: (c: QuadraticCurve2d) => Closed;
+/**
+ * The tight `[min, max]` range of y over the curve's parameter domain `[0, 1]`,
+ * accounting for an interior extremum if one exists.
+ *
+ * @param c - The quadratic curve.
+ * @returns The closed range of y over `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const yRange: (c: QuadraticCurve2d) => Closed;
+/**
+ * Renders the curve as a single SVG path-data drawing command — for a
+ * quadratic curve, `Q ctrlX,ctrlY endX,endY`, where the control point is
+ * recovered from the monomial coefficients via the inverse Bernstein
+ * expansion. Does not include a leading `M`.
+ *
+ * @param c - The quadratic curve.
+ * @returns The SVG drawing command for this segment, without a leading `M`.
+ * @since 2.0.0
+ */
+export declare const toPathDataSegment: (c: QuadraticCurve2d) => string;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Monotonic` when the x polynomial is strictly monotonic on the unit
+ * interval `[0, 1]`. The y-axis trait is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicX: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Monotonic, YT>;
+/** @since 2.0.0 */
+export declare const isIncreasingX: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Increasing, YT>;
+/** @since 2.0.0 */
+export declare const isDecreasingX: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Decreasing, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Monotonic`. The x-axis trait is unchanged.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicY: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT, YT & Monotonic>;
+/** @since 2.0.0 */
+export declare const isIncreasingY: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT, YT & Increasing>;
+/** @since 2.0.0 */
+export declare const isDecreasingY: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT, YT & Decreasing>;
 /**
  * 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:
- * `QuadraticPolynomial.isMonotonic(curve.x, Interval.unit)`.
- *
  * @since 2.0.0
  */
 export declare const isMonotonic: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Monotonic, YT & Monotonic>;
@@ -221,3 +289,35 @@ export declare const asMonotonic: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => Quadr
 export declare const asIncreasing: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => QuadraticCurve2d<XT & Increasing, YT & Increasing>;
 /** @since 2.0.0 */
 export declare const asDecreasing: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => QuadraticCurve2d<XT & Decreasing, YT & Decreasing>;
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to a `QuadraticCurve2d`, returning a new
+     * curve whose image is the affine image of the original. Internally the
+     * transformation works directly on the curve's monomial coefficients —
+     * `c0` receives the full affine, `c1` and `c2` receive only the linear part.
+     *
+     * @param c - The quadratic curve.
+     * @param a - The affine transform.
+     * @returns The transformed quadratic curve.
+     * @since 2.0.0
+     */
+    (c: QuadraticCurve2d, a: Affine2d): QuadraticCurve2d;
+    /**
+     * Applies an `Affine2d` transform to a `QuadraticCurve2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `QuadraticCurve2d` and returns the transformed curve.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (c: QuadraticCurve2d) => QuadraticCurve2d;
+};
+/**
+ * The {@link Curve2dOps} bundle for `QuadraticCurve2d`. Used by
+ * `QuadraticPath2d` to wire up the path-level operation surface. The
+ * `solveAtX` / `solveAtY` entries narrow the curve's potentially-2-element
+ * result to `AtMostOne` — path callers enforce that via the path's
+ * `MonotonicX`/`MonotonicY` brand.
+ *
+ * @since 2.0.0
+ */
+export declare const Ops: Curve2dOps<QuadraticCurve2d>;