@weasel-js/core 1.5.1 → 1.5.2

package/dist/resize.js

@@ -1,5 +1,5 @@
-export { CORNER_ANCHORS, DEFAULT_RESIZE_BEHAVIORS, clampMinSize, cornerPoint, cornerResizeHandles, fixedCornerOf, hitCornerHandle, lockAspectWithModifier, pointSnapToGrid, snapToGrid, snapToGuides } from './chunk-XXQ6FLCJ.js';
-import './chunk-HAGOFNP5.js';
-export { AUTO_POSE_DESCRIPTOR, RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR, isPathLike, isRectPose, poseDescriptorForNode } from './chunk-3LPQ2XZG.js';
+export { CORNER_ANCHORS, DEFAULT_RESIZE_BEHAVIORS, clampMinSize, cornerPoint, cornerResizeHandles, fixedCornerOf, hitCornerHandle, lockAspectWithModifier, pointSnapToGrid, snapToGrid, snapToGuides } from './chunk-H6N2JSZ3.js';
+import './chunk-HPFJUUTF.js';
+export { AUTO_POSE_DESCRIPTOR, RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR, isPathLike, isRectPose, poseDescriptorForNode } from './chunk-L5YNZYEG.js';
 //# sourceMappingURL=resize.js.map
 //# sourceMappingURL=resize.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "Domain-agnostic 2D scene graph primitives for React: viewport math, drag/resize/insert/clone interactions, layered canvas rendering.",
   "license": "MIT",
   "author": "orochi235",
@@ -76,16 +76,16 @@
   },
   "peerDependencies": {
     "react": ">=18",
-    "@weasel-js/font": "1.5.1"
+    "@weasel-js/font": "1.5.2"
   },
   "dependencies": {
-    "@weasel-js/cursor": "1.5.1",
-    "@weasel-js/geom": "1.5.1",
-    "@weasel-js/gestures": "1.5.1",
-    "@weasel-js/history": "1.5.1",
-    "@weasel-js/paint": "1.5.1",
-    "@weasel-js/routing": "1.5.1",
-    "@weasel-js/text": "1.5.1",
+    "@weasel-js/cursor": "1.5.2",
+    "@weasel-js/geom": "1.5.2",
+    "@weasel-js/gestures": "1.5.2",
+    "@weasel-js/history": "1.5.2",
+    "@weasel-js/paint": "1.5.2",
+    "@weasel-js/routing": "1.5.2",
+    "@weasel-js/text": "1.5.2",
     "earcut": "2.2.4",
     "polygon-clipping": "^0.15.7"
   },
@@ -103,6 +103,6 @@
     "2d"
   ],
   "devDependencies": {
-    "@weasel-js/modes": "1.5.1"
+    "@weasel-js/modes": "1.5.2"
   }
 }

