bireactive 0.2.0

package/dist/core/lenses/typed-factor.js

@@ -0,0 +1,376 @@
+// typed-factor.ts — heterogeneous-output factor lens.
+//
+// Generalises `factorLens` (scalar-only) to typed inputs/outputs via the
+// `Pack` trait. Inputs and outputs are flat-packed; the Jacobian is the
+// full M×N matrix; writing one channel sends a sparse δy through the LSQ
+// pseudoinverse. Invariance is approximate (the Jacobian path) — use
+// closed-form lenses like `procrustesLens` for exactness.
+//
+//   const { centroid, rotation, scale } = factor([v1, v2, v3] as const, {
+//     centroid: { Cls: Vec, fwd: pts => … },
+//     rotation: { Cls: Num, fwd: pts => atan2(…) },
+//     scale:    { Cls: Num, fwd: pts => hypot(…) },
+//   });
+//   centroid.value = { x: 100, y: 50 };  // typed
+//
+// `bundle()` is the 1→M case: `factor()` over a single typed source.
+import { Num, Vec, } from "../index.js";
+function getPack(cell) {
+    const ctor = cell.constructor;
+    const p = ctor.traits?.pack;
+    if (!p) {
+        const name = ctor.name ?? "?";
+        throw new Error(`typed-factor: ${name} has no traits.pack`);
+    }
+    return p;
+}
+function getPackFromCls(Cls) {
+    const p = Cls.traits?.pack;
+    if (!p) {
+        const name = Cls.name ?? "?";
+        throw new Error(`typed-factor: ${name} has no traits.pack`);
+    }
+    return p;
+}
+function cumOffsets(dims) {
+    const out = [];
+    let acc = 0;
+    for (const d of dims) {
+        out.push(acc);
+        acc += d;
+    }
+    return out;
+}
+export function factor(inputs, outputs, opts = {}) {
+    const inputCount = inputs.length;
+    if (inputCount === 0) {
+        throw new Error("typed-factor: need ≥ 1 input");
+    }
+    const inputPacks = inputs.map(s => getPack(s));
+    const inputDims = inputPacks.map(p => p.dim);
+    const inputOffsets = cumOffsets(inputDims);
+    const N = inputDims.reduce((s, d) => s + d, 0);
+    // Map each flat input index back to its source input index — used
+    // to know which typed input to re-unpack after FD perturbation.
+    const whichInput = new Array(N);
+    for (let k = 0; k < inputCount; k++) {
+        for (let d = 0; d < inputDims[k]; d++) {
+            whichInput[inputOffsets[k] + d] = k;
+        }
+    }
+    const outputKeys = Object.keys(outputs);
+    const outputCount = outputKeys.length;
+    if (outputCount === 0) {
+        throw new Error("typed-factor: need ≥ 1 output");
+    }
+    const outputSpecs = outputKeys.map(k => outputs[k]);
+    const outputPacks = outputSpecs.map(s => getPackFromCls(s.Cls));
+    const outputDims = outputPacks.map(p => p.dim);
+    const outputOffsets = cumOffsets(outputDims);
+    const M = outputDims.reduce((s, d) => s + d, 0);
+    const weights = opts.inputWeights ?? Array.from({ length: N }, () => 1);
+    if (weights.length !== N) {
+        throw new Error(`typed-factor: inputWeights length ${weights.length} ≠ flat input dim ${N}`);
+    }
+    const eps = opts.eps ?? 1e-5;
+    const lambda = opts.damping ?? 1e-6;
+    const converge = opts.converge ?? false;
+    const maxIters = opts.maxIters ?? 10;
+    const tol = opts.tol ?? 1e-4;
+    // All-or-nothing analytical Jacobian: skip FD only when every output
+    // supplies one (no mixed mode).
+    const useAnalyticalJ = outputSpecs.every(s => s.jacobian !== undefined);
+    // Shared scratch buffers — safe across the M cells because writes
+    // execute synchronously inside one `_setWithExclusion` call.
+    const flatIn = new Float64Array(N);
+    const flatOutBase = new Float64Array(M);
+    const flatOutPerturbed = new Float64Array(M);
+    const J = new Float64Array(M * N);
+    const A = new Float64Array(M * M);
+    const Ainv = new Float64Array(M * M);
+    const dy = new Float64Array(M);
+    const kvec = new Float64Array(M);
+    // Per-write driver, shared by all M cells.
+    const computeBwd = (channelIdx, // which named output is being written
+    target, vals) => {
+        // 1. Pack current inputs → flatIn
+        for (let k = 0; k < inputCount; k++) {
+            inputPacks[k].read(vals[k], flatIn, inputOffsets[k]);
+        }
+        // FD working copies: typedScratch[k] is re-unpacked when its slice of
+        // flatIn is perturbed.
+        const typedScratch = vals.slice();
+        // 2. Base outputs
+        for (let j = 0; j < outputCount; j++) {
+            const out = outputSpecs[j].fwd(typedScratch);
+            outputPacks[j].read(out, flatOutBase, outputOffsets[j]);
+        }
+        // 3. δy: sparse, only channelIdx's slice is non-zero.
+        dy.fill(0);
+        {
+            const dim = outputDims[channelIdx];
+            const baseOff = outputOffsets[channelIdx];
+            // Pack target into flatOutPerturbed (reused buffer, no allocation).
+            outputPacks[channelIdx].read(target, flatOutPerturbed, baseOff);
+            for (let i = 0; i < dim; i++) {
+                dy[baseOff + i] = flatOutPerturbed[baseOff + i] - flatOutBase[baseOff + i];
+            }
+        }
+        // 4. Build Jacobian. Either analytical (fast + exact) or FD.
+        if (useAnalyticalJ) {
+            for (let j = 0; j < outputCount; j++) {
+                const rows = outputSpecs[j].jacobian(typedScratch);
+                const dim = outputDims[j];
+                const baseOff = outputOffsets[j];
+                for (let d = 0; d < dim; d++) {
+                    const row = rows[d];
+                    for (let i = 0; i < N; i++) {
+                        J[(baseOff + d) * N + i] = row[i];
+                    }
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < N; i++) {
+                const saved = flatIn[i];
+                flatIn[i] = saved + eps;
+                const k = whichInput[i];
+                typedScratch[k] = inputPacks[k].write(flatIn, inputOffsets[k]);
+                for (let j = 0; j < outputCount; j++) {
+                    const o = outputSpecs[j].fwd(typedScratch);
+                    outputPacks[j].read(o, flatOutPerturbed, outputOffsets[j]);
+                    const dim = outputDims[j];
+                    const baseOff = outputOffsets[j];
+                    for (let d = 0; d < dim; d++) {
+                        J[(baseOff + d) * N + i] =
+                            (flatOutPerturbed[baseOff + d] - flatOutBase[baseOff + d]) / eps;
+                    }
+                }
+                flatIn[i] = saved;
+                // Restore the affected typed input to its base value.
+                typedScratch[k] = inputPacks[k].write(flatIn, inputOffsets[k]);
+            }
+        }
+        // 5. A = J W J^T + λI
+        for (let r = 0; r < M; r++) {
+            for (let c = 0; c < M; c++) {
+                let s = 0;
+                for (let i = 0; i < N; i++) {
+                    s += J[r * N + i] * weights[i] * J[c * N + i];
+                }
+                A[r * M + c] = s + (r === c ? lambda : 0);
+            }
+        }
+        // 6. Solve A · k = δy
+        if (!invertMatrix(A, M, Ainv)) {
+            return vals.map(() => undefined);
+        }
+        for (let r = 0; r < M; r++) {
+            let s = 0;
+            for (let c = 0; c < M; c++)
+                s += Ainv[r * M + c] * dy[c];
+            kvec[r] = s;
+        }
+        // 7. δx = W J^T k, applied to flatIn → produces new flat input vector.
+        //    Then unpack per-input to typed updates.
+        const updates = new Array(inputCount);
+        for (let k = 0; k < inputCount; k++) {
+            const baseOff = inputOffsets[k];
+            const dim = inputDims[k];
+            let anyChange = false;
+            for (let d = 0; d < dim; d++) {
+                const flatIdx = baseOff + d;
+                const w = weights[flatIdx];
+                if (w === 0)
+                    continue;
+                let dxi = 0;
+                for (let r = 0; r < M; r++)
+                    dxi += J[r * N + flatIdx] * kvec[r];
+                const newVal = flatIn[flatIdx] + w * dxi;
+                if (newVal !== flatIn[flatIdx])
+                    anyChange = true;
+                flatIn[flatIdx] = newVal;
+            }
+            updates[k] = anyChange
+                ? inputPacks[k].write(flatIn, baseOff)
+                : undefined;
+        }
+        return updates;
+    };
+    const result = {};
+    for (let k = 0; k < outputCount; k++) {
+        const idx = k;
+        const key = outputKeys[idx];
+        const spec = outputSpecs[idx];
+        // biome-ignore lint/suspicious/noExplicitAny: typed at facade
+        const Cls = spec.Cls;
+        // Auto-converging backward: iterate the single-Newton step until the
+        // channel's reading is within tol (1 iter when linear). Runs on a local
+        // copy inside `put`, so the engine applies converged inputs in one shot.
+        const outPack = outputPacks[idx];
+        const outDim = outputDims[idx];
+        const convergeBwd = (target, vals) => {
+            const targetBuf = new Float64Array(outDim);
+            const currentBuf = new Float64Array(outDim);
+            outPack.read(target, targetBuf, 0);
+            const cur = vals.slice();
+            for (let it = 0; it < maxIters; it++) {
+                const updates = computeBwd(idx, target, cur);
+                for (let i = 0; i < cur.length; i++) {
+                    if (updates[i] !== undefined)
+                        cur[i] = updates[i];
+                }
+                outPack.read(spec.fwd(cur), currentBuf, 0);
+                let sumSq = 0;
+                for (let d = 0; d < outDim; d++) {
+                    const diff = targetBuf[d] - currentBuf[d];
+                    sumSq += diff * diff;
+                }
+                if (Math.sqrt(sumSq) < tol)
+                    break;
+            }
+            return cur;
+        };
+        const cell = Cls.lens(inputs, (vals) => spec.fwd(vals), converge
+            ? (target, vals) => convergeBwd(target, vals)
+            : (target, vals) => computeBwd(idx, target, vals));
+        result[key] = cell;
+    }
+    return result;
+}
+// factorTuple — positional API.
+//
+// Same engine, no names. Outputs are a tuple of specs; the result is a
+// tuple of writables. Terser to destructure, but order-sensitive and
+// loses self-documenting names.
+export function factorTuple(inputs, outputs, opts = {}) {
+    // Wrap to named, call factor, unwrap (one-time setup; hot path identical).
+    // biome-ignore lint/suspicious/noExplicitAny: variance escape
+    const named = {};
+    for (let i = 0; i < outputs.length; i++)
+        named[String(i)] = outputs[i];
+    const result = factor(inputs, named, opts);
+    return outputs.map((_, i) => result[String(i)]);
+}
+// bundle — 1→M dual, sugar over factor() with one input.
+//
+// A single typed source factored into M coupled views — `factor()` with
+// a length-1 input array. Writing a view sends a sparse δy through the
+// Jacobian solve (small, since N = the source's pack dim).
+export function bundle(source, views, opts = {}) {
+    // factor() takes an input array, so pass [source] and wrap each view's
+    // fwd to receive the single-element array form.
+    // biome-ignore lint/suspicious/noExplicitAny: variance escape
+    const wrapped = {};
+    for (const key of Object.keys(views)) {
+        const v = views[key];
+        wrapped[key] = {
+            Cls: v.Cls,
+            // biome-ignore lint/suspicious/noExplicitAny: variance escape
+            fwd: (inputs) => v.fwd([inputs[0]]),
+            jacobian: v.jacobian
+                ? // biome-ignore lint/suspicious/noExplicitAny: variance escape
+                    (inputs) => v.jacobian([inputs[0]])
+                : undefined,
+        };
+    }
+    return factor([source], wrapped, opts);
+}
+// For field-style bundles, `field()` already covers the independent case;
+// use `bundle()` when you want coupled writes through the Jacobian solve.
+// Matrix inverse (Gauss-Jordan with partial pivoting).
+function invertMatrix(A, M, out) {
+    const W = 2 * M;
+    const aug = new Float64Array(M * W);
+    for (let r = 0; r < M; r++) {
+        for (let c = 0; c < M; c++)
+            aug[r * W + c] = A[r * M + c];
+        for (let c = 0; c < M; c++)
+            aug[r * W + M + c] = r === c ? 1 : 0;
+    }
+    for (let i = 0; i < M; i++) {
+        let p = i;
+        let pv = Math.abs(aug[i * W + i]);
+        for (let r = i + 1; r < M; r++) {
+            const v = Math.abs(aug[r * W + i]);
+            if (v > pv) {
+                pv = v;
+                p = r;
+            }
+        }
+        if (pv < 1e-14)
+            return false;
+        if (p !== i) {
+            for (let c = 0; c < W; c++) {
+                const t = aug[i * W + c];
+                aug[i * W + c] = aug[p * W + c];
+                aug[p * W + c] = t;
+            }
+        }
+        const inv = 1 / aug[i * W + i];
+        for (let c = 0; c < W; c++)
+            aug[i * W + c] *= inv;
+        for (let r = 0; r < M; r++) {
+            if (r === i)
+                continue;
+            const f = aug[r * W + i];
+            if (f === 0)
+                continue;
+            for (let c = 0; c < W; c++)
+                aug[r * W + c] -= f * aug[i * W + c];
+        }
+    }
+    for (let r = 0; r < M; r++) {
+        for (let c = 0; c < M; c++)
+            out[r * M + c] = aug[r * W + M + c];
+    }
+    return true;
+}
+// Sugar: closed-form Procrustes via factor() typed API.
+//
+// Procrustes with typed outputs (centroid is a real Vec) but a
+// Jacobian-LSQ bwd — a showcase for the typed ergonomics. The
+// closed-form `procrustesLens` is faster and exact.
+export function procrustesTyped(points) {
+    const K = points.length;
+    return factor(points, {
+        centroid: {
+            Cls: Vec,
+            fwd: (pts) => {
+                let sx = 0;
+                let sy = 0;
+                for (let i = 0; i < K; i++) {
+                    sx += pts[i].x;
+                    sy += pts[i].y;
+                }
+                return { x: sx / K, y: sy / K };
+            },
+        },
+        rotation: {
+            Cls: Num,
+            fwd: (pts) => {
+                let sx = 0;
+                let sy = 0;
+                for (let i = 0; i < K; i++) {
+                    sx += pts[i].x;
+                    sy += pts[i].y;
+                }
+                return Math.atan2(pts[0].y - sy / K, pts[0].x - sx / K);
+            },
+        },
+        scale: {
+            Cls: Num,
+            fwd: (pts) => {
+                let sx = 0;
+                let sy = 0;
+                for (let i = 0; i < K; i++) {
+                    sx += pts[i].x;
+                    sy += pts[i].y;
+                }
+                return Math.hypot(pts[0].x - sx / K, pts[0].y - sy / K);
+            },
+        },
+        // Damping bumped up — atan2/hypot are non-linear; without damping the
+        // first-Newton-step error compounds at the boundary of well-conditioned.
+    }, { damping: 1e-3 });
+}

package/dist/core/network-utils.d.ts

@@ -0,0 +1,14 @@
+import { type Read } from "./signal.js";
+/** Disposable handle. */
+export interface Lifecycle {
+    dispose(): void;
+}
+/** Run `body(item)` per element on first sight (storing its cleanup) and
+ *  run that cleanup when the element leaves. Identity is element
+ *  reference — keep stable refs across mutations, don't re-create
+ *  objects every frame. */
+export declare function each<T>(source: Read<readonly T[]>, body: (item: T) => () => void): Lifecycle;
+/** Run `body(v)` while `source.value` is truthy; run the returned
+ *  cleanup on falsy and re-arm. (Distinct from `anim.ts`'s one-shot
+ *  `when(sig)` Animator.) */
+export declare function when<T>(source: Read<T>, body: (v: T) => () => void): Lifecycle;

package/dist/core/network-utils.js

@@ -0,0 +1,62 @@
+// network-utils.ts — reactive-collection lifecycle helpers over the
+// `network` model. Implemented purely via `effect`:
+//
+//   `each(source, body)` — body runs per element (keyed by reference
+//                          identity); cleanup on removal.
+//   `when(source, body)` — body runs while truthy; cleanup on falsy.
+import { effect } from "./signal.js";
+/** Run `body(item)` per element on first sight (storing its cleanup) and
+ *  run that cleanup when the element leaves. Identity is element
+ *  reference — keep stable refs across mutations, don't re-create
+ *  objects every frame. */
+export function each(source, body) {
+    const handles = new Map();
+    const eff = effect(() => {
+        const items = source.value;
+        const seen = new Set(items);
+        for (const item of items) {
+            if (!handles.has(item))
+                handles.set(item, body(item));
+        }
+        for (const [item, cleanup] of handles) {
+            if (!seen.has(item)) {
+                cleanup();
+                handles.delete(item);
+            }
+        }
+    });
+    return {
+        dispose() {
+            eff();
+            for (const cleanup of handles.values())
+                cleanup();
+            handles.clear();
+        },
+    };
+}
+/** Run `body(v)` while `source.value` is truthy; run the returned
+ *  cleanup on falsy and re-arm. (Distinct from `anim.ts`'s one-shot
+ *  `when(sig)` Animator.) */
+export function when(source, body) {
+    let cleanup;
+    const eff = effect(() => {
+        const v = source.value;
+        if (v) {
+            if (cleanup === undefined)
+                cleanup = body(v);
+        }
+        else if (cleanup !== undefined) {
+            cleanup();
+            cleanup = undefined;
+        }
+    });
+    return {
+        dispose() {
+            eff();
+            if (cleanup !== undefined) {
+                cleanup();
+                cleanup = undefined;
+            }
+        },
+    };
+}

package/dist/core/new-primitives.d.ts

@@ -0,0 +1,33 @@
+import type { Cell, Writable } from "./signal.js";
+import { Num } from "./values/num.js";
+import { Vec } from "./values/vec.js";
+type V = {
+    x: number;
+    y: number;
+};
+/** Distance between two Vecs. RO — the inverse isn't unique. For a
+ *  writable variant see `radialLens`. */
+export declare function distanceLens(a: Cell<V>, b: Cell<V>): Num;
+/** Angle from `a` to `b`, in radians. RO. */
+export declare function angleLens(a: Cell<V>, b: Cell<V>): Num;
+/** Reflect `point` across the line through `axisStart`/`axisEnd`. Writes
+ *  the reflected position back to `point` (axis unchanged); reflection is
+ *  involutive, so the same formula reads and writes. */
+export declare function reflectionLens(point: Cell<V>, axisStart: Cell<V>, axisEnd: Cell<V>): Writable<Vec>;
+/** Lerp between two Vecs at parameter `t`. Writing the interpolated point
+ *  shifts both endpoints rigidly (preserving t). */
+export declare function vecLerp(a: Cell<V>, b: Cell<V>, t: Cell<number>): Writable<Vec>;
+/** Sum of two nums; writing the sum splits the delta equally between
+ *  a and b (the "pulley" conservation pattern). */
+export declare function pulleySum(a: Num, b: Num): Writable<Num>;
+/** Difference of two nums: `a - b`. Writing the difference shifts
+ *  both inputs symmetrically by ±half-delta. */
+export declare function diffLens(a: Num, b: Num): Writable<Num>;
+/** Mean of N nums, clamped to `[lo, hi]` on read and write (writes are
+ *  clamped before the delta is distributed). */
+export declare function clampedMean(parents: readonly Num[], lo: number, hi: number): Writable<Num>;
+/** Quadratic Bézier point at parameter `t`. RO. */
+export declare function bezier2(p0: Cell<V>, p1: Cell<V>, p2: Cell<V>, t: Cell<number>): Vec;
+/** Cubic Bézier point at parameter `t`. RO. */
+export declare function bezier3(p0: Cell<V>, p1: Cell<V>, p2: Cell<V>, p3: Cell<V>, t: Cell<number>): Vec;
+export {};

package/dist/core/new-primitives.js

@@ -0,0 +1,113 @@
+// new-primitives.ts — building blocks over the N-input `Cls.lens` /
+// `Cls.derive` forms. All are a few lines on top of the engine.
+import { Num } from "./values/num.js";
+import { Vec } from "./values/vec.js";
+/** Distance between two Vecs. RO — the inverse isn't unique. For a
+ *  writable variant see `radialLens`. */
+export function distanceLens(a, b) {
+    return Num.derive([a, b], vals => Math.hypot(vals[0].x - vals[1].x, vals[0].y - vals[1].y));
+}
+/** Angle from `a` to `b`, in radians. RO. */
+export function angleLens(a, b) {
+    return Num.derive([a, b], vals => Math.atan2(vals[1].y - vals[0].y, vals[1].x - vals[0].x));
+}
+/** Reflect `point` across the line through `axisStart`/`axisEnd`. Writes
+ *  the reflected position back to `point` (axis unchanged); reflection is
+ *  involutive, so the same formula reads and writes. */
+export function reflectionLens(point, axisStart, axisEnd) {
+    const reflect = (p, a, b) => {
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const len2 = dx * dx + dy * dy;
+        if (len2 === 0)
+            return p;
+        const t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+        const projX = a.x + t * dx;
+        const projY = a.y + t * dy;
+        return { x: 2 * projX - p.x, y: 2 * projY - p.y };
+    };
+    return Vec.lens([point, axisStart, axisEnd], vals => reflect(vals[0], vals[1], vals[2]), (target, vals) => [reflect(target, vals[1], vals[2]), undefined, undefined]);
+}
+/** Lerp between two Vecs at parameter `t`. Writing the interpolated point
+ *  shifts both endpoints rigidly (preserving t). */
+export function vecLerp(a, b, t) {
+    return Vec.lens([a, b, t], vals => {
+        const [av, bv, tv] = vals;
+        return { x: av.x + (bv.x - av.x) * tv, y: av.y + (bv.y - av.y) * tv };
+    }, (target, vals) => {
+        const [av, bv, tv] = vals;
+        const dx = target.x - (av.x + (bv.x - av.x) * tv);
+        const dy = target.y - (av.y + (bv.y - av.y) * tv);
+        return [{ x: av.x + dx, y: av.y + dy }, { x: bv.x + dx, y: bv.y + dy }, undefined];
+    });
+}
+/** Sum of two nums; writing the sum splits the delta equally between
+ *  a and b (the "pulley" conservation pattern). */
+export function pulleySum(a, b) {
+    return Num.lens([a, b], vals => vals[0] + vals[1], (target, vals) => {
+        const [av, bv] = vals;
+        const cur = av + bv;
+        const delta = target - cur;
+        return [av + delta / 2, bv + delta / 2];
+    });
+}
+/** Difference of two nums: `a - b`. Writing the difference shifts
+ *  both inputs symmetrically by ±half-delta. */
+export function diffLens(a, b) {
+    return Num.lens([a, b], vals => vals[0] - vals[1], (target, vals) => {
+        const [av, bv] = vals;
+        const cur = av - bv;
+        const delta = target - cur;
+        return [av + delta / 2, bv - delta / 2];
+    });
+}
+/** Mean of N nums, clamped to `[lo, hi]` on read and write (writes are
+ *  clamped before the delta is distributed). */
+export function clampedMean(parents, lo, hi) {
+    const n = parents.length;
+    const inv = 1 / n;
+    return Num.lens(parents, vals => {
+        const arr = vals;
+        let s = 0;
+        for (let i = 0; i < n; i++)
+            s += arr[i];
+        const m = s * inv;
+        return m < lo ? lo : m > hi ? hi : m;
+    }, (target, vals) => {
+        const arr = vals;
+        const clamped = target < lo ? lo : target > hi ? hi : target;
+        let s = 0;
+        for (let i = 0; i < n; i++)
+            s += arr[i];
+        const cur = s * inv;
+        const delta = clamped - cur;
+        const out = new Array(n);
+        for (let i = 0; i < n; i++)
+            out[i] = arr[i] + delta;
+        return out;
+    });
+}
+/** Quadratic Bézier point at parameter `t`. RO. */
+export function bezier2(p0, p1, p2, t) {
+    return Vec.derive([p0, p1, p2, t], vals => {
+        const [a, b, c, tv] = vals;
+        const u = 1 - tv;
+        return {
+            x: u * u * a.x + 2 * u * tv * b.x + tv * tv * c.x,
+            y: u * u * a.y + 2 * u * tv * b.y + tv * tv * c.y,
+        };
+    });
+}
+/** Cubic Bézier point at parameter `t`. RO. */
+export function bezier3(p0, p1, p2, p3, t) {
+    return Vec.derive([p0, p1, p2, p3, t], vals => {
+        const [a, b, c, d, tv] = vals;
+        const u = 1 - tv;
+        const u2 = u * u;
+        const t2 = tv * tv;
+        return {
+            x: u2 * u * a.x + 3 * u2 * tv * b.x + 3 * u * t2 * c.x + t2 * tv * d.x,
+            y: u2 * u * a.y + 3 * u2 * tv * b.y + 3 * u * t2 * c.y + t2 * tv * d.y,
+        };
+    });
+}