@allyhub/sdk 0.1.0-alpha.8 → 0.2.0-next.1

package/dist/paths.js

@@ -1,720 +1,2 @@
-// 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
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+const F=/[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/y,st=/[MmLlHhVvCcSsQqTtAaZz]/,ot=/[\s,]/;class rt{i=0;d;constructor(t){this.d=t}skip(){for(;this.i<this.d.length&&ot.test(this.d.charAt(this.i));)this.i++}done(){return this.skip(),this.i>=this.d.length}command(){this.skip();const t=this.d.charAt(this.i);if(st.test(t))return this.i++,t}number(){this.skip(),F.lastIndex=this.i;const t=F.exec(this.d);if(!t)throw this.error("a number");return this.i=F.lastIndex,Number(t[0])}flag(){this.skip();const t=this.d.charAt(this.i);if(t!=="0"&&t!=="1")throw this.error("an arc flag, 0 or 1");return this.i++,t==="1"?1:0}error(t){const n=this.d.slice(this.i,this.i+12);return new Error(`Path "${this.d}": expected ${t} at character ${String(this.i)}${n?` ("${n}")`:""}`)}}function z(s){const t=new rt(s),n=[];let e=0,o=0,a=0,h=0,r=null,u;for(;!t.done();){const i=t.command();if(i!==void 0)u=i;else{if(u===void 0||u==="Z"||u==="z")throw t.error("a command");u==="M"?u="L":u==="m"&&(u="l")}if(n.length===0&&u!=="M"&&u!=="m")throw new Error(`Path "${s}": a path starts with M`);const y=u===u.toLowerCase(),c=y?e:0,x=y?o:0;switch(u.toUpperCase()){case"M":{e=a=c+t.number(),o=h=x+t.number(),n.push({type:"M",x:e,y:o}),r=null;break}case"L":case"H":case"V":{const p=u.toUpperCase();p==="L"?(e=c+t.number(),o=x+t.number()):p==="H"?e=c+t.number():o=x+t.number(),n.push({type:"L",x:e,y:o}),r=null;break}case"C":case"S":{let p,m;u.toUpperCase()==="C"?(p=c+t.number(),m=x+t.number()):(p=r?.type==="C"?2*e-r.x:e,m=r?.type==="C"?2*o-r.y:o);const f=c+t.number(),M=x+t.number();e=c+t.number(),o=x+t.number(),n.push({type:"C",x1:p,y1:m,x2:f,y2:M,x:e,y:o}),r={type:"C",x:f,y:M};break}case"Q":case"T":{let p,m;u.toUpperCase()==="Q"?(p=c+t.number(),m=x+t.number()):(p=r?.type==="Q"?2*e-r.x:e,m=r?.type==="Q"?2*o-r.y:o),e=c+t.number(),o=x+t.number(),n.push({type:"Q",x1:p,y1:m,x:e,y:o}),r={type:"Q",x:p,y:m};break}case"A":{const p=t.number(),m=t.number(),f=t.number(),M=t.flag(),g=t.flag();e=c+t.number(),o=x+t.number(),n.push({type:"A",rx:p,ry:m,angle:f,large:M,sweep:g,x:e,y:o}),r=null;break}default:n.push({type:"Z"}),e=a,o=h,r=null}}return n}function b(s){const t=Math.round(s*1e4)/1e4;return String(t===0?0:t)}function E(s){return s.map(t=>{switch(t.type){case"M":case"L":return`${t.type}${b(t.x)} ${b(t.y)}`;case"C":return`C${b(t.x1)} ${b(t.y1)} ${b(t.x2)} ${b(t.y2)} ${b(t.x)} ${b(t.y)}`;case"Q":return`Q${b(t.x1)} ${b(t.y1)} ${b(t.x)} ${b(t.y)}`;case"A":return`A${b(t.rx)} ${b(t.ry)} ${b(t.angle)} ${String(t.large)} ${String(t.sweep)} ${b(t.x)} ${b(t.y)}`;default:return"Z"}}).join(" ")}export function normalizePath(s){return E(z(s))}const N=(s=>{const t=new Float64Array(s),n=new Float64Array(s);for(let e=0;e<Math.ceil(s/2);e++){let o=Math.cos(Math.PI*(e+.75)/(s+.5)),a=1;for(let h=0;h<100;h++){let r=1,u=0;for(let y=1;y<=s;y++){const c=u;u=r,r=((2*y-1)*o*u-(y-1)*c)/y}a=s*(o*r-u)/(o*o-1);const i=o;if(o=i-r/a,Math.abs(o-i)<1e-15)break}t[e]=-o,t[s-1-e]=o,n[e]=n[s-1-e]=2/((1-o*o)*a*a)}return{xs:t,ws:n}})(16),S=16;function O(s,t){const n=1-t,e=n*n*n,o=3*n*n*t,a=3*n*t*t,h=t*t*t;return{x:e*l(s,0)+o*l(s,2)+a*l(s,4)+h*l(s,6),y:e*l(s,1)+o*l(s,3)+a*l(s,5)+h*l(s,7)}}function j(s,t){const n=1-t,e=3*n*n,o=6*n*t,a=3*t*t;return{x:e*(l(s,2)-l(s,0))+o*(l(s,4)-l(s,2))+a*(l(s,6)-l(s,4)),y:e*(l(s,3)-l(s,1))+o*(l(s,5)-l(s,3))+a*(l(s,7)-l(s,5))}}const l=(s,t)=>s[t]??0;function Y(s,t,n){const e=(n-t)/2,o=(t+n)/2;let a=0;for(let h=0;h<N.xs.length;h++){const r=j(s,o+e*(N.xs[h]??0));a+=(N.ws[h]??0)*Math.hypot(r.x,r.y)}return a*e}function V(s,t){const n=new Float64Array(S+1);for(let e=0;e<S;e++)n[e+1]=(n[e]??0)+Y(s,e/S,(e+1)/S);return{p:s,cubic:!0,length:n[S]??0,cum:n,sub:t,close:!1}}function _(s,t,n){return{p:s,cubic:!1,length:Math.hypot(l(s,2)-l(s,0),l(s,3)-l(s,1)),cum:null,sub:t,close:n}}const ct=Math.PI/2;function at(s,t,n){let e=Math.abs(n.rx),o=Math.abs(n.ry);if(e===0||o===0)return null;const a=n.angle*Math.PI/180,h=Math.cos(a),r=Math.sin(a),u=(s-n.x)/2,i=(t-n.y)/2,y=h*u+r*i,c=-r*u+h*i,x=y*y/(e*e)+c*c/(o*o);x>1&&(e*=Math.sqrt(x),o*=Math.sqrt(x));const p=e*e*o*o-e*e*c*c-o*o*y*y,m=e*e*c*c+o*o*y*y,f=(n.large!==n.sweep?1:-1)*Math.sqrt(Math.max(0,p/m)),M=f*e*c/o,g=-f*o*y/e,k=h*M-r*g+(s+n.x)/2,L=r*M+h*g+(t+n.y)/2,d=($,w,A,Z)=>Math.atan2($*Z-w*A,$*A+w*Z),C=(y-M)/e,D=(c-g)/o,Q=d(1,0,C,D);let P=d(C,D,(-y-M)/e,(-c-g)/o);!n.sweep&&P>0&&(P-=2*Math.PI),n.sweep&&P<0&&(P+=2*Math.PI);const v=Math.max(1,Math.ceil(Math.abs(P)/ct-1e-9)),H=P/v,R=4/3*Math.tan(H/4),q=($,w)=>[k+h*e*$-r*o*w,L+r*e*$+h*o*w],B=[];let G=s,J=t;for(let $=0;$<v;$++){const w=Q+$*H,A=w+H,Z=q(Math.cos(w)-R*Math.sin(w),Math.sin(w)+R*Math.cos(w)),nt=q(Math.cos(A)+R*Math.sin(A),Math.sin(A)-R*Math.cos(A)),K=$===v-1?[n.x,n.y]:q(Math.cos(A),Math.sin(A)),W=K[0]??0,X=K[1]??0;B.push([G,J,...Z,...nt,W,X]),G=W,J=X}return B}function it(s){const t=[];let n=0,e=0,o=0,a=0,h=-1;for(const i of s){switch(i.type){case"M":n=o=i.x,e=a=i.y,h++;continue;case"L":t.push(_([n,e,i.x,i.y],h,!1));break;case"C":t.push(V([n,e,i.x1,i.y1,i.x2,i.y2,i.x,i.y],h));break;case"Q":t.push(V([n,e,n+2/3*(i.x1-n),e+2/3*(i.y1-e),i.x+2/3*(i.x1-i.x),i.y+2/3*(i.y1-i.y),i.x,i.y],h));break;case"A":{if(n===i.x&&e===i.y)break;const y=at(n,e,i);if(y)for(const c of y)t.push(V(c,h));else t.push(_([n,e,i.x,i.y],h,!1));break}default:t.push(_([n,e,o,a],h,!0)),n=o,e=a;continue}n=i.x,e=i.y}const r=[];let u=0;for(const i of t)r.push(u),u+=i.length;return{pieces:t,offsets:r,total:u,last:{x:n,y:e}}}const I=new Map,ht=64;function U(s){const t=I.get(s);if(t)return t;const n=it(z(s));if(I.size>=ht){const e=I.keys().next();e.done||I.delete(e.value)}return I.set(s,n),n}function T(s,t){const n=s.cum;if(!n||s.length<=0||t<=0)return 0;if(t>=s.length)return 1;let e=0,o=S;for(;o-e>1;){const c=e+o>>1;(n[c]??0)<=t?e=c:o=c}const a=e/S,h=t-(n[e]??0);let r=a,u=(e+1)/S;const i=(n[e+1]??0)-(n[e]??0);let y=i>0?a+(u-r)*(h/i):a;for(let c=0;c<12;c++){const x=Y(s.p,a,y)-h;if(Math.abs(x)<1e-9)break;x>0?u=y:r=y;const p=j(s.p,y),m=Math.hypot(p.x,p.y);let f=m>0?y-x/m:(r+u)/2;(f<=r||f>=u)&&(f=(r+u)/2),y=f}return y}function tt(s,t){const n=Math.min(Math.max(t,0),s.total);for(let e=0;e<s.pieces.length;e++){const o=s.pieces[e],a=s.offsets[e]??0;if(o&&o.length>0&&a+o.length>=n)return{piece:o,s:n-a}}return null}export function pathLength(s){return U(s).total}export function pointAtLength(s,t){const n=U(s),e=tt(n,t);if(!e)return{...n.last};const{piece:o,s:a}=e;if(o.cubic)return O(o.p,T(o,a));const h=a/o.length;return{x:l(o.p,0)+(l(o.p,2)-l(o.p,0))*h,y:l(o.p,1)+(l(o.p,3)-l(o.p,1))*h}}export function tangentAtLength(s,t){const n=tt(U(s),t);if(!n)return{x:1,y:0};const{piece:e,s:o}=n,a=e.p;let h;if(e.cubic){const u=T(e,o);if(h=j(a,u),Math.hypot(h.x,h.y)<1e-9){const i=O(a,Math.max(0,u-1e-4)),y=O(a,Math.min(1,u+1e-4));h={x:y.x-i.x,y:y.y-i.y}}}else h={x:l(a,2)-l(a,0),y:l(a,3)-l(a,1)};const r=Math.hypot(h.x,h.y);return r>0?{x:h.x/r,y:h.y/r}:{x:1,y:0}}export function drawOn(s,t){const n=U(s).total;if(n<=0)return{strokeDasharray:"none",strokeDashoffset:0};const e=Math.min(Math.max(t,0),1);return{strokeDasharray:`${b(n)} ${b(2*n)}`,strokeDashoffset:e<=0?1.5*n:n*(1-e)}}function et(s,t){const n=(Q,P)=>Q+(P-Q)*t,[e,o,a,h,r,u,i,y]=[0,1,2,3,4,5,6,7].map(Q=>l(s,Q)),c=n(e,a),x=n(o,h),p=n(a,r),m=n(h,u),f=n(r,i),M=n(u,y),g=n(c,p),k=n(x,m),L=n(p,f),d=n(m,M),C=n(g,L),D=n(k,d);return[[e,o,c,x,g,k,C,D],[C,D,L,d,f,M,i,y]]}function lt(s,t,n){const e=n<1?et(s,n)[0]:[...s];return t<=0?e:et(e,n>0?t/n:0)[1]}export function trimPath(s,t,n){const e=U(s),o=Math.min(Math.max(t,0),1)*e.total,a=Math.min(Math.max(n,0),1)*e.total;if(a<=o)return"";const h=[];let r=null,u=-1,i=!1;for(let y=0;y<e.pieces.length;y++){const c=e.pieces[y];if(!c)continue;const x=e.offsets[y]??0,p=Math.max(o,x),m=Math.min(a,x+c.length);if(c.length<=0){c.close&&i&&c.sub===u&&r&&x<=a&&h.push({type:"Z"});continue}if(m<=p)continue;let f;if(c.cubic)f=lt(c.p,T(c,p-x),T(c,m-x));else{const k=(p-x)/c.length,L=(m-x)/c.length,d=c.p;f=[k,L].flatMap(C=>[l(d,0)+(l(d,2)-l(d,0))*C,l(d,1)+(l(d,3)-l(d,1))*C])}const M={x:l(f,0),y:l(f,1)};(!r||c.sub!==u||Math.hypot(M.x-r.x,M.y-r.y)>1e-9)&&(h.push({type:"M",...M}),i=p===x&&e.pieces.findIndex(k=>k.sub===c.sub&&k.length>0)===y,u=c.sub);const g=p===x&&m===x+c.length;c.close&&i&&g?h.push({type:"Z"}):c.cubic?h.push({type:"C",x1:l(f,2),y1:l(f,3),x2:l(f,4),y2:l(f,5),x:l(f,6),y:l(f,7)}):h.push({type:"L",x:l(f,2),y:l(f,3)}),r={x:l(f,f.length-2),y:l(f,f.length-1)}}return E(h)}export function interpolatePath(s,t,n){const e=z(s),o=z(t);if(e.length!==o.length)throw new Error(`interpolatePath: the paths have ${String(e.length)} and ${String(o.length)} commands ("${E(e)}", "${E(o)}")`);const a=(r,u)=>r+(u-r)*n,h=e.map((r,u)=>{const i=o[u],y=()=>new Error(`interpolatePath: command ${String(u+1)} differs: ${E([r])} and ${i?E([i]):"nothing"}`);if(i?.type!==r.type)throw y();switch(r.type){case"Z":return r;case"M":case"L":{const c=i;return{type:r.type,x:a(r.x,c.x),y:a(r.y,c.y)}}case"C":{const c=i;return{type:"C",x1:a(r.x1,c.x1),y1:a(r.y1,c.y1),x2:a(r.x2,c.x2),y2:a(r.y2,c.y2),x:a(r.x,c.x),y:a(r.y,c.y)}}case"Q":{const c=i;return{type:"Q",x1:a(r.x1,c.x1),y1:a(r.y1,c.y1),x:a(r.x,c.x),y:a(r.y,c.y)}}default:{const c=i;if(c.large!==r.large||c.sweep!==r.sweep)throw y();return{type:"A",rx:a(r.rx,c.rx),ry:a(r.ry,c.ry),angle:a(r.angle,c.angle),large:r.large,sweep:r.sweep,x:a(r.x,c.x),y:a(r.y,c.y)}}}});return E(h)}