@weasel-js/geom 1.9.4 → 1.10.1

package/dist/index.js

@@ -1,17 +1,17 @@
 import { PORT_REACH, portControls, portCurvePoints } from './chunk-YQADYJJ7.js';
 export { PORT_REACH } from './chunk-YQADYJJ7.js';
-import { cubicPointAt } from './chunk-HPVINMOM.js';
-export { cubicPointAt, fitCubicThroughDeletion, splitCubicAtT } from './chunk-HPVINMOM.js';
+import { cubicPointAt, splitCubicAtT } from './chunk-NJ3IGAKR.js';
+export { cubicPointAt, splitCubicAtT } from './chunk-NJ3IGAKR.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-NL423YYZ.js';
-export { boundsOfCoords, boxContainsBox, boxContainsPoint, rectToContour, unionBox } from './chunk-NL423YYZ.js';
-import { DEFAULT_FLATTEN_TOLERANCE, pointInPolygon, pointSegmentDist2, flattenQuadratic, flattenCubic, segmentsCross } from './chunk-X6GJRIQD.js';
-export { DEFAULT_FLATTEN_TOLERANCE, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pointInPolygon, pointSegmentDist2, segmentsCross } from './chunk-X6GJRIQD.js';
-import { SINGULAR_RATIO } from './chunk-N5SYTHMR.js';
-export { EPS, approxEq, clamp, cross, dot, len2, sign, sub } from './chunk-N5SYTHMR.js';
-import { forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z, pathCommandCoordCount } from './chunk-E4TJRGJD.js';
-export { PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, forEachSegment, pathCommandCoordCount } from './chunk-E4TJRGJD.js';
+import { extractPolylines, rectToContour } from './chunk-7WFFCHRL.js';
+export { boundsOfCoords, boxContainsBox, boxContainsPoint, rectToContour, unionBox } from './chunk-7WFFCHRL.js';
+import { fillsOpenSubpaths, pointInPolygon, pointSegmentDist2, flattenQuadratic, flattenCubic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross } from './chunk-IDXY2NCA.js';
+export { DEFAULT_FLATTEN_TOLERANCE, defaultOpenFill, fillsOpenSubpaths, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pointInPolygon, pointSegmentDist2, segmentsCross, setDefaultOpenFill } from './chunk-IDXY2NCA.js';
+import { SINGULAR_RATIO } from './chunk-755Y4YZS.js';
+export { EPS, approxEq, clamp, cross, dot, len2, sign, sub } from './chunk-755Y4YZS.js';
+import { forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z, pathCommandCoordCount } from './chunk-OXH3NOXC.js';
+export { PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, forEachSegment, pathCommandCoordCount } from './chunk-OXH3NOXC.js';
 
 // src/view.ts
 var ZOOM_FLOOR = 1e-9;
@@ -19,7 +19,7 @@ function normalizeZoom(zoom) {
   return zoom >= ZOOM_FLOOR && zoom < Infinity ? zoom : ZOOM_FLOOR;
 }
 
-// src/mat3.ts
+// src/affine.ts
 function identity() {
   return [1, 0, 0, 1, 0, 0];
 }
