@weasel-js/core 1.9.4 → 1.10.0

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

@@ -0,0 +1,124 @@
+import { unionAABB as e } from "../../../core/geometry/unionBounds.js";
+import { visualBoundsViaDescriptor as t } from "../../../core/geometry/poseDescriptor.js";
+import { poseDescriptorOf as n } from "../poseDescriptorDep.js";
+import { shapeSources as r } from "../selectionSubtree.js";
+import { createTransformOp as i } from "../../../core/ops/transform.js";
+import { geometryDataOp as a } from "../geometryProjection.js";
+import { scenePoseFrame as o } from "../poseFrame.js";
+import { defaultCommitAdapter as s } from "../defaultCommitAdapter.js";
+import { FlipXIcon as c, FlipYIcon as l } from "../defaults/icons/editIcons.js";
+import { requiresSelection as u } from "../defaults/requiresSelection.js";
+import { flipPoseAboutBounds as d, flipPoseViaDescriptor as f } from "./helpers.js";
+import { actionReferenceSources as p, resolveSpatialReference as m } from "../spatialReference.js";
+import { multiply as h, rotate as g, translate as _ } from "@weasel-js/geom";
+import { createElement as v } from "react";
+//#region src/interactions/actions/flip/action.ts
+function y(e, t, n, r) {
+	let i = t.local(n, {
+		x: r.x + r.width / 2,
+		y: r.y + r.height / 2,
+		width: 0,
+		height: 0,
+		rotation: 0
+	}), a = i.rotation ?? 0, o = e === "x" ? [
+		-1,
+		0,
+		0,
+		1,
+		0,
+		0
+	] : [
+		1,
+		0,
+		0,
+		-1,
+		0,
+		0
+	], s = h(h(g(a), o), g(-a));
+	return h(_(i.x, i.y), h(s, _(-i.x, -i.y)));
+}
+function b(n, c, l, u, h, g, _, v, b) {
+	let x = n.get();
+	if (x.length === 0) return;
+	let S = o(c), C = [], w = /* @__PURE__ */ new Map();
+	for (let e of x) {
+		let n = r(c, [e]), i = n.length !== 1 || n[0] !== e ? t(S.world(e), _) : null;
+		for (let e of n) C.includes(e) || (C.push(e), i && w.set(e, i));
+	}
+	let T = /* @__PURE__ */ new Map();
+	for (let e of C) c.get(e) !== void 0 && T.set(e, S.world(e));
+	let E = null;
+	if (u === "union") E = e([...T.values()].map((e) => t(e, _)));
+	else if (u !== "each" && (E = m(u, p(v, b, c, S, _)), E === null)) return;
+	let D = [];
+	for (let e of C) {
+		let t = c.get(e);
+		if (!t) continue;
+		let n = T.get(e), r = E ?? w.get(e) ?? null, o = r ? d(n, l, _, r) : f(n, l, _);
+		D.push(i({
+			id: e,
+			from: t.pose,
+			to: S.local(e, o),
+			label: "Flip"
+		}));
+		let s = r ?? _.getBounds(n), u = a(g, {
+			id: e,
+			data: t.data,
+			pose: t.pose
+		}, y(l, S, e, s), "Flip");
+		u && D.push(u);
+	}
+	D.length !== 0 && (h ? h(D, "Flip") : c.applyBatch(D, "Flip", s(c, n.adapterMethods)));
+}
+var x = {
+	id: "flip",
+	label: "Flip",
+	group: "flip",
+	variants: [{
+		key: "x",
+		label: "Flip Horizontal",
+		icon: v(c),
+		params: { axis: "x" }
+	}, {
+		key: "y",
+		label: "Flip Vertical",
+		icon: v(l),
+		params: { axis: "y" }
+	}],
+	defaultBinding: [{
+		spec: {
+			kind: "key",
+			key: ["h", "H"],
+			mods: { shift: !0 }
+		},
+		opts: { params: { axis: "x" } }
+	}, {
+		spec: {
+			kind: "key",
+			key: ["v", "V"],
+			mods: { shift: !0 }
+		},
+		opts: { params: { axis: "y" } }
+	}],
+	eligible: { capability: "transforms-selection" },
+	requires: [
+		"selection",
+		"scene",
+		"applyOps",
+		"geometryProjection",
+		"poseDescriptor",
+		"pointer"
+	],
+	invoker: {
+		timing: "immediate",
+		run: (e, t) => {
+			let r = t?.axis ?? "x", i = t?.pivot ?? "each", a = e.selection, o = e.scene, s = e.applyOps, c = e.geometryProjection;
+			a && o && b(a, o, r, i, s, c, n(e.poseDescriptor), t, e.pointer);
+		}
+	},
+	enabled: u
+};
+//#endregion
+export { x as flipAction };
+
+//# sourceMappingURL=action.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["localMirror","at","frame","id","pivotWorld","theta","mirror","axis","turned","multiply","rotate","translate","flipSelection","selected","selection","scenePoseFrame","scene","ids","ownPivot","members","shapeSources","box","visualBoundsViaDescriptor","geom","member","worlds","sharedPivot","pivot","unionAABB","p","resolveSpatialReference","actionReferenceSources","params","pointer","ops","node","world","about","flipped","flipPoseAboutBounds","flipPoseViaDescriptor","createTransformOp","g","dataOp","geometryDataOp","geometryProjection","applyOps","defaultCommitAdapter","flipAction","createElement","FlipXIcon","FlipYIcon","deps","poseDescriptorOf","requiresSelection"],"sources":["../../../../src/interactions/actions/flip/action.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { shapeSources } from '../selectionSubtree';\nimport { createElement } from 'react';\nimport { FlipXIcon, FlipYIcon } from '../defaults/icons/editIcons';\nimport type { Op } from 'core/ops/types';\nimport { multiply, rotate, translate, type Mat3 } from '@weasel-js/geom';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { PoseDescriptor } from '../resize/geometry';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport {\n  flipPoseAboutBounds,\n  flipPoseViaDescriptor,\n  type FlipAxis,\n  type FlipPivot,\n} from './helpers';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport { visualBoundsViaDescriptor } from '../align/align';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { actionReferenceSources, resolveSpatialReference } from '../spatialReference';\nimport type { PointerContextValue } from '@weasel-js/routing/react';\nimport type { RectPose } from 'core/scene/types';\nimport type { Action } from '@weasel-js/routing';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { requiresSelection } from '../defaults/requiresSelection';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { geometryDataOp, type GeometryProjection } from '../geometryProjection';\n\n/**\n * The world mirror about `axis` through the center of `pivotWorld`, written in\n * the frame `id` stores its data in. `geometryProjection.transform` is given\n * the affine the node's own pose underwent, and data-held geometry is local —\n * so a world mirror has to be conjugated by the frame or an asymmetric shape\n * reflects across the wrong line while its pose lands correctly.\n *\n * The frame's turn comes back as the rotation on a rebased zero-size pose at\n * the pivot point, so no composition strategy has to expose one.\n */\nfunction localMirror(\n  axis: FlipAxis,\n  frame: PoseFrame<unknown>,\n  id: Parameters<PoseFrame<unknown>['local']>[0],\n  pivotWorld: { x: number; y: number; width: number; height: number },\n): Mat3 {\n  const at = frame.local(id, {\n    x: pivotWorld.x + pivotWorld.width / 2,\n    y: pivotWorld.y + pivotWorld.height / 2,\n    width: 0,\n    height: 0,\n    rotation: 0,\n  }) as RectPose;\n  const theta = at.rotation ?? 0;\n  const mirror: Mat3 = axis === 'x' ? [-1, 0, 0, 1, 0, 0] : [1, 0, 0, -1, 0, 0];\n  const turned = multiply(multiply(rotate(theta), mirror), rotate(-theta));\n  return multiply(translate(at.x, at.y), multiply(turned, translate(-at.x, -at.y)));\n}\n\n/**\n * Flip the current selection in `scene` along `axis`, as one undo entry.\n *\n * Pivot: `'each'` (per-item own AABB) unless the caller passes `'union'`,\n * which mirrors every pose about the selection's *visual* union AABB — the\n * rotated ink extents — so items swap sides as well as reflect, or a\n * `SpatialReference`, which mirrors about the center of what it names. A rotated\n * member's own mirrored position needs no expansion: `axisAlignedBounds`\n * keeps the stored box's center, so mirroring either box lands the same place.\n */\nfunction flipSelection(\n  selection: SelectionApi,\n  scene: Scene<unknown, string, unknown>,\n  axis: FlipAxis,\n  pivot: FlipPivot,\n  applyOps: ((ops: Op[], label: string) => void) | undefined,\n  geometryProjection: GeometryProjection | undefined,\n  geom: PoseDescriptor<unknown>,\n  params: Record<string, unknown> | undefined,\n  pointer: PointerContextValue | undefined,\n): void {\n  const selected = selection.get();\n  if (selected.length === 0) return;\n  const frame = scenePoseFrame(scene);\n\n  // A group whose pose derives from its children mirrors by mirroring them,\n  // about the group's own box where each selected node flips in place.\n  const ids: NodeId[] = [];\n  const ownPivot = new Map<string, Bounds>();\n  for (const id of selected) {\n    const members = shapeSources(scene, [id]) as NodeId[];\n    const stoodIn = members.length !== 1 || members[0] !== id;\n    const box = stoodIn ? visualBoundsViaDescriptor(frame.world(id), geom) : null;\n    for (const member of members) {\n      if (ids.includes(member)) continue;\n      ids.push(member);\n      if (box) ownPivot.set(member, box);\n    }\n  }\n\n  const worlds = new Map<string, unknown>();\n  for (const id of ids) {\n    if (scene.get(id) !== undefined) worlds.set(id as string, frame.world(id));\n  }\n  let sharedPivot: ReturnType<typeof unionAABB> = null;\n  if (pivot === 'union') {\n    sharedPivot = unionAABB([...worlds.values()].map((p) => visualBoundsViaDescriptor(p, geom)));\n  } else if (pivot !== 'each') {\n    sharedPivot = resolveSpatialReference(pivot, actionReferenceSources(params, pointer, scene, frame, geom));\n    if (sharedPivot === null) return;\n  }\n\n  const ops: Op[] = [];\n  for (const id of ids) {\n    const node = scene.get(id);\n    if (!node) continue;\n    const world = worlds.get(id as string)!;\n    const about = sharedPivot ?? ownPivot.get(id as string) ?? null;\n    const flipped = about\n      ? flipPoseAboutBounds(world, axis, geom, about)\n      : flipPoseViaDescriptor(world, axis, geom);\n    ops.push(createTransformOp<unknown>({\n      id: id as string,\n      from: node.pose,\n      to: frame.local(id, flipped),\n      label: 'Flip',\n    }));\n    // Mirror the data-held geometry about the SAME pivot the pose flip uses.\n    // A pose-only flip of a bare-AABB pose is identity, so this data op is\n    // the only way an asymmetric shape actually mirrors.\n    const g = about ?? geom.getBounds(world);\n    const dataOp = geometryDataOp(\n      geometryProjection,\n      { id: id as string, data: node.data, pose: node.pose },\n      localMirror(axis, frame, id, g),\n      'Flip',\n    );\n    if (dataOp) ops.push(dataOp);\n  }\n  if (ops.length === 0) return;\n\n  if (applyOps) applyOps(ops, 'Flip');\n  else scene.applyBatch(ops, 'Flip', defaultCommitAdapter(scene, selection.adapterMethods));\n}\n\n/**\n * @experimental\n * Flips the selection. `params.axis` (`'x'` | `'y'`, default `'x'`) picks the\n * direction, and the optional `params.pivot` (a `FlipPivot`, default `'each'`)\n * picks what it mirrors about.\n */\nexport const flipAction: Action & { requires: string[] } = {\n  id: 'flip',\n  label: 'Flip',\n  group: 'flip',\n  variants: [\n    { key: 'x', label: 'Flip Horizontal', icon: createElement(FlipXIcon), params: { axis: 'x' } },\n    { key: 'y', label: 'Flip Vertical', icon: createElement(FlipYIcon), params: { axis: 'y' } },\n  ],\n  defaultBinding: [\n    { spec: { kind: 'key', key: ['h', 'H'], mods: { shift: true } }, opts: { params: { axis: 'x' } } },\n    { spec: { kind: 'key', key: ['v', 'V'], mods: { shift: true } }, opts: { params: { axis: 'y' } } },\n  ],\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'applyOps', 'geometryProjection', 'poseDescriptor', 'pointer'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps, params) => {\n      const axis = (params?.axis as FlipAxis | undefined) ?? 'x';\n      const pivot = (params?.pivot as FlipPivot | undefined) ?? 'each';\n      const selection = deps.selection;\n      const scene = deps.scene;\n      const applyOps = deps.applyOps;\n      const geometryProjection = deps.geometryProjection;\n      if (!selection || !scene) return;\n      flipSelection(\n        selection, scene, axis, pivot, applyOps, geometryProjection,\n        poseDescriptorOf(deps.poseDescriptor),\n        params, deps.pointer,\n      );\n    },\n  },\n  enabled: requiresSelection,\n};\n"],"mappings":";;;;;;;;;;;;;;;AAsCA,SAASA,EACP,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAKC,EAAM,MAAMC,GAAI;EACzB,GAAGC,EAAW,IAAIA,EAAW,QAAQ;EACrC,GAAGA,EAAW,IAAIA,EAAW,SAAS;EACtC,OAAO;EACP,QAAQ;EACR,UAAU;CACZ,CAAC,GACKC,IAAQJ,EAAG,YAAY,GACvBK,IAAeC,MAAS,MAAM;EAAC;EAAI;EAAG;EAAG;EAAG;EAAG;CAAC,IAAI;EAAC;EAAG;EAAG;EAAG;EAAI;EAAG;CAAC,GACtEC,IAASC,EAASA,EAASC,EAAOL,CAAK,GAAGC,CAAM,GAAGI,EAAO,CAACL,CAAK,CAAC;CACvE,OAAOI,EAASE,EAAUV,EAAG,GAAGA,EAAG,CAAC,GAAGQ,EAASD,GAAQG,EAAU,CAACV,EAAG,GAAG,CAACA,EAAG,CAAC,CAAC,CAAC;AAClF;AAYA,SAASW,EACP,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAWC,EAAU,IAAI;CAC/B,IAAID,EAAS,WAAW,GAAG;CAC3B,IAAMX,IAAQa,EAAeC,CAAK,GAI5BC,IAAgB,CAAC,GACjBC,oBAAW,IAAI,IAAoB;CACzC,KAAK,IAAMf,KAAMU,GAAU;EACzB,IAAMM,IAAUC,EAAaJ,GAAO,CAACb,CAAE,CAAC,GAElCkB,IADUF,EAAQ,WAAW,KAAKA,EAAQ,OAAOhB,IACjCmB,EAA0BpB,EAAM,MAAMC,CAAE,GAAGoB,CAAI,IAAI;EACzE,KAAK,IAAMC,KAAUL,GACnB,AAAIF,EAAI,SAASO,CAAM,MACvBP,EAAI,KAAKO,CAAM,GACXH,KAAKH,EAAS,IAAIM,GAAQH,CAAG;CAErC;CAEA,IAAMI,oBAAS,IAAI,IAAqB;CACxC,KAAK,IAAMtB,KAAMc,GACf,AAAID,EAAM,IAAIb,CAAE,MAAM,KAAA,KAAWsB,EAAO,IAAItB,GAAcD,EAAM,MAAMC,CAAE,CAAC;CAE3E,IAAIuB,IAA4C;CAChD,IAAIC,MAAU,SACZ,IAAcC,EAAU,CAAC,GAAGH,EAAO,OAAO,CAAC,CAAC,CAAC,KAAK,MAAMH,EAA0BO,GAAGN,CAAI,CAAC,CAAC;MACtF,IAAII,MAAU,WACnB,IAAcG,EAAwBH,GAAOI,EAAuBC,GAAQC,GAASjB,GAAOd,GAAOqB,CAAI,CAAC,GACpGG,MAAgB,OAAM;CAG5B,IAAMQ,IAAY,CAAC;CACnB,KAAK,IAAM/B,KAAMc,GAAK;EACpB,IAAMkB,IAAOnB,EAAM,IAAIb,CAAE;EACzB,IAAI,CAACgC,GAAM;EACX,IAAMC,IAAQX,EAAO,IAAItB,CAAY,GAC/BkC,IAAQX,KAAeR,EAAS,IAAIf,CAAY,KAAK,MACrDmC,IAAUD,IACZE,EAAoBH,GAAO7B,GAAMgB,GAAMc,CAAK,IAC5CG,EAAsBJ,GAAO7B,GAAMgB,CAAI;EAC3C,EAAI,KAAKkB,EAA2B;GAC9B;GACJ,MAAMN,EAAK;GACX,IAAIjC,EAAM,MAAMC,GAAImC,CAAO;GAC3B,OAAO;EACT,CAAC,CAAC;EAIF,IAAMI,IAAIL,KAASd,EAAK,UAAUa,CAAK,GACjCO,IAASC,EACbC,GACA;GAAM;GAAc,MAAMV,EAAK;GAAM,MAAMA,EAAK;EAAK,GACrDnC,EAAYO,GAAML,GAAOC,GAAIuC,CAAC,GAC9B,MACF;EACA,AAAIC,KAAQT,EAAI,KAAKS,CAAM;CAC7B;CACA,AAAIT,EAAI,WAAW,MAEfY,IAAUA,EAASZ,GAAK,MAAM,IAC7BlB,EAAM,WAAWkB,GAAK,QAAQa,EAAqB/B,GAAOF,EAAU,cAAc,CAAC;AAC1F;AAQA,IAAakC,IAA8C;CACzD,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,CACR;EAAE,KAAK;EAAK,OAAO;EAAmB,MAAMC,EAAcC,CAAS;EAAG,QAAQ,EAAE,MAAM,IAAI;CAAE,GAC5F;EAAE,KAAK;EAAK,OAAO;EAAiB,MAAMD,EAAcE,CAAS;EAAG,QAAQ,EAAE,MAAM,IAAI;CAAE,CAC5F;CACA,gBAAgB,CACd;EAAE,MAAM;GAAE,MAAM;GAAO,KAAK,CAAC,KAAK,GAAG;GAAG,MAAM,EAAE,OAAO,GAAK;EAAE;EAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,EAAE;CAAE,GACjG;EAAE,MAAM;GAAE,MAAM;GAAO,KAAK,CAAC,KAAK,GAAG;GAAG,MAAM,EAAE,OAAO,GAAK;EAAE;EAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,EAAE;CAAE,CACnG;CACA,UAAU,EAAE,YAAY,uBAAuB;CAC/C,UAAU;EAAC;EAAa;EAAS;EAAY;EAAsB;EAAkB;CAAS;CAC9F,SAAS;EACP,QAAQ;EACR,MAAM,GAAM,MAAW;GACrB,IAAM5C,IAAQyB,GAAQ,QAAiC,KACjDL,IAASK,GAAQ,SAAmC,QACpDlB,IAAYsC,EAAK,WACjBpC,IAAQoC,EAAK,OACbN,IAAWM,EAAK,UAChBP,IAAqBO,EAAK;GAChC,AAAKtC,KAAcE,KACnBJ,EACEE,GAAWE,GAAOT,GAAMoB,GAAOmB,GAAUD,GACzCQ,EAAiBD,EAAK,cAAc,GACpCpB,GAAQoB,EAAK,OACf;EACF;CACF;CACA,SAASE;AACX"}

