@weasel-js/core 1.4.4 → 1.5.1

package/dist/{chunk-WPM42WJP.js → chunk-3LPQ2XZG.js}

@@ -1,52 +1,7 @@
-import { PATH_Z, PATH_Q, elevateQuadraticToCubic, cubicBounds, PATH_C, PATH_L, PATH_M, pointSegmentDist2, transformCoords, forEachSegment, pathCommandCoordCount, boxToBox } from '@weasel-js/geom';
-export { PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, pathCommandCoordCount } from '@weasel-js/geom';
+import { forEachSegment, PATH_Z, PATH_Q, elevateQuadraticToCubic, cubicBounds, PATH_C, PATH_L, PATH_M, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, pointSegmentDist2, transformCoords, pathCommandCoordCount, boxToBox } from '@weasel-js/geom';
+export { DEFAULT_FLATTEN_TOLERANCE, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pathCommandCoordCount } from '@weasel-js/geom';
 
-// src/core/units.ts
-function resolveUnit(v, unitSystem) {
-  if (typeof v === "number") return v;
-  if (!unitSystem) {
-    throw new Error(
-      `resolveUnit: tagged value { value: ${v.value}, unit: '${v.unit}' } requires a UnitSystem`
-    );
-  }
-  const factor = unitSystem.units[v.unit];
-  if (factor === void 0) {
-    const known = Object.keys(unitSystem.units).join(", ") || "(none)";
-    throw new Error(
-      `resolveUnit: unknown unit '${v.unit}' (system base: '${unitSystem.base}', known units: ${known})`
-    );
-  }
-  return v.value * factor;
-}
-function formatUnit(baseValue, displayUnit, unitSystem, opts) {
-  const factor = unitSystem.units[displayUnit];
-  if (factor === void 0) {
-    const known = Object.keys(unitSystem.units).join(", ") || "(none)";
-    throw new Error(
-      `formatUnit: unknown unit '${displayUnit}' (system base: '${unitSystem.base}', known units: ${known})`
-    );
-  }
-  const precision = opts?.precision ?? 2;
-  const suffix = opts?.suffix ?? true;
-  const display = baseValue / factor;
-  let s = display.toFixed(precision);
-  if (s.includes(".")) {
-    s = s.replace(/0+$/, "").replace(/\.$/, "");
-  }
-  return suffix ? `${s}${displayUnit}` : s;
-}
-var IMPERIAL_INCHES = {
-  base: "in",
-  units: { in: 1, ft: 12, yd: 36, mi: 63360 }
-};
-var METRIC_MM = {
-  base: "mm",
-  units: { mm: 1, cm: 10, m: 1e3, km: 1e6 }
-};
-var PIXELS = {
-  base: "px",
-  units: { px: 1 }
-};
+// src/core/geometry/path.ts
 function boundsOfPath(path) {
   if (path.kind === "rect") return path;
   const { commands, coords } = path;
@@ -54,9 +9,7 @@ function boundsOfPath(path) {
     return { kind: "rect", x: 0, y: 0, width: 0, height: 0 };
   }
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  let ci = 0;
   let seen = false;
-  let px = 0, py = 0;
   const include = (x, y) => {
     if (x < minX) minX = x;
     if (x > maxX) maxX = x;
@@ -64,40 +17,34 @@ function boundsOfPath(path) {
     if (y > maxY) maxY = y;
     seen = true;
   };
-  for (let i = 0; i < commands.length; i++) {
-    const cmd = commands[i];
+  forEachSegment(commands, coords, (cmd, ci, px, py) => {
     switch (cmd) {
       case PATH_M:
       case PATH_L: {
-        const x = coords[ci], y = coords[ci + 1];
-        include(x, y);
-        px = x;
-        py = y;
-        ci += 2;
+        include(coords[ci], coords[ci + 1]);
         break;
       }
       case PATH_C: {
-        const x1 = coords[ci], y1 = coords[ci + 1];
-        const x2 = coords[ci + 2], y2 = coords[ci + 3];
-        const x3 = coords[ci + 4], y3 = coords[ci + 5];
-        const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(px, py, x1, y1, x2, y2, x3, y3);
+        const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(
+          px,
+          py,
+          coords[ci],
+          coords[ci + 1],
+          coords[ci + 2],
+          coords[ci + 3],
+          coords[ci + 4],
+          coords[ci + 5]
+        );
         include(bMinX, bMinY);
         include(bMaxX, bMaxY);
-        px = x3;
-        py = y3;
-        ci += 6;
         break;
       }
       case PATH_Q: {
-        const qx1 = coords[ci], qy1 = coords[ci + 1];
         const qx2 = coords[ci + 2], qy2 = coords[ci + 3];
-        const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(px, py, qx1, qy1, qx2, qy2);
+        const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(px, py, coords[ci], coords[ci + 1], qx2, qy2);
         const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(px, py, c1x, c1y, c2x, c2y, qx2, qy2);
         include(bMinX, bMinY);
         include(bMaxX, bMaxY);
-        px = qx2;
-        py = qy2;
-        ci += 4;
         break;
       }
       case PATH_Z:
@@ -105,133 +52,10 @@ function boundsOfPath(path) {
       default:
         throw new Error(`boundsOfPath: unknown command ${cmd}`);
     }
-  }
+  });
   if (!seen) return { kind: "rect", x: 0, y: 0, width: 0, height: 0 };
   return { kind: "rect", x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
-
-// src/features/paths/flatten.ts
-var DEFAULT_FLATTEN_TOLERANCE = 0.5;
-var MIN_FLATTEN_TOLERANCE = 1e-6;
-function usableTolerance(tolerance) {
-  return tolerance > 0 ? tolerance : MIN_FLATTEN_TOLERANCE;
-}
-function finite6(a, b, c, d, e, f) {
-  return Number.isFinite(a) && Number.isFinite(b) && Number.isFinite(c) && Number.isFinite(d) && Number.isFinite(e) && Number.isFinite(f);
-}
-function finite8(a, b, c, d, e, f, g, h) {
-  return finite6(a, b, c, d, e, f) && Number.isFinite(g) && Number.isFinite(h);
-}
-function distPointToLine(px, py, ax, ay, bx, by) {
-  const dx = bx - ax;
-  const dy = by - ay;
-  const len2 = dx * dx + dy * dy;
-  if (len2 === 0) {
-    const ex = px - ax;
-    const ey = py - ay;
-    return Math.sqrt(ex * ex + ey * ey);
-  }
-  const cross = (px - ax) * dy - (py - ay) * dx;
-  return Math.abs(cross) / Math.sqrt(len2);
-}
-function flattenCubic(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out) {
-  if (!finite8(x0, y0, x1, y1, x2, y2, x3, y3)) {
-    out.push(x3, y3);
-    return;
-  }
-  flattenCubicRec(x0, y0, x1, y1, x2, y2, x3, y3, usableTolerance(tolerance), out);
-}
-function flattenCubicRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out) {
-  const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);
-  const d2 = distPointToLine(x2, y2, x0, y0, x3, y3);
-  if (Math.max(d1, d2) <= tolerance) {
-    out.push(x3, y3);
-    return;
-  }
-  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
-  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
-  const x23 = (x2 + x3) * 0.5, y23 = (y2 + y3) * 0.5;
-  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
-  const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;
-  const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;
-  flattenCubicRec(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out);
-  flattenCubicRec(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out);
-}
-function flattenQuadratic(x0, y0, x1, y1, x2, y2, tolerance, out) {
-  if (!finite6(x0, y0, x1, y1, x2, y2)) {
-    out.push(x2, y2);
-    return;
-  }
-  flattenQuadraticRec(x0, y0, x1, y1, x2, y2, usableTolerance(tolerance), out);
-}
-function flattenQuadraticRec(x0, y0, x1, y1, x2, y2, tolerance, out) {
-  const d = distPointToLine(x1, y1, x0, y0, x2, y2);
-  if (d <= tolerance) {
-    out.push(x2, y2);
-    return;
-  }
-  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
-  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
-  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
-  flattenQuadraticRec(x0, y0, x01, y01, x012, y012, tolerance, out);
-  flattenQuadraticRec(x012, y012, x12, y12, x2, y2, tolerance, out);
-}
-function flattenCubicWithArcLen(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut) {
-  if (!finite8(x0, y0, x1, y1, x2, y2, x3, y3)) {
-    out.push(x3, y3);
-    arcOut.push(0);
-    return 0;
-  }
-  return flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, usableTolerance(tolerance), out, arcOut, 0);
-}
-function flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut, accum) {
-  const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);
-  const d2 = distPointToLine(x2, y2, x0, y0, x3, y3);
-  if (Math.max(d1, d2) <= tolerance) {
-    const lastX = out.length >= 2 ? out[out.length - 2] : x0;
-    const lastY = out.length >= 2 ? out[out.length - 1] : y0;
-    const seg = Math.hypot(x3 - lastX, y3 - lastY);
-    accum += seg;
-    out.push(x3, y3);
-    arcOut.push(accum);
-    return accum;
-  }
-  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
-  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
-  const x23 = (x2 + x3) * 0.5, y23 = (y2 + y3) * 0.5;
-  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
-  const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;
-  const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;
-  accum = flattenCubicArcRec(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out, arcOut, accum);
-  accum = flattenCubicArcRec(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out, arcOut, accum);
-  return accum;
-}
-function flattenQuadraticWithArcLen(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut) {
-  if (!finite6(x0, y0, x1, y1, x2, y2)) {
-    out.push(x2, y2);
-    arcOut.push(0);
-    return 0;
-  }
-  return flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, usableTolerance(tolerance), out, arcOut, 0);
-}
-function flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut, accum) {
-  const d = distPointToLine(x1, y1, x0, y0, x2, y2);
-  if (d <= tolerance) {
-    const lastX = out.length >= 2 ? out[out.length - 2] : x0;
-    const lastY = out.length >= 2 ? out[out.length - 1] : y0;
-    const seg = Math.hypot(x2 - lastX, y2 - lastY);
-    accum += seg;
-    out.push(x2, y2);
-    arcOut.push(accum);
-    return accum;
-  }
-  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
-  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
-  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
-  accum = flattenQuadraticArcRec(x0, y0, x01, y01, x012, y012, tolerance, out, arcOut, accum);
-  accum = flattenQuadraticArcRec(x012, y012, x12, y12, x2, y2, tolerance, out, arcOut, accum);
-  return accum;
-}
 function pointInPath(path, x, y, opts = {}) {
   if (path.kind === "rect") {
     return x >= path.x && x <= path.x + path.width && y >= path.y && y <= path.y + path.height;
@@ -244,7 +68,6 @@ function pointInPolygonPath(path, x, y, tolerance) {
   let crossings = 0;
   let winding = 0;
   let subStartX = 0, subStartY = 0;
-  let curX = 0, curY = 0;
   let subVerts = [];
   let subOpen = false;
   const flushSubpath = (closed) => {
@@ -263,57 +86,52 @@ function pointInPolygonPath(path, x, y, tolerance) {
     subVerts = [];
     subOpen = false;
   };
-  let ci = 0;
-  for (let i = 0; i < commands.length; i++) {
-    const cmd = commands[i];
+  forEachSegment(commands, coords, (cmd, ci, curX, curY) => {
     switch (cmd) {
       case PATH_M: {
         if (subOpen) flushSubpath(false);
         subStartX = coords[ci];
         subStartY = coords[ci + 1];
-        curX = subStartX;
-        curY = subStartY;
-        subVerts.push(curX, curY);
+        subVerts.push(subStartX, subStartY);
         subOpen = true;
-        ci += 2;
         break;
       }
-      case PATH_L: {
-        curX = coords[ci];
-        curY = coords[ci + 1];
-        subVerts.push(curX, curY);
-        ci += 2;
+      case PATH_L:
+        subVerts.push(coords[ci], coords[ci + 1]);
         break;
-      }
-      case PATH_C: {
-        const x1 = coords[ci], y1 = coords[ci + 1];
-        const x2 = coords[ci + 2], y2 = coords[ci + 3];
-        const x3 = coords[ci + 4], y3 = coords[ci + 5];
-        flattenCubic(curX, curY, x1, y1, x2, y2, x3, y3, tolerance, subVerts);
-        curX = x3;
-        curY = y3;
-        ci += 6;
+      case PATH_C:
+        flattenCubic(
+          curX,
+          curY,
+          coords[ci],
+          coords[ci + 1],
+          coords[ci + 2],
+          coords[ci + 3],
+          coords[ci + 4],
+          coords[ci + 5],
+          tolerance,
+          subVerts
+        );
         break;
-      }
-      case PATH_Q: {
-        const x1 = coords[ci], y1 = coords[ci + 1];
-        const x2 = coords[ci + 2], y2 = coords[ci + 3];
-        flattenQuadratic(curX, curY, x1, y1, x2, y2, tolerance, subVerts);
-        curX = x2;
-        curY = y2;
-        ci += 4;
+      case PATH_Q:
+        flattenQuadratic(
+          curX,
+          curY,
+          coords[ci],
+          coords[ci + 1],
+          coords[ci + 2],
+          coords[ci + 3],
+          tolerance,
+          subVerts
+        );
         break;
-      }
-      case PATH_Z: {
+      case PATH_Z:
         flushSubpath(true);
-        curX = subStartX;
-        curY = subStartY;
         break;
-      }
       default:
         throw new Error(`pointInPath: unknown command ${cmd}`);
     }
-  }
+  });
   if (subOpen) flushSubpath(false);
   return fillRule === "evenodd" ? (crossings & 1) === 1 : winding !== 0;
 }
@@ -334,7 +152,6 @@ function polylineWithinThreshold(path, px, py, t2, tolerance) {
   const { commands, coords } = path;
   if (commands.length === 0) return false;
   let subStartX = 0, subStartY = 0;
-  let curX = 0, curY = 0;
   let subVerts = [];
   let subOpen = false;
   const checkSegments = (closed) => {
@@ -346,62 +163,66 @@ function polylineWithinThreshold(path, px, py, t2, tolerance) {
     }
     return false;
   };
-  let ci = 0;
-  for (let i = 0; i < commands.length; i++) {
-    const cmd = commands[i];
+  let hit = false;
+  forEachSegment(commands, coords, (cmd, ci, curX, curY) => {
     switch (cmd) {
       case PATH_M: {
         if (subOpen) {
-          if (checkSegments(false)) return true;
+          if (checkSegments(false)) {
+            hit = true;
+            return false;
+          }
           subVerts = [];
         }
         subStartX = coords[ci];
         subStartY = coords[ci + 1];
-        curX = subStartX;
-        curY = subStartY;
-        subVerts.push(curX, curY);
+        subVerts.push(subStartX, subStartY);
         subOpen = true;
-        ci += 2;
         break;
       }
-      case PATH_L: {
-        curX = coords[ci];
-        curY = coords[ci + 1];
-        subVerts.push(curX, curY);
-        ci += 2;
+      case PATH_L:
+        subVerts.push(coords[ci], coords[ci + 1]);
         break;
-      }
-      case PATH_C: {
-        const x1 = coords[ci], y1 = coords[ci + 1];
-        const x2 = coords[ci + 2], y2 = coords[ci + 3];
-        const x3 = coords[ci + 4], y3 = coords[ci + 5];
-        flattenCubic(curX, curY, x1, y1, x2, y2, x3, y3, tolerance, subVerts);
-        curX = x3;
-        curY = y3;
-        ci += 6;
+      case PATH_C:
+        flattenCubic(
+          curX,
+          curY,
+          coords[ci],
+          coords[ci + 1],
+          coords[ci + 2],
+          coords[ci + 3],
+          coords[ci + 4],
+          coords[ci + 5],
+          tolerance,
+          subVerts
+        );
         break;
-      }
-      case PATH_Q: {
-        const x1 = coords[ci], y1 = coords[ci + 1];
-        const x2 = coords[ci + 2], y2 = coords[ci + 3];
-        flattenQuadratic(curX, curY, x1, y1, x2, y2, tolerance, subVerts);
-        curX = x2;
-        curY = y2;
-        ci += 4;
+      case PATH_Q:
+        flattenQuadratic(
+          curX,
+          curY,
+          coords[ci],
+          coords[ci + 1],
+          coords[ci + 2],
+          coords[ci + 3],
+          tolerance,
+          subVerts
+        );
         break;
-      }
-      case PATH_Z: {
-        if (checkSegments(true)) return true;
+      case PATH_Z:
+        if (checkSegments(true)) {
+          hit = true;
+          return false;
+        }
         subVerts = [];
         subOpen = false;
-        curX = subStartX;
-        curY = subStartY;
         break;
-      }
       default:
         throw new Error(`strokeHitTest: unknown command ${cmd}`);
     }
-  }
+    return true;
+  });
+  if (hit) return true;
   if (subOpen && checkSegments(false)) return true;
   return false;
 }
@@ -609,7 +430,81 @@ function scalePolygon(path, src, dst) {
   return transformPath(path, m);
 }
 
-// src/interactions/actions/resize/geometry.ts
+// src/core/geometry/unionBounds.ts
+function unionBounds(poses) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let any = false;
+  for (const p of poses) {
+    any = true;
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    const right = p.x + p.width;
+    const bottom = p.y + p.height;
+    if (right > maxX) maxX = right;
+    if (bottom > maxY) maxY = bottom;
+  }
+  if (!any) return null;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function axisAlignedBounds(b) {
+  const rotation = b.rotation;
+  if (!rotation) {
+    return { x: b.x, y: b.y, width: b.width, height: b.height };
+  }
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const cx = b.x + b.width / 2;
+  const cy = b.y + b.height / 2;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const corners = [
+    [b.x, b.y],
+    [b.x + b.width, b.y],
+    [b.x + b.width, b.y + b.height],
+    [b.x, b.y + b.height]
+  ];
+  for (const [px, py] of corners) {
+    const dx = px - cx;
+    const dy = py - cy;
+    const rx = cx + dx * cos - dy * sin;
+    const ry = cy + dx * sin + dy * cos;
+    if (rx < minX) minX = rx;
+    if (rx > maxX) maxX = rx;
+    if (ry < minY) minY = ry;
+    if (ry > maxY) maxY = ry;
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function unionAABB(parts) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let any = false;
+  for (const part of parts) {
+    if (!part) continue;
+    const b = axisAlignedBounds(part);
+    any = true;
+    if (b.x < minX) minX = b.x;
+    if (b.y < minY) minY = b.y;
+    const right = b.x + b.width;
+    const bottom = b.y + b.height;
+    if (right > maxX) maxX = right;
+    if (bottom > maxY) maxY = bottom;
+  }
+  if (!any) return null;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+
+// src/core/geometry/poseDescriptor.ts
+function poseDescriptorForNode(descriptor, node) {
+  return descriptor.forNode?.(node) ?? descriptor;
+}
 function aabbIntersectsRect(b, r) {
   return b.x < r.x + r.width && b.x + b.width > r.x && b.y < r.y + r.height && b.y + b.height > r.y;
 }
@@ -626,6 +521,7 @@ var RECT_POSE_DESCRIPTOR = {
       height: p.height * sy
     };
   },
+  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height }),
   translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),
   intersectsRect: (p, r) => aabbIntersectsRect(p, r),
   lerp: (a, b, t) => ({
@@ -634,7 +530,8 @@ var RECT_POSE_DESCRIPTOR = {
     y: a.y + (b.y - a.y) * t,
     width: a.width + (b.width - a.width) * t,
     height: a.height + (b.height - a.height) * t
-  })
+  }),
+  withRotation: (p, rotation) => ({ ...p, rotation })
 };
 var ROTATED_POSE_DESCRIPTOR = {
   getBounds: RECT_POSE_DESCRIPTOR.getBounds,
@@ -642,7 +539,9 @@ var ROTATED_POSE_DESCRIPTOR = {
   translate: RECT_POSE_DESCRIPTOR.translate,
   intersectsRect: RECT_POSE_DESCRIPTOR.intersectsRect,
   lerp: RECT_POSE_DESCRIPTOR.lerp,
-  getRotation: (p) => p.rotation
+  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height, rotation: 0 }),
+  getRotation: (p) => p.rotation,
+  withRotation: (p, rotation) => ({ ...p, rotation })
 };
 function remapRotatedLeaf(pose, src, dst) {
   const sx = src.width === 0 ? 1 : dst.width / src.width;
@@ -666,22 +565,24 @@ function remapRotatedLeaf(pose, src, dst) {
     rotation
   };
 }
