@weasel-js/core 1.7.0 → 1.7.2

package/dist/chunk-L5YNZYEG.js

@@ -1,648 +0,0 @@
-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/geometry/path.ts
-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 seen = false;
-  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;
-  };
-  forEachSegment(commands, coords, (cmd, ci, px, py) => {
-    switch (cmd) {
-      case PATH_M:
-      case PATH_L: {
-        include(coords[ci], coords[ci + 1]);
-        break;
-      }
-      case PATH_C: {
-        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);
-        break;
-      }
-      case PATH_Q: {
-        const qx2 = coords[ci + 2], qy2 = coords[ci + 3];
-        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);
-        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 };
-}
-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 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;
-  };
-  forEachSegment(commands, coords, (cmd, ci, curX, curY) => {
-    switch (cmd) {
-      case PATH_M: {
-        if (subOpen) flushSubpath(false);
-        subStartX = coords[ci];
-        subStartY = coords[ci + 1];
-        subVerts.push(subStartX, subStartY);
-        subOpen = true;
-        break;
-      }
-      case PATH_L:
-        subVerts.push(coords[ci], coords[ci + 1]);
-        break;
-      case PATH_C:
-        flattenCubic(
-          curX,
-          curY,
-          coords[ci],
-          coords[ci + 1],
-          coords[ci + 2],
-          coords[ci + 3],
-          coords[ci + 4],
-          coords[ci + 5],
-          tolerance,
-          subVerts
-        );
-        break;
-      case PATH_Q:
-        flattenQuadratic(
-          curX,
-          curY,
-          coords[ci],
-          coords[ci + 1],
-          coords[ci + 2],
-          coords[ci + 3],
-          tolerance,
-          subVerts
-        );
-        break;
-      case PATH_Z:
-        flushSubpath(true);
-        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 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 hit = false;
-  forEachSegment(commands, coords, (cmd, ci, curX, curY) => {
-    switch (cmd) {
-      case PATH_M: {
-        if (subOpen) {
-          if (checkSegments(false)) {
-            hit = true;
-            return false;
-          }
-          subVerts = [];
-        }
-        subStartX = coords[ci];
-        subStartY = coords[ci + 1];
-        subVerts.push(subStartX, subStartY);
-        subOpen = true;
-        break;
-      }
-      case PATH_L:
-        subVerts.push(coords[ci], coords[ci + 1]);
-        break;
-      case PATH_C:
-        flattenCubic(
-          curX,
-          curY,
-          coords[ci],
-          coords[ci + 1],
-          coords[ci + 2],
-          coords[ci + 3],
-          coords[ci + 4],
-          coords[ci + 5],
-          tolerance,
-          subVerts
-        );
-        break;
-      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)) {
-          hit = true;
-          return false;
-        }
-        subVerts = [];
-        subOpen = false;
-        break;
-      default:
-        throw new Error(`strokeHitTest: unknown command ${cmd}`);
-    }
-    return true;
-  });
-  if (hit) return true;
-  if (subOpen && checkSegments(false)) return true;
-  return false;
-}
-
-// 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 polylineFromPoints(points) {
-  const b = new PathBuilder();
-  const first = points[0];
-  if (!first) return rectPath(0, 0, 0, 0);
-  b.moveTo(first.x, first.y);
-  for (let i = 1; i < points.length; i++) {
-    const p = points[i];
-    if (p) b.lineTo(p.x, p.y);
-  }
-  return b.build();
-}
-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;
-  forEachSegment(commands, coords, (cmd, ci) => {
-    for (let k = 0, len = pathCommandCoordCount(cmd); k < len; k += 2) {
-      next[ci + k] = coords[ci + k] + dx;
-      next[ci + k + 1] = coords[ci + k + 1] + dy;
-    }
-  });
-  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
-}
-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);
-}
-
-// 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;
-}
-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
-    };
-  },
-  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) => ({
-    ...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
-  }),
-  // `Bounds` carries an optional `rotation`, and `withRotation` writes into
-  // it — so reading it back has to be the same channel, or a pose reports
-  // itself unrotated to `useResize` and to port placement while painting
-  // rotated.
-  getRotation: (p) => p.rotation ?? 0,
-  withRotation: (p, rotation) => ({ ...p, rotation })
-};
-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,
-  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;
-  const sy = src.height === 0 ? 1 : dst.height / src.height;
-  const theta = pose.rotation ?? 0;
-  const cos = Math.cos(theta);
-  const sin = Math.sin(theta);
-  const ux = sx * cos, uy = sy * sin;
-  const vx = -sx * sin, vy = sy * cos;
-  const width = pose.width * Math.hypot(ux, uy);
-  const height = pose.height * Math.hypot(vx, vy);
-  const rotation = Math.atan2(uy, ux);
-  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;
-  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;
-  return {
-    ...pose,
-    x: cxNew - width / 2,
-    y: cyNew - height / 2,
-    width,
-    height,
-    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) => 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).
-  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
-};
-
-// 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) => {
-    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),
-  withRotation: (p, rotation) => isPathLike(p) ? p : { ...p, rotation }
-};
-
-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, translatePoseViaDescriptor, unionAABB, unionBounds, visualBoundsViaDescriptor };
-//# sourceMappingURL=chunk-L5YNZYEG.js.map
-//# sourceMappingURL=chunk-L5YNZYEG.js.map