@weasel-js/core 1.10.0 → 1.11.0

package/dist/interactions/actions/poseFrame.js

@@ -1,43 +1,60 @@
-import { composeWorldPose as e, frameAtOrAbove as t, rebaseLocalPose as n } from "../../core/scene/composeFrame.js";
-import { definesFrame as r, effectivePose as i } from "../../core/scene/effectivePose.js";
-import { asNodeId as a } from "../../core/scene/types.js";
+import { composeWorldPose, frameAtOrAbove, rebaseLocalPose } from "../../core/scene/composeFrame.js";
+import { definesFrame, effectivePose } from "../../core/scene/effectivePose.js";
+import { asNodeId } from "../../core/scene/types.js";
+
 //#region src/interactions/actions/poseFrame.ts
-function o(r, i) {
+/**
+* World reads and local writes, paired, for the default actions.
+*
+* A container's pose defines a frame, so a node's stored pose is expressed in
+* its parent's. The geometry an action reasons about is world; every pose it
+* writes back through `setPose` or a pose op is local. An action that reads
+* world and writes world looks right for one gesture and drifts on the next,
+* because the stored pose is then read in the parent's frame again.
+*
+* Under `IDENTITY_POSE_COMPOSITION`, the default, local and world are the same
+* value. `core/scene/frameFixture.ts` is the scene where they differ.
+*/
+/** Pair the two directions over an arbitrary pose adapter. */
+function poseFrame(adapter, pc) {
 	return {
-		pc: i,
-		world: (t) => e(r, t, i.compose),
-		frame: (e) => {
-			let n = t(r, r.getParent(e));
-			return n === null ? null : a(n);
+		pc,
+		world: (id) => composeWorldPose(adapter, id, pc.compose),
+		frame: (id) => {
+			const frame = frameAtOrAbove(adapter, adapter.getParent(id));
+			return frame === null ? null : asNodeId(frame);
 		},
-		parentWorld: (n) => {
-			let a = t(r, r.getParent(n));
-			return a === null ? null : e(r, a, i.compose);
+		parentWorld: (id) => {
+			const frame = frameAtOrAbove(adapter, adapter.getParent(id));
+			return frame === null ? null : composeWorldPose(adapter, frame, pc.compose);
 		},
-		local: (e, t) => n(r, t, r.getParent(e), i.compose, i.decompose),
-		localUnder: (e, t) => n(r, t, e, i.compose, i.decompose)
+		local: (id, worldPose) => rebaseLocalPose(adapter, worldPose, adapter.getParent(id), pc.compose, pc.decompose),
+		localUnder: (parentId, worldPose) => rebaseLocalPose(adapter, worldPose, parentId, pc.compose, pc.decompose)
 	};
 }
-function s(e) {
-	let t = e.composition, n = e;
-	return o({
-		getPose: (t) => {
-			let r = e.get(t);
-			return r === void 0 ? {
+/** The `poseFrame` a scene-backed action works in, over the scene's own
+*  composition. Under IDENTITY every method is a no-op. */
+function scenePoseFrame(scene) {
+	const pc = scene.composition;
+	const source = scene;
+	return poseFrame({
+		getPose: (id) => {
+			const node = scene.get(id);
+			return node === void 0 ? {
 				x: 0,
 				y: 0,
 				width: 0,
 				height: 0
-			} : i(n, r);
+			} : effectivePose(source, node);
 		},
-		getParent: (t) => e.get(t)?.parent ?? null,
-		definesFrame: (t) => {
-			let n = e.get(t);
-			return n === void 0 || r(n);
+		getParent: (id) => scene.get(id)?.parent ?? null,
+		definesFrame: (id) => {
+			const node = scene.get(id);
+			return node === void 0 || definesFrame(node);
 		}
-	}, t);
+	}, pc);
 }
-//#endregion
-export { o as poseFrame, s as scenePoseFrame };
 
+//#endregion
+export { poseFrame, scenePoseFrame };
 //# sourceMappingURL=poseFrame.js.map

package/dist/interactions/actions/poseFrame.js.map

@@ -1 +1 @@
-{"version":3,"file":"poseFrame.js","names":["poseFrame","composeWorldPose","adapter","id","pc","frame","frameAtOrAbove","asNodeId","rebaseLocalPose","worldPose","parentId","scenePoseFrame","scene","source","node","effectivePose","definesFrame"],"sources":["../../../src/interactions/actions/poseFrame.ts"],"sourcesContent":["/**\n * World reads and local writes, paired, for the default actions.\n *\n * A container's pose defines a frame, so a node's stored pose is expressed in\n * its parent's. The geometry an action reasons about is world; every pose it\n * writes back through `setPose` or a pose op is local. An action that reads\n * world and writes world looks right for one gesture and drifts on the next,\n * because the stored pose is then read in the parent's frame again.\n *\n * Under `IDENTITY_POSE_COMPOSITION`, the default, local and world are the same\n * value. `core/scene/frameFixture.ts` is the scene where they differ.\n */\nimport { definesFrame, effectivePose, type PoseSource } from 'core/scene/effectivePose';\nimport { asNodeId, type NodeId, type Scene } from 'core/scene/types';\nimport {\n  composeWorldPose,\n  frameAtOrAbove,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseComposition,\n} from 'core/scene/composePose';\n\n/** The two directions an action needs, over one composition strategy. */\nexport interface PoseFrame<TPose> {\n  /** The strategy in force. `closure` says what it can express exactly. */\n  readonly pc: PoseComposition<TPose>;\n  /** `id`'s pose in world coordinates, honoring an in-flight gesture override. */\n  world(id: NodeId): TPose;\n  /** The node whose frame `id` is stored in, or `null` for the root frame. */\n  frame(id: NodeId): NodeId | null;\n  /** World pose of the frame `id` is stored in, or `null` for the root frame. */\n  parentWorld(id: NodeId): TPose | null;\n  /** `worldPose` expressed in `id`'s own parent frame — what `setPose` stores. */\n  local(id: NodeId, worldPose: TPose): TPose;\n  /** `worldPose` expressed under `parentId`'s frame. For a node about to be\n   *  reparented, whose current parent is not the frame it will be stored in. */\n  localUnder(parentId: NodeId | null, worldPose: TPose): TPose;\n}\n\n/** Pair the two directions over an arbitrary pose adapter. */\nexport function poseFrame<TPose>(\n  adapter: PoseAdapter<TPose>,\n  pc: PoseComposition<TPose>,\n): PoseFrame<TPose> {\n  return {\n    pc,\n    world: (id) => composeWorldPose(adapter, id as string, pc.compose),\n    frame: (id) => {\n      const frame = frameAtOrAbove(adapter, adapter.getParent(id as string));\n      return frame === null ? null : asNodeId(frame);\n    },\n    parentWorld: (id) => {\n      const frame = frameAtOrAbove(adapter, adapter.getParent(id as string));\n      return frame === null ? null : composeWorldPose(adapter, frame, pc.compose);\n    },\n    local: (id, worldPose) =>\n      rebaseLocalPose(adapter, worldPose, adapter.getParent(id as string), pc.compose, pc.decompose),\n    localUnder: (parentId, worldPose) =>\n      rebaseLocalPose(adapter, worldPose, parentId as string | null, pc.compose, pc.decompose),\n  };\n}\n\n/** The `poseFrame` a scene-backed action works in, over the scene's own\n *  composition. Under IDENTITY every method is a no-op. */\nexport function scenePoseFrame(scene: Scene<unknown, string, unknown>): PoseFrame<unknown> {\n  const pc = scene.composition;\n  const source = scene as unknown as PoseSource<unknown>;\n  const adapter: PoseAdapter<unknown> = {\n    getPose: (id) => {\n      const node = scene.get(id as NodeId);\n      return node === undefined ? { x: 0, y: 0, width: 0, height: 0 } : effectivePose(source, node);\n    },\n    getParent: (id) => scene.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = scene.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n  return poseFrame(adapter, pc);\n}\n"],"mappings":";;;;AAwCA,SAAgBA,EACd,GACA,GACkB;CAClB,OAAO;EACL;EACA,QAAQ,MAAOC,EAAiBC,GAASC,GAAcC,EAAG,OAAO;EACjE,QAAQ,MAAO;GACb,IAAMC,IAAQC,EAAeJ,GAASA,EAAQ,UAAUC,CAAY,CAAC;GACrE,OAAOE,MAAU,OAAO,OAAOE,EAASF,CAAK;EAC/C;EACA,cAAc,MAAO;GACnB,IAAMA,IAAQC,EAAeJ,GAASA,EAAQ,UAAUC,CAAY,CAAC;GACrE,OAAOE,MAAU,OAAO,OAAOJ,EAAiBC,GAASG,GAAOD,EAAG,OAAO;EAC5E;EACA,QAAQ,GAAI,MACVI,EAAgBN,GAASO,GAAWP,EAAQ,UAAUC,CAAY,GAAGC,EAAG,SAASA,EAAG,SAAS;EAC/F,aAAa,GAAU,MACrBI,EAAgBN,GAASO,GAAWC,GAA2BN,EAAG,SAASA,EAAG,SAAS;CAC3F;AACF;AAIA,SAAgBO,EAAe,GAA4D;CACzF,IAAMP,IAAKQ,EAAM,aACXC,IAASD;CAYf,OAAOZ,EAAU;EAVf,UAAU,MAAO;GACf,IAAMc,IAAOF,EAAM,IAAIT,CAAY;GACnC,OAAOW,MAAS,KAAA,IAAY;IAAE,GAAG;IAAG,GAAG;IAAG,OAAO;IAAG,QAAQ;GAAE,IAAIC,EAAcF,GAAQC,CAAI;EAC9F;EACA,YAAY,MAAOF,EAAM,IAAIT,CAAY,CAAC,EAAE,UAAU;EACtD,eAAe,MAAO;GACpB,IAAMW,IAAOF,EAAM,IAAIT,CAAY;GACnC,OAAOW,MAAS,KAAA,KAAaE,EAAaF,CAAI;EAChD;CAEe,GAASV,CAAE;AAC9B"}
+{"version":3,"file":"poseFrame.js","names":[],"sources":["../../../src/interactions/actions/poseFrame.ts"],"sourcesContent":["/**\n * World reads and local writes, paired, for the default actions.\n *\n * A container's pose defines a frame, so a node's stored pose is expressed in\n * its parent's. The geometry an action reasons about is world; every pose it\n * writes back through `setPose` or a pose op is local. An action that reads\n * world and writes world looks right for one gesture and drifts on the next,\n * because the stored pose is then read in the parent's frame again.\n *\n * Under `IDENTITY_POSE_COMPOSITION`, the default, local and world are the same\n * value. `core/scene/frameFixture.ts` is the scene where they differ.\n */\nimport { definesFrame, effectivePose, type PoseSource } from 'core/scene/effectivePose';\nimport { asNodeId, type NodeId, type Scene } from 'core/scene/types';\nimport {\n  composeWorldPose,\n  frameAtOrAbove,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseComposition,\n} from 'core/scene/composePose';\n\n/** The two directions an action needs, over one composition strategy. */\nexport interface PoseFrame<TPose> {\n  /** The strategy in force. `closure` says what it can express exactly. */\n  readonly pc: PoseComposition<TPose>;\n  /** `id`'s pose in world coordinates, honoring an in-flight gesture override. */\n  world(id: NodeId): TPose;\n  /** The node whose frame `id` is stored in, or `null` for the root frame. */\n  frame(id: NodeId): NodeId | null;\n  /** World pose of the frame `id` is stored in, or `null` for the root frame. */\n  parentWorld(id: NodeId): TPose | null;\n  /** `worldPose` expressed in `id`'s own parent frame — what `setPose` stores. */\n  local(id: NodeId, worldPose: TPose): TPose;\n  /** `worldPose` expressed under `parentId`'s frame. For a node about to be\n   *  reparented, whose current parent is not the frame it will be stored in. */\n  localUnder(parentId: NodeId | null, worldPose: TPose): TPose;\n}\n\n/** Pair the two directions over an arbitrary pose adapter. */\nexport function poseFrame<TPose>(\n  adapter: PoseAdapter<TPose>,\n  pc: PoseComposition<TPose>,\n): PoseFrame<TPose> {\n  return {\n    pc,\n    world: (id) => composeWorldPose(adapter, id as string, pc.compose),\n    frame: (id) => {\n      const frame = frameAtOrAbove(adapter, adapter.getParent(id as string));\n      return frame === null ? null : asNodeId(frame);\n    },\n    parentWorld: (id) => {\n      const frame = frameAtOrAbove(adapter, adapter.getParent(id as string));\n      return frame === null ? null : composeWorldPose(adapter, frame, pc.compose);\n    },\n    local: (id, worldPose) =>\n      rebaseLocalPose(adapter, worldPose, adapter.getParent(id as string), pc.compose, pc.decompose),\n    localUnder: (parentId, worldPose) =>\n      rebaseLocalPose(adapter, worldPose, parentId as string | null, pc.compose, pc.decompose),\n  };\n}\n\n/** The `poseFrame` a scene-backed action works in, over the scene's own\n *  composition. Under IDENTITY every method is a no-op. */\nexport function scenePoseFrame(scene: Scene<unknown, string, unknown>): PoseFrame<unknown> {\n  const pc = scene.composition;\n  const source = scene as unknown as PoseSource<unknown>;\n  const adapter: PoseAdapter<unknown> = {\n    getPose: (id) => {\n      const node = scene.get(id as NodeId);\n      return node === undefined ? { x: 0, y: 0, width: 0, height: 0 } : effectivePose(source, node);\n    },\n    getParent: (id) => scene.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = scene.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n  return poseFrame(adapter, pc);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAwCA,SAAgB,UACd,SACA,IACkB;CAClB,OAAO;EACL;EACA,QAAQ,OAAO,iBAAiB,SAAS,IAAc,GAAG,OAAO;EACjE,QAAQ,OAAO;GACb,MAAM,QAAQ,eAAe,SAAS,QAAQ,UAAU,EAAY,CAAC;GACrE,OAAO,UAAU,OAAO,OAAO,SAAS,KAAK;EAC/C;EACA,cAAc,OAAO;GACnB,MAAM,QAAQ,eAAe,SAAS,QAAQ,UAAU,EAAY,CAAC;GACrE,OAAO,UAAU,OAAO,OAAO,iBAAiB,SAAS,OAAO,GAAG,OAAO;EAC5E;EACA,QAAQ,IAAI,cACV,gBAAgB,SAAS,WAAW,QAAQ,UAAU,EAAY,GAAG,GAAG,SAAS,GAAG,SAAS;EAC/F,aAAa,UAAU,cACrB,gBAAgB,SAAS,WAAW,UAA2B,GAAG,SAAS,GAAG,SAAS;CAC3F;AACF;;;AAIA,SAAgB,eAAe,OAA4D;CACzF,MAAM,KAAK,MAAM;CACjB,MAAM,SAAS;CAYf,OAAO,UAAU;EAVf,UAAU,OAAO;GACf,MAAM,OAAO,MAAM,IAAI,EAAY;GACnC,OAAO,SAAS,SAAY;IAAE,GAAG;IAAG,GAAG;IAAG,OAAO;IAAG,QAAQ;GAAE,IAAI,cAAc,QAAQ,IAAI;EAC9F;EACA,YAAY,OAAO,MAAM,IAAI,EAAY,CAAC,EAAE,UAAU;EACtD,eAAe,OAAO;GACpB,MAAM,OAAO,MAAM,IAAI,EAAY;GACnC,OAAO,SAAS,UAAa,aAAa,IAAI;EAChD;CAEe,GAAS,EAAE;AAC9B"}

package/dist/interactions/actions/resize/action.js

@@ -1,13 +1,28 @@
-import { closeGesture as e, runBehaviorCancel as t } from "../gestureLifecycle.js";
-import { inPlane as n, selectionLayer as r } from "../planeInput.js";
-import { commitResize as i } from "./commit.js";
-import { nextFrame as a } from "./frame.js";
-import { beginResize as o } from "./session.js";
+import { closeGesture, runBehaviorCancel } from "../gestureLifecycle.js";
+import { inPlane, selectionLayer } from "../planeInput.js";
+import { SNAP_ROLES } from "../../../features/snap/roles.js";
+import { recordTransform } from "../transform-again/memory.js";
+import { commitResize } from "./commit.js";
+import { nextFrame } from "./frame.js";
+import { beginResize } from "./session.js";
+import { unitsOfBox } from "./replay.js";
+
 //#region src/interactions/actions/resize/action.ts
-var s = n({
+/**
+* Anchor-relative drag resize, committed as one batch on release. It needs
+* `InvocationCtx.drag.affordance` with a `handle:*` kind.
+*
+* The dragged corner or edge snaps through the `snap` dep's session before
+* the box is resized, held to the handle's axis, and to the box's diagonal
+* while `snap.constrain` (Shift) is held. The optional `resizePolicy` dep
+* carries the constraints, point snaps, and `expandIds`; absent, the invoker
+* runs no constraints and `ids => ids` expansion.
+*/
+var resizeAction = inPlane({
 	id: "resize",
 	label: "Resize",
 	eligible: { capability: "transforms-selection" },
+	modifierRoles: SNAP_ROLES,
 	requires: [
 		"selection",
 		"scene",
@@ -15,41 +30,66 @@ var s = n({
 		"poseDescriptor",
 		"applyOps",
 		"geometryProjection",
-		"view"
+		"view",
+		"boundsIncludeStroke",
+		"kitSettings",
+		"snap"
 	],
 	invoker: {
 		timing: "ongoing",
-		start(n, r) {
-			let s = o(n);
-			if (!s) return {};
-			let { session: c, readers: l } = s, u = c.scene.overrides.hold(), d = { previews: /* @__PURE__ */ new Map() };
-			return c.lifecycle.start(c.writeIds), {
+		start(ctx, _opts) {
+			const begun = beginResize(ctx);
+			if (!begun) return {};
+			const { session, readers } = begun;
+			const subject = [...ctx.deps.selection?.get() ?? []];
+			const hold = session.scene.overrides.hold();
+			let frame = { previews: /* @__PURE__ */ new Map() };
+			session.lifecycle.start(session.writeIds);
+			return {
 				kind: "resize",
-				onMove(e) {
-					e.drag && (d = a(c, l, e), u.set(d.previews));
+				onMove(moveCtx) {
+					if (!moveCtx.drag) return;
+					frame = nextFrame(session, readers, moveCtx);
+					hold.set(frame.previews);
 				},
-				onEnd(n, r) {
-					let a = !1;
+				onEnd(_endCtx, reason) {
+					let committed = false;
 					try {
-						r === "commit" ? a = i(c, d) : t(c.constraints, c.gestureCtx);
+						if (reason === "commit") {
+							committed = commitResize(session, frame);
+							if (committed && frame.proposed) {
+								const to = unitsOfBox(session.box.bounds, frame.proposed);
+								recordTransform(session.scene, {
+									kind: "scale",
+									to,
+									anchor: session.box.anchor
+								}, subject);
+							}
+						} else runBehaviorCancel(session.constraints, session.gestureCtx);
 					} finally {
-						e({
-							hold: u,
-							previews: d.previews,
-							behaviors: c.constraints,
-							ctx: c.gestureCtx,
-							lifecycle: c.lifecycle
-						}, a);
+						session.snap.end();
+						closeGesture({
+							hold,
+							previews: frame.previews,
+							behaviors: session.constraints,
+							ctx: session.gestureCtx,
+							lifecycle: session.lifecycle
+						}, committed);
 					}
 				},
-				previewIds: () => d.previews.keys(),
-				previewPose: (e) => d.previews.get(e) ?? null
+				previewIds: () => frame.previews.keys(),
+				previewPose: (id) => frame.previews.get(id) ?? null
 			};
 		}
 	},
-	enabled: () => !0
-}, r);
-//#endregion
-export { s as resizeAction };
+	/**
+	* Always enabled: the dispatcher treats anything `!== true` as "skip and
+	* try the next match", so a disabled reason here makes the resize binding
+	* silently lose to lower-specificity matches (e.g. ambient `insertAction`).
+	*/
+	enabled: () => true
+}, selectionLayer);
 
+//#endregion
+export { resizeAction };
 //# sourceMappingURL=action.js.map

package/dist/interactions/actions/resize/action.js.map

@@ -1 +1 @@
-{"version":3,"file":"action.js","names":["resizeAction","inPlane","begun","beginResize","ctx","hold","session","frame","moveCtx","nextFrame","readers","committed","reason","commitResize","runBehaviorCancel","id","selectionLayer"],"sources":["../../../../src/interactions/actions/resize/action.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport { closeGesture, runBehaviorCancel } from '../gestureLifecycle';\nimport { inPlane, selectionLayer } from '../planeInput';\nimport { commitResize } from './commit';\nimport { nextFrame } from './frame';\nimport { beginResize, type ResizeFrame } from './session';\n\n/**\n * @experimental\n * Anchor-relative drag resize, committed as one batch on release. It needs\n * `InvocationCtx.drag.affordance` with a `handle:*` kind.\n *\n * The optional `resizePolicy` dep carries the constraints, point snaps, and\n * `expandIds`; absent, the invoker falls back to the kit's default\n * constraints, no snap, and `ids => ids` expansion.\n */\nexport const resizeAction: Action & { requires: string[] } = inPlane({\n  id: 'resize',\n  label: 'Resize',\n  // No default binding: a bare `{ kind: 'drag' }` claims every drag at ambient\n  // scope. The resize handles bind it (`selectionResizeBindings`).\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'resizePolicy', 'poseDescriptor', 'applyOps', 'geometryProjection', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, _opts): OngoingHandle {\n      const begun = beginResize(ctx);\n      if (!begun) return {};\n      const { session, readers } = begun;\n      const hold = session.scene.overrides.hold();\n      let frame: ResizeFrame = { previews: new Map() };\n      session.lifecycle.start(session.writeIds as readonly string[]);\n      return {\n        kind: 'resize',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          frame = nextFrame(session, readers, moveCtx);\n          hold.set(frame.previews);\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            if (reason === 'commit') committed = commitResize(session, frame);\n            else runBehaviorCancel(session.constraints, session.gestureCtx);\n          } finally {\n            closeGesture({ hold, previews: frame.previews, behaviors: session.constraints, ctx: session.gestureCtx, lifecycle: session.lifecycle }, committed);\n          }\n        },\n        previewIds: () => frame.previews.keys(),\n        previewPose: (id: string) => frame.previews.get(id as NodeId) ?? null,\n      };\n    },\n  },\n  /**\n   * Always enabled: the dispatcher treats anything `!== true` as \"skip and\n   * try the next match\", so a disabled reason here makes the resize binding\n   * silently lose to lower-specificity matches (e.g. ambient `insertAction`).\n   */\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":";;;;;;AAkBA,IAAaA,IAAgDC,EAAQ;CACnE,IAAI;CACJ,OAAO;CAGP,UAAU,EAAE,YAAY,uBAAuB;CAC/C,UAAU;EAAC;EAAa;EAAS;EAAgB;EAAkB;EAAY;EAAsB;CAAM;CAC3G,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAsB;GAC9C,IAAMC,IAAQC,EAAYC,CAAG;GAC7B,IAAI,CAACF,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,YAAS,eAAYA,GACvBG,IAAOC,EAAQ,MAAM,UAAU,KAAK,GACtCC,IAAqB,EAAE,0BAAU,IAAI,IAAI,EAAE;GAE/C,OADAD,EAAQ,UAAU,MAAMA,EAAQ,QAA6B,GACtD;IACL,MAAM;IACN,OAAO,GAA8B;KACnC,AAAKE,EAAQ,SACb,IAAQC,EAAUH,GAASI,GAASF,CAAO,GAC3CH,EAAK,IAAIE,EAAM,QAAQ;IACzB;IACA,MAAM,GAAwB,GAAmC;KAC/D,IAAII,IAAY;KAChB,IAAI;MACF,AAAIC,MAAW,WAAU,IAAYC,EAAaP,GAASC,CAAK,IAC3DO,EAAkBR,EAAQ,aAAaA,EAAQ,UAAU;KAChE,UAAU;MACR,EAAa;OAAE;OAAM,UAAUC,EAAM;OAAU,WAAWD,EAAQ;OAAa,KAAKA,EAAQ;OAAY,WAAWA,EAAQ;MAAU,GAAGK,CAAS;KACnJ;IACF;IACA,kBAAkBJ,EAAM,SAAS,KAAK;IACtC,cAAc,MAAeA,EAAM,SAAS,IAAIQ,CAAY,KAAK;GACnE;EACF;CACF;CAMA,eAAe;AACjB,GAAGC,CAAc"}
+{"version":3,"file":"action.js","names":[],"sources":["../../../../src/interactions/actions/resize/action.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport { closeGesture, runBehaviorCancel } from '../gestureLifecycle';\nimport { inPlane, selectionLayer } from '../planeInput';\nimport { commitResize } from './commit';\nimport { nextFrame } from './frame';\nimport { beginResize, type ResizeFrame } from './session';\nimport { unitsOfBox } from './replay';\nimport { recordTransform } from '../transform-again/memory';\nimport { SNAP_ROLES } from 'features/snap/roles';\n\n/**\n * Anchor-relative drag resize, committed as one batch on release. It needs\n * `InvocationCtx.drag.affordance` with a `handle:*` kind.\n *\n * The dragged corner or edge snaps through the `snap` dep's session before\n * the box is resized, held to the handle's axis, and to the box's diagonal\n * while `snap.constrain` (Shift) is held. The optional `resizePolicy` dep\n * carries the constraints, point snaps, and `expandIds`; absent, the invoker\n * runs no constraints and `ids => ids` expansion.\n */\nexport const resizeAction: Action & { requires: string[] } = inPlane({\n  id: 'resize',\n  label: 'Resize',\n  // No default binding: a bare `{ kind: 'drag' }` claims every drag at ambient\n  // scope. The resize handles bind it (`selectionResizeBindings`).\n  eligible: { capability: 'transforms-selection' },\n  modifierRoles: SNAP_ROLES,\n  requires: [\n    'selection', 'scene', 'resizePolicy', 'poseDescriptor', 'applyOps', 'geometryProjection', 'view',\n    'boundsIncludeStroke', 'kitSettings', 'snap',\n  ],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, _opts): OngoingHandle {\n      const begun = beginResize(ctx);\n      if (!begun) return {};\n      const { session, readers } = begun;\n      const subject = [...(ctx.deps.selection?.get() ?? [])] as string[];\n      const hold = session.scene.overrides.hold();\n      let frame: ResizeFrame = { previews: new Map() };\n      session.lifecycle.start(session.writeIds as readonly string[]);\n      return {\n        kind: 'resize',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          frame = nextFrame(session, readers, moveCtx);\n          hold.set(frame.previews);\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            if (reason === 'commit') {\n              committed = commitResize(session, frame);\n              if (committed && frame.proposed) {\n                const to = unitsOfBox(session.box.bounds, frame.proposed);\n                recordTransform(session.scene, { kind: 'scale', to, anchor: session.box.anchor }, subject);\n              }\n            } else runBehaviorCancel(session.constraints, session.gestureCtx);\n          } finally {\n            session.snap.end();\n            closeGesture({ hold, previews: frame.previews, behaviors: session.constraints, ctx: session.gestureCtx, lifecycle: session.lifecycle }, committed);\n          }\n        },\n        previewIds: () => frame.previews.keys(),\n        previewPose: (id: string) => frame.previews.get(id as NodeId) ?? null,\n      };\n    },\n  },\n  /**\n   * Always enabled: the dispatcher treats anything `!== true` as \"skip and\n   * try the next match\", so a disabled reason here makes the resize binding\n   * silently lose to lower-specificity matches (e.g. ambient `insertAction`).\n   */\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,eAAgD,QAAQ;CACnE,IAAI;CACJ,OAAO;CAGP,UAAU,EAAE,YAAY,uBAAuB;CAC/C,eAAe;CACf,UAAU;EACR;EAAa;EAAS;EAAgB;EAAkB;EAAY;EAAsB;EAC1F;EAAuB;EAAe;CACxC;CACA,SAAS;EACP,QAAQ;EACR,MAAM,KAAoB,OAAsB;GAC9C,MAAM,QAAQ,YAAY,GAAG;GAC7B,IAAI,CAAC,OAAO,OAAO,CAAC;GACpB,MAAM,EAAE,SAAS,YAAY;GAC7B,MAAM,UAAU,CAAC,GAAI,IAAI,KAAK,WAAW,IAAI,KAAK,CAAC,CAAE;GACrD,MAAM,OAAO,QAAQ,MAAM,UAAU,KAAK;GAC1C,IAAI,QAAqB,EAAE,0BAAU,IAAI,IAAI,EAAE;GAC/C,QAAQ,UAAU,MAAM,QAAQ,QAA6B;GAC7D,OAAO;IACL,MAAM;IACN,OAAO,SAA8B;KACnC,IAAI,CAAC,QAAQ,MAAM;KACnB,QAAQ,UAAU,SAAS,SAAS,OAAO;KAC3C,KAAK,IAAI,MAAM,QAAQ;IACzB;IACA,MAAM,SAAwB,QAAmC;KAC/D,IAAI,YAAY;KAChB,IAAI;MACF,IAAI,WAAW,UAAU;OACvB,YAAY,aAAa,SAAS,KAAK;OACvC,IAAI,aAAa,MAAM,UAAU;QAC/B,MAAM,KAAK,WAAW,QAAQ,IAAI,QAAQ,MAAM,QAAQ;QACxD,gBAAgB,QAAQ,OAAO;SAAE,MAAM;SAAS;SAAI,QAAQ,QAAQ,IAAI;QAAO,GAAG,OAAO;OAC3F;MACF,OAAO,kBAAkB,QAAQ,aAAa,QAAQ,UAAU;KAClE,UAAU;MACR,QAAQ,KAAK,IAAI;MACjB,aAAa;OAAE;OAAM,UAAU,MAAM;OAAU,WAAW,QAAQ;OAAa,KAAK,QAAQ;OAAY,WAAW,QAAQ;MAAU,GAAG,SAAS;KACnJ;IACF;IACA,kBAAkB,MAAM,SAAS,KAAK;IACtC,cAAc,OAAe,MAAM,SAAS,IAAI,EAAY,KAAK;GACnE;EACF;CACF;;;;;;CAMA,eAAe;AACjB,GAAG,cAAc"}

package/dist/interactions/actions/resize/aspect.js

@@ -0,0 +1,44 @@
+import { EPS } from "../../../features/snap/resizeBox.js";
+
+//#region src/interactions/actions/resize/aspect.ts
+/** `b` with the axis an edge handle leaves free scaled to keep `origin`'s
+*  aspect, centered on `origin`. A corner comes back unchanged: `onDiagonal`
+*  already put its pointer on the diagonal. */
+function edgeAspect(b, origin, anchor) {
+	if (anchor.x === "free" === (anchor.y === "free") || origin.width === 0 || origin.height === 0) return b;
+	const ratio = origin.width / origin.height;
+	if (anchor.x === "free") {
+		const width = Math.abs(b.height * ratio);
+		return {
+			...b,
+			x: origin.x + origin.width / 2 - width / 2,
+			width
+		};
+	}
+	const height = Math.abs(b.width / ratio);
+	return {
+		...b,
+		y: origin.y + origin.height / 2 - height / 2,
+		height
+	};
+}
+/** A corner drag's `local` delta put on the diagonal of `drawn`, scaled by
+*  whichever axis it grows the box more on relative to its size, so the
+*  corner keeps up with the cursor on that axis. Null for an edge handle or
+*  a box with no area. */
+function onDiagonal(local, drawn, anchor) {
+	if (anchor.x === "free" || anchor.y === "free" || Math.abs(drawn.width) < EPS || Math.abs(drawn.height) < EPS) return null;
+	const dx = anchor.x === "min" ? drawn.width : -drawn.width;
+	const dy = anchor.y === "min" ? drawn.height : -drawn.height;
+	const sx = local.x / dx;
+	const sy = local.y / dy;
+	const s = Math.abs(sx) >= Math.abs(sy) ? sx : sy;
+	return {
+		x: s * dx,
+		y: s * dy
+	};
+}
+
+//#endregion
+export { edgeAspect, onDiagonal };
+//# sourceMappingURL=aspect.js.map

package/dist/interactions/actions/resize/aspect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aspect.js","names":[],"sources":["../../../../src/interactions/actions/resize/aspect.ts"],"sourcesContent":["import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { EPS } from 'features/snap/resizeBox';\nimport type { ResizeAnchor } from '../../gestures/types';\n\n/** `b` with the axis an edge handle leaves free scaled to keep `origin`'s\n *  aspect, centered on `origin`. A corner comes back unchanged: `onDiagonal`\n *  already put its pointer on the diagonal. */\nexport function edgeAspect(b: Bounds, origin: Bounds, anchor: ResizeAnchor): Bounds {\n  if ((anchor.x === 'free') === (anchor.y === 'free') || origin.width === 0 || origin.height === 0) return b;\n  const ratio = origin.width / origin.height;\n  if (anchor.x === 'free') {\n    const width = Math.abs(b.height * ratio);\n    return { ...b, x: origin.x + origin.width / 2 - width / 2, width };\n  }\n  const height = Math.abs(b.width / ratio);\n  return { ...b, y: origin.y + origin.height / 2 - height / 2, height };\n}\n\n/** A corner drag's `local` delta put on the diagonal of `drawn`, scaled by\n *  whichever axis it grows the box more on relative to its size, so the\n *  corner keeps up with the cursor on that axis. Null for an edge handle or\n *  a box with no area. */\nexport function onDiagonal(local: { x: number; y: number }, drawn: Bounds, anchor: ResizeAnchor): { x: number; y: number } | null {\n  if (anchor.x === 'free' || anchor.y === 'free' || Math.abs(drawn.width) < EPS || Math.abs(drawn.height) < EPS) return null;\n  const dx = anchor.x === 'min' ? drawn.width : -drawn.width;\n  const dy = anchor.y === 'min' ? drawn.height : -drawn.height;\n  const sx = local.x / dx;\n  const sy = local.y / dy;\n  const s = Math.abs(sx) >= Math.abs(sy) ? sx : sy;\n  return { x: s * dx, y: s * dy };\n}\n"],"mappings":";;;;;;AAOA,SAAgB,WAAW,GAAW,QAAgB,QAA8B;CAClF,IAAK,OAAO,MAAM,YAAa,OAAO,MAAM,WAAW,OAAO,UAAU,KAAK,OAAO,WAAW,GAAG,OAAO;CACzG,MAAM,QAAQ,OAAO,QAAQ,OAAO;CACpC,IAAI,OAAO,MAAM,QAAQ;EACvB,MAAM,QAAQ,KAAK,IAAI,EAAE,SAAS,KAAK;EACvC,OAAO;GAAE,GAAG;GAAG,GAAG,OAAO,IAAI,OAAO,QAAQ,IAAI,QAAQ;GAAG;EAAM;CACnE;CACA,MAAM,SAAS,KAAK,IAAI,EAAE,QAAQ,KAAK;CACvC,OAAO;EAAE,GAAG;EAAG,GAAG,OAAO,IAAI,OAAO,SAAS,IAAI,SAAS;EAAG;CAAO;AACtE;;;;;AAMA,SAAgB,WAAW,OAAiC,OAAe,QAAuD;CAChI,IAAI,OAAO,MAAM,UAAU,OAAO,MAAM,UAAU,KAAK,IAAI,MAAM,KAAK,IAAI,OAAO,KAAK,IAAI,MAAM,MAAM,IAAI,KAAK,OAAO;CACtH,MAAM,KAAK,OAAO,MAAM,QAAQ,MAAM,QAAQ,CAAC,MAAM;CACrD,MAAM,KAAK,OAAO,MAAM,QAAQ,MAAM,SAAS,CAAC,MAAM;CACtD,MAAM,KAAK,MAAM,IAAI;CACrB,MAAM,KAAK,MAAM,IAAI;CACrB,MAAM,IAAI,KAAK,IAAI,EAAE,KAAK,KAAK,IAAI,EAAE,IAAI,KAAK;CAC9C,OAAO;EAAE,GAAG,IAAI;EAAI,GAAG,IAAI;CAAG;AAChC"}

package/dist/interactions/actions/resize/behaviors/clampMinSize.js

@@ -1,18 +1,43 @@
 //#region src/interactions/actions/resize/behaviors/clampMinSize.ts
-function e(e) {
-	let { minWidth: t, minHeight: n } = e;
-	return { onMove(e, { pose: r, anchor: i }) {
-		let { x: a, y: o, width: s, height: c } = r, l = !1;
-		if (i.x !== "free" && s < t && (i.x === "min" || (a = a + s - t), s = t, l = !0), i.y !== "free" && c < n && (i.y === "min" || (o = o + c - n), c = n, l = !0), l) return { pose: {
-			...r,
-			x: a,
-			y: o,
-			width: s,
-			height: c
-		} };
+/** `pose` grown to `min` on each axis `anchor` lets the drag move, holding
+*  the anchored edge: the dragged edge is pushed back rather than the node
+*  moved, and a box dragged past its anchor comes back to the minimum on the
+*  anchor's side. `null` when `pose` already meets it. */
+function clampToMinSize(pose, anchor, min) {
+	let { x, y, width, height } = pose;
+	let changed = false;
+	if (anchor.x !== "free" && width < min.width) {
+		if (anchor.x === "max") x += width - min.width;
+		width = min.width;
+		changed = true;
+	}
+	if (anchor.y !== "free" && height < min.height) {
+		if (anchor.y === "max") y += height - min.height;
+		height = min.height;
+		changed = true;
+	}
+	return changed ? {
+		...pose,
+		x,
+		y,
+		width,
+		height
+	} : null;
+}
+/** Resize constraint that stops a node shrinking past a minimum. The anchored
+*  edge stays put, so clamping pushes the dragged edge back rather than moving
+*  the node. */
+function clampMinSize(args) {
+	const min = {
+		width: args.minWidth,
+		height: args.minHeight
+	};
+	return { onMove(_ctx, { pose, anchor }) {
+		const clamped = clampToMinSize(pose, anchor, min);
+		return clamped ? { pose: clamped } : void 0;
 	} };
 }
-//#endregion
-export { e as clampMinSize };
 
+//#endregion
+export { clampMinSize, clampToMinSize };
 //# sourceMappingURL=clampMinSize.js.map

package/dist/interactions/actions/resize/behaviors/clampMinSize.js.map

@@ -1 +1 @@
-{"version":3,"file":"clampMinSize.js","names":["clampMinSize","args","pose","changed","anchor","width","minWidth","x","height","minHeight","y"],"sources":["../../../../../src/interactions/actions/resize/behaviors/clampMinSize.ts"],"sourcesContent":["import type { BoundsConstraint } from '../../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** Resize constraint that stops a node shrinking past a minimum. The anchored\n *  edge stays put, so clamping pushes the dragged edge back rather than moving\n *  the node. */\nexport function clampMinSize<TPose extends Bounds>(args: {\n  minWidth: number;\n  minHeight: number;\n}): BoundsConstraint<TPose> {\n  const { minWidth, minHeight } = args;\n  return {\n    onMove(_ctx, { pose, anchor }) {\n      let { x, y, width, height } = pose;\n      let changed = false;\n      if (anchor.x !== 'free' && width < minWidth) {\n        if (anchor.x === 'min') {\n          // West edge is anchor; east edge was dragged. Hold x; widen to min.\n          width = minWidth;\n        } else {\n          // East edge is anchor at originalRight = x + width. Hold the right;\n          // shift x left so width = minWidth.\n          const right = x + width;\n          x = right - minWidth;\n          width = minWidth;\n        }\n        changed = true;\n      }\n      if (anchor.y !== 'free' && height < minHeight) {\n        if (anchor.y === 'min') {\n          height = minHeight;\n        } else {\n          const bottom = y + height;\n          y = bottom - minHeight;\n          height = minHeight;\n        }\n        changed = true;\n      }\n      if (!changed) return;\n      return { pose: { ...pose, x, y, width, height } };\n    },\n  };\n}\n"],"mappings":";AAMA,SAAgBA,EAAmC,GAGvB;CAC1B,IAAM,EAAE,aAAU,iBAAcC;CAChC,OAAO,EACL,OAAO,GAAM,EAAE,SAAM,aAAU;EAC7B,IAAI,EAAE,MAAG,MAAG,UAAO,cAAWC,GAC1BC,IAAU;EAwBd,IAvBIC,EAAO,MAAM,UAAUC,IAAQC,MAC7BF,EAAO,MAAM,UAOf,IADcG,IAAIF,IACNC,IALZ,IAAQA,GAQV,IAAU,KAERF,EAAO,MAAM,UAAUI,IAASC,MAC9BL,EAAO,MAAM,UAIf,IADeM,IAAIF,IACNC,IAHb,IAASA,GAMX,IAAU,KAEPN,GACL,OAAO,EAAE,MAAM;GAAE,GAAGD;GAAM;GAAG;GAAG;GAAO;EAAO,EAAE;CAClD,EACF;AACF"}
+{"version":3,"file":"clampMinSize.js","names":[],"sources":["../../../../../src/interactions/actions/resize/behaviors/clampMinSize.ts"],"sourcesContent":["import type { BoundsConstraint, ResizeAnchor } from '../../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** `pose` grown to `min` on each axis `anchor` lets the drag move, holding\n *  the anchored edge: the dragged edge is pushed back rather than the node\n *  moved, and a box dragged past its anchor comes back to the minimum on the\n *  anchor's side. `null` when `pose` already meets it. */\nexport function clampToMinSize<TPose extends Bounds>(\n  pose: TPose,\n  anchor: ResizeAnchor,\n  min: { width: number; height: number },\n): TPose | null {\n  let { x, y, width, height } = pose;\n  let changed = false;\n  if (anchor.x !== 'free' && width < min.width) {\n    // Anchored west, the east edge was dragged: hold x. Anchored east, hold\n    // the right edge.\n    if (anchor.x === 'max') x += width - min.width;\n    width = min.width;\n    changed = true;\n  }\n  if (anchor.y !== 'free' && height < min.height) {\n    if (anchor.y === 'max') y += height - min.height;\n    height = min.height;\n    changed = true;\n  }\n  return changed ? { ...pose, x, y, width, height } : null;\n}\n\n/** Resize constraint that stops a node shrinking past a minimum. The anchored\n *  edge stays put, so clamping pushes the dragged edge back rather than moving\n *  the node. */\nexport function clampMinSize<TPose extends Bounds>(args: {\n  minWidth: number;\n  minHeight: number;\n}): BoundsConstraint<TPose> {\n  const min = { width: args.minWidth, height: args.minHeight };\n  return {\n    onMove(_ctx, { pose, anchor }) {\n      const clamped = clampToMinSize(pose, anchor, min);\n      return clamped ? { pose: clamped } : undefined;\n    },\n  };\n}\n"],"mappings":";;;;;AAOA,SAAgB,eACd,MACA,QACA,KACc;CACd,IAAI,EAAE,GAAG,GAAG,OAAO,WAAW;CAC9B,IAAI,UAAU;CACd,IAAI,OAAO,MAAM,UAAU,QAAQ,IAAI,OAAO;EAG5C,IAAI,OAAO,MAAM,OAAO,KAAK,QAAQ,IAAI;EACzC,QAAQ,IAAI;EACZ,UAAU;CACZ;CACA,IAAI,OAAO,MAAM,UAAU,SAAS,IAAI,QAAQ;EAC9C,IAAI,OAAO,MAAM,OAAO,KAAK,SAAS,IAAI;EAC1C,SAAS,IAAI;EACb,UAAU;CACZ;CACA,OAAO,UAAU;EAAE,GAAG;EAAM;EAAG;EAAG;EAAO;CAAO,IAAI;AACtD;;;;AAKA,SAAgB,aAAmC,MAGvB;CAC1B,MAAM,MAAM;EAAE,OAAO,KAAK;EAAU,QAAQ,KAAK;CAAU;CAC3D,OAAO,EACL,OAAO,MAAM,EAAE,MAAM,UAAU;EAC7B,MAAM,UAAU,eAAe,MAAM,QAAQ,GAAG;EAChD,OAAO,UAAU,EAAE,MAAM,QAAQ,IAAI;CACvC,EACF;AACF"}

package/dist/interactions/actions/resize/boxFrame.js

@@ -1,16 +1,20 @@
-import { targetTransformOf as e } from "../../../core/geometry/targetFrame.js";
+import { targetTransformOf } from "../../../core/geometry/targetFrame.js";
+
 //#region src/interactions/actions/resize/boxFrame.ts
-function t(t, n) {
-	return e({
-		x: n.x,
-		y: n.y,
-		width: n.width,
-		height: n.height,
-		rotation: t.rotation,
-		transform: t.transform
+/** The frame `bounds` is drawn in while a box with this rotation and
+*  `transform` is resized: both about `bounds`' own center, which moves as
+*  the box does. */
+function boxFrame(box, bounds) {
+	return targetTransformOf({
+		x: bounds.x,
+		y: bounds.y,
+		width: bounds.width,
+		height: bounds.height,
+		rotation: box.rotation,
+		transform: box.transform
 	});
 }
-//#endregion
-export { t as boxFrame };
 
+//#endregion
+export { boxFrame };
 //# sourceMappingURL=boxFrame.js.map

package/dist/interactions/actions/resize/boxFrame.js.map

@@ -1 +1 @@
-{"version":3,"file":"boxFrame.js","names":["boxFrame","targetTransformOf","bounds","box"],"sources":["../../../../src/interactions/actions/resize/boxFrame.ts"],"sourcesContent":["import type { PoseLinear } from '@weasel-js/geom';\nimport { targetTransformOf, type TargetTransform } from 'core/geometry/targetFrame';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** The frame `bounds` is drawn in while a box with this rotation and\n *  `transform` is resized: both about `bounds`' own center, which moves as\n *  the box does. */\nexport function boxFrame(\n  box: { readonly rotation: number; readonly transform?: PoseLinear },\n  bounds: Bounds,\n): TargetTransform {\n  return targetTransformOf({\n    x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height,\n    rotation: box.rotation, transform: box.transform,\n  });\n}\n"],"mappings":";;AAOA,SAAgBA,EACd,GACA,GACiB;CACjB,OAAOC,EAAkB;EACvB,GAAGC,EAAO;EAAG,GAAGA,EAAO;EAAG,OAAOA,EAAO;EAAO,QAAQA,EAAO;EAC9D,UAAUC,EAAI;EAAU,WAAWA,EAAI;CACzC,CAAC;AACH"}
+{"version":3,"file":"boxFrame.js","names":[],"sources":["../../../../src/interactions/actions/resize/boxFrame.ts"],"sourcesContent":["import type { PoseLinear } from '@weasel-js/geom';\nimport { targetTransformOf, type TargetTransform } from 'core/geometry/targetFrame';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** The frame `bounds` is drawn in while a box with this rotation and\n *  `transform` is resized: both about `bounds`' own center, which moves as\n *  the box does. */\nexport function boxFrame(\n  box: { readonly rotation: number; readonly transform?: PoseLinear },\n  bounds: Bounds,\n): TargetTransform {\n  return targetTransformOf({\n    x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height,\n    rotation: box.rotation, transform: box.transform,\n  });\n}\n"],"mappings":";;;;;;AAOA,SAAgB,SACd,KACA,QACiB;CACjB,OAAO,kBAAkB;EACvB,GAAG,OAAO;EAAG,GAAG,OAAO;EAAG,OAAO,OAAO;EAAO,QAAQ,OAAO;EAC9D,UAAU,IAAI;EAAU,WAAW,IAAI;CACzC,CAAC;AACH"}