@allyhub/sdk 0.0.0-stage → 0.1.0-alpha.6

package/dist/paths.js

@@ -0,0 +1,720 @@
+// SVG paths measured without a browser: a path's length, the point and the
+// direction at a length, the stroke-dash values that draw it on, the stretch
+// of it between two fractions of its length, and the path between two paths
+// that have the same commands. Pure functions of the path's text, so they
+// give the same numbers in mount, in render and in a test.
+//
+// After Remotion's @remotion/paths
+// (https://github.com/remotion-dev/remotion/tree/main/packages/paths,
+// Copyright (c) 2023 JonnyBurger, MIT): getLength, getPointAtLength,
+// getTangentAtLength, evolvePath and interpolatePath, written again and
+// smaller. Arcs become cubic curves by the SVG specification's endpoint to
+// centre conversion (SVG 1.1, appendix F.6). See NOTICE.
+// ---- reading a path ---------------------------------------------------------
+const NUMBER = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/y;
+const COMMAND = /[MmLlHhVvCcSsQqTtAaZz]/;
+const SEPARATOR = /[\s,]/;
+class Reader {
+    i = 0;
+    d;
+    constructor(d) {
+        this.d = d;
+    }
+    skip() {
+        while (this.i < this.d.length && SEPARATOR.test(this.d.charAt(this.i)))
+            this.i++;
+    }
+    done() {
+        this.skip();
+        return this.i >= this.d.length;
+    }
+    command() {
+        this.skip();
+        const c = this.d.charAt(this.i);
+        if (!COMMAND.test(c))
+            return undefined;
+        this.i++;
+        return c;
+    }
+    number() {
+        this.skip();
+        NUMBER.lastIndex = this.i;
+        const m = NUMBER.exec(this.d);
+        if (!m)
+            throw this.error("a number");
+        this.i = NUMBER.lastIndex;
+        return Number(m[0]);
+    }
+    flag() {
+        this.skip();
+        const c = this.d.charAt(this.i);
+        if (c !== "0" && c !== "1")
+            throw this.error("an arc flag, 0 or 1");
+        this.i++;
+        return c === "1" ? 1 : 0;
+    }
+    error(what) {
+        const at = this.d.slice(this.i, this.i + 12);
+        return new Error(`Path "${this.d}": expected ${what} at character ${String(this.i)}${at ? ` ("${at}")` : ""}`);
+    }
+}
+/** A path's commands, absolute: H and V as L, S as C, T as Q. */
+function parse(d) {
+    const r = new Reader(d);
+    const out = [];
+    let cx = 0;
+    let cy = 0;
+    let sx = 0;
+    let sy = 0;
+    // The last control point of a C or Q, for S and T to reflect.
+    let ctrl = null;
+    let letter;
+    while (!r.done()) {
+        const read = r.command();
+        if (read !== undefined)
+            letter = read;
+        else if (letter === undefined || letter === "Z" || letter === "z")
+            throw r.error("a command");
+        else if (letter === "M")
+            letter = "L";
+        else if (letter === "m")
+            letter = "l";
+        if (letter === undefined)
+            break;
+        if (out.length === 0 && letter !== "M" && letter !== "m")
+            throw new Error(`Path "${d}": a path starts with M`);
+        const rel = letter === letter.toLowerCase();
+        const ox = rel ? cx : 0;
+        const oy = rel ? cy : 0;
+        switch (letter.toUpperCase()) {
+            case "M": {
+                cx = sx = ox + r.number();
+                cy = sy = oy + r.number();
+                out.push({ type: "M", x: cx, y: cy });
+                ctrl = null;
+                break;
+            }
+            case "L":
+            case "H":
+            case "V": {
+                const up = letter.toUpperCase();
+                if (up === "L") {
+                    cx = ox + r.number();
+                    cy = oy + r.number();
+                }
+                else if (up === "H")
+                    cx = ox + r.number();
+                else
+                    cy = oy + r.number();
+                out.push({ type: "L", x: cx, y: cy });
+                ctrl = null;
+                break;
+            }
+            case "C":
+            case "S": {
+                let x1;
+                let y1;
+                if (letter.toUpperCase() === "C") {
+                    x1 = ox + r.number();
+                    y1 = oy + r.number();
+                }
+                else {
+                    x1 = ctrl?.type === "C" ? 2 * cx - ctrl.x : cx;
+                    y1 = ctrl?.type === "C" ? 2 * cy - ctrl.y : cy;
+                }
+                const x2 = ox + r.number();
+                const y2 = oy + r.number();
+                cx = ox + r.number();
+                cy = oy + r.number();
+                out.push({ type: "C", x1, y1, x2, y2, x: cx, y: cy });
+                ctrl = { type: "C", x: x2, y: y2 };
+                break;
+            }
+            case "Q":
+            case "T": {
+                let x1;
+                let y1;
+                if (letter.toUpperCase() === "Q") {
+                    x1 = ox + r.number();
+                    y1 = oy + r.number();
+                }
+                else {
+                    x1 = ctrl?.type === "Q" ? 2 * cx - ctrl.x : cx;
+                    y1 = ctrl?.type === "Q" ? 2 * cy - ctrl.y : cy;
+                }
+                cx = ox + r.number();
+                cy = oy + r.number();
+                out.push({ type: "Q", x1, y1, x: cx, y: cy });
+                ctrl = { type: "Q", x: x1, y: y1 };
+                break;
+            }
+            case "A": {
+                const rx = r.number();
+                const ry = r.number();
+                const angle = r.number();
+                const large = r.flag();
+                const sweep = r.flag();
+                cx = ox + r.number();
+                cy = oy + r.number();
+                out.push({ type: "A", rx, ry, angle, large, sweep, x: cx, y: cy });
+                ctrl = null;
+                break;
+            }
+            default: {
+                out.push({ type: "Z" });
+                cx = sx;
+                cy = sy;
+                ctrl = null;
+            }
+        }
+    }
+    return out;
+}
+/** A number as a path writes it: at most 4 decimals, no `-0`. */
+function fmt(n) {
+    const r = Math.round(n * 1e4) / 1e4;
+    return String(r === 0 ? 0 : r);
+}
+function write(commands) {
+    return commands
+        .map((c) => {
+        switch (c.type) {
+            case "M":
+            case "L":
+                return `${c.type}${fmt(c.x)} ${fmt(c.y)}`;
+            case "C":
+                return `C${fmt(c.x1)} ${fmt(c.y1)} ${fmt(c.x2)} ${fmt(c.y2)} ${fmt(c.x)} ${fmt(c.y)}`;
+            case "Q":
+                return `Q${fmt(c.x1)} ${fmt(c.y1)} ${fmt(c.x)} ${fmt(c.y)}`;
+            case "A":
+                return `A${fmt(c.rx)} ${fmt(c.ry)} ${fmt(c.angle)} ${String(c.large)} ${String(c.sweep)} ${fmt(c.x)} ${fmt(c.y)}`;
+            default:
+                return "Z";
+        }
+    })
+        .join(" ");
+}
+/**
+ * A path written with absolute commands only (H and V as L, S as C, T as Q,
+ * numbers to 4 decimals): what `interpolatePath` compares. Throws on a path
+ * it cannot read.
+ */
+export function normalizePath(d) {
+    return write(parse(d));
+}
+// ---- measuring ----------------------------------------------------------------
+// Gauss–Legendre nodes and weights on [-1, 1] (Newton's method on the
+// Legendre polynomial), for the length of a curve.
+const GAUSS = ((n) => {
+    const xs = new Float64Array(n);
+    const ws = new Float64Array(n);
+    for (let i = 0; i < Math.ceil(n / 2); i++) {
+        let z = Math.cos((Math.PI * (i + 0.75)) / (n + 0.5));
+        let pp = 1;
+        for (let iter = 0; iter < 100; iter++) {
+            let p1 = 1;
+            let p2 = 0;
+            for (let j = 1; j <= n; j++) {
+                const p3 = p2;
+                p2 = p1;
+                p1 = ((2 * j - 1) * z * p2 - (j - 1) * p3) / j;
+            }
+            pp = (n * (z * p1 - p2)) / (z * z - 1);
+            const z1 = z;
+            z = z1 - p1 / pp;
+            if (Math.abs(z - z1) < 1e-15)
+                break;
+        }
+        xs[i] = -z;
+        xs[n - 1 - i] = z;
+        ws[i] = ws[n - 1 - i] = 2 / ((1 - z * z) * pp * pp);
+    }
+    return { xs, ws };
+})(16);
+/** Steps a curve's length table is kept at. */
+const STEPS = 16;
+function cubicAt(p, t) {
+    const mt = 1 - t;
+    const a = mt * mt * mt;
+    const b = 3 * mt * mt * t;
+    const c = 3 * mt * t * t;
+    const d = t * t * t;
+    return {
+        x: a * n(p, 0) + b * n(p, 2) + c * n(p, 4) + d * n(p, 6),
+        y: a * n(p, 1) + b * n(p, 3) + c * n(p, 5) + d * n(p, 7),
+    };
+}
+function cubicDerivative(p, t) {
+    const mt = 1 - t;
+    const a = 3 * mt * mt;
+    const b = 6 * mt * t;
+    const c = 3 * t * t;
+    return {
+        x: a * (n(p, 2) - n(p, 0)) +
+            b * (n(p, 4) - n(p, 2)) +
+            c * (n(p, 6) - n(p, 4)),
+        y: a * (n(p, 3) - n(p, 1)) +
+            b * (n(p, 5) - n(p, 3)) +
+            c * (n(p, 7) - n(p, 5)),
+    };
+}
+/** p[i], which is always there. */
+const n = (p, i) => p[i] ?? 0;
+/** A cubic's length from t = a to t = b. */
+function arcLength(p, a, b) {
+    const half = (b - a) / 2;
+    const mid = (a + b) / 2;
+    let sum = 0;
+    for (let i = 0; i < GAUSS.xs.length; i++) {
+        const d = cubicDerivative(p, mid + half * (GAUSS.xs[i] ?? 0));
+        sum += (GAUSS.ws[i] ?? 0) * Math.hypot(d.x, d.y);
+    }
+    return sum * half;
+}
+function cubicPiece(p, sub) {
+    const cum = new Float64Array(STEPS + 1);
+    for (let k = 0; k < STEPS; k++)
+        cum[k + 1] = (cum[k] ?? 0) + arcLength(p, k / STEPS, (k + 1) / STEPS);
+    return { p, cubic: true, length: cum[STEPS] ?? 0, cum, sub, close: false };
+}
+function linePiece(p, sub, close) {
+    return {
+        p,
+        cubic: false,
+        length: Math.hypot(n(p, 2) - n(p, 0), n(p, 3) - n(p, 1)),
+        cum: null,
+        sub,
+        close,
+    };
+}
+/**
+ * The most of a turn one cubic of an arc covers: a quarter, as Chrome draws
+ * and measures arcs, so a length here is the browser's (a circle comes out
+ * 1.4e-4 longer than 2πr in both).
+ */
+const ARC_STEP = Math.PI / 2;
+/**
+ * An arc as cubics of at most a quarter turn each (SVG 1.1, F.6.5).
+ */
+function arcCubics(x1, y1, a) {
+    let rx = Math.abs(a.rx);
+    let ry = Math.abs(a.ry);
+    if (rx === 0 || ry === 0)
+        return null;
+    const phi = (a.angle * Math.PI) / 180;
+    const cos = Math.cos(phi);
+    const sin = Math.sin(phi);
+    const dx = (x1 - a.x) / 2;
+    const dy = (y1 - a.y) / 2;
+    const xp = cos * dx + sin * dy;
+    const yp = -sin * dx + cos * dy;
+    const lambda = (xp * xp) / (rx * rx) + (yp * yp) / (ry * ry);
+    if (lambda > 1) {
+        rx *= Math.sqrt(lambda);
+        ry *= Math.sqrt(lambda);
+    }
+    const num = rx * rx * ry * ry - rx * rx * yp * yp - ry * ry * xp * xp;
+    const den = rx * rx * yp * yp + ry * ry * xp * xp;
+    const coef = (a.large !== a.sweep ? 1 : -1) * Math.sqrt(Math.max(0, num / den));
+    const cxp = (coef * rx * yp) / ry;
+    const cyp = (-coef * ry * xp) / rx;
+    const cx = cos * cxp - sin * cyp + (x1 + a.x) / 2;
+    const cy = sin * cxp + cos * cyp + (y1 + a.y) / 2;
+    const angle = (ux, uy, vx, vy) => Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+    const ux = (xp - cxp) / rx;
+    const uy = (yp - cyp) / ry;
+    const theta = angle(1, 0, ux, uy);
+    let delta = angle(ux, uy, (-xp - cxp) / rx, (-yp - cyp) / ry);
+    if (!a.sweep && delta > 0)
+        delta -= 2 * Math.PI;
+    if (a.sweep && delta < 0)
+        delta += 2 * Math.PI;
+    const count = Math.max(1, Math.ceil(Math.abs(delta) / ARC_STEP - 1e-9));
+    const step = delta / count;
+    const k = (4 / 3) * Math.tan(step / 4);
+    const map = (u, v) => [
+        cx + cos * rx * u - sin * ry * v,
+        cy + sin * rx * u + cos * ry * v,
+    ];
+    const out = [];
+    let px = x1;
+    let py = y1;
+    for (let i = 0; i < count; i++) {
+        const a1 = theta + i * step;
+        const a2 = a1 + step;
+        const c1 = map(Math.cos(a1) - k * Math.sin(a1), Math.sin(a1) + k * Math.cos(a1));
+        const c2 = map(Math.cos(a2) + k * Math.sin(a2), Math.sin(a2) - k * Math.cos(a2));
+        const end = i === count - 1 ? [a.x, a.y] : map(Math.cos(a2), Math.sin(a2));
+        const ex = end[0] ?? 0;
+        const ey = end[1] ?? 0;
+        out.push([px, py, ...c1, ...c2, ex, ey]);
+        px = ex;
+        py = ey;
+    }
+    return out;
+}
+function measureCommands(commands) {
+    const pieces = [];
+    let x = 0;
+    let y = 0;
+    let sx = 0;
+    let sy = 0;
+    let sub = -1;
+    for (const c of commands) {
+        switch (c.type) {
+            case "M":
+                x = sx = c.x;
+                y = sy = c.y;
+                sub++;
+                continue;
+            case "L":
+                pieces.push(linePiece([x, y, c.x, c.y], sub, false));
+                break;
+            case "C":
+                pieces.push(cubicPiece([x, y, c.x1, c.y1, c.x2, c.y2, c.x, c.y], sub));
+                break;
+            case "Q":
+                pieces.push(cubicPiece([
+                    x,
+                    y,
+                    x + (2 / 3) * (c.x1 - x),
+                    y + (2 / 3) * (c.y1 - y),
+                    c.x + (2 / 3) * (c.x1 - c.x),
+                    c.y + (2 / 3) * (c.y1 - c.y),
+                    c.x,
+                    c.y,
+                ], sub));
+                break;
+            case "A": {
+                if (x === c.x && y === c.y)
+                    break;
+                const cubics = arcCubics(x, y, c);
+                if (cubics)
+                    for (const p of cubics)
+                        pieces.push(cubicPiece(p, sub));
+                else
+                    pieces.push(linePiece([x, y, c.x, c.y], sub, false));
+                break;
+            }
+            default:
+                pieces.push(linePiece([x, y, sx, sy], sub, true));
+                x = sx;
+                y = sy;
+                continue;
+        }
+        x = c.x;
+        y = c.y;
+    }
+    const offsets = [];
+    let total = 0;
+    for (const piece of pieces) {
+        offsets.push(total);
+        total += piece.length;
+    }
+    return { pieces, offsets, total, last: { x, y } };
+}
+const MEASURED = new Map();
+const MEASURED_CACHE = 64;
+function measured(d) {
+    const found = MEASURED.get(d);
+    if (found)
+        return found;
+    const m = measureCommands(parse(d));
+    if (MEASURED.size >= MEASURED_CACHE) {
+        const oldest = MEASURED.keys().next();
+        if (!oldest.done)
+            MEASURED.delete(oldest.value);
+    }
+    MEASURED.set(d, m);
+    return m;
+}
+/** The curve parameter t at a length s from a cubic's start. */
+function cubicT(piece, s) {
+    const cum = piece.cum;
+    if (!cum || piece.length <= 0)
+        return 0;
+    if (s <= 0)
+        return 0;
+    if (s >= piece.length)
+        return 1;
+    let k = 0;
+    let hi = STEPS;
+    while (hi - k > 1) {
+        const mid = (k + hi) >> 1;
+        if ((cum[mid] ?? 0) <= s)
+            k = mid;
+        else
+            hi = mid;
+    }
+    const base = k / STEPS;
+    const want = s - (cum[k] ?? 0);
+    let lo = base;
+    let up = (k + 1) / STEPS;
+    const span = (cum[k + 1] ?? 0) - (cum[k] ?? 0);
+    let t = span > 0 ? base + (up - lo) * (want / span) : base;
+    for (let i = 0; i < 12; i++) {
+        const f = arcLength(piece.p, base, t) - want;
+        if (Math.abs(f) < 1e-9)
+            break;
+        if (f > 0)
+            up = t;
+        else
+            lo = t;
+        const d = cubicDerivative(piece.p, t);
+        const speed = Math.hypot(d.x, d.y);
+        let next = speed > 0 ? t - f / speed : (lo + up) / 2;
+        if (next <= lo || next >= up)
+            next = (lo + up) / 2;
+        t = next;
+    }
+    return t;
+}
+/** The piece at a length along the path, and the length into it. */
+function pieceAt(m, length) {
+    const s = Math.min(Math.max(length, 0), m.total);
+    for (let i = 0; i < m.pieces.length; i++) {
+        const piece = m.pieces[i];
+        const offset = m.offsets[i] ?? 0;
+        if (piece && piece.length > 0 && offset + piece.length >= s)
+            return { piece, s: s - offset };
+    }
+    return null;
+}
+/** The path's length, in its own units. Throws on a path it cannot read. */
+export function pathLength(d) {
+    return measured(d).total;
+}
+/**
+ * The point at a length along the path (clamped to 0 – its length). A path
+ * with no length gives its last point.
+ */
+export function pointAtLength(d, length) {
+    const m = measured(d);
+    const at = pieceAt(m, length);
+    if (!at)
+        return { ...m.last };
+    const { piece, s } = at;
+    if (piece.cubic)
+        return cubicAt(piece.p, cubicT(piece, s));
+    const f = s / piece.length;
+    return {
+        x: n(piece.p, 0) + (n(piece.p, 2) - n(piece.p, 0)) * f,
+        y: n(piece.p, 1) + (n(piece.p, 3) - n(piece.p, 1)) * f,
+    };
+}
+/**
+ * The direction the path runs in at a length along it, a vector of length 1
+ * (`Math.atan2(v.y, v.x)` is its angle in radians). A path with no length
+ * gives `{ x: 1, y: 0 }`.
+ */
+export function tangentAtLength(d, length) {
+    const at = pieceAt(measured(d), length);
+    if (!at)
+        return { x: 1, y: 0 };
+    const { piece, s } = at;
+    const p = piece.p;
+    let v;
+    if (piece.cubic) {
+        const t = cubicT(piece, s);
+        v = cubicDerivative(p, t);
+        if (Math.hypot(v.x, v.y) < 1e-9) {
+            // A control point on its end: the direction the curve leaves it in.
+            const a = cubicAt(p, Math.max(0, t - 1e-4));
+            const b = cubicAt(p, Math.min(1, t + 1e-4));
+            v = { x: b.x - a.x, y: b.y - a.y };
+        }
+    }
+    else
+        v = { x: n(p, 2) - n(p, 0), y: n(p, 3) - n(p, 1) };
+    const len = Math.hypot(v.x, v.y);
+    return len > 0 ? { x: v.x / len, y: v.y / len } : { x: 1, y: 0 };
+}
+/**
+ * The stroke-dash values that show the first `progress` (0–1, clamped) of
+ * the path's stroke: 0 shows none of it, 1 all of it. Set them in render
+ * from an eased progress: `css(path, drawOn(d, ease.out(progress(t, 0.2, 1))))`.
+ * The gap is twice the length, so a browser that measures the path a little
+ * longer never shows the next dash.
+ */
+export function drawOn(d, progress) {
+    const length = measured(d).total;
+    if (length <= 0)
+        return { strokeDasharray: "none", strokeDashoffset: 0 };
+    const p = Math.min(Math.max(progress, 0), 1);
+    return {
+        strokeDasharray: `${fmt(length)} ${fmt(2 * length)}`,
+        // At 0 the dash is put wholly before the start, so no cap shows there.
+        strokeDashoffset: p <= 0 ? 1.5 * length : length * (1 - p),
+    };
+}
+/** A cubic split at t: the curve before and after. */
+function split(p, t) {
+    const lerp = (a, b) => a + (b - a) * t;
+    const [x0, y0, x1, y1, x2, y2, x3, y3] = [0, 1, 2, 3, 4, 5, 6, 7].map((i) => n(p, i));
+    const ax = lerp(x0, x1);
+    const ay = lerp(y0, y1);
+    const bx = lerp(x1, x2);
+    const by = lerp(y1, y2);
+    const cx = lerp(x2, x3);
+    const cy = lerp(y2, y3);
+    const dx = lerp(ax, bx);
+    const dy = lerp(ay, by);
+    const ex = lerp(bx, cx);
+    const ey = lerp(by, cy);
+    const fx = lerp(dx, ex);
+    const fy = lerp(dy, ey);
+    return [
+        [x0, y0, ax, ay, dx, dy, fx, fy],
+        [fx, fy, ex, ey, cx, cy, x3, y3],
+    ];
+}
+/** A cubic between t0 and t1. */
+function between(p, t0, t1) {
+    const head = t1 < 1 ? split(p, t1)[0] : [...p];
+    if (t0 <= 0)
+        return head;
+    return split(head, t1 > 0 ? t0 / t1 : 0)[1];
+}
+/**
+ * The stretch of the path from `from` to `to`, fractions of its length
+ * (0–1, clamped), as a path: lines and cubic curves (Q and A become cubics),
+ * a move at the start of each subpath it crosses, and Z where it keeps a
+ * whole subpath. `""` when `to` is not after `from`. Animate `to` to grow a
+ * line, both to send a stretch along it.
+ */
+export function trimPath(d, from, to) {
+    const m = measured(d);
+    const a = Math.min(Math.max(from, 0), 1) * m.total;
+    const b = Math.min(Math.max(to, 0), 1) * m.total;
+    if (b <= a)
+        return "";
+    const out = [];
+    let pen = null;
+    let sub = -1;
+    // Whether the output's current subpath began at its subpath's start.
+    let whole = false;
+    for (let i = 0; i < m.pieces.length; i++) {
+        const piece = m.pieces[i];
+        if (!piece)
+            continue;
+        const o = m.offsets[i] ?? 0;
+        const s0 = Math.max(a, o);
+        const s1 = Math.min(b, o + piece.length);
+        if (piece.length <= 0) {
+            // A Z that adds no length closes a subpath kept whole.
+            if (piece.close && whole && piece.sub === sub && pen && o <= b)
+                out.push({ type: "Z" });
+            continue;
+        }
+        if (s1 <= s0)
+            continue;
+        let seg;
+        if (piece.cubic)
+            seg = between(piece.p, cubicT(piece, s0 - o), cubicT(piece, s1 - o));
+        else {
+            const f0 = (s0 - o) / piece.length;
+            const f1 = (s1 - o) / piece.length;
+            const p = piece.p;
+            seg = [f0, f1].flatMap((f) => [
+                n(p, 0) + (n(p, 2) - n(p, 0)) * f,
+                n(p, 1) + (n(p, 3) - n(p, 1)) * f,
+            ]);
+        }
+        const start = { x: n(seg, 0), y: n(seg, 1) };
+        if (!pen ||
+            piece.sub !== sub ||
+            Math.hypot(start.x - pen.x, start.y - pen.y) > 1e-9) {
+            out.push({ type: "M", ...start });
+            whole =
+                s0 === o &&
+                    m.pieces.findIndex((q) => q.sub === piece.sub && q.length > 0) === i;
+            sub = piece.sub;
+        }
+        const kept = s0 === o && s1 === o + piece.length;
+        if (piece.close && whole && kept)
+            out.push({ type: "Z" });
+        else if (piece.cubic)
+            out.push({
+                type: "C",
+                x1: n(seg, 2),
+                y1: n(seg, 3),
+                x2: n(seg, 4),
+                y2: n(seg, 5),
+                x: n(seg, 6),
+                y: n(seg, 7),
+            });
+        else
+            out.push({ type: "L", x: n(seg, 2), y: n(seg, 3) });
+        pen = { x: n(seg, seg.length - 2), y: n(seg, seg.length - 1) };
+    }
+    return write(out);
+}
+// ---- between two paths ----------------------------------------------------------
+/**
+ * The path `x` of the way from `a` to `b` (0 is `a`, 1 is `b`; values
+ * outside 0–1 go on past them, for an easing that overshoots). Both paths
+ * must have the same commands once absolute (`normalizePath`), and an arc's
+ * flags must match; otherwise it throws, naming the first command that
+ * differs. Draw the two shapes with the same commands to morph between them.
+ */
+export function interpolatePath(a, b, x) {
+    const ca = parse(a);
+    const cb = parse(b);
+    if (ca.length !== cb.length)
+        throw new Error(`interpolatePath: the paths have ${String(ca.length)} and ${String(cb.length)} commands ("${write(ca)}", "${write(cb)}")`);
+    const lerp = (u, v) => u + (v - u) * x;
+    const out = ca.map((u, i) => {
+        const v = cb[i];
+        const differ = () => new Error(`interpolatePath: command ${String(i + 1)} differs: ${write([u])} and ${v ? write([v]) : "nothing"}`);
+        if (v?.type !== u.type)
+            throw differ();
+        switch (u.type) {
+            case "Z":
+                return u;
+            case "M":
+            case "L": {
+                const w = v;
+                return { type: u.type, x: lerp(u.x, w.x), y: lerp(u.y, w.y) };
+            }
+            case "C": {
+                const w = v;
+                return {
+                    type: "C",
+                    x1: lerp(u.x1, w.x1),
+                    y1: lerp(u.y1, w.y1),
+                    x2: lerp(u.x2, w.x2),
+                    y2: lerp(u.y2, w.y2),
+                    x: lerp(u.x, w.x),
+                    y: lerp(u.y, w.y),
+                };
+            }
+            case "Q": {
+                const w = v;
+                return {
+                    type: "Q",
+                    x1: lerp(u.x1, w.x1),
+                    y1: lerp(u.y1, w.y1),
+                    x: lerp(u.x, w.x),
+                    y: lerp(u.y, w.y),
+                };
+            }
+            default: {
+                const w = v;
+                if (w.large !== u.large || w.sweep !== u.sweep)
+                    throw differ();
+                return {
+                    type: "A",
+                    rx: lerp(u.rx, w.rx),
+                    ry: lerp(u.ry, w.ry),
+                    angle: lerp(u.angle, w.angle),
+                    large: u.large,
+                    sweep: u.sweep,
+                    x: lerp(u.x, w.x),
+                    y: lerp(u.y, w.y),
+                };
+            }
+        }
+    });
+    return write(out);
+}
+//# sourceMappingURL=paths.js.map