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

package/dist/splines/linear2d.d.ts

@@ -1,4 +1,5 @@
 import type { LinearPath2d } from '../path/linear2d.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Pipeable } from '../utils.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { Linear2dTypeId } from './linear2d.internal.ts';
@@ -89,6 +90,70 @@ export declare const prepend: {
      */
     (p: Linear2d, ...points: ReadonlyArray<Vector2>): Linear2d;
 };
+export declare const mapPoints: {
+    /**
+     * Applies a per-point transform to every point in a `Linear2d`, preserving
+     * point count and spline identity.
+     *
+     * @param f - The point transform.
+     * @returns A function that takes a `Linear2d` and returns the mapped polyline.
+     * @since 2.0.0
+     */
+    (f: (p: Vector2) => Vector2): (s: Linear2d) => Linear2d;
+    /**
+     * Applies a per-point transform to every point in a `Linear2d`.
+     *
+     * @param s - The polyline.
+     * @param f - The point transform.
+     * @returns A new `Linear2d` with the transform applied to each point.
+     * @since 2.0.0
+     */
+    (s: Linear2d, f: (p: Vector2) => Vector2): Linear2d;
+};
+export declare const flatMap: {
+    /**
+     * Hands the polyline's full point array to `f` and uses its returned
+     * `Linear2d` as the result. Useful for transforms that need to see all
+     * points at once — resampling, smoothing, decimation — while still going
+     * through this module's builders to maintain the 2-or-more-points invariant.
+     *
+     * @param f - The bulk transform.
+     * @returns A function that takes a `Linear2d` and returns the rebuilt polyline.
+     * @since 2.0.0
+     */
+    (f: (points: ReadonlyArray<Vector2>) => Linear2d): (s: Linear2d) => Linear2d;
+    /**
+     * Hands the polyline's full point array to `f` and uses its returned
+     * `Linear2d` as the result.
+     *
+     * @param s - The polyline.
+     * @param f - The bulk transform.
+     * @returns The `Linear2d` returned by `f`.
+     * @since 2.0.0
+     */
+    (s: Linear2d, f: (points: ReadonlyArray<Vector2>) => Linear2d): Linear2d;
+};
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to every point of a `Linear2d`. Polylines
+     * are degree-1 in every basis, so the transformed polyline is exactly the
+     * affine image of the original.
+     *
+     * @param s - The polyline.
+     * @param a - The affine transform.
+     * @returns A new `Linear2d` whose points are the affine images of the input's.
+     * @since 2.0.0
+     */
+    (s: Linear2d, a: Affine2d): Linear2d;
+    /**
+     * Applies an `Affine2d` transform to every point of a `Linear2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `Linear2d` and returns the transformed polyline.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (s: Linear2d) => Linear2d;
+};
 /**
  * Converts a `Linear2d` to a `LinearPath2d` by joining consecutive points
  * with straight segments. The result is unbranded; assert

package/dist/splines/rationalBezier2d.d.ts

@@ -1,4 +1,5 @@
 import type { RationalCubicPath2d } from '../path/rationalCubic2d.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Pipeable } from '../utils.ts';
 import type { Vector2, Weighted } from '../vector/vector2.ts';
 import type { Bezier2d } from './bezier2d.ts';
@@ -116,6 +117,81 @@ export declare const fromBezier: (b: Bezier2d) => RationalBezier2d;
  * @since 2.0.0
  */
 export declare const toPath: (r: RationalBezier2d) => RationalCubicPath2d;
