@weasel-js/geom 1.13.0 → 1.14.1

package/dist/index.js

@@ -1,22 +1,23 @@
-import { carryCorners, evalSeg, parseSubpaths, keepCorners, anchorRange, subSeg, writePath, derivSeg } from './chunk-YPWFGFQX.js';
-export { CORNER_RESTORE_TOLERANCE, cornerTraces, keepCorners, restoreCorners } from './chunk-YPWFGFQX.js';
+import { carryCorners, parseSubpaths, intersectSegments, evalSeg, keepCorners, anchorRange, subSeg, writePath, derivSeg } from './chunk-3YH5XU3H.js';
+export { CORNER_RESTORE_TOLERANCE, cornerTraces, intersectSegments, keepCorners, restoreCorners } from './chunk-3YH5XU3H.js';
+import { createBvh } from './chunk-XXNK4N7Z.js';
 import { PORT_REACH, portControls, portCurvePoints } from './chunk-YQADYJJ7.js';
 export { PORT_REACH } from './chunk-YQADYJJ7.js';
-import { cubicDerivativeAt, cubicCurvatureAt } from './chunk-UI3FUWXM.js';
-export { SPIRO_KINDS, combTeeth, cubicCurvatureAt, cubicCurvatureSource, cubicDerivativeAt, curvatureComb, eulerAngleAt, eulerCurvatureAt, eulerCurvatureDerivativesAt, eulerPointAt, fitEulerSegment, isSpiroKind, placeEulerSegment, solveSpiro, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath } from './chunk-UI3FUWXM.js';
-import { extractPolylines } from './chunk-VHXOCDZ2.js';
-import { boundsOfPath, fitPointRun, keepCorner } from './chunk-STGSBIOL.js';
-export { boundsOfPath } from './chunk-STGSBIOL.js';
-import { countPathAnchors, pathToAnchors, anchorsToPath, isAnchorSmooth, segmentEnds, isStraightSegment, nearestSegmentT } from './chunk-Q66NA2FU.js';
-export { anchorsToPath, countPathAnchors, isAnchorSmooth, isStraightSegment, nearestSegmentT, pathToAnchors, segmentEnds } from './chunk-Q66NA2FU.js';
-import { nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestOnCubic } from './chunk-CE7IY7TB.js';
-export { nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic } from './chunk-CE7IY7TB.js';
-import { resolveCorners, pointInPolygon, cornerCuts, fillsOpenSubpaths, schneiderFit, fitCubicWithTangents, flattenCubic, pointSegmentDist2, flattenQuadratic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross } from './chunk-2PKPKU4P.js';
-export { CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, DEFAULT_FLATTEN_TOLERANCE, cornerCenter, cornerCuts, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerShapePoint, defaultOpenFill, fillsOpenSubpaths, fitCubicWithTangents, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, isCornerShape, nextCornerShape, pointInPolygon, pointSegmentDist2, remapPerAnchor, resolveCorners, resolveCornersWithSources, schneiderFit, segmentsCross, setDefaultOpenFill } from './chunk-2PKPKU4P.js';
+import { cubicDerivativeAt, cubicCurvatureAt } from './chunk-42TZDN5C.js';
+export { SPIRO_KINDS, combTeeth, cubicCurvatureAt, cubicCurvatureSource, cubicDerivativeAt, curvatureComb, eulerAngleAt, eulerCurvatureAt, eulerCurvatureDerivativesAt, eulerPointAt, fitEulerSegment, isSpiroKind, placeEulerSegment, solveSpiro, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath } from './chunk-42TZDN5C.js';
+import { extractPolylines } from './chunk-FROQPADA.js';
+import { boundsOfPath, fitPointRun, keepCorner } from './chunk-ZOMUTU7J.js';
+export { boundsOfPath } from './chunk-ZOMUTU7J.js';
+import { countPathAnchors, pathToAnchors, anchorsToPath, isAnchorSmooth, segmentEnds, isStraightSegment, nearestSegmentT } from './chunk-3HQJGI63.js';
+export { anchorsToPath, countPathAnchors, isAnchorSmooth, isStraightSegment, nearestSegmentT, pathToAnchors, segmentEnds } from './chunk-3HQJGI63.js';
+import { nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestOnCubic } from './chunk-2N6OWA7E.js';
+export { nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic } from './chunk-2N6OWA7E.js';
+import { resolveCorners, pointInPolygon, cornerCuts, fillsOpenSubpaths, schneiderFit, fitCubicWithTangents, flattenCubic, pointSegmentDist2, flattenQuadratic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross, tangentAt } from './chunk-EURWZUNY.js';
+export { CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, DEFAULT_FLATTEN_TOLERANCE, cornerCenter, cornerCuts, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerShapePoint, defaultOpenFill, fillsOpenSubpaths, fitCubicWithTangents, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, isCornerShape, nextCornerShape, pointInPolygon, pointSegmentDist2, remapPerAnchor, resolveCorners, resolveCornersWithSources, schneiderFit, segmentsCross, setDefaultOpenFill } from './chunk-EURWZUNY.js';
 import { SINGULAR_RATIO, clamp } from './chunk-755Y4YZS.js';
 export { EPS, approxEq, clamp, cross, dot, len2, sign, sub } from './chunk-755Y4YZS.js';
