curvy 2.0.0-alpha.16 → 2.0.0-alpha.17

package/dist/characteristic/index.mjs

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

package/dist/curve/cubic2d.d.ts

@@ -3,7 +3,7 @@ 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 { Decreasing, Increasing, Monotonic, Reflected } 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';
@@ -396,3 +396,17 @@ export declare const transform: {
      */
     (a: Affine2d): (c: CubicCurve2d) => CubicCurve2d;
 };
+/**
+ * Reverses the curve's parameter direction, returning the curve traced from
+ * `t = 1` back to `t = 0`. The geometric image is identical — the same points
+ * in the same places — but the start and end swap and each axis's monotonic
+ * sense inverts: an `Increasing` axis becomes `Decreasing` and vice versa
+ * (`Reflected`), a bare `Monotonic` axis stays monotonic. Per component this
+ * reflects each coordinate polynomial about its domain midpoint
+ * (`CubicPolynomial.reflectDomain`).
+ *
+ * @param c - The cubic curve to reverse.
+ * @returns The reversed curve, its per-axis direction brands flipped.
+ * @since 2.0.0
+ */
+export declare const reverse: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<Reflected<XT>, Reflected<YT>>;

package/dist/curve/curve2d.d.ts

@@ -78,4 +78,12 @@ export interface Curve2dOps<C> {
      * denominator. Path-level callers route through this op per curve.
      */
     transform(c: C, a: Affine2d): C;
+    /**
+     * Reverse the curve's parameter direction, returning the curve traced from
+     * t = 1 to t = 0. The geometric image is unchanged — start and end swap and
+     * any monotonic axis inverts — since per component this reflects each
+     * coordinate polynomial about its domain midpoint (`p(1 - u)`). Path-level
+     * `reverse` routes through this op per curve.
+     */
+    reverse(c: C): C;
 }

package/dist/curve/index.mjs

@@ -1,2 +1,3 @@
-import { i as rationalCubic2d_exports, m as quadratic2d_exports, s as cubic2d_exports, v as linear2d_exports } from "../shared/rationalCubic2d-D_TBd-3i.mjs";
+import { n as cubic2d_exports, p as quadratic2d_exports, y as linear2d_exports } from "../shared/cubic2d-CI82mN9o.mjs";
+import { i as rationalCubic2d_exports } from "../shared/rationalCubic2d-aT1o6oCm.mjs";
 export { cubic2d_exports as CubicCurve2d, linear2d_exports as LinearCurve2d, quadratic2d_exports as QuadraticCurve2d, rationalCubic2d_exports as RationalCubicCurve2d };

package/dist/curve/linear2d.d.ts

@@ -3,7 +3,7 @@ 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 { Decreasing, Increasing, Monotonic, Reflected } 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';
@@ -356,3 +356,17 @@ export declare const transform: {
      */
     (a: Affine2d): (c: LinearCurve2d) => LinearCurve2d;
 };
+/**
+ * Reverses the curve's parameter direction, returning the curve traced from
+ * `t = 1` back to `t = 0`. The geometric image is identical — the same points
+ * in the same places — but the start and end swap and each axis's monotonic
+ * sense inverts: an `Increasing` axis becomes `Decreasing` and vice versa
+ * (`Reflected`), a bare `Monotonic` axis stays monotonic. Per component this
+ * reflects each coordinate polynomial about its domain midpoint
+ * (`LinearPolynomial.reflectDomain`).
+ *
+ * @param c - The linear curve to reverse.
+ * @returns The reversed curve, its per-axis direction brands flipped.
+ * @since 2.0.0
+ */
+export declare const reverse: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearCurve2d<Reflected<XT>, Reflected<YT>>;

package/dist/curve/quadratic2d.d.ts

@@ -3,7 +3,7 @@ import type { TwoDimensional } from '../dimensions.ts';
 import type { Closed, Interval } from '../interval/interval.ts';
 import type { Pipeable } from '../utils.ts';
 import type { QuadraticPolynomial } from '../polynomial/quadratic.ts';
-import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
+import type { Decreasing, Increasing, Monotonic, Reflected } 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';
@@ -402,3 +402,17 @@ export declare const transform: {
      */
     (a: Affine2d): (c: QuadraticCurve2d) => QuadraticCurve2d;
 };
