@weasel-js/geom 1.7.0 → 1.7.2

package/dist/index.js

@@ -1,7 +1,17 @@
-import { cubicEvalAt, elevateQuadraticToCubic, forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z } from './chunk-36DHVSOV.js';
-export { DEFAULT_FLATTEN_TOLERANCE, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, cubicBounds, cubicEvalAt, elevateQuadraticToCubic, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, pathCommandCoordCount, quadraticEvalAt, splitCubicAt, splitLineAt, splitQuadraticAt } from './chunk-36DHVSOV.js';
-import { PORT_REACH, SINGULAR_RATIO, portControls, cubicAt, sign, len2, dot } from './chunk-3GFNUO4N.js';
-export { EPS, PORT_REACH, approxEq, cross, dot, len2, sign, sub } from './chunk-3GFNUO4N.js';
+import { PORT_REACH, portControls, cubicAt } from './chunk-TXEGHCJ4.js';
+export { PORT_REACH } from './chunk-TXEGHCJ4.js';
+import { cubicPointAt } from './chunk-HPVINMOM.js';
+export { cubicPointAt, fitCubicThroughDeletion, splitCubicAtT } from './chunk-HPVINMOM.js';
+import { cubicEvalAt, elevateQuadraticToCubic, cubicBounds } from './chunk-URQMDR6Q.js';
+export { cubicBounds, cubicEvalAt, elevateQuadraticToCubic, quadraticEvalAt, splitCubicAt, splitLineAt, splitQuadraticAt } from './chunk-URQMDR6Q.js';
+import { extractPolylines } from './chunk-6T5I3PR5.js';
+export { boundsOfCoords, boxContainsBox, boxContainsPoint, rectToContour, unionBox } from './chunk-6T5I3PR5.js';
+import { DEFAULT_FLATTEN_TOLERANCE, pointInPolygon, pointSegmentDist2, flattenQuadratic, flattenCubic, segmentsCross } from './chunk-RQYCDPU5.js';
+export { DEFAULT_FLATTEN_TOLERANCE, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pointInPolygon, pointSegmentDist2, segmentsCross } from './chunk-RQYCDPU5.js';
+import { SINGULAR_RATIO } from './chunk-7ROQRYOA.js';
+export { EPS, approxEq, cross, dot, len2, sign, sub } from './chunk-7ROQRYOA.js';
+import { forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z, pathCommandCoordCount } from './chunk-HEZTRG2M.js';
+export { PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, forEachSegment, pathCommandCoordCount } from './chunk-HEZTRG2M.js';
 
 // src/mat3.ts
 function identity() {
@@ -51,34 +61,6 @@ function rotateAboutPoint(cx, cy, rad) {
   return multiply(translate(cx, cy), multiply(rotate(rad), translate(-cx, -cy)));
 }
 
-// src/box.ts
-function boundsOfCoords(coords) {
-  if (coords.length < 2) return null;
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (let i = 0; i + 1 < coords.length; i += 2) {
-    const x = coords[i], y = coords[i + 1];
-    if (x < minX) minX = x;
-    if (y < minY) minY = y;
-    if (x > maxX) maxX = x;
-    if (y > maxY) maxY = y;
-  }
-  return [minX, minY, maxX, maxY];
-}
-function unionBox(a, b) {
-  return [
-    Math.min(a[0], b[0]),
-    Math.min(a[1], b[1]),
-    Math.max(a[2], b[2]),
-    Math.max(a[3], b[3])
-  ];
-}
-function boxContainsPoint(b, x, y) {
-  return x >= b[0] && x <= b[2] && y >= b[1] && y <= b[3];
-}
-function rectToContour(x, y, w, h) {
-  return Float64Array.of(x, y, x + w, y, x + w, y + h, x, y + h);
-}
-
 // src/nearest.ts
 function nearestOnLine(px, py, x0, y0, x1, y1) {
   const vx = x1 - x0, vy = y1 - y0;
@@ -198,33 +180,221 @@ function portCurvePoints(ax, ay, bx, by, outNormal, inNormal, samples, reach = P
   return out;
 }
 
-// src/polyline.ts
-function pointInPolygon(coords, px, py, start = 0, end = coords.length >> 1) {
-  if (end - start < 3) return false;
-  let inside = false;
-  for (let i = start, j = end - 1; i < end; j = i++) {
-    const xi = coords[i * 2], yi = coords[i * 2 + 1];
-    const xj = coords[j * 2], yj = coords[j * 2 + 1];
-    const crosses = yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi;
-    if (crosses) inside = !inside;
-  }
-  return inside;
-}
-function segmentsCross(ax, ay, bx, by, cx, cy, dx, dy) {
-  const d1 = sign((dx - cx) * (ay - cy) - (dy - cy) * (ax - cx));
-  const d2 = sign((dx - cx) * (by - cy) - (dy - cy) * (bx - cx));
-  const d3 = sign((bx - ax) * (cy - ay) - (by - ay) * (cx - ax));
-  const d4 = sign((bx - ax) * (dy - ay) - (by - ay) * (dx - ax));
-  return d1 !== d2 && d3 !== d4;
-}
-function pointSegmentDist2(px, py, ax, ay, bx, by) {
-  const vx = bx - ax, vy = by - ay;
-  const wx = px - ax, wy = py - ay;
-  const vv = len2(vx, vy);
-  let t = vv === 0 ? 0 : dot(wx, wy, vx, vy) / vv;
-  t = t < 0 ? 0 : t > 1 ? 1 : t;
-  const dx = px - (ax + t * vx), dy = py - (ay + t * vy);
-  return len2(dx, dy);
+// src/paths/builder.ts
+var PathBuilder = class _PathBuilder {
+  cmds = [];
+  xs = [];
+  fillRule = "nonzero";
+  /** Seed a builder with an existing `PolygonPath`. Useful for extending
+   *  an in-flight path with another segment (e.g. appending a cubic to
+   *  the end of a curve in response to a user action) without hand-
+   *  reaching into the `commands` / `coords` typed arrays.
+   *
+   *  ```ts
+   *  const next = PathBuilder.fromPath(current).curveTo(...).build();
+   *  ```
+   */
+  static fromPath(path) {
+    const b = new _PathBuilder();
+    b.cmds = Array.from(path.commands);
+    b.xs = Array.from(path.coords);
+    b.fillRule = path.fillRule;
+    return b;
+  }
+  setFillRule(rule) {
+    this.fillRule = rule;
+    return this;
+  }
+  moveTo(x, y) {
+    this.cmds.push(PATH_M);
+    this.xs.push(x, y);
+    return this;
+  }
+  lineTo(x, y) {
+    this.cmds.push(PATH_L);
+    this.xs.push(x, y);
+    return this;
+  }
+  /** Cubic bezier to (x, y) with control points (x1, y1) and (x2, y2). */
+  curveTo(x1, y1, x2, y2, x, y) {
+    this.cmds.push(PATH_C);
+    this.xs.push(x1, y1, x2, y2, x, y);
+    return this;
+  }
+  /** Quadratic bezier to (x, y) with control point (x1, y1). */
+  quadTo(x1, y1, x, y) {
+    this.cmds.push(PATH_Q);
+    this.xs.push(x1, y1, x, y);
+    return this;
+  }
+  close() {
+    this.cmds.push(PATH_Z);
+    return this;
+  }
+  build() {
+    return {
+      kind: "polygon",
+      commands: new Uint8Array(this.cmds),
+      coords: new Float32Array(this.xs),
+      fillRule: this.fillRule
+    };
+  }
+};
+function rectPath(x, y, width, height) {
+  return { kind: "rect", x, y, width, height };
+}
+function polylineFromPoints(points) {
+  const b = new PathBuilder();
+  const first = points[0];
+  if (!first) return rectPath(0, 0, 0, 0);
+  b.moveTo(first.x, first.y);
+  for (let i = 1; i < points.length; i++) {
+    const p = points[i];
+    if (p) b.lineTo(p.x, p.y);
+  }
+  return b.build();
+}
+function polygonFromPoints(points, opts = {}) {
+  if (points.length === 0) {
+    return {
+      kind: "polygon",
+      commands: new Uint8Array(),
+      coords: new Float32Array(),
+      fillRule: opts.fillRule ?? "nonzero"
+    };
+  }
+  const b = new PathBuilder();
+  if (opts.fillRule) b.setFillRule(opts.fillRule);
+  b.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) b.lineTo(points[i].x, points[i].y);
+  b.close();
+  return b.build();
+}
+var ELLIPSE_KAPPA = 0.5522847498307936;
+function ellipsePath(bounds) {
+  const cx = bounds.x + bounds.width / 2;
+  const cy = bounds.y + bounds.height / 2;
+  const rx = bounds.width / 2;
+  const ry = bounds.height / 2;
+  const ox = rx * ELLIPSE_KAPPA;
+  const oy = ry * ELLIPSE_KAPPA;
+  const b = new PathBuilder();
+  b.moveTo(cx + rx, cy);
+  b.curveTo(cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry);
+  b.curveTo(cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy);
+  b.curveTo(cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry);
+  b.curveTo(cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy);
+  b.close();
+  return b.build();
+}
+function regularPolygonPath(center, radius, sides, rotation = 0) {
+  const b = new PathBuilder();
+  for (let i = 0; i < sides; i++) {
+    const a = rotation + i / sides * Math.PI * 2;
+    const x = center.x + radius * Math.cos(a);
+    const y = center.y + radius * Math.sin(a);
+    if (i === 0) b.moveTo(x, y);
+    else b.lineTo(x, y);
+  }
+  b.close();
+  return b.build();
+}
+function starPath(center, outerRadius, points = 5, innerRadius = outerRadius / 2, rotation = 0) {
+  const b = new PathBuilder();
+  const n = points * 2;
+  for (let i = 0; i < n; i++) {
+    const a = rotation + i / n * Math.PI * 2;
+    const r = i % 2 === 0 ? outerRadius : innerRadius;
+    const x = center.x + r * Math.cos(a);
+    const y = center.y + r * Math.sin(a);
+    if (i === 0) b.moveTo(x, y);
+    else b.lineTo(x, y);
+  }
+  b.close();
+  return b.build();
+}
+function linePath(a, b) {
+  const pb = new PathBuilder();
+  pb.moveTo(a.x, a.y);
+  pb.lineTo(b.x, b.y);
+  return pb.build();
+}
+
+// src/paths/bounds.ts
+function boundsOfPath(path) {
+  if (path.kind === "rect") return path;
+  const { commands, coords } = path;
+  if (commands.length === 0) {
+    return { kind: "rect", x: 0, y: 0, width: 0, height: 0 };
+  }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let seen = false;
+  const include = (x, y) => {
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+    seen = true;
+  };
+  forEachSegment(commands, coords, (cmd, ci, px, py) => {
+    switch (cmd) {
+      case PATH_M:
+      case PATH_L: {
+        include(coords[ci], coords[ci + 1]);
+        break;
+      }
+      case PATH_C: {
+        const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(
+          px,
+          py,
+          coords[ci],
+          coords[ci + 1],
+          coords[ci + 2],
+          coords[ci + 3],
+          coords[ci + 4],
+          coords[ci + 5]
+        );
+        include(bMinX, bMinY);
+        include(bMaxX, bMaxY);
+        break;
+      }
+      case PATH_Q: {
+        const qx2 = coords[ci + 2], qy2 = coords[ci + 3];
+        const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(px, py, coords[ci], coords[ci + 1], qx2, qy2);
+        const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(px, py, c1x, c1y, c2x, c2y, qx2, qy2);
+        include(bMinX, bMinY);
+        include(bMaxX, bMaxY);
+        break;
+      }
+      case PATH_Z:
+        break;
+      default:
+        throw new Error(`boundsOfPath: unknown command ${cmd}`);
+    }
+  });
+  if (!seen) return { kind: "rect", x: 0, y: 0, width: 0, height: 0 };
+  return { kind: "rect", x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+
+// src/paths/unionBoundsPath.ts
+function unionBoundsPath(paths) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let any = false;
+  for (const p of paths) {
+    any = true;
+    const b = boundsOfPath(p);
+    if (b.x < minX) minX = b.x;
+    if (b.y < minY) minY = b.y;
+    const right = b.x + b.width;
+    const bottom = b.y + b.height;
+    if (right > maxX) maxX = right;
+    if (bottom > maxY) maxY = bottom;
+  }
+  if (!any) return null;
+  return { kind: "rect", x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
 
 // src/affine.ts
@@ -239,6 +409,1146 @@ function transformCoords(coords, m) {
   return out;
 }
 
+// src/paths/transformPath.ts
+function transformPath(path, m) {
+  const [a, b, c, d, e, f] = m;
+  if (path.kind === "rect") {
+    if (b === 0 && c === 0) {
+      const x0 = a * path.x + e;
+      const y0 = d * path.y + f;
+      const x1 = a * (path.x + path.width) + e;
+      const y1 = d * (path.y + path.height) + f;
+      return {
+        kind: "rect",
+        x: Math.min(x0, x1),
+        y: Math.min(y0, y1),
+        width: Math.abs(x1 - x0),
+        height: Math.abs(y1 - y0)
+      };
+    }
+    const poly = new PathBuilder().moveTo(path.x, path.y).lineTo(path.x + path.width, path.y).lineTo(path.x + path.width, path.y + path.height).lineTo(path.x, path.y + path.height).close().build();
+    return transformPolygon(poly, m);
+  }
+  return transformPolygon(path, m);
+}
+function transformPolygon(path, m) {
+  const mapped = transformCoords(path.coords, m);
+  return { ...path, coords: Float32Array.from(mapped) };
+}
+
+// src/paths/transform.ts
+function translatePath(path, dx, dy) {
+  if (path.kind === "rect") {
+    return { kind: "rect", x: path.x + dx, y: path.y + dy, width: path.width, height: path.height };
+  }
+  return translatePolygonCopy(path, dx, dy);
+}
+function translatePolygonCopy(path, dx, dy) {
+  const next = new Float32Array(path.coords.length);
+  const { commands, coords } = path;
+  forEachSegment(commands, coords, (cmd, ci) => {
+    for (let k = 0, len = pathCommandCoordCount(cmd); k < len; k += 2) {
+      next[ci + k] = coords[ci + k] + dx;
+      next[ci + k + 1] = coords[ci + k + 1] + dy;
+    }
+  });
+  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
+}
+function scalePathToBounds(path, target) {
+  if (path.kind === "rect") {
+    return { kind: "rect", x: target.x, y: target.y, width: target.width, height: target.height };
+  }
+  const src = boundsOfPath(path);
+  return scalePolygon(path, src, target);
+}
+function scalePolygon(path, src, dst) {
+  const m = boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height);
+  return transformPath(path, m);
+}
+
+// src/paths/compose.ts
+function composePath(parent, child) {
+  const origin = pathOrigin(parent);
+  return translatePath(child, origin.x, origin.y);
+}
+function decomposePath(parent, world) {
+  const origin = pathOrigin(parent);
+  return translatePath(world, -origin.x, -origin.y);
+}
+function pathOrigin(path) {
+  if (path.kind === "rect") return { x: path.x, y: path.y };
+  let minX = Infinity;
+  let minY = Infinity;
+  const { coords } = path;
+  for (let i = 0; i < coords.length; i += 2) {
+    if (coords[i] < minX) minX = coords[i];
+    if (coords[i + 1] < minY) minY = coords[i + 1];
+  }
+  if (minX === Infinity) return { x: 0, y: 0 };
+  return { x: minX, y: minY };
+}
+
+// src/paths/splitSubpaths.ts
+function splitSubpaths(path) {
+  const { commands, coords, fillRule } = path;
+  const out = [];
+  let cmdStart = 0;
+  let coordStart = 0;
+  forEachSegment(commands, coords, (cmd, ci, _px, _py, i) => {
+    if (cmd !== PATH_M || i <= cmdStart) return;
+    out.push({
+      kind: "polygon",
+      commands: commands.slice(cmdStart, i),
+      coords: coords.slice(coordStart, ci),
+      fillRule
+    });
+    cmdStart = i;
+    coordStart = ci;
+  });
+  out.push({
+    kind: "polygon",
+    commands: commands.slice(cmdStart),
+    coords: coords.slice(coordStart),
+    fillRule
+  });
+  return out;
+}
+
+// src/paths/winding.ts
+var GL_T = [0.5 - Math.sqrt(15) / 10, 0.5, 0.5 + Math.sqrt(15) / 10];
+var GL_W = [5 / 18, 8 / 18, 5 / 18];
+function pathSignedArea(path) {
+  if (path.kind === "rect") return path.width * path.height;
+  const { commands, coords } = path;
+  let twice = 0;
+  let startX = 0, startY = 0;
+  let open = false;
+  let endX = 0, endY = 0;
+  const close = () => {
+    if (open) twice += endX * startY - startX * endY;
+    open = false;
+  };
+  forEachSegment(commands, coords, (cmd, ci, px, py) => {
+    if (cmd === PATH_M) {
+      close();
+      startX = endX = coords[ci];
+      startY = endY = coords[ci + 1];
+      open = true;
+      return;
+    }
+    if (cmd === PATH_Z) {
+      close();
+      endX = startX;
+      endY = startY;
+      return;
+    }
+    if (!open) {
+      startX = px;
+      startY = py;
+      open = true;
+    }
+    if (cmd === PATH_L) {
+      endX = coords[ci];
+      endY = coords[ci + 1];
+      twice += px * endY - endX * py;
+      return;
+    }
+    const cubic = cmd === PATH_C;
+    const x1 = coords[ci], y1 = coords[ci + 1];
+    const x2 = coords[ci + 2], y2 = coords[ci + 3];
+    const x3 = cubic ? coords[ci + 4] : x2, y3 = cubic ? coords[ci + 5] : y2;
+    for (let k = 0; k < 3; k++) {
+      const t = GL_T[k], u = 1 - t;
+      let x, y, dx, dy;
+      if (cubic) {
+        x = u * u * u * px + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x3;
+        y = u * u * u * py + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y3;
+        dx = 3 * (u * u * (x1 - px) + 2 * u * t * (x2 - x1) + t * t * (x3 - x2));
+        dy = 3 * (u * u * (y1 - py) + 2 * u * t * (y2 - y1) + t * t * (y3 - y2));
+      } else {
+        x = u * u * px + 2 * u * t * x1 + t * t * x2;
+        y = u * u * py + 2 * u * t * y1 + t * t * y2;
+        dx = 2 * (u * (x1 - px) + t * (x2 - x1));
+        dy = 2 * (u * (y1 - py) + t * (y2 - y1));
+      }
+      twice += GL_W[k] * (x * dy - y * dx);
+    }
+    endX = x3;
+    endY = y3;
+  });
+  close();
+  return twice / 2;
+}
+function reversePath(path) {
+  const cmds = [];
+  const out = [];
+  let segs = [];
+  let sx = 0, sy = 0;
+  let started = false;
+  const flush = (closed) => {
+    if (!started) return;
+    const last = segs[segs.length - 1];
+    const ex = last ? last.args[last.args.length - 2] : sx;
+    const ey = last ? last.args[last.args.length - 1] : sy;
+    if (closed) {
+      cmds.push(PATH_M);
+      out.push(sx, sy);
+      if (ex !== sx || ey !== sy) {
+        cmds.push(PATH_L);
+        out.push(ex, ey);
+      }
+    } else {
+      cmds.push(PATH_M);
+      out.push(ex, ey);
+    }
+    for (let i = segs.length - 1; i >= 0; i--) {
+      const s = segs[i];
+      cmds.push(s.cmd);
+      if (s.cmd === PATH_C) out.push(s.args[2], s.args[3], s.args[0], s.args[1]);
+      else if (s.cmd === PATH_Q) out.push(s.args[0], s.args[1]);
+      out.push(s.fromX, s.fromY);
+    }
+    if (closed) cmds.push(PATH_Z);
+    segs = [];
+    started = false;
+  };
+  const { commands, coords } = path;
+  forEachSegment(commands, coords, (cmd, ci, px, py) => {
+    if (cmd === PATH_M) {
+      flush(false);
+      sx = coords[ci];
+      sy = coords[ci + 1];
+      started = true;
+      return;
+    }
+    if (cmd === PATH_Z) {
+      flush(true);
+      return;
+    }
+    if (!started) {
+      sx = px;
+      sy = py;
+      started = true;
+    }
+    const n = cmd === PATH_C ? 6 : cmd === PATH_Q ? 4 : 2;
+    segs.push({ cmd, args: Array.from(coords.subarray(ci, ci + n)), fromX: px, fromY: py });
+  });
+  flush(false);
+  return {
+    kind: "polygon",
+    commands: new Uint8Array(cmds),
+    coords: new Float32Array(out),
+    fillRule: path.fillRule
+  };
+}
+
+// src/paths/pathFromD.ts
+var NUM_RE = /[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g;
+var NUM_RE_AT = /[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/y;
+function isCommandLetter(d, j) {
+  const c = d[j];
+  if (!/[A-Za-z]/.test(c)) return false;
+  if (c !== "e" && c !== "E") return true;
+  if (!/[\d.]/.test(d[j - 1] ?? "")) return true;
+  const k = d[j + 1] === "+" || d[j + 1] === "-" ? j + 2 : j + 1;
+  return !/\d/.test(d[k] ?? "");
+}
+function tokenize(d) {
+  const out = [];
+  let i = 0;
+  while (i < d.length) {
+    if (isCommandLetter(d, i)) {
+      let j = i + 1;
+      while (j < d.length && !isCommandLetter(d, j)) j++;
+      const argSlice = d.slice(i + 1, j);
+      const cmd = d[i];
+      out.push({
+        cmd,
+        args: cmd === "A" || cmd === "a" ? readArcArgs(argSlice) : readNumbers(argSlice)
+      });
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  return out;
+}
+function readNumbers(s) {
+  const out = [];
+  let m;
+  NUM_RE.lastIndex = 0;
+  while ((m = NUM_RE.exec(s)) !== null) {
+    const n = Number(m[0]);
+    if (Number.isFinite(n)) out.push(n);
+  }
+  return out;
+}
+function readArcArgs(s) {
+  const out = [];
+  let i = 0;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === "," || c === " " || c === "	" || c === "\n" || c === "\r") {
+      i++;
+      continue;
+    }
+    const slot = out.length % 7;
+    if (slot === 3 || slot === 4) {
+      if (c !== "0" && c !== "1") return out;
+      out.push(c === "1" ? 1 : 0);
+      i++;
+      continue;
+    }
+    NUM_RE_AT.lastIndex = i;
+    const m = NUM_RE_AT.exec(s);
+    if (!m) return out;
+    out.push(Number(m[0]));
+    i = NUM_RE_AT.lastIndex;
+  }
+  return out;
+}
+var ARG_COUNTS = {
+  M: 2,
+  L: 2,
+  H: 1,
+  V: 1,
+  C: 6,
+  S: 4,
+  Q: 4,
+  T: 2,
+  A: 7,
+  Z: 0
+};
+function pathFromD(d, onWarn) {
+  const tokens = tokenize(d);
+  const b = new PathBuilder();
+  const st = {
+    x: 0,
+    y: 0,
+    startX: 0,
+    startY: 0,
+    lastCubicCtrl: null,
+    lastQuadCtrl: null
+  };
+  for (const { cmd, args } of tokens) {
+    const upper = cmd.toUpperCase();
+    const relative = cmd !== upper;
+    const argCount = ARG_COUNTS[upper];
+    if (argCount === void 0) {
+      onWarn?.(`unknown path command: ${cmd}`);
+      continue;
+    }
+    if (upper === "Z") {
+      b.close();
+      st.x = st.startX;
+      st.y = st.startY;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      continue;
+    }
+    const groups = argCount === 0 ? 1 : Math.floor(args.length / argCount);
+    for (let g = 0; g < groups; g++) {
+      const a = args.slice(g * argCount, (g + 1) * argCount);
+      const effectiveUpper = upper === "M" && g > 0 ? "L" : upper;
+      runCommand(effectiveUpper, relative, a, st, b);
+    }
+  }
+  return b.build();
+}
+function runCommand(upper, relative, a, st, b) {
+  const rx = relative ? st.x : 0;
+  const ry = relative ? st.y : 0;
+  switch (upper) {
+    case "M": {
+      const x = a[0] + rx;
+      const y = a[1] + ry;
+      b.moveTo(x, y);
+      st.x = x;
+      st.y = y;
+      st.startX = x;
+      st.startY = y;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "L": {
+      const x = a[0] + rx;
+      const y = a[1] + ry;
+      b.lineTo(x, y);
+      st.x = x;
+      st.y = y;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "H": {
+      const x = a[0] + (relative ? st.x : 0);
+      b.lineTo(x, st.y);
+      st.x = x;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "V": {
+      const y = a[0] + (relative ? st.y : 0);
+      b.lineTo(st.x, y);
+      st.y = y;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "C": {
+      const x1 = a[0] + rx, y1 = a[1] + ry;
+      const x2 = a[2] + rx, y2 = a[3] + ry;
+      const x = a[4] + rx, y = a[5] + ry;
+      b.curveTo(x1, y1, x2, y2, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastCubicCtrl = { x: x2, y: y2 };
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "S": {
+      const ref = st.lastCubicCtrl ?? { x: st.x, y: st.y };
+      const x1 = 2 * st.x - ref.x;
+      const y1 = 2 * st.y - ref.y;
+      const x2 = a[0] + rx, y2 = a[1] + ry;
+      const x = a[2] + rx, y = a[3] + ry;
+      b.curveTo(x1, y1, x2, y2, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastCubicCtrl = { x: x2, y: y2 };
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "Q": {
+      const x1 = a[0] + rx, y1 = a[1] + ry;
+      const x = a[2] + rx, y = a[3] + ry;
+      b.quadTo(x1, y1, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastQuadCtrl = { x: x1, y: y1 };
+      st.lastCubicCtrl = null;
+      return;
+    }
+    case "T": {
+      const ref = st.lastQuadCtrl ?? { x: st.x, y: st.y };
+      const x1 = 2 * st.x - ref.x;
+      const y1 = 2 * st.y - ref.y;
+      const x = a[0] + rx, y = a[1] + ry;
+      b.quadTo(x1, y1, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastQuadCtrl = { x: x1, y: y1 };
+      st.lastCubicCtrl = null;
+      return;
+    }
+    case "A": {
+      const rxA = Math.abs(a[0]);
+      const ryA = Math.abs(a[1]);
+      const xRot = a[2];
+      const largeArc = a[3] !== 0;
+      const sweep = a[4] !== 0;
+      const ex = a[5] + rx;
+      const ey = a[6] + ry;
+      arcToCubics(st.x, st.y, ex, ey, rxA, ryA, xRot, largeArc, sweep, b);
+      st.x = ex;
+      st.y = ey;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    default:
+      return;
+  }
+}
+function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep, b) {
+  if (x1 === x2 && y1 === y2) return;
+  if (rx === 0 || ry === 0) {
+    b.lineTo(x2, y2);
+    return;
+  }
+  const phi = xAxisRotationDeg * Math.PI / 180;
+  const cosPhi = Math.cos(phi);
+  const sinPhi = Math.sin(phi);
+  const dx = (x1 - x2) / 2;
+  const dy = (y1 - y2) / 2;
+  const x1p = cosPhi * dx + sinPhi * dy;
+  const y1p = -sinPhi * dx + cosPhi * dy;
+  let rxs = rx * rx;
+  let rys = ry * ry;
+  const x1ps = x1p * x1p;
+  const y1ps = y1p * y1p;
+  const lambda = x1ps / rxs + y1ps / rys;
+  let rxFixed = rx;
+  let ryFixed = ry;
+  if (lambda > 1) {
+    const sqrtLambda = Math.sqrt(lambda);
+    rxFixed = sqrtLambda * rx;
+    ryFixed = sqrtLambda * ry;
+    rxs = rxFixed * rxFixed;
+    rys = ryFixed * ryFixed;
+  }
+  const sign2 = largeArc === sweep ? -1 : 1;
+  const num = rxs * rys - rxs * y1ps - rys * x1ps;
+  const den = rxs * y1ps + rys * x1ps;
+  const factor = sign2 * Math.sqrt(Math.max(0, num / den));
+  const cxp = factor * (rxFixed * y1p) / ryFixed;
+  const cyp = factor * -(ryFixed * x1p) / rxFixed;
+  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 dot2 = ux * vx + uy * vy;
+    const len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
+    let a = Math.acos(Math.max(-1, Math.min(1, dot2 / len)));
+    if (ux * vy - uy * vx < 0) a = -a;
+    return a;
+  };
+  const theta1 = angle(1, 0, (x1p - cxp) / rxFixed, (y1p - cyp) / ryFixed);
+  let dTheta = angle(
+    (x1p - cxp) / rxFixed,
+    (y1p - cyp) / ryFixed,
+    (-x1p - cxp) / rxFixed,
+    (-y1p - cyp) / ryFixed
+  );
+  if (!sweep && dTheta > 0) dTheta -= 2 * Math.PI;
+  else if (sweep && dTheta < 0) dTheta += 2 * Math.PI;
+  const segCount = Math.max(1, Math.ceil(Math.abs(dTheta) / (Math.PI / 2)));
+  const segAngle = dTheta / segCount;
+  const t = 4 / 3 * Math.tan(segAngle / 4);
+  let prevX = x1;
+  let prevY = y1;
+  let prevDx = -Math.sin(theta1) * rxFixed;
+  let prevDy = Math.cos(theta1) * ryFixed;
+  for (let i = 1; i <= segCount; i++) {
+    const theta = theta1 + i * segAngle;
+    const cosT = Math.cos(theta);
+    const sinT = Math.sin(theta);
+    const px = cosPhi * (cosT * rxFixed) - sinPhi * (sinT * ryFixed) + cx;
+    const py = sinPhi * (cosT * rxFixed) + cosPhi * (sinT * ryFixed) + cy;
+    const dxNew = -sinT * rxFixed;
+    const dyNew = cosT * ryFixed;
+    const c1x = prevX + cosPhi * (t * prevDx) - sinPhi * (t * prevDy);
+    const c1y = prevY + sinPhi * (t * prevDx) + cosPhi * (t * prevDy);
+    const c2x = px - cosPhi * (t * dxNew) + sinPhi * (t * dyNew);
+    const c2y = py - sinPhi * (t * dxNew) - cosPhi * (t * dyNew);
+    b.curveTo(c1x, c1y, c2x, c2y, px, py);
+    prevX = px;
+    prevY = py;
+    prevDx = dxNew;
+    prevDy = dyNew;
+  }
+}
+
+// src/paths/pathAt.ts
+function pointAlongPath(path, t, opts = {}) {
+  const polylines = extractPolylines(
+    path,
+    opts.flattenTolerance === void 0 ? {} : { flattenTolerance: opts.flattenTolerance }
+  );
+  const segments = [];
+  let total = 0;
+  let first;
+  for (const pl of polylines) {
+    const count = pl.points.length / 2;
+    if (count === 0) continue;
+    first ??= { x: pl.points[0], y: pl.points[1] };
+    const last2 = pl.closed ? count : count - 1;
+    for (let i = 0; i < last2; i++) {
+      const j = (i + 1) % count;
+      const ax = pl.points[i * 2];
+      const ay = pl.points[i * 2 + 1];
+      const bx = pl.points[j * 2];
+      const by = pl.points[j * 2 + 1];
+      const len = Math.hypot(bx - ax, by - ay);
+      if (len === 0) continue;
+      segments.push({ ax, ay, bx, by, len });
+      total += len;
+    }
+  }
+  if (first === void 0) return null;
+  if (segments.length === 0) return { point: first, tangent: { x: 1, y: 0 } };
+  const target = Math.min(Math.max(t, 0), 1) * total;
+  let walked = 0;
+  for (const seg of segments) {
+    if (walked + seg.len < target) {
+      walked += seg.len;
+      continue;
+    }
+    const u = (target - walked) / seg.len;
+    return {
+      point: { x: seg.ax + (seg.bx - seg.ax) * u, y: seg.ay + (seg.by - seg.ay) * u },
+      tangent: { x: (seg.bx - seg.ax) / seg.len, y: (seg.by - seg.ay) / seg.len }
+    };
+  }
+  const last = segments[segments.length - 1];
+  return {
+    point: { x: last.bx, y: last.by },
+    tangent: { x: (last.bx - last.ax) / last.len, y: (last.by - last.ay) / last.len }
+  };
+}
+
+// src/paths/pathDistance.ts
+function pointToRectPerimeterDist(px, py, rx, ry, rw, rh) {
+  const dx = Math.max(rx - px, px - (rx + rw), 0);
+  const dy = Math.max(ry - py, py - (ry + rh), 0);
+  if (dx > 0 || dy > 0) return Math.hypot(dx, dy);
+  const left = px - rx, right = rx + rw - px;
+  const top = py - ry, bottom = ry + rh - py;
+  return Math.min(left, right, top, bottom);
+}
+function pathDistanceToPoint(path, px, py) {
+  if (path.kind === "rect") {
+    return pointToRectPerimeterDist(px, py, path.x, path.y, path.width, path.height);
+  }
+  return nearestOnPath(path.commands, path.coords, px, py)?.dist ?? Infinity;
+}
+
+// src/paths/schneiderFit.ts
+function schneiderFit(samples, errorTolerance) {
+  if (samples.length === 0) {
+    return {
+      kind: "polygon",
+      commands: new Uint8Array(),
+      coords: new Float32Array(),
+      fillRule: "nonzero"
+    };
+  }
+  const b = new PathBuilder();
+  b.moveTo(samples[0].x, samples[0].y);
+  if (samples.length === 1) {
+    return b.build();
+  }
+  if (samples.length === 2) {
+    emitStraightCubic(b, samples[0], samples[1]);
+    return b.build();
+  }
+  fitRecursive(samples, errorTolerance, b);
+  return b.build();
+}
+function fitRecursive(samples, errorTolerance, b) {
+  if (samples.length === 2) {
+    const fit2 = fitOneCubic(samples);
+    b.curveTo(fit2.cp1.x, fit2.cp1.y, fit2.cp2.x, fit2.cp2.y, fit2.end.x, fit2.end.y);
+    return;
+  }
+  const fit = fitOneCubic(samples);
+  const { worstIndex, worstError } = measureError(samples, fit);
+  if (worstError <= errorTolerance * errorTolerance) {
+    b.curveTo(fit.cp1.x, fit.cp1.y, fit.cp2.x, fit.cp2.y, fit.end.x, fit.end.y);
+    return;
+  }
+  const left = samples.slice(0, worstIndex + 1);
+  const right = samples.slice(worstIndex);
+  fitRecursive(left, errorTolerance, b);
+  fitRecursive(right, errorTolerance, b);
+}
+function measureError(samples, fit) {
+  let worstIndex = 1;
+  let worstError = 0;
+  const a = samples[0];
+  for (let i = 1; i < samples.length - 1; i++) {
+    const t = i / (samples.length - 1);
+    const q = cubicPointAt(a, fit.cp1, fit.cp2, fit.end, t);
+    const dx = samples[i].x - q.x;
+    const dy = samples[i].y - q.y;
+    const sq = dx * dx + dy * dy;
+    if (sq > worstError) {
+      worstError = sq;
+      worstIndex = i;
+    }
+  }
+  return { worstIndex, worstError };
+}
+function fitOneCubic(samples) {
+  const n = samples.length;
+  const a = samples[0];
+  const e = samples[n - 1];
+  const tStart = unit(sub2(samples[1], a));
+  const tEnd = unit(sub2(samples[n - 2], e));
+  const ts = chordLengthParam(samples);
+  if (ts === null) return { cp1: { ...a }, cp2: { ...e }, end: e };
+  let fit = solveLS(samples, ts, a, e, tStart, tEnd);
+  for (let pass = 0; pass < 4; pass++) {
+    reparameterize(samples, ts, a, e, fit);
+    fit = solveLS(samples, ts, a, e, tStart, tEnd);
+  }
+  return fit;
+}
+function chordLengthParam(samples) {
+  const n = samples.length;
+  const ts = new Array(n);
+  ts[0] = 0;
+  let total = 0;
+  for (let i = 1; i < n; i++) {
+    total += dist(samples[i - 1], samples[i]);
+    ts[i] = total;
+  }
+  if (total === 0) return null;
+  for (let i = 0; i < n; i++) ts[i] /= total;
+  return ts;
+}
+function solveLS(samples, ts, a, e, tStart, tEnd) {
+  const n = samples.length;
+  let c11 = 0, c12 = 0, c22 = 0, x1 = 0, x2 = 0;
+  for (let i = 0; i < n; i++) {
+    const t = ts[i];
+    const u = 1 - t;
+    const b0 = u * u * u;
+    const b1 = 3 * u * u * t;
+    const b2 = 3 * u * t * t;
+    const b3 = t * t * t;
+    const A1x = b1 * tStart.x;
+    const A1y = b1 * tStart.y;
+    const A2x = b2 * tEnd.x;
+    const A2y = b2 * tEnd.y;
+    c11 += A1x * A1x + A1y * A1y;
+    c12 += A1x * A2x + A1y * A2y;
+    c22 += A2x * A2x + A2y * A2y;
+    const targetX = samples[i].x - (b0 + b1) * a.x - (b2 + b3) * e.x;
+    const targetY = samples[i].y - (b0 + b1) * a.y - (b2 + b3) * e.y;
+    x1 += A1x * targetX + A1y * targetY;
+    x2 += A2x * targetX + A2y * targetY;
+  }
+  const det = c11 * c22 - c12 * c12;
+  let alpha1;
+  let alpha2;
+  if (Math.abs(det) < 1e-12) {
+    const chord = dist(a, e);
+    alpha1 = alpha2 = chord / 3;
+  } else {
+    alpha1 = (c22 * x1 - c12 * x2) / det;
+    alpha2 = (c11 * x2 - c12 * x1) / det;
+    if (alpha1 < 1e-6 || alpha2 < 1e-6) {
+      const chord = dist(a, e);
+      alpha1 = alpha2 = chord / 3;
+    }
+  }
+  return {
+    cp1: { x: a.x + tStart.x * alpha1, y: a.y + tStart.y * alpha1 },
+    cp2: { x: e.x + tEnd.x * alpha2, y: e.y + tEnd.y * alpha2 },
+    end: e
+  };
+}
+function reparameterize(samples, ts, a, e, fit) {
+  for (let i = 1; i < samples.length - 1; i++) {
+    ts[i] = newtonRefineT(samples[i], ts[i], samples[0], fit.cp1, fit.cp2, samples[samples.length - 1]);
+  }
+}
+function newtonRefineT(p, t, p0, p1, p2, p3) {
+  const u = 1 - t;
+  const { x: qx, y: qy } = cubicPointAt(p0, p1, p2, p3, t);
+  const qpx = 3 * u * u * (p1.x - p0.x) + 6 * u * t * (p2.x - p1.x) + 3 * t * t * (p3.x - p2.x);
+  const qpy = 3 * u * u * (p1.y - p0.y) + 6 * u * t * (p2.y - p1.y) + 3 * t * t * (p3.y - p2.y);
+  const qppx = 6 * u * (p2.x - 2 * p1.x + p0.x) + 6 * t * (p3.x - 2 * p2.x + p1.x);
+  const qppy = 6 * u * (p2.y - 2 * p1.y + p0.y) + 6 * t * (p3.y - 2 * p2.y + p1.y);
+  const dx = qx - p.x;
+  const dy = qy - p.y;
+  const numerator = dx * qpx + dy * qpy;
+  const denominator = qpx * qpx + qpy * qpy + dx * qppx + dy * qppy;
+  if (Math.abs(denominator) < 1e-12) return t;
+  const next = t - numerator / denominator;
+  if (next < 0) return 0;
+  if (next > 1) return 1;
+  return next;
+}
+function sub2(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y };
+}
+function dist(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function unit(v) {
+  const m = Math.hypot(v.x, v.y);
+  if (m === 0) return { x: 0, y: 0 };
+  return { x: v.x / m, y: v.y / m };
+}
+function emitStraightCubic(b, a, c) {
+  const cp1x = a.x + (c.x - a.x) / 3;
+  const cp1y = a.y + (c.y - a.y) / 3;
+  const cp2x = a.x + 2 * (c.x - a.x) / 3;
+  const cp2y = a.y + 2 * (c.y - a.y) / 3;
+  b.curveTo(cp1x, cp1y, cp2x, cp2y, c.x, c.y);
+}
+
+// src/screenBand.ts
+function stretchOf(m) {
+  const e = (m.a + m.d) / 2;
+  const f = (m.a - m.d) / 2;
+  const g = (m.b + m.c) / 2;
+  const h = (m.b - m.c) / 2;
+  const q = Math.hypot(e, h);
+  const r = Math.hypot(f, g);
+  const phi = (Math.atan2(h, e) + Math.atan2(g, f)) / 2;
+  return { s1: q + r, s2: Math.abs(q - r), phi };
+}
+function isSimilarity(s) {
+  return s.s1 - s.s2 <= 1e-9 * s.s1;
+}
+function capsuleWithinPx(px0, py0, ax, ay, bx, by, r, slop, m, st) {
+  const sax = m.a * ax + m.c * ay, say = m.b * ax + m.d * ay;
+  const sbx = m.a * bx + m.c * by, sby = m.b * bx + m.d * by;
+  const slop2 = slop * slop;
+  const dCenter2 = pointSegmentDist2(px0, py0, sax, say, sbx, sby);
+  if (dCenter2 <= slop2) return true;
+  if (r <= 0) return false;
+  const reach = slop + r * st.s1;
+  if (dCenter2 > reach * reach) return false;
+  const wx = bx - ax, wy = by - ay;
+  const wl = Math.hypot(wx, wy);
+  if (wl > 0) {
+    const nx = -wy / wl * r, ny = wx / wl * r;
+    const ox = m.a * nx + m.c * ny, oy = m.b * nx + m.d * ny;
+    if (quadWithinPx(px0, py0, [
+      sax + ox,
+      say + oy,
+      sbx + ox,
+      sby + oy,
+      sbx - ox,
+      sby - oy,
+      sax - ox,
+      say - oy
+    ], slop2)) return true;
+  }
+  return ellipseWithinPx(px0 - sax, py0 - say, r, slop, st) || ellipseWithinPx(px0 - sbx, py0 - sby, r, slop, st);
+}
+function quadWithinPx(x, y, q, slop2) {
+  let pos = 0, neg = 0;
+  for (let i = 0; i < 8; i += 2) {
+    const j = (i + 2) % 8;
+    const cr = (q[j] - q[i]) * (y - q[i + 1]) - (q[j + 1] - q[i + 1]) * (x - q[i]);
+    if (cr > 0) pos++;
+    else if (cr < 0) neg++;
+  }
+  if (pos === 0 || neg === 0) return true;
+  for (let i = 0; i < 8; i += 2) {
+    const j = (i + 2) % 8;
+    if (pointSegmentDist2(x, y, q[i], q[i + 1], q[j], q[j + 1]) <= slop2) return true;
+  }
+  return false;
+}
+function ellipseWithinPx(dx, dy, r, slop, st) {
+  const cos = Math.cos(st.phi), sin = Math.sin(st.phi);
+  const u = Math.abs(cos * dx + sin * dy);
+  const v = Math.abs(-sin * dx + cos * dy);
+  const e0 = r * st.s1, e1 = r * st.s2;
+  if (e1 <= 0) {
+    const over = Math.max(0, u - e0);
+    return over * over + v * v <= slop * slop;
+  }
+  return distToEllipse(e0, e1, u, v) <= slop;
+}
+function distToEllipse(e0, e1, y0, y1) {
+  const z0 = y0 / e0, z1 = y1 / e1;
+  const g = z0 * z0 + z1 * z1 - 1;
+  if (g <= 0) return 0;
+  if (y1 > 0) {
+    if (y0 > 0) {
+      const r0 = e0 / e1 * (e0 / e1);
+      const n0 = r0 * z0;
+      let s0 = z1 - 1;
+      let s1 = Math.hypot(n0, z1) - 1;
+      let s = 0;
+      for (let i = 0; i < 100; i++) {
+        s = (s0 + s1) / 2;
+        if (s === s0 || s === s1) break;
+        const a = n0 / (s + r0), b = z1 / (s + 1);
+        const gs = a * a + b * b - 1;
+        if (gs > 0) s0 = s;
+        else if (gs < 0) s1 = s;
+        else break;
+      }
+      const x0 = r0 * y0 / (s + r0);
+      const x1 = y1 / (s + 1);
+      return Math.hypot(x0 - y0, x1 - y1);
+    }
+    return y1 - e1;
+  }
+  const numer = e0 * y0, denom = e0 * e0 - e1 * e1;
+  if (numer < denom) {
+    const t = numer / denom;
+    const x0 = e0 * t, x1 = e1 * Math.sqrt(1 - t * t);
+    return Math.hypot(x0 - y0, x1);
+  }
+  return y0 - e0;
+}
+
+// src/pathHitTest.ts
+function flatSubpaths(path, tolerance) {
+  const { commands, coords } = path;
+  const closed = [];
+  const open = [];
+  let sub3 = [];
+  forEachSegment(commands, coords, (cmd, ci, curX, curY) => {
+    switch (cmd) {
+      case PATH_M:
+        if (sub3.length >= 2) open.push(sub3);
+        sub3 = [coords[ci], coords[ci + 1]];
+        break;
+      case PATH_L:
+        sub3.push(coords[ci], coords[ci + 1]);
+        break;
+      case PATH_C:
+        flattenCubic(
+          curX,
+          curY,
+          coords[ci],
+          coords[ci + 1],
+          coords[ci + 2],
+          coords[ci + 3],
+          coords[ci + 4],
+          coords[ci + 5],
+          tolerance,
+          sub3
+        );
+        break;
+      case PATH_Q:
+        flattenQuadratic(
+          curX,
+          curY,
+          coords[ci],
+          coords[ci + 1],
+          coords[ci + 2],
+          coords[ci + 3],
+          tolerance,
+          sub3
+        );
+        break;
+      case PATH_Z:
+        if (sub3.length >= 6) closed.push(sub3);
+        else if (sub3.length >= 2) open.push(sub3);
+        sub3 = [];
+        break;
+      default:
+        throw new Error(`pathHitTest: unknown command ${cmd}`);
+    }
+  });
+  if (sub3.length >= 2) open.push(sub3);
+  return { closed, open };
+}
+function closedSubpaths(path, opts) {
+  return flatSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE).closed;
+}
+function pointInPath(path, x, y, opts = {}) {
+  if (path.kind === "rect") {
+    return x >= path.x && x <= path.x + path.width && y >= path.y && y <= path.y + path.height;
+  }
+  let crossings = 0;
+  let winding = 0;
+  for (const sub3 of closedSubpaths(path, opts)) {
+    const n = sub3.length;
+    for (let i = 0; i < n; i += 2) {
+      const j = (i + 2) % n;
+      const ay = sub3[i + 1], by = sub3[j + 1];
+      if (ay > y === by > y) continue;
+      const ax = sub3[i], bx = sub3[j];
+      if (x >= ax + (y - ay) / (by - ay) * (bx - ax)) continue;
+      crossings++;
+      winding += ay <= y ? 1 : -1;
+    }
+  }
+  return path.fillRule === "evenodd" ? (crossings & 1) === 1 : winding !== 0;
+}
+function strokeHitTest(path, x, y, threshold, opts = {}) {
+  const slop = opts.slop;
+  if (slop && slop.px > 0) {
+    const [a, b, c, d] = slop.transform;
+    const m = { a, b, c, d };
+    const st = stretchOf(m);
+    if (isSimilarity(st)) {
+      return strokeHitTest(path, x, y, threshold + slop.px / st.s1, { tolerance: opts.tolerance });
+    }
+    const sx = a * x + c * y, sy = b * x + d * y;
+    return someSegment(path, opts.tolerance, (ax, ay, bx, by) => capsuleWithinPx(sx, sy, ax, ay, bx, by, threshold, slop.px, m, st));
+  }
+  const t2 = threshold * threshold;
+  return someSegment(path, opts.tolerance, (ax, ay, bx, by) => pointSegmentDist2(x, y, ax, ay, bx, by) <= t2);
+}
+function someSegment(path, tolerance, visit) {
+  if (path.kind === "rect") {
+    const { x: rx, y: ry, width: w, height: h } = path;
+    return visit(rx, ry, rx + w, ry) || visit(rx + w, ry, rx + w, ry + h) || visit(rx + w, ry + h, rx, ry + h) || visit(rx, ry + h, rx, ry);
+  }
+  const { closed, open } = flatSubpaths(path, tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+  const run = (sub3, wrap) => {
+    const n = sub3.length;
+    const last = wrap ? n : n - 2;
+    for (let i = 0; i < last; i += 2) {
+      const j = (i + 2) % n;
+      if (visit(sub3[i], sub3[i + 1], sub3[j], sub3[j + 1])) return true;
+    }
+    return false;
+  };
+  return closed.some((sub3) => run(sub3, true)) || open.some((sub3) => run(sub3, false));
+}
+function rectToVerts(r) {
+  return [
+    { x: r.x, y: r.y },
+    { x: r.x + r.width, y: r.y },
+    { x: r.x + r.width, y: r.y + r.height },
+    { x: r.x, y: r.y + r.height }
+  ];
+}
+function flattenVerts(poly) {
+  const flat = new Array(poly.length * 2);
+  for (let i = 0; i < poly.length; i++) {
+    flat[i * 2] = poly[i].x;
+    flat[i * 2 + 1] = poly[i].y;
+  }
+  return flat;
+}
+function polygonsIntersect(a, b) {
+  if (a.length === 0 || b.length === 0) return false;
+  if (pointInPolygon(flattenVerts(a), b[0].x, b[0].y)) return true;
+  if (pointInPolygon(flattenVerts(b), a[0].x, a[0].y)) return true;
+  for (let i = 0; i < a.length; i++) {
+    const a0 = a[i], a1 = a[(i + 1) % a.length];
+    for (let j = 0; j < b.length; j++) {
+      const b0 = b[j], b1 = b[(j + 1) % b.length];
+      if (segmentsCross(a0.x, a0.y, a1.x, a1.y, b0.x, b0.y, b1.x, b1.y)) return true;
+    }
+  }
+  return false;
+}
+function anyEdge(subpaths, visit) {
+  for (const sub3 of subpaths) {
+    const n = sub3.length;
+    for (let i = 0; i < n; i += 2) {
+      const j = (i + 2) % n;
+      if (visit(sub3[i], sub3[i + 1], sub3[j], sub3[j + 1])) return true;
+    }
+  }
+  return false;
+}
+function anyEdgeCrossesRect(subpaths, r) {
+  const x0 = r.x, y0 = r.y, x1 = r.x + r.width, y1 = r.y + r.height;
+  return anyEdge(
+    subpaths,
+    (ax, ay, bx, by) => segmentsCross(ax, ay, bx, by, x0, y0, x1, y0) || segmentsCross(ax, ay, bx, by, x1, y0, x1, y1) || segmentsCross(ax, ay, bx, by, x1, y1, x0, y1) || segmentsCross(ax, ay, bx, by, x0, y1, x0, y0)
+  );
+}
+function anyEdgeCrossesPolygon(subpaths, poly) {
+  if (poly.length === 0) return false;
+  return anyEdge(subpaths, (ax, ay, bx, by) => {
+    for (let i = 0; i < poly.length; i++) {
+      const p0 = poly[i], p1 = poly[(i + 1) % poly.length];
+      if (segmentsCross(ax, ay, bx, by, p0.x, p0.y, p1.x, p1.y)) return true;
+    }
+    return false;
+  });
+}
+function anyOpenEdgeCrossesPolygon(runs, poly) {
+  for (const run of runs) {
+    for (let i = 0; i + 3 < run.length; i += 2) {
+      const ax = run[i], ay = run[i + 1], bx = run[i + 2], by = run[i + 3];
+      for (let k = 0; k < poly.length; k++) {
+        const p0 = poly[k], p1 = poly[(k + 1) % poly.length];
+        if (segmentsCross(ax, ay, bx, by, p0.x, p0.y, p1.x, p1.y)) return true;
+      }
+    }
+  }
+  return false;
+}
+function anyVertexInRect(subpaths, r) {
+  for (const sub3 of subpaths) {
+    for (let i = 0; i < sub3.length; i += 2) {
+      const x = sub3[i], y = sub3[i + 1];
+      if (x >= r.x && x <= r.x + r.width && y >= r.y && y <= r.y + r.height) return true;
+    }
+  }
+  return false;
+}
+function anyVertexInPolygon(subpaths, flatPoly) {
+  for (const sub3 of subpaths) {
+    for (let i = 0; i < sub3.length; i += 2) {
+      if (pointInPolygon(flatPoly, sub3[i], sub3[i + 1])) return true;
+    }
+  }
+  return false;
+}
+function pathContainsPoint(path, x, y, opts = {}) {
+  return pointInPath(path, x, y, opts);
+}
+function pathContainsRect(path, rect, opts = {}) {
+  if (path.kind === "rect") {
+    return rect.x >= path.x && rect.y >= path.y && rect.x + rect.width <= path.x + path.width && rect.y + rect.height <= path.y + path.height;
+  }
+  const subpaths = closedSubpaths(path, opts);
+  if (subpaths.length === 0) return false;
+  for (const c of rectToVerts(rect)) {
+    if (!pointInPath(path, c.x, c.y, opts)) return false;
+  }
+  return !anyVertexInRect(subpaths, rect) && !anyEdgeCrossesRect(subpaths, rect);
+}
+function pathIntersectsRect(path, rect, opts = {}) {
+  if (path.kind === "rect") {
+    return rect.x < path.x + path.width && rect.x + rect.width > path.x && rect.y < path.y + path.height && rect.y + rect.height > path.y;
+  }
+  const subpaths = closedSubpaths(path, opts);
+  if (subpaths.length === 0) return false;
+  for (const c of rectToVerts(rect)) {
+    if (pointInPath(path, c.x, c.y, opts)) return true;
+  }
+  if (anyVertexInRect(subpaths, rect)) return true;
+  return anyEdgeCrossesRect(subpaths, rect);
+}
+function pathContainsPolygon(path, polygon, opts = {}) {
+  if (polygon.length === 0) return false;
+  if (path.kind === "rect") {
+    return polygon.every(
+      (p) => p.x >= path.x && p.x <= path.x + path.width && p.y >= path.y && p.y <= path.y + path.height
+    );
+  }
+  const subpaths = closedSubpaths(path, opts);
+  if (subpaths.length === 0) return false;
+  for (const p of polygon) {
+    if (!pointInPath(path, p.x, p.y, opts)) return false;
+  }
+  return !anyVertexInPolygon(subpaths, flattenVerts(polygon)) && !anyEdgeCrossesPolygon(subpaths, polygon);
+}
+function pathIntersectsPolygon(path, polygon, opts = {}) {
+  if (polygon.length === 0) return false;
+  if (path.kind === "rect") {
+    return polygonsIntersect(rectToVerts(path), polygon);
+  }
+  const subpaths = closedSubpaths(path, opts);
+  if (subpaths.length === 0) return false;
+  for (const p of polygon) {
+    if (pointInPath(path, p.x, p.y, opts)) return true;
+  }
+  if (anyVertexInPolygon(subpaths, flattenVerts(polygon))) return true;
+  return anyEdgeCrossesPolygon(subpaths, polygon);
+}
+function polygonContainsPath(polygon, path, opts = {}) {
+  if (polygon.length < 3) return false;
+  let subpaths;
+  if (path.kind === "rect") {
+    subpaths = [flattenVerts(rectToVerts(path))];
+  } else {
+    const { closed, open } = flatSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+    subpaths = [...closed, ...open];
+  }
+  if (subpaths.length === 0) return false;
+  const flatPoly = flattenVerts(polygon);
+  for (const sub3 of subpaths) {
+    for (let i = 0; i < sub3.length; i += 2) {
+      if (!pointInPolygon(flatPoly, sub3[i], sub3[i + 1])) return false;
+    }
+  }
+  return !anyEdgeCrossesPolygon(subpaths, polygon);
+}
+function polygonIntersectsPath(polygon, path, opts = {}) {
+  if (polygon.length < 3) return false;
+  if (path.kind === "rect") return polygonsIntersect(rectToVerts(path), polygon);
+  const { closed, open } = flatSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+  const flatPoly = flattenVerts(polygon);
+  if (anyVertexInPolygon(closed, flatPoly) || anyVertexInPolygon(open, flatPoly)) return true;
+  if (anyEdgeCrossesPolygon(closed, polygon) || anyOpenEdgeCrossesPolygon(open, polygon)) {
+    return true;
+  }
+  return closed.length > 0 && pointInPath(path, polygon[0].x, polygon[0].y, opts);
+}
+
 // src/place.ts
 function alignAlong(start, extent, size, align) {
   if (align === "start") return start;
@@ -304,6 +1614,186 @@ function placeRect(options) {
   return { rect: shiftAcross(rect, boundary, resolved.side, padding), placement: resolved };
 }
 
-export { applyToPoint, boundsOfCoords, boxContainsPoint, boxToBox, clampRectWithin, identity, invert, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, placeRect, pointInPolygon, pointSegmentDist2, portControls2 as portControls, portCurvePoints, rectToContour, rotate, rotateAboutPoint, scale, segmentsCross, transformCoords, translate, unionBox };
+// src/easings.ts
+var linear = (t) => t;
+var easeInQuad = (t) => t * t;
+var easeOutQuad = (t) => 1 - (1 - t) * (1 - t);
+var easeInOutQuad = (t) => t < 0.5 ? 2 * t * t : 1 - 2 * (1 - t) * (1 - t);
+var easeInCubic = (t) => t * t * t;
+var easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+var easeInOutCubic = (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+var easeInQuart = (t) => t * t * t * t;
+var easeOutQuart = (t) => 1 - Math.pow(1 - t, 4);
+var easeInOutQuart = (t) => t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
+var easeInQuint = (t) => t * t * t * t * t;
+var easeOutQuint = (t) => 1 - Math.pow(1 - t, 5);
+var easeInOutQuint = (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 - Math.pow(-2 * t + 2, 5) / 2;
+var easeInSine = (t) => 1 - Math.cos(t * Math.PI / 2);
+var easeOutSine = (t) => Math.sin(t * Math.PI / 2);
+var easeInOutSine = (t) => -(Math.cos(Math.PI * t) - 1) / 2;
+var easeInExpo = (t) => t === 0 ? 0 : Math.pow(2, 10 * t - 10);
+var easeOutExpo = (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t);
+var easeInOutExpo = (t) => {
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return t < 0.5 ? Math.pow(2, 20 * t - 10) / 2 : (2 - Math.pow(2, -20 * t + 10)) / 2;
+};
+var easeInCirc = (t) => 1 - Math.sqrt(1 - t * t);
+var easeOutCirc = (t) => Math.sqrt(1 - Math.pow(t - 1, 2));
+var easeInOutCirc = (t) => t < 0.5 ? (1 - Math.sqrt(1 - Math.pow(2 * t, 2))) / 2 : (Math.sqrt(1 - Math.pow(-2 * t + 2, 2)) + 1) / 2;
+var C1 = 1.70158;
+var C2 = C1 * 1.525;
+var C3 = C1 + 1;
+var C4 = 2 * Math.PI / 3;
+var C5 = 2 * Math.PI / 4.5;
+var easeInBack = (t) => C3 * t * t * t - C1 * t * t;
+var easeOutBack = (t) => 1 + C3 * Math.pow(t - 1, 3) + C1 * Math.pow(t - 1, 2);
+var easeInOutBack = (t) => t < 0.5 ? Math.pow(2 * t, 2) * ((C2 + 1) * 2 * t - C2) / 2 : (Math.pow(2 * t - 2, 2) * ((C2 + 1) * (2 * t - 2) + C2) + 2) / 2;
+var easeInElastic = (t) => {
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * C4);
+};
+var easeOutElastic = (t) => {
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * C4) + 1;
+};
+var easeInOutElastic = (t) => {
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return t < 0.5 ? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * C5)) / 2 : Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * C5) / 2 + 1;
+};
+var easeOutBounce = (t) => {
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (t < 1 / d1) return n1 * t * t;
+  if (t < 2 / d1) {
+    t -= 1.5 / d1;
+    return n1 * t * t + 0.75;
+  }
+  if (t < 2.5 / d1) {
+    t -= 2.25 / d1;
+    return n1 * t * t + 0.9375;
+  }
+  t -= 2.625 / d1;
+  return n1 * t * t + 0.984375;
+};
+var easeInBounce = (t) => 1 - easeOutBounce(1 - t);
+var easeInOutBounce = (t) => t < 0.5 ? (1 - easeOutBounce(1 - 2 * t)) / 2 : (1 + easeOutBounce(2 * t - 1)) / 2;
+var easeIn = easeInQuad;
+var easeOut = easeOutQuad;
+var easeInOut = easeInOutQuad;
+var EASINGS = {
+  linear,
+  easeInQuad,
+  easeOutQuad,
+  easeInOutQuad,
+  easeInCubic,
+  easeOutCubic,
+  easeInOutCubic,
+  easeInQuart,
+  easeOutQuart,
+  easeInOutQuart,
+  easeInQuint,
+  easeOutQuint,
+  easeInOutQuint,
+  easeInSine,
+  easeOutSine,
+  easeInOutSine,
+  easeInExpo,
+  easeOutExpo,
+  easeInOutExpo,
+  easeInCirc,
+  easeOutCirc,
+  easeInOutCirc,
+  easeInBack,
+  easeOutBack,
+  easeInOutBack,
+  easeInElastic,
+  easeOutElastic,
+  easeInOutElastic,
+  easeInBounce,
+  easeOutBounce,
+  easeInOutBounce
+};
+var SPRING_PRESETS = {
+  gentle: { stiffness: 120, damping: 14, mass: 1 },
+  wobbly: { stiffness: 180, damping: 12, mass: 1 },
+  stiff: { stiffness: 210, damping: 20, mass: 1 },
+  slow: { stiffness: 80, damping: 20, mass: 1 }
+};
+
+// src/easingSpec.ts
+var NEWTON_ITERATIONS = 8;
+var NEWTON_MIN_SLOPE = 1e-3;
+var SUBDIVISION_EPSILON = 1e-7;
+var SUBDIVISION_MAX = 12;
+function bezierAt(t, a1, a2) {
+  const c = 3 * a1;
+  const b = 3 * (a2 - a1) - c;
+  const a = 1 - c - b;
+  return ((a * t + b) * t + c) * t;
+}
+function bezierSlope(t, a1, a2) {
+  const c = 3 * a1;
+  const b = 3 * (a2 - a1) - c;
+  const a = 1 - c - b;
+  return (3 * a * t + 2 * b) * t + c;
+}
+function solveForX(x, x1, x2) {
+  let t = x;
+  for (let i = 0; i < NEWTON_ITERATIONS; i++) {
+    const slope = bezierSlope(t, x1, x2);
+    if (slope < NEWTON_MIN_SLOPE) break;
+    t -= (bezierAt(t, x1, x2) - x) / slope;
+  }
+  let lo = 0;
+  let hi = 1;
+  t = Math.min(1, Math.max(0, t));
+  for (let i = 0; i < SUBDIVISION_MAX; i++) {
+    const err = bezierAt(t, x1, x2) - x;
+    if (Math.abs(err) < SUBDIVISION_EPSILON) return t;
+    if (err > 0) hi = t;
+    else lo = t;
+    t = (lo + hi) / 2;
+  }
+  return t;
+}
+function cubicBezierEasing(x1, y1, x2, y2) {
+  const cx1 = Math.min(1, Math.max(0, x1));
+  const cx2 = Math.min(1, Math.max(0, x2));
+  return (t) => {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    return bezierAt(solveForX(t, cx1, cx2), y1, y2);
+  };
+}
+var bezierCache = /* @__PURE__ */ new Map();
+function isBezier(spec) {
+  return typeof spec === "object" && spec !== null && "bezier" in spec;
+}
+function resolveEasing(spec) {
+  if (spec === void 0) return EASINGS.linear;
+  if (typeof spec === "function") return spec;
+  if (typeof spec === "string") {
+    const fn = EASINGS[spec];
+    if (!fn) throw new Error(`resolveEasing: unknown easing name "${spec}"`);
+    return fn;
+  }
+  if (isBezier(spec)) {
+    const [x1, y1, x2, y2] = spec.bezier;
+    const key = `${x1},${y1},${x2},${y2}`;
+    let fn = bezierCache.get(key);
+    if (!fn) {
+      fn = cubicBezierEasing(x1, y1, x2, y2);
+      bezierCache.set(key, fn);
+    }
+    return fn;
+  }
+  throw new Error("resolveEasing: unrecognized easing spec");
+}
+
+export { EASINGS, PathBuilder, SPRING_PRESETS, applyToPoint, boundsOfPath, boxToBox, clampRectWithin, composePath, cubicBezierEasing, decomposePath, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, ellipsePath, identity, invert, linePath, linear, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls2 as portControls, portCurvePoints, rectPath, regularPolygonPath, resolveEasing, reversePath, rotate, rotateAboutPoint, scale, scalePathToBounds, schneiderFit, splitSubpaths, starPath, strokeHitTest, transformCoords, transformPath, translate, translatePath, unionBoundsPath };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map