@weasel-js/geom 1.10.0 → 1.10.1

package/dist/index.js

@@ -1,13 +1,13 @@
 import { PORT_REACH, portControls, portCurvePoints } from './chunk-YQADYJJ7.js';
 export { PORT_REACH } from './chunk-YQADYJJ7.js';
-import { cubicPointAt, splitCubicAtT, fitCubicThroughDeletion } from './chunk-XS6ERH3X.js';
-export { cubicPointAt, fitCubicThroughDeletion, splitCubicAtT } from './chunk-XS6ERH3X.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, rectToContour } from './chunk-MDT7F32A.js';
-export { boundsOfCoords, boxContainsBox, boxContainsPoint, rectToContour, unionBox } from './chunk-MDT7F32A.js';
-import { fillsOpenSubpaths, pointInPolygon, pointSegmentDist2, flattenQuadratic, flattenCubic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross } from './chunk-WQMYOCFB.js';
-export { DEFAULT_FLATTEN_TOLERANCE, defaultOpenFill, fillsOpenSubpaths, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pointInPolygon, pointSegmentDist2, segmentsCross, setDefaultOpenFill } from './chunk-WQMYOCFB.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';
@@ -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) {
@@ -1078,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);
   }
@@ -1189,127 +1198,920 @@ function emitStraightCubic(b, a, c) {
   b.curveTo(cp1x, cp1y, cp2x, cp2y, c.x, c.y);
 }
 