+/**
+ * Reverses the curve's parameter direction, returning the curve traced from
+ * `t = 1` back to `t = 0`. The geometric image is identical — the same points
+ * in the same places — but the start and end swap and each axis's monotonic
+ * sense inverts: an `Increasing` axis becomes `Decreasing` and vice versa
+ * (`Reflected`), a bare `Monotonic` axis stays monotonic. Per component this
+ * reflects each coordinate polynomial about its domain midpoint
+ * (`QuadraticPolynomial.reflectDomain`).
+ *
+ * @param c - The quadratic curve to reverse.
+ * @returns The reversed curve, its per-axis direction brands flipped.
+ * @since 2.0.0
+ */
+export declare const reverse: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => QuadraticCurve2d<Reflected<XT>, Reflected<YT>>;

package/dist/interval/index.mjs

@@ -1,3 +1,3 @@
-import { c as interval_exports } from "../shared/interval-Dv6eHXJH.mjs";
-import { n as interval2d_exports } from "../shared/interval2d-B8wt0szh.mjs";
+import { l as interval_exports } from "../shared/interval-8-erxD4h.mjs";
+import { n as interval2d_exports } from "../shared/interval2d-CVS66YmV.mjs";
 export { interval_exports as Interval, interval2d_exports as Interval2d };