+function visualBoundsViaDescriptor(pose, geometry) {
+  const b = geometry.getBounds(pose);
+  const rotation = geometry.getRotation?.(pose) ?? b.rotation ?? 0;
+  return axisAlignedBounds({ x: b.x, y: b.y, width: b.width, height: b.height, rotation });
+}
+function translatePoseViaDescriptor(pose, dx, dy, geometry) {
+  if (geometry.translate) return geometry.translate(pose, dx, dy);
+  const src = geometry.getBounds(pose);
+  const dst = { x: src.x + dx, y: src.y + dy, width: src.width, height: src.height };
+  return geometry.remapBounds(pose, src, dst);
+}
 var pathPoseDescriptor = {
   getBounds: (path) => boundsOfPath(path),
-  remapBounds: (path, src, dst) => {
-    const sx = src.width === 0 ? 0 : dst.width / src.width;
-    const sy = src.height === 0 ? 0 : dst.height / src.height;
-    if (path.kind === "rect") {
-      return {
-        kind: "rect",
-        x: dst.x + (path.x - src.x) * sx,
-        y: dst.y + (path.y - src.y) * sy,
-        width: path.width * sx,
-        height: path.height * sy
-      };
-    }
-    return remapPolygon(path, src, dst, sx, sy);
-  },
+  remapBounds: (path, src, dst) => transformPath(
+    path,
+    boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height)
+  ),
+  fromBounds: (b) => ({ kind: "rect", x: b.x, y: b.y, width: b.width, height: b.height }),
   translate: (path, dx, dy) => translatePath(path, dx, dy),
   // WHY: AABB pre-test is cheap; only fall through to per-corner pointInPath
   //      when the rect is fully inside the AABB (silhouette test).