-// src/pathSubpaths.ts
-function flatSubpaths(path, tolerance) {
+// 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 = [];
-  const open = [];
-  let sub3 = [];
-  forEachSegment(commands, coords, (cmd, ci, curX, curY, _i, opensSubpath) => {
-    if (opensSubpath) sub3 = [curX, curY];
+  let current = null;
+  forEachSegment(commands, coords, (cmd, ci) => {
     switch (cmd) {
-      case PATH_M:
-        if (sub3.length >= 2) open.push(sub3);
-        sub3 = [coords[ci], coords[ci + 1]];
+      case PATH_M: {
+        if (current) {
+          anchors.push(current);
+          closed.push(false);
+        }
+        current = [{ x: coords[ci], y: coords[ci + 1] }];
         break;
-      case PATH_L:
-        sub3.push(coords[ci], coords[ci + 1]);
+      }
+      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:
-        flattenCubic(
-          curX,
-          curY,
-          coords[ci],
-          coords[ci + 1],
-          coords[ci + 2],
-          coords[ci + 3],
-          coords[ci + 4],
-          coords[ci + 5],
-          tolerance,
-          sub3
-        );
+      }
+      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:
-        flattenQuadratic(
-          curX,
-          curY,
-          coords[ci],
-          coords[ci + 1],
-          coords[ci + 2],
-          coords[ci + 3],
-          tolerance,
-          sub3
-        );
+      }
+      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 (sub3.length >= 6) closed.push(sub3);
-        else if (sub3.length >= 2) open.push(sub3);
-        sub3 = [];
+      }
+      case PATH_Z: {
+        if (current) {
+          foldClosingCurve(current);
+          anchors.push(current);
+          closed.push(true);
+          current = null;
+        }
         break;
+      }
       default:
-        throw new Error(`pathHitTest: unknown command ${cmd}`);
+        throw new Error(`pathToAnchors: 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)
-  };
+  if (current) {
+    anchors.push(current);
+    closed.push(false);
+  }
+  return { anchors, closed };
 }
-function closedSubpaths(path, opts) {
-  return regionSubpaths(path, opts).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;
 }
-
-// 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 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;
 }
-function isSimilarity(s) {
-  return s.s1 - s.s2 <= 1e-9 * s.s1;
+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 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;
+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 ellipseWithinPx(px0 - sax, py0 - say, r, slop, st) || ellipseWithinPx(px0 - sbx, py0 - sby, r, slop, st);
+  return n;
 }
-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 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;
+  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, 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) neg2++;
+  }
+  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;
+  }
+  return false;
 }
 function ellipseWithinPx(dx, dy, r, slop, st) {
   const cos = Math.cos(st.phi), sin = Math.sin(st.phi);
@@ -1586,218 +2388,61 @@ function circlePath(cx, cy, r, segments = 32) {
   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/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++;
+  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);
   }
-  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;
+  cmds[segments] = PATH_Z;
+  return { kind: "polygon", commands: cmds, coords, fillRule: "nonzero" };
 }
-function isStraightSegment(a, b) {
-  return a.outHandle == null && b.inHandle == null;
+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 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 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 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 };
-      }
+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++;
     }
   }
-  return best;
+  cmds[count] = PATH_Z;
+  return { kind: "polygon", commands: cmds, coords, fillRule: "nonzero" };
 }
 
 // src/glMat3.ts
@@ -1920,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) {
@@ -1964,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;
@@ -2166,44 +2811,6 @@ function meanScale(s) {
   return Math.sqrt(Math.abs(s.x * s.y));
 }
 
-// src/pxExtent.ts
-function pxExtent(px, scale2, rotation = 0) {
-  if (!rotation) {
-    return {
-      x: px / Math.abs(scale2.x),
-      y: px / Math.abs(scale2.y)
-    };
-  }
-  const c = Math.cos(rotation), s = Math.sin(rotation);
-  return {
-    x: px * Math.hypot(c / scale2.x, s / scale2.y),
-    y: px * Math.hypot(s / scale2.x, c / scale2.y)
-  };
-}
-function scaleDelta(dx, dy, scale2) {
-  return { x: dx * scale2.x, y: dy * scale2.y };
-}
-function withinPxBox(dx, dy, px, scale2) {
-  const s = scaleDelta(dx, dy, scale2);
-  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;
-}
-function withinPxRadius(dx, dy, px, scale2) {
-  const s = scaleDelta(dx, dy, scale2);
-  return s.x * s.x + s.y * s.y <= px * px;
-}
-function standoff(anchor, normal, px, scale2) {
-  const k = Math.sign(scale2.x * scale2.y) || 1;
-  let nx = normal.x * scale2.y * k;
-  let ny = normal.y * scale2.x * k;
-  const l = Math.hypot(nx, ny) || 1;
-  nx /= l;
-  ny /= l;
-  return { x: anchor.x + nx * px / scale2.x, y: anchor.y + ny * px / scale2.y, nx, ny };
-}
-function screenAngleOf(rotation, scale2) {
-  return Math.atan2(Math.sin(rotation) * scale2.y, Math.cos(rotation) * scale2.x);
-}
-
 // src/poseRotation.ts
 function poseRotationOf(pose) {
   const p = pose;
@@ -2260,12 +2867,12 @@ function poseLinearOf(pose) {
 function poseFrameOf(pose) {
   const p = pose;
   if (!p || p.x == null || p.y == null || p.width == null || p.height == null) return null;
-  const linear2 = poseLinearOf(p);
-  if (!p.rotation && !linear2) 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 (!linear2) return rotateAboutPoint(cx, cy, p.rotation);
-  const [a, b, c, d] = linear2;
+  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;
 }
@@ -2286,185 +2893,221 @@ function pathThroughPoseFrame(path, pose) {
   return r ? rotatePathAround(path, r.cx, r.cy, r.rotation) : path;
 }
 
-// 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;
+// 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 anchorAt(set, flatIndex) {
-  const loc = locateAnchor(set, flatIndex);
-  if (!loc) return null;
-  return set.anchors[loc.sub][loc.idx] ?? null;
+function linear2(m, d) {
+  return { x: m[0] * d.x + m[2] * d.y, y: m[1] * d.x + m[3] * d.y };
 }
-function editAnchorSet(path, edit) {
-  const set = pathToAnchors(path);
-  const changed = edit(set);
-  if (changed === false) return null;
-  return anchorsToPath(set.anchors, set.closed, path);
+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 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;
+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));
+    }
   }
-  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;
+  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;
 }
-function insertAnchorOnSegment(set, args) {
-  const ends = segmentEnds(set.anchors, set.closed, args.sub, args.segIdx);
-  if (!ends) return -1;
+
+// 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 at = args.segIdx + 1;
-  if (isStraightSegment(a, b)) {
-    set.anchors[args.sub].splice(at, 0, {
-      x: a.x + (b.x - a.x) * args.t,
-      y: a.y + (b.y - a.y) * args.t
-    });
-    return flatAnchorIndex(set, args.sub, at);
-  }
-  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(at, 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, at);
+  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 segmentAt(set, x, y, opts) {
-  const scale2 = opts.scale ?? { x: 1, y: 1 };
-  const onScreen = (p) => ({ x: p.x * scale2.x, y: p.y * scale2.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 * scale2.x, y * scale2.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, scale2)) return null;
-  if (withinPxRadius(point.x - ends.a.x, point.y - ends.a.y, tol, scale2)) return null;
-  if (withinPxRadius(point.x - ends.b.x, point.y - ends.b.y, tol, scale2)) return null;
-  return { sub: hit.sub, segIdx: hit.segIdx, t: hit.t, x: point.x, y: point.y };
+function lerp(a, b, f) {
+  return { x: a.x + (b.x - a.x) * f, y: a.y + (b.y - a.y) * f };
 }
-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 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 };
 }
-function deleteAnchorsAt(set, flatIndexes) {
-  const bySub = /* @__PURE__ */ new Map();
+
+// src/paths/handleEdits.ts
+function retractHandles(set, flatIndexes) {
+  let changed = false;
   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) {
-        const { c1, c2 } = fitCubicThroughDeletion(prev, next);
-        prev.outHandle = c1;
-        next.inHandle = c2;
-      }
-      sub3.splice(i, 1);
+    const a = anchorAt(set, flat);
+    if (!a) continue;
+    if (a.inHandle) {
+      changed = changed || !same2(a.inHandle, a);
+      delete a.inHandle;
     }
-  }
-  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);
+    if (a.outHandle) {
+      changed = changed || !same2(a.outHandle, a);
+      delete a.outHandle;
     }
   }
-  return true;
+  return changed;
 }
-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;
+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 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;
+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, scale2, accept) {
+function nearestPathAnchor(paths, point, px, scale3, accept) {
   let best = null;
   let bestD2 = px * px;
   for (const { id, path } of paths) {
@@ -2473,7 +3116,7 @@ function nearestPathAnchor(paths, point, px, scale2, accept) {
       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, scale2);
+        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;
@@ -2580,6 +3223,6 @@ function typedArrayReplacer(_key, value) {
   return tagTypedArray(value) ?? value;
 }
 
-export { EASINGS, PathBuilder, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, anchorAt, anchorCount, anchorsInRect, anchorsToPath, applyToPoint, boundsOfPath, boxToBox, circlePath, clampRectWithin, 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, ellipsePath, flatAnchorIndex, hasOpenSubpath, identity, insertAnchorOnSegment, invert, isAnchorSmooth, isStraightSegment, linePath, linear, locateAnchor, mat3, meanScale, 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, resolveEasing, reverseAnchors, reversePath, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, scale, scaleDelta, scalePathToBounds, schneiderFit, screenAngleOf, segmentAt, segmentEnds, splitByClosure, splitSubpaths, squarePath, standoff, starPath, strokeHitTest, tagTypedArray, tagTypedArrays, transformCoords, transformPath, translate, translateAnchorBy, translatePath, typedArrayReplacer, unionBoundsPath, untagTypedArray, viewToMat3, withinPxBox, withinPxRadius, worldEditToStorage };
+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