-import { PATH_M, PATH_L, PATH_C, PATH_Q, PATH_Z, PathBuilder, withCorner, scaleCorners, forEachSegment, pathCommandCoordCount, withoutCorners, elevateQuadraticToCubic, cubicEvalAt, cubicPointAt, splitCubicAtT, cubicAxisExtremaTs, rectToContour, splitCubicAt } from './chunk-B53BERKG.js';
-export { PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, PathBuilder, asPolygonPath, boundsOfCoords, boxContainsBox, boxContainsPoint, compactCorners, cornerAt, cornerSpecAt, cubicAxisExtremaTs, cubicBounds, cubicEvalAt, cubicPointAt, elevateQuadraticToCubic, ellipsePath, forEachSegment, hasCorners, lerpCorners, linePath, pathCommandCoordCount, polygonFromPoints, polylineFromPoints, quadraticEvalAt, rectPath, rectToContour, regularPolygonPath, scaleCorners, splitCubicAt, splitCubicAtT, splitLineAt, splitQuadraticAt, starPath, unionBox, withCorner, withoutCorners } from './chunk-B53BERKG.js';
+import { worldCoords, PATH_M, PATH_L, PATH_C, PATH_Q, PATH_Z, PathBuilder, withCorner, scaleCorners, originFor, coordsFrom, forEachSegment, pathCommandCoordCount, withoutCorners, elevateQuadraticToCubic, cubicEvalAt, cubicPointAt, splitCubicAtT, cubicAxisExtremaTs, rectToContour, splitCubicAt } from './chunk-B3D6KWW3.js';
+export { ORIGIN_THRESHOLD, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, PathBuilder, addOrigin, asPolygonPath, boundsOfCoords, boxContainsBox, boxContainsPoint, compactCorners, coordsFrom, cornerAt, cornerSpecAt, cubicAxisExtremaTs, cubicBounds, cubicEvalAt, cubicPointAt, elevateQuadraticToCubic, ellipsePath, forEachSegment, hasCorners, joinPaths, lerpCorners, linePath, originFor, originOf, pathCommandCoordCount, pathPoint, polygonFromPoints, polylineFromPoints, quadraticEvalAt, rectPath, rectToContour, regularPolygonPath, scaleCorners, splitCubicAt, splitCubicAtT, splitLineAt, splitQuadraticAt, starPath, unionBox, withCorner, withoutCorners, worldCoords } from './chunk-B3D6KWW3.js';
 
 // src/view.ts
 var ZOOM_FLOOR = 1e-9;