@@ -718,25 +619,20 @@ var pathPoseDescriptor = {
   // so the rotate cursor doesn't appear without a working interaction.
   supportsRotation: () => false
 };
-function remapPolygon(path, src, dst, sx, sy) {
-  const next = new Float32Array(path.coords.length);
-  const { commands, coords } = path;
-  forEachSegment(commands, coords, (cmd, ci) => {
-    for (let k = 0, len = pathCommandCoordCount(cmd); k < len; k += 2) {
-      next[ci + k] = dst.x + (coords[ci + k] - src.x) * sx;
-      next[ci + k + 1] = dst.y + (coords[ci + k + 1] - src.y) * sy;
-    }
-  });
-  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
-}
 
 // src/interactions/actions/resize/autoPoseDescriptor.ts
 function isPathLike(p) {
   return !!p && typeof p === "object" && "kind" in p && (p.kind === "polygon" || p.kind === "rect");
 }
+function isRectPose(p) {
+  if (!p || typeof p !== "object") return false;
+  const r = p;
+  return typeof r.x === "number" && typeof r.y === "number" && typeof r.width === "number" && typeof r.height === "number";
+}
 var AUTO_POSE_DESCRIPTOR = {
   getBounds: (p) => isPathLike(p) ? pathPoseDescriptor.getBounds(p) : RECT_POSE_DESCRIPTOR.getBounds(p),
   remapBounds: (p, src, dst) => isPathLike(p) ? pathPoseDescriptor.remapBounds(p, src, dst) : RECT_POSE_DESCRIPTOR.remapBounds(p, src, dst),
+  fromBounds: (b, template) => isPathLike(template) ? pathPoseDescriptor.fromBounds(b, template) : RECT_POSE_DESCRIPTOR.fromBounds(b, template),
   translate: (p, dx, dy) => isPathLike(p) ? pathPoseDescriptor.translate(p, dx, dy) : RECT_POSE_DESCRIPTOR.translate(p, dx, dy),
   intersectsRect: (p, rect) => isPathLike(p) ? pathPoseDescriptor.intersectsRect(p, rect) : RECT_POSE_DESCRIPTOR.intersectsRect(p, rect),
   getRotation: (p) => {
@@ -748,116 +644,10 @@ var AUTO_POSE_DESCRIPTOR = {
   // Everything else flows through `wrapWithPoseRotation`'s x/y/w/h gate at
   // paint time, so report `true` and let the wrapper no-op for poses
   // missing AABB fields.
-  supportsRotation: (p) => !isPathLike(p)
-};
-
-// src/interactions/gestures/shared/strategies/grid.ts
-var RECT_ORIGIN_PROJECTION = {
-  getOrigin: (p) => ({ x: p.x, y: p.y }),
-  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy })
-};
-var AUTO_ORIGIN_PROJECTION = {
-  getOrigin: (p) => {
-    if (isPathLike(p)) {
-      const b = boundsOfPath(p);
-      return { x: b.x, y: b.y };
-    }
-    const r = p;
-    return { x: r.x, y: r.y };
-  },
-  translate: (p, dx, dy) => {
-    if (isPathLike(p)) return translatePath(p, dx, dy);
-    const r = p;
-    return { ...r, x: r.x + dx, y: r.y + dy };
-  }
+  supportsRotation: (p) => !isPathLike(p),
+  withRotation: (p, rotation) => isPathLike(p) ? p : { ...p, rotation }
 };