+export declare const mapPoints: {
+    /**
+     * Applies a per-point transform to every weighted control point in a
+     * `RationalBezier2d`, preserving point count.
+     *
+     * The transform sees each control point as a `Vector2.Weighted` —
+     * matching the type's storage form. To lift a position-only function into
+     * a weighted mapper while preserving weights, use
+     * {@link Vector2.liftWithWeight}.
+     *
+     * @param f - The weighted-point transform.
+     * @returns A function that takes a `RationalBezier2d` and returns the mapped spline.
+     * @since 2.0.0
+     */
+    (f: (p: Weighted) => Weighted): (s: RationalBezier2d) => RationalBezier2d;
+    /**
+     * Applies a per-point transform to every weighted control point in a
+     * `RationalBezier2d`.
+     *
+     * @param s - The rational bezier.
+     * @param f - The weighted-point transform.
+     * @returns A new `RationalBezier2d` with the transform applied to each point.
+     * @since 2.0.0
+     */
+    (s: RationalBezier2d, f: (p: Weighted) => Weighted): RationalBezier2d;
+};
+export declare const flatMap: {
+    /**
+     * Hands the bezier's full weighted control-point array to `f` and uses its
+     * returned `RationalBezier2d` as the result. The returned bezier goes
+     * through this module's builders, so the `3n + 1` point-count invariant is
+     * enforced at construction.
+     *
+     * @param f - The bulk transform.
+     * @returns A function that takes a `RationalBezier2d` and returns the rebuilt spline.
+     * @since 2.0.0
+     */
+    (f: (points: ReadonlyArray<Weighted>) => RationalBezier2d): (s: RationalBezier2d) => RationalBezier2d;
+    /**
+     * Hands the bezier's full weighted control-point array to `f` and uses its
+     * returned `RationalBezier2d` as the result.
+     *
+     * @param s - The rational bezier.
+     * @param f - The bulk transform.
+     * @returns The `RationalBezier2d` returned by `f`.
+     * @since 2.0.0
+     */
+    (s: RationalBezier2d, f: (points: ReadonlyArray<Weighted>) => RationalBezier2d): RationalBezier2d;
+};
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to every control-point position of a
+     * `RationalBezier2d`, preserving each point's weight. Rational Bézier
+     * evaluation is `Σ w_i N_i(t) P_i / Σ w_i N_i(t)`; affine maps commute with
+     * the numerator's barycentric combination, so transforming positions while
+     * holding weights fixed exactly parameterizes the affine image of the
+     * original curve.
+     *
+     * @param s - The rational bezier.
+     * @param a - The affine transform.
+     * @returns A new `RationalBezier2d` whose positions are the affine images
+     *   of the input's, with weights unchanged.
+     * @since 2.0.0
+     */
+    (s: RationalBezier2d, a: Affine2d): RationalBezier2d;
+    /**
+     * Applies an `Affine2d` transform to every control-point position of a
+     * `RationalBezier2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `RationalBezier2d` and returns the transformed bezier.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (s: RationalBezier2d) => RationalBezier2d;
+};
 export declare const subdivide: {
     /**
      * Splits a `RationalBezier2d` at the given global parameter `u ∈ (0, 1)`

package/dist/transform/affine2d.d.ts

@@ -0,0 +1,339 @@
+import type { Matrix2x2 } from '../matrix/matrix2x2.ts';
+import type { Matrix3x3 } from '../matrix/matrix3x3.ts';
+import type * as Solution from '../solution/solution.ts';
+import type { Pipeable } from '../utils.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+import type { Affine2dTypeId } from './affine2d.internal.ts';
+import type { AffineTraits, Invertible } from './traits.ts';
+export type { Invertible } from './traits.ts';
+/**
+ * A 2D affine transformation — the most general map of the form
+ *
+ * ```
+ * x' = a · x + b · y + tx
+ * y' = c · x + d · y + ty
+ * ```
+ *
+ * Represented internally as a 3×3 matrix in homogeneous form (the third row is
+ * always `[0, 0, 1]`), so that composition is matrix multiplication and a
+ * single instance can describe any chain of translates, scales, rotations,
+ * reflections, and shears.
+ *
+ * Affine maps commute with polynomial evaluation: transforming a spline's
+ * control points and then sampling produces the same point as sampling first
+ * and then transforming. Concrete spline modules expose `transform(s, a)`
+ * helpers that take advantage of this.
+ *
+ * The `Traits` type parameter is a phantom marker that accumulates trait
+ * brands as the transform is refined via `isInvertible` / `asInvertible`. The
+ * runtime value carries no trait data — `Traits` only flows through the type
+ * system to enable tighter return types on operations like {@link inverse}.
+ *
+ * @since 2.0.0
+ */
+export interface Affine2d<out Traits = unknown> extends Pipeable {
+    readonly [Affine2dTypeId]: Affine2dTypeId;
+    readonly [AffineTraits]: Traits;
+    /**
+     * The underlying 3×3 homogeneous matrix. Last row is always `[0, 0, 1]`.
+     */
+    readonly matrix: Matrix3x3;
+}
+/**
+ * Checks if a value is an `Affine2d`.
+ *
+ * @param a - The value to check.
+ * @returns `true` if the value is an `Affine2d`, `false` otherwise.
+ * @since 2.0.0
+ */
+export declare const isAffine2d: (a: unknown) => a is Affine2d;
+/**
+ * Lifts a `Matrix3x3` into an `Affine2d` after asserting its last row is
+ * `[0, 0, 1]`. Use this when constructing affine transforms from an already-
+ * built matrix; prefer the named constructors below for ordinary usage.
+ *
+ * @param matrix - The matrix to lift. Must have a last row of `[0, 0, 1]`.
+ * @returns A new `Affine2d` wrapping the matrix.
+ * @throws If the matrix's last row is not `[0, 0, 1]` within tolerance.
+ * @since 2.0.0
+ */
+export declare const fromMatrix: (matrix: Matrix3x3) => Affine2d;
+/**
+ * The identity transform — leaves every point fixed.
+ *
+ * @since 2.0.0
+ */
+export declare const identity: Affine2d;
+/**
+ * Creates an `Affine2d` that translates by `(tx, ty)`.
+ *
+ * @param tx - The x translation.
+ * @param ty - The y translation.
+ * @returns A new translating `Affine2d`.
+ * @since 2.0.0
+ */
+export declare const translate: (tx: number, ty: number) => Affine2d;
+/**
+ * Creates an `Affine2d` that translates by the components of a `Vector2`.
+ *
+ * @param v - The vector whose components define the translation.
+ * @returns A new translating `Affine2d`.
+ * @since 2.0.0
+ */
+export declare const translateBy: (v: Vector2) => Affine2d;
+export declare const scale: {
+    /**
+     * Creates an `Affine2d` that scales uniformly by `xy` on both axes,
+     * centered on the origin.
+     *
+     * @param xy - The uniform scale factor.
+     * @returns A new scaling `Affine2d`.
+     * @since 2.0.0
+     */
+    (xy: number): Affine2d;
+    /**
+     * Creates an `Affine2d` that scales by `sx` on the x axis and `sy` on the
+     * y axis, centered on the origin.
+     *
+     * @param sx - The x scale factor.
+     * @param sy - The y scale factor.
+     * @returns A new scaling `Affine2d`.
+     * @since 2.0.0
+     */
+    (sx: number, sy: number): Affine2d;
+};
+/**
+ * Creates an `Affine2d` that scales by `(sx, sy)` about `origin`. Points at
+ * `origin` are left fixed; every other point moves toward or away from
+ * `origin` along the corresponding axis.
+ *
+ * @param sx - The x scale factor.
+ * @param sy - The y scale factor.
+ * @param origin - The fixed point of the scaling.
+ * @returns A new scaling `Affine2d`.
+ * @since 2.0.0
+ */
+export declare const scaleAround: (sx: number, sy: number, origin: Vector2) => Affine2d;
+/**
+ * Creates an `Affine2d` that rotates by `theta` radians around the origin.
+ * Counter-clockwise in the standard mathematical orientation (with y up); if
+ * your coordinate system has y down, rotation is clockwise.
+ *
+ * @param theta - The rotation angle in radians.
+ * @returns A new rotating `Affine2d`.
+ * @since 2.0.0
+ */
+export declare const rotate: (theta: number) => Affine2d;
+/**
+ * Creates an `Affine2d` that rotates by `theta` radians around `origin`.
+ *
+ * @param theta - The rotation angle in radians.
+ * @param origin - The fixed point of the rotation.
+ * @returns A new rotating `Affine2d`.
+ * @since 2.0.0
+ */
+export declare const rotateAround: (theta: number, origin: Vector2) => Affine2d;
+/**
+ * Reflects points across the x axis: `(x, y) → (x, -y)`.
+ *
+ * @since 2.0.0
+ */
+export declare const reflectX: Affine2d;
+/**
+ * Reflects points across the y axis: `(x, y) → (-x, y)`.
+ *
+ * @since 2.0.0
+ */
+export declare const reflectY: Affine2d;
+/**
+ * Creates an `Affine2d` that reflects across the line passing through
+ * `origin` in the direction `direction`. `direction` need not be unit length;
+ * it is normalized internally.
+ *
+ * @param origin - A point on the mirror line.
+ * @param direction - A non-zero vector parallel to the mirror line.
+ * @returns A new reflecting `Affine2d`.
+ * @throws If `direction` is the zero vector.
+ * @since 2.0.0
+ */
+export declare const reflectAcrossLine: (origin: Vector2, direction: Vector2) => Affine2d;
+/**
+ * Creates an `Affine2d` shear with `kx` horizontal shear (x gains `kx · y`)
+ * and `ky` vertical shear (y gains `ky · x`).
+ *
+ * @param kx - The horizontal shear factor.
+ * @param ky - The vertical shear factor.
+ * @returns A new shearing `Affine2d`.
+ * @since 2.0.0
+ */
+export declare const shear: (kx: number, ky: number) => Affine2d;
+export declare const andThen: {
+    /**
+     * Sequences two `Affine2d` transforms, applying `a` first and then `b`.
+     * Designed for pipe chains:
+     *
+     * ```ts
+     * import * as Affine2d from 'curvy/transform'
+     *
+     * const t = Affine2d.identity.pipe(
+     *   Affine2d.andThen(Affine2d.translate(1, 0)),
+     *   Affine2d.andThen(Affine2d.rotate(Math.PI / 2)),
+     * )
+     * // applying t = translate first, then rotate
+     * ```
+     *
+     * In matrix terms this returns `b · a`, the matrix that yields the same
+     * result as applying `a` then `b` to a column-vector point.
+     *
+     * @param a - The transform applied first.
+     * @param b - The transform applied second.
+     * @returns A new combined `Affine2d`.
+     * @since 2.0.0
+     */
+    (a: Affine2d, b: Affine2d): Affine2d;
+    /**
+     * Pipe-friendly form of {@link andThen}. `andThen(b)(a)` applies `a` then
+     * `b`.
+     *
+     * @param b - The transform applied after the piped-in transform.
+     * @returns A function that takes the transform to apply first and returns the sequenced transform.
+     * @since 2.0.0
+     */
+    (b: Affine2d): (a: Affine2d) => Affine2d;
+};
+export declare const inverse: {
+    /**
+     * Inverts an `Invertible`-branded `Affine2d`. Because the brand guarantees
+     * non-singularity, the result is always a single transform — wrapped in
+     * `Solution.One`.
+     *
+     * @param a - The transform to invert.
+     * @since 2.0.0
+     */
+    <T extends Invertible>(a: Affine2d<T>): Solution.One<Affine2d<T>>;
+    /**
+     * Inverts an `Affine2d`. Returns `Solution.none` if the transform is
+     * singular (e.g. a scale with a zero factor). Use {@link asInvertible} or
+     * {@link isInvertible} to refine the type and tighten the return to
+     * `Solution.One`, or use {@link inverseUnsafe} if you want the throwing form.
+     *
+     * @param a - The transform to invert.
+     * @since 2.0.0
+     */
+    <T>(a: Affine2d<T>): Solution.AtMostOne<Affine2d<T>>;
+};
+/**
+ * Inverts an `Affine2d`. Throws when the transform is singular (e.g. a scale
+ * with a zero factor). Useful when invertibility has already been validated
+ * out-of-band; otherwise prefer {@link inverse}.
+ *
+ * @param a - The transform to invert.
+ * @returns The inverse transform.
+ * @throws If `a` is singular.
+ * @since 2.0.0
+ */
+export declare const inverseUnsafe: (a: Affine2d) => Affine2d;
+/**
+ * Type-narrowing predicate: refines an `Affine2d<T>` to
+ * `Affine2d<T & Invertible>` when the underlying matrix is invertible
+ * (determinant non-zero within the default absolute tolerance).
+ *
+ * @param a - The transform to check.
+ * @returns `true` when `a` is invertible.
+ * @since 2.0.0
+ */
+export declare const isInvertible: <T>(a: Affine2d<T>) => a is Affine2d<T & Invertible>;
+/**
+ * Asserts that the transform is invertible, throwing on a singular transform.
+ *
+ * @param a - The transform to assert against.
+ * @returns The same transform, typed with the `Invertible` brand.
+ * @throws When `a` is singular.
+ * @since 2.0.0
+ */
+export declare const asInvertible: <T>(a: Affine2d<T>) => Affine2d<T & Invertible>;
+export declare const apply: {
+    /**
+     * Applies an `Affine2d` to a `Vector2`, returning the transformed point.
+     *
+     * @param a - The transform to apply.
+     * @param p - The point to transform.
+     * @returns The transformed point.
+     * @since 2.0.0
+     */
+    (a: Affine2d, p: Vector2): Vector2;
+    /**
+     * Applies an `Affine2d` to a `Vector2`.
+     *
+     * @param p - The point to transform.
+     * @returns A function that takes the transform and returns the transformed point.
+     * @since 2.0.0
+     */
+    (p: Vector2): (a: Affine2d) => Vector2;
+};
+/**
+ * Returns a `Vector2 → Vector2` function that applies `a` to its argument.
+ * Designed as the bridge to per-point mappers like `Bezier2d.mapPoints`:
+ *
+ * ```ts
+ * Bezier2d.mapPoints(spline, Affine2d.applyTo(transform))
+ * ```
+ *
+ * @param a - The transform to lift.
+ * @returns A function that applies `a` to a point.
+ * @since 2.0.0
+ */
+export declare const applyTo: (a: Affine2d) => (p: Vector2) => Vector2;
+/**
+ * Extracts the 2×2 linear part of an `Affine2d` — the upper-left block of
+ * its homogeneous matrix, ignoring translation. Maps direction vectors
+ * (tangents, differences of points) under the transform.
+ *
+ * @param a - The transform.
+ * @returns The 2×2 linear part.
+ * @since 2.0.0
+ */
+export declare const linear: (a: Affine2d) => Matrix2x2;
+/**
+ * Extracts the translation vector of an `Affine2d` — the third column of its
+ * homogeneous matrix, ignoring the linear part.
+ *
+ * @param a - The transform.
+ * @returns The translation vector.
+ * @since 2.0.0
+ */
+export declare const translation: (a: Affine2d) => Vector2;
+/**
+ * Returns the `Affine2d` corresponding to `a`'s linear part with translation
+ * zeroed. Equivalent to building an affine from {@link linear} but stays in
+ * the `Affine2d` type so it can be applied via {@link apply} or {@link applyTo}.
+ *
+ * Use this to transform anything that is *not* a position — tangent vectors
+ * in Hermite control data, or the higher-degree coefficients of a polynomial
+ * curve, both of which see only the linear part of an affine map.
+ *
+ * @param a - The transform.
+ * @returns The translation-free `Affine2d`.
+ * @since 2.0.0
+ */
+export declare const linearPart: (a: Affine2d) => Affine2d;
+export declare const equals: {
+    /**
+     * Checks if two `Affine2d` instances are approximately equal within the
+     * default absolute tolerance.
+     *
+     * @param a - The first transform.
+     * @param b - The second transform.
+     * @returns `true` when each matrix entry is within tolerance.
+     * @since 2.0.0
+     */
+    (a: Affine2d, b: Affine2d): boolean;
+    /**
+     * Checks if two `Affine2d` instances are approximately equal.
+     *
+     * @param b - The second transform.
+     * @returns A function that takes the first transform and returns the comparison.
+     * @since 2.0.0
+     */
+    (b: Affine2d): (a: Affine2d) => boolean;
+};