package/dist/interactions/actions/flip/helpers.js

@@ -1,4 +1,4 @@
-import { poseLinearOf as e } from "../../../core/geometry/poseFrame.js";
+import { poseLinearOf as e } from "@weasel-js/geom";
 //#region src/interactions/actions/flip/helpers.ts
 function t(e, t, n, o) {
 	let s = n.getBounds(e), c = o.x + o.width / 2, l = o.y + o.height / 2, u = t === "x" ? {

package/dist/interactions/actions/flip/helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.js","names":["flipPoseAboutBounds","src","geometry","pose","cxPivot","pivotBounds","cyPivot","dst","axis","next","rotation","mirrorLinear","negateRotation","normalizeNegativeExtent","flipPoseViaDescriptor","p","mutated","nx","ny","nw","nh","l","poseLinearOf"],"sources":["../../../../src/interactions/actions/flip/helpers.ts"],"sourcesContent":["/**\n * Pose-flip helpers used by `flipAction` (via `defaults/flip.ts`).\n *\n * These were extracted from the legacy `useFlip` hook when it was removed —\n * they remain because the descriptor-style `flipAction` still needs to reflect\n * arbitrary `TPose` values through a `PoseDescriptor`.\n */\nimport type { PoseDescriptor } from '../resize/geometry';\nimport type { SpatialReference } from '../spatialReference';\nimport { poseLinearOf } from 'core/geometry/poseFrame';\n\n/** Axis for flip. `'x'` mirrors horizontally (left↔right); `'y'` mirrors vertically (top↔bottom). */\nexport type FlipAxis = 'x' | 'y';\n\n/** How a multi-selection flip chooses its pivot.\n *\n *  - `'each'` — every pose mirrors about its own AABB; spatial layout of the\n *    selection is unchanged, individual items are reflected in place.\n *  - `'union'` — every pose mirrors about the selection's union AABB; items\n *    swap sides as well as reflect, matching Illustrator/Figma defaults.\n *  - a {@link SpatialReference} — every pose mirrors about the center of the\n *    bounds it names: the pointer, a world point or rect, or a key node. */\nexport type FlipPivot = 'each' | 'union' | SpatialReference;\n\n/** Reflect `pose` across the centerline of `pivotBounds` along `axis`, using\n *  `geometry` to read bounds and remap. The pose's own AABB is read once to\n *  compute the reflected destination rect; coords inside the pose are then\n *  remapped through the affine that takes its own bounds → reflected dst.\n *  A rotation the pose carries is negated: a mirror reverses the sense of the\n *  turn, and `remapBounds` carries the original angle through untouched. A\n *  `transform` it carries is mirrored the same way, on either axis. */\nexport function flipPoseAboutBounds<TPose>(\n  pose: TPose,\n  axis: FlipAxis,\n  geometry: PoseDescriptor<TPose>,\n  pivotBounds: { x: number; y: number; width: number; height: number },\n): TPose {\n  const src = geometry.getBounds(pose);\n  const cxPivot = pivotBounds.x + pivotBounds.width / 2;\n  const cyPivot = pivotBounds.y + pivotBounds.height / 2;\n  const dst = axis === 'x'\n    ? { x: 2 * cxPivot - src.x, y: src.y, width: -src.width, height: src.height }\n    : { x: src.x, y: 2 * cyPivot - src.y, width: src.width, height: -src.height };\n  const next = geometry.remapBounds(pose, src, dst);\n  const rotation = geometry.getRotation?.(pose) ?? (src as { rotation?: number }).rotation ?? 0;\n  return mirrorLinear(negateRotation(normalizeNegativeExtent(next), rotation, geometry));\n}\n\n/** Reflect `pose` across the centerline of its own AABB along `axis`. */\nexport function flipPoseViaDescriptor<TPose>(\n  pose: TPose,\n  axis: FlipAxis,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  return flipPoseAboutBounds(pose, axis, geometry, geometry.getBounds(pose));\n}\n\nfunction negateRotation<TPose>(pose: TPose, rotation: number, geometry: PoseDescriptor<TPose>): TPose {\n  if (rotation === 0) return pose;\n  return geometry.withRotation ? geometry.withRotation(pose, -rotation) : pose;\n}\n\nfunction normalizeNegativeExtent<TPose>(pose: TPose): TPose {\n  const p = pose as unknown as { x?: number; y?: number; width?: number; height?: number };\n  let mutated = false;\n  let nx = p.x;\n  let ny = p.y;\n  let nw = p.width;\n  let nh = p.height;\n  if (typeof nw === 'number' && nw < 0 && typeof nx === 'number') {\n    nx = nx + nw;\n    nw = -nw;\n    mutated = true;\n  }\n  if (typeof nh === 'number' && nh < 0 && typeof ny === 'number') {\n    ny = ny + nh;\n    nh = -nh;\n    mutated = true;\n  }\n  if (!mutated) return pose;\n  return { ...(pose as object), x: nx, y: ny, width: nw, height: nh } as TPose;\n}\n\n/** `M · L · M` for a mirror `M` on either axis: the off-diagonal terms change sign. */\nfunction mirrorLinear<TPose>(pose: TPose): TPose {\n  const l = poseLinearOf(pose);\n  if (!l || (l[1] === 0 && l[2] === 0)) return pose;\n  return { ...(pose as object), transform: [l[0], -l[1], -l[2], l[3]] } as TPose;\n}\n"],"mappings":";;AA+BA,SAAgBA,EACd,GACA,GACA,GACA,GACO;CACP,IAAMC,IAAMC,EAAS,UAAUC,CAAI,GAC7BC,IAAUC,EAAY,IAAIA,EAAY,QAAQ,GAC9CC,IAAUD,EAAY,IAAIA,EAAY,SAAS,GAC/CE,IAAMC,MAAS,MACjB;EAAE,GAAG,IAAIJ,IAAUH,EAAI;EAAG,GAAGA,EAAI;EAAG,OAAO,CAACA,EAAI;EAAO,QAAQA,EAAI;CAAO,IAC1E;EAAE,GAAGA,EAAI;EAAG,GAAG,IAAIK,IAAUL,EAAI;EAAG,OAAOA,EAAI;EAAO,QAAQ,CAACA,EAAI;CAAO,GACxEQ,IAAOP,EAAS,YAAYC,GAAMF,GAAKM,CAAG,GAC1CG,IAAWR,EAAS,cAAcC,CAAI,KAAMF,EAA8B,YAAY;CAC5F,OAAOU,EAAaC,EAAeC,EAAwBJ,CAAI,GAAGC,GAAUR,CAAQ,CAAC;AACvF;AAGA,SAAgBY,EACd,GACA,GACA,GACO;CACP,OAAOd,EAAoBG,GAAMK,GAAMN,GAAUA,EAAS,UAAUC,CAAI,CAAC;AAC3E;AAEA,SAASS,EAAsB,GAAa,GAAkB,GAAwC;CAEpG,OADIF,MAAa,IAAUP,IACpBD,EAAS,eAAeA,EAAS,aAAaC,GAAM,CAACO,CAAQ,IAAIP;AAC1E;AAEA,SAASU,EAA+B,GAAoB;CAC1D,IAAME,IAAIZ,GACNa,IAAU,IACVC,IAAKF,EAAE,GACPG,IAAKH,EAAE,GACPI,IAAKJ,EAAE,OACPK,IAAKL,EAAE;CAYX,OAXI,OAAOI,KAAO,YAAYA,IAAK,KAAK,OAAOF,KAAO,aACpD,KAAUE,GACV,IAAK,CAACA,GACN,IAAU,KAER,OAAOC,KAAO,YAAYA,IAAK,KAAK,OAAOF,KAAO,aACpD,KAAUE,GACV,IAAK,CAACA,GACN,IAAU,KAEPJ,IACE;EAAE,GAAIb;EAAiB,GAAGc;EAAI,GAAGC;EAAI,OAAOC;EAAI,QAAQC;CAAG,IAD7CjB;AAEvB;AAGA,SAASQ,EAAoB,GAAoB;CAC/C,IAAMU,IAAIC,EAAanB,CAAI;CAE3B,OADI,CAACkB,KAAMA,EAAE,OAAO,KAAKA,EAAE,OAAO,IAAWlB,IACtC;EAAE,GAAIA;EAAiB,WAAW;GAACkB,EAAE;GAAI,CAACA,EAAE;GAAI,CAACA,EAAE;GAAIA,EAAE;EAAE;CAAE;AACtE"}
+{"version":3,"file":"helpers.js","names":["flipPoseAboutBounds","src","geometry","pose","cxPivot","pivotBounds","cyPivot","dst","axis","next","rotation","mirrorLinear","negateRotation","normalizeNegativeExtent","flipPoseViaDescriptor","p","mutated","nx","ny","nw","nh","l","poseLinearOf"],"sources":["../../../../src/interactions/actions/flip/helpers.ts"],"sourcesContent":["/**\n * Pose-flip helpers used by `flipAction` (via `defaults/flip.ts`).\n *\n * These were extracted from the legacy `useFlip` hook when it was removed —\n * they remain because the descriptor-style `flipAction` still needs to reflect\n * arbitrary `TPose` values through a `PoseDescriptor`.\n */\nimport type { PoseDescriptor } from '../resize/geometry';\nimport type { SpatialReference } from '../spatialReference';\nimport { poseLinearOf } from '@weasel-js/geom';\n\n/** Axis for flip. `'x'` mirrors horizontally (left↔right); `'y'` mirrors vertically (top↔bottom). */\nexport type FlipAxis = 'x' | 'y';\n\n/** How a multi-selection flip chooses its pivot.\n *\n *  - `'each'` — every pose mirrors about its own AABB; spatial layout of the\n *    selection is unchanged, individual items are reflected in place.\n *  - `'union'` — every pose mirrors about the selection's union AABB; items\n *    swap sides as well as reflect, matching Illustrator/Figma defaults.\n *  - a {@link SpatialReference} — every pose mirrors about the center of the\n *    bounds it names: the pointer, a world point or rect, or a key node. */\nexport type FlipPivot = 'each' | 'union' | SpatialReference;\n\n/** Reflect `pose` across the centerline of `pivotBounds` along `axis`, using\n *  `geometry` to read bounds and remap. The pose's own AABB is read once to\n *  compute the reflected destination rect; coords inside the pose are then\n *  remapped through the affine that takes its own bounds → reflected dst.\n *  A rotation the pose carries is negated: a mirror reverses the sense of the\n *  turn, and `remapBounds` carries the original angle through untouched. A\n *  `transform` it carries is mirrored the same way, on either axis. */\nexport function flipPoseAboutBounds<TPose>(\n  pose: TPose,\n  axis: FlipAxis,\n  geometry: PoseDescriptor<TPose>,\n  pivotBounds: { x: number; y: number; width: number; height: number },\n): TPose {\n  const src = geometry.getBounds(pose);\n  const cxPivot = pivotBounds.x + pivotBounds.width / 2;\n  const cyPivot = pivotBounds.y + pivotBounds.height / 2;\n  const dst = axis === 'x'\n    ? { x: 2 * cxPivot - src.x, y: src.y, width: -src.width, height: src.height }\n    : { x: src.x, y: 2 * cyPivot - src.y, width: src.width, height: -src.height };\n  const next = geometry.remapBounds(pose, src, dst);\n  const rotation = geometry.getRotation?.(pose) ?? (src as { rotation?: number }).rotation ?? 0;\n  return mirrorLinear(negateRotation(normalizeNegativeExtent(next), rotation, geometry));\n}\n\n/** Reflect `pose` across the centerline of its own AABB along `axis`. */\nexport function flipPoseViaDescriptor<TPose>(\n  pose: TPose,\n  axis: FlipAxis,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  return flipPoseAboutBounds(pose, axis, geometry, geometry.getBounds(pose));\n}\n\nfunction negateRotation<TPose>(pose: TPose, rotation: number, geometry: PoseDescriptor<TPose>): TPose {\n  if (rotation === 0) return pose;\n  return geometry.withRotation ? geometry.withRotation(pose, -rotation) : pose;\n}\n\nfunction normalizeNegativeExtent<TPose>(pose: TPose): TPose {\n  const p = pose as unknown as { x?: number; y?: number; width?: number; height?: number };\n  let mutated = false;\n  let nx = p.x;\n  let ny = p.y;\n  let nw = p.width;\n  let nh = p.height;\n  if (typeof nw === 'number' && nw < 0 && typeof nx === 'number') {\n    nx = nx + nw;\n    nw = -nw;\n    mutated = true;\n  }\n  if (typeof nh === 'number' && nh < 0 && typeof ny === 'number') {\n    ny = ny + nh;\n    nh = -nh;\n    mutated = true;\n  }\n  if (!mutated) return pose;\n  return { ...(pose as object), x: nx, y: ny, width: nw, height: nh } as TPose;\n}\n\n/** `M · L · M` for a mirror `M` on either axis: the off-diagonal terms change sign. */\nfunction mirrorLinear<TPose>(pose: TPose): TPose {\n  const l = poseLinearOf(pose);\n  if (!l || (l[1] === 0 && l[2] === 0)) return pose;\n  return { ...(pose as object), transform: [l[0], -l[1], -l[2], l[3]] } as TPose;\n}\n"],"mappings":";;AA+BA,SAAgBA,EACd,GACA,GACA,GACA,GACO;CACP,IAAMC,IAAMC,EAAS,UAAUC,CAAI,GAC7BC,IAAUC,EAAY,IAAIA,EAAY,QAAQ,GAC9CC,IAAUD,EAAY,IAAIA,EAAY,SAAS,GAC/CE,IAAMC,MAAS,MACjB;EAAE,GAAG,IAAIJ,IAAUH,EAAI;EAAG,GAAGA,EAAI;EAAG,OAAO,CAACA,EAAI;EAAO,QAAQA,EAAI;CAAO,IAC1E;EAAE,GAAGA,EAAI;EAAG,GAAG,IAAIK,IAAUL,EAAI;EAAG,OAAOA,EAAI;EAAO,QAAQ,CAACA,EAAI;CAAO,GACxEQ,IAAOP,EAAS,YAAYC,GAAMF,GAAKM,CAAG,GAC1CG,IAAWR,EAAS,cAAcC,CAAI,KAAMF,EAA8B,YAAY;CAC5F,OAAOU,EAAaC,EAAeC,EAAwBJ,CAAI,GAAGC,GAAUR,CAAQ,CAAC;AACvF;AAGA,SAAgBY,EACd,GACA,GACA,GACO;CACP,OAAOd,EAAoBG,GAAMK,GAAMN,GAAUA,EAAS,UAAUC,CAAI,CAAC;AAC3E;AAEA,SAASS,EAAsB,GAAa,GAAkB,GAAwC;CAEpG,OADIF,MAAa,IAAUP,IACpBD,EAAS,eAAeA,EAAS,aAAaC,GAAM,CAACO,CAAQ,IAAIP;AAC1E;AAEA,SAASU,EAA+B,GAAoB;CAC1D,IAAME,IAAIZ,GACNa,IAAU,IACVC,IAAKF,EAAE,GACPG,IAAKH,EAAE,GACPI,IAAKJ,EAAE,OACPK,IAAKL,EAAE;CAYX,OAXI,OAAOI,KAAO,YAAYA,IAAK,KAAK,OAAOF,KAAO,aACpD,KAAUE,GACV,IAAK,CAACA,GACN,IAAU,KAER,OAAOC,KAAO,YAAYA,IAAK,KAAK,OAAOF,KAAO,aACpD,KAAUE,GACV,IAAK,CAACA,GACN,IAAU,KAEPJ,IACE;EAAE,GAAIb;EAAiB,GAAGc;EAAI,GAAGC;EAAI,OAAOC;EAAI,QAAQC;CAAG,IAD7CjB;AAEvB;AAGA,SAASQ,EAAoB,GAAoB;CAC/C,IAAMU,IAAIC,EAAanB,CAAI;CAE3B,OADI,CAACkB,KAAMA,EAAE,OAAO,KAAKA,EAAE,OAAO,IAAWlB,IACtC;EAAE,GAAIA;EAAiB,WAAW;GAACkB,EAAE;GAAI,CAACA,EAAE;GAAI,CAACA,EAAE;GAAIA,EAAE;EAAE;CAAE;AACtE"}

package/dist/interactions/actions/gestureFrames.js

@@ -0,0 +1,18 @@
+import { planeOf as e } from "./planeInput.js";
+import { scenePoseFrame as t } from "./poseFrame.js";
+//#region src/interactions/actions/gestureFrames.ts
+function n(n, r, i = t(n)) {
+	return {
+		world: (e) => i.world(e),
+		toWorld: (e, t) => {
+			let n = i.parentWorld(e);
+			return n === null ? t : i.pc.compose(n, t);
+		},
+		toLocal: (e, t) => i.local(e, t),
+		planeOf: (t) => e(r, t)
+	};
+}
+//#endregion
+export { n as sceneGestureFrames };
+
+//# sourceMappingURL=gestureFrames.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gestureFrames.js","names":["sceneGestureFrames","scenePoseFrame","scene","frame","id","parent","pose","worldPose","planeOf","view","layer"],"sources":["../../../src/interactions/actions/gestureFrames.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport type { GestureFrames } from '../gestures/types';\nimport { planeOf } from './planeInput';\nimport { scenePoseFrame, type PoseFrame } from './poseFrame';\n\n/** A scene-backed gesture's {@link GestureFrames}. `view` is the `view` dep. */\nexport function sceneGestureFrames(\n  scene: Scene<unknown, string, unknown>,\n  view: unknown,\n  frame: PoseFrame<unknown> = scenePoseFrame(scene),\n): GestureFrames<unknown> {\n  return {\n    world: (id) => frame.world(id as NodeId),\n    toWorld: (id, pose) => {\n      const parent = frame.parentWorld(id as NodeId);\n      return parent === null ? pose : frame.pc.compose(parent, pose);\n    },\n    toLocal: (id, worldPose) => frame.local(id as NodeId, worldPose),\n    planeOf: (layer) => planeOf(view, layer),\n  };\n}\n"],"mappings":";;;AAMA,SAAgBA,EACd,GACA,GACA,IAA4BC,EAAeC,CAAK,GACxB;CACxB,OAAO;EACL,QAAQ,MAAOC,EAAM,MAAMC,CAAY;EACvC,UAAU,GAAI,MAAS;GACrB,IAAMC,IAASF,EAAM,YAAYC,CAAY;GAC7C,OAAOC,MAAW,OAAOC,IAAOH,EAAM,GAAG,QAAQE,GAAQC,CAAI;EAC/D;EACA,UAAU,GAAI,MAAcH,EAAM,MAAMC,GAAcG,CAAS;EAC/D,UAAU,MAAUC,EAAQC,GAAMC,CAAK;CACzC;AACF"}

package/dist/interactions/actions/gestureLifecycle.js

@@ -1,9 +1,10 @@
+import { SceneArrivalRefused as e } from "../../core/scene/arrivals.js";
 //#region src/interactions/actions/gestureLifecycle.ts
-function e(e) {
+function t(e) {
 	let t = {};
 	return e.label !== void 0 && (t.label = e.label), e.transient !== void 0 && (t.transient = e.transient), e.onGestureStart && (t.onGestureStart = e.onGestureStart), e.onGestureEnd && (t.onGestureEnd = e.onGestureEnd), t;
 }
-function t(e, t, n = []) {
+function n(e, t, n = []) {
 	let r = e ?? {}, i = !1, a = !1;
 	return {
 		label: r.label ?? t,
@@ -17,28 +18,54 @@ function t(e, t, n = []) {
 		}
 	};
 }
-function n(e, t, n) {
-	if (t.transient) {
-		e.scene.untracked(() => {
-			for (let t of n) t.apply(e.adapter);
-		});
-		return;
+function r(t, n, r) {
+	if (n.transient) {
+		try {
+			t.scene.untracked(() => {
+				for (let e of r) e.apply(t.adapter);
+			});
+		} catch (t) {
+			if (!(t instanceof e)) throw t;
+			return !1;
+		}
+		return !0;
 	}
-	let r = t.labelFor(n);
-	e.applyOps ? e.applyOps(n, r) : e.scene.applyBatch(n, r, e.adapter);
-}
-function r(e, t) {
-	let n;
-	for (let r of e) {
-		let e = r.onEnd?.(t, { answered: n !== void 0 });
-		n === void 0 && e !== void 0 && (n = e);
+	let i = n.labelFor(r);
+	return t.applyOps ? (t.applyOps(r, i), !0) : t.scene.applyBatch(r, i, t.adapter);
+}
+function i(e, t, ...[n]) {
+	let r, i = !1;
+	return a(e, (e) => {
+		try {
+			let a = e.onEnd?.(t, {
+				...n,
+				answered: i || r !== void 0
+			});
+			r === void 0 && a !== void 0 && (r = a);
+		} catch (e) {
+			throw i = !0, e;
+		}
+	}), r;
+}
+function a(e, t) {
+	let n = [];
+	for (let r of e) try {
+		t(r);
+	} catch (e) {
+		n.push(e);
 	}
-	return n;
+	if (n.length > 0) throw n[0];
+}
+function o(e, t) {
+	a(e, (e) => e.onCancel?.(t));
+}
+function s(e, t, n) {
+	a(e, (e) => e.onSettled?.(t, n));
 }
-function i(e, t) {
-	for (let n of e) n.onCancel?.(t);
+function c(e, t) {
+	e.hold.drop(), e.previews.clear(), a([() => s(e.behaviors, e.ctx, t), () => e.lifecycle.end(t)], (e) => e());
 }
 //#endregion
-export { n as commitGestureOps, e as gestureLifecycleParams, t as readGestureLifecycle, r as reduceBehaviorEnd, i as runBehaviorCancel };
+export { c as closeGesture, r as commitGestureOps, t as gestureLifecycleParams, n as readGestureLifecycle, i as reduceBehaviorEnd, o as runBehaviorCancel, s as runBehaviorSettled };
 
 //# sourceMappingURL=gestureLifecycle.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"gestureLifecycle.js","names":["gestureLifecycleParams","out","o","readGestureLifecycle","source","started","ended","defaultLabel","ops","behaviors","b","ids","committed","commitGestureOps","lifecycle","op","target","label","reduceBehaviorEnd","answer","r","ctx","runBehaviorCancel"],"sources":["../../../src/interactions/actions/gestureLifecycle.ts"],"sourcesContent":["/**\n * The lifecycle the ongoing transform actions (`move`, `resize`, `rotate`)\n * share: what their committed batch is called in history, whether it is\n * recorded at all, and the callbacks fired as the gesture opens and closes.\n *\n * Move and rotate read it from their binding's params; resize reads it from\n * the `resizePolicy` dep, where the rest of its options already live.\n */\nimport type { Op } from 'core/ops/types';\nimport type { Scene } from 'core/scene/types';\nimport type { BehaviorEnd } from 'interactions/gestures/types';\n\n/** The lifecycle options, as a binding's params or the resize policy carry\n *  them. */\nexport interface GestureLifecycleOptions {\n  /** History label for the committed batch. Unset, the batch takes its first\n   *  op's label (a layout drop or a behavior names its own), else the\n   *  action's. */\n  label?: string;\n  /** Commit through `scene.untracked`: the edit lands, but no undo entry\n   *  records it and the consumer `applyOps` hook is bypassed. Unset, any\n   *  behavior's `defaultTransient: true` turns it on. */\n  transient?: boolean;\n  /** Fired once the gesture starts changing poses, with the ids it moves. */\n  onGestureStart?(ids: string[]): void;\n  /** Fired once per `onGestureStart`: `true` when the gesture wrote to the\n   *  document, `false` on cancel, abort, or a release with nothing to write. */\n  onGestureEnd?(committed: boolean): void;\n}\n\n/** The params entries for {@link GestureLifecycleOptions}, with the unset\n *  keys left out. */\nexport function gestureLifecycleParams(o: GestureLifecycleOptions): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  if (o.label !== undefined) out.label = o.label;\n  if (o.transient !== undefined) out.transient = o.transient;\n  if (o.onGestureStart) out.onGestureStart = o.onGestureStart;\n  if (o.onGestureEnd) out.onGestureEnd = o.onGestureEnd;\n  return out;\n}\n\n/** A gesture's resolved lifecycle. `start` and `end` fire their callbacks at\n *  most once each, and `end` only after `start`. */\nexport interface GestureLifecycle {\n  /** The label ops built by the action itself carry. */\n  readonly label: string;\n  /** The history label for committing `ops`. */\n  labelFor(ops: readonly Op[]): string;\n  readonly transient: boolean;\n  start(ids: readonly string[]): void;\n  end(committed: boolean): void;\n}\n\nexport function readGestureLifecycle(\n  source: GestureLifecycleOptions | Record<string, unknown> | undefined,\n  defaultLabel: string,\n  behaviors: readonly { defaultTransient?: boolean }[] = [],\n): GestureLifecycle {\n  const o = (source ?? {}) as GestureLifecycleOptions;\n  let started = false;\n  let ended = false;\n  return {\n    label: o.label ?? defaultLabel,\n    labelFor: (ops) => o.label ?? ops[0]?.label ?? defaultLabel,\n    transient: o.transient ?? behaviors.some((b) => b.defaultTransient === true),\n    start(ids) {\n      if (started) return;\n      started = true;\n      o.onGestureStart?.([...ids]);\n    },\n    end(committed) {\n      if (!started || ended) return;\n      ended = true;\n      o.onGestureEnd?.(committed);\n    },\n  };\n}\n\n/** Commit a gesture's ops: untracked when transient, else through the\n *  consumer `applyOps` hook when one is wired, else into the scene's history. */\nexport function commitGestureOps(\n  target: {\n    scene: Scene<unknown, string, unknown>;\n    applyOps?: (ops: Op[], label: string) => void;\n    adapter: unknown;\n  },\n  lifecycle: GestureLifecycle,\n  ops: Op[],\n): void {\n  if (lifecycle.transient) {\n    target.scene.untracked(() => {\n      for (const op of ops) op.apply(target.adapter);\n    });\n    return;\n  }\n  const label = lifecycle.labelFor(ops);\n  if (target.applyOps) target.applyOps(ops, label);\n  else target.scene.applyBatch(ops, label, target.adapter);\n}\n\n/** Runs every behavior's `onEnd` in order; the first that answers decides the\n *  commit and later answers are ignored. `null` aborts, `Op[]` claims it (an\n *  empty array included), and `undefined` means every behavior deferred to the\n *  action's own commit. */\nexport function reduceBehaviorEnd<TCtx>(\n  behaviors: readonly { onEnd?(ctx: TCtx, end: BehaviorEnd): Op[] | null | void }[],\n  ctx: TCtx,\n): Op[] | null | undefined {\n  let answer: Op[] | null | undefined;\n  for (const b of behaviors) {\n    const r = b.onEnd?.(ctx, { answered: answer !== undefined });\n    if (answer === undefined && r !== undefined) answer = r;\n  }\n  return answer;\n}\n\n/** Runs every behavior's `onCancel`, for a gesture closing without a commit. */\nexport function runBehaviorCancel<TCtx>(\n  behaviors: readonly { onCancel?(ctx: TCtx): void }[],\n  ctx: TCtx,\n): void {\n  for (const b of behaviors) b.onCancel?.(ctx);\n}\n"],"mappings":";AAgCA,SAAgBA,EAAuB,GAAqD;CAC1F,IAAMC,IAA+B,CAAC;CAKtC,OAJIC,EAAE,UAAU,KAAA,MAAW,EAAI,QAAQA,EAAE,QACrCA,EAAE,cAAc,KAAA,MAAW,EAAI,YAAYA,EAAE,YAC7CA,EAAE,mBAAgB,EAAI,iBAAiBA,EAAE,iBACzCA,EAAE,iBAAc,EAAI,eAAeA,EAAE,eAClCD;AACT;AAcA,SAAgBE,EACd,GACA,GACA,IAAuD,CAAC,GACtC;CAClB,IAAMD,IAAKE,KAAU,CAAC,GAClBC,IAAU,IACVC,IAAQ;CACZ,OAAO;EACL,OAAOJ,EAAE,SAASK;EAClB,WAAW,MAAQL,EAAE,SAASM,EAAI,EAAE,EAAE,SAASD;EAC/C,WAAWL,EAAE,aAAaO,EAAU,MAAM,MAAMC,EAAE,qBAAqB,EAAI;EAC3E,MAAM,GAAK;GACT,AAAIL,MACJ,IAAU,IACVH,EAAE,iBAAiB,CAAC,GAAGS,CAAG,CAAC;EAC7B;EACA,IAAI,GAAW;GACb,AAAKN,KAAW,OAChB,IAAQ,IACRH,EAAE,eAAeU,CAAS;EAC5B;CACF;AACF;AAIA,SAAgBC,EACd,GAKA,GACA,GACM;CACN,IAAIC,EAAU,WAAW;EACvB,EAAO,MAAM,gBAAgB;GAC3B,KAAK,IAAMC,KAAMP,GAAK,EAAG,MAAMQ,EAAO,OAAO;EAC/C,CAAC;EACD;CACF;CACA,IAAMC,IAAQH,EAAU,SAASN,CAAG;CACpC,AAAIQ,EAAO,WAAUA,EAAO,SAASR,GAAKS,CAAK,IAC1CD,EAAO,MAAM,WAAWR,GAAKS,GAAOD,EAAO,OAAO;AACzD;AAMA,SAAgBE,EACd,GACA,GACyB;CACzB,IAAIC;CACJ,KAAK,IAAMT,KAAKD,GAAW;EACzB,IAAMW,IAAIV,EAAE,QAAQW,GAAK,EAAE,UAAUF,MAAW,KAAA,EAAU,CAAC;EAC3D,AAAIA,MAAW,KAAA,KAAaC,MAAM,KAAA,MAAW,IAASA;CACxD;CACA,OAAOD;AACT;AAGA,SAAgBG,EACd,GACA,GACM;CACN,KAAK,IAAMZ,KAAKD,GAAW,EAAE,WAAWY,CAAG;AAC7C"}
+{"version":3,"file":"gestureLifecycle.js","names":["gestureLifecycleParams","out","o","readGestureLifecycle","source","started","ended","defaultLabel","ops","behaviors","b","ids","committed","commitGestureOps","lifecycle","op","target","err","SceneArrivalRefused","label","reduceBehaviorEnd","own","answer","threw","runEvery","r","ctx","errors","item","items","runBehaviorCancel","runBehaviorSettled","closeGesture","gesture","step"],"sources":["../../../src/interactions/actions/gestureLifecycle.ts"],"sourcesContent":["/**\n * The lifecycle the ongoing transform actions (`move`, `resize`, `rotate`)\n * share: what their committed batch is called in history, whether it is\n * recorded at all, and the callbacks fired as the gesture opens and closes.\n *\n * Move and rotate read it from their binding's params; resize reads it from\n * the `resizePolicy` dep, where the rest of its options already live.\n */\nimport type { Op } from 'core/ops/types';\nimport { SceneArrivalRefused } from 'core/scene/arrivals';\nimport type { Scene } from 'core/scene/types';\nimport type { BehaviorEnd } from 'interactions/gestures/types';\nimport type { NodeId, PoseHold } from 'core/scene/types';\n\n/** The lifecycle options, as a binding's params or the resize policy carry\n *  them. */\nexport interface GestureLifecycleOptions {\n  /** History label for the committed batch. Unset, the batch takes its first\n   *  op's label (a layout drop or a behavior names its own), else the\n   *  action's. */\n  label?: string;\n  /** Commit through `scene.untracked`: the edit lands, but no undo entry\n   *  records it and the consumer `applyOps` hook is bypassed. Unset, any\n   *  behavior's `defaultTransient: true` turns it on. */\n  transient?: boolean;\n  /** Fired once the gesture starts changing poses, with the ids it moves. */\n  onGestureStart?(ids: string[]): void;\n  /** Fired once per `onGestureStart`: `true` when the gesture wrote to the\n   *  document, `false` on cancel, abort, or a release with nothing to write. */\n  onGestureEnd?(committed: boolean): void;\n}\n\n/** The params entries for {@link GestureLifecycleOptions}, with the unset\n *  keys left out. */\nexport function gestureLifecycleParams(o: GestureLifecycleOptions): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  if (o.label !== undefined) out.label = o.label;\n  if (o.transient !== undefined) out.transient = o.transient;\n  if (o.onGestureStart) out.onGestureStart = o.onGestureStart;\n  if (o.onGestureEnd) out.onGestureEnd = o.onGestureEnd;\n  return out;\n}\n\n/** A gesture's resolved lifecycle. `start` and `end` fire their callbacks at\n *  most once each, and `end` only after `start`. */\nexport interface GestureLifecycle {\n  /** The label ops built by the action itself carry. */\n  readonly label: string;\n  /** The history label for committing `ops`. */\n  labelFor(ops: readonly Op[]): string;\n  readonly transient: boolean;\n  start(ids: readonly string[]): void;\n  end(committed: boolean): void;\n}\n\nexport function readGestureLifecycle(\n  source: GestureLifecycleOptions | Record<string, unknown> | undefined,\n  defaultLabel: string,\n  behaviors: readonly { defaultTransient?: boolean }[] = [],\n): GestureLifecycle {\n  const o = (source ?? {}) as GestureLifecycleOptions;\n  let started = false;\n  let ended = false;\n  return {\n    label: o.label ?? defaultLabel,\n    labelFor: (ops) => o.label ?? ops[0]?.label ?? defaultLabel,\n    transient: o.transient ?? behaviors.some((b) => b.defaultTransient === true),\n    start(ids) {\n      if (started) return;\n      started = true;\n      o.onGestureStart?.([...ids]);\n    },\n    end(committed) {\n      if (!started || ended) return;\n      ended = true;\n      o.onGestureEnd?.(committed);\n    },\n  };\n}\n\n/** Commit a gesture's ops: untracked when transient, else through the\n *  consumer `applyOps` hook when one is wired, else into the scene's history.\n *  Returns whether the commit landed: false when a container refused what\n *  the ops brought it, which the scene reverts. A consumer's `applyOps` may\n *  keep the document elsewhere, so it is taken at its word. */\nexport function commitGestureOps(\n  target: {\n    scene: Scene<unknown, string, unknown>;\n    applyOps?: (ops: Op[], label: string) => void;\n    adapter: unknown;\n  },\n  lifecycle: GestureLifecycle,\n  ops: Op[],\n): boolean {\n  if (lifecycle.transient) {\n    try {\n      target.scene.untracked(() => {\n        for (const op of ops) op.apply(target.adapter);\n      });\n    } catch (err) {\n      // `untracked` lets a refused arrival out; `applyBatch` swallows it.\n      if (!(err instanceof SceneArrivalRefused)) throw err;\n      return false;\n    }\n    return true;\n  }\n  const label = lifecycle.labelFor(ops);\n  if (!target.applyOps) return target.scene.applyBatch(ops, label, target.adapter);\n  target.applyOps(ops, label);\n  return true;\n}\n\n/** The trailing argument of {@link reduceBehaviorEnd}: what `TEnd` adds to\n *  `BehaviorEnd`, required exactly when it adds something. */\ntype OwnEndFields<TEnd extends BehaviorEnd> = keyof Omit<TEnd, keyof BehaviorEnd> extends never\n  ? [own?: Omit<TEnd, keyof BehaviorEnd>]\n  : [own: Omit<TEnd, keyof BehaviorEnd>];\n\n/** Runs every behavior's `onEnd` in order; the first that answers decides the\n *  commit and later answers are ignored. `null` aborts, `Op[]` claims it (an\n *  empty array included), and `undefined` means every behavior deferred to the\n *  action's own commit. An action whose behaviors take more than a plain\n *  `BehaviorEnd` passes the rest as `own`; each `onEnd` gets it beside\n *  `answered`. One that throws does not stop the rest, which are told the\n *  commit is decided; its error is rethrown after, so nothing commits. */\nexport function reduceBehaviorEnd<TCtx, TEnd extends BehaviorEnd = BehaviorEnd>(\n  behaviors: readonly { onEnd?(ctx: TCtx, end: TEnd): Op[] | null | void }[],\n  ctx: TCtx,\n  ...[own]: OwnEndFields<TEnd>\n): Op[] | null | undefined {\n  let answer: Op[] | null | undefined;\n  let threw = false;\n  runEvery(behaviors, (b) => {\n    try {\n      const r = b.onEnd?.(ctx, { ...own, answered: threw || answer !== undefined } as TEnd);\n      if (answer === undefined && r !== undefined) answer = r;\n    } catch (err) {\n      threw = true;\n      throw err;\n    }\n  });\n  return answer;\n}\n\n/** Runs `step` for every item, a throwing one included, then rethrows the\n *  first error. For steps that each release something of their own. */\nfunction runEvery<T>(items: readonly T[], step: (item: T) => void): void {\n  const errors: unknown[] = [];\n  for (const item of items) {\n    try {\n      step(item);\n    } catch (err) {\n      errors.push(err);\n    }\n  }\n  if (errors.length > 0) throw errors[0];\n}\n\n/** Runs every behavior's `onCancel`, for a gesture closing without a commit.\n *  One that throws does not stop the rest; its error is rethrown after. */\nexport function runBehaviorCancel<TCtx>(\n  behaviors: readonly { onCancel?(ctx: TCtx): void }[],\n  ctx: TCtx,\n): void {\n  runEvery(behaviors, (b) => b.onCancel?.(ctx));\n}\n\n/** Runs every behavior's `onSettled`, once the gesture's commit has landed or\n *  its cancel has run. One that throws does not stop the rest; its error is\n *  rethrown after. */\nexport function runBehaviorSettled<TCtx>(\n  behaviors: readonly { onSettled?(ctx: TCtx, committed: boolean): void }[],\n  ctx: TCtx,\n  committed: boolean,\n): void {\n  runEvery(behaviors, (b) => b.onSettled?.(ctx, committed));\n}\n\n/** What {@link closeGesture} closes. */\nexport interface ClosingGesture<TCtx> {\n  hold: PoseHold<unknown>;\n  /** The action's own buffer of this frame's poses, emptied at the close. */\n  previews: Map<NodeId, unknown>;\n  behaviors: readonly { onSettled?(ctx: TCtx, committed: boolean): void }[];\n  ctx: TCtx;\n  lifecycle: GestureLifecycle;\n}\n\n/**\n * The close a transform action runs from its `finally`, commit or cancel:\n * drop the preview overrides, tell the behaviors, then fire `onGestureEnd`,\n * which fires even when a behavior's `onSettled` throws; the first error is\n * rethrown.\n */\nexport function closeGesture<TCtx>(gesture: ClosingGesture<TCtx>, committed: boolean): void {\n  gesture.hold.drop();\n  gesture.previews.clear();\n  runEvery([\n    () => runBehaviorSettled(gesture.behaviors, gesture.ctx, committed),\n    () => gesture.lifecycle.end(committed),\n  ], (step) => step());\n}\n"],"mappings":";;AAkCA,SAAgBA,EAAuB,GAAqD;CAC1F,IAAMC,IAA+B,CAAC;CAKtC,OAJIC,EAAE,UAAU,KAAA,MAAW,EAAI,QAAQA,EAAE,QACrCA,EAAE,cAAc,KAAA,MAAW,EAAI,YAAYA,EAAE,YAC7CA,EAAE,mBAAgB,EAAI,iBAAiBA,EAAE,iBACzCA,EAAE,iBAAc,EAAI,eAAeA,EAAE,eAClCD;AACT;AAcA,SAAgBE,EACd,GACA,GACA,IAAuD,CAAC,GACtC;CAClB,IAAMD,IAAKE,KAAU,CAAC,GAClBC,IAAU,IACVC,IAAQ;CACZ,OAAO;EACL,OAAOJ,EAAE,SAASK;EAClB,WAAW,MAAQL,EAAE,SAASM,EAAI,EAAE,EAAE,SAASD;EAC/C,WAAWL,EAAE,aAAaO,EAAU,MAAM,MAAMC,EAAE,qBAAqB,EAAI;EAC3E,MAAM,GAAK;GACT,AAAIL,MACJ,IAAU,IACVH,EAAE,iBAAiB,CAAC,GAAGS,CAAG,CAAC;EAC7B;EACA,IAAI,GAAW;GACb,AAAKN,KAAW,OAChB,IAAQ,IACRH,EAAE,eAAeU,CAAS;EAC5B;CACF;AACF;AAOA,SAAgBC,EACd,GAKA,GACA,GACS;CACT,IAAIC,EAAU,WAAW;EACvB,IAAI;GACF,EAAO,MAAM,gBAAgB;IAC3B,KAAK,IAAMC,KAAMP,GAAK,EAAG,MAAMQ,EAAO,OAAO;GAC/C,CAAC;EACH,SAASC,GAAK;GAEZ,IAAI,EAAEA,aAAeC,IAAsB,MAAMD;GACjD,OAAO;EACT;EACA,OAAO;CACT;CACA,IAAME,IAAQL,EAAU,SAASN,CAAG;CAGpC,OAFKQ,EAAO,YACZA,EAAO,SAASR,GAAKW,CAAK,GACnB,MAFsBH,EAAO,MAAM,WAAWR,GAAKW,GAAOH,EAAO,OAAO;AAGjF;AAeA,SAAgBI,EACd,GACA,GACA,GAAG,CAACC,IACqB;CACzB,IAAIC,GACAC,IAAQ;CAUZ,OATAC,EAASf,IAAY,MAAM;EACzB,IAAI;GACF,IAAMgB,IAAIf,EAAE,QAAQgB,GAAK;IAAE,GAAGL;IAAK,UAAUE,KAASD,MAAW,KAAA;GAAU,CAAS;GACpF,AAAIA,MAAW,KAAA,KAAaG,MAAM,KAAA,MAAW,IAASA;EACxD,SAASR,GAAK;GAEZ,MADA,IAAQ,IACFA;EACR;CACF,CAAC,GACMK;AACT;AAIA,SAASE,EAAY,GAAqB,GAA+B;CACvE,IAAMG,IAAoB,CAAC;CAC3B,KAAK,IAAMC,KAAQC,GACjB,IAAI;EACF,EAAKD,CAAI;CACX,SAASX,GAAK;EACZ,EAAO,KAAKA,CAAG;CACjB;CAEF,IAAIU,EAAO,SAAS,GAAG,MAAMA,EAAO;AACtC;AAIA,SAAgBG,EACd,GACA,GACM;CACN,EAASrB,IAAY,MAAMC,EAAE,WAAWgB,CAAG,CAAC;AAC9C;AAKA,SAAgBK,EACd,GACA,GACA,GACM;CACN,EAAStB,IAAY,MAAMC,EAAE,YAAYgB,GAAKd,CAAS,CAAC;AAC1D;AAkBA,SAAgBoB,EAAmB,GAA+B,GAA0B;CAG1F,AAFAC,EAAQ,KAAK,KAAK,GAClBA,EAAQ,SAAS,MAAM,GACvBT,EAAS,OACDO,EAAmBE,EAAQ,WAAWA,EAAQ,KAAKrB,CAAS,SAC5DqB,EAAQ,UAAU,IAAIrB,CAAS,CACvC,IAAI,MAASsB,EAAK,CAAC;AACrB"}

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

@@ -0,0 +1,72 @@
+import { runBehaviorSettled as e } from "../gestureLifecycle.js";
+import { inPlane as t, insertLayer as n } from "../planeInput.js";
+import { shapeKindInfo as r } from "../../../core/shapeKinds.js";
+import { insertKind as i, insertShape as a } from "./shape.js";
+import { cancelInsert as o, commitInsert as s } from "./commit.js";
+import { beginInsert as c } from "./session.js";
+import { nextFrame as l } from "./frame.js";
+import { resolveParams as u } from "@weasel-js/routing";
+//#region src/interactions/actions/insert/action.ts
+var d = t({
+	id: "insert",
+	label: "Insert",
+	group: "insert",
+	eligible: { capability: "creates-shapes" },
+	requires: [
+		"insert",
+		"insertLive",
+		"selection",
+		"snap",
+		"textEdit",
+		"scene",
+		"applyOps",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(t, n) {
+			let d = c(t, n);
+			if (!d) return {};
+			let { session: f, readers: p } = d, m = d.frame, h = {
+				open: !0,
+				userRotation: 0
+			}, g = t.deps.insertLive;
+			return g && (g.gesture = h), {
+				kind: "insert",
+				onMove(e) {
+					m = l(f, p, m, e);
+				},
+				overlay() {
+					if (!h.open) return null;
+					let e = u(f.opts?.params);
+					if (!r(i(e))?.insertPreview) return null;
+					let { bounds: t, extras: n, start: o } = a(e, m, m.points, h.userRotation);
+					return {
+						kind: "insertPreview",
+						shape: n.kind,
+						bounds: t,
+						extras: n,
+						anchorPoint: {
+							x: o.x,
+							y: o.y
+						}
+					};
+				},
+				onEnd(t, n) {
+					h.open = !1, g?.gesture === h && (g.gesture = null);
+					let r = !1;
+					try {
+						n === "cancel" ? o(f) : r = s(f, m, t.drag?.points ?? m.points, h.userRotation);
+					} finally {
+						e(f.behaviors, f.gestureCtx, r);
+					}
+				}
+			};
+		}
+	},
+	enabled: () => !0
+}, n);
+//#endregion
+export { d as insertAction };
+
+//# sourceMappingURL=action.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["insertAction","inPlane","begun","beginInsert","ctx","opts","frame","gesture","live","nextFrame","session","readers","moveCtx","resolved","resolveParams","shapeKindInfo","insertKind","insertShape","extras","start","committed","reason","cancelInsert","commitInsert","endCtx","insertLayer"],"sources":["../../../../src/interactions/actions/insert/action.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, BindingOpts, OngoingOverlay } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport { shapeKindInfo } from 'core/shapeKinds';\nimport type { KitInsertShape } from 'core/shapeKinds';\nimport { runBehaviorSettled } from '../gestureLifecycle';\nimport { inPlane, insertLayer } from '../planeInput';\nimport { cancelInsert, commitInsert } from './commit';\nimport { nextFrame } from './frame';\nimport type { InsertLiveGesture } from './live';\nimport { beginInsert } from './session';\nimport { insertKind, insertShape } from './shape';\n\n/**\n * @experimental\n * Drag-to-insert. The node `kind` is read from `opts.params.kind`.\n *\n * Grid snapping comes from the optional `snap` dep, applied to the drag's\n * start and current point (never to freehand pencil samples). Behaviors from\n * the binding's `opts.behaviors` (`InsertBehavior[]`) run over the two points\n * after that; on release the first answer wins (`null` aborts, `Op[]` commits\n * in place of the insert).\n *\n * The new node has no scene id until commit, so the live preview is the\n * `overlay()` surface with `kind: 'insertPreview'`. A consumer-defined kind\n * the kit cannot draw skips the preview and still commits on release.\n */\nexport const insertAction: Action & { requires: string[] } = inPlane({\n  id: 'insert',\n  label: 'Insert',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  requires: ['insert', 'insertLive', 'selection', 'snap', 'textEdit', 'scene', 'applyOps', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const begun = beginInsert(ctx, opts);\n      if (!begun) return {};\n      const { session, readers } = begun;\n      let frame = begun.frame;\n      const gesture: InsertLiveGesture = { open: true, userRotation: 0 };\n      const live = ctx.deps.insertLive;\n      if (live) live.gesture = gesture;\n\n      return {\n        kind: 'insert',\n        onMove(moveCtx: InvocationCtx): void {\n          frame = nextFrame(session, readers, frame, moveCtx);\n        },\n        overlay(): OngoingOverlay | null {\n          if (!gesture.open) return null;\n          // Resolve params on every overlay() so thunked params (polygon\n          // sides ticking via ArrowUp mid-drag) reflect in the live preview.\n          const resolved = resolveParams(session.opts?.params);\n          if (!shapeKindInfo(insertKind(resolved))?.insertPreview) return null;\n          const { bounds, extras, start } = insertShape(resolved, frame, frame.points, gesture.userRotation);\n          return {\n            kind: 'insertPreview',\n            shape: extras.kind as KitInsertShape,\n            bounds,\n            extras,\n            // Anchor dot at the click point: radial shapes have no vertex\n            // there, and in center mode it marks the growth axis.\n            anchorPoint: { x: start.x, y: start.y },\n          };\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          gesture.open = false;\n          if (live?.gesture === gesture) live.gesture = null;\n          let committed = false;\n          try {\n            if (reason === 'cancel') cancelInsert(session);\n            else committed = commitInsert(session, frame, endCtx.drag?.points ?? frame.points, gesture.userRotation);\n          } finally {\n            runBehaviorSettled(session.behaviors, session.gestureCtx, committed);\n          }\n        },\n      };\n    },\n  },\n  /** Insert needs no selection; anything but `true` blocks dispatcher-routed inserts. */\n  enabled: () => true as const,\n}, insertLayer);\n"],"mappings":";;;;;;;;;AA2BA,IAAaA,IAAgDC,EAAQ;CACnE,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,UAAU;EAAC;EAAU;EAAc;EAAa;EAAQ;EAAY;EAAS;EAAY;CAAM;CAC/F,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAMC,IAAQC,EAAYC,GAAKC,CAAI;GACnC,IAAI,CAACH,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,YAAS,eAAYA,GACzBI,IAAQJ,EAAM,OACZK,IAA6B;IAAE,MAAM;IAAM,cAAc;GAAE,GAC3DC,IAAOJ,EAAI,KAAK;GAGtB,OAFII,MAAM,EAAK,UAAUD,IAElB;IACL,MAAM;IACN,OAAO,GAA8B;KACnC,IAAQE,EAAUC,GAASC,GAASL,GAAOM,CAAO;IACpD;IACA,UAAiC;KAC/B,IAAI,CAACL,EAAQ,MAAM,OAAO;KAG1B,IAAMM,IAAWC,EAAcJ,EAAQ,MAAM,MAAM;KACnD,IAAI,CAACK,EAAcC,EAAWH,CAAQ,CAAC,CAAC,EAAE,eAAe,OAAO;KAChE,IAAM,EAAE,WAAQ,WAAQ,aAAUI,EAAYJ,GAAUP,GAAOA,EAAM,QAAQC,EAAQ,YAAY;KACjG,OAAO;MACL,MAAM;MACN,OAAOW,EAAO;MACd;MACA;MAGA,aAAa;OAAE,GAAGC,EAAM;OAAG,GAAGA,EAAM;MAAE;KACxC;IACF;IACA,MAAM,GAAuB,GAAmC;KAE9D,AADA,EAAQ,OAAO,IACXX,GAAM,YAAYD,MAAS,EAAK,UAAU;KAC9C,IAAIa,IAAY;KAChB,IAAI;MACF,AAAIC,MAAW,WAAUC,EAAaZ,CAAO,IACxC,IAAYa,EAAab,GAASJ,GAAOkB,EAAO,MAAM,UAAUlB,EAAM,QAAQC,EAAQ,YAAY;KACzG,UAAU;MACR,EAAmBG,EAAQ,WAAWA,EAAQ,YAAYU,CAAS;KACrE;IACF;GACF;EACF;CACF;CAEA,eAAe;AACjB,GAAGK,CAAW"}

package/dist/interactions/actions/insert/commit.js

@@ -0,0 +1,28 @@
+import { commitGestureOps as e, readGestureLifecycle as t, reduceBehaviorEnd as n, runBehaviorCancel as r } from "../gestureLifecycle.js";
+import { defaultCommitAdapter as i } from "../defaultCommitAdapter.js";
+import { insertShape as a, isCommittableExtent as o } from "./shape.js";
+import { resolveParams as s } from "@weasel-js/routing";
+//#region src/interactions/actions/insert/commit.ts
+function c(e) {
+	r(e.behaviors, e.gestureCtx), e.priorSelection.length > 0 && e.selection?.set([...e.priorSelection]);
+}
+function l(r, c, l, u) {
+	let d = s(r.opts?.params);
+	if (r.behaviors.length > 0) {
+		let a = n(r.behaviors, r.gestureCtx);
+		if (a === null) return !1;
+		if (a !== void 0) return r.scene ? e({
+			scene: r.scene,
+			applyOps: r.applyOps,
+			adapter: i(r.scene, r.selection?.adapterMethods)
+		}, t(d, "Insert", r.behaviors), a) : !1;
+	}
+	let { bounds: f, extras: p } = a(d, c, l, u);
+	if (!o(f, p.kind)) return !1;
+	let m = r.dep.commit(f, p);
+	return m !== null && p.kind === "text" && r.textEdit?.startEdit(String(m), { caret: 0 }), m !== null;
+}
+//#endregion
+export { c as cancelInsert, l as commitInsert };
+
+//# sourceMappingURL=commit.js.map

package/dist/interactions/actions/insert/commit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.js","names":["cancelInsert","runBehaviorCancel","session","commitInsert","resolved","resolveParams","r","reduceBehaviorEnd","commitGestureOps","defaultCommitAdapter","readGestureLifecycle","insertShape","frame","points","userRotation","isCommittableExtent","bounds","extras","id"],"sources":["../../../../src/interactions/actions/insert/commit.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel } from '../gestureLifecycle';\nimport type { InsertFrame, InsertSession } from './session';\nimport { insertShape, isCommittableExtent } from './shape';\n\n/** Cancel the insert: tell the behaviors, and put the selection the draw\n *  cleared back. */\nexport function cancelInsert(\n  session: Pick<InsertSession, 'behaviors' | 'gestureCtx' | 'priorSelection' | 'selection'>,\n): void {\n  runBehaviorCancel(session.behaviors, session.gestureCtx);\n  if (session.priorSelection.length > 0) session.selection?.set([...session.priorSelection]);\n}\n\n/** Commit the insert. Returns whether it committed: a behavior's ops reached\n *  the scene, or the `insert` dep minted a node. `points` is the pointer\n *  trail as the release left it. */\nexport function commitInsert(\n  session: InsertSession,\n  frame: Pick<InsertFrame, 'shaped' | 'altHeld'>,\n  points: ReadonlyArray<DragSample> | null,\n  userRotation: number,\n): boolean {\n  // Resolve params at commit time so thunked params (polygon\n  // `sides` adjusted mid-drag, etc.) see the latest tool state.\n  const resolved = resolveParams(session.opts?.params);\n\n  if (session.behaviors.length > 0) {\n    const r = reduceBehaviorEnd(session.behaviors, session.gestureCtx);\n    if (r === null) return false;\n    if (r !== undefined) {\n      if (!session.scene) return false;\n      return commitGestureOps(\n        {\n          scene: session.scene,\n          applyOps: session.applyOps,\n          adapter: defaultCommitAdapter(session.scene, session.selection?.adapterMethods),\n        },\n        readGestureLifecycle(resolved, 'Insert', session.behaviors),\n        r,\n      );\n    }\n  }\n\n  const { bounds, extras } = insertShape(resolved, frame, points, userRotation);\n  // Sub-threshold drag — no insert.\n  if (!isCommittableExtent(bounds, extras.kind)) return false;\n\n  const id = session.dep.commit(bounds, extras);\n\n  // A freshly dragged text box is empty, so it draws nothing and the\n  // tool's own `click on selected body → enterTextEdit` binding has\n  // nothing visible to click. Drop straight into the caret instead —\n  // which is also what every other editor does with a text tool.\n  // `textEdit` is optional: without it the box is still committed,\n  // exactly as before.\n  if (id !== null && extras.kind === 'text') {\n    session.textEdit?.startEdit(String(id), { caret: 0 });\n  }\n  return id !== null;\n}\n"],"mappings":";;;;;AASA,SAAgBA,EACd,GACM;CAEN,AADAC,EAAkBC,EAAQ,WAAWA,EAAQ,UAAU,GACnDA,EAAQ,eAAe,SAAS,KAAGA,EAAQ,WAAW,IAAI,CAAC,GAAGA,EAAQ,cAAc,CAAC;AAC3F;AAKA,SAAgBC,EACd,GACA,GACA,GACA,GACS;CAGT,IAAMC,IAAWC,EAAcH,EAAQ,MAAM,MAAM;CAEnD,IAAIA,EAAQ,UAAU,SAAS,GAAG;EAChC,IAAMI,IAAIC,EAAkBL,EAAQ,WAAWA,EAAQ,UAAU;EACjE,IAAII,MAAM,MAAM,OAAO;EACvB,IAAIA,MAAM,KAAA,GAER,OADKJ,EAAQ,QACNM,EACL;GACE,OAAON,EAAQ;GACf,UAAUA,EAAQ;GAClB,SAASO,EAAqBP,EAAQ,OAAOA,EAAQ,WAAW,cAAc;EAChF,GACAQ,EAAqBN,GAAU,UAAUF,EAAQ,SAAS,GAC1DI,CACF,IAT2B;CAW/B;CAEA,IAAM,EAAE,WAAQ,cAAWK,EAAYP,GAAUQ,GAAOC,GAAQC,CAAY;CAE5E,IAAI,CAACC,EAAoBC,GAAQC,EAAO,IAAI,GAAG,OAAO;CAEtD,IAAMC,IAAKhB,EAAQ,IAAI,OAAOc,GAAQC,CAAM;CAW5C,OAHIC,MAAO,QAAQD,EAAO,SAAS,UACjCf,EAAQ,UAAU,UAAU,OAAOgB,CAAE,GAAG,EAAE,OAAO,EAAE,CAAC,GAE/CA,MAAO;AAChB"}

package/dist/interactions/actions/insert/extras.js

@@ -0,0 +1,65 @@
+//#region src/interactions/actions/insert/extras.ts
+function e(e, t, n, r, i, a) {
+	let o = e?.kind ?? "rect";
+	switch (o) {
+		case "rect":
+		case "ellipse": return { kind: o };
+		case "line": return {
+			kind: "line",
+			a: {
+				x: t,
+				y: n
+			},
+			b: {
+				x: r,
+				y: i
+			}
+		};
+		case "polygon": {
+			let a = Number(e?.sides ?? 6), o = r === t && i === n ? 0 : Math.atan2(i - n, r - t), s = {
+				kind: "polygon",
+				sides: a,
+				rotation: e?.rotation === void 0 ? o : Number(e.rotation)
+			};
+			if (e?.originMode === "center") {
+				let e = r - t, a = i - n;
+				s.center = {
+					x: t,
+					y: n
+				}, s.radius = Math.hypot(e, a);
+			} else e?.center !== void 0 && (s.center = e.center), e?.radius !== void 0 && (s.radius = e.radius);
+			return s;
+		}
+		case "star": {
+			let a = Number(e?.points ?? 5), o = Number(e?.innerRadiusRatio ?? .5), s = r === t && i === n ? 0 : Math.atan2(i - n, r - t), c = {
+				kind: "star",
+				points: a,
+				innerRadiusRatio: o,
+				rotation: e?.rotation === void 0 ? s : Number(e.rotation)
+			};
+			if (e?.originMode === "center") {
+				let e = r - t, a = i - n;
+				c.center = {
+					x: t,
+					y: n
+				}, c.outerRadius = Math.hypot(e, a);
+			} else e?.center !== void 0 && (c.center = e.center), e?.outerRadius !== void 0 && (c.outerRadius = e.outerRadius);
+			return c;
+		}
+		case "pencil": return {
+			kind: "pencil",
+			samples: e?.samples ?? a ?? []
+		};
+		default: return {
+			...e ?? {},
+			kind: o
+		};
+	}
+}
+function t(e, t) {
+	t !== 0 && (e.kind === "star" || e.kind === "polygon") && (e.rotation += t);
+}
+//#endregion
+export { t as applyUserRotation, e as buildExtras };
+
+//# sourceMappingURL=extras.js.map

package/dist/interactions/actions/insert/extras.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extras.js","names":["buildExtras","kind","params","\"kind\"","startX","startY","currentX","currentY","sides","\"sides\"","dragAngle","extras","\"rotation\"","\"originMode\"","dx","dy","\"center\"","\"radius\"","pts","\"points\"","ir","\"innerRadiusRatio\"","\"outerRadius\"","\"samples\"","points","applyUserRotation","userRotation"],"sources":["../../../../src/interactions/actions/insert/extras.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport type { InsertExtras } from '../depSchema';\n\n/** Build a typed `InsertExtras` from the static params + gesture context.\n *  Kit-built-in kinds (line / polygon / star / pencil) read kind-specific\n *  fields; unknown kinds pass the raw params through as `{ kind, ... }`. */\nexport function buildExtras(\n  params: Record<string, unknown> | undefined,\n  startX: number,\n  startY: number,\n  currentX: number,\n  currentY: number,\n  points: ReadonlyArray<DragSample> | null,\n): InsertExtras {\n  const kind = ((params?.['kind'] as string | undefined) ?? 'rect');\n  switch (kind) {\n    case 'rect':\n    case 'ellipse':\n      return { kind } as InsertExtras;\n    case 'line':\n      // Use the live drag endpoints (not AABB) so the line preserves the\n      // user's drag direction — drag from bottom-left to top-right makes a\n      // line that slopes up, not the bounds diagonal.\n      return { kind: 'line', a: { x: startX, y: startY }, b: { x: currentX, y: currentY } };\n    case 'polygon': {\n      const sides = Number(params?.['sides'] ?? 6);\n      // When the tool omits rotation, point the first vertex along the\n      // drag vector so dragging in a direction orients the shape that\n      // way. Sub-pixel drags (no direction yet) fall back to 0.\n      const dragAngle = (currentX === startX && currentY === startY)\n        ? 0\n        : Math.atan2(currentY - startY, currentX - startX);\n      const rotation = params?.['rotation'] !== undefined\n        ? Number(params['rotation'])\n        : dragAngle;\n      const extras: InsertExtras = { kind: 'polygon', sides, rotation };\n      // Drag-from-center: tool's Alt binding passes `originMode:'center'`.\n      // Compute polygon center + radius from the drag vector so the shape\n      // anchors on the click point. Without this, the dep falls back to\n      // inscribing in the AABB (drag-from-corner default).\n      if (params?.['originMode'] === 'center') {\n        const dx = currentX - startX;\n        const dy = currentY - startY;\n        (extras as { center?: unknown }).center = { x: startX, y: startY };\n        (extras as { radius?: unknown }).radius = Math.hypot(dx, dy);\n      } else {\n        if (params?.['center'] !== undefined) (extras as { center?: unknown }).center = params['center'];\n        if (params?.['radius'] !== undefined) (extras as { radius?: unknown }).radius = params['radius'];\n      }\n      return extras;\n    }\n    case 'star': {\n      const pts = Number(params?.['points'] ?? 5);\n      const ir = Number(params?.['innerRadiusRatio'] ?? 0.5);\n      const dragAngle = (currentX === startX && currentY === startY)\n        ? 0\n        : Math.atan2(currentY - startY, currentX - startX);\n      const rotation = params?.['rotation'] !== undefined\n        ? Number(params['rotation'])\n        : dragAngle;\n      const extras: InsertExtras = { kind: 'star', points: pts, innerRadiusRatio: ir, rotation };\n      if (params?.['originMode'] === 'center') {\n        const dx = currentX - startX;\n        const dy = currentY - startY;\n        (extras as { center?: unknown }).center = { x: startX, y: startY };\n        (extras as { outerRadius?: unknown }).outerRadius = Math.hypot(dx, dy);\n      } else {\n        if (params?.['center'] !== undefined) (extras as { center?: unknown }).center = params['center'];\n        if (params?.['outerRadius'] !== undefined) (extras as { outerRadius?: unknown }).outerRadius = params['outerRadius'];\n      }\n      return extras;\n    }\n    case 'pencil':\n      // Prefer tool-supplied samples (param) when present — pencil tools may\n      // capture richer per-sample data (pressure/tilt). Fall back to the\n      // dispatcher's accumulated pointer trail.\n      return {\n        kind: 'pencil',\n        samples: (params?.['samples'] as ReadonlyArray<DragSample> | undefined)\n          ?? points\n          ?? [],\n      };\n    default:\n      // Consumer-defined kind: pass everything through so a custom insert\n      // dep can read its own fields.\n      return { ...(params ?? {}), kind } as InsertExtras;\n  }\n}\n\n/** Add a user-driven rotation offset onto kinds that carry rotation. Rect\n *  / ellipse / line / pencil don't expose a rotation field on their\n *  extras today, so they ignore the offset. */\nexport function applyUserRotation(extras: InsertExtras, userRotation: number): void {\n  if (userRotation === 0) return;\n  if (extras.kind === 'star' || extras.kind === 'polygon') {\n    (extras as { rotation: number }).rotation += userRotation;\n  }\n}\n"],"mappings":";AAMA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACc;CACd,IAAMC,IAASC,GAASC,QAAkC;CAC1D,QAAQF,GAAR;EACE,KAAK;EACL,KAAK,WACH,OAAO,EAAE,QAAK;EAChB,KAAK,QAIH,OAAO;GAAE,MAAM;GAAQ,GAAG;IAAE,GAAGG;IAAQ,GAAGC;GAAO;GAAG,GAAG;IAAE,GAAGC;IAAU,GAAGC;GAAS;EAAE;EACtF,KAAK,WAAW;GACd,IAAMC,IAAQ,OAAON,GAASO,SAAY,CAAC,GAIrCC,IAAaJ,MAAaF,KAAUG,MAAaF,IACnD,IACA,KAAK,MAAME,IAAWF,GAAQC,IAAWF,CAAM,GAI7CO,IAAuB;IAAE,MAAM;IAAW;IAAO,UAHtCT,GAASU,aAAgB,KAAA,IAEtCF,IADA,OAAOR,EAAOU,QAAW;GAEmC;GAKhE,IAAIV,GAASW,eAAkB,UAAU;IACvC,IAAMC,IAAKR,IAAWF,GAChBW,IAAKR,IAAWF;IAEtB,AADA,EAAiC,SAAS;KAAE,GAAGD;KAAQ,GAAGC;IAAO,GACjE,EAAiC,SAAS,KAAK,MAAMS,GAAIC,CAAE;GAC7D,OAEE,AADIb,GAASc,WAAc,KAAA,MAAW,EAAiC,SAASd,EAAOc,SACnFd,GAASe,WAAc,KAAA,MAAW,EAAiC,SAASf,EAAOe;GAEzF,OAAON;EACT;EACA,KAAK,QAAQ;GACX,IAAMO,IAAM,OAAOhB,GAASiB,UAAa,CAAC,GACpCC,IAAK,OAAOlB,GAASmB,oBAAuB,EAAG,GAC/CX,IAAaJ,MAAaF,KAAUG,MAAaF,IACnD,IACA,KAAK,MAAME,IAAWF,GAAQC,IAAWF,CAAM,GAI7CO,IAAuB;IAAE,MAAM;IAAQ,QAAQO;IAAK,kBAAkBE;IAAI,UAH/DlB,GAASU,aAAgB,KAAA,IAEtCF,IADA,OAAOR,EAAOU,QAAW;GAE4D;GACzF,IAAIV,GAASW,eAAkB,UAAU;IACvC,IAAMC,IAAKR,IAAWF,GAChBW,IAAKR,IAAWF;IAEtB,AADA,EAAiC,SAAS;KAAE,GAAGD;KAAQ,GAAGC;IAAO,GACjE,EAAsC,cAAc,KAAK,MAAMS,GAAIC,CAAE;GACvE,OAEE,AADIb,GAASc,WAAc,KAAA,MAAW,EAAiC,SAASd,EAAOc,SACnFd,GAASoB,gBAAmB,KAAA,MAAW,EAAsC,cAAcpB,EAAOoB;GAExG,OAAOX;EACT;EACA,KAAK,UAIH,OAAO;GACL,MAAM;GACN,SAAUT,GAASqB,WACdC,KACA,CAAC;EACR;EACF,SAGE,OAAO;GAAE,GAAItB,KAAU,CAAC;GAAI;EAAK;CACrC;AACF;AAKA,SAAgBuB,EAAkB,GAAsB,GAA4B;CAClF,AAAIC,MAAiB,MACjBf,EAAO,SAAS,UAAUA,EAAO,SAAS,eAC5C,EAAiC,YAAYe;AAEjD"}

package/dist/interactions/actions/insert/frame.js

@@ -0,0 +1,48 @@
+import { pointerStateOf as e } from "../pointerState.js";
+import { computeBounds as t, effectiveOriginMode as n, snapTo15Degrees as r } from "./geometry.js";
+import { GESTURE_KEY as i } from "./session.js";
+import { resolveParams as a } from "@weasel-js/routing";
+//#region src/interactions/actions/insert/frame.ts
+function o(o, s, c, l) {
+	let u = a(o.opts?.params), d = u?.kind ?? "rect", f = o.gestureCtx, p = f.origin.get(i), m = {
+		x: c.pointer.x,
+		y: c.pointer.y
+	};
+	if (d === "line" && c.shiftHeld && (m = r(p, m)), m = o.snap(m), o.behaviors.length > 0) {
+		f.modifiers = { ...l.modifiers }, f.pointer = e(c.pointer, l), f.view = s.view(), f.plane = s.plane(), f.current.set(i, m);
+		let r = n(u?.originMode, c.altHeld);
+		for (let e of o.behaviors) {
+			let n = t(p.x, p.y, m.x, m.y, r), i = e.onMove?.(f, {
+				start: p,
+				current: m,
+				bounds: n,
+				pose: n
+			});
+			i && (i.start && (p = i.start), i.current && (m = i.current));
+		}
+		f.current.set(i, m);
+	}
+	return {
+		start: p,
+		current: m
+	};
+}
+function s(e, t, n, r) {
+	let i = {
+		pointer: {
+			x: r.world.x,
+			y: r.world.y
+		},
+		altHeld: r.modifiers.alt,
+		shiftHeld: r.modifiers.shift
+	};
+	return {
+		...i,
+		points: r.drag?.points ? r.drag.points : n.points,
+		shaped: o(e, t, i, r)
+	};
+}
+//#endregion
+export { s as nextFrame };
+
+//# sourceMappingURL=frame.js.map

package/dist/interactions/actions/insert/frame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.js","names":["shapeEndpoints","resolved","resolveParams","session","kind","\"kind\"","gctx","start","GESTURE_KEY","current","raw","snapTo15Degrees","moveCtx","pointerStateOf","readers","mode","effectiveOriginMode","\"originMode\"","b","bounds","computeBounds","r","nextFrame","prev"],"sources":["../../../../src/interactions/actions/insert/frame.ts"],"sourcesContent":["import type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport { resolveParams } from '@weasel-js/routing';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { InsertPoint } from '../../gestures/types';\nimport { computeBounds, effectiveOriginMode, snapTo15Degrees } from './geometry';\nimport { GESTURE_KEY, type InsertFrame, type InsertSession } from './session';\n\n/**\n * Shape the raw pointer into the drag's endpoints, in order: the line tool's\n * Shift-constrain (on the raw pointer, around the shaped start, so the locked\n * angle survives), the `snap` dep, then each behavior's `onMove`, each seeing\n * the points the one before it returned.\n */\nfunction shapeEndpoints(\n  session: Pick<InsertSession, 'opts' | 'snap' | 'behaviors' | 'gestureCtx'>,\n  readers: GestureReaders,\n  raw: Pick<InsertFrame, 'pointer' | 'altHeld' | 'shiftHeld'>,\n  moveCtx: Pick<InvocationCtx, 'modifiers' | 'screen'>,\n): { start: InsertPoint; current: InsertPoint } {\n  const resolved = resolveParams(session.opts?.params);\n  const kind = (resolved?.['kind'] as string | undefined) ?? 'rect';\n  const gctx = session.gestureCtx;\n  let start = gctx.origin.get(GESTURE_KEY) as InsertPoint;\n  let current = { x: raw.pointer.x, y: raw.pointer.y };\n  if (kind === 'line' && raw.shiftHeld) {\n    current = snapTo15Degrees(start, current);\n  }\n  current = session.snap(current);\n\n  if (session.behaviors.length > 0) {\n    gctx.modifiers = { ...moveCtx.modifiers };\n    gctx.pointer = pointerStateOf(raw.pointer, moveCtx);\n    gctx.view = readers.view();\n    gctx.plane = readers.plane();\n    gctx.current.set(GESTURE_KEY, current);\n    const mode = effectiveOriginMode(resolved?.['originMode'], raw.altHeld);\n    for (const b of session.behaviors) {\n      const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);\n      const r = b.onMove?.(gctx, { start, current, bounds, pose: bounds });\n      if (!r) continue;\n      if (r.start) start = r.start;\n      if (r.current) current = r.current;\n    }\n    gctx.current.set(GESTURE_KEY, current);\n  }\n  return { start, current };\n}\n\n/** One pump event's pointer, modifiers, and trail, and the endpoints they\n *  shape to. Each behavior's `onMove` runs once per call. */\nexport function nextFrame(\n  session: InsertSession,\n  readers: GestureReaders,\n  prev: Pick<InsertFrame, 'points'>,\n  moveCtx: InvocationCtx,\n): InsertFrame {\n  const raw = {\n    pointer: { x: moveCtx.world.x, y: moveCtx.world.y },\n    // Each pointermove carries fresh modifier state from the dispatcher;\n    // releasing / pressing a key mid-drag takes effect on the next move tick\n    // (true modifier-only events don't fire without a cursor change).\n    altHeld: moveCtx.modifiers.alt,\n    shiftHeld: moveCtx.modifiers.shift,\n  };\n  return {\n    ...raw,\n    // The dispatcher mutates its own per-gesture trail in place but\n    // attaches the array reference to each InvocationCtx.drag — keep\n    // the latest reference in case the dispatcher swaps it.\n    points: moveCtx.drag?.points ? moveCtx.drag.points : prev.points,\n    shaped: shapeEndpoints(session, readers, raw, moveCtx),\n  };\n}\n"],"mappings":";;;;;AAcA,SAASA,EACP,GACA,GACA,GACA,GAC8C;CAC9C,IAAMC,IAAWC,EAAcC,EAAQ,MAAM,MAAM,GAC7CC,IAAQH,GAAWI,QAAkC,QACrDC,IAAOH,EAAQ,YACjBI,IAAQD,EAAK,OAAO,IAAIE,CAAW,GACnCC,IAAU;EAAE,GAAGC,EAAI,QAAQ;EAAG,GAAGA,EAAI,QAAQ;CAAE;CAMnD,IALIN,MAAS,UAAUM,EAAI,cACzB,IAAUC,EAAgBJ,GAAOE,CAAO,IAE1C,IAAUN,EAAQ,KAAKM,CAAO,GAE1BN,EAAQ,UAAU,SAAS,GAAG;EAKhC,AAJA,EAAK,YAAY,EAAE,GAAGS,EAAQ,UAAU,GACxC,EAAK,UAAUC,EAAeH,EAAI,SAASE,CAAO,GAClD,EAAK,OAAOE,EAAQ,KAAK,GACzB,EAAK,QAAQA,EAAQ,MAAM,GAC3BR,EAAK,QAAQ,IAAIE,GAAaC,CAAO;EACrC,IAAMM,IAAOC,EAAoBf,GAAWgB,YAAeP,EAAI,OAAO;EACtE,KAAK,IAAMQ,KAAKf,EAAQ,WAAW;GACjC,IAAMgB,IAASC,EAAcb,EAAM,GAAGA,EAAM,GAAGE,EAAQ,GAAGA,EAAQ,GAAGM,CAAI,GACnEM,IAAIH,EAAE,SAASZ,GAAM;IAAE;IAAO;IAAS;IAAQ,MAAMa;GAAO,CAAC;GACnE,AAAKE,MACDA,EAAE,UAAO,IAAQA,EAAE,QACnBA,EAAE,YAAS,IAAUA,EAAE;EAC7B;EACA,EAAK,QAAQ,IAAIb,GAAaC,CAAO;CACvC;CACA,OAAO;EAAE;EAAO;CAAQ;AAC1B;AAIA,SAAgBa,EACd,GACA,GACA,GACA,GACa;CACb,IAAMZ,IAAM;EACV,SAAS;GAAE,GAAGE,EAAQ,MAAM;GAAG,GAAGA,EAAQ,MAAM;EAAE;EAIlD,SAASA,EAAQ,UAAU;EAC3B,WAAWA,EAAQ,UAAU;CAC/B;CACA,OAAO;EACL,GAAGF;EAIH,QAAQE,EAAQ,MAAM,SAASA,EAAQ,KAAK,SAASW,EAAK;EAC1D,QAAQvB,EAAeG,GAASW,GAASJ,GAAKE,CAAO;CACvD;AACF"}