@grafloria/element 0.3.17 → 0.3.19

package/src/libs/renderer/src/canvas/path-geometry.js

@@ -0,0 +1,673 @@
+"use strict";
+// path-geometry.ts — the geometry half of the Canvas backend.
+//
+// Canvas 2D has no `<rect rx>`, no `<circle>`, no `d="M 0 0 A …"` and no
+// `transform="translate(…) rotate(…)"`. Everything the VNode tree expresses
+// geometrically has to be normalised into ONE representation before it can be
+// drawn, hit-tested or bounded. That representation is {@link PathCmd}:
+//
+//     M x y | L x y | C c1x c1y c2x c2y x y | Q cx cy x y | Z
+//
+// i.e. exactly the four path primitives a 2D context can consume
+// (`moveTo` / `lineTo` / `bezierCurveTo` / `quadraticCurveTo` / `closePath`).
+//
+// Everything downstream reuses this one form:
+//   - the PAINTER issues the commands to the 2D context,
+//   - the HIT INDEX flattens them to polygons for point-in-shape / distance,
+//   - the DIRTY tracker takes their bounding box.
+//
+// So a shape cannot be drawn in one place and picked in another: the pixels and
+// the hit region are generated from the same command list. That is the whole
+// reason this module exists as a separate layer.
+//
+// ARCS: `A` path commands and `<circle>`/`<ellipse>` are converted to cubic
+// béziers (the standard 4-segment kappa approximation, max radial error ≈ 2.7e-4
+// of the radius — far below a device pixel at any sane zoom). Documented, not
+// hidden: it is why canvas circles are *approximately*, not bit-identically, the
+// SVG circle.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDENTITY = void 0;
+exports.multiply = multiply;
+exports.applyMatrix = applyMatrix;
+exports.translation = translation;
+exports.scaling = scaling;
+exports.rotation = rotation;
+exports.parseTransform = parseTransform;
+exports.rectPath = rectPath;
+exports.ellipsePath = ellipsePath;
+exports.circlePath = circlePath;
+exports.linePath = linePath;
+exports.polyPath = polyPath;
+exports.parsePath = parsePath;
+exports.arcToCubics = arcToCubics;
+exports.flattenPath = flattenPath;
+exports.transformCmds = transformCmds;
+exports.pathBounds = pathBounds;
+exports.pointInPath = pointInPath;
+exports.distanceToPath = distanceToPath;
+exports.distanceToSegment = distanceToSegment;
+exports.boundsUnion = boundsUnion;
+exports.boundsIntersect = boundsIntersect;
+exports.padBounds = padBounds;
+/** Circle → cubic magic number: 4/3 · tan(π/8). */
+const KAPPA = 0.5522847498307936;
+exports.IDENTITY = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
+// ---------------------------------------------------------------------------
+// Matrix math
+// ---------------------------------------------------------------------------
+/** `m1 · m2` — apply m2 FIRST, then m1 (the SVG/canvas nesting convention). */
+function multiply(m1, m2) {
+    return {
+        a: m1.a * m2.a + m1.c * m2.b,
+        b: m1.b * m2.a + m1.d * m2.b,
+        c: m1.a * m2.c + m1.c * m2.d,
+        d: m1.b * m2.c + m1.d * m2.d,
+        e: m1.a * m2.e + m1.c * m2.f + m1.e,
+        f: m1.b * m2.e + m1.d * m2.f + m1.f,
+    };
+}
+function applyMatrix(m, p) {
+    return { x: m.a * p.x + m.c * p.y + m.e, y: m.b * p.x + m.d * p.y + m.f };
+}
+function translation(dx, dy) {
+    return { a: 1, b: 0, c: 0, d: 1, e: dx, f: dy };
+}
+function scaling(sx, sy = sx) {
+    return { a: sx, b: 0, c: 0, d: sy, e: 0, f: 0 };
+}
+function rotation(degrees, cx = 0, cy = 0) {
+    const rad = (degrees * Math.PI) / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    const rot = { a: cos, b: sin, c: -sin, d: cos, e: 0, f: 0 };
+    if (cx === 0 && cy === 0)
+        return rot;
+    // rotate(a, cx, cy) === translate(cx,cy) rotate(a) translate(-cx,-cy)
+    return multiply(multiply(translation(cx, cy), rot), translation(-cx, -cy));
+}
+/**
+ * Parse an SVG `transform` attribute into a matrix.
+ *
+ * Supports the forms the renderer actually emits — translate / rotate / scale /
+ * matrix — composed left-to-right, exactly as SVG composes them. An
+ * unrecognised function is skipped rather than throwing: a transform we cannot
+ * read must not take the whole frame down.
+ */
+function parseTransform(transform) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (!transform)
+        return exports.IDENTITY;
+    let m = exports.IDENTITY;
+    const re = /([a-zA-Z]+)\s*\(([^)]*)\)/g;
+    let match;
+    while ((match = re.exec(transform)) !== null) {
+        const fn = match[1];
+        const args = match[2]
+            .split(/[\s,]+/)
+            .map((v) => parseFloat(v))
+            .filter((v) => !Number.isNaN(v));
+        switch (fn) {
+            case 'translate':
+                m = multiply(m, translation((_a = args[0]) !== null && _a !== void 0 ? _a : 0, (_b = args[1]) !== null && _b !== void 0 ? _b : 0));
+                break;
+            case 'scale':
+                m = multiply(m, scaling((_c = args[0]) !== null && _c !== void 0 ? _c : 1, (_e = (_d = args[1]) !== null && _d !== void 0 ? _d : args[0]) !== null && _e !== void 0 ? _e : 1));
+                break;
+            case 'rotate':
+                m = multiply(m, rotation((_f = args[0]) !== null && _f !== void 0 ? _f : 0, (_g = args[1]) !== null && _g !== void 0 ? _g : 0, (_h = args[2]) !== null && _h !== void 0 ? _h : 0));
+                break;
+            case 'matrix':
+                if (args.length >= 6) {
+                    m = multiply(m, {
+                        a: args[0],
+                        b: args[1],
+                        c: args[2],
+                        d: args[3],
+                        e: args[4],
+                        f: args[5],
+                    });
+                }
+                break;
+            default:
+                // skew / unknown: not emitted by the renderer today. Ignored on purpose.
+                break;
+        }
+    }
+    return m;
+}
+// ---------------------------------------------------------------------------
+// Primitive → PathCmd[]
+// ---------------------------------------------------------------------------
+/** Axis-aligned rectangle, with optional (possibly asymmetric) corner radii. */
+function rectPath(x, y, width, height, rx = 0, ry = rx) {
+    const w = Math.abs(width);
+    const h = Math.abs(height);
+    const x0 = width < 0 ? x + width : x;
+    const y0 = height < 0 ? y + height : y;
+    let a = Math.max(0, rx || 0);
+    let b = Math.max(0, ry || rx || 0);
+    a = Math.min(a, w / 2);
+    b = Math.min(b, h / 2);
+    if (a === 0 || b === 0) {
+        return [
+            { op: 'M', x: x0, y: y0 },
+            { op: 'L', x: x0 + w, y: y0 },
+            { op: 'L', x: x0 + w, y: y0 + h },
+            { op: 'L', x: x0, y: y0 + h },
+            { op: 'Z' },
+        ];
+    }
+    const ka = a * KAPPA;
+    const kb = b * KAPPA;
+    return [
+        { op: 'M', x: x0 + a, y: y0 },
+        { op: 'L', x: x0 + w - a, y: y0 },
+        { op: 'C', x1: x0 + w - a + ka, y1: y0, x2: x0 + w, y2: y0 + b - kb, x: x0 + w, y: y0 + b },
+        { op: 'L', x: x0 + w, y: y0 + h - b },
+        {
+            op: 'C',
+            x1: x0 + w,
+            y1: y0 + h - b + kb,
+            x2: x0 + w - a + ka,
+            y2: y0 + h,
+            x: x0 + w - a,
+            y: y0 + h,
+        },
+        { op: 'L', x: x0 + a, y: y0 + h },
+        { op: 'C', x1: x0 + a - ka, y1: y0 + h, x2: x0, y2: y0 + h - b + kb, x: x0, y: y0 + h - b },
+        { op: 'L', x: x0, y: y0 + b },
+        { op: 'C', x1: x0, y1: y0 + b - kb, x2: x0 + a - ka, y2: y0, x: x0 + a, y: y0 },
+        { op: 'Z' },
+    ];
+}
+/** Ellipse centred at (cx, cy) as four cubic segments. */
+function ellipsePath(cx, cy, rx, ry) {
+    const a = Math.abs(rx);
+    const b = Math.abs(ry);
+    const ka = a * KAPPA;
+    const kb = b * KAPPA;
+    return [
+        { op: 'M', x: cx + a, y: cy },
+        { op: 'C', x1: cx + a, y1: cy + kb, x2: cx + ka, y2: cy + b, x: cx, y: cy + b },
+        { op: 'C', x1: cx - ka, y1: cy + b, x2: cx - a, y2: cy + kb, x: cx - a, y: cy },
+        { op: 'C', x1: cx - a, y1: cy - kb, x2: cx - ka, y2: cy - b, x: cx, y: cy - b },
+        { op: 'C', x1: cx + ka, y1: cy - b, x2: cx + a, y2: cy - kb, x: cx + a, y: cy },
+        { op: 'Z' },
+    ];
+}
+function circlePath(cx, cy, r) {
+    return ellipsePath(cx, cy, r, r);
+}
+function linePath(x1, y1, x2, y2) {
+    return [
+        { op: 'M', x: x1, y: y1 },
+        { op: 'L', x: x2, y: y2 },
+    ];
+}
+/** `points="1,2 3,4"` (or `1 2 3 4`) → a polyline / polygon command list. */
+function polyPath(points, close) {
+    if (!points)
+        return [];
+    const nums = points
+        .trim()
+        .split(/[\s,]+/)
+        .map((v) => parseFloat(v))
+        .filter((v) => !Number.isNaN(v));
+    const cmds = [];
+    for (let i = 0; i + 1 < nums.length; i += 2) {
+        cmds.push(i === 0 ? { op: 'M', x: nums[i], y: nums[i + 1] } : { op: 'L', x: nums[i], y: nums[i + 1] });
+    }
+    if (close && cmds.length > 0)
+        cmds.push({ op: 'Z' });
+    return cmds;
+}
+// ---------------------------------------------------------------------------
+// SVG path `d` parser
+// ---------------------------------------------------------------------------
+/**
+ * Parse an SVG path `d` string into {@link PathCmd}s.
+ *
+ * Full command coverage (M m L l H h V v C c S s Q q T t A a Z z) including
+ * implicit repeated coordinate sets ("M 0 0 10 10" ⇒ moveto + lineto) and the
+ * smooth-curve reflection rules. Arcs are converted to cubics.
+ *
+ * Written by hand rather than leaned on the DOM (`SVGPathElement`) so it works
+ * headlessly — in Node, in a worker, in a test — which is exactly where the
+ * canvas backend has to be provable.
+ */
+function parsePath(d) {
+    if (!d)
+        return [];
+    const cmds = [];
+    const tokens = d.match(/[MmLlHhVvCcSsQqTtAaZz]|[-+]?(?:\d*\.\d+|\d+)(?:[eE][-+]?\d+)?/g);
+    if (!tokens)
+        return [];
+    let i = 0;
+    let cx = 0; // current point
+    let cy = 0;
+    let sx = 0; // sub-path start (for Z)
+    let sy = 0;
+    let prevCtrlX = 0; // last cubic control point (for S)
+    let prevCtrlY = 0;
+    let prevQCtrlX = 0; // last quadratic control point (for T)
+    let prevQCtrlY = 0;
+    let prevOp = '';
+    let op = '';
+    const num = () => {
+        const v = parseFloat(tokens[i++]);
+        return Number.isNaN(v) ? 0 : v;
+    };
+    const isCmd = (t) => !!t && /[MmLlHhVvCcSsQqTtAaZz]/.test(t);
+    while (i < tokens.length) {
+        if (isCmd(tokens[i])) {
+            op = tokens[i++];
+        }
+        else if (op === 'M') {
+            op = 'L'; // implicit lineto after a moveto
+        }
+        else if (op === 'm') {
+            op = 'l';
+        }
+        else if (!op) {
+            i++; // stray number before any command
+            continue;
+        }
+        const rel = op === op.toLowerCase();
+        const ox = rel ? cx : 0;
+        const oy = rel ? cy : 0;
+        switch (op.toUpperCase()) {
+            case 'M': {
+                cx = num() + ox;
+                cy = num() + oy;
+                sx = cx;
+                sy = cy;
+                cmds.push({ op: 'M', x: cx, y: cy });
+                break;
+            }
+            case 'L': {
+                cx = num() + ox;
+                cy = num() + oy;
+                cmds.push({ op: 'L', x: cx, y: cy });
+                break;
+            }
+            case 'H': {
+                cx = num() + ox;
+                cmds.push({ op: 'L', x: cx, y: cy });
+                break;
+            }
+            case 'V': {
+                cy = num() + oy;
+                cmds.push({ op: 'L', x: cx, y: cy });
+                break;
+            }
+            case 'C': {
+                const x1 = num() + ox;
+                const y1 = num() + oy;
+                const x2 = num() + ox;
+                const y2 = num() + oy;
+                cx = num() + ox;
+                cy = num() + oy;
+                cmds.push({ op: 'C', x1, y1, x2, y2, x: cx, y: cy });
+                prevCtrlX = x2;
+                prevCtrlY = y2;
+                break;
+            }
+            case 'S': {
+                const smooth = /[CcSs]/.test(prevOp);
+                const x1 = smooth ? 2 * cx - prevCtrlX : cx;
+                const y1 = smooth ? 2 * cy - prevCtrlY : cy;
+                const x2 = num() + ox;
+                const y2 = num() + oy;
+                cx = num() + ox;
+                cy = num() + oy;
+                cmds.push({ op: 'C', x1, y1, x2, y2, x: cx, y: cy });
+                prevCtrlX = x2;
+                prevCtrlY = y2;
+                break;
+            }
+            case 'Q': {
+                const x1 = num() + ox;
+                const y1 = num() + oy;
+                cx = num() + ox;
+                cy = num() + oy;
+                cmds.push({ op: 'Q', x1, y1, x: cx, y: cy });
+                prevQCtrlX = x1;
+                prevQCtrlY = y1;
+                break;
+            }
+            case 'T': {
+                const smooth = /[QqTt]/.test(prevOp);
+                const x1 = smooth ? 2 * cx - prevQCtrlX : cx;
+                const y1 = smooth ? 2 * cy - prevQCtrlY : cy;
+                cx = num() + ox;
+                cy = num() + oy;
+                cmds.push({ op: 'Q', x1, y1, x: cx, y: cy });
+                prevQCtrlX = x1;
+                prevQCtrlY = y1;
+                break;
+            }
+            case 'A': {
+                const rx = num();
+                const ry = num();
+                const rot = num();
+                const largeArc = num();
+                const sweep = num();
+                const ex = num() + ox;
+                const ey = num() + oy;
+                cmds.push(...arcToCubics(cx, cy, rx, ry, rot, largeArc !== 0, sweep !== 0, ex, ey));
+                cx = ex;
+                cy = ey;
+                break;
+            }
+            case 'Z': {
+                cmds.push({ op: 'Z' });
+                cx = sx;
+                cy = sy;
+                break;
+            }
+            default:
+                i++; // unknown token — do not spin
+                break;
+        }
+        prevOp = op;
+    }
+    return cmds;
+}
+/**
+ * SVG elliptical arc → cubic béziers (endpoint→centre parameterisation, SVG 1.1
+ * appendix F.6). Used by `A` path commands — the actor shape's head, cylinder
+ * caps, jump-point arcs.
+ */
+function arcToCubics(x1, y1, rx, ry, rotationDeg, largeArc, sweep, x2, y2) {
+    if (rx === 0 || ry === 0)
+        return [{ op: 'L', x: x2, y: y2 }];
+    if (x1 === x2 && y1 === y2)
+        return [];
+    let arx = Math.abs(rx);
+    let ary = Math.abs(ry);
+    const phi = ((rotationDeg % 360) * Math.PI) / 180;
+    const cosPhi = Math.cos(phi);
+    const sinPhi = Math.sin(phi);
+    const dx2 = (x1 - x2) / 2;
+    const dy2 = (y1 - y2) / 2;
+    const x1p = cosPhi * dx2 + sinPhi * dy2;
+    const y1p = -sinPhi * dx2 + cosPhi * dy2;
+    // Correct out-of-range radii (spec F.6.6)
+    const lambda = (x1p * x1p) / (arx * arx) + (y1p * y1p) / (ary * ary);
+    if (lambda > 1) {
+        const s = Math.sqrt(lambda);
+        arx *= s;
+        ary *= s;
+    }
+    const rxSq = arx * arx;
+    const rySq = ary * ary;
+    const numerator = rxSq * rySq - rxSq * y1p * y1p - rySq * x1p * x1p;
+    const denominator = rxSq * y1p * y1p + rySq * x1p * x1p;
+    let coef = Math.sqrt(Math.max(0, numerator / denominator));
+    if (largeArc === sweep)
+        coef = -coef;
+    const cxp = (coef * (arx * y1p)) / ary;
+    const cyp = (coef * -(ary * x1p)) / arx;
+    const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
+    const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
+    const angle = (ux, uy, vx, vy) => {
+        const dot = ux * vx + uy * vy;
+        const len = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy);
+        let a = Math.acos(Math.max(-1, Math.min(1, len === 0 ? 1 : dot / len)));
+        if (ux * vy - uy * vx < 0)
+            a = -a;
+        return a;
+    };
+    const ux = (x1p - cxp) / arx;
+    const uy = (y1p - cyp) / ary;
+    const vx = (-x1p - cxp) / arx;
+    const vy = (-y1p - cyp) / ary;
+    const theta1 = angle(1, 0, ux, uy);
+    let dTheta = angle(ux, uy, vx, vy);
+    if (!sweep && dTheta > 0)
+        dTheta -= 2 * Math.PI;
+    else if (sweep && dTheta < 0)
+        dTheta += 2 * Math.PI;
+    // Split into <= 90° segments and emit a cubic for each.
+    const segments = Math.max(1, Math.ceil(Math.abs(dTheta / (Math.PI / 2))));
+    const delta = dTheta / segments;
+    const t = (4 / 3) * Math.tan(delta / 4);
+    const out = [];
+    let th = theta1;
+    let px = x1;
+    let py = y1;
+    const e = (ct, st) => ({
+        x: cx + cosPhi * arx * ct - sinPhi * ary * st,
+        y: cy + sinPhi * arx * ct + cosPhi * ary * st,
+    });
+    const ePrime = (ct, st) => ({
+        x: -cosPhi * arx * st - sinPhi * ary * ct,
+        y: -sinPhi * arx * st + cosPhi * ary * ct,
+    });
+    for (let s = 0; s < segments; s++) {
+        const th2 = th + delta;
+        const cosTh = Math.cos(th);
+        const sinTh = Math.sin(th);
+        const cosTh2 = Math.cos(th2);
+        const sinTh2 = Math.sin(th2);
+        const p2 = e(cosTh2, sinTh2);
+        const d1 = ePrime(cosTh, sinTh);
+        const d2 = ePrime(cosTh2, sinTh2);
+        out.push({
+            op: 'C',
+            x1: px + t * d1.x,
+            y1: py + t * d1.y,
+            x2: p2.x - t * d2.x,
+            y2: p2.y - t * d2.y,
+            x: p2.x,
+            y: p2.y,
+        });
+        px = p2.x;
+        py = p2.y;
+        th = th2;
+    }
+    return out;
+}
+function cubicAt(p0, p1, p2, p3, 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 * p0.x + b * p1.x + c * p2.x + d * p3.x,
+        y: a * p0.y + b * p1.y + c * p2.y + d * p3.y,
+    };
+}
+function quadAt(p0, p1, p2, t) {
+    const mt = 1 - t;
+    return {
+        x: mt * mt * p0.x + 2 * mt * t * p1.x + t * t * p2.x,
+        y: mt * mt * p0.y + 2 * mt * t * p1.y + t * t * p2.y,
+    };
+}
+/**
+ * Flatten a command list into polylines. `steps` controls curve subdivision —
+ * 16 segments per curve keeps the deviation well under a pixel for the curve
+ * sizes a diagram draws, and hit-testing only ever needs "within tolerance".
+ */
+function flattenPath(cmds, steps = 16) {
+    const subs = [];
+    let current = null;
+    let cursor = { x: 0, y: 0 };
+    const ensure = () => {
+        if (!current) {
+            current = { points: [Object.assign({}, cursor)], closed: false };
+            subs.push(current);
+        }
+        return current;
+    };
+    for (const cmd of cmds) {
+        switch (cmd.op) {
+            case 'M':
+                cursor = { x: cmd.x, y: cmd.y };
+                current = { points: [Object.assign({}, cursor)], closed: false };
+                subs.push(current);
+                break;
+            case 'L':
+                ensure().points.push({ x: cmd.x, y: cmd.y });
+                cursor = { x: cmd.x, y: cmd.y };
+                break;
+            case 'C': {
+                const sub = ensure();
+                const p0 = cursor;
+                const p1 = { x: cmd.x1, y: cmd.y1 };
+                const p2 = { x: cmd.x2, y: cmd.y2 };
+                const p3 = { x: cmd.x, y: cmd.y };
+                for (let s = 1; s <= steps; s++)
+                    sub.points.push(cubicAt(p0, p1, p2, p3, s / steps));
+                cursor = p3;
+                break;
+            }
+            case 'Q': {
+                const sub = ensure();
+                const p0 = cursor;
+                const p1 = { x: cmd.x1, y: cmd.y1 };
+                const p2 = { x: cmd.x, y: cmd.y };
+                for (let s = 1; s <= steps; s++)
+                    sub.points.push(quadAt(p0, p1, p2, s / steps));
+                cursor = p2;
+                break;
+            }
+            case 'Z': {
+                if (current) {
+                    current.closed = true;
+                    cursor = Object.assign({}, current.points[0]);
+                }
+                break;
+            }
+        }
+    }
+    return subs.filter((s) => s.points.length > 0);
+}
+function transformCmds(cmds, m) {
+    if (m === exports.IDENTITY)
+        return cmds;
+    return cmds.map((cmd) => {
+        switch (cmd.op) {
+            case 'M':
+            case 'L': {
+                const p = applyMatrix(m, cmd);
+                return { op: cmd.op, x: p.x, y: p.y };
+            }
+            case 'C': {
+                const c1 = applyMatrix(m, { x: cmd.x1, y: cmd.y1 });
+                const c2 = applyMatrix(m, { x: cmd.x2, y: cmd.y2 });
+                const p = applyMatrix(m, { x: cmd.x, y: cmd.y });
+                return { op: 'C', x1: c1.x, y1: c1.y, x2: c2.x, y2: c2.y, x: p.x, y: p.y };
+            }
+            case 'Q': {
+                const c1 = applyMatrix(m, { x: cmd.x1, y: cmd.y1 });
+                const p = applyMatrix(m, { x: cmd.x, y: cmd.y });
+                return { op: 'Q', x1: c1.x, y1: c1.y, x: p.x, y: p.y };
+            }
+            default:
+                return cmd;
+        }
+    });
+}
+/** Bounding box of the flattened path. `null` for an empty path. */
+function pathBounds(cmds) {
+    const subs = flattenPath(cmds, 8);
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const sub of subs) {
+        for (const p of sub.points) {
+            if (p.x < minX)
+                minX = p.x;
+            if (p.y < minY)
+                minY = p.y;
+            if (p.x > maxX)
+                maxX = p.x;
+            if (p.y > maxY)
+                maxY = p.y;
+        }
+    }
+    if (!isFinite(minX))
+        return null;
+    return { minX, minY, maxX, maxY };
+}
+/**
+ * Non-zero-winding point-in-path — the same fill rule a 2D context uses by
+ * default, so "is this point inside the filled shape?" answers identically to
+ * "did the fill put a pixel here?".
+ */
+function pointInPath(cmds, p) {
+    const subs = flattenPath(cmds);
+    let winding = 0;
+    for (const sub of subs) {
+        const pts = sub.points;
+        if (pts.length < 2)
+            continue;
+        // A fill always treats a sub-path as closed, whether or not `Z` was issued.
+        const n = pts.length;
+        for (let i = 0; i < n; i++) {
+            const a = pts[i];
+            const b = pts[(i + 1) % n];
+            if (a.y <= p.y) {
+                if (b.y > p.y && cross(a, b, p) > 0)
+                    winding++;
+            }
+            else if (b.y <= p.y && cross(a, b, p) < 0) {
+                winding--;
+            }
+        }
+    }
+    return winding !== 0;
+}
+function cross(a, b, p) {
+    return (b.x - a.x) * (p.y - a.y) - (p.x - a.x) * (b.y - a.y);
+}
+/** Shortest distance from `p` to the path's outline (open OR closed). */
+function distanceToPath(cmds, p) {
+    const subs = flattenPath(cmds);
+    let best = Infinity;
+    for (const sub of subs) {
+        const pts = sub.points;
+        if (pts.length === 1) {
+            best = Math.min(best, Math.hypot(p.x - pts[0].x, p.y - pts[0].y));
+            continue;
+        }
+        const segCount = sub.closed ? pts.length : pts.length - 1;
+        for (let i = 0; i < segCount; i++) {
+            const a = pts[i];
+            const b = pts[(i + 1) % pts.length];
+            best = Math.min(best, distanceToSegment(p, a, b));
+        }
+    }
+    return best;
+}
+function distanceToSegment(p, a, b) {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const lenSq = dx * dx + dy * dy;
+    let t = lenSq === 0 ? 0 : ((p.x - a.x) * dx + (p.y - a.y) * dy) / lenSq;
+    t = Math.max(0, Math.min(1, t));
+    return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+function boundsUnion(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return {
+        minX: Math.min(a.minX, b.minX),
+        minY: Math.min(a.minY, b.minY),
+        maxX: Math.max(a.maxX, b.maxX),
+        maxY: Math.max(a.maxY, b.maxY),
+    };
+}
+function boundsIntersect(a, b) {
+    return !(a.maxX < b.minX || a.minX > b.maxX || a.maxY < b.minY || a.minY > b.maxY);
+}
+function padBounds(b, pad) {
+    return { minX: b.minX - pad, minY: b.minY - pad, maxX: b.maxX + pad, maxY: b.maxY + pad };
+}
+//# sourceMappingURL=path-geometry.js.map