package/dist/transform/affine2d.internal.d.ts

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

package/dist/transform/index.d.ts

@@ -0,0 +1,3 @@
+import * as Affine2dNs from './affine2d.ts';
+export type Affine2d = Affine2dNs.Affine2d;
+export { Affine2dNs as Affine2d };

package/dist/transform/index.mjs

@@ -0,0 +1,2 @@
+import { t as affine2d_exports } from "../shared/affine2d-Dvna84gc.mjs";
+export { affine2d_exports as Affine2d };

package/dist/transform/traits.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Trait brands for affine transforms.
+ *
+ * The `Invertible` brand is shared with matrices — an invertible `Affine2d`
+ * is one whose underlying 3x3 matrix is invertible — so it is re-exported
+ * from {@link ../matrix/traits.ts} rather than redeclared here.
+ *
+ * @since 2.0.0
+ */
+export type { Invertible } from '../matrix/traits.ts';
+/**
+ * Phantom property key used by affine interfaces to hold their `Traits` type
+ * parameter. The runtime object never has a value at this key — the `declare`
+ * modifier on the impl class makes the property type-visible only.
+ *
+ * @since 2.0.0
+ */
+export declare const AffineTraits: unique symbol;
+export type AffineTraits = typeof AffineTraits;

package/dist/vector/index.mjs