@@ -66,6 +66,16 @@ function boxToBox(sx, sy, sw, sh, dx, dy, dw, dh) {
 function rotateAboutPoint(cx, cy, rad) {
   return multiply(translate(cx, cy), multiply(rotate(rad), translate(-cx, -cy)));
 }
+function transformCoords(coords, m) {
+  const out = new Float64Array(coords.length);
+  const a = m[0], b = m[1], c = m[2], d = m[3], e = m[4], f = m[5];
+  for (let i = 0; i + 1 < coords.length; i += 2) {
+    const x = coords[i], y = coords[i + 1];
+    out[i] = a * x + c * y + e;
+    out[i + 1] = b * x + d * y + f;
+  }
+  return out;
+}
 
 // src/nearest.ts
 function nearestOnLine(px, py, x0, y0, x1, y1) {
@@ -397,18 +407,6 @@ function unionBoundsPath(paths) {
   return { kind: "rect", x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
 
-// src/affine.ts
-function transformCoords(coords, m) {
-  const out = new Float64Array(coords.length);
-  const a = m[0], b = m[1], c = m[2], d = m[3], e = m[4], f = m[5];
-  for (let i = 0; i + 1 < coords.length; i += 2) {
-    const x = coords[i], y = coords[i + 1];
-    out[i] = a * x + c * y + e;
-    out[i + 1] = b * x + d * y + f;
-  }
-  return out;
-}
-
 // src/paths/transformPath.ts
 var AXIS_ALIGNED_EPSILON = 1e-9;
 function transformPath(path, m) {
@@ -453,7 +451,7 @@ function translatePolygonCopy(path, dx, dy) {
       next[ci + k + 1] = coords[ci + k + 1] + dy;
     }
   });
-  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
+  return { ...path, coords: next };
 }
 function scalePathToBounds(path, target) {
   if (path.kind === "rect") {
@@ -483,54 +481,74 @@ function pathOrigin(path) {
 
 // src/paths/splitSubpaths.ts
 function splitSubpaths(path) {
-  const { commands, coords, fillRule } = path;
+  const { commands, coords } = 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
-    });
+    out.push({ ...path, commands: commands.slice(cmdStart, i), coords: coords.slice(coordStart, ci) });
     cmdStart = i;
     coordStart = ci;
   });
-  out.push({
-    kind: "polygon",
-    commands: commands.slice(cmdStart),
-    coords: coords.slice(coordStart),
-    fillRule
-  });
+  out.push({ ...path, commands: commands.slice(cmdStart), coords: coords.slice(coordStart) });
   return out;
 }
 
+// src/paths/splitByClosure.ts
+var endsInZ = (sub3) => sub3.commands[sub3.commands.length - 1] === PATH_Z;
+function hasOpenSubpath(path) {
+  return path.kind === "polygon" && path.commands.length > 0 && splitSubpaths(path).some((sub3) => !endsInZ(sub3));
+}
+function splitByClosure(path) {
+  const closed = [];
+  const open = [];
+  if (path.commands.length > 0) {
+    for (const sub3 of splitSubpaths(path)) (endsInZ(sub3) ? closed : open).push(sub3);
+  }
+  const join = (subs) => {
+    if (subs.length === 0) return null;
+    const commands = new Uint8Array(subs.reduce((n, s) => n + s.commands.length, 0));
+    const coords = new Float32Array(subs.reduce((n, s) => n + s.coords.length, 0));
+    let ci = 0, xi = 0;
+    for (const s of subs) {
+      commands.set(s.commands, ci);
+      coords.set(s.coords, xi);
+      ci += s.commands.length;
+      xi += s.coords.length;
+    }
+    return { ...path, commands, coords };
+  };
+  return { closed: join(closed), open: join(open) };
+}
+
 // 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;
+  const fillsOpen = fillsOpenSubpaths(path);
+  let total = 0;
   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;
+  const close = (drawn) => {
+    if (open && (drawn || fillsOpen)) total += twice + endX * startY - startX * endY;
+    twice = 0;
     open = false;
   };
   forEachSegment(commands, coords, (cmd, ci, px, py) => {
     if (cmd === PATH_M) {
-      close();
+      close(false);
       startX = endX = coords[ci];
       startY = endY = coords[ci + 1];
       open = true;
       return;
     }
     if (cmd === PATH_Z) {
-      close();
+      close(true);
       endX = startX;
       endY = startY;
       return;
@@ -569,8 +587,8 @@ function pathSignedArea(path) {
     endX = x3;
     endY = y3;
   });
-  close();
-  return twice / 2;
+  close(false);
+  return total / 2;
 }
 function reversePath(path) {
   const cmds = [];
@@ -627,12 +645,7 @@ function reversePath(path) {
     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
-  };
+  return { ...path, commands: new Uint8Array(cmds), coords: new Float32Array(out) };
 }
 
 // src/paths/pathFromD.ts
@@ -1063,15 +1076,26 @@ function measureError(samples, fit) {
   return { worstIndex, worstError };
 }
 function fitOneCubic(samples) {
+  const n = samples.length;
+  return fitWithTangents(
+    samples,
+    unit(sub2(samples[1], samples[0])),
+    unit(sub2(samples[n - 2], samples[n - 1])),
+    4
+  );
+}
+function fitCubicWithTangents(samples, tStart, tEnd, opts = {}) {
+  const { cp1, cp2 } = fitWithTangents(samples, tStart, tEnd, opts.passes ?? 4, opts.params);
+  return { cp1, cp2 };
+}
+function fitWithTangents(samples, tStart, tEnd, passes, params) {
   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);
+  const ts = params ? [...params] : chordLengthParam(samples);
   if (ts === null) return { cp1: { ...a }, cp2: { ...e }, end: e, ts: samples.map(() => 0) };
   let fit = solveLS(samples, ts, a, e, tStart, tEnd);
-  for (let pass = 0; pass < 4; pass++) {
+  for (let pass = 0; pass < passes; pass++) {
     reparameterize(samples, ts, a, e, fit);
     fit = solveLS(samples, ts, a, e, tStart, tEnd);
   }
@@ -1174,6 +1198,865 @@ function emitStraightCubic(b, a, c) {
   b.curveTo(cp1x, cp1y, cp2x, cp2y, c.x, c.y);
 }
 
+// src/paths/spanFit.ts
+var SAMPLES_PER_SEGMENT = 16;
+var SPLIT_SEARCH_STEPS = 40;
+function fitCubicThroughDeletion(prev, removed, next) {
+  const first = segmentControls(prev, removed);
+  const second = segmentControls(removed, next);
+  const samples = [...sampleCubic(first), ...sampleCubic(second).slice(1)];
+  const tStart = startTangent(first);
+  const tEnd = startTangent(reversed(second));
+  const fitAt = (s) => {
+    const params = splitParams(s);
+    const fit = fitCubicWithTangents(samples, tStart, tEnd, { params, passes: 0 });
+    return { fit, error: squaredError(samples, params, prev, fit.cp1, fit.cp2, next) };
+  };
+  let lo = 0.02;
+  let hi = 0.98;
+  const phi = (Math.sqrt(5) - 1) / 2;
+  let m1 = hi - phi * (hi - lo);
+  let m2 = lo + phi * (hi - lo);
+  let e1 = fitAt(m1).error;
+  let e2 = fitAt(m2).error;
+  for (let i = 0; i < SPLIT_SEARCH_STEPS; i++) {
+    if (e1 < e2) {
+      hi = m2;
+      m2 = m1;
+      e2 = e1;
+      m1 = hi - phi * (hi - lo);
+      e1 = fitAt(m1).error;
+    } else {
+      lo = m1;
+      m1 = m2;
+      e1 = e2;
+      m2 = lo + phi * (hi - lo);
+      e2 = fitAt(m2).error;
+    }
+  }
+  const { cp1, cp2 } = fitCubicWithTangents(samples, tStart, tEnd, {
+    params: splitParams((lo + hi) / 2)
+  });
+  return { c1: cp1, c2: cp2 };
+}
+function splitParams(s) {
+  const out = [];
+  for (let i = 0; i <= SAMPLES_PER_SEGMENT; i++) out.push(s * i / SAMPLES_PER_SEGMENT);
+  for (let i = 1; i <= SAMPLES_PER_SEGMENT; i++) out.push(s + (1 - s) * i / SAMPLES_PER_SEGMENT);
+  return out;
+}
+function squaredError(samples, params, p0, p1, p2, p3) {
+  let sum = 0;
+  for (let i = 0; i < samples.length; i++) {
+    const q = cubicPointAt(p0, p1, p2, p3, params[i]);
+    sum += (q.x - samples[i].x) ** 2 + (q.y - samples[i].y) ** 2;
+  }
+  return sum;
+}
+function segmentControls(a, b) {
+  return [
+    { x: a.x, y: a.y },
+    a.outHandle ?? { x: a.x, y: a.y },
+    b.inHandle ?? { x: b.x, y: b.y },
+    { x: b.x, y: b.y }
+  ];
+}
+function sampleCubic([p0, p1, p2, p3]) {
+  const out = [];
+  for (let i = 0; i <= SAMPLES_PER_SEGMENT; i++) {
+    out.push(cubicPointAt(p0, p1, p2, p3, i / SAMPLES_PER_SEGMENT));
+  }
+  return out;
+}
+function reversed([p0, p1, p2, p3]) {
+  return [p3, p2, p1, p0];
+}
+function startTangent([p0, ...rest]) {
+  for (const p of rest) {
+    const dx = p.x - p0.x;
+    const dy = p.y - p0.y;
+    const len = Math.hypot(dx, dy);
+    if (len > 1e-9) return { x: dx / len, y: dy / len };
+  }
+  return { x: 0, y: 0 };
+}
+
+// src/paths/anchors.ts
+function pathToAnchors(path) {
+  const { commands, coords } = path;
+  const anchors = [];
+  const closed = [];
+  let current = null;
+  forEachSegment(commands, coords, (cmd, ci) => {
+    switch (cmd) {
+      case PATH_M: {
+        if (current) {
+          anchors.push(current);
+          closed.push(false);
+        }
+        current = [{ x: coords[ci], y: coords[ci + 1] }];
+        break;
+      }
+      case PATH_L: {
+        if (!current) throw new Error("pathToAnchors: L without prior M");
+        current.push({ x: coords[ci], y: coords[ci + 1] });
+        break;
+      }
+      case PATH_C: {
+        if (!current) throw new Error("pathToAnchors: C without prior M");
+        const prev = current[current.length - 1];
+        prev.outHandle = { x: coords[ci], y: coords[ci + 1] };
+        current.push({
+          x: coords[ci + 4],
+          y: coords[ci + 5],
+          inHandle: { x: coords[ci + 2], y: coords[ci + 3] }
+        });
+        break;
+      }
+      case PATH_Q: {
+        if (!current) throw new Error("pathToAnchors: Q without prior M");
+        const handle = { x: coords[ci], y: coords[ci + 1] };
+        const prev = current[current.length - 1];
+        prev.outHandle = handle;
+        current.push({ x: coords[ci + 2], y: coords[ci + 3], inHandle: { ...handle } });
+        break;
+      }
+      case PATH_Z: {
+        if (current) {
+          foldClosingCurve(current);
+          anchors.push(current);
+          closed.push(true);
+          current = null;
+        }
+        break;
+      }
+      default:
+        throw new Error(`pathToAnchors: unknown command ${cmd}`);
+    }
+  });
+  if (current) {
+    anchors.push(current);
+    closed.push(false);
+  }
+  return { anchors, closed };
+}
+function foldClosingCurve(sub3) {
+  if (sub3.length < 2) return;
+  const first = sub3[0];
+  const last = sub3[sub3.length - 1];
+  if (!last.inHandle || last.x !== first.x || last.y !== first.y) return;
+  sub3.pop();
+  first.inHandle = last.inHandle;
+}
+function anchorsToPath(anchors, closed, like) {
+  const b = new PathBuilder();
+  for (let s = 0; s < anchors.length; s++) {
+    const sub3 = anchors[s];
+    if (sub3.length === 0) continue;
+    b.moveTo(sub3[0].x, sub3[0].y);
+    for (let i = 1; i < sub3.length; i++) {
+      const prev = sub3[i - 1];
+      const cur = sub3[i];
+      const hasHandle = prev.outHandle != null || cur.inHandle != null;
+      if (!hasHandle) {
+        b.lineTo(cur.x, cur.y);
+      } else {
+        const c1 = prev.outHandle ?? { x: prev.x, y: prev.y };
+        const c2 = cur.inHandle ?? { x: cur.x, y: cur.y };
+        b.curveTo(c1.x, c1.y, c2.x, c2.y, cur.x, cur.y);
+      }
+    }
+    if (closed[s]) {
+      const last = sub3[sub3.length - 1];
+      const first = sub3[0];
+      const hasHandle = last.outHandle != null || first.inHandle != null;
+      if (hasHandle) {
+        const c1 = last.outHandle ?? { x: last.x, y: last.y };
+        const c2 = first.inHandle ?? { x: first.x, y: first.y };
+        b.curveTo(c1.x, c1.y, c2.x, c2.y, first.x, first.y);
+      }
+      b.close();
+    }
+  }
+  const built = b.build();
+  return like ? { ...like, commands: built.commands, coords: built.coords } : built;
+}
+var SMOOTH_THRESHOLD = 1e-3;
+function isAnchorSmooth(a) {
+  if (!a.inHandle || !a.outHandle) return false;
+  const inDX = a.inHandle.x - a.x;
+  const inDY = a.inHandle.y - a.y;
+  const outDX = a.outHandle.x - a.x;
+  const outDY = a.outHandle.y - a.y;
+  const inLen = Math.hypot(inDX, inDY);
+  const outLen = Math.hypot(outDX, outDY);
+  if (inLen === 0 || outLen === 0) return false;
+  const cross2 = (inDX * outDY - inDY * outDX) / (inLen * outLen);
+  return Math.abs(cross2) < SMOOTH_THRESHOLD;
+}
+function countPathAnchors(path) {
+  if (path.kind === "rect") return 4;
+  const cmds = path.commands;
+  let n = 0;
+  for (let i = 0; i < cmds.length; i++) {
+    const c = cmds[i];
+    if (c === PATH_M || c === PATH_L || c === PATH_C || c === PATH_Q) n++;
+  }
+  return n;
+}
+function segmentEnds(anchors, closed, sub3, segIdx) {
+  const s = anchors[sub3];
+  if (!s || segIdx < 0) return null;
+  if (segIdx + 1 < s.length) return { a: s[segIdx], b: s[segIdx + 1] };
+  if (closed?.[sub3] && s.length > 1 && segIdx === s.length - 1) return { a: s[segIdx], b: s[0] };
+  return null;
+}
+function isStraightSegment(a, b) {
+  return a.outHandle == null && b.inHandle == null;
+}
+function nearestOnSegment(a, b, x, y) {
+  const p1 = a.outHandle ?? a;
+  const p2 = b.inHandle ?? b;
+  const hit = isStraightSegment(a, b) ? nearestOnLine(x, y, a.x, a.y, b.x, b.y) : nearestOnCubic(x, y, a.x, a.y, p1.x, p1.y, p2.x, p2.y, b.x, b.y);
+  return { t: hit.t, d2: hit.dist * hit.dist };
+}
+function nearestSegmentT(anchors, wx, wy, closed) {
+  let bestD2 = Infinity;
+  let best = null;
+  for (let s = 0; s < anchors.length; s++) {
+    const segCount = anchors[s].length - (closed?.[s] ? 0 : 1);
+    for (let i = 0; i < segCount; i++) {
+      const ends = segmentEnds(anchors, closed, s, i);
+      if (!ends) continue;
+      const hit = nearestOnSegment(ends.a, ends.b, wx, wy);
+      if (hit.d2 < bestD2) {
+        bestD2 = hit.d2;
+        best = { sub: s, segIdx: i, t: hit.t };
+      }
+    }
+  }
+  return best;
+}
+
+// src/paths/simplifyPath.ts
+var CUBIC_SAMPLES2 = 12;
+var MAX_LINE_SAMPLES = 8;
+var LONG_STRAIGHT = 4;
+function simplifyPath(path, tolerance, opts = {}) {
+  const tol = Math.max(tolerance, 1e-6);
+  const cosCorner = Math.cos((opts.cornerAngle ?? 40) * Math.PI / 180);
+  const { anchors, closed } = pathToAnchors(path);
+  const out = [];
+  const outClosed = [];
+  anchors.forEach((sub3, s) => {
+    if (sub3.length < 2) return;
+    out.push(simplifySubpath(sub3, closed[s], tol, cosCorner));
+    outClosed.push(closed[s]);
+  });
+  return anchorsToPath(out, outClosed, path);
+}
+function simplifySubpath(sub3, closed, tol, cosCorner) {
+  const n = sub3.length;
+  const breaks = /* @__PURE__ */ new Set();
+  for (let i = 0; i < n; i++) {
+    if (isCorner(sub3, i, closed, cosCorner)) breaks.add(i);
+    if (isLongStraight(sub3, i, closed)) {
+      breaks.add(i);
+      breaks.add((i + 1) % n);
+    }
+  }
+  const corners = [...breaks].sort((a, b) => a - b);
+  const result = [];
+  if (closed && corners.length === 0) {
+    const pts = sampleRun(sub3, 0, n, tol);
+    const t = unit2(sub22(pts[1], pts[pts.length - 2]));
+    fitRun(pts, t, neg(t), tol, result, true);
+    return result;
+  }
+  const stops = closed ? [...corners, corners[0] + n] : corners;
+  for (let k = 0; k + 1 < stops.length; k++) {
+    const pts = sampleRun(sub3, stops[k], stops[k + 1], tol);
+    const last = closed && k + 2 === stops.length;
+    fitRun(pts, unit2(sub22(pts[1], pts[0])), unit2(sub22(pts[pts.length - 2], pts[pts.length - 1])), tol, result, last);
+  }
+  return result;
+}
+function isCorner(sub3, i, closed, cosCorner) {
+  const n = sub3.length;
+  const a = sub3[i];
+  const prev = sub3[(i - 1 + n) % n];
+  const next = sub3[(i + 1) % n];
+  if (!closed && (i === 0 || i === n - 1)) return true;
+  const from = a.inHandle && !same(a.inHandle, a) ? a.inHandle : prev.outHandle && !same(prev.outHandle, a) ? prev.outHandle : prev;
+  const to = a.outHandle && !same(a.outHandle, a) ? a.outHandle : next.inHandle && !same(next.inHandle, a) ? next.inHandle : next;
+  const d1 = unit2(sub22(a, from));
+  const d2 = unit2(sub22(to, a));
+  return d1.x * d2.x + d1.y * d2.y < cosCorner;
+}
+function isLongStraight(sub3, i, closed) {
+  const n = sub3.length;
+  const len = (k) => {
+    if (!closed && (k < 0 || k >= n - 1)) return 0;
+    const a2 = sub3[(k + n) % n];
+    const b2 = sub3[(k + 1) % n];
+    return Math.hypot(b2.x - a2.x, b2.y - a2.y);
+  };
+  if (!closed && i >= n - 1) return false;
+  const a = sub3[i];
+  const b = sub3[(i + 1) % n];
+  if (a.outHandle || b.inHandle) return false;
+  return len(i) >= LONG_STRAIGHT * Math.max(len(i - 1), len(i + 1));
+}
+function sampleRun(sub3, from, to, tol) {
+  const n = sub3.length;
+  const pts = [{ x: sub3[from % n].x, y: sub3[from % n].y }];
+  for (let i = from; i < to; i++) {
+    const a = sub3[i % n];
+    const b = sub3[(i + 1) % n];
+    if (!a.outHandle && !b.inHandle) {
+      const len = Math.hypot(b.x - a.x, b.y - a.y);
+      const steps = Math.min(MAX_LINE_SAMPLES, Math.max(1, Math.floor(len / (4 * tol))));
+      for (let k = 1; k <= steps; k++) pts.push({ x: a.x + (b.x - a.x) * k / steps, y: a.y + (b.y - a.y) * k / steps });
+    } else {
+      const c1 = a.outHandle ?? a;
+      const c2 = b.inHandle ?? b;
+      for (let k = 1; k <= CUBIC_SAMPLES2; k++) pts.push(cubicPointAt(a, c1, c2, b, k / CUBIC_SAMPLES2));
+    }
+  }
+  return dedupe(pts);
+}
+function fitRun(pts, tStart, tEnd, tol, out, closing) {
+  if (out.length === 0) out.push({ x: pts[0].x, y: pts[0].y });
+  const segs = [];
+  fitRecursive2(pts, tStart, tEnd, tol, segs);
+  segs.forEach((seg, i) => {
+    const prev = out[out.length - 1];
+    if (seg.c1) prev.outHandle = seg.c1;
+    const isLast = i === segs.length - 1;
+    if (closing && isLast) {
+      if (seg.c2) out[0].inHandle = seg.c2;
+      return;
+    }
+    out.push(seg.c2 ? { x: seg.end.x, y: seg.end.y, inHandle: seg.c2 } : { x: seg.end.x, y: seg.end.y });
+  });
+}
+function fitRecursive2(pts, tStart, tEnd, tol, out) {
+  const a = pts[0];
+  const e = pts[pts.length - 1];
+  if (pts.length <= 2 || worstFromLine(pts, a, e).dist <= tol) {
+    out.push({ end: e });
+    return;
+  }
+  const { cp1, cp2 } = fitCubicWithTangents(pts, tStart, tEnd);
+  const worst = worstFromCubic(pts, a, cp1, cp2, e);
+  if (worst.dist <= tol) {
+    out.push({ c1: cp1, c2: cp2, end: e });
+    return;
+  }
+  const k = worst.index;
+  const center = unit2(sub22(pts[k + 1], pts[k - 1]));
+  fitRecursive2(pts.slice(0, k + 1), tStart, neg(center), tol, out);
+  fitRecursive2(pts.slice(k), center, tEnd, tol, out);
+}
+function worstFromLine(pts, a, e) {
+  let index = 1, dist2 = 0;
+  for (let i = 1; i < pts.length - 1; i++) {
+    const d = nearestOnLine(pts[i].x, pts[i].y, a.x, a.y, e.x, e.y).dist;
+    if (d > dist2) {
+      dist2 = d;
+      index = i;
+    }
+  }
+  return { index, dist: dist2 };
+}
+function worstFromCubic(pts, a, c1, c2, e) {
+  let index = 1, dist2 = 0;
+  for (let i = 1; i < pts.length - 1; i++) {
+    const d = nearestOnCubic(pts[i].x, pts[i].y, a.x, a.y, c1.x, c1.y, c2.x, c2.y, e.x, e.y).dist;
+    if (d > dist2) {
+      dist2 = d;
+      index = i;
+    }
+  }
+  return { index, dist: dist2 };
+}
+function dedupe(pts) {
+  return pts.filter((p, i) => i === 0 || !same(p, pts[i - 1]));
+}
+var same = (p, q) => p.x === q.x && p.y === q.y;
+var sub22 = (p, q) => ({ x: p.x - q.x, y: p.y - q.y });
+var neg = (p) => ({ x: -p.x, y: -p.y });
+function unit2(p) {
+  const len = Math.hypot(p.x, p.y);
+  return len === 0 ? { x: 0, y: 0 } : { x: p.x / len, y: p.y / len };
+}
+
+// src/pxExtent.ts
+function pxExtent(px, scale3, rotation = 0) {
+  if (!rotation) {
+    return {
+      x: px / Math.abs(scale3.x),
+      y: px / Math.abs(scale3.y)
+    };
+  }
+  const c = Math.cos(rotation), s = Math.sin(rotation);
+  return {
+    x: px * Math.hypot(c / scale3.x, s / scale3.y),
+    y: px * Math.hypot(s / scale3.x, c / scale3.y)
+  };
+}
+function scaleDelta(dx, dy, scale3) {
+  return { x: dx * scale3.x, y: dy * scale3.y };
+}
+function withinPxBox(dx, dy, px, scale3) {
+  const s = scaleDelta(dx, dy, scale3);
+  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;
+}
+function withinPxRadius(dx, dy, px, scale3) {
+  const s = scaleDelta(dx, dy, scale3);
+  return s.x * s.x + s.y * s.y <= px * px;
+}
+function standoff(anchor, normal, px, scale3) {
+  const k = Math.sign(scale3.x * scale3.y) || 1;
+  let nx = normal.x * scale3.y * k;
+  let ny = normal.y * scale3.x * k;
+  const l = Math.hypot(nx, ny) || 1;
+  nx /= l;
+  ny /= l;
+  return { x: anchor.x + nx * px / scale3.x, y: anchor.y + ny * px / scale3.y, nx, ny };
+}
+function screenAngleOf(rotation, scale3) {
+  return Math.atan2(Math.sin(rotation) * scale3.y, Math.cos(rotation) * scale3.x);
+}
+
+// src/paths/anchorOrigins.ts
+var at = (x) => ({ x, y: x });
+var keyOf = (p) => `${p.x},${p.y}`;
+function heldBy(path, set) {
+  const coords = new Float32Array(path.coords.length);
+  for (let i = 0; i < coords.length; i++) coords[i] = i >> 1;
+  const indexed = pathToAnchors({ ...path, coords }).anchors;
+  return indexed.map((sub3, s) => {
+    if (sub3.length === set.anchors[s].length + 1) sub3[0].inHandle = sub3.pop().inHandle;
+    return sub3.map((a) => ({ point: a.x, in: a.inHandle?.x, out: a.outHandle?.x }));
+  });
+}
+function writtenFrom(set) {
+  let flat = 0;
+  const coded = set.anchors.map((sub3) => sub3.map((a) => {
+    const k = 3 * flat++;
+    return {
+      ...at(k),
+      ...a.inHandle ? { inHandle: at(k + 1) } : {},
+      ...a.outHandle ? { outHandle: at(k + 2) } : {}
+    };
+  }));
+  return anchorsToPath(coded, set.closed).coords;
+}
+function neighbor(sub3, closed, i, step) {
+  for (let n = 1; n < sub3.length; n++) {
+    let j = i + step * n;
+    if (j < 0 || j >= sub3.length) {
+      if (!closed) return -1;
+      j = (j + sub3.length) % sub3.length;
+    }
+    if (sub3[j]) return j;
+  }
+  return -1;
+}
+function blended(anchors, held, closed, i) {
+  const p = neighbor(held, closed, i, -1);
+  const n = neighbor(held, closed, i, 1);
+  if (p === -1 && n === -1) return null;
+  const a = held[p === -1 ? n : p].point;
+  const b = held[n === -1 ? p : n].point;
+  if (p === -1 || n === -1 || a === b) return { a, b: a, t: 0 };
+  const dp = Math.hypot(anchors[i].x - anchors[p].x, anchors[i].y - anchors[p].y);
+  const dn = Math.hypot(anchors[i].x - anchors[n].x, anchors[i].y - anchors[n].y);
+  return { a, b, t: dp + dn > 0 ? dp / (dp + dn) : 0 };
+}
+function copied(anchor, byPlace) {
+  const was = byPlace.get(keyOf(anchor));
+  if (!was) return void 0;
+  const handle = (h) => h ? byPlace.get(`${keyOf(anchor)}:${keyOf(h)}`)?.point : void 0;
+  return { point: was.point, in: handle(anchor.inHandle), out: handle(anchor.outHandle) };
+}
+function editAnchorSetTracked(path, edit) {
+  const set = pathToAnchors(path);
+  const byAnchor = /* @__PURE__ */ new Map();
+  const byPlace = /* @__PURE__ */ new Map();
+  heldBy(path, set).forEach((sub3, s) => sub3.forEach((held2, i) => {
+    const anchor = set.anchors[s][i];
+    byAnchor.set(anchor, held2);
+    if (byPlace.has(keyOf(anchor))) return;
+    if (anchor.inHandle) byPlace.set(`${keyOf(anchor)}:${keyOf(anchor.inHandle)}`, { point: held2.in });
+    if (anchor.outHandle) byPlace.set(`${keyOf(anchor)}:${keyOf(anchor.outHandle)}`, { point: held2.out });
+    byPlace.set(keyOf(anchor), { point: held2.point });
+  }));
+  if (edit(set) === false) return null;
+  const held = [];
+  const own = [];
+  set.anchors.forEach((sub3, s) => {
+    const subHeld = sub3.map((a) => byAnchor.get(a) ?? copied(a, byPlace));
+    sub3.forEach((_, i) => {
+      const h = subHeld[i];
+      held.push(h);
+      own.push(h ? { a: h.point, b: h.point, t: 0 } : blended(sub3, subHeld, set.closed[s], i));
+    });
+  });
+  const origins = Array.from(writtenFrom(set).filter((_, i) => i % 2 === 0), (code) => {
+    const anchor = Math.floor(code / 3);
+    const handle = code % 3 === 1 ? held[anchor]?.in : code % 3 === 2 ? held[anchor]?.out : void 0;
+    return handle === void 0 ? own[anchor] : { a: handle, b: handle, t: 0 };
+  });
+  return { path: anchorsToPath(set.anchors, set.closed, path), origins };
+}
+function remapPointValues(values, origins) {
+  return origins.map((o) => {
+    if (!o) return 0;
+    const a = values[o.a] ?? 0;
+    return o.t === 0 ? a : a + ((values[o.b] ?? 0) - a) * o.t;
+  });
+}
+
+// src/paths/anchorEdits.ts
+function anchorCount(set) {
+  let n = 0;
+  for (const sub3 of set.anchors) n += sub3.length;
+  return n;
+}
+function locateAnchor(set, flatIndex) {
+  if (flatIndex < 0) return null;
+  let remaining = flatIndex;
+  for (let sub3 = 0; sub3 < set.anchors.length; sub3++) {
+    const len = set.anchors[sub3].length;
+    if (remaining < len) return { sub: sub3, idx: remaining };
+    remaining -= len;
+  }
+  return null;
+}
+function flatAnchorIndex(set, sub3, idx) {
+  if (sub3 < 0 || sub3 >= set.anchors.length) return -1;
+  if (idx < 0 || idx >= set.anchors[sub3].length) return -1;
+  let base = 0;
+  for (let s = 0; s < sub3; s++) base += set.anchors[s].length;
+  return base + idx;
+}
+function anchorAt(set, flatIndex) {
+  const loc = locateAnchor(set, flatIndex);
+  if (!loc) return null;
+  return set.anchors[loc.sub][loc.idx] ?? null;
+}
+function editAnchorSet(path, edit) {
+  return editAnchorSetTracked(path, edit)?.path ?? null;
+}
+function translateAnchorBy(set, flatIndex, dx, dy) {
+  const a = anchorAt(set, flatIndex);
+  if (!a) return false;
+  a.x += dx;
+  a.y += dy;
+  if (a.inHandle) {
+    a.inHandle.x += dx;
+    a.inHandle.y += dy;
+  }
+  if (a.outHandle) {
+    a.outHandle.x += dx;
+    a.outHandle.y += dy;
+  }
+  return true;
+}
+function moveHandleTo(set, flatIndex, side, toX, toY, breakSmoothness) {
+  const a = anchorAt(set, flatIndex);
+  if (!a) return false;
+  const wasSmooth = isAnchorSmooth(a);
+  const target = { x: toX, y: toY };
+  if (side === "out") a.outHandle = target;
+  else a.inHandle = target;
+  const oppositeSide = side === "out" ? "in" : "out";
+  const opposite = oppositeSide === "in" ? a.inHandle : a.outHandle;
+  if (!breakSmoothness && wasSmooth && opposite) {
+    const mirrored = { x: 2 * a.x - target.x, y: 2 * a.y - target.y };
+    if (oppositeSide === "in") a.inHandle = mirrored;
+    else a.outHandle = mirrored;
+  }
+  return true;
+}
+function insertAnchorOnSegment(set, args) {
+  const ends = segmentEnds(set.anchors, set.closed, args.sub, args.segIdx);
+  if (!ends) return -1;
+  const { a, b } = ends;
+  const at2 = args.segIdx + 1;
+  if (isStraightSegment(a, b)) {
+    set.anchors[args.sub].splice(at2, 0, {
+      x: a.x + (b.x - a.x) * args.t,
+      y: a.y + (b.y - a.y) * args.t
+    });
+    return flatAnchorIndex(set, args.sub, at2);
+  }
+  const p0 = a, p1 = a.outHandle ?? a, p2 = b.inHandle ?? b, p3 = b;
+  const { left, right } = splitCubicAtT(p0, p1, p2, p3, args.t);
+  a.outHandle = { x: left[1].x, y: left[1].y };
+  b.inHandle = { x: right[2].x, y: right[2].y };
+  set.anchors[args.sub].splice(at2, 0, {
+    x: left[3].x,
+    y: left[3].y,
+    inHandle: { x: left[2].x, y: left[2].y },
+    outHandle: { x: right[1].x, y: right[1].y }
+  });
+  return flatAnchorIndex(set, args.sub, at2);
+}
+function segmentAt(set, x, y, opts) {
+  const scale3 = opts.scale ?? { x: 1, y: 1 };
+  const onScreen = (p) => ({ x: p.x * scale3.x, y: p.y * scale3.y });
+  const screenAnchors = set.anchors.map((sub3) => sub3.map((a) => ({
+    ...onScreen(a),
+    ...a.inHandle ? { inHandle: onScreen(a.inHandle) } : {},
+    ...a.outHandle ? { outHandle: onScreen(a.outHandle) } : {}
+  })));
+  const hit = nearestSegmentT(screenAnchors, x * scale3.x, y * scale3.y, set.closed);
+  if (!hit) return null;
+  const ends = segmentEnds(set.anchors, set.closed, hit.sub, hit.segIdx);
+  const point = pointOnSegment(ends.a, ends.b, hit.t);
+  const tol = opts.tolerancePx;
+  if (!withinPxRadius(point.x - x, point.y - y, tol, scale3)) return null;
+  if (withinPxRadius(point.x - ends.a.x, point.y - ends.a.y, tol, scale3)) return null;
+  if (withinPxRadius(point.x - ends.b.x, point.y - ends.b.y, tol, scale3)) return null;
+  return { sub: hit.sub, segIdx: hit.segIdx, t: hit.t, x: point.x, y: point.y };
+}
+function pointOnSegment(a, b, t) {
+  if (isStraightSegment(a, b)) return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+  return cubicPointAt(a, a.outHandle ?? a, b.inHandle ?? b, b, t);
+}
+function deleteAnchorsAt(set, flatIndexes) {
+  const bySub = /* @__PURE__ */ new Map();
+  for (const flat of new Set(flatIndexes)) {
+    const loc = locateAnchor(set, flat);
+    if (!loc) continue;
+    const list = bySub.get(loc.sub);
+    if (list) list.push(loc.idx);
+    else bySub.set(loc.sub, [loc.idx]);
+  }
+  if (bySub.size === 0) return false;
+  let survivors = 0;
+  for (let s = 0; s < set.anchors.length; s++) {
+    const doomed = bySub.get(s)?.length ?? 0;
+    if (set.anchors[s].length - doomed >= 2) survivors++;
+  }
+  if (survivors === 0) return false;
+  for (const [s, indices] of bySub) {
+    const sub3 = set.anchors[s];
+    if (!sub3) continue;
+    indices.sort((a, b) => b - a);
+    for (const i of indices) {
+      const wraps = set.closed[s] && sub3.length > 2;
+      const prev = wraps ? sub3[(i - 1 + sub3.length) % sub3.length] : sub3[i - 1];
+      const next = wraps ? sub3[(i + 1) % sub3.length] : sub3[i + 1];
+      if (prev && next && !(isStraightSegment(prev, sub3[i]) && isStraightSegment(sub3[i], next))) {
+        const { c1, c2 } = fitCubicThroughDeletion(prev, sub3[i], next);
+        prev.outHandle = c1;
+        next.inHandle = c2;
+      }
+      sub3.splice(i, 1);
+    }
+  }
+  for (let s = set.anchors.length - 1; s >= 0; s--) {
+    if (set.anchors[s].length < 2) {
+      set.anchors.splice(s, 1);
+      set.closed.splice(s, 1);
+    }
+  }
+  return true;
+}
+function openSubpathAt(set, flatIndex) {
+  const loc = locateAnchor(set, flatIndex);
+  if (!loc) return false;
+  if (!set.closed[loc.sub]) return false;
+  const sub3 = set.anchors[loc.sub];
+  if (!sub3) return false;
+  const { inHandle, ...start } = sub3[loc.idx];
+  const end = { x: start.x, y: start.y, ...inHandle ? { inHandle } : {} };
+  set.anchors[loc.sub] = [start, ...sub3.slice(loc.idx + 1), ...sub3.slice(0, loc.idx), end];
+  set.closed[loc.sub] = false;
+  return true;
+}
+function anchorsInRect(set, rect) {
+  const x2 = rect.x + rect.width;
+  const y2 = rect.y + rect.height;
+  const hits = [];
+  let flat = 0;
+  for (const sub3 of set.anchors) {
+    for (const a of sub3) {
+      if (a.x >= rect.x && a.x <= x2 && a.y >= rect.y && a.y <= y2) hits.push(flat);
+      flat++;
+    }
+  }
+  return hits;
+}
+
+// src/paths/joinAnchors.ts
+var COINCIDENT = 1e-6;
+function averageAnchorsAt(set, flatIndexes, axis = "both") {
+  const picked = [];
+  for (const flat of new Set(flatIndexes)) {
+    const loc = locateAnchor(set, flat);
+    if (loc) picked.push({ flat, a: set.anchors[loc.sub][loc.idx] });
+  }
+  if (picked.length < 2) return false;
+  const mx = picked.reduce((s, p) => s + p.a.x, 0) / picked.length;
+  const my = picked.reduce((s, p) => s + p.a.y, 0) / picked.length;
+  for (const { flat, a } of picked) {
+    translateAnchorBy(set, flat, axis === "y" ? 0 : mx - a.x, axis === "x" ? 0 : my - a.y);
+  }
+  return true;
+}
+function subpathEndAt(set, flatIndex) {
+  const loc = locateAnchor(set, flatIndex);
+  if (!loc || set.closed[loc.sub]) return null;
+  const len = set.anchors[loc.sub].length;
+  if (loc.idx === len - 1) return { sub: loc.sub, end: "last" };
+  if (loc.idx === 0) return { sub: loc.sub, end: "first" };
+  return null;
+}
+function joinSubpathEnds(set, a, b) {
+  const subA = set.anchors[a.sub];
+  const subB = set.anchors[b.sub];
+  if (!subA || !subB || set.closed[a.sub] || set.closed[b.sub]) return false;
+  if (a.sub === b.sub) {
+    if (a.end === b.end || subA.length < 2) return false;
+    const first = subA[0];
+    const last = subA[subA.length - 1];
+    if (coincide(first, last) && subA.length > 2) {
+      if (last.inHandle) first.inHandle = last.inHandle;
+      subA.pop();
+    }
+    set.closed[a.sub] = true;
+    return true;
+  }
+  if (a.end === "first") reverseInPlace(subA);
+  if (b.end === "last") reverseInPlace(subB);
+  const tail = subA[subA.length - 1];
+  const head = subB[0];
+  let joined;
+  if (coincide(tail, head)) {
+    if (head.outHandle) tail.outHandle = head.outHandle;
+    joined = [...subA, ...subB.slice(1)];
+  } else {
+    joined = [...subA, ...subB];
+  }
+  const keep = Math.min(a.sub, b.sub);
+  const drop = Math.max(a.sub, b.sub);
+  set.anchors[keep] = joined;
+  set.anchors.splice(drop, 1);
+  set.closed.splice(drop, 1);
+  return true;
+}
+function joinAnchorsAt(set, flatA, flatB) {
+  if (flatA === flatB) return false;
+  const a = subpathEndAt(set, flatA);
+  const b = subpathEndAt(set, flatB);
+  if (!a || !b) return false;
+  return joinSubpathEnds(set, a, b);
+}
+function closestOpenEnds(set, accept = () => true) {
+  const ends = [];
+  set.anchors.forEach((sub3, s) => {
+    if (set.closed[s] || sub3.length < 2) return;
+    ends.push({ end: { sub: s, end: "first" }, at: sub3[0] });
+    ends.push({ end: { sub: s, end: "last" }, at: sub3[sub3.length - 1] });
+  });
+  let best = null;
+  let bestD = Infinity;
+  for (let i = 0; i < ends.length; i++) {
+    for (let j = i + 1; j < ends.length; j++) {
+      const p = ends[i], q = ends[j];
+      if (p.end.sub === q.end.sub || !accept(p.end, q.end)) continue;
+      const d = Math.hypot(p.at.x - q.at.x, p.at.y - q.at.y);
+      if (d < bestD) {
+        bestD = d;
+        best = [p.end, q.end];
+      }
+    }
+  }
+  return best;
+}
+var coincide = (p, q) => Math.hypot(p.x - q.x, p.y - q.y) <= COINCIDENT;
+function reverseInPlace(sub3) {
+  sub3.reverse();
+  for (const a of sub3) {
+    const { inHandle, outHandle } = a;
+    delete a.inHandle;
+    delete a.outHandle;
+    if (outHandle) a.inHandle = outHandle;
+    if (inHandle) a.outHandle = inHandle;
+  }
+}
+
+// src/pathSubpaths.ts
+function flatSubpaths(path, tolerance) {
+  const { commands, coords } = path;
+  const closed = [];
+  const open = [];
+  let sub3 = [];
+  forEachSegment(commands, coords, (cmd, ci, curX, curY, _i, opensSubpath) => {
+    if (opensSubpath) sub3 = [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 regionSubpaths(path, opts) {
+  const flat = flatSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+  if (!fillsOpenSubpaths(path)) return flat;
+  return {
+    closed: [...flat.closed, ...flat.open.filter((sub3) => sub3.length >= 6)],
+    open: flat.open.filter((sub3) => sub3.length < 6)
+  };
+}
+function closedSubpaths(path, opts) {
+  return regionSubpaths(path, opts).closed;
+}
+
 // src/screenBand.ts
 function stretchOf(m) {
   const e = (m.a + m.d) / 2;
@@ -1216,14 +2099,14 @@ function capsuleWithinPx(px0, py0, ax, ay, bx, by, r, slop, m, st) {
   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;
+  let pos = 0, neg2 = 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++;
+    else if (cr < 0) neg2++;
   }
-  if (pos === 0 || neg === 0) return true;
+  if (pos === 0 || neg2 === 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;
@@ -1277,62 +2160,6 @@ function distToEllipse(e0, e1, y0, y1) {
 }
 
 // src/pathHitTest.ts
-function flatSubpaths(path, tolerance) {
-  const { commands, coords } = path;
-  const closed = [];
-  const open = [];
-  let sub3 = [];
-  forEachSegment(commands, coords, (cmd, ci, curX, curY, _i, opensSubpath) => {
-    if (opensSubpath) sub3 = [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;
@@ -1530,7 +2357,7 @@ function polygonContainsPath(polygon, path, opts = {}) {
   if (path.kind === "rect") {
     subpaths = [flattenVerts(rectToVerts(path))];
   } else {
-    const { closed, open } = flatSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+    const { closed, open } = regionSubpaths(path, opts);
     subpaths = [...closed, ...open];
   }
   if (subpaths.length === 0) return false;
@@ -1544,14 +2371,192 @@ function polygonContainsPath(polygon, path, opts = {}) {
 }
 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 filled = opts.filled !== false;
+  if (path.kind === "rect" && filled) return polygonsIntersect(rectToVerts(path), polygon);
+  const { closed, open } = path.kind === "rect" ? { closed: [flattenVerts(rectToVerts(path))], open: [] } : regionSubpaths(path, opts);
   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);
+  return filled && closed.length > 0 && pointInPath(path, polygon[0].x, polygon[0].y, opts);
+}
+
+// src/paths/markers.ts
+function circlePath(cx, cy, r, segments = 32) {
+  const cmds = new Uint8Array(segments + 1);
+  const coords = new Float32Array(segments * 2);
+  cmds[0] = PATH_M;
+  coords[0] = cx + r;
+  coords[1] = cy;
+  for (let i = 1; i < segments; i++) {
+    cmds[i] = PATH_L;
+    const theta = i / segments * Math.PI * 2;
+    coords[i * 2] = cx + r * Math.cos(theta);
+    coords[i * 2 + 1] = cy + r * Math.sin(theta);
+  }
+  cmds[segments] = PATH_Z;
+  return { kind: "polygon", commands: cmds, coords, fillRule: "nonzero" };
+}
+function squarePath(cx, cy, size) {
+  const half = size / 2;
+  const x0 = cx - half, y0 = cy - half;
+  const x1 = cx + half, y1 = cy + half;
+  return {
+    kind: "polygon",
+    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),
+    coords: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),
+    fillRule: "nonzero"
+  };
+}
+function rectMarkerPath(x, y, width, height) {
+  return {
+    kind: "polygon",
+    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),
+    coords: Float32Array.from(rectToContour(x, y, width, height)),
+    fillRule: "nonzero"
+  };
+}
+function roundRectPath(x, y, width, height, r, cornerSamples = 8) {
+  const radius = Math.max(0, Math.min(r, Math.min(width, height) / 2));
+  if (radius === 0) return rectMarkerPath(x, y, width, height);
+  const HALF_PI = Math.PI / 2;
+  const corners = [
+    [x + radius, y + radius, Math.PI],
+    [x + width - radius, y + radius, -HALF_PI],
+    [x + width - radius, y + height - radius, 0],
+    [x + radius, y + height - radius, HALF_PI]
+  ];
+  const perCorner = cornerSamples + 1;
+  const count = corners.length * perCorner;
+  const cmds = new Uint8Array(count + 1);
+  const coords = new Float32Array(count * 2);
+  let i = 0;
+  for (const [cx, cy, start] of corners) {
+    for (let s = 0; s <= cornerSamples; s++) {
+      const theta = start + s / cornerSamples * HALF_PI;
+      cmds[i] = i === 0 ? PATH_M : PATH_L;
+      coords[i * 2] = cx + radius * Math.cos(theta);
+      coords[i * 2 + 1] = cy + radius * Math.sin(theta);
+      i++;
+    }
+  }
+  cmds[count] = PATH_Z;
+  return { kind: "polygon", commands: cmds, coords, fillRule: "nonzero" };
+}
+
+// src/glMat3.ts
+function create(a, b, c, d, tx, ty) {
+  return new Float64Array([a, b, 0, c, d, 0, tx, ty, 1]);
+}
+function identity2() {
+  return create(1, 0, 0, 1, 0, 0);
+}
+function multiply2(out, m) {
+  const a = out[0], b = out[1];
+  const c = out[3], d = out[4];
+  const tx = out[6], ty = out[7];
+  const ma = m[0], mb = m[1];
+  const mc = m[3], md = m[4];
+  const mtx = m[6], mty = m[7];
+  return create(
+    a * ma + c * mb,
+    // new a
+    b * ma + d * mb,
+    // new b
+    a * mc + c * md,
+    // new c
+    b * mc + d * md,
+    // new d
+    a * mtx + c * mty + tx,
+    // new tx
+    b * mtx + d * mty + ty
+    // new ty
+  );
+}
+function translated(m, tx, ty) {
+  const t = create(1, 0, 0, 1, tx, ty);
+  return multiply2(m, t);
+}
+function scaled(m, sx, sy) {
+  const s = create(sx, 0, 0, sy, 0, 0);
+  return multiply2(m, s);
+}
+function toAffine(m) {
+  return [m[0], m[1], m[3], m[4], m[6], m[7]];
+}
+function fromAffine(a) {
+  return create(a[0], a[1], a[2], a[3], a[4], a[5]);
+}
+function invert2(m) {
+  const inv = invert(toAffine(m));
+  return inv && fromAffine(inv);
+}
+function toUniform(m) {
+  return Float32Array.from(m);
+}
+function apply(m, x, y) {
+  const a = m[0], b = m[1];
+  const c = m[3], d = m[4];
+  const tx = m[6], ty = m[7];
+  return [a * x + c * y + tx, b * x + d * y + ty];
+}
+function screenToClip(width, height) {
+  return create(
+    2 / width,
+    // a
+    0,
+    // b
+    0,
+    // c
+    -2 / height,
+    // d
+    -1,
+    // tx
+    1
+    // ty
+  );
+}
+function meanScaleOf(m) {
+  return Math.sqrt(Math.abs(m[0] * m[4] - m[1] * m[3]));
+}
+function minScaleOf(m) {
+  const sum = m[0] * m[0] + m[1] * m[1] + m[3] * m[3] + m[4] * m[4];
+  const det = m[0] * m[4] - m[1] * m[3];
+  return Math.sqrt(Math.max(0, (sum - Math.sqrt(Math.max(0, sum * sum - 4 * det * det))) / 2));
+}
+var mat3 = {
+  identity: identity2,
+  toAffine,
+  fromAffine,
+  multiply: multiply2,
+  translated,
+  scaled,
+  invert: invert2,
+  toUniform,
+  apply,
+  screenToClip,
+  meanScaleOf,
+  minScaleOf
+};
+
+// src/viewToMat3.ts
+function viewToMat3(view) {
+  const sx = view.scale.x;
+  const sy = view.scale.y;
+  const tx = -view.x * sx + 0;
+  const ty = -view.y * sy + 0;
+  return new Float64Array([
+    sx,
+    0,
+    0,
+    0,
+    sy,
+    0,
+    tx,
+    ty,
+    1
+  ]);
 }
 
 // src/place.ts
@@ -1560,14 +2565,14 @@ function alignAlong(start, extent, size, align) {
   if (align === "end") return start + extent - size;
   return start + (extent - size) / 2;
 }
-function positionOn(anchor, overlay, placement, offset, crossOffset) {
+function positionOn(anchor, overlay, placement, offset2, crossOffset) {
   const { width, height } = overlay;
   const { side, align } = placement;
   if (side === "top" || side === "bottom") {
-    const y = side === "bottom" ? anchor.y + anchor.height + offset : anchor.y - offset - height;
+    const y = side === "bottom" ? anchor.y + anchor.height + offset2 : anchor.y - offset2 - height;
     return { x: alignAlong(anchor.x, anchor.width, width, align) + crossOffset, y, width, height };
   }
-  const x = side === "right" ? anchor.x + anchor.width + offset : anchor.x - offset - width;
+  const x = side === "right" ? anchor.x + anchor.width + offset2 : anchor.x - offset2 - width;
   return { x, y: alignAlong(anchor.y, anchor.height, height, align) + crossOffset, width, height };
 }
 function clampAxis(start, size, low, extent, padding) {
@@ -1604,13 +2609,13 @@ function fitsAlongSide(rect, boundary, side, padding) {
   return start >= low && end <= high;
 }
 function placeRect(options) {
-  const { anchor, overlay, boundary, placement, offset = 0, crossOffset = 0 } = options;
+  const { anchor, overlay, boundary, placement, offset: offset2 = 0, crossOffset = 0 } = options;
   const { padding = 0, flip = true } = options;
   let resolved = placement;
-  let rect = positionOn(anchor, overlay, resolved, offset, crossOffset);
+  let rect = positionOn(anchor, overlay, resolved, offset2, crossOffset);
   if (flip && !fitsAlongSide(rect, boundary, resolved.side, padding)) {
     const opposite = { side: OPPOSITE[resolved.side], align: resolved.align };
-    const flipped = positionOn(anchor, overlay, opposite, offset, crossOffset);
+    const flipped = positionOn(anchor, overlay, opposite, offset2, crossOffset);
     if (fitsAlongSide(flipped, boundary, opposite.side, padding)) {
       resolved = opposite;
       rect = flipped;
@@ -1801,6 +2806,423 @@ function resolveEasing(spec) {
   throw new Error("resolveEasing: unrecognized easing spec");
 }
 
-export { EASINGS, PathBuilder, SPRING_PRESETS, ZOOM_FLOOR, 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, normalizeZoom, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls2 as portControls, portCurvePoints2 as portCurvePoints, rectPath, regularPolygonPath, resolveEasing, reversePath, rotate, rotateAboutPoint, scale, scalePathToBounds, schneiderFit, splitSubpaths, starPath, strokeHitTest, transformCoords, transformPath, translate, translatePath, unionBoundsPath };
+// src/meanScale.ts
+function meanScale(s) {
+  return Math.sqrt(Math.abs(s.x * s.y));
+}
+
+// src/poseRotation.ts
+function poseRotationOf(pose) {
+  const p = pose;
+  if (p.rotation && p.x != null && p.y != null && p.width != null && p.height != null) {
+    return { cx: p.x + p.width / 2, cy: p.y + p.height / 2, rotation: p.rotation };
+  }
+  return null;
+}
+function rotatePathAround(path, cx, cy, rotation) {
+  if (path.kind === "rect") {
+    return rotateRectCorners(path.x, path.y, path.width, path.height, cx, cy, rotation);
+  }
+  return rotatePolygon(path, cx, cy, rotation);
+}
+function rotatePolygon(path, cx, cy, rotation) {
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const { commands, coords } = path;
+  const next = new Float32Array(coords.length);
+  forEachSegment(commands, coords, (cmd, ci) => {
+    for (let k = 0, len = pathCommandCoordCount(cmd); k < len; k += 2) {
+      const dx = coords[ci + k] - cx;
+      const dy = coords[ci + k + 1] - cy;
+      next[ci + k] = cx + dx * cos - dy * sin;
+      next[ci + k + 1] = cy + dx * sin + dy * cos;
+    }
+  });
+  return { ...path, coords: next };
+}
+function rotateRectCorners(x, y, w, h, cx, cy, rotation) {
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const rotate2 = (px, py) => {
+    const dx = px - cx;
+    const dy = py - cy;
+    return [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];
+  };
+  const [x0, y0] = rotate2(x, y);
+  const [x1, y1] = rotate2(x + w, y);
+  const [x2, y2] = rotate2(x + w, y + h);
+  const [x3, y3] = rotate2(x, y + h);
+  const commands = new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]);
+  const coords = new Float32Array([x0, y0, x1, y1, x2, y2, x3, y3]);
+  return { kind: "polygon", commands, coords, fillRule: "nonzero" };
+}
+
+// src/poseFrame.ts
+function poseLinearOf(pose) {
+  const t = pose?.transform;
+  if (!Array.isArray(t) || t.length !== 4) return null;
+  if (t[0] === 1 && t[1] === 0 && t[2] === 0 && t[3] === 1) return null;
+  return t;
+}
+function poseFrameOf(pose) {
+  const p = pose;
+  if (!p || p.x == null || p.y == null || p.width == null || p.height == null) return null;
+  const linear3 = poseLinearOf(p);
+  if (!p.rotation && !linear3) return null;
+  const cx = p.x + p.width / 2;
+  const cy = p.y + p.height / 2;
+  if (!linear3) return rotateAboutPoint(cx, cy, p.rotation);
+  const [a, b, c, d] = linear3;
+  const about = [a, b, c, d, cx - (a * cx + c * cy), cy - (b * cx + d * cy)];
+  return p.rotation ? multiply(rotateAboutPoint(cx, cy, p.rotation), about) : about;
+}
+function poseFrameInverseOf(pose) {
+  if (!poseLinearOf(pose)) {
+    const r = poseRotationOf(pose);
+    return r && rotateAboutPoint(r.cx, r.cy, -r.rotation);
+  }
+  const frame = poseFrameOf(pose);
+  return frame && invert(frame);
+}
+function pathThroughPoseFrame(path, pose) {
+  if (poseLinearOf(pose)) {
+    const frame = poseFrameOf(pose);
+    return frame ? transformPath(path, frame) : path;
+  }
+  const r = poseRotationOf(pose);
+  return r ? rotatePathAround(path, r.cx, r.cy, r.rotation) : path;
+}
+
+// src/paths/anchorSymmetry.ts
+function near(a, b, tol) {
+  if (!a || !b) return a === b;
+  return Math.abs(a.x - b.x) <= tol && Math.abs(a.y - b.y) <= tol;
+}
+function image(m, p) {
+  if (!p) return void 0;
+  const [x, y] = applyToPoint(m, p.x, p.y);
+  return { x, y };
+}
+function linear2(m, d) {
+  return { x: m[0] * d.x + m[2] * d.y, y: m[1] * d.x + m[3] * d.y };
+}
+function landing(m, a, b, tol) {
+  if (!near(image(m, a), b, tol)) return null;
+  const i = image(m, a.inHandle);
+  const o = image(m, a.outHandle);
+  if (near(i, b.inHandle, tol) && near(o, b.outHandle, tol)) return false;
+  if (near(i, b.outHandle, tol) && near(o, b.inHandle, tol)) return true;
+  return null;
+}
+function anchorSymmetry(set, m, tolerance = 1e-6) {
+  const n = anchorCount(set);
+  const partners = [];
+  const flips = [];
+  const taken = /* @__PURE__ */ new Set();
+  for (let i = 0; i < n; i++) {
+    const a = anchorAt(set, i);
+    let found = -1;
+    let flip = false;
+    for (let j = 0; j < n && found < 0; j++) {
+      if (taken.has(j)) continue;
+      const how = landing(m, a, anchorAt(set, j), tolerance);
+      if (how === null) continue;
+      found = j;
+      flip = how;
+    }
+    if (found < 0) return null;
+    taken.add(found);
+    partners.push(found);
+    flips.push(flip);
+  }
+  return { m, partners, flips };
+}
+function anchorSymmetries(set, group, tolerance = 1e-6) {
+  return group.map((m) => anchorSymmetry(set, m, tolerance)).filter((s) => s !== null);
+}
+function averaged(d, syms, fixes, apply2) {
+  let x = d.x;
+  let y = d.y;
+  let k = 1;
+  for (const s of syms) {
+    if (!fixes(s)) continue;
+    const p = apply2(s.m, d);
+    x += p.x;
+    y += p.y;
+    k++;
+  }
+  return { x: x / k, y: y / k };
+}
+function translateAnchorsSymmetric(set, flats, dx, dy, syms) {
+  const dragged = new Set(flats);
+  const moves = /* @__PURE__ */ new Map();
+  for (const flat of flats) {
+    const d = averaged({ x: dx, y: dy }, syms, (s) => s.partners[flat] === flat, linear2);
+    moves.set(flat, d);
+    for (const s of syms) {
+      const j = s.partners[flat];
+      if (j === void 0 || dragged.has(j) || moves.has(j)) continue;
+      moves.set(j, linear2(s.m, d));
+    }
+  }
+  let changed = false;
+  for (const [flat, d] of moves) changed = translateAnchorBy(set, flat, d.x, d.y) || changed;
+  return changed;
+}
+var other = (side) => side === "in" ? "out" : "in";
+function moveHandleSymmetric(set, flat, side, toX, toY, breakSmoothness, syms) {
+  const a = anchorAt(set, flat);
+  if (!a || !(side === "in" ? a.inHandle : a.outHandle)) return false;
+  const sideUnder = (s, sd) => s.flips[flat] ? other(sd) : sd;
+  const fixesHandle = (s) => s.partners[flat] === flat && sideUnder(s, side) === side;
+  const to = averaged({ x: toX, y: toY }, syms, fixesHandle, image);
+  const targets = /* @__PURE__ */ new Map();
+  const put = (f, sd, p) => {
+    const key = `${f}:${sd}`;
+    if (!targets.has(key)) targets.set(key, { flat: f, side: sd, to: p });
+  };
+  put(flat, side, to);
+  for (const s of syms) put(s.partners[flat], sideUnder(s, side), image(s.m, to));
+  const opposite = side === "in" ? a.outHandle : a.inHandle;
+  const drivenBySymmetry = targets.has(`${flat}:${other(side)}`);
+  if (!drivenBySymmetry && !breakSmoothness && opposite && isAnchorSmooth(a)) {
+    const opp = { x: 2 * a.x - to.x, y: 2 * a.y - to.y };
+    put(flat, other(side), opp);
+    for (const s of syms) put(s.partners[flat], sideUnder(s, other(side)), image(s.m, opp));
+  }
+  for (const t of targets.values()) {
+    const b = anchorAt(set, t.flat);
+    if (!b) continue;
+    if (t.side === "in") b.inHandle = t.to;
+    else b.outHandle = t.to;
+  }
+  return true;
+}
+
+// src/paths/bendSegment.ts
+var T_MARGIN = 0.05;
+function bendSegment(set, grip, dx, dy) {
+  const ends = segmentEnds(set.anchors, set.closed, grip.sub, grip.segIdx);
+  if (!ends) return false;
+  const { a, b } = ends;
+  const aSmooth = isAnchorSmooth(a);
+  const bSmooth = isAnchorSmooth(b);
+  const straight = isStraightSegment(a, b);
+  const p1 = a.outHandle ?? (straight ? lerp(a, b, 1 / 3) : { x: a.x, y: a.y });
+  const p2 = b.inHandle ?? (straight ? lerp(a, b, 2 / 3) : { x: b.x, y: b.y });
+  const t = Math.min(1 - T_MARGIN, Math.max(T_MARGIN, grip.t));
+  const u = 1 - t;
+  const k = 1 / (3 * t * u * (u * u + t * t));
+  a.outHandle = { x: p1.x + k * u * dx, y: p1.y + k * u * dy };
+  b.inHandle = { x: p2.x + k * t * dx, y: p2.y + k * t * dy };
+  if (aSmooth) a.inHandle = alignedOpposite(a, a.outHandle, a.inHandle);
+  if (bSmooth) b.outHandle = alignedOpposite(b, b.inHandle, b.outHandle);
+  return true;
+}
+function lerp(a, b, f) {
+  return { x: a.x + (b.x - a.x) * f, y: a.y + (b.y - a.y) * f };
+}
+function alignedOpposite(anchor, moved, other2) {
+  const mx = moved.x - anchor.x;
+  const my = moved.y - anchor.y;
+  const len = Math.hypot(mx, my);
+  if (len === 0) return other2;
+  const keep = Math.hypot(other2.x - anchor.x, other2.y - anchor.y);
+  return { x: anchor.x - mx / len * keep, y: anchor.y - my / len * keep };
+}
+
+// src/paths/handleEdits.ts
+function retractHandles(set, flatIndexes) {
+  let changed = false;
+  for (const flat of new Set(flatIndexes)) {
+    const a = anchorAt(set, flat);
+    if (!a) continue;
+    if (a.inHandle) {
+      changed = changed || !same2(a.inHandle, a);
+      delete a.inHandle;
+    }
+    if (a.outHandle) {
+      changed = changed || !same2(a.outHandle, a);
+      delete a.outHandle;
+    }
+  }
+  return changed;
+}
+function makeHandlesSymmetric(set, flatIndexes) {
+  let changed = false;
+  for (const flat of new Set(flatIndexes)) {
+    const loc = locateAnchor(set, flat);
+    if (!loc) continue;
+    const sub3 = set.anchors[loc.sub];
+    const isEnd = !set.closed[loc.sub] && (loc.idx === 0 || loc.idx === sub3.length - 1);
+    if (isEnd) continue;
+    changed = symmetrize(sub3[loc.idx]) || changed;
+  }
+  return changed;
+}
+function symmetrize(a) {
+  const out = a.outHandle ? offset(a, a.outHandle) : null;
+  const inFlipped = a.inHandle ? scale2(offset(a, a.inHandle), -1) : null;
+  const outLen = out ? Math.hypot(out.x, out.y) : 0;
+  const inLen = inFlipped ? Math.hypot(inFlipped.x, inFlipped.y) : 0;
+  if (outLen === 0 && inLen === 0) return false;
+  let dir;
+  let len;
+  if (outLen > 0 && inLen > 0) {
+    const sum = { x: out.x / outLen + inFlipped.x / inLen, y: out.y / outLen + inFlipped.y / inLen };
+    const sumLen = Math.hypot(sum.x, sum.y);
+    dir = sumLen > 1e-9 ? scale2(sum, 1 / sumLen) : scale2(out, 1 / outLen);
+    len = (outLen + inLen) / 2;
+  } else if (outLen > 0) {
+    dir = scale2(out, 1 / outLen);
+    len = outLen;
+  } else {
+    dir = scale2(inFlipped, 1 / inLen);
+    len = inLen;
+  }
+  const nextOut = { x: a.x + dir.x * len, y: a.y + dir.y * len };
+  const nextIn = { x: a.x - dir.x * len, y: a.y - dir.y * len };
+  if (same2(a.outHandle, nextOut) && same2(a.inHandle, nextIn)) return false;
+  a.outHandle = nextOut;
+  a.inHandle = nextIn;
+  return true;
+}
+function handleAlongItsAngle(anchor, handle, to) {
+  const d = offset(anchor, handle);
+  const len = Math.hypot(d.x, d.y);
+  if (len === 0) return { x: to.x, y: to.y };
+  const ux = d.x / len;
+  const uy = d.y / len;
+  const along = Math.max(0, (to.x - anchor.x) * ux + (to.y - anchor.y) * uy);
+  return { x: anchor.x + ux * along, y: anchor.y + uy * along };
+}
+function offset(from, to) {
+  return { x: to.x - from.x, y: to.y - from.y };
+}
+function scale2(p, k) {
+  return { x: p.x * k, y: p.y * k };
+}
+function same2(p, q) {
+  return !!p && Math.abs(p.x - q.x) < 1e-9 && Math.abs(p.y - q.y) < 1e-9;
+}
+
+// src/paths/nearestAnchor.ts
+function nearestPathAnchor(paths, point, px, scale3, accept) {
+  let best = null;
+  let bestD2 = px * px;
+  for (const { id, path } of paths) {
+    const { anchors, closed } = pathToAnchors(path);
+    for (let sub3 = 0; sub3 < anchors.length; sub3++) {
+      const list = anchors[sub3];
+      for (let idx = 0; idx < list.length; idx++) {
+        const a = list[idx];
+        const s = scaleDelta(a.x - point.x, a.y - point.y, scale3);
+        const d2 = s.x * s.x + s.y * s.y;
+        if (d2 > bestD2 || best !== null && d2 === bestD2) continue;
+        const end = closed[sub3] ? null : idx === list.length - 1 ? "last" : idx === 0 ? "first" : null;
+        const hit = { id, sub: sub3, idx, x: a.x, y: a.y, end };
+        if (accept && !accept(hit)) continue;
+        best = hit;
+        bestD2 = d2;
+      }
+    }
+  }
+  return best;
+}
+function reverseAnchors(anchors) {
+  return anchors.map((a) => {
+    const { inHandle, outHandle, ...rest } = a;
+    const r = { ...rest };
+    if (outHandle) r.inHandle = { ...outHandle };
+    if (inHandle) r.outHandle = { ...inHandle };
+    return r;
+  }).reverse();
+}
+
+// src/paths/pathInWorld.ts
+function pathInPoseFrame(path, pose) {
+  if (path.kind === "rect") {
+    if (path.x === pose.x && path.y === pose.y && path.width === pose.width && path.height === pose.height) return path;
+    return { kind: "rect", x: pose.x, y: pose.y, width: pose.width, height: pose.height };
+  }
+  const b = boundsOfPath(path);
+  if (b.x === pose.x && b.y === pose.y && b.width === pose.width && b.height === pose.height) {
+    return path;
+  }
+  const m = boxToBox(b.x, b.y, b.width, b.height, pose.x, pose.y, pose.width, pose.height);
+  return transformPath(path, m);
+}
+function pathInWorld(path, pose) {
+  const local = pathInPoseFrame(path, pose);
+  const frame = poseFrameOf(pose);
+  if (!frame) return local;
+  return transformPath(local, frame);
+}
+function worldEditToStorage(pose, worldPath) {
+  const back = poseFrameInverseOf(pose);
+  const frame = back && poseFrameOf(pose);
+  const unrotated = back ? transformPath(worldPath, back) : worldPath;
+  const b = boundsOfPath(unrotated);
+  const aligned = translatePath(unrotated, -b.x, -b.y);
+  let x = b.x, y = b.y;
+  if (frame) {
+    const [cx, cy] = applyToPoint(frame, b.x + b.width / 2, b.y + b.height / 2);
+    x = cx - b.width / 2;
+    y = cy - b.height / 2;
+  }
+  return {
+    pose: { ...pose, x, y, width: b.width, height: b.height },
+    path: aligned
+  };
+}
+
+// src/typedArrayJson.ts
+var TYPED_ARRAY_CONSTRUCTORS = {
+  i8: Int8Array,
+  u8: Uint8Array,
+  u8c: Uint8ClampedArray,
+  i16: Int16Array,
+  u16: Uint16Array,
+  i32: Int32Array,
+  u32: Uint32Array,
+  f32: Float32Array,
+  f64: Float64Array
+};
+var TAGS = new Map(
+  Object.keys(TYPED_ARRAY_CONSTRUCTORS).map((tag) => [TYPED_ARRAY_CONSTRUCTORS[tag].name, tag])
+);
+var classOf = (value) => Object.prototype.toString.call(value).slice(8, -1);
+function tagTypedArray(value) {
+  if (!ArrayBuffer.isView(value)) return void 0;
+  const tag = TAGS.get(classOf(value));
+  return tag && { __ta: tag, data: Array.from(value) };
+}
+function untagTypedArray(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const { __ta: tag, data } = value;
+  if (typeof tag !== "string" || !Object.hasOwn(TYPED_ARRAY_CONSTRUCTORS, tag) || !Array.isArray(data)) return void 0;
+  return TYPED_ARRAY_CONSTRUCTORS[tag].from(data);
+}
+var isPlain = (value) => classOf(value) === "Object";
+function mapDeep(value, leaf) {
+  const swapped = leaf(value);
+  if (swapped !== void 0) return swapped;
+  if (Array.isArray(value)) return value.map((v) => mapDeep(v, leaf));
+  if (!isPlain(value)) return value;
+  const out = {};
+  for (const key of Object.keys(value)) out[key] = mapDeep(value[key], leaf);
+  return out;
+}
+function tagTypedArrays(value) {
+  return mapDeep(value, tagTypedArray);
+}
+function reviveTypedArrays(value) {
+  return mapDeep(value, untagTypedArray);
+}
+function typedArrayReplacer(_key, value) {
+  return tagTypedArray(value) ?? value;
+}
+
+export { EASINGS, PathBuilder, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, anchorAt, anchorCount, anchorSymmetries, anchorSymmetry, anchorsInRect, anchorsToPath, applyToPoint, averageAnchorsAt, bendSegment, boundsOfPath, boxToBox, circlePath, clampRectWithin, closestOpenEnds, composePath, countPathAnchors, cubicBezierEasing, decomposePath, deleteAnchorsAt, 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, editAnchorSet, editAnchorSetTracked, ellipsePath, fitCubicThroughDeletion, fitCubicWithTangents, flatAnchorIndex, handleAlongItsAngle, hasOpenSubpath, identity, insertAnchorOnSegment, invert, isAnchorSmooth, isStraightSegment, joinAnchorsAt, joinSubpathEnds, linePath, linear, locateAnchor, makeHandlesSymmetric, mat3, meanScale, moveHandleSymmetric, moveHandleTo, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestPathAnchor, nearestSegmentT, normalizeZoom, openSubpathAt, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, pathThroughPoseFrame, pathToAnchors, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, pxExtent, rectMarkerPath, rectPath, regularPolygonPath, remapPointValues, resolveEasing, retractHandles, reverseAnchors, reversePath, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, scale, scaleDelta, scalePathToBounds, schneiderFit, screenAngleOf, segmentAt, segmentEnds, simplifyPath, splitByClosure, splitSubpaths, squarePath, standoff, starPath, strokeHitTest, subpathEndAt, tagTypedArray, tagTypedArrays, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, typedArrayReplacer, unionBoundsPath, untagTypedArray, viewToMat3, withinPxBox, withinPxRadius, worldEditToStorage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map