package/dist/matrix/index.mjs

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
-import { A as fromRows$2, B as toRows$2, C as transpose$3, D as determinant$2, E as columnVector$2, F as rowVector$2, H as vectorProductLeft$2, I as setColumn$2, L as setRow$2, M as make$2, N as reverseColumns$2, O as equals$2, P as reverseRows$2, R as solveSystem$2, S as toRows$3, T as vectorProductRight$3, U as vectorProductRight$2, V as transpose$2, _ as rowVector$3, a as fromColumns$3, b as solveSystem$3, c as inverse$1, d as isMatrix3x3$1, f as make$3, g as reverseRows$3, h as reverseColumns$3, i as equals$3, j as isMatrix2x2$1, k as fromColumns$2, l as inverseUnsafe$1, m as multiply$1, n as columnVector$3, o as fromRows$3, p as minor$1, r as determinant$3, s as identity$1, t as asInvertible$1, u as isInvertible$1, v as setColumn$3, w as vectorProductLeft$3, x as toColumns$3, y as setRow$3, z as toColumns$2 } from "../shared/matrix3x3.internal-CFbYATcm.mjs";
-import { r as matrix4x4_exports } from "../shared/matrix4x4-DNcb1l5T.mjs";
+import { A as fromRows$2, B as toRows$2, C as transpose$3, D as determinant$2, E as columnVector$2, F as rowVector$2, H as vectorProductLeft$2, I as setColumn$2, L as setRow$2, M as make$2, N as reverseColumns$2, O as equals$2, P as reverseRows$2, R as solveSystem$2, S as toRows$3, T as vectorProductRight$3, U as vectorProductRight$2, V as transpose$2, _ as rowVector$3, a as fromColumns$3, b as solveSystem$3, c as inverse$1, d as isMatrix3x3$1, f as make$3, g as reverseRows$3, h as reverseColumns$3, i as equals$3, j as isMatrix2x2$1, k as fromColumns$2, l as inverseUnsafe$1, m as multiply$1, n as columnVector$3, o as fromRows$3, p as minor$1, r as determinant$3, s as identity$1, t as asInvertible$1, u as isInvertible$1, v as setColumn$3, w as vectorProductLeft$3, x as toColumns$3, y as setRow$3, z as toColumns$2 } from "../shared/matrix3x3.internal-eK-9vsoI.mjs";
+import { r as matrix4x4_exports } from "../shared/matrix4x4-DCRpqQsP.mjs";
 //#region src/matrix/matrix2x2.ts
 var matrix2x2_exports = /* @__PURE__ */ __exportAll({
 	columnVector: () => columnVector$1,

package/dist/path/cubic2d.d.ts

@@ -67,6 +67,33 @@ export declare const append: {
      */
     (p: CubicPath2d, c: CubicCurve2d): CubicPath2d;
 };
+export declare const appendContinuous: {
+    /**
+     * Appends a cubic curve to a `Continuous` path, preserving the brand.
+     *
+     * @param c - The cubic curve to append.
+     * @returns A function that takes a `Continuous` cubic path and returns a new one with the curve appended.
+     * @since 2.0.0
+     */
+    (c: CubicCurve2d): (p: CubicPath2d<Continuous>) => CubicPath2d<Continuous>;
+    /**
+     * Appends a cubic curve to a `Continuous` cubic path, preserving the brand.
+     * The curve's start point must coincide with the path's current end point
+     * (G^0 continuity), compared with `coincident` tolerance (see `PRECISION.md`).
+     *
+     * Only the new join is checked — the input's `Continuous` brand already
+     * vouches for the rest. Other trait brands are dropped, since a new curve can
+     * still reverse an axis and break monotonicity; reassert them with the
+     * relevant refiner if needed.
+     *
+     * @param p - A continuous cubic path.
+     * @param c - The cubic curve to append.
+     * @returns A new `Continuous` cubic path with the curve appended.
+     * @throws `Error` when the curve does not connect to the path's end point.
+     * @since 2.0.0
+     */
+    (p: CubicPath2d<Continuous>, c: CubicCurve2d): CubicPath2d<Continuous>;
+};
 /**
  * Calculates the total arc length of a cubic path.
  *
@@ -349,3 +376,17 @@ export declare const transform: {
      */
     (a: Affine2d): (p: CubicPath2d) => CubicPath2d;
 };
+/**
+ * Reverses the path, returning it traced end-to-start: the segment order is
+ * reversed and each segment's parameter direction flipped. The geometric image
+ * is identical. `Continuous` survives the reversal in substance but, like every
+ * brand, is dropped from the type — reversal turns `IncreasingX` into
+ * `DecreasingX` (and likewise on the y axis), so the direction brands cannot
+ * carry through. Reassert what still holds with `isContinuous`, `isIncreasingX`,
+ * and their siblings.
+ *
+ * @param p - The path to reverse.
+ * @returns The reversed path, with all trait brands dropped.
+ * @since 2.0.0
+ */
+export declare const reverse: (p: CubicPath2d) => CubicPath2d;

package/dist/path/index.mjs

@@ -1,305 +1,4 @@
-import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
-import { invariant } from "../utils.mjs";
-import { g as Ops } from "../shared/rationalCubic2d-D_TBd-3i.mjs";
-import { n as rationalCubic2d_exports, o as linear2d_exports, r as cubic2d_exports, s as makeMethods } from "../shared/rationalCubic2d-D9bMCQ8P.mjs";
-//#region src/path/quadratic2d.internal.ts
-const QuadraticPath2dTypeId = Symbol("curvy/path/quadratic2d");
-const methods = makeMethods(QuadraticPath2dTypeId, Ops);
-/** @internal */
-const isQuadraticPath2d$1 = (p) => typeof p === "object" && p !== null && QuadraticPath2dTypeId in p;
-/** @internal */
-const make$1 = methods.make;
-/** @internal */
-const fromArray$1 = methods.fromArray;
-/** @internal */
-const append$1 = methods.append;
-/** @internal */
-const length$1 = methods.length;
-/** @internal */
-const solve$1 = methods.solve;
-/** @internal */
-const toPathData$1 = methods.toPathData;
-/** @internal */
-const isContinuous$1 = methods.isContinuous;
-/** @internal */
-const asContinuous$1 = (p) => {
-	invariant(isContinuous$1(p), "quadratic path is not continuous");
-	return p;
-};
-/** @internal */
-const isIncreasingX$1 = methods.isIncreasingX;
-/** @internal */
-const isDecreasingX$1 = methods.isDecreasingX;
-/** @internal */
-const isMonotonicX$1 = methods.isMonotonicX;
-/** @internal */
-const isIncreasingY$1 = methods.isIncreasingY;
-/** @internal */
-const isDecreasingY$1 = methods.isDecreasingY;
-/** @internal */
-const isMonotonicY$1 = methods.isMonotonicY;
-/** @internal */
-const asIncreasingX$1 = (p) => {
-	invariant(isIncreasingX$1(p), "quadratic path is not increasing in x");
-	return p;
-};
-/** @internal */
-const asDecreasingX$1 = (p) => {
-	invariant(isDecreasingX$1(p), "quadratic path is not decreasing in x");
-	return p;
-};
-/** @internal */
-const asMonotonicX$1 = (p) => {
-	invariant(isMonotonicX$1(p), "quadratic path is not monotonic in x");
-	return p;
-};
-/** @internal */
-const asIncreasingY$1 = (p) => {
-	invariant(isIncreasingY$1(p), "quadratic path is not increasing in y");
-	return p;
-};
-/** @internal */
-const asDecreasingY$1 = (p) => {
-	invariant(isDecreasingY$1(p), "quadratic path is not decreasing in y");
-	return p;
-};
-/** @internal */
-const asMonotonicY$1 = (p) => {
-	invariant(isMonotonicY$1(p), "quadratic path is not monotonic in y");
-	return p;
-};
-/** @internal */
-const solveAtX$1 = methods.solveAtX;
-/** @internal */
-const solveAtY$1 = methods.solveAtY;
-/** @internal */
-const boundingBox$1 = methods.boundingBox;
-/** @internal */
-const transform$1 = methods.transform;
-//#endregion
-//#region src/path/quadratic2d.ts
-var quadratic2d_exports = /* @__PURE__ */ __exportAll({
-	append: () => append,
-	asContinuous: () => asContinuous,
-	asDecreasingX: () => asDecreasingX,
-	asDecreasingY: () => asDecreasingY,
-	asIncreasingX: () => asIncreasingX,
-	asIncreasingY: () => asIncreasingY,
-	asMonotonicX: () => asMonotonicX,
-	asMonotonicY: () => asMonotonicY,
-	boundingBox: () => boundingBox,
-	fromArray: () => fromArray,
-	isContinuous: () => isContinuous,
-	isDecreasingX: () => isDecreasingX,
-	isDecreasingY: () => isDecreasingY,
-	isIncreasingX: () => isIncreasingX,
-	isIncreasingY: () => isIncreasingY,
-	isMonotonicX: () => isMonotonicX,
-	isMonotonicY: () => isMonotonicY,
-	isQuadraticPath2d: () => isQuadraticPath2d,
-	length: () => length,
-	make: () => make,
-	solve: () => solve,
-	solveAtX: () => solveAtX,
-	solveAtY: () => solveAtY,
-	toPathData: () => toPathData,
-	transform: () => transform
-});
-/**
-* Creates a new `QuadraticPath2d` instance from a sequence of curves.
-*
-* @param curves - The curves to create the path from. At least one is required.
-* @returns A new `QuadraticPath2d` instance.
-* @throws `Error` when called with no curves.
-* @since 2.0.0
-*/
-const make = make$1;
-/**
-* Creates a new `QuadraticPath2d` instance from an array of curves.
-*
-* @param curves - The curves to create the path from. At least one is required.
-* @returns A new `QuadraticPath2d` instance.
-* @throws `Error` when the array is empty.
-* @since 2.0.0
-*/
-const fromArray = fromArray$1;
-/**
-* Checks if a value is a `QuadraticPath2d`.
-*
-* @param p - The value to check.
-* @returns `true` if the value is a `QuadraticPath2d`, `false` otherwise.
-* @since 1.0.0
-*/
-const isQuadraticPath2d = isQuadraticPath2d$1;
-const append = append$1;
-/**
-* Calculates the total arc length of a quadratic path.
-*
-* @param p - The quadratic path to measure.
-* @returns The sum of the segments' arc lengths.
-* @since 1.0.0
-*/
-const length = length$1;
-const solve = solve$1;
-/**
-* Serializes a quadratic path as an SVG path data string (the value of a
-* `<path>` element's `d` attribute), using `M` and `Q` commands. Discontinuities
-* between curves emit a fresh `M` command.
-*
-* @param p - The quadratic path to serialize.
-* @returns The SVG path data string.
-* @since 2.0.0
-*/
-const toPathData = toPathData$1;
-/**
-* Checks if adjacent curves connect at their join points (G^0 continuity),
-* each junction compared with `coincident` tolerance (see `PRECISION.md`),
-* adding `Continuous` to the path's traits.
-*
-* @param p - The quadratic path to check.
-* @returns `true` when every junction connects, narrowing to `QuadraticPath2d<T & Continuous>`.
-* @since 2.0.0
-*/
-const isContinuous = isContinuous$1;
-/**
-* Asserts that the quadratic path is continuous, throwing on failure.
-*
-* @param p - The quadratic path to assert against.
-* @returns The same path, with `Continuous` added to its traits.
-* @throws `Error` when adjacent curves do not connect.
-* @since 2.0.0
-*/
-const asContinuous = asContinuous$1;
-/**
-* Checks if the path's x-coordinate increases as the path parameter
-* advances. Every segment's x polynomial is strictly increasing on
-* `[0, 1]` and adjacent segments' x-ranges don't overlap. Adds
-* `IncreasingX` to the path's traits.
-*
-* @param p - The quadratic path to check.
-* @returns `true` when x increases along the path, narrowing to `QuadraticPath2d<T & IncreasingX>`.
-* @since 2.0.0
-*/
-const isIncreasingX = isIncreasingX$1;
-/**
-* Checks if the path's x-coordinate decreases as the path parameter
-* advances. Every segment's x polynomial is strictly decreasing on
-* `[0, 1]` and adjacent segments' x-ranges don't overlap. Adds
-* `DecreasingX` to the path's traits.
-*
-* @param p - The quadratic path to check.
-* @returns `true` when x decreases along the path, narrowing to `QuadraticPath2d<T & DecreasingX>`.
-* @since 2.0.0
-*/
-const isDecreasingX = isDecreasingX$1;
-/**
-* Checks if the path's x-coordinate is monotonic (increasing or
-* decreasing) as the path parameter advances, the property the brand
-* `solveAtX` requires. Adds `MonotonicX` to the path's traits.
-*
-* @param p - The quadratic path to check.
-* @returns `true` when x is monotonic along the path, narrowing to `QuadraticPath2d<T & MonotonicX>`.
-* @since 2.0.0
-*/
-const isMonotonicX = isMonotonicX$1;
-/**
-* Checks if the path's y-coordinate increases as the path parameter
-* advances. Every segment's y polynomial is strictly increasing on
-* `[0, 1]` and adjacent segments' y-ranges don't overlap. Adds
-* `IncreasingY` to the path's traits.
-*
-* @param p - The quadratic path to check.
-* @returns `true` when y increases along the path, narrowing to `QuadraticPath2d<T & IncreasingY>`.
-* @since 2.0.0
-*/
-const isIncreasingY = isIncreasingY$1;
-/**
-* Checks if the path's y-coordinate decreases as the path parameter
-* advances. Every segment's y polynomial is strictly decreasing on
-* `[0, 1]` and adjacent segments' y-ranges don't overlap. Adds
-* `DecreasingY` to the path's traits.
-*
-* @param p - The quadratic path to check.
-* @returns `true` when y decreases along the path, narrowing to `QuadraticPath2d<T & DecreasingY>`.
-* @since 2.0.0
-*/
-const isDecreasingY = isDecreasingY$1;
-/**
-* Checks if the path's y-coordinate is monotonic (increasing or
-* decreasing) as the path parameter advances, the property the brand
-* `solveAtY` requires. Adds `MonotonicY` to the path's traits.
-*
-* @param p - The quadratic path to check.
-* @returns `true` when y is monotonic along the path, narrowing to `QuadraticPath2d<T & MonotonicY>`.
-* @since 2.0.0
-*/
-const isMonotonicY = isMonotonicY$1;
-/**
-* Asserts that the path is strictly increasing in x, throwing on failure.
-*
-* @param p - The quadratic path to assert against.
-* @returns The same path, with `IncreasingX` added to its traits.
-* @throws `Error` when the path is not strictly increasing in x.
-* @since 2.0.0
-*/
-const asIncreasingX = asIncreasingX$1;
-/**
-* Asserts that the path is strictly decreasing in x, throwing on failure.
-*
-* @param p - The quadratic path to assert against.
-* @returns The same path, with `DecreasingX` added to its traits.
-* @throws `Error` when the path is not strictly decreasing in x.
-* @since 2.0.0
-*/
-const asDecreasingX = asDecreasingX$1;
-/**
-* Asserts that the path is monotonic in x, throwing on failure.
-*
-* @param p - The quadratic path to assert against.
-* @returns The same path, with `MonotonicX` added to its traits.
-* @throws `Error` when the path is not monotonic in x.
-* @since 2.0.0
-*/
-const asMonotonicX = asMonotonicX$1;
-/**
-* Asserts that the path is strictly increasing in y, throwing on failure.
-*
-* @param p - The quadratic path to assert against.
-* @returns The same path, with `IncreasingY` added to its traits.
-* @throws `Error` when the path is not strictly increasing in y.
-* @since 2.0.0
-*/
-const asIncreasingY = asIncreasingY$1;
-/**
-* Asserts that the path is strictly decreasing in y, throwing on failure.
-*
-* @param p - The quadratic path to assert against.
-* @returns The same path, with `DecreasingY` added to its traits.
-* @throws `Error` when the path is not strictly decreasing in y.
-* @since 2.0.0
-*/
-const asDecreasingY = asDecreasingY$1;
-/**
-* Asserts that the path is monotonic in y, throwing on failure.
-*
-* @param p - The quadratic path to assert against.
-* @returns The same path, with `MonotonicY` added to its traits.
-* @throws `Error` when the path is not monotonic in y.
-* @since 2.0.0
-*/
-const asMonotonicY = asMonotonicY$1;
-const solveAtX = solveAtX$1;
-const solveAtY = solveAtY$1;
-/**
-* Computes the axis-aligned bounding box of the path.
-*
-* @param p - The quadratic path.
-* @returns The smallest closed `Interval2d` enclosing every segment.
-* @since 2.0.0
-*/
-const boundingBox = boundingBox$1;
-const transform = transform$1;
-//#endregion
+import { f as linear2d_exports, r as cubic2d_exports } from "../shared/cubic2d-q1HU0uM9.mjs";
+import { a as quadratic2d_exports } from "../shared/quadratic2d-CXlMyyCs.mjs";
+import { n as rationalCubic2d_exports } from "../shared/rationalCubic2d-CGU2mYjs.mjs";
 export { cubic2d_exports as CubicPath2d, linear2d_exports as LinearPath2d, quadratic2d_exports as QuadraticPath2d, rationalCubic2d_exports as RationalCubicPath2d };
-
-//# sourceMappingURL=index.mjs.map

package/dist/path/linear2d.d.ts

@@ -68,6 +68,33 @@ export declare const append: {
      */
     (p: LinearPath2d, c: LinearCurve2d): LinearPath2d;
 };
+export declare const appendContinuous: {
+    /**
+     * Appends a linear curve to a `Continuous` path, preserving the brand.
+     *
+     * @param c - The linear curve to append.
+     * @returns A function that takes a `Continuous` linear path and returns a new one with the curve appended.
+     * @since 2.0.0
+     */
+    (c: LinearCurve2d): (p: LinearPath2d<Continuous>) => LinearPath2d<Continuous>;
+    /**
+     * Appends a linear curve to a `Continuous` linear path, preserving the brand.
+     * The curve's start point must coincide with the path's current end point
+     * (G^0 continuity), compared with `coincident` tolerance (see `PRECISION.md`).
+     *
+     * Only the new join is checked — the input's `Continuous` brand already
+     * vouches for the rest. Other trait brands are dropped, since a new curve can
+     * still reverse an axis and break monotonicity; reassert them with the
+     * relevant refiner if needed.
+     *
+     * @param p - A continuous linear path.
+     * @param c - The linear curve to append.
+     * @returns A new `Continuous` linear path with the curve appended.
+     * @throws `Error` when the curve does not connect to the path's end point.
+     * @since 2.0.0
+     */
+    (p: LinearPath2d<Continuous>, c: LinearCurve2d): LinearPath2d<Continuous>;
+};
 /**
  * Calculates the total arc length of a linear path.
  *
@@ -326,3 +353,17 @@ export declare const transform: {
      */
     (a: Affine2d): (p: LinearPath2d) => LinearPath2d;
 };