@@ -1,4 +1,4 @@
-import { l as vector2_exports } from "../shared/vector2-CSkaMXvp.mjs";
-import { n as vector3_exports } from "../shared/vector3-CR2LPV03.mjs";
-import { r as vector4_exports } from "../shared/vector4-PO_7EYd-.mjs";
+import { u as vector2_exports } from "../shared/vector2-DuA3EmfL.mjs";
+import { n as vector3_exports } from "../shared/vector3-oxtggkDp.mjs";
+import { r as vector4_exports } from "../shared/vector4-DGHuCvTV.mjs";
 export { vector2_exports as Vector2, vector3_exports as Vector3, vector4_exports as Vector4 };

package/dist/vector/vector2.d.ts

@@ -87,6 +87,55 @@ export declare const withWeight: {
  * @since 2.0.0
  */
 export declare const unweighted: (w: Weighted) => Vector2;
+export declare const liftWithWeight: {
+    /**
+     * Lifts a `Vector2 → Vector2` function to operate on `Vector2.Weighted` by
+     * applying the function to the position and preserving the input's weight.
+     *
+     * Designed as the bridge between point-only utilities (e.g. {@link setR},
+     * `Vector2.add(offset)`) and weighted-spline mappers like
+     * `RationalBezier2d.mapPoints`. The default of "preserve weight" is the safe
+     * choice for the common case — translating, rotating, or scaling positions
+     * on a curve like a conic arc shouldn't silently collapse the curve's
+     * geometry-defining weights to a uniform value.
+     *
+     * @param fn - The position-only function to lift.
+     * @returns A function from `Weighted` to `Weighted` that preserves weight.
+     * @since 2.0.0
+     */
+    (fn: (v: Vector2) => Vector2): (w: Weighted) => Weighted;
+    /**
+     * Lifts a `Vector2 → Vector2` function to operate on `Vector2.Weighted`,
+     * replacing the input's weight with the given value.
+     *
+     * @param fn - The position-only function to lift.
+     * @param weight - The positive scalar weight to attach to each output.
+     * @returns A function from `Weighted` to `Weighted` that overrides weight.
+     * @since 2.0.0
+     */
+    (fn: (v: Vector2) => Vector2, weight: number): (w: Weighted) => Weighted;
+    /**
+     * Applies a `Vector2 → Vector2` function to the position of a
+     * `Vector2.Weighted`, preserving the input's weight.
+     *
+     * @param w - The weighted point to transform.
+     * @param fn - The position-only function to apply.
+     * @returns A new `Vector2.Weighted` with the function applied to position and the original weight.
+     * @since 2.0.0
+     */
+    (w: Weighted, fn: (v: Vector2) => Vector2): Weighted;
+    /**
+     * Applies a `Vector2 → Vector2` function to the position of a
+     * `Vector2.Weighted`, replacing the weight with the given value.
+     *
+     * @param w - The weighted point to transform.
+     * @param fn - The position-only function to apply.
+     * @param weight - The positive scalar weight to attach to the output.
+     * @returns A new `Vector2.Weighted` with the function applied to position and the overridden weight.
+     * @since 2.0.0
+     */
+    (w: Weighted, fn: (v: Vector2) => Vector2, weight: number): Weighted;
+};
 export declare const weightedEquals: {
     /**
      * Checks if two `Vector2.Weighted` instances are approximately equal —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "curvy",
-  "version": "2.0.0-alpha.13",
+  "version": "2.0.0-alpha.14",
   "description": "Spline and Curve utilities",
   "homepage": "https://github.com/tkofh/curvy#readme",
   "bugs": {
@@ -58,6 +58,10 @@
       "types": "./dist/characteristic/index.d.ts",
       "import": "./dist/characteristic/index.mjs"
     },
+    "./transform": {
+      "types": "./dist/transform/index.d.ts",
+      "import": "./dist/transform/index.mjs"
+    },
     "./number": {
       "types": "./dist/number.d.ts",
       "import": "./dist/number.mjs"

package/dist/shared/characteristic-BkEr-rr8.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"characteristic-BkEr-rr8.mjs","names":["Matrix4x4.make","CubicPolynomial.fromVector","Matrix4x4.vectorProductLeft"],"sources":["../../src/characteristic/characteristic.ts"],"sourcesContent":["import * as Matrix4x4 from '../matrix/matrix4x4.ts'\nimport * as CubicPolynomial from '../polynomial/cubic.ts'\nimport { roundDown } from '../number.ts'\nimport type * as Vector4 from '../vector/vector4.ts'\n\n/**\n * The cubic Bézier characteristic matrix.\n *\n * Maps Bernstein-basis control points `(P₀, P₁, P₂, P₃)` to monomial cubic\n * coefficients `(c₀, c₁, c₂, c₃)` for `c₀ + c₁·t + c₂·t² + c₃·t³`. The matrix\n * IS the Bézier spline family — combined with control points (via {@link apply}),\n * it produces the cubic polynomial that parameterizes the curve.\n *\n * @since 2.0.0\n */\nexport const cubicBezier: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1,\n  0,\n  0,\n  0,\n  -3,\n  3,\n  0,\n  0,\n  3,\n  -6,\n  3,\n  0,\n  -1,\n  3,\n  -3,\n  1,\n)\n\n/**\n * The cubic Hermite characteristic matrix.\n *\n * Maps Hermite control data `(P₀, V₀, P₁, V₁)` — two endpoints and two\n * tangent vectors — to monomial cubic coefficients.\n *\n * @since 2.0.0\n */\nexport const cubicHermite: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1,\n  0,\n  0,\n  0,\n  0,\n  1,\n  0,\n  0,\n  -3,\n  -2,\n  3,\n  -1,\n  2,\n  1,\n  -2,\n  1,\n)\n\n/**\n * The uniform cubic B-spline (basis spline) characteristic matrix.\n *\n * Maps a window of four control points to the monomial cubic coefficients\n * of one segment of the corresponding uniform cubic B-spline. Stride-1\n * application produces a C² piecewise spline; the curve does not generally\n * pass through the control points.\n *\n * @since 2.0.0\n */\nexport const cubicBasisSpline: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1 / 6,\n  4 / 6,\n  roundDown(1 / 6),\n  0,\n  -0.5,\n  0,\n  0.5,\n  0,\n  0.5,\n  -1,\n  0.5,\n  0,\n  -1 / 6,\n  0.5,\n  -0.5,\n  1 / 6,\n)\n\nconst cardinalCache = new Map<number, Matrix4x4.Matrix4x4>()\n\n/**\n * The cubic Cardinal spline characteristic matrix, parameterized by tension.\n *\n * Maps four control points to the monomial cubic coefficients of one\n * Cardinal segment. The tension `s` controls how tightly the curve hugs\n * the control points: `s = 0` produces straight-line segments between\n * adjacent points, `s = 0.5` is the Catmull-Rom variant (see\n * {@link cubicCatmullRom}), and higher values produce looser, more curved\n * shapes.\n *\n * Cached per tension value — repeated calls with the same tension return\n * the same matrix instance.\n *\n * @param tension - The tension parameter.\n * @returns The characteristic matrix for that tension.\n * @since 2.0.0\n */\nexport const cubicCardinal = (tension: number): Matrix4x4.Matrix4x4 => {\n  let m = cardinalCache.get(tension)\n  if (m === undefined) {\n    m = Matrix4x4.make(\n      0,\n      1,\n      0,\n      0,\n      -tension,\n      0,\n      tension,\n      0,\n      2 * tension,\n      tension - 3,\n      3 - 2 * tension,\n      -tension,\n      -tension,\n      2 - tension,\n      tension - 2,\n      tension,\n    )\n    cardinalCache.set(tension, m)\n  }\n  return m\n}\n\n/**\n * The cubic Catmull-Rom characteristic matrix — Cardinal with tension `0.5`.\n * The most common Cardinal-family variant; reused widely enough to deserve\n * a constant.\n *\n * @since 2.0.0\n */\nexport const cubicCatmullRom: Matrix4x4.Matrix4x4 = cubicCardinal(0.5)\n\n/**\n * Applies a characteristic matrix to N channels of control values, producing\n * N cubic polynomials in monomial form.\n *\n * Each channel is a `Vector4` packing one axis's values across the four\n * control points: `(v₀, v₁, v₂, v₃)`. The result tuple has the same arity\n * as the input.\n *\n * The polynomial 2D spline pipeline applies this with two channels (x, y);\n * the rational 2D pipeline uses three (x, y, w) where `w` is the projective\n * denominator. Higher channel counts generalize to 3D, rational 3D, and\n * beyond — the characteristic matrix doesn't care about the geometric\n * domain, only about how to combine four samples per channel.\n *\n * @param matrix - The characteristic matrix of the spline family.\n * @param channels - One `Vector4` per output polynomial, packing the four control values for that channel.\n * @returns A tuple of cubic polynomials, one per input channel.\n * @since 2.0.0\n */\nexport const apply = <const Channels extends ReadonlyArray<Vector4.Vector4>>(\n  matrix: Matrix4x4.Matrix4x4,\n  ...channels: Channels\n): { readonly [K in keyof Channels]: CubicPolynomial.CubicPolynomial } => {\n  const result = channels.map((c) =>\n    CubicPolynomial.fromVector(Matrix4x4.vectorProductLeft(matrix, c)),\n  )\n  return result as { readonly [K in keyof Channels]: CubicPolynomial.CubicPolynomial }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAeA,MAAa,cAAmCA,KAC9C,GACA,GACA,GACA,GACA,IACA,GACA,GACA,GACA,GACA,IACA,GACA,GACA,IACA,GACA,IACA,EACD;;;;;;;;;AAUD,MAAa,eAAoCA,KAC/C,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IACA,IACA,GACA,IACA,GACA,GACA,IACA,EACD;;;;;;;;;;;AAYD,MAAa,mBAAwCA,KACnD,IAAI,GACJ,IAAI,GACJ,UAAU,IAAI,EAAE,EAChB,GACA,KACA,GACA,IACA,GACA,IACA,IACA,IACA,GACA,KAAK,GACL,IACA,KACA,IAAI,EACL;AAED,MAAM,gCAAgB,IAAI,KAAkC;;;;;;;;;;;;;;;;;;AAmB5D,MAAa,iBAAiB,YAAyC;CACrE,IAAI,IAAI,cAAc,IAAI,QAAQ;CAClC,IAAI,MAAM,KAAA,GAAW;EACnB,IAAIA,KACF,GACA,GACA,GACA,GACA,CAAC,SACD,GACA,SACA,GACA,IAAI,SACJ,UAAU,GACV,IAAI,IAAI,SACR,CAAC,SACD,CAAC,SACD,IAAI,SACJ,UAAU,GACV,QACD;EACD,cAAc,IAAI,SAAS,EAAE;;CAE/B,OAAO;;;;;;;;;AAUT,MAAa,kBAAuC,cAAc,GAAI;;;;;;;;;;;;;;;;;;;;AAqBtE,MAAa,SACX,QACA,GAAG,aACqE;CAIxE,OAHe,SAAS,KAAK,MAC3BC,WAA2BC,kBAA4B,QAAQ,EAAE,CAAC,CAEvD"}