-function gridSnapStrategy(spacing, arg) {
-  const isOpts = typeof arg === "object" && arg !== null && ("origin" in arg || "debug" in arg || "unitSystem" in arg) && !("base" in arg);
-  const optsArg = isOpts ? arg : null;
-  const unitSystem = optsArg ? optsArg.unitSystem : arg;
-  const proj = optsArg && optsArg.origin ? optsArg.origin : AUTO_ORIGIN_PROJECTION;
-  const debug = optsArg ? optsArg.debug : void 0;
-  const c = resolveUnit(spacing, unitSystem);
-  return {
-    snap(pose) {
-      const o = proj.getOrigin(pose);
-      const sx = Math.round(o.x / c) * c;
-      const sy = Math.round(o.y / c) * c;
-      debug?.recordSnapCandidate({ x: sx, y: sy }, true);
-      return proj.translate(pose, sx - o.x, sy - o.y);
-    }
-  };
-}
-function pointToGridCell(point, spacing, unitSystem, origin = { x: 0, y: 0 }) {
-  const s = resolveUnit(spacing, unitSystem);
-  return {
-    col: Math.floor((point.x - origin.x) / s),
-    row: Math.floor((point.y - origin.y) / s)
-  };
-}
-
-// src/core/viewport/pxExtent.ts
-var MIN_SCALE = 1e-9;
-function pxExtent(px, scale) {
-  return {
-    x: px / Math.max(MIN_SCALE, Math.abs(scale.x)),
-    y: px / Math.max(MIN_SCALE, Math.abs(scale.y))
-  };
-}
-function scaleDelta(dx, dy, scale) {
-  return { x: dx * scale.x, y: dy * scale.y };
-}
-function withinPxBox(dx, dy, px, scale) {
-  const s = scaleDelta(dx, dy, scale);
-  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;
-}
-function withinPxRadius(dx, dy, px, scale) {
-  const s = scaleDelta(dx, dy, scale);
-  return s.x * s.x + s.y * s.y <= px * px;
-}
-
-// src/interactions/gestures/shared/strategies/guides.ts
-var DEFAULT_GUIDE_TOLERANCE_PX = 6;
-function guideSnapStrategy(getGuides, options = {}) {
-  const tolerance = options.tolerance ?? DEFAULT_GUIDE_TOLERANCE_PX;
-  const getView = options.getView;
-  const proj = options.origin ?? RECT_ORIGIN_PROJECTION;
-  return {
-    snap(pose) {
-      const guides = getGuides();
-      if (guides.length === 0) return null;
-      const tol = getView ? pxExtent(tolerance, getView().scale) : { x: tolerance, y: tolerance };
-      const o = proj.getOrigin(pose);
-      let bestDx = 0;
-      let bestAbsDx = Infinity;
-      let bestDy = 0;
-      let bestAbsDy = Infinity;
-      for (const g of guides) {
-        if (g.axis === "x") {
-          const d = g.offset - o.x;
-          const ad = Math.abs(d);
-          if (ad <= tol.x && ad < bestAbsDx) {
-            bestAbsDx = ad;
-            bestDx = d;
-          }
-        } else {
-          const d = g.offset - o.y;
-          const ad = Math.abs(d);
-          if (ad <= tol.y && ad < bestAbsDy) {
-            bestAbsDy = ad;
-            bestDy = d;
-          }
-        }
-      }
-      if (bestAbsDx === Infinity && bestAbsDy === Infinity) return null;
-      const dx = bestAbsDx === Infinity ? 0 : bestDx;
-      const dy = bestAbsDy === Infinity ? 0 : bestDy;
-      if (dx === 0 && dy === 0) return null;
-      return proj.translate(pose, dx, dy);
-    }
-  };
-}
 
