@weasel-js/core 0.5.0

package/dist/chunk-CQNKCG34.js

@@ -0,0 +1,831 @@
+import { elevateQuadraticToCubic, cubicBounds, transformCoords, boxToBox } 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/features/paths/types.ts
+var PATH_M = 0;
+var PATH_L = 1;
+var PATH_C = 2;
+var PATH_Q = 3;
+var PATH_Z = 4;
+var PATH_CMD_LENGTHS = [2, 2, 6, 4, 0];
+function boundsOfPath(path) {
+  if (path.kind === "rect") return path;
+  const { commands, coords } = path;
+  if (commands.length === 0) {
+    return { kind: "rect", x: 0, y: 0, width: 0, height: 0 };
+  }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let ci = 0;
+  let seen = false;
+  let px = 0, py = 0;
+  const include = (x, y) => {
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+    seen = true;
+  };
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    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;
+        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);
+        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 [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:
+        break;
+      default:
+        throw new Error(`boundsOfPath: unknown command ${cmd}`);
+    }
+  }
+  if (!seen) return { kind: "rect", x: 0, y: 0, width: 0, height: 0 };
+  return { kind: "rect", x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+
+// src/features/paths/flatten.ts
+var DEFAULT_FLATTEN_TOLERANCE = 0.5;
+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) {
+  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;
+  flattenCubic(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out);
+  flattenCubic(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out);
+}
+function flattenQuadratic(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;
+  flattenQuadratic(x0, y0, x01, y01, x012, y012, tolerance, out);
+  flattenQuadratic(x012, y012, x12, y12, x2, y2, tolerance, out);
+}
+function flattenCubicWithArcLen(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut) {
+  return flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, 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) {
+  return flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, 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;
+}
+
+// src/features/paths/hitTest.ts
+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;
+  }
+  return pointInPolygonPath(path, x, y, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+}
+function pointInPolygonPath(path, x, y, tolerance) {
+  const { commands, coords, fillRule } = path;
+  if (commands.length === 0) return false;
+  let crossings = 0;
+  let winding = 0;
+  let subStartX = 0, subStartY = 0;
+  let curX = 0, curY = 0;
+  let subVerts = [];
+  let subOpen = false;
+  const flushSubpath = (closed) => {
+    if (closed && subVerts.length >= 4) {
+      subVerts.push(subStartX, subStartY);
+      for (let i = 0; i < subVerts.length - 2; i += 2) {
+        const ax = subVerts[i], ay = subVerts[i + 1];
+        const bx = subVerts[i + 2], by = subVerts[i + 3];
+        if (segmentCrossesRayRight(x, y, ax, ay, bx, by)) {
+          crossings++;
+          if (ay <= y && by > y) winding++;
+          else if (by <= y && ay > y) winding--;
+        }
+      }
+    }
+    subVerts = [];
+    subOpen = false;
+  };
+  let ci = 0;
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    switch (cmd) {
+      case PATH_M: {
+        if (subOpen) flushSubpath(false);
+        subStartX = coords[ci];
+        subStartY = coords[ci + 1];
+        curX = subStartX;
+        curY = subStartY;
+        subVerts.push(curX, curY);
+        subOpen = true;
+        ci += 2;
+        break;
+      }
+      case PATH_L: {
+        curX = coords[ci];
+        curY = coords[ci + 1];
+        subVerts.push(curX, curY);
+        ci += 2;
+        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;
+        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;
+        break;
+      }
+      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;
+}
+function segmentCrossesRayRight(x, y, ax, ay, bx, by) {
+  if (ay > y === by > y) return false;
+  const xCross = ax + (y - ay) / (by - ay) * (bx - ax);
+  return x < xCross;
+}
+function strokeHitTest(path, x, y, threshold, opts = {}) {
+  const t2 = threshold * threshold;
+  if (path.kind === "rect") {
+    const { x: rx, y: ry, width: w, height: h } = path;
+    return pointSegmentDist2(x, y, rx, ry, rx + w, ry) <= t2 || pointSegmentDist2(x, y, rx + w, ry, rx + w, ry + h) <= t2 || pointSegmentDist2(x, y, rx + w, ry + h, rx, ry + h) <= t2 || pointSegmentDist2(x, y, rx, ry + h, rx, ry) <= t2;
+  }
+  return polylineWithinThreshold(path, x, y, t2, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+}
+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) => {
+    if (closed && subVerts.length >= 4) subVerts.push(subStartX, subStartY);
+    for (let i = 0; i < subVerts.length - 2; i += 2) {
+      if (pointSegmentDist2(px, py, subVerts[i], subVerts[i + 1], subVerts[i + 2], subVerts[i + 3]) <= t2) {
+        return true;
+      }
+    }
+    return false;
+  };
+  let ci = 0;
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    switch (cmd) {
+      case PATH_M: {
+        if (subOpen) {
+          if (checkSegments(false)) return true;
+          subVerts = [];
+        }
+        subStartX = coords[ci];
+        subStartY = coords[ci + 1];
+        curX = subStartX;
+        curY = subStartY;
+        subVerts.push(curX, curY);
+        subOpen = true;
+        ci += 2;
+        break;
+      }
+      case PATH_L: {
+        curX = coords[ci];
+        curY = coords[ci + 1];
+        subVerts.push(curX, curY);
+        ci += 2;
+        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;
+        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;
+        break;
+      }
+      case PATH_Z: {
+        if (checkSegments(true)) return true;
+        subVerts = [];
+        subOpen = false;
+        curX = subStartX;
+        curY = subStartY;
+        break;
+      }
+      default:
+        throw new Error(`strokeHitTest: unknown command ${cmd}`);
+    }
+  }
+  if (subOpen && checkSegments(false)) return true;
+  return false;
+}
+function pointSegmentDist2(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const len2 = dx * dx + dy * dy;
+  if (len2 === 0) {
+    const ex2 = px - ax, ey2 = py - ay;
+    return ex2 * ex2 + ey2 * ey2;
+  }
+  let t = ((px - ax) * dx + (py - ay) * dy) / len2;
+  if (t < 0) t = 0;
+  else if (t > 1) t = 1;
+  const cx = ax + t * dx;
+  const cy = ay + t * dy;
+  const ex = px - cx, ey = py - cy;
+  return ex * ex + ey * ey;
+}
+
+// src/features/paths/builder.ts
+var PathBuilder = class _PathBuilder {
+  cmds = [];
+  xs = [];
+  fillRule = "nonzero";
+  /** Seed a builder with an existing `PolygonPath`. Useful for extending
+   *  an in-flight path with another segment (e.g. appending a cubic to
+   *  the end of a curve in response to a user action) without hand-
+   *  reaching into the `commands` / `coords` typed arrays.
+   *
+   *  ```ts
+   *  const next = PathBuilder.fromPath(current).curveTo(...).build();
+   *  ```
+   */
+  static fromPath(path) {
+    const b = new _PathBuilder();
+    b.cmds = Array.from(path.commands);
+    b.xs = Array.from(path.coords);
+    b.fillRule = path.fillRule;
+    return b;
+  }
+  setFillRule(rule) {
+    this.fillRule = rule;
+    return this;
+  }
+  moveTo(x, y) {
+    this.cmds.push(PATH_M);
+    this.xs.push(x, y);
+    return this;
+  }
+  lineTo(x, y) {
+    this.cmds.push(PATH_L);
+    this.xs.push(x, y);
+    return this;
+  }
+  /** Cubic bezier to (x, y) with control points (x1, y1) and (x2, y2). */
+  curveTo(x1, y1, x2, y2, x, y) {
+    this.cmds.push(PATH_C);
+    this.xs.push(x1, y1, x2, y2, x, y);
+    return this;
+  }
+  /** Quadratic bezier to (x, y) with control point (x1, y1). */
+  quadTo(x1, y1, x, y) {
+    this.cmds.push(PATH_Q);
+    this.xs.push(x1, y1, x, y);
+    return this;
+  }
+  close() {
+    this.cmds.push(PATH_Z);
+    return this;
+  }
+  build() {
+    return {
+      kind: "polygon",
+      commands: new Uint8Array(this.cmds),
+      coords: new Float32Array(this.xs),
+      fillRule: this.fillRule
+    };
+  }
+};
+function rectPath(x, y, width, height) {
+  return { kind: "rect", x, y, width, height };
+}
+function polygonFromPoints(points, opts = {}) {
+  if (points.length === 0) {
+    return {
+      kind: "polygon",
+      commands: new Uint8Array(),
+      coords: new Float32Array(),
+      fillRule: opts.fillRule ?? "nonzero"
+    };
+  }
+  const b = new PathBuilder();
+  if (opts.fillRule) b.setFillRule(opts.fillRule);
+  b.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) b.lineTo(points[i].x, points[i].y);
+  b.close();
+  return b.build();
+}
+var ELLIPSE_KAPPA = 0.5522847498307936;
+function ellipsePath(bounds) {
+  const cx = bounds.x + bounds.width / 2;
+  const cy = bounds.y + bounds.height / 2;
+  const rx = bounds.width / 2;
+  const ry = bounds.height / 2;
+  const ox = rx * ELLIPSE_KAPPA;
+  const oy = ry * ELLIPSE_KAPPA;
+  const b = new PathBuilder();
+  b.moveTo(cx + rx, cy);
+  b.curveTo(cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry);
+  b.curveTo(cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy);
+  b.curveTo(cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry);
+  b.curveTo(cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy);
+  b.close();
+  return b.build();
+}
+function regularPolygonPath(center, radius, sides, rotation = 0) {
+  const b = new PathBuilder();
+  for (let i = 0; i < sides; i++) {
+    const a = rotation + i / sides * Math.PI * 2;
+    const x = center.x + radius * Math.cos(a);
+    const y = center.y + radius * Math.sin(a);
+    if (i === 0) b.moveTo(x, y);
+    else b.lineTo(x, y);
+  }
+  b.close();
+  return b.build();
+}
+function starPath(center, outerRadius, points = 5, innerRadius = outerRadius / 2, rotation = 0) {
+  const b = new PathBuilder();
+  const n = points * 2;
+  for (let i = 0; i < n; i++) {
+    const a = rotation + i / n * Math.PI * 2;
+    const r = i % 2 === 0 ? outerRadius : innerRadius;
+    const x = center.x + r * Math.cos(a);
+    const y = center.y + r * Math.sin(a);
+    if (i === 0) b.moveTo(x, y);
+    else b.lineTo(x, y);
+  }
+  b.close();
+  return b.build();
+}
+function linePath(a, b) {
+  const pb = new PathBuilder();
+  pb.moveTo(a.x, a.y);
+  pb.lineTo(b.x, b.y);
+  return pb.build();
+}
+function transformPath(path, m) {
+  const [a, b, c, d, e, f] = m;
+  if (path.kind === "rect") {
+    if (b === 0 && c === 0) {
+      const x0 = a * path.x + e;
+      const y0 = d * path.y + f;
+      const x1 = a * (path.x + path.width) + e;
+      const y1 = d * (path.y + path.height) + f;
+      return {
+        kind: "rect",
+        x: Math.min(x0, x1),
+        y: Math.min(y0, y1),
+        width: Math.abs(x1 - x0),
+        height: Math.abs(y1 - y0)
+      };
+    }
+    const poly = new PathBuilder().moveTo(path.x, path.y).lineTo(path.x + path.width, path.y).lineTo(path.x + path.width, path.y + path.height).lineTo(path.x, path.y + path.height).close().build();
+    return transformPolygon(poly, m);
+  }
+  return transformPolygon(path, m);
+}
+function transformPolygon(path, m) {
+  const mapped = transformCoords(path.coords, m);
+  return { ...path, coords: Float32Array.from(mapped) };
+}
+function translatePath(path, dx, dy) {
+  if (path.kind === "rect") {
+    return { kind: "rect", x: path.x + dx, y: path.y + dy, width: path.width, height: path.height };
+  }
+  return translatePolygonCopy(path, dx, dy);
+}
+function translatePolygonCopy(path, dx, dy) {
+  const next = new Float32Array(path.coords.length);
+  const { commands, coords } = path;
+  let ci = 0;
+  for (let i = 0; i < commands.length; i++) {
+    const len = COORD_COUNT[commands[i]];
+    for (let k = 0; k < len; k += 2) {
+      next[ci + k] = coords[ci + k] + dx;
+      next[ci + k + 1] = coords[ci + k + 1] + dy;
+    }
+    ci += len;
+  }
+  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
+}
+function translatePolygonInPlace(path, dx, dy) {
+  const { commands, coords } = path;
+  let ci = 0;
+  for (let i = 0; i < commands.length; i++) {
+    const len = COORD_COUNT[commands[i]];
+    for (let k = 0; k < len; k += 2) {
+      coords[ci + k] += dx;
+      coords[ci + k + 1] += dy;
+    }
+    ci += len;
+  }
+  return path;
+}
+function scalePathToBounds(path, target) {
+  if (path.kind === "rect") {
+    return { kind: "rect", x: target.x, y: target.y, width: target.width, height: target.height };
+  }
+  const src = boundsOfPath(path);
+  return scalePolygon(path, src, target);
+}
+function scalePolygon(path, src, dst) {
+  const m = boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height);
+  return transformPath(path, m);
+}
+var COORD_COUNT = {
+  [PATH_M]: 2,
+  [PATH_L]: 2,
+  [PATH_C]: 6,
+  [PATH_Q]: 4,
+  [PATH_Z]: 0
+};
+
+// src/interactions/actions/resize/geometry.ts
+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;
+}
+var RECT_POSE_DESCRIPTOR = {
+  getBounds: (p) => p,
+  remapBounds: (p, src, dst) => {
+    const sx = src.width === 0 ? 1 : dst.width / src.width;
+    const sy = src.height === 0 ? 1 : dst.height / src.height;
+    return {
+      ...p,
+      x: dst.x + (p.x - src.x) * sx,
+      y: dst.y + (p.y - src.y) * sy,
+      width: p.width * sx,
+      height: p.height * sy
+    };
+  },
+  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),
+  intersectsRect: (p, r) => aabbIntersectsRect(p, r),
+  lerp: (a, b, t) => ({
+    ...a,
+    x: a.x + (b.x - a.x) * t,
+    y: a.y + (b.y - a.y) * t,
+    width: a.width + (b.width - a.width) * t,
+    height: a.height + (b.height - a.height) * t
+  })
+};
+var ROTATED_POSE_DESCRIPTOR = {
+  getBounds: RECT_POSE_DESCRIPTOR.getBounds,
+  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds,
+  translate: RECT_POSE_DESCRIPTOR.translate,
+  intersectsRect: RECT_POSE_DESCRIPTOR.intersectsRect,
+  lerp: RECT_POSE_DESCRIPTOR.lerp,
+  getRotation: (p) => p.rotation
+};
+
+// src/features/paths/poseDescriptor.ts
+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);
+  },
+  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).
+  intersectsRect: (path, rect) => {
+    const b = boundsOfPath(path);
+    if (!aabbIntersectsRect(b, rect)) return false;
+    if (path.kind === "rect") return true;
+    if (pointInPath(path, rect.x, rect.y) || pointInPath(path, rect.x + rect.width, rect.y) || pointInPath(path, rect.x, rect.y + rect.height) || pointInPath(path, rect.x + rect.width, rect.y + rect.height)) return true;
+    return true;
+  },
+  lerp: (a, b, t) => {
+    if (a.kind === "rect" && b.kind === "rect") {
+      return {
+        kind: "rect",
+        x: a.x + (b.x - a.x) * t,
+        y: a.y + (b.y - a.y) * t,
+        width: a.width + (b.width - a.width) * t,
+        height: a.height + (b.height - a.height) * t
+      };
+    }
+    if (a.kind === "polygon" && b.kind === "polygon" && a.coords.length === b.coords.length) {
+      const next = new Float32Array(a.coords.length);
+      for (let i = 0; i < a.coords.length; i++) {
+        next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;
+      }
+      return { kind: "polygon", commands: a.commands, coords: next, fillRule: a.fillRule };
+    }
+    throw new Error("pathPoseDescriptor.lerp: incompatible path shapes");
+  },
+  // Path poses carry no x/y/width/height/rotation fields — the kit's
+  // `wrapWithPoseRotation` helper has nothing to bind a rotation to, and
+  // `remapBounds` would drop a synthetic rotation field on every commit.
+  // Returning false here hides the rotation affordance for Path consumers
+  // 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;
+  let ci = 0;
+  for (let i = 0; i < commands.length; i++) {
+    const len = COORD_COUNT2[commands[i]];
+    for (let k = 0; 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;
+    }
+    ci += len;
+  }
+  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
+}
+var COORD_COUNT2 = {
+  [PATH_M]: 2,
+  [PATH_L]: 2,
+  [PATH_C]: 6,
+  [PATH_Q]: 4,
+  [PATH_Z]: 0
+};
+
+// src/interactions/actions/resize/autoPoseDescriptor.ts
+function isPathLike(p) {
+  return !!p && typeof p === "object" && "kind" in p && (p.kind === "polygon" || p.kind === "rect");
+}
+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),
+  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) => {
+    if (isPathLike(p)) return 0;
+    const r = p.rotation;
+    return typeof r === "number" ? r : 0;
+  },
+  // Path-shaped poses can't carry rotation (see `pathPoseDescriptor`).
+  // 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 };
+  }
+};
+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/meanScale.ts
+function meanScale(s) {
+  return Math.sqrt(s.x * s.y);
+}
+
+// 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 worldTolerance = getView ? tolerance / Math.max(1e-9, meanScale(getView().scale)) : 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 <= worldTolerance && ad < bestAbsDx) {
+            bestAbsDx = ad;
+            bestDx = d;
+          }
+        } else {
+          const d = g.offset - o.y;
+          const ad = Math.abs(d);
+          if (ad <= worldTolerance && 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, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, PIXELS, PathBuilder, RECT_ORIGIN_PROJECTION, RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR, boundsOfPath, ellipsePath, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, formatUnit, gridSnapStrategy, guideSnapStrategy, linePath, meanScale, pathPoseDescriptor, pointInPath, pointToGridCell, polygonFromPoints, rectPath, regularPolygonPath, resolveUnit, scalePathToBounds, starPath, strokeHitTest, transformPath, translatePath, translatePolygonInPlace };
+//# sourceMappingURL=chunk-CQNKCG34.js.map
+//# sourceMappingURL=chunk-CQNKCG34.js.map