+/**
+ * Reverses the path, returning it traced end-to-start: the segment order is
+ * reversed and each segment's parameter direction flipped. The geometric image
+ * is identical. `Continuous` survives the reversal in substance but, like every
+ * brand, is dropped from the type — reversal turns `IncreasingX` into
+ * `DecreasingX` (and likewise on the y axis), so the direction brands cannot
+ * carry through. Reassert what still holds with `isContinuous`, `isIncreasingX`,
+ * and their siblings.
+ *
+ * @param p - The path to reverse.
+ * @returns The reversed path, with all trait brands dropped.
+ * @since 2.0.0
+ */
+export declare const reverse: (p: LinearPath2d) => LinearPath2d;

package/dist/path/path2d.d.ts

@@ -39,6 +39,7 @@ export declare const makeMethods: <C>(typeId: symbol, ops: Curve2dOps<C>) => {
     fromArray: (curves: ReadonlyArray<C>) => Path2d<C>;
     make: (...curves: ReadonlyArray<C>) => Path2d<C>;
     append: ((c: C) => (p: Path2d<C>) => Path2d<C>) & ((p: Path2d<C>, c: C) => Path2d<C>);
+    appendContinuous: ((c: C) => (p: Path2d<C, Continuous>) => Path2d<C, Continuous>) & ((p: Path2d<C, Continuous>, c: C) => Path2d<C, Continuous>);
     length: (p: Path2d<C>) => number;
     solve: ((u: number) => (p: Path2d<C>) => Vector2) & ((p: Path2d<C>, u: number) => Vector2);
     toPathData: (p: Path2d<C>) => string;
@@ -53,4 +54,5 @@ export declare const makeMethods: <C>(typeId: symbol, ops: Curve2dOps<C>) => {
     solveAtY: ((...args: Array<any>) => any) & ((p: Path2d<C>, y: number) => Solution.AtMostOne<number>);
     boundingBox: (p: Path2d<C>) => Interval2d.Interval2d<Interval.Closed, Interval.Closed>;
     transform: ((a: Affine2d) => (p: Path2d<C>) => Path2d<C>) & ((p: Path2d<C>, a: Affine2d) => Path2d<C>);
+    reverse: (p: Path2d<C>) => Path2d<C>;
 };

package/dist/path/quadratic2d.d.ts

@@ -67,6 +67,34 @@ export declare const append: {
      */
     (p: QuadraticPath2d, c: QuadraticCurve2d): QuadraticPath2d;
 };
+export declare const appendContinuous: {
+    /**
+     * Appends a quadratic curve to a `Continuous` path, preserving the brand.
+     *
+     * @param c - The quadratic curve to append.
+     * @returns A function that takes a `Continuous` quadratic path and returns a new one with the curve appended.
+     * @since 2.0.0
+     */
+    (c: QuadraticCurve2d): (p: QuadraticPath2d<Continuous>) => QuadraticPath2d<Continuous>;
+    /**
+     * Appends a quadratic curve to a `Continuous` quadratic path, preserving the
+     * brand. The curve's start point must coincide with the path's current end
+     * point (G^0 continuity), compared with `coincident` tolerance (see
+     * `PRECISION.md`).
+     *
+     * Only the new join is checked — the input's `Continuous` brand already
+     * vouches for the rest. Other trait brands are dropped, since a new curve can
+     * still reverse an axis and break monotonicity; reassert them with the
+     * relevant refiner if needed.
+     *
+     * @param p - A continuous quadratic path.
+     * @param c - The quadratic curve to append.
+     * @returns A new `Continuous` quadratic path with the curve appended.
+     * @throws `Error` when the curve does not connect to the path's end point.
+     * @since 2.0.0
+     */
+    (p: QuadraticPath2d<Continuous>, c: QuadraticCurve2d): QuadraticPath2d<Continuous>;
+};
 /**
  * Calculates the total arc length of a quadratic path.
  *
@@ -321,3 +349,17 @@ export declare const transform: {
      */
     (a: Affine2d): (p: QuadraticPath2d) => QuadraticPath2d;
 };
+/**
+ * Reverses the path, returning it traced end-to-start: the segment order is
+ * reversed and each segment's parameter direction flipped. The geometric image
+ * is identical. `Continuous` survives the reversal in substance but, like every
+ * brand, is dropped from the type — reversal turns `IncreasingX` into
+ * `DecreasingX` (and likewise on the y axis), so the direction brands cannot
+ * carry through. Reassert what still holds with `isContinuous`, `isIncreasingX`,
+ * and their siblings.
+ *
+ * @param p - The path to reverse.
+ * @returns The reversed path, with all trait brands dropped.
+ * @since 2.0.0
+ */
+export declare const reverse: (p: QuadraticPath2d) => QuadraticPath2d;

package/dist/piecewise/index.d.ts

@@ -0,0 +1,4 @@
+import * as PiecewiseNs from './piecewise.ts';
+export type Piecewise<P, Trait = unknown> = PiecewiseNs.Piecewise<P, Trait>;
+export type Piece<P> = PiecewiseNs.Piece<P>;
+export { PiecewiseNs as Piecewise };