-export { AUTO_POSE_DESCRIPTOR, DEFAULT_FLATTEN_TOLERANCE, DEFAULT_GUIDE_TOLERANCE_PX, IMPERIAL_INCHES, METRIC_MM, PIXELS, PathBuilder, RECT_ORIGIN_PROJECTION, RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR, boundsOfPath, ellipsePath, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, formatUnit, gridSnapStrategy, guideSnapStrategy, isPathLike, linePath, pathPoseDescriptor, pointInPath, pointToGridCell, polygonFromPoints, polylineFromPoints, pxExtent, rectPath, regularPolygonPath, remapRotatedLeaf, resolveUnit, scaleDelta, scalePathToBounds, starPath, strokeHitTest, transformPath, translatePath, translatePolygonInPlace, withinPxBox, withinPxRadius };
-//# sourceMappingURL=chunk-WPM42WJP.js.map
-//# sourceMappingURL=chunk-WPM42WJP.js.map
+export { AUTO_POSE_DESCRIPTOR, PathBuilder, RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR, aabbIntersectsRect, axisAlignedBounds, boundsOfPath, ellipsePath, isPathLike, isRectPose, linePath, pathPoseDescriptor, pointInPath, polygonFromPoints, polylineFromPoints, poseDescriptorForNode, rectPath, regularPolygonPath, remapRotatedLeaf, scalePathToBounds, starPath, strokeHitTest, transformPath, translatePath, translatePolygonInPlace, translatePoseViaDescriptor, unionAABB, unionBounds, visualBoundsViaDescriptor };
+//# sourceMappingURL=chunk-3LPQ2XZG.js.map
+//# sourceMappingURL=chunk-3LPQ2XZG.js.map