@@ -440,25 +441,26 @@ function pathShape(path, options = {}) {
 // src/track/run.ts
 var pointsDown = (normal2) => normal2.y > 1e-9;
 function trackRun(shape, from = 0, to = 1, options = {}) {
-  const { side = "auto", about = (from + to) / 2 } = options;
+  const { side = "auto", about = (from + to) / 2, direction = "ltr" } = options;
+  const rtl = direction === "rtl";
   const mid = shape.at(about);
   const flipped = side === "auto" ? pointsDown(mid.normal) : side === "flipped";
   const sgn = flipped ? -1 : 1;
   const reading = (n) => ({ x: -(sgn * n.y), y: sgn * n.x });
   const r0 = reading(mid.normal);
-  const reversed3 = r0.x * mid.tangent.x + r0.y * mid.tangent.y < 0;
+  const reversed3 = r0.x * mid.tangent.x + r0.y * mid.tangent.y < 0 !== rtl;
   const span = to - from;
   const lo = Math.min(from, to);
   const hi = Math.max(from, to);
-  const toF = (g) => reversed3 ? to - g * span : from + g * span;
+  const toShape = (g) => reversed3 ? to - g * span : from + g * span;
   const at2 = (g, options2) => {
-    const s = options2?.open ? shape.at(toF(g), options2) : shape.at(toF(clamp(g, 0, 1)));
+    const s = options2?.open ? shape.at(toShape(g), options2) : shape.at(toShape(clamp(g, 0, 1)));
     const dir = reading(s.normal);
     const angle = Math.atan2(dir.y, dir.x) * 180 / Math.PI;
     const normal2 = { x: sgn * s.normal.x, y: sgn * s.normal.y };
     return {
       point: s.point,
-      tangent: dir,
+      tangent: rtl ? { x: -dir.x, y: -dir.y } : dir,
       normal: normal2,
       angle: angle === 0 ? 0 : angle === -180 ? 180 : angle,
       turned: pointsDown(normal2)
@@ -470,7 +472,7 @@ function trackRun(shape, from = 0, to = 1, options = {}) {
     const q = shape.at(f).point;
     const dist = Math.hypot(p.x - q.x, p.y - q.y);
     if (!options2?.open) return { f: toG(f), dist };
-    return { f: toG(shape.nearest(p, { open: true, about: toF(options2.about ?? 0.5) }).f), dist };
+    return { f: toG(shape.nearest(p, { open: true, about: toShape(options2.about ?? 0.5) }).f), dist };
   };
   return {
     kind: shape.kind,
@@ -481,7 +483,9 @@ function trackRun(shape, from = 0, to = 1, options = {}) {
     to,
     flipped,
     reversed: reversed3,
+    direction,
     at: at2,
+    toShape,
     nearest
   };
 }
@@ -495,7 +499,7 @@ function pathToD(given) {
     return `M${num(x)} ${num(y)}h${num(width)}v${num(height)}h${num(-width)}Z`;
   }
   const cmds = path.commands;
-  const xs = path.coords;
+  const xs = worldCoords(path);
   const out = [];
   let ci = 0;
   for (let i = 0; i < cmds.length; i++) {
@@ -732,7 +736,9 @@ function portCurvePoints2(ax, ay, bx, by, outNormal, inNormal, samples, reach =
 
 // src/pathSubpaths.ts
 function flatSubpaths(path, tolerance) {
-  const { commands, coords } = resolveCorners(path);
+  const drawn = resolveCorners(path);
+  const { commands } = drawn;
+  const coords = worldCoords(drawn);
   const closed = [];
   const open = [];
   let sub3 = [];
@@ -1174,7 +1180,7 @@ function unionBoundsPath(paths) {
 
 // src/paths/transformPath.ts
 var AXIS_ALIGNED_EPSILON = 1e-9;
-function transformPath(path, m) {
+function transformPath(path, m, opts = {}) {
   const [a, b, c, d, e, f] = m;
   if (path.kind === "rect") {
     if (Math.abs(b) < AXIS_ALIGNED_EPSILON && Math.abs(c) < AXIS_ALIGNED_EPSILON) {
@@ -1190,15 +1196,25 @@ function transformPath(path, m) {
         height: Math.abs(y1 - y0)
       };
     }
-    const poly = new PathBuilder().moveTo(path.x, path.y).lineTo(path.x + path.width, path.y).lineTo(path.x + path.width, path.y + path.height).lineTo(path.x, path.y + path.height).close().build();
-    return transformPolygon(poly, m);
+    const poly = new PathBuilder().autoOrigin().moveTo(path.x, path.y).lineTo(path.x + path.width, path.y).lineTo(path.x + path.width, path.y + path.height).lineTo(path.x, path.y + path.height).close().build();
+    return transformPolygon(poly, m, opts);
   }
-  return transformPolygon(path, m);
+  return transformPolygon(path, m, opts);
 }
-function transformPolygon(path, m) {
-  const mapped = transformCoords(path.coords, m);
+function transformPolygon(path, m, opts) {
   const scaled2 = scaleCorners(path, Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])));
-  return { ...scaled2, coords: Float32Array.from(mapped) };
+  const o = path.origin;
+  if (o === void 0) {
+    const mapped = transformCoords(path.coords, m);
+    const picked = opts.autoOrigin !== false ? originFor(mapped) : void 0;
+    return picked ? { ...scaled2, coords: coordsFrom(picked, mapped), origin: picked } : { ...scaled2, coords: Float32Array.from(mapped) };
+  }
+  const [a, b, c, d, e, f] = m;
+  return {
+    ...scaled2,
+    coords: Float32Array.from(transformCoords(path.coords, [a, b, c, d, 0, 0])),
+    origin: { x: a * o.x + c * o.y + e, y: b * o.x + d * o.y + f }
+  };
 }
 
 // src/paths/transform.ts
@@ -1209,6 +1225,8 @@ function translatePath(path, dx2, dy2) {
   return translatePolygonCopy(path, dx2, dy2);
 }
 function translatePolygonCopy(path, dx2, dy2) {
+  const o = path.origin;
+  if (o) return { ...path, coords: path.coords.slice(), origin: { x: o.x + dx2, y: o.y + dy2 } };
   const next = new Float32Array(path.coords.length);
   const { commands, coords } = path;
   forEachSegment(commands, coords, (cmd, ci) => {
@@ -1529,7 +1547,7 @@ var ARG_COUNTS = {
 };
 function pathFromD(d, onWarn) {
   const tokens = tokenize(d);
-  const b = new PathBuilder();
+  const b = new PathBuilder().autoOrigin();
   const st = {
     x: 0,
     y: 0,
@@ -1797,7 +1815,9 @@ function pathToCubicContours(path) {
     if (current.segs.length > 0) out.push(current);
     current = null;
   };
-  const { commands, coords } = resolveCorners(path);
+  const drawn = resolveCorners(path);
+  const { commands } = drawn;
+  const coords = worldCoords(drawn);
   forEachSegment(commands, coords, (cmd, ci, px, py, _i, opens) => {
     if (opens) {
       current = { segs: [], closed: false };
@@ -2105,6 +2125,103 @@ function repeatAlongPath(shape, path, opts = {}) {
   });
 }
 
+// src/paths/contourSamples.ts
+function sampleAt({ c, line }, t) {
+  const [x, y] = cubicEvalAt(...c, t);
+  const seg = { line, p0: { x: c[0], y: c[1] }, c1: { x: c[2], y: c[3] }, c2: { x: c[4], y: c[5] }, p3: { x: c[6], y: c[7] } };
+  return { at: { x, y }, dir: tangentAt(seg, t) };
+}
+function sampleContour(contour, pieces) {
+  const out = [];
+  for (const seg of contour.segs) for (let k = 0; k < pieces; k++) out.push(sampleAt(seg, k / pieces));
+  const last = contour.segs.at(-1);
+  if (!contour.closed && last !== void 0) out.push(sampleAt(last, 1));
+  return out;
+}
+function polylineContour(points, closed) {
+  const segs = [];
+  for (let i = 1; i < points.length; i++) {
+    segs.push(lineSegment(points[i - 1].x, points[i - 1].y, points[i].x, points[i].y));
+  }
+  return { segs, closed };
+}
+function countParam(value, fallback, min = 0) {
+  const v = value === void 0 || !Number.isFinite(value) ? fallback : Math.round(value);
+  return Math.max(min, Math.min(v, 1e3));
+}
+
+// src/paths/roughenPath.ts
+function hash01(seed, i, k) {
+  let h = Math.imul((seed | 0) ^ 625341585, 2654435761) ^ Math.imul(i + 1, 2246822519) ^ Math.imul(k + 1, 3266489917);
+  h = Math.imul(h ^ h >>> 16, 2146121005);
+  h = Math.imul(h ^ h >>> 15, 2221713035);
+  h ^= h >>> 16;
+  return (h >>> 0) / 4294967296;
+}
+function roughenPath(path, opts) {
+  const { size, seed = 0 } = opts;
+  if (!(size > 0 && Number.isFinite(size))) return path;
+  const pieces = countParam(opts.detail, 4) + 1;
+  const contours = pathToCubicContours(path).map((contour, r) => polylineContour(
+    sampleContour(contour, pieces).map(({ at: at2 }, i) => ({
+      x: at2.x + (hash01(seed, r * 65536 + i, 0) * 2 - 1) * size,
+      y: at2.y + (hash01(seed, r * 65536 + i, 1) * 2 - 1) * size
+    })),
+    contour.closed
+  ));
+  return cubicContoursToPath(contours, path.kind === "polygon" ? path.fillRule : "nonzero");
+}
+
+// src/paths/zigzagPath.ts
+function zigzagPath(path, opts) {
+  const { size, smooth = false } = opts;
+  if (!(size !== 0 && Number.isFinite(size))) return path;
+  const pieces = countParam(opts.ridges, 4) + 1;
+  const contours = pathToCubicContours(path).map((contour) => {
+    let normal2 = { x: 0, y: 0 };
+    const points = sampleContour(contour, pieces).map(({ at: at2, dir }, i) => {
+      if (dir) normal2 = { x: -dir.y, y: dir.x };
+      const side = i % 2 === 0 ? size : -size;
+      return { x: at2.x + normal2.x * side, y: at2.y + normal2.y * side };
+    });
+    return smooth ? smoothThrough(points, contour.closed) : polylineContour(points, contour.closed);
+  });
+  return cubicContoursToPath(contours, path.kind === "polygon" ? path.fillRule : "nonzero");
+}
+function smoothThrough(points, closed) {
+  const n = points.length;
+  const at2 = (i) => closed ? points[(i + n) % n] : points[Math.max(0, Math.min(n - 1, i))];
+  const reach = (i) => ({ x: (at2(i + 1).x - at2(i - 1).x) / 6, y: (at2(i + 1).y - at2(i - 1).y) / 6 });
+  const segs = [];
+  for (let i = 0; i < (closed ? n : n - 1); i++) {
+    const a = at2(i);
+    const b = at2(i + 1);
+    const ra = reach(i);
+    const rb = reach(i + 1);
+    segs.push({ c: [a.x, a.y, a.x + ra.x, a.y + ra.y, b.x - rb.x, b.y - rb.y, b.x, b.y], line: false });
+  }
+  return { segs, closed };
+}
+
+// src/paths/puckerBloatPath.ts
+function puckerBloatPath(path, opts) {
+  const { amount } = opts;
+  if (!(amount !== 0 && Number.isFinite(amount))) return path;
+  const b = boundsOfPath(path);
+  const cx = b.x + b.width / 2;
+  const cy = b.y + b.height / 2;
+  const handle = (x, y) => [x + (x - cx) * amount, y + (y - cy) * amount];
+  const anchor = (x, y) => [x - (x - cx) * amount / 2, y - (y - cy) * amount / 2];
+  const contours = pathToCubicContours(path).map(({ segs, closed }) => ({
+    closed,
+    segs: segs.map(({ c }) => ({
+      c: [...anchor(c[0], c[1]), ...handle(c[2], c[3]), ...handle(c[4], c[5]), ...anchor(c[6], c[7])],
+      line: false
+    }))
+  }));
+  return cubicContoursToPath(contours, path.kind === "polygon" ? path.fillRule : "nonzero");
+}
+
 // src/paths/pathDistance.ts
 function pointToRectPerimeterDist(px, py, rx, ry, rw, rh) {
   const dx2 = Math.max(rx - px, px - (rx + rw), 0);
@@ -2119,116 +2236,7 @@ function pathDistanceToPoint(path, px, py) {
     return pointToRectPerimeterDist(px, py, path.x, path.y, path.width, path.height);
   }
   const drawn = resolveCorners(path);
-  return nearestOnPath(drawn.commands, drawn.coords, px, py)?.dist ?? Infinity;
-}
-
-// src/intersect/segmentIntersections.ts
-var FLAT = 1e-4;
-var MAX_DEPTH = 48;
-var SAME_T = 1e-7;
-var MAX_HITS = 16;
-function boxOf(pts) {
-  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
-  for (const p of pts) {
-    if (p.x < x0) x0 = p.x;
-    if (p.x > x1) x1 = p.x;
-    if (p.y < y0) y0 = p.y;
-    if (p.y > y1) y1 = p.y;
-  }
-  return [x0, y0, x1, y1];
-}
-function flatness(pts) {
-  if (pts.length === 2) return 0;
-  const a = pts[0], b = pts[pts.length - 1];
-  const dx2 = b.x - a.x, dy2 = b.y - a.y;
-  const len = Math.hypot(dx2, dy2);
-  let worst2 = 0;
-  for (let i = 1; i < pts.length - 1; i++) {
-    const p = pts[i];
-    const d = len === 0 ? Math.hypot(p.x - a.x, p.y - a.y) : Math.abs((p.x - a.x) * dy2 - (p.y - a.y) * dx2) / len;
-    if (d > worst2) worst2 = d;
-  }
-  return worst2;
-}
-function halve(p) {
-  let row = p.pts;
-  const left = [row[0]];
-  const right = [row[row.length - 1]];
-  while (row.length > 1) {
-    const next = [];
-    for (let i = 0; i + 1 < row.length; i++) {
-      next.push({ x: (row[i].x + row[i + 1].x) / 2, y: (row[i].y + row[i + 1].y) / 2 });
-    }
-    row = next;
-    left.push(row[0]);
-    right.unshift(row[row.length - 1]);
-  }
-  const tm = (p.t0 + p.t1) / 2;
-  return [{ pts: left, t0: p.t0, t1: tm }, { pts: right, t0: tm, t1: p.t1 }];
-}
-function chordCross(p0, p1, q0, q1, slack) {
-  const rx = p1.x - p0.x, ry = p1.y - p0.y;
-  const sx = q1.x - q0.x, sy = q1.y - q0.y;
-  const den = rx * sy - ry * sx;
-  if (den === 0) return null;
-  const qx = q0.x - p0.x, qy = q0.y - p0.y;
-  const u = (qx * sy - qy * sx) / den;
-  const v = (qx * ry - qy * rx) / den;
-  if (u < -slack || u > 1 + slack || v < -slack || v > 1 + slack) return null;
-  return [u, v];
-}
-function refine(a, b, ta, tb) {
-  for (let i = 0; i < 12; i++) {
-    const pa = evalSeg(a, ta), pb = evalSeg(b, tb);
-    const fx = pa.x - pb.x, fy = pa.y - pb.y;
-    if (Math.abs(fx) + Math.abs(fy) < 1e-12) break;
-    const da = derivSeg(a, ta), db = derivSeg(b, tb);
-    const det = -da.x * db.y + da.y * db.x;
-    if (det === 0) break;
-    const dta = (-fx * -db.y - -fy * -db.x) / det;
-    const dtb = (da.x * -fy - da.y * -fx) / det;
-    ta = Math.min(1, Math.max(0, ta + dta));
-    tb = Math.min(1, Math.max(0, tb + dtb));
-  }
-  return [ta, tb];
-}
-function intersectSegments(a, b) {
-  if (a.length === 2 && b.length === 2) {
-    const uv = chordCross(a[0], a[1], b[0], b[1], 1e-12);
-    if (!uv) return [];
-    const ta = Math.min(1, Math.max(0, uv[0]));
-    const tb = Math.min(1, Math.max(0, uv[1]));
-    const p = evalSeg(a, ta);
-    return [{ ta, tb, x: p.x, y: p.y }];
-  }
-  const out = [];
-  const push = (ta, tb) => {
-    [ta, tb] = refine(a, b, ta, tb);
-    const pa = evalSeg(a, ta), pb = evalSeg(b, tb);
-    if (Math.hypot(pa.x - pb.x, pa.y - pb.y) > 1e-6 * (1 + Math.abs(pa.x) + Math.abs(pa.y))) return;
-    if (out.some((h) => Math.abs(h.ta - ta) < SAME_T && Math.abs(h.tb - tb) < SAME_T)) return;
-    out.push({ ta, tb, x: pa.x, y: pa.y });
-  };
-  const stack = [[{ pts: a, t0: 0, t1: 1 }, { pts: b, t0: 0, t1: 1 }, 0]];
-  while (stack.length > 0 && out.length < MAX_HITS) {
-    const [p, q, depth] = stack.pop();
-    const bp = boxOf(p.pts), bq = boxOf(q.pts);
-    if (bp[0] > bq[2] + FLAT || bq[0] > bp[2] + FLAT || bp[1] > bq[3] + FLAT || bq[1] > bp[3] + FLAT) continue;
-    const fp = flatness(p.pts), fq = flatness(q.pts);
-    if (fp <= FLAT && fq <= FLAT || depth >= MAX_DEPTH) {
-      const uv = chordCross(p.pts[0], p.pts[p.pts.length - 1], q.pts[0], q.pts[q.pts.length - 1], 1e-6);
-      if (uv) push(p.t0 + uv[0] * (p.t1 - p.t0), q.t0 + uv[1] * (q.t1 - q.t0));
-      continue;
-    }
-    if (fp >= fq) {
-      const [l, r] = halve(p);
-      stack.push([l, q, depth + 1], [r, q, depth + 1]);
-    } else {
-      const [l, r] = halve(q);
-      stack.push([p, l, depth + 1], [p, r, depth + 1]);
-    }
-  }
-  return out.sort((h, k) => h.ta - k.ta);
+  return nearestOnPath(drawn.commands, worldCoords(drawn), px, py)?.dist ?? Infinity;
 }
 
 // src/intersect/pathSegments.ts
@@ -2494,6 +2502,45 @@ function quadrantPoints(segs) {
   }
   return out;
 }
+var SPATIAL = /* @__PURE__ */ new WeakMap();
+function spatialOf(index) {
+  let sp = SPATIAL.get(index);
+  if (!sp) SPATIAL.set(index, sp = { targets: /* @__PURE__ */ new Map() });
+  return sp;
+}
+function targetsIn(index, kind, box) {
+  const sp = spatialOf(index);
+  const list = index.targets(kind);
+  let held = sp.targets.get(kind);
+  if (held?.list !== list) {
+    const tree = createBvh(2, list.map((t, i) => [i, [t.x, t.y, t.x, t.y]]));
+    sp.targets.set(kind, held = { list, tree });
+  }
+  const out = [];
+  held.tree.queryBox(box, (i) => {
+    out.push(i);
+  });
+  return out.sort((a, b) => a - b);
+}
+function segmentsIn(index, box) {
+  const sp = spatialOf(index);
+  const list = index.segments;
+  if (sp.segments?.list !== list) {
+    const at3 = [];
+    const entries = [];
+    list.forEach((segs, path) => segs.forEach((seg, k) => {
+      entries.push([at3.length, [seg.box.x0, seg.box.y0, seg.box.x1, seg.box.y1]]);
+      at3.push([path, k]);
+    }));
+    sp.segments = { list, tree: createBvh(2, entries), at: at3 };
+  }
+  const { tree, at: at2 } = sp.segments;
+  const found = [];
+  tree.queryBox(box, (i) => {
+    found.push(i);
+  });
+  return found.sort((a, b) => a - b).map((i) => at2[i]);
+}
 function nearestOnSeg(s, p) {
   if (s.length === 2) return nearestOnLine(p.x, p.y, s[0].x, s[0].y, s[1].x, s[1].y);
   if (s.length === 3) return nearestOnQuadratic(p.x, p.y, s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y);
@@ -2515,39 +2562,39 @@ function findPathSnaps(index, probe, query) {
     const distance = metric(x - probe.x, y - probe.y);
     if (distance <= r) hits.push({ kind, x, y, distance, paths });
   };
+  const rx = sx > 0 ? r / sx : Infinity, ry = sy > 0 ? r / sy : Infinity;
+  const box = [probe.x - rx, probe.y - ry, probe.x + rx, probe.y + ry];
   for (const kind of STATIC_KINDS) {
     if (!kinds.has(kind)) continue;
-    for (const t of index.targets(kind)) if (!t.paths.some(skip)) offer(kind, t.x, t.y, t.paths);
+    const list = index.targets(kind);
+    for (const i of targetsIn(index, kind, box)) {
+      const t = list[i];
+      if (!t.paths.some(skip)) offer(kind, t.x, t.y, t.paths);
+    }
   }
-  const rx = r / (sx || 1), ry = r / (sy || 1);
-  const near2 = (s) => s.box.x0 - rx <= probe.x && probe.x <= s.box.x1 + rx && s.box.y0 - ry <= probe.y && probe.y <= s.box.y1 + ry;
   const o = query.origin;
-  if (o && (kinds.has("tangent") || kinds.has("perpendicular"))) {
-    index.segments.forEach((segs, path) => {
-      if (skip(path)) return;
-      for (const s of segs) {
-        if (!near2(s)) continue;
-        const lists = [];
-        if (kinds.has("tangent")) lists.push(["tangent", tangentTsFrom(s.pts, o)]);
-        if (kinds.has("perpendicular")) lists.push(["perpendicular", perpendicularTsFrom(s.pts, o)]);
-        for (const [kind, ts] of lists) {
-          for (const t of ts) {
-            const p = evalSeg(s.pts, t);
-            if (metric(p.x - o.x, p.y - o.y) > r) offer(kind, p.x, p.y, [path]);
-          }
+  const tangents = o !== void 0 && (kinds.has("tangent") || kinds.has("perpendicular"));
+  if (!tangents && !kinds.has("nearest")) return hits;
+  const near2 = segmentsIn(index, box).filter(([path]) => !skip(path));
+  if (o && tangents) {
+    for (const [path, k] of near2) {
+      const s = index.segments[path][k];
+      const lists = [];
+      if (kinds.has("tangent")) lists.push(["tangent", tangentTsFrom(s.pts, o)]);
+      if (kinds.has("perpendicular")) lists.push(["perpendicular", perpendicularTsFrom(s.pts, o)]);
+      for (const [kind, ts] of lists) {
+        for (const t of ts) {
+          const p = evalSeg(s.pts, t);
+          if (metric(p.x - o.x, p.y - o.y) > r) offer(kind, p.x, p.y, [path]);
         }
       }
-    });
+    }
   }
   if (hits.length > 0 || !kinds.has("nearest")) return hits;
-  index.segments.forEach((segs, path) => {
-    if (skip(path)) return;
-    for (const s of segs) {
-      if (!near2(s)) continue;
-      const n = nearestOnSeg(s.pts, probe);
-      offer("nearest", n.x, n.y, [path]);
-    }
-  });
+  for (const [path, k] of near2) {
+    const n = nearestOnSeg(index.segments[path][k].pts, probe);
+    offer("nearest", n.x, n.y, [path]);
+  }
   return hits;
 }
 
@@ -2675,7 +2722,8 @@ 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;
+  const { origin: _indicesHaveNone, ...bare } = path;
+  const indexed = pathToAnchors({ ...bare, 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, i) => ({ point: a.x, in: a.inHandle?.x, out: a.outHandle?.x, sub: s, idx: i }));
@@ -2694,7 +2742,7 @@ function writtenFrom(set) {
       ...a.outHandle ? { outHandle: at(k + 2) } : {}
     };
   }));
-  return anchorsToPath(coded, set.closed).coords;
+  return worldCoords(anchorsToPath(coded, set.closed));
 }
 function neighbor(sub3, closed, i, step) {
   for (let n = 1; n < sub3.length; n++) {
@@ -2817,6 +2865,14 @@ function standoff(anchor, normal2, px, scale3) {
   ny /= l;
   return { x: anchor.x + nx * px / scale3.x, y: anchor.y + ny * px / scale3.y, nx, ny };
 }
+function pxExtentInFrame(px, scale3, frame) {
+  const [a, b, c, d] = frame;
+  const ux = a * scale3.x, uy = b * scale3.y;
+  const vx = c * scale3.x, vy = d * scale3.y;
+  const det = Math.abs(ux * vy - uy * vx);
+  if (det === 0) return { x: 0, y: 0 };
+  return { x: px * Math.hypot(vx, vy) / det, y: px * Math.hypot(ux, uy) / det };
+}
 function screenAngleOf(rotation, scale3) {
   return Math.atan2(Math.sin(rotation) * scale3.y, Math.cos(rotation) * scale3.x);
 }
@@ -3427,7 +3483,7 @@ function unit(p) {
 }
 
 // src/paths/growRegion.ts
-var MAX_DEPTH2 = 6;
+var MAX_DEPTH = 6;
 var SAMPLES3 = [0.2, 0.35, 0.5, 0.65, 0.8];
 function growRegion(path, distance, opts = {}) {
   const b = new PathBuilder();
@@ -3595,7 +3651,7 @@ function offsetSeg(seg, ctx, depth) {
     ],
     line: false
   };
-  if (depth >= MAX_DEPTH2 || offsetError(c, out.c, ctx) <= ctx.tol) return [out];
+  if (depth >= MAX_DEPTH || offsetError(c, out.c, ctx) <= ctx.tol) return [out];
   const [l, r] = splitSegment(seg, 0.5);
   return [...offsetSeg(l, ctx, depth + 1), ...offsetSeg(r, ctx, depth + 1)];
 }
@@ -3663,7 +3719,7 @@ var STEPS = 16;
 var END2 = 1e-7;
 function segmentCrossings(segs) {
   const flat = segs.map((s) => flatten2(s));
-  const boxes = flat.map(boxOf2);
+  const boxes = flat.map(boxOf);
   const out = [];
   for (let a = 0; a < segs.length; a++) {
     for (let b = a + 1; b < segs.length; b++) {
@@ -3674,7 +3730,7 @@ function segmentCrossings(segs) {
           const hit = linesCross(pa[i], pa[i + 1], pb[j], pb[j + 1]);
           if (hit === null) continue;
           const guess = [(i + hit[0]) / (pa.length - 1), (j + hit[1]) / (pb.length - 1)];
-          const [s, t] = segs[a].line && segs[b].line ? guess : refine2(segs[a].c, segs[b].c, guess);
+          const [s, t] = segs[a].line && segs[b].line ? guess : refine(segs[a].c, segs[b].c, guess);
           if (atEnd(s) && atEnd(t)) continue;
           if (out.some((x) => x.a === a && x.b === b && Math.abs(x.s - s) < 1e-6 && Math.abs(x.t - t) < 1e-6)) continue;
           out.push({ a, b, s, t });
@@ -3691,7 +3747,7 @@ function flatten2(seg) {
   for (let i = 0; i <= STEPS; i++) out.push(cubicEvalAt(...seg.c, i / STEPS));
   return out;
 }
-function boxOf2(pts) {
+function boxOf(pts) {
   const b = [Infinity, Infinity, -Infinity, -Infinity];
   for (const [x, y] of pts) {
     b[0] = Math.min(b[0], x);
@@ -3710,7 +3766,7 @@ function linesCross(a, b, c, d) {
   const w = ((c[0] - a[0]) * ry - (c[1] - a[1]) * rx) / den;
   return u >= 0 && u <= 1 && w >= 0 && w <= 1 ? [u, w] : null;
 }
-function refine2(a, b, guess) {
+function refine(a, b, guess) {
   const gap = (s2, t2) => {
     const p = cubicEvalAt(...a, s2), q = cubicEvalAt(...b, t2);
     return [p[0] - q[0], p[1] - q[1]];
@@ -4890,6 +4946,9 @@ function rotatePathAround(path, cx, cy, rotation) {
 function rotatePolygon(path, cx, cy, rotation) {
   const cos = Math.cos(rotation);
   const sin = Math.sin(rotation);
+  if (path.origin) {
+    return transformPath(path, [cos, sin, -sin, cos, cx - cx * cos + cy * sin, cy - cx * sin - cy * cos]);
+  }
   const { commands, coords } = path;
   const next = new Float32Array(coords.length);
   forEachSegment(commands, coords, (cmd, ci) => {
@@ -4938,6 +4997,13 @@ function poseFrameOf(pose) {
   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 boxFrameOf(pose) {
+  const p = pose;
+  if (!p || p.x == null || p.y == null || p.width == null || p.height == null) return null;
+  const at2 = translate(p.x, p.y);
+  const frame = poseFrameOf(p);
+  return frame ? multiply(frame, at2) : at2;
+}
 function poseFrameInverseOf(pose) {
   if (!poseLinearOf(pose)) {
     const r = poseRotationOf(pose);
@@ -5123,7 +5189,7 @@ function smudgePath(path, opts) {
   if (!(radius > 0) || strength === 0 || delta.x === 0 && delta.y === 0) return path;
   const detail = opts.detail ?? radius / 3;
   return editAnchorSet(path, (set) => {
-    refine3(set, center, radius, detail);
+    refine2(set, center, radius, detail);
     let touched = false;
     let flat = 0;
     for (const sub3 of set.anchors) {
@@ -5143,7 +5209,7 @@ function weight(p, c, radius) {
   const u2 = ((p.x - c.x) ** 2 + (p.y - c.y) ** 2) / (radius * radius);
   return u2 >= 1 ? 0 : (1 - u2) ** 2;
 }
-function refine3(set, c, radius, detail) {
+function refine2(set, c, radius, detail) {
   if (!Number.isFinite(detail) || detail <= 0) return;
   let added = 0;
   for (let sub3 = 0; sub3 < set.anchors.length; sub3++) {
@@ -6787,6 +6853,6 @@ function typedArrayReplacer(_key, value) {
   return tagTypedArray(value) ?? value;
 }
 
-export { ANCHOR_FIELDS, CONSTRAINT_TOLERANCE, EASINGS, PATH_SNAP_KINDS, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, addExtremaAnchors, anchorAt, anchorCount, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsInRect, anchorsUnderBrush, anchorsWhere, applyToPoint, arcShape, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, bendSide, blendPaths, boxToBox, circlePath, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, createPathSnapIndex, cubicBezierEasing, cubicContoursToPath, decomposePath, deleteAnchorsAt, directionMarks, 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, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, intersectSegments, invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, lengthToward, lengthenOpenEnd, lengthenPathEnd, lineShape, linear, locateAnchor, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, moveHandleTo, multiply, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, openSubpathAt, pathAnchorPoints, pathAwayFromAnchors, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathShape, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeAlongRun, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonIntersectsPath, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, pxExtent, readAnchorFields, rectMarkerPath, remapAnchorValues, remapConstraints, remapPointValues, repeatAlongPath, resamplePath, resolveEasing, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, runLength, runPlaces, runStationAt, scale, scaleDelta, scalePathToBounds, scaleSegmentHandles, screenAngleOf, segmentAt2 as segmentAt, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, setSubpathStart, shiftTrack, shrinkAnchorSelection, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, stationsAlongPath, strokeHitTest, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, trackRun, trackShapeD, trackSlice, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField };
+export { ANCHOR_FIELDS, CONSTRAINT_TOLERANCE, EASINGS, PATH_SNAP_KINDS, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, addExtremaAnchors, anchorAt, anchorCount, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsInRect, anchorsUnderBrush, anchorsWhere, applyToPoint, arcShape, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, bendSide, blendPaths, boxFrameOf, boxToBox, circlePath, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, createPathSnapIndex, cubicBezierEasing, cubicContoursToPath, decomposePath, deleteAnchorsAt, directionMarks, 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, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, lengthToward, lengthenOpenEnd, lengthenPathEnd, lineShape, linear, locateAnchor, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, moveHandleTo, multiply, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, openSubpathAt, pathAnchorPoints, pathAwayFromAnchors, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathShape, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeAlongRun, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonIntersectsPath, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, puckerBloatPath, pxExtent, pxExtentInFrame, readAnchorFields, rectMarkerPath, remapAnchorValues, remapConstraints, remapPointValues, repeatAlongPath, resamplePath, resolveEasing, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roughenPath, roundRectPath, runLength, runPlaces, runStationAt, scale, scaleDelta, scalePathToBounds, scaleSegmentHandles, screenAngleOf, segmentAt2 as segmentAt, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, setSubpathStart, shiftTrack, shrinkAnchorSelection, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, stationsAlongPath, strokeHitTest, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, trackRun, trackShapeD, trackSlice, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField, zigzagPath };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map