package/dist/chunk-3LPQ2XZG.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/features/paths/bounds.ts","../src/features/paths/hitTest.ts","../src/features/paths/builder.ts","../src/features/paths/transformPath.ts","../src/features/paths/transform.ts","../src/core/geometry/unionBounds.ts","../src/core/geometry/poseDescriptor.ts","../src/features/paths/poseDescriptor.ts","../src/interactions/actions/resize/autoPoseDescriptor.ts"],"names":["forEachSegment","pathCommandCoordCount","boxToBox"],"mappings":"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","file":"chunk-3LPQ2XZG.js","sourcesContent":["/**\n * AABB bounds of a `Path`. Returned as `RectPath` for direct reuse with the\n * rect fast path machinery (selection AABB, area-select intersection).\n *\n * `RectPath` is its own bounds — O(1). For `PolygonPath`, walk segment by\n * segment, computing the tight bound per segment:\n *\n *   - `M` / `L`: just the endpoint.\n *   - `Q`: quadratic Bezier — endpoints plus axis-aligned extrema (one\n *     possible inflection per axis).\n *   - `C`: cubic Bezier — endpoints plus axis-aligned extrema (up to two\n *     possible inflections per axis, found via the quadratic formula on\n *     the derivative).\n *\n * Control points are NOT included directly; they're used only to compute\n * extrema that actually lie on the curve. This avoids the classic \"AABB\n * extends past where the curve visibly reaches\" bug for curved paths whose\n * control points poke outside the visible extent.\n *\n * Empty paths (no commands) return a zero-size rect anchored at the\n * origin — the convention used elsewhere in the kit for missing geometry.\n */\n\nimport { cubicBounds, elevateQuadraticToCubic, forEachSegment } from '@weasel-js/geom';\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type Path,\n  type RectPath,\n} from './types';\n\n/** AABB of a `Path`, returned as a `RectPath` for direct reuse with rect-fast-path machinery. */\nexport function boundsOfPath(path: Path): RectPath {\n  if (path.kind === 'rect') return path;\n\n  const { commands, coords } = path;\n  if (commands.length === 0) {\n    return { kind: 'rect', x: 0, y: 0, width: 0, height: 0 };\n  }\n\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  let seen = false;\n\n  const include = (x: number, y: number) => {\n    if (x < minX) minX = x;\n    if (x > maxX) maxX = x;\n    if (y < minY) minY = y;\n    if (y > maxY) maxY = y;\n    seen = true;\n  };\n\n  forEachSegment(commands, coords, (cmd, ci, px, py) => {\n    switch (cmd) {\n      case PATH_M:\n      case PATH_L: {\n        include(coords[ci], coords[ci + 1]);\n        break;\n      }\n      case PATH_C: {\n        const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(\n          px, py,\n          coords[ci], coords[ci + 1],\n          coords[ci + 2], coords[ci + 3],\n          coords[ci + 4], coords[ci + 5],\n        );\n        include(bMinX, bMinY);\n        include(bMaxX, bMaxY);\n        break;\n      }\n      case PATH_Q: {\n        const qx2 = coords[ci + 2], qy2 = coords[ci + 3];\n        const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(px, py, coords[ci], coords[ci + 1], qx2, qy2);\n        const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(px, py, c1x, c1y, c2x, c2y, qx2, qy2);\n        include(bMinX, bMinY);\n        include(bMaxX, bMaxY);\n        break;\n      }\n      case PATH_Z:\n        break;\n      default:\n        throw new Error(`boundsOfPath: unknown command ${cmd}`);\n    }\n  });\n\n  if (!seen) return { kind: 'rect', x: 0, y: 0, width: 0, height: 0 };\n  return { kind: 'rect', x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n","/**\n * Point-in-path hit-testing. `RectPath` short-circuits to AABB compare\n * (O(1)). `PolygonPath` walks the command stream, flattening any bezier\n * segments to line segments, then runs ray-casting (even-odd) or\n * winding-number (non-zero) per the path's `fillRule`.\n *\n * Open subpaths (no `Z`) are skipped for filled hit-testing — they have\n * no enclosed area. For open polylines (strokes), use `strokeHitTest`\n * which computes point-to-segment distance against the flattened\n * polyline and returns true within a configurable threshold.\n */\n\nimport { forEachSegment, pointSegmentDist2 } from '@weasel-js/geom';\nimport { flattenCubic, flattenQuadratic, DEFAULT_FLATTEN_TOLERANCE } from './flatten';\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type Path,\n  type PolygonPath,\n} from './types';\n\n/** Options for `pointInPath`. */\nexport interface PointInPathOptions {\n  /** Bezier flattening tolerance in world units. Default 0.5. */\n  tolerance?: number;\n}\n\n/** Filled-region hit-test for a `Path`. Rect short-circuits to AABB; polygons run ray-cast / winding per `fillRule`. */\nexport function pointInPath(\n  path: Path,\n  x: number,\n  y: number,\n  opts: PointInPathOptions = {},\n): boolean {\n  if (path.kind === 'rect') {\n    return x >= path.x && x <= path.x + path.width && y >= path.y && y <= path.y + path.height;\n  }\n  return pointInPolygonPath(path, x, y, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);\n}\n\nfunction pointInPolygonPath(path: PolygonPath, x: number, y: number, tolerance: number): boolean {\n  const { commands, coords, fillRule } = path;\n  if (commands.length === 0) return false;\n\n  // Walk the command stream; flatten beziers into per-subpath vertex arrays.\n  // For each closed subpath, accumulate winding/crossings against (x, y).\n  let crossings = 0;\n  let winding = 0;\n\n  let subStartX = 0, subStartY = 0;\n  let subVerts: number[] = []; // flat [x, y, x, y, ...] for current subpath\n  let subOpen = false;\n\n  const flushSubpath = (closed: boolean) => {\n    if (closed && subVerts.length >= 4) {\n      // Close the subpath back to its start.\n      subVerts.push(subStartX, subStartY);\n      // Now subVerts is a closed polyline; tally crossings/winding.\n      for (let i = 0; i < subVerts.length - 2; i += 2) {\n        const ax = subVerts[i],     ay = subVerts[i + 1];\n        const bx = subVerts[i + 2], by = subVerts[i + 3];\n        if (segmentCrossesRayRight(x, y, ax, ay, bx, by)) {\n          crossings++;\n          if (ay <= y && by > y) winding++;\n          else if (by <= y && ay > y) winding--;\n        }\n      }\n    }\n    subVerts = [];\n    subOpen = false;\n  };\n\n  forEachSegment(commands, coords, (cmd, ci, curX, curY) => {\n    switch (cmd) {\n      case PATH_M: {\n        if (subOpen) flushSubpath(false);\n        subStartX = coords[ci]; subStartY = coords[ci + 1];\n        subVerts.push(subStartX, subStartY);\n        subOpen = true;\n        break;\n      }\n      case PATH_L:\n        subVerts.push(coords[ci], coords[ci + 1]);\n        break;\n      case PATH_C:\n        flattenCubic(\n          curX, curY,\n          coords[ci], coords[ci + 1],\n          coords[ci + 2], coords[ci + 3],\n          coords[ci + 4], coords[ci + 5],\n          tolerance, subVerts,\n        );\n        break;\n      case PATH_Q:\n        flattenQuadratic(\n          curX, curY,\n          coords[ci], coords[ci + 1],\n          coords[ci + 2], coords[ci + 3],\n          tolerance, subVerts,\n        );\n        break;\n      case PATH_Z:\n        flushSubpath(true);\n        break;\n      default:\n        throw new Error(`pointInPath: unknown command ${cmd}`);\n    }\n  });\n  if (subOpen) flushSubpath(false);\n\n  return fillRule === 'evenodd' ? (crossings & 1) === 1 : winding !== 0;\n}\n\n/**\n * Does the rightward horizontal ray from (x, y) cross segment (ax,ay)→(bx,by)?\n * Standard half-open rule (segments touching from above count, from below\n * don't) — avoids double-counting at shared vertices.\n */\nfunction segmentCrossesRayRight(\n  x: number, y: number,\n  ax: number, ay: number,\n  bx: number, by: number,\n): boolean {\n  if ((ay > y) === (by > y)) return false;\n  const xCross = ax + ((y - ay) / (by - ay)) * (bx - ax);\n  return x < xCross;\n}\n\n/** Options for {@link strokeHitTest}. */\nexport interface StrokeHitTestOptions {\n  /** Bezier flattening tolerance in world units. Default 0.5. */\n  tolerance?: number;\n}\n\n/**\n * Stroke-distance hit-test. Returns true when (x, y) lies within\n * `threshold` world units of the path's outline — i.e. when a stroke\n * of total width `2 * threshold` drawn along the path would cover the\n * point.\n *\n * Works for both closed and open subpaths — unlike {@link pointInPath},\n * which only tests filled regions. Use this for picking on open\n * polylines / curves and for adding stroke-clickability to closed\n * shapes (logical OR with `pointInPath` when both behaviors are\n * desired).\n *\n * `threshold` is typically the stroke's half-width plus a small slop\n * (e.g. `strokeWidth / 2 + 4`). Cap segments are approximated by the\n * threshold radius around each anchor — the test treats every flattened\n * segment as a capsule of width `2 * threshold`.\n */\nexport function strokeHitTest(\n  path: Path,\n  x: number,\n  y: number,\n  threshold: number,\n  opts: StrokeHitTestOptions = {},\n): boolean {\n  const t2 = threshold * threshold;\n  if (path.kind === 'rect') {\n    const { x: rx, y: ry, width: w, height: h } = path;\n    return (\n      pointSegmentDist2(x, y, rx, ry, rx + w, ry) <= t2\n      || pointSegmentDist2(x, y, rx + w, ry, rx + w, ry + h) <= t2\n      || pointSegmentDist2(x, y, rx + w, ry + h, rx, ry + h) <= t2\n      || pointSegmentDist2(x, y, rx, ry + h, rx, ry) <= t2\n    );\n  }\n  return polylineWithinThreshold(path, x, y, t2, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);\n}\n\nfunction polylineWithinThreshold(\n  path: PolygonPath,\n  px: number, py: number,\n  t2: number,\n  tolerance: number,\n): boolean {\n  const { commands, coords } = path;\n  if (commands.length === 0) return false;\n\n  // Reuse pointInPath's command-stream + flatten walk; check distance from\n  // (px, py) to each emitted segment instead of accumulating crossings.\n  let subStartX = 0, subStartY = 0;\n  let subVerts: number[] = [];\n  let subOpen = false;\n\n  const checkSegments = (closed: boolean): boolean => {\n    if (closed && subVerts.length >= 4) subVerts.push(subStartX, subStartY);\n    for (let i = 0; i < subVerts.length - 2; i += 2) {\n      if (pointSegmentDist2(px, py, subVerts[i], subVerts[i + 1], subVerts[i + 2], subVerts[i + 3]) <= t2) {\n        return true;\n      }\n    }\n    return false;\n  };\n\n  let hit = false;\n  forEachSegment(commands, coords, (cmd, ci, curX, curY) => {\n    switch (cmd) {\n      case PATH_M: {\n        if (subOpen) {\n          if (checkSegments(false)) { hit = true; return false; }\n          subVerts = [];\n        }\n        subStartX = coords[ci]; subStartY = coords[ci + 1];\n        subVerts.push(subStartX, subStartY);\n        subOpen = true;\n        break;\n      }\n      case PATH_L:\n        subVerts.push(coords[ci], coords[ci + 1]);\n        break;\n      case PATH_C:\n        flattenCubic(\n          curX, curY,\n          coords[ci], coords[ci + 1],\n          coords[ci + 2], coords[ci + 3],\n          coords[ci + 4], coords[ci + 5],\n          tolerance, subVerts,\n        );\n        break;\n      case PATH_Q:\n        flattenQuadratic(\n          curX, curY,\n          coords[ci], coords[ci + 1],\n          coords[ci + 2], coords[ci + 3],\n          tolerance, subVerts,\n        );\n        break;\n      case PATH_Z:\n        if (checkSegments(true)) { hit = true; return false; }\n        subVerts = [];\n        subOpen = false;\n        break;\n      default:\n        throw new Error(`strokeHitTest: unknown command ${cmd}`);\n    }\n    return true;\n  });\n  if (hit) return true;\n  if (subOpen && checkSegments(false)) return true;\n  return false;\n}\n","/**\n * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`\n * encoding behind move/line/curve/close calls and a final `build()`. Use\n * this to construct paths in tests and demos; production callers that need\n * to mutate large paths in place should reach for the raw arrays directly.\n *\n * Numeric capacity grows by doubling — typical for amortized O(1) push.\n *\n * Also exposes `rectPath` / `polygonFromPoints` shortcuts for the common\n * cases. `rectPath` returns the lighter `RectPath` subtype, not a polygon.\n */\n\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type PathFillRule,\n  type PolygonPath,\n  type RectPath,\n} from './types';\n\n/** Fluent builder for `PolygonPath`; hides the `Uint8Array`/`Float32Array` encoding behind move/line/curve/close calls. */\nexport class PathBuilder {\n  private cmds: number[] = [];\n  private xs: number[] = [];\n  private fillRule: PathFillRule = 'nonzero';\n\n  /** Seed a builder with an existing `PolygonPath`. Useful for extending\n   *  an in-flight path with another segment (e.g. appending a cubic to\n   *  the end of a curve in response to a user action) without hand-\n   *  reaching into the `commands` / `coords` typed arrays.\n   *\n   *  ```ts\n   *  const next = PathBuilder.fromPath(current).curveTo(...).build();\n   *  ```\n   */\n  static fromPath(path: PolygonPath): PathBuilder {\n    const b = new PathBuilder();\n    b.cmds = Array.from(path.commands);\n    b.xs = Array.from(path.coords);\n    b.fillRule = path.fillRule;\n    return b;\n  }\n\n  setFillRule(rule: PathFillRule): this {\n    this.fillRule = rule;\n    return this;\n  }\n\n  moveTo(x: number, y: number): this {\n    this.cmds.push(PATH_M);\n    this.xs.push(x, y);\n    return this;\n  }\n\n  lineTo(x: number, y: number): this {\n    this.cmds.push(PATH_L);\n    this.xs.push(x, y);\n    return this;\n  }\n\n  /** Cubic bezier to (x, y) with control points (x1, y1) and (x2, y2). */\n  curveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this {\n    this.cmds.push(PATH_C);\n    this.xs.push(x1, y1, x2, y2, x, y);\n    return this;\n  }\n\n  /** Quadratic bezier to (x, y) with control point (x1, y1). */\n  quadTo(x1: number, y1: number, x: number, y: number): this {\n    this.cmds.push(PATH_Q);\n    this.xs.push(x1, y1, x, y);\n    return this;\n  }\n\n  close(): this {\n    this.cmds.push(PATH_Z);\n    return this;\n  }\n\n  build(): PolygonPath {\n    return {\n      kind: 'polygon',\n      commands: new Uint8Array(this.cmds),\n      coords: new Float32Array(this.xs),\n      fillRule: this.fillRule,\n    };\n  }\n}\n\n/** Construct a `RectPath` (the fast-path subtype). */\nexport function rectPath(x: number, y: number, width: number, height: number): RectPath {\n  return { kind: 'rect', x, y, width, height };\n}\n\n/** Build an open polyline from a flat list of points — the same geometry as\n *  {@link polygonFromPoints} without the closing edge. A freehand stroke and a\n *  measurement line want this; a region wants the closed one. */\nexport function polylineFromPoints(\n  points: readonly { x: number; y: number }[],\n): PolygonPath | RectPath {\n  const b = new PathBuilder();\n  const first = points[0];\n  if (!first) return rectPath(0, 0, 0, 0);\n  b.moveTo(first.x, first.y);\n  for (let i = 1; i < points.length; i++) {\n    const p = points[i];\n    if (p) b.lineTo(p.x, p.y);\n  }\n  return b.build();\n}\n\n/** Build a closed polygon from a flat list of points. */\nexport function polygonFromPoints(\n  points: readonly { x: number; y: number }[],\n  opts: { fillRule?: PathFillRule } = {},\n): PolygonPath {\n  if (points.length === 0) {\n    return {\n      kind: 'polygon',\n      commands: new Uint8Array(),\n      coords: new Float32Array(),\n      fillRule: opts.fillRule ?? 'nonzero',\n    };\n  }\n  const b = new PathBuilder();\n  if (opts.fillRule) b.setFillRule(opts.fillRule);\n  b.moveTo(points[0].x, points[0].y);\n  for (let i = 1; i < points.length; i++) b.lineTo(points[i].x, points[i].y);\n  b.close();\n  return b.build();\n}\n\n/** Cubic-Bezier kappa for circular-quadrant approximation (<1% max error). */\nconst ELLIPSE_KAPPA = 0.5522847498307936;\n\n/** Closed ellipse inscribed in `bounds`, as a 4-cubic-Bezier `PolygonPath`.\n *  Matches the geometry `useEllipseTool`'s overlay paints. */\nexport function ellipsePath(\n  bounds: { x: number; y: number; width: number; height: number },\n): PolygonPath {\n  const cx = bounds.x + bounds.width / 2;\n  const cy = bounds.y + bounds.height / 2;\n  const rx = bounds.width / 2;\n  const ry = bounds.height / 2;\n  const ox = rx * ELLIPSE_KAPPA;\n  const oy = ry * ELLIPSE_KAPPA;\n  const b = new PathBuilder();\n  b.moveTo(cx + rx, cy);\n  b.curveTo(cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry);\n  b.curveTo(cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy);\n  b.curveTo(cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry);\n  b.curveTo(cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy);\n  b.close();\n  return b.build();\n}\n\n/** Closed regular n-gon centered at `center`, circumscribed by `radius`.\n *  `rotation` is in radians; default 0 puts the first vertex on the +x axis. */\nexport function regularPolygonPath(\n  center: { x: number; y: number },\n  radius: number,\n  sides: number,\n  rotation = 0,\n): PolygonPath {\n  const b = new PathBuilder();\n  for (let i = 0; i < sides; i++) {\n    const a = rotation + (i / sides) * Math.PI * 2;\n    const x = center.x + radius * Math.cos(a);\n    const y = center.y + radius * Math.sin(a);\n    if (i === 0) b.moveTo(x, y); else b.lineTo(x, y);\n  }\n  b.close();\n  return b.build();\n}\n\n/** Closed n-pointed star centered at `center`, alternating `outerRadius` and\n *  `innerRadius` (default `outerRadius / 2`). `rotation` is in radians. */\nexport function starPath(\n  center: { x: number; y: number },\n  outerRadius: number,\n  points = 5,\n  innerRadius: number = outerRadius / 2,\n  rotation = 0,\n): PolygonPath {\n  const b = new PathBuilder();\n  const n = points * 2;\n  for (let i = 0; i < n; i++) {\n    const a = rotation + (i / n) * Math.PI * 2;\n    const r = i % 2 === 0 ? outerRadius : innerRadius;\n    const x = center.x + r * Math.cos(a);\n    const y = center.y + r * Math.sin(a);\n    if (i === 0) b.moveTo(x, y); else b.lineTo(x, y);\n  }\n  b.close();\n  return b.build();\n}\n\n/** Open 2-vertex polyline from `a` to `b` — strokeable, not fillable. */\nexport function linePath(\n  a: { x: number; y: number },\n  b: { x: number; y: number },\n): PolygonPath {\n  const pb = new PathBuilder();\n  pb.moveTo(a.x, a.y);\n  pb.lineTo(b.x, b.y);\n  return pb.build();\n}\n","import { type Mat3, transformCoords } from '@weasel-js/geom';\nimport { PathBuilder } from './builder';\nimport { type Path, type PolygonPath } from './types';\n\n/** Apply an affine `Mat3` to a path's geometry.\n *\n * Axis-aligned maps (no rotation/shear, i.e. `m[1] === 0 && m[2] === 0`) keep a\n * `RectPath` a rect — the four corners stay axis-aligned, so we transform the\n * two diagonal corners and normalize negative extent (mirror). Rotation or\n * shear promotes the rect's four corners to a `PolygonPath`. Polygon paths map\n * every coord via the kernel's `transformCoords`, preserving the command stream\n * and `fillRule`. Never mutates the input.\n *\n * `Mat3` here is the 6-tuple `number[]` from `@weasel-js/geom` (DOMMatrix order:\n * `[a, b, c, d, e, f]` where `x' = a·x + c·y + e`, `y' = b·x + d·y + f`),\n * not the renderer's 9-element `Float32Array`. */\nexport function transformPath(path: Path, m: Mat3): Path {\n  const [a, b, c, d, e, f] = m;\n  if (path.kind === 'rect') {\n    if (b === 0 && c === 0) {\n      // Pure scale + translate — corners remain axis-aligned.\n      const x0 = a * path.x + e;\n      const y0 = d * path.y + f;\n      const x1 = a * (path.x + path.width) + e;\n      const y1 = d * (path.y + path.height) + f;\n      return {\n        kind: 'rect',\n        x: Math.min(x0, x1),\n        y: Math.min(y0, y1),\n        width: Math.abs(x1 - x0),\n        height: Math.abs(y1 - y0),\n      };\n    }\n    // Rotation / shear — promote to polygon with the four rect corners.\n    const poly = new PathBuilder()\n      .moveTo(path.x, path.y)\n      .lineTo(path.x + path.width, path.y)\n      .lineTo(path.x + path.width, path.y + path.height)\n      .lineTo(path.x, path.y + path.height)\n      .close()\n      .build();\n    return transformPolygon(poly, m);\n  }\n  return transformPolygon(path, m);\n}\n\nfunction transformPolygon(path: PolygonPath, m: Mat3): PolygonPath {\n  // transformCoords returns Float64Array; PolygonPath.coords is Float32Array.\n  const mapped = transformCoords(path.coords, m);\n  return { ...path, coords: Float32Array.from(mapped) };\n}\n","/**\n * In-place and copy-out path transforms. Translation is the most common —\n * called every pointermove during a drag — so the polygon variant mutates\n * the float buffer directly to keep allocation pressure off the GC.\n *\n * `scalePathToBounds` is for the resize interaction: given the path's\n * current AABB and the desired new AABB, scales every coordinate\n * proportionally.\n */\n\nimport { boxToBox, forEachSegment, pathCommandCoordCount } from '@weasel-js/geom';\nimport { boundsOfPath } from './bounds';\nimport { transformPath } from './transformPath';\nimport type { Path, PolygonPath, RectPath } from './types';\n\n/**\n * Translate a path by (dx, dy). Returns a new instance — the kit's pose\n * model treats poses as immutable to keep React state-update semantics\n * predictable. Polygon coords are copied into a fresh `Float32Array`.\n */\nexport function translatePath(path: Path, dx: number, dy: number): Path {\n  if (path.kind === 'rect') {\n    return { kind: 'rect', x: path.x + dx, y: path.y + dy, width: path.width, height: path.height };\n  }\n  return translatePolygonCopy(path, dx, dy);\n}\n\nfunction translatePolygonCopy(path: PolygonPath, dx: number, dy: number): PolygonPath {\n  const next = new Float32Array(path.coords.length);\n  const { commands, coords } = path;\n  forEachSegment(commands, coords, (cmd, ci) => {\n    for (let k = 0, len = pathCommandCoordCount(cmd); k < len; k += 2) {\n      next[ci + k] = coords[ci + k] + dx;\n      next[ci + k + 1] = coords[ci + k + 1] + dy;\n    }\n  });\n  return { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\n}\n\n/**\n * Translate a polygon path's coords *in place*. Returns the same\n * `PolygonPath` reference. Use only for transient overlay buffers — never\n * for committed scene state, which must remain immutable for React.\n */\nexport function translatePolygonInPlace(path: PolygonPath, dx: number, dy: number): PolygonPath {\n  const { commands, coords } = path;\n  forEachSegment(commands, coords, (cmd, ci) => {\n    for (let k = 0, len = pathCommandCoordCount(cmd); k < len; k += 2) {\n      coords[ci + k] += dx;\n      coords[ci + k + 1] += dy;\n    }\n  });\n  return path;\n}\n\n/**\n * Scale a path's coords so its current AABB maps to `target`. Resize\n * interactions use this to make a polygon follow a corner-handle drag.\n *\n * A degenerate source axis (zero width or height) has no ratio to scale by,\n * so `boxToBox` translates that axis instead — a zero scale is not\n * invertible and would discard what is left on it.\n */\nexport function scalePathToBounds(path: Path, target: RectPath): Path {\n  if (path.kind === 'rect') {\n    return { kind: 'rect', x: target.x, y: target.y, width: target.width, height: target.height };\n  }\n  const src = boundsOfPath(path);\n  return scalePolygon(path, src, target);\n}\n\nfunction scalePolygon(path: PolygonPath, src: RectPath, dst: RectPath): PolygonPath {\n  const m = boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height);\n  // src/dst are axis-aligned, so the polygon stays a polygon after this pure scale+translate.\n  return transformPath(path, m) as PolygonPath;\n}\n","/**\n * Union math over rect-shaped poses.\n *\n * Two answers, deliberately distinct. `unionBounds` folds the *unrotated*\n * boxes and is what commit-time actions want, because they go on to write\n * poses back in that same frame. `unionAABB` expands each rotated member to\n * the extent of its ink first, and is what anything a user looks at or clicks\n * wants — selection chrome, gesture bounds, an export viewBox. Folding the\n * unrotated box there under-reports the extent of a rotated member exactly\n * when the consumer is watching it move.\n */\n\nimport type { RectPose } from 'core/scene/types';\nexport type { RectPose };\n\n/** Compute the AABB envelope of a set of rect-shaped poses, ignoring any\n *  rotation they carry. See the module docstring before reaching for this\n *  over {@link unionAABB}. */\nexport function unionBounds<TPose extends RectPose>(poses: Iterable<TPose>): RectPose | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const p of poses) {\n    any = true;\n    if (p.x < minX) minX = p.x;\n    if (p.y < minY) minY = p.y;\n    const right = p.x + p.width;\n    const bottom = p.y + p.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Axis-align a pose that carries a `rotation`: returns the AABB of the\n * rotated rectangle, with `rotation` dropped. Follows the kit's rotation\n * convention (`poseRotationOf`): rotate about the unrotated AABB center.\n *\n * Unrotated input is returned as-is.\n */\nexport function axisAlignedBounds<TPose extends RectPose>(b: TPose): RectPose {\n  const rotation = b.rotation;\n  if (!rotation) {\n    // Strip an explicit `rotation: 0` so callers can rely on the absence of\n    // the field meaning \"axis-aligned\".\n    return { x: b.x, y: b.y, width: b.width, height: b.height };\n  }\n  const cos = Math.cos(rotation);\n  const sin = Math.sin(rotation);\n  const cx = b.x + b.width / 2;\n  const cy = b.y + b.height / 2;\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  const corners: ReadonlyArray<readonly [number, number]> = [\n    [b.x, b.y],\n    [b.x + b.width, b.y],\n    [b.x + b.width, b.y + b.height],\n    [b.x, b.y + b.height],\n  ];\n  for (const [px, py] of corners) {\n    const dx = px - cx;\n    const dy = py - cy;\n    const rx = cx + dx * cos - dy * sin;\n    const ry = cy + dx * sin + dy * cos;\n    if (rx < minX) minX = rx;\n    if (rx > maxX) maxX = rx;\n    if (ry < minY) minY = ry;\n    if (ry > maxY) maxY = ry;\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Fold every part into one world-space AABB, skipping `null` / `undefined`\n * entries. Rotated parts are expanded via {@link axisAlignedBounds} first;\n * the result never carries a `rotation` (a union of several oriented boxes\n * has no single orientation to report).\n *\n * Returns `null` when nothing was contributed.\n */\nexport function unionAABB<TPose extends RectPose>(\n  parts: Iterable<TPose | null | undefined>,\n): RectPose | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const part of parts) {\n    if (!part) continue;\n    const b = axisAlignedBounds(part);\n    any = true;\n    if (b.x < minX) minX = b.x;\n    if (b.y < minY) minY = b.y;\n    const right = b.x + b.width;\n    const bottom = b.y + b.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n","import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { axisAlignedBounds } from 'core/geometry/unionBounds';\n\n/** `Bounds` with a required rotation angle (radians). Pivot is the AABB\n *  center of the unrotated `{x, y, width, height}`. */\nexport interface RotatedPose extends Bounds {\n  rotation: number;\n}\n\n/**\n * Bridges arbitrary `TPose` shapes into the resize hook's bounds-driven math.\n * The hook reads bounds via `getBounds`, runs anchor-relative math on those\n * bounds, then asks `remapBounds` to project the result back into TPose.\n *\n * `remapBounds(pose, src, dst)` is a single operation that subsumes both\n * \"set my own AABB to dst\" (single-leaf resize) and \"scale me as a leaf\n * inside parent's src→dst rect\" (group resize) — they're the same affine\n * map. For rect-shaped poses the default geometry interprets the pose as\n * its own bounds; for Path or polygon poses the consumer supplies a\n * projection that knows how to read and rewrite the underlying geometry.\n */\nexport interface PoseDescriptor<TPose, TNode = unknown> {\n  getBounds(pose: TPose): Bounds;\n  remapBounds(pose: TPose, src: Bounds, dst: Bounds): TPose;\n  /** A pose occupying `bounds`, of the same kind as `template`. Unlike\n   *  `remapBounds`, the result carries none of the template's shape. */\n  fromBounds(bounds: Bounds, template: TPose): TPose;\n  /** Translate the pose by (dx, dy). Optional — when omitted, callers fall\n   *  back to a translation derived from `remapBounds` (origin shifted, no\n   *  scale). Path-shaped poses should provide this for performance. */\n  translate?(pose: TPose, dx: number, dy: number): TPose;\n  /** True iff any portion of the pose's geometry intersects `rect`. Optional\n   *  — when omitted, area-select and similar callers test against `getBounds`\n   *  AABB (looser, but correct for axis-aligned rect poses). */\n  intersectsRect?(pose: TPose, rect: Bounds): boolean;\n  /** Interpolate between two poses. Optional — animation helpers fall back to\n   *  rect-shape lerp when omitted (which fails for non-rect poses). */\n  lerp?(a: TPose, b: TPose, t: number): TPose;\n  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted — descriptor\n   *  declares \"this pose has no rotation.\" When supplied and non-zero,\n   *  `useResize` projects the drag delta into the leaf's local frame,\n   *  runs anchor math there, and translates the resulting pose so the\n   *  diagonally opposite world-space corner is pinned. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation. Consulted by the\n   *  rotation affordance to decide whether to render the rotate cursor /\n   *  drag-band over a selection. When omitted, the kit assumes `true` for\n   *  back-compat — descriptors whose poses lack `x/y/width/height/rotation`\n   *  fields (e.g. polygon Paths) should return `false` so the affordance\n   *  hides instead of exposing a non-functional rotate cursor. */\n  supportsRotation?(pose: TPose): boolean;\n  /** Write a rotation (radians) into the pose, bounds unchanged. Absent means\n   *  the pose cannot carry one, and the rotate action leaves it alone. */\n  withRotation?(pose: TPose, rotation: number): TPose;\n  /**\n   * A descriptor specialized to one node. Every other method here sees only\n   * the pose, so shapes sharing a pose type — a sphere and a box both posed by\n   * position/rotation/scale — are indistinguishable to them. Implement this to\n   * read `node.data` once and hand back a descriptor that knows which shape it\n   * is describing.\n   *\n   * Callers reach it through {@link poseDescriptorForNode}, at whichever site\n   * holds the node; the specialized descriptor then travels into the bounds and\n   * hit-test helpers in place of this one. Sites with only an id keep using the\n   * unspecialized descriptor, which is why this is optional on both ends.\n   */\n  forNode?(node: TNode): PoseDescriptor<TPose, TNode>;\n}\n\n/** The descriptor `node` should be read through: its own specialization when\n *  it declares one, and otherwise the descriptor unchanged. */\nexport function poseDescriptorForNode<TPose, TNode>(\n  descriptor: PoseDescriptor<TPose, TNode>,\n  node: TNode,\n): PoseDescriptor<TPose, TNode> {\n  return descriptor.forNode?.(node) ?? descriptor;\n}\n\n/** AABB-vs-AABB overlap. Exported for callers building a default\n *  `intersectsRect` from `getBounds`. */\nexport function aabbIntersectsRect(b: Bounds, r: Bounds): boolean {\n  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;\n}\n\n/** Identity geometry for `TPose extends Bounds`. Treats the pose as its\n *  own bounds and remaps via affine scale against `src`/`dst`. */\nexport const RECT_POSE_DESCRIPTOR: PoseDescriptor<Bounds> = {\n  getBounds: (p) => p,\n  remapBounds: (p, src, dst) => {\n    const sx = src.width === 0 ? 1 : dst.width / src.width;\n    const sy = src.height === 0 ? 1 : dst.height / src.height;\n    return {\n      ...p,\n      x: dst.x + (p.x - src.x) * sx,\n      y: dst.y + (p.y - src.y) * sy,\n      width: p.width * sx,\n      height: p.height * sy,\n    };\n  },\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n  intersectsRect: (p, r) => aabbIntersectsRect(p, r),\n  lerp: (a, b, t) => ({\n    ...a,\n    x: a.x + (b.x - a.x) * t,\n    y: a.y + (b.y - a.y) * t,\n    width: a.width + (b.width - a.width) * t,\n    height: a.height + (b.height - a.height) * t,\n  }),\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/** Identity geometry for `RotatedPose`. Inherits rect-shape projection\n *  from `RECT_POSE_DESCRIPTOR` (the `RotatedPose extends Bounds`\n *  subtype lets the rect descriptor's methods apply directly; `remapBounds`\n *  preserves the `rotation` field via `...p` spread). Adds `getRotation` so\n *  `useResize` knows to take the rotation-aware math path. */\nexport const ROTATED_POSE_DESCRIPTOR: PoseDescriptor<RotatedPose> = {\n  getBounds: RECT_POSE_DESCRIPTOR.getBounds as PoseDescriptor<RotatedPose>['getBounds'],\n  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds as PoseDescriptor<RotatedPose>['remapBounds'],\n  translate: RECT_POSE_DESCRIPTOR.translate as PoseDescriptor<RotatedPose>['translate'],\n  intersectsRect: RECT_POSE_DESCRIPTOR.intersectsRect as PoseDescriptor<RotatedPose>['intersectsRect'],\n  lerp: RECT_POSE_DESCRIPTOR.lerp as PoseDescriptor<RotatedPose>['lerp'],\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height, rotation: 0 }),\n  getRotation: (p) => p.rotation,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/**\n * Remap a **rotated** leaf inside a group resize.\n *\n * The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the\n * group's per-axis factors and carries `rotation` through untouched. That is\n * right when `src`/`dst` are already expressed in the leaf's own frame — the\n * single-leaf resize path, where the drag delta was projected into that frame\n * before the anchor math ran. In a group resize they are world-frame, so the\n * leaf's local axes do not line up with the axes being scaled: at 90° a\n * horizontal stretch should grow the leaf's `height`, and the naive map grows\n * its `width`.\n *\n * What this computes is the group affine applied to the leaf's local frame,\n * with the shear dropped — the pose model is `{x, y, width, height, rotation}`\n * and cannot represent the parallelogram a non-uniform scale of a rotated box\n * actually produces. The center moves exactly; each local axis takes the\n * length of its own image; the rotation follows the image of the local x-axis.\n *\n * Degenerates to the naive map at `rotation === 0`, and to a plain uniform\n * scale when `sx === sy`, both exactly.\n */\nexport function remapRotatedLeaf<TPose extends RotatedPose>(\n  pose: TPose,\n  src: Bounds,\n  dst: Bounds,\n): TPose {\n  const sx = src.width === 0 ? 1 : dst.width / src.width;\n  const sy = src.height === 0 ? 1 : dst.height / src.height;\n  const theta = pose.rotation ?? 0;\n  const cos = Math.cos(theta);\n  const sin = Math.sin(theta);\n\n  // Images of the leaf's local unit axes under the group's diagonal scale.\n  const ux = sx * cos, uy = sy * sin;\n  const vx = -sx * sin, vy = sy * cos;\n\n  const width = pose.width * Math.hypot(ux, uy);\n  const height = pose.height * Math.hypot(vx, vy);\n  const rotation = Math.atan2(uy, ux);\n\n  // The center is a point, so it takes the group affine directly.\n  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;\n  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;\n\n  return {\n    ...pose,\n    x: cxNew - width / 2,\n    y: cyNew - height / 2,\n    width,\n    height,\n    rotation,\n  };\n}\n\n/** The pose's visual bounds: its frame expanded to cover the rotated\n *  rectangle, so a turned shape reports the extent of its ink. */\nexport function visualBoundsViaDescriptor<TPose>(\n  pose: TPose,\n  geometry: PoseDescriptor<TPose>,\n): Bounds {\n  const b = geometry.getBounds(pose);\n  const rotation =\n    geometry.getRotation?.(pose) ?? (b as { rotation?: number }).rotation ?? 0;\n  return axisAlignedBounds({ x: b.x, y: b.y, width: b.width, height: b.height, rotation });\n}\n\n/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted\n *  copy of the pose's own bounds when the descriptor has none. */\nexport function translatePoseViaDescriptor<TPose>(\n  pose: TPose,\n  dx: number,\n  dy: number,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  if (geometry.translate) return geometry.translate(pose, dx, dy);\n  const src = geometry.getBounds(pose);\n  const dst = { x: src.x + dx, y: src.y + dy, width: src.width, height: src.height };\n  return geometry.remapBounds(pose, src, dst);\n}\n","import { boxToBox } from '@weasel-js/geom';\nimport { boundsOfPath } from './bounds';\nimport { pointInPath } from './hitTest';\nimport { translatePath } from './transform';\nimport { transformPath } from './transformPath';\nimport type { Path } from './types';\nimport { aabbIntersectsRect, type PoseDescriptor } from 'interactions/actions/resize/geometry';\n\n/**\n * `PoseDescriptor` for `Path` poses — wires `useResize` to operate\n * on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel\n * the rest of the kit uses.\n *\n * `remapBounds` mirrors `scalePathToBounds` but takes `src` explicitly: the\n * resize hook knows the group's origin AABB and uses it for every leaf,\n * instead of each leaf scaling against its own AABB (which would ignore\n * group context).\n */\nexport const pathPoseDescriptor: PoseDescriptor<Path> = {\n  getBounds: (path) => boundsOfPath(path),\n  remapBounds: (path, src, dst) => transformPath(\n    path,\n    boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height),\n  ),\n  fromBounds: (b) => ({ kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (path, dx, dy) => translatePath(path, dx, dy),\n  // WHY: AABB pre-test is cheap; only fall through to per-corner pointInPath\n  //      when the rect is fully inside the AABB (silhouette test).\n  intersectsRect: (path, rect) => {\n    const b = boundsOfPath(path);\n    if (!aabbIntersectsRect(b, rect)) return false;\n    if (path.kind === 'rect') return true;\n    // Sample the rect's four corners; any inside the polygon ⇒ overlap.\n    if (\n      pointInPath(path, rect.x, rect.y) ||\n      pointInPath(path, rect.x + rect.width, rect.y) ||\n      pointInPath(path, rect.x, rect.y + rect.height) ||\n      pointInPath(path, rect.x + rect.width, rect.y + rect.height)\n    ) return true;\n    // Conservative fallback: AABB overlap counts. Tighter edge-vs-edge test\n    // would be the next step; defer until a demo demands it.\n    return true;\n  },\n  lerp: (a, b, t) => {\n    if (a.kind === 'rect' && b.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: a.x + (b.x - a.x) * t,\n        y: a.y + (b.y - a.y) * t,\n        width: a.width + (b.width - a.width) * t,\n        height: a.height + (b.height - a.height) * t,\n      };\n    }\n    if (a.kind === 'polygon' && b.kind === 'polygon' && a.coords.length === b.coords.length) {\n      const next = new Float32Array(a.coords.length);\n      for (let i = 0; i < a.coords.length; i++) {\n        next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;\n      }\n      return { kind: 'polygon', commands: a.commands, coords: next, fillRule: a.fillRule };\n    }\n    throw new Error('pathPoseDescriptor.lerp: incompatible path shapes');\n  },\n  // Path poses carry no x/y/width/height/rotation fields — the kit's\n  // `wrapWithPoseRotation` helper has nothing to bind a rotation to, and\n  // `remapBounds` would drop a synthetic rotation field on every commit.\n  // Returning false here hides the rotation affordance for Path consumers\n  // so the rotate cursor doesn't appear without a working interaction.\n  supportsRotation: () => false,\n};\n","import type { Path } from 'features/paths/types';\nimport { pathPoseDescriptor } from 'features/paths/poseDescriptor';\nimport { RECT_POSE_DESCRIPTOR, type PoseDescriptor } from './geometry';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for\n *  callers that need to fork between `pathPoseDescriptor` and\n *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire\n *  `poseDescriptor` explicitly. */\nexport function isPathLike(p: unknown): p is Path {\n  return !!p && typeof p === 'object' && 'kind' in p\n    && ((p as { kind: unknown }).kind === 'polygon' || (p as { kind: unknown }).kind === 'rect');\n}\n\n/** True for a pose with numeric top-level `x`/`y`/`width`/`height` — the only\n *  shape the rect descriptor and the kit's built-in painters can read. */\nexport function isRectPose(p: unknown): p is { x: number; y: number; width: number; height: number; rotation?: number } {\n  if (!p || typeof p !== 'object') return false;\n  const r = p as Record<string, unknown>;\n  return typeof r.x === 'number' && typeof r.y === 'number'\n    && typeof r.width === 'number' && typeof r.height === 'number';\n}\n\n/** Per-call dispatch: if the pose looks like a Path, route to\n *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing\n *  demos with Path TPose to wire `poseDescriptor={pathPoseDescriptor}`\n *  explicitly. `getRotation` surfaces a `pose.rotation` field on non-Path poses\n *  so demos using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to\n *  wire `poseDescriptor={ROTATED_POSE_DESCRIPTOR}` just to get rotated\n *  selection chrome and rotation-aware corner hit-tests. */\nexport const AUTO_POSE_DESCRIPTOR: PoseDescriptor<unknown> = {\n  getBounds: (p) => isPathLike(p)\n    ? pathPoseDescriptor.getBounds(p)\n    : RECT_POSE_DESCRIPTOR.getBounds(p as { x: number; y: number; width: number; height: number }),\n  remapBounds: (p, src, dst) => isPathLike(p)\n    ? pathPoseDescriptor.remapBounds(p, src, dst)\n    : RECT_POSE_DESCRIPTOR.remapBounds(p as { x: number; y: number; width: number; height: number }, src, dst),\n  fromBounds: (b, template) => isPathLike(template)\n    ? pathPoseDescriptor.fromBounds(b, template)\n    : RECT_POSE_DESCRIPTOR.fromBounds(b, template as Bounds),\n  translate: (p, dx, dy) => isPathLike(p)\n    ? pathPoseDescriptor.translate!(p, dx, dy)\n    : RECT_POSE_DESCRIPTOR.translate!(p as { x: number; y: number; width: number; height: number }, dx, dy),\n  intersectsRect: (p, rect) => isPathLike(p)\n    ? pathPoseDescriptor.intersectsRect!(p, rect)\n    : RECT_POSE_DESCRIPTOR.intersectsRect!(p as { x: number; y: number; width: number; height: number }, rect),\n  getRotation: (p) => {\n    if (isPathLike(p)) return 0;\n    const r = (p as { rotation?: unknown }).rotation;\n    return typeof r === 'number' ? r : 0;\n  },\n  // Path-shaped poses can't carry rotation (see `pathPoseDescriptor`).\n  // Everything else flows through `wrapWithPoseRotation`'s x/y/w/h gate at\n  // paint time, so report `true` and let the wrapper no-op for poses\n  // missing AABB fields.\n  supportsRotation: (p) => !isPathLike(p),\n  withRotation: (p, rotation) => isPathLike(p) ? p : { ...(p as object), rotation },\n};\n"]}