@weasel-js/core 1.10.1 → 1.11.1

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

@@ -1,63 +1,110 @@
-import { readGestureLifecycle as e } from "../gestureLifecycle.js";
-import { gestureReaders as t } from "../../gestures/shared/screenTolerance.js";
-import { nodeDescriptors as n, poseDescriptorOf as r } from "../poseDescriptorDep.js";
-import { scenePoseFrame as i } from "../poseFrame.js";
-import { buildGestureContext as a, captureBox as o, captureStarts as s, captureTargets as c, resolvePolicy as l } from "./capture.js";
+import { localToWorld } from "../../../core/geometry/targetFrame.js";
+import { outsetBox } from "../../../core/geometry/inkExtents.js";
+import { scenePoseFrame } from "../poseFrame.js";
+import { nodeDescriptors, poseDescriptorOf } from "../poseDescriptorDep.js";
+import { transformFinisher } from "../transformFinish.js";
+import { readGestureLifecycle } from "../gestureLifecycle.js";
+import { gestureReaders } from "../../gestures/shared/screenTolerance.js";
+import { drawnBoxes } from "../drawnBoxes.js";
+import { boxFrame } from "./boxFrame.js";
+import { buildGestureContext, captureBox, captureStarts, captureTargets, resolvePolicy } from "./capture.js";
+import { boxMinimum } from "./minimum.js";
+import { inputSession } from "../../../features/snap/session2d.js";
+
 //#region src/interactions/actions/resize/session.ts
-function u(e, t, a, u) {
-	let d = r(u.poseDescriptor), f = u.resizePolicy, { constraints: p, pointSnap: m, expandIds: h } = l(f), g = n(e, d), _ = c(e, t, h);
-	if (!_) return null;
-	let { writeIds: v, isGroupPath: y } = _, b = i(e), x = u.view, S = s(e, v, g, b, x);
-	if (S.startPoses.size === 0) return null;
-	let { box: C, ruleOrigin: w } = o(S, v, y, a, d, g);
+/** Capture what resizing `ids` from `anchor` acts on. Null when nothing it
+*  would write exists. */
+function captureResize(scene, ids, anchor, deps) {
+	const geometry = poseDescriptorOf(deps.poseDescriptor);
+	const policy = deps.resizePolicy;
+	const { constraints, expandIds } = resolvePolicy(policy);
+	const geometryOf = nodeDescriptors(scene, geometry);
+	const targets = captureTargets(scene, ids, expandIds);
+	if (!targets) return null;
+	const { writeIds, isGroupPath } = targets;
+	const poseFrame = scenePoseFrame(scene);
+	const view = deps.view;
+	const boxes = drawnBoxes({
+		...deps,
+		scene
+	}, poseFrame);
+	const starts = captureStarts(scene, writeIds, geometryOf, poseFrame, view, boxes);
+	if (starts.startPoses.size === 0) return null;
+	const { box, ruleOrigin } = captureBox(starts, writeIds, isGroupPath, anchor, geometry, geometryOf);
+	const sharedBox = isGroupPath || writeIds.length > 1;
+	const written = writeIds.filter((id) => starts.startPoses.has(id));
 	return {
 		place: {
-			scene: e,
-			writeIds: v,
-			sharedBox: y || v.length > 1,
-			box: C,
-			startPoses: S.startPoses,
-			startWorlds: S.startWorlds,
-			geometryOf: g,
-			poseFrame: b,
-			view: x
+			scene,
+			writeIds,
+			sharedBox,
+			minimum: boxMinimum(scene, written, starts.leafBounds, starts.startWorlds, box.bounds, sharedBox),
+			box,
+			startPoses: starts.startPoses,
+			startWorlds: starts.startWorlds,
+			geometryOf,
+			poseFrame,
+			view
 		},
-		ruleOrigin: w,
-		policy: f,
-		constraints: p,
-		pointSnap: m
+		ruleOrigin,
+		policy,
+		constraints
+	};
+}
+/** The drag's snap session, over the box as drawn in its own frame. */
+function beginSnap(ctx, ids, press, box) {
+	const frame = boxFrame(box, box.bounds);
+	const req = {
+		gesture: "resize",
+		ids,
+		press,
+		handle: box.anchor,
+		constrain: "aspect",
+		box: {
+			bounds: outsetBox(box.bounds, box.extents),
+			toWorld: (p) => localToWorld(frame, p.x, p.y)
+		}
 	};
+	return ctx.deps.snap?.begin(req) ?? inputSession(req);
 }
-function d(n) {
-	let r = n.deps.selection, i = n.deps.scene;
-	if (!r || !i) return null;
-	let o = r.get();
-	if (o.length === 0) return null;
-	let s = n.drag?.affordance?.anchor;
-	if (!s) return null;
-	let c = u(i, o, s, n.deps);
-	if (!c) return null;
-	let { place: l, ruleOrigin: d, policy: f, constraints: p, pointSnap: m } = c, h = {
-		x: n.drag?.start.x ?? 0,
-		y: n.drag?.start.y ?? 0
-	}, g = t(n.deps), _ = a(n, o, d, h, g);
-	for (let e of p) e.onStart?.(_);
+/** Capture a resize at press. Null when nothing is selected, the press is not
+*  on a resize handle, or nothing it would write exists. Runs each
+*  constraint's `onStart`. */
+function beginResize(ctx) {
+	const selection = ctx.deps.selection;
+	const scene = ctx.deps.scene;
+	if (!selection || !scene) return null;
+	const ids = selection.get();
+	if (ids.length === 0) return null;
+	const anchor = ctx.drag?.affordance?.anchor;
+	if (!anchor) return null;
+	const captured = captureResize(scene, ids, anchor, ctx.deps);
+	if (!captured) return null;
+	const { place, ruleOrigin, policy, constraints } = captured;
+	const startWorld = {
+		x: ctx.drag?.start.x ?? 0,
+		y: ctx.drag?.start.y ?? 0
+	};
+	const readers = gestureReaders(ctx.deps);
+	const gestureCtx = buildGestureContext(ctx, ids, ruleOrigin, startWorld, readers);
+	for (const b of constraints) b.onStart?.(gestureCtx);
 	return {
 		session: {
-			...l,
-			startWorld: h,
-			constraints: p,
-			pointSnap: m,
-			gestureCtx: _,
-			applyOps: n.deps.applyOps,
-			geometryProjection: n.deps.geometryProjection,
-			selectionMethods: r.adapterMethods,
-			lifecycle: e(f, "Resize", p)
+			...place,
+			startWorld,
+			constraints,
+			gestureCtx,
+			applyOps: ctx.deps.applyOps,
+			finish: transformFinisher(ctx.deps),
+			geometryProjection: ctx.deps.geometryProjection,
+			selectionMethods: selection.adapterMethods,
+			lifecycle: readGestureLifecycle(policy, "Resize", constraints),
+			snap: beginSnap(ctx, ids, startWorld, place.box)
 		},
-		readers: g
+		readers
 	};
 }
-//#endregion
-export { d as beginResize, u as captureResize };
 
+//#endregion
+export { beginResize, captureResize };
 //# sourceMappingURL=session.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"session.js","names":["captureResize","geometry","poseDescriptorOf","deps","policy","resolvePolicy","geometryOf","nodeDescriptors","scene","targets","captureTargets","ids","expandIds","poseFrame","scenePoseFrame","view","starts","captureStarts","writeIds","captureBox","isGroupPath","anchor","beginResize","selection","ctx","captured","startWorld","readers","gestureReaders","gestureCtx","buildGestureContext","ruleOrigin","b","constraints","place","readGestureLifecycle"],"sources":["../../../../src/interactions/actions/resize/session.ts"],"sourcesContent":["import type { PoseLinear } from '@weasel-js/geom';\nimport type { ActionDeps, InvocationCtx } from '@weasel-js/routing';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { BoundsConstraint, GestureContext, PointSnapBehavior, ResizeAnchor } from '../../gestures/types';\nimport type { GeometryProjection } from '../geometryProjection';\nimport { readGestureLifecycle, type GestureLifecycle } from '../gestureLifecycle';\nimport { nodeDescriptors, poseDescriptorOf } from '../poseDescriptorDep';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { buildGestureContext, captureBox, captureStarts, captureTargets, resolvePolicy } from './capture';\nimport type { PoseDescriptor } from './geometry';\n\n/** The box the drag resizes, as the press found it. */\nexport interface ResizeBox {\n  /** The union for a group or a multi-selection, a lone target's own bounds\n   *  otherwise. The `src` rect every write id is remapped from. */\n  readonly bounds: Bounds;\n  readonly anchor: ResizeAnchor;\n  /** A lone target's rotation; 0 for a group. */\n  readonly rotation: number;\n  /** A lone target's `transform`; none for a group. */\n  readonly transform?: PoseLinear;\n  /** World position of the corner opposite the dragged one, which a resize\n   *  in a turned or skewed frame pins. */\n  readonly fixedWorld: { x: number; y: number };\n}\n\n/** What a resize captured at press. Nothing here changes during the drag. */\nexport interface ResizeSession {\n  readonly scene: Scene<unknown, string, unknown>;\n  /** The ids the gesture writes: the leaf set for a group, else the selection. */\n  readonly writeIds: readonly NodeId[];\n  /** Whether `box` stands for several write ids, each remapped inside it,\n   *  rather than being a lone target's own. */\n  readonly sharedBox: boolean;\n  readonly box: ResizeBox;\n  /** Start poses as stored: the `from` of each op. */\n  readonly startPoses: ReadonlyMap<NodeId, unknown>;\n  /** Start poses in world, the frame the anchor math and the drag share. */\n  readonly startWorlds: ReadonlyMap<NodeId, unknown>;\n  /** Where the pointer pressed. */\n  readonly startWorld: { x: number; y: number };\n  readonly geometryOf: (id: NodeId) => PoseDescriptor<unknown>;\n  /** World reads and local writes over the scene's composition strategy. */\n  readonly poseFrame: PoseFrame<unknown>;\n  readonly view: unknown;\n  readonly constraints: readonly BoundsConstraint<Bounds>[];\n  readonly pointSnap: readonly PointSnapBehavior<Bounds>[];\n  /** Reused across the drag; constraints mutate its `scratch`. */\n  readonly gestureCtx: GestureContext<Bounds>;\n  readonly applyOps?: (ops: Op[], label: string) => void;\n  /** When present, the commit maps each leaf's data-held geometry by the\n   *  affine its pose underwent. */\n  readonly geometryProjection?: GeometryProjection;\n  readonly selectionMethods: SelectionApi['adapterMethods'] | undefined;\n  /** Label, history, and callbacks from the `resizePolicy` dep. */\n  readonly lifecycle: GestureLifecycle;\n}\n\n/** What one `onMove` produced. Replaced, not mutated, by the next. */\nexport interface ResizeFrame {\n  /** Stored-frame pose of every write id the move reached. */\n  readonly previews: Map<NodeId, unknown>;\n  /** The box the move resized `ResizeBox.bounds` to; absent before the first move. */\n  readonly proposed?: Bounds;\n}\n\n/** The part of a resize that a box alone decides: what it writes, the box\n *  they share, and where each starts. */\nexport type ResizePlace = Pick<\n  ResizeSession,\n  'scene' | 'writeIds' | 'sharedBox' | 'box' | 'startPoses' | 'startWorlds' | 'geometryOf' | 'poseFrame' | 'view'\n>;\n\n/** Capture what resizing `ids` from `anchor` acts on. Null when nothing it\n *  would write exists. */\nexport function captureResize(\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  anchor: ResizeAnchor,\n  deps: Pick<ActionDeps, 'poseDescriptor' | 'resizePolicy' | 'view'>,\n): {\n  place: ResizePlace;\n  ruleOrigin: Bounds;\n  policy: ActionDeps['resizePolicy'];\n  constraints: BoundsConstraint<Bounds>[];\n  pointSnap: PointSnapBehavior<Bounds>[];\n} | null {\n  const geometry = poseDescriptorOf(deps.poseDescriptor);\n  const policy = deps.resizePolicy;\n  const { constraints, pointSnap, expandIds } = resolvePolicy(policy);\n  const geometryOf = nodeDescriptors(scene, geometry);\n\n  const targets = captureTargets(scene, ids, expandIds);\n  if (!targets) return null;\n  const { writeIds, isGroupPath } = targets;\n\n  // The drag delta is world, so the anchor math runs on world poses — carried\n  // into the plane the edit is measured in — and each result is carried back\n  // to its node's plane and stored in the node's own parent frame.\n  const poseFrame = scenePoseFrame(scene);\n  const view = deps.view;\n  const starts = captureStarts(scene, writeIds, geometryOf, poseFrame, view);\n  if (starts.startPoses.size === 0) return null;\n\n  const { box, ruleOrigin } = captureBox(starts, writeIds, isGroupPath, anchor, geometry, geometryOf);\n  return {\n    place: {\n      scene,\n      writeIds,\n      sharedBox: isGroupPath || writeIds.length > 1,\n      box,\n      startPoses: starts.startPoses,\n      startWorlds: starts.startWorlds,\n      geometryOf,\n      poseFrame,\n      view,\n    },\n    ruleOrigin,\n    policy,\n    constraints,\n    pointSnap,\n  };\n}\n\n/** Capture a resize at press. Null when nothing is selected, the press is not\n *  on a resize handle, or nothing it would write exists. Runs each\n *  constraint's `onStart`. */\nexport function beginResize(\n  ctx: InvocationCtx,\n): { session: ResizeSession; readers: GestureReaders } | null {\n  const selection = ctx.deps.selection;\n  const scene = ctx.deps.scene;\n  if (!selection || !scene) return null;\n\n  const ids = selection.get() as NodeId[];\n  if (ids.length === 0) return null;\n\n  const anchor = ctx.drag?.affordance?.anchor;\n  if (!anchor) return null;\n\n  const captured = captureResize(scene, ids, anchor, ctx.deps);\n  if (!captured) return null;\n  const { place, ruleOrigin, policy, constraints, pointSnap } = captured;\n  const startWorld = { x: ctx.drag?.start.x ?? 0, y: ctx.drag?.start.y ?? 0 };\n  const readers = gestureReaders(ctx.deps);\n  const gestureCtx = buildGestureContext(ctx, ids, ruleOrigin, startWorld, readers);\n  for (const b of constraints) b.onStart?.(gestureCtx);\n\n  const session: ResizeSession = {\n    ...place,\n    startWorld,\n    constraints,\n    pointSnap,\n    gestureCtx,\n    applyOps: ctx.deps.applyOps,\n    geometryProjection: ctx.deps.geometryProjection,\n    selectionMethods: selection.adapterMethods,\n    lifecycle: readGestureLifecycle(policy, 'Resize', constraints),\n  };\n  return { session, readers };\n}\n"],"mappings":";;;;;;AA+EA,SAAgBA,EACd,GACA,GACA,GACA,GAOO;CACP,IAAMC,IAAWC,EAAiBC,EAAK,cAAc,GAC/CC,IAASD,EAAK,cACd,EAAE,gBAAa,cAAW,iBAAcE,EAAcD,CAAM,GAC5DE,IAAaC,EAAgBC,GAAOP,CAAQ,GAE5CQ,IAAUC,EAAeF,GAAOG,GAAKC,CAAS;CACpD,IAAI,CAACH,GAAS,OAAO;CACrB,IAAM,EAAE,aAAU,mBAAgBA,GAK5BI,IAAYC,EAAeN,CAAK,GAChCO,IAAOZ,EAAK,MACZa,IAASC,EAAcT,GAAOU,GAAUZ,GAAYO,GAAWE,CAAI;CACzE,IAAIC,EAAO,WAAW,SAAS,GAAG,OAAO;CAEzC,IAAM,EAAE,QAAK,kBAAeG,EAAWH,GAAQE,GAAUE,GAAaC,GAAQpB,GAAUK,CAAU;CAClG,OAAO;EACL,OAAO;GACL;GACA;GACA,WAAWc,KAAeF,EAAS,SAAS;GAC5C;GACA,YAAYF,EAAO;GACnB,aAAaA,EAAO;GACpB;GACA;GACA;EACF;EACA;EACA;EACA;EACA;CACF;AACF;AAKA,SAAgBM,EACd,GAC4D;CAC5D,IAAMC,IAAYC,EAAI,KAAK,WACrBhB,IAAQgB,EAAI,KAAK;CACvB,IAAI,CAACD,KAAa,CAACf,GAAO,OAAO;CAEjC,IAAMG,IAAMY,EAAU,IAAI;CAC1B,IAAIZ,EAAI,WAAW,GAAG,OAAO;CAE7B,IAAMU,IAASG,EAAI,MAAM,YAAY;CACrC,IAAI,CAACH,GAAQ,OAAO;CAEpB,IAAMI,IAAWzB,EAAcQ,GAAOG,GAAKU,GAAQG,EAAI,IAAI;CAC3D,IAAI,CAACC,GAAU,OAAO;CACtB,IAAM,EAAE,UAAO,eAAY,WAAQ,gBAAa,iBAAcA,GACxDC,IAAa;EAAE,GAAGF,EAAI,MAAM,MAAM,KAAK;EAAG,GAAGA,EAAI,MAAM,MAAM,KAAK;CAAE,GACpEG,IAAUC,EAAeJ,EAAI,IAAI,GACjCK,IAAaC,EAAoBN,GAAKb,GAAKoB,GAAYL,GAAYC,CAAO;CAChF,KAAK,IAAMK,KAAKC,GAAa,EAAE,UAAUJ,CAAU;CAanD,OAAO;EAAE,SAAA;GAVP,GAAGK;GACH;GACA;GACA;GACA;GACA,UAAUV,EAAI,KAAK;GACnB,oBAAoBA,EAAI,KAAK;GAC7B,kBAAkBD,EAAU;GAC5B,WAAWY,EAAqB/B,GAAQ,UAAU6B,CAAW;EAEtD;EAAS;CAAQ;AAC5B"}
+{"version":3,"file":"session.js","names":[],"sources":["../../../../src/interactions/actions/resize/session.ts"],"sourcesContent":["import type { PoseLinear } from '@weasel-js/geom';\nimport type { ActionDeps, InvocationCtx } from '@weasel-js/routing';\nimport { transformFinisher, type TransformFinisher } from '../transformFinish';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { BoundsConstraint, GestureContext, ResizeAnchor } from '../../gestures/types';\nimport type { GeometryProjection } from '../geometryProjection';\nimport { readGestureLifecycle, type GestureLifecycle } from '../gestureLifecycle';\nimport { nodeDescriptors, poseDescriptorOf } from '../poseDescriptorDep';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { buildGestureContext, captureBox, captureStarts, captureTargets, resolvePolicy } from './capture';\nimport type { PoseDescriptor } from './geometry';\nimport type { InkExtents } from 'core/geometry/inkExtents';\nimport { drawnBoxes } from '../drawnBoxes';\nimport type { MinSize } from 'core/scene/minSize';\nimport { boxMinimum } from './minimum';\nimport { boxFrame } from './boxFrame';\nimport { localToWorld } from 'core/geometry/targetFrame';\nimport { outsetBox } from 'core/geometry/inkExtents';\nimport type { SnapBegin, SnapSession } from '../snapDep';\nimport { inputSession } from 'features/snap/session2d';\n\n/** The box the drag resizes, as the press found it. */\nexport interface ResizeBox {\n  /** The union for a group or a multi-selection, a lone target's own bounds\n   *  otherwise. The `src` rect every write id is remapped from. */\n  readonly bounds: Bounds;\n  readonly anchor: ResizeAnchor;\n  /** A lone target's rotation; 0 for a group. */\n  readonly rotation: number;\n  /** A lone target's `transform`; none for a group. */\n  readonly transform?: PoseLinear;\n  /** World position of the corner opposite the dragged one, which a resize\n   *  in a turned or skewed frame pins. */\n  readonly fixedWorld: { x: number; y: number };\n  /** How far the ink reaches past `bounds` in its own frame. The handles sit\n   *  on `bounds` grown by it, and the constraints see that box; the stroke\n   *  does not scale, so the same extents come off whatever box they return. */\n  readonly extents: InkExtents;\n}\n\n/** What a resize captured at press. Nothing here changes during the drag. */\nexport interface ResizeSession {\n  readonly scene: Scene<unknown, string, unknown>;\n  /** The ids the gesture writes: the leaf set for a group, else the selection. */\n  readonly writeIds: readonly NodeId[];\n  /** Whether `box` stands for several write ids, each remapped inside it,\n   *  rather than being a lone target's own. */\n  readonly sharedBox: boolean;\n  readonly box: ResizeBox;\n  /** Start poses as stored: the `from` of each op. */\n  readonly startPoses: ReadonlyMap<NodeId, unknown>;\n  /** Start poses in world, the frame the anchor math and the drag share. */\n  readonly startWorlds: ReadonlyMap<NodeId, unknown>;\n  /** Where the pointer pressed. */\n  readonly startWorld: { x: number; y: number };\n  readonly geometryOf: (id: NodeId) => PoseDescriptor<unknown>;\n  /** World reads and local writes over the scene's composition strategy. */\n  readonly poseFrame: PoseFrame<unknown>;\n  readonly view: unknown;\n  /** The smallest `box` may be resized to, from the written nodes' own\n   *  minimums: a floor under every constraint. `null` for none. */\n  readonly minimum: MinSize | null;\n  readonly constraints: readonly BoundsConstraint<Bounds>[];\n  /** Reused across the drag; constraints mutate its `scratch`. */\n  readonly gestureCtx: GestureContext<Bounds>;\n  readonly applyOps?: (ops: Op[], label: string) => void;\n  /** Finishes the committed batch with the other nodes that change with it. */\n  readonly finish?: TransformFinisher;\n  /** When present, the commit maps each leaf's data-held geometry by the\n   *  affine its pose underwent. */\n  readonly geometryProjection?: GeometryProjection;\n  readonly selectionMethods: SelectionApi['adapterMethods'] | undefined;\n  /** Label, history, and callbacks from the `resizePolicy` dep. */\n  readonly lifecycle: GestureLifecycle;\n  /** The drag's snapping: the `snap` dep's session, else one that only holds\n   *  the handle to its axis and Shift to the aspect. */\n  readonly snap: SnapSession;\n}\n\n/** What one `onMove` produced. Replaced, not mutated, by the next. */\nexport interface ResizeFrame {\n  /** Stored-frame pose of every write id the move reached. */\n  readonly previews: Map<NodeId, unknown>;\n  /** The box the move resized `ResizeBox.bounds` to; absent before the first move. */\n  readonly proposed?: Bounds;\n}\n\n/** The part of a resize that a box alone decides: what it writes, the box\n *  they share, and where each starts. */\nexport type ResizePlace = Pick<\n  ResizeSession,\n  'scene' | 'writeIds' | 'sharedBox' | 'box' | 'startPoses' | 'startWorlds' | 'geometryOf' | 'poseFrame' | 'view' | 'minimum'\n>;\n\n/** Capture what resizing `ids` from `anchor` acts on. Null when nothing it\n *  would write exists. */\nexport function captureResize(\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  anchor: ResizeAnchor,\n  deps: Pick<ActionDeps, 'poseDescriptor' | 'resizePolicy' | 'view' | 'boundsIncludeStroke'>,\n): {\n  place: ResizePlace;\n  ruleOrigin: Bounds;\n  policy: ActionDeps['resizePolicy'];\n  constraints: BoundsConstraint<Bounds>[];\n} | null {\n  const geometry = poseDescriptorOf(deps.poseDescriptor);\n  const policy = deps.resizePolicy;\n  const { constraints, expandIds } = resolvePolicy(policy);\n  const geometryOf = nodeDescriptors(scene, geometry);\n\n  const targets = captureTargets(scene, ids, expandIds);\n  if (!targets) return null;\n  const { writeIds, isGroupPath } = targets;\n\n  // The drag delta is world, so the anchor math runs on world poses — carried\n  // into the plane the edit is measured in — and each result is carried back\n  // to its node's plane and stored in the node's own parent frame.\n  const poseFrame = scenePoseFrame(scene);\n  const view = deps.view;\n  const boxes = drawnBoxes({ ...deps, scene }, poseFrame);\n  const starts = captureStarts(scene, writeIds, geometryOf, poseFrame, view, boxes);\n  if (starts.startPoses.size === 0) return null;\n\n  const { box, ruleOrigin } = captureBox(starts, writeIds, isGroupPath, anchor, geometry, geometryOf);\n  const sharedBox = isGroupPath || writeIds.length > 1;\n  const written = writeIds.filter((id) => starts.startPoses.has(id));\n  return {\n    place: {\n      scene,\n      writeIds,\n      sharedBox,\n      minimum: boxMinimum(scene, written, starts.leafBounds, starts.startWorlds, box.bounds, sharedBox),\n      box,\n      startPoses: starts.startPoses,\n      startWorlds: starts.startWorlds,\n      geometryOf,\n      poseFrame,\n      view,\n    },\n    ruleOrigin,\n    policy,\n    constraints,\n  };\n}\n\n/** The drag's snap session, over the box as drawn in its own frame. */\nfunction beginSnap(ctx: InvocationCtx, ids: readonly NodeId[], press: { x: number; y: number }, box: ResizeBox): SnapSession {\n  const frame = boxFrame(box, box.bounds);\n  const req: SnapBegin = {\n    gesture: 'resize',\n    ids,\n    press,\n    handle: box.anchor,\n    constrain: 'aspect',\n    box: { bounds: outsetBox(box.bounds, box.extents), toWorld: (p) => localToWorld(frame, p.x, p.y) },\n  };\n  return ctx.deps.snap?.begin(req) ?? inputSession(req);\n}\n\n/** Capture a resize at press. Null when nothing is selected, the press is not\n *  on a resize handle, or nothing it would write exists. Runs each\n *  constraint's `onStart`. */\nexport function beginResize(\n  ctx: InvocationCtx,\n): { session: ResizeSession; readers: GestureReaders } | null {\n  const selection = ctx.deps.selection;\n  const scene = ctx.deps.scene;\n  if (!selection || !scene) return null;\n\n  const ids = selection.get() as NodeId[];\n  if (ids.length === 0) return null;\n\n  const anchor = ctx.drag?.affordance?.anchor;\n  if (!anchor) return null;\n\n  const captured = captureResize(scene, ids, anchor, ctx.deps);\n  if (!captured) return null;\n  const { place, ruleOrigin, policy, constraints } = captured;\n  const startWorld = { x: ctx.drag?.start.x ?? 0, y: ctx.drag?.start.y ?? 0 };\n  const readers = gestureReaders(ctx.deps);\n  const gestureCtx = buildGestureContext(ctx, ids, ruleOrigin, startWorld, readers);\n  for (const b of constraints) b.onStart?.(gestureCtx);\n\n  const session: ResizeSession = {\n    ...place,\n    startWorld,\n    constraints,\n    gestureCtx,\n    applyOps: ctx.deps.applyOps,\n    finish: transformFinisher(ctx.deps),\n    geometryProjection: ctx.deps.geometryProjection,\n    selectionMethods: selection.adapterMethods,\n    lifecycle: readGestureLifecycle(policy, 'Resize', constraints),\n    snap: beginSnap(ctx, ids, startWorld, place.box),\n  };\n  return { session, readers };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAoGA,SAAgB,cACd,OACA,KACA,QACA,MAMO;CACP,MAAM,WAAW,iBAAiB,KAAK,cAAc;CACrD,MAAM,SAAS,KAAK;CACpB,MAAM,EAAE,aAAa,cAAc,cAAc,MAAM;CACvD,MAAM,aAAa,gBAAgB,OAAO,QAAQ;CAElD,MAAM,UAAU,eAAe,OAAO,KAAK,SAAS;CACpD,IAAI,CAAC,SAAS,OAAO;CACrB,MAAM,EAAE,UAAU,gBAAgB;CAKlC,MAAM,YAAY,eAAe,KAAK;CACtC,MAAM,OAAO,KAAK;CAClB,MAAM,QAAQ,WAAW;EAAE,GAAG;EAAM;CAAM,GAAG,SAAS;CACtD,MAAM,SAAS,cAAc,OAAO,UAAU,YAAY,WAAW,MAAM,KAAK;CAChF,IAAI,OAAO,WAAW,SAAS,GAAG,OAAO;CAEzC,MAAM,EAAE,KAAK,eAAe,WAAW,QAAQ,UAAU,aAAa,QAAQ,UAAU,UAAU;CAClG,MAAM,YAAY,eAAe,SAAS,SAAS;CACnD,MAAM,UAAU,SAAS,QAAQ,OAAO,OAAO,WAAW,IAAI,EAAE,CAAC;CACjE,OAAO;EACL,OAAO;GACL;GACA;GACA;GACA,SAAS,WAAW,OAAO,SAAS,OAAO,YAAY,OAAO,aAAa,IAAI,QAAQ,SAAS;GAChG;GACA,YAAY,OAAO;GACnB,aAAa,OAAO;GACpB;GACA;GACA;EACF;EACA;EACA;EACA;CACF;AACF;;AAGA,SAAS,UAAU,KAAoB,KAAwB,OAAiC,KAA6B;CAC3H,MAAM,QAAQ,SAAS,KAAK,IAAI,MAAM;CACtC,MAAM,MAAiB;EACrB,SAAS;EACT;EACA;EACA,QAAQ,IAAI;EACZ,WAAW;EACX,KAAK;GAAE,QAAQ,UAAU,IAAI,QAAQ,IAAI,OAAO;GAAG,UAAU,MAAM,aAAa,OAAO,EAAE,GAAG,EAAE,CAAC;EAAE;CACnG;CACA,OAAO,IAAI,KAAK,MAAM,MAAM,GAAG,KAAK,aAAa,GAAG;AACtD;;;;AAKA,SAAgB,YACd,KAC4D;CAC5D,MAAM,YAAY,IAAI,KAAK;CAC3B,MAAM,QAAQ,IAAI,KAAK;CACvB,IAAI,CAAC,aAAa,CAAC,OAAO,OAAO;CAEjC,MAAM,MAAM,UAAU,IAAI;CAC1B,IAAI,IAAI,WAAW,GAAG,OAAO;CAE7B,MAAM,SAAS,IAAI,MAAM,YAAY;CACrC,IAAI,CAAC,QAAQ,OAAO;CAEpB,MAAM,WAAW,cAAc,OAAO,KAAK,QAAQ,IAAI,IAAI;CAC3D,IAAI,CAAC,UAAU,OAAO;CACtB,MAAM,EAAE,OAAO,YAAY,QAAQ,gBAAgB;CACnD,MAAM,aAAa;EAAE,GAAG,IAAI,MAAM,MAAM,KAAK;EAAG,GAAG,IAAI,MAAM,MAAM,KAAK;CAAE;CAC1E,MAAM,UAAU,eAAe,IAAI,IAAI;CACvC,MAAM,aAAa,oBAAoB,KAAK,KAAK,YAAY,YAAY,OAAO;CAChF,KAAK,MAAM,KAAK,aAAa,EAAE,UAAU,UAAU;CAcnD,OAAO;EAAE;GAXP,GAAG;GACH;GACA;GACA;GACA,UAAU,IAAI,KAAK;GACnB,QAAQ,kBAAkB,IAAI,IAAI;GAClC,oBAAoB,IAAI,KAAK;GAC7B,kBAAkB,UAAU;GAC5B,WAAW,qBAAqB,QAAQ,UAAU,WAAW;GAC7D,MAAM,UAAU,KAAK,KAAK,YAAY,MAAM,GAAG;EAExC;EAAS;CAAQ;AAC5B"}

package/dist/interactions/actions/resolveOverlays.js

@@ -1,61 +1,76 @@
-import { insertPreviewExtent as e } from "../../canvas/insertPreviewExtent.js";
+import { insertPreviewExtent } from "../../canvas/insertPreviewExtent.js";
+
 //#region src/interactions/actions/resolveOverlays.ts
-function t(t) {
-	let n = [];
-	for (let r of t) switch (r.kind) {
+/** The overlays worth painting, in the order the handles published them. */
+function resolveOverlays(overlays) {
+	const out = [];
+	for (const ov of overlays) switch (ov.kind) {
 		case "marquee": {
-			let e = Math.min(r.start.x, r.current.x), t = Math.min(r.start.y, r.current.y), i = Math.abs(r.current.x - r.start.x), a = Math.abs(r.current.y - r.start.y);
-			if (i === 0 && a === 0) break;
-			n.push({
+			const x = Math.min(ov.start.x, ov.current.x);
+			const y = Math.min(ov.start.y, ov.current.y);
+			const width = Math.abs(ov.current.x - ov.start.x);
+			const height = Math.abs(ov.current.y - ov.start.y);
+			if (width === 0 && height === 0) break;
+			out.push({
 				kind: "marquee",
 				visibilityId: "action.marquee",
 				bounds: {
-					x: e,
-					y: t,
-					width: i,
-					height: a
+					x,
+					y,
+					width,
+					height
 				},
-				shiftHeld: r.shiftHeld
+				shiftHeld: ov.shiftHeld
 			});
 			break;
 		}
 		case "lasso":
-			if (r.vertices.length < 2) break;
-			n.push({
+			if (ov.vertices.length < 2) break;
+			out.push({
 				kind: "lasso",
 				visibilityId: "action.lasso",
-				vertices: r.vertices,
-				current: r.current,
-				shiftHeld: r.shiftHeld
+				vertices: ov.vertices,
+				current: ov.current,
+				shiftHeld: ov.shiftHeld
 			});
 			break;
 		case "insertPreview": {
-			let { bounds: t, geometry: i } = e(r);
-			if (t.width === 0 && t.height === 0 && r.shape !== "pencil" || i.kind === "pencil" && i.samples.length < 2) break;
-			n.push({
+			const { bounds, geometry } = insertPreviewExtent(ov);
+			if (bounds.width === 0 && bounds.height === 0 && ov.shape !== "pencil") break;
+			if (geometry.kind === "pencil" && geometry.samples.length < 2) break;
+			out.push({
 				kind: "insertPreview",
 				visibilityId: "action.insert-preview",
-				shape: r.shape,
-				bounds: t,
-				geometry: i,
-				extras: r.extras,
-				...r.anchorPoint && r.shape !== "pencil" ? { anchorPoint: r.anchorPoint } : {},
-				...r.copies ? { copies: r.copies } : {}
+				shape: ov.shape,
+				bounds,
+				geometry,
+				extras: ov.extras,
+				...ov.anchorPoint && ov.shape !== "pencil" ? { anchorPoint: ov.anchorPoint } : {},
+				...ov.copies ? { copies: ov.copies } : {}
 			});
 			break;
 		}
 		case "polyline":
-			if (r.points.length < 2) break;
-			n.push({
+			if (ov.points.length < 2) break;
+			out.push({
 				kind: "polyline",
 				visibilityId: "action.polyline",
-				points: r.points,
-				role: r.role ?? "chrome"
+				points: ov.points,
+				role: ov.role ?? "chrome"
+			});
+			break;
+		case "brush":
+			if (ov.points.length === 0 || !(ov.radiusPx > 0)) break;
+			out.push({
+				kind: "brush",
+				visibilityId: "action.brush",
+				points: ov.points,
+				radiusPx: ov.radiusPx
 			});
 	}
-	return n;
+	return out;
 }
-//#endregion
-export { t as resolveOverlays };
 
+//#endregion
+export { resolveOverlays };
 //# sourceMappingURL=resolveOverlays.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"resolveOverlays.js","names":["resolveOverlays","out","ov","overlays","x","y","width","height","insertPreviewExtent","bounds","geometry"],"sources":["../../../src/interactions/actions/resolveOverlays.ts"],"sourcesContent":["/**\n * What an in-flight gesture is proposing to paint *beside* the scene, resolved\n * to geometry.\n *\n * The sibling of `resolvePreviews`: that one answers for the ghosts of scene\n * nodes a gesture is displacing, this one for the chrome a gesture draws that\n * is no node at all — a marquee rect, a lasso trail, the outline of a shape\n * being dragged out.\n *\n * What stays out, as in `resolvePreviews`: no view, no screen projection, no\n * `DrawCommand`, no style, no React, no dispatcher. World coordinates only.\n */\n\nimport type { InsertPreviewGeometry } from '../../canvas/insertPreviewExtent';\nimport { insertPreviewExtent } from '../../canvas/insertPreviewExtent';\nimport type { Bounds } from '../../core/viewport/fitViewToBounds';\nimport type { KitInsertShape } from '../../core/shapeKinds';\nimport type { OngoingOverlay, OverlayRole } from '@weasel-js/routing';\n\ntype Point = { x: number; y: number };\n\n/**\n * The chrome-caps id a surface consults before painting each variant. The\n * gating itself is the painter's — two views of one surface may disagree about\n * whether to show an in-flight marquee — but the id is not something a caller\n * should have to guess.\n */\nexport type OverlayVisibilityId =\n  | 'action.marquee'\n  | 'action.lasso'\n  | 'action.insert-preview'\n  | 'action.polyline';\n\n/**\n * One in-flight overlay, in world coordinates.\n *\n * Every degenerate overlay is already gone: a marquee of zero size, a lasso\n * under two vertices, a zero-area insert of anything but a pencil, a pencil\n * under two samples, a run of fewer than two points. Whatever is in this list\n * is worth painting.\n */\nexport type ResolvedOverlay =\n  | {\n      kind: 'marquee';\n      visibilityId: 'action.marquee';\n      /** The drag normalized: `start`/`current` in either order, one AABB. */\n      bounds: Bounds;\n      /** Additive intent. Core's 2D layer paints the same rect either way. */\n      shiftHeld: boolean;\n    }\n  | {\n      kind: 'lasso';\n      visibilityId: 'action.lasso';\n      /** The trail so far, at least two long. The region it encloses is the\n       *  trail closed back to its first vertex. */\n      vertices: ReadonlyArray<Point>;\n      /** Live pointer position — the trail's last vertex until it advances. */\n      current: Point;\n      shiftHeld: boolean;\n    }\n  | {\n      kind: 'insertPreview';\n      visibilityId: 'action.insert-preview';\n      shape: KitInsertShape;\n      /** Extent of `geometry`, which for a radial or freehand shape is not the\n       *  drag rect. See `insertPreviewExtent`. */\n      bounds: Bounds;\n      geometry: InsertPreviewGeometry;\n      /** The drag's anchor — a growth axis to mark. Absent for a pencil, which\n       *  has none. */\n      anchorPoint?: Point;\n      /** World affines the shape will also be drawn under, as the action gave them. */\n      copies?: readonly (readonly [number, number, number, number, number, number])[];\n      /** The action's per-shape payload, verbatim. Carries what geometry\n       *  cannot: an image insert's `src`, say. */\n      extras: unknown;\n    }\n  | {\n      kind: 'polyline';\n      visibilityId: 'action.polyline';\n      /** The run, at least two long, open — the last point does not join the\n       *  first. A closed sweep is a `lasso`. */\n      points: ReadonlyArray<Point>;\n      /** What the run is, for a painter choosing a style. Never defaulted\n       *  away: `'chrome'` when the action named none. A role the painter has\n       *  no style for is drawn as plain chrome, not dropped. */\n      role: OverlayRole;\n    };\n\n/** The overlays worth painting, in the order the handles published them. */\nexport function resolveOverlays(overlays: Iterable<OngoingOverlay>): ResolvedOverlay[] {\n  const out: ResolvedOverlay[] = [];\n  for (const ov of overlays) {\n    switch (ov.kind) {\n      case 'marquee': {\n        const x = Math.min(ov.start.x, ov.current.x);\n        const y = Math.min(ov.start.y, ov.current.y);\n        const width = Math.abs(ov.current.x - ov.start.x);\n        const height = Math.abs(ov.current.y - ov.start.y);\n        if (width === 0 && height === 0) break;\n        out.push({\n          kind: 'marquee',\n          visibilityId: 'action.marquee',\n          bounds: { x, y, width, height },\n          shiftHeld: ov.shiftHeld,\n        });\n        break;\n      }\n      case 'lasso': {\n        if (ov.vertices.length < 2) break;\n        out.push({\n          kind: 'lasso',\n          visibilityId: 'action.lasso',\n          vertices: ov.vertices,\n          current: ov.current,\n          shiftHeld: ov.shiftHeld,\n        });\n        break;\n      }\n      case 'insertPreview': {\n        const { bounds, geometry } = insertPreviewExtent(ov);\n        // A pencil can be meaningful at zero AABB — a closed loop, a\n        // sub-threshold gesture — where every other shape cannot.\n        if (bounds.width === 0 && bounds.height === 0 && ov.shape !== 'pencil') break;\n        if (geometry.kind === 'pencil' && geometry.samples.length < 2) break;\n        out.push({\n          kind: 'insertPreview',\n          visibilityId: 'action.insert-preview',\n          // Routing types the insert shape as an open string; a\n          // consumer-defined kind is legal there.\n          shape: ov.shape as KitInsertShape,\n          bounds,\n          geometry,\n          extras: ov.extras,\n          ...(ov.anchorPoint && ov.shape !== 'pencil' ? { anchorPoint: ov.anchorPoint } : {}),\n          ...(ov.copies ? { copies: ov.copies } : {}),\n        });\n        break;\n      }\n      case 'polyline': {\n        if (ov.points.length < 2) break;\n        out.push({\n          kind: 'polyline',\n          visibilityId: 'action.polyline',\n          points: ov.points,\n          role: ov.role ?? 'chrome',\n        });\n        break;\n      }\n    }\n  }\n  return out;\n}\n"],"mappings":";;AA0FA,SAAgBA,EAAgB,GAAuD;CACrF,IAAMC,IAAyB,CAAC;CAChC,KAAK,IAAMC,KAAMC,GACf,QAAQD,EAAG,MAAX;EACE,KAAK,WAAW;GACd,IAAME,IAAI,KAAK,IAAIF,EAAG,MAAM,GAAGA,EAAG,QAAQ,CAAC,GACrCG,IAAI,KAAK,IAAIH,EAAG,MAAM,GAAGA,EAAG,QAAQ,CAAC,GACrCI,IAAQ,KAAK,IAAIJ,EAAG,QAAQ,IAAIA,EAAG,MAAM,CAAC,GAC1CK,IAAS,KAAK,IAAIL,EAAG,QAAQ,IAAIA,EAAG,MAAM,CAAC;GACjD,IAAII,MAAU,KAAKC,MAAW,GAAG;GACjC,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,QAAQ;KAAE;KAAG;KAAG;KAAO;IAAO;IAC9B,WAAWL,EAAG;GAChB,CAAC;GACD;EACF;EACA,KAAK;GACH,IAAIA,EAAG,SAAS,SAAS,GAAG;GAC5B,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,UAAUA,EAAG;IACb,SAASA,EAAG;IACZ,WAAWA,EAAG;GAChB,CAAC;GACD;EAEF,KAAK,iBAAiB;GACpB,IAAM,EAAE,WAAQ,gBAAaM,EAAoBN,CAAE;GAInD,IADIO,EAAO,UAAU,KAAKA,EAAO,WAAW,KAAKP,EAAG,UAAU,YAC1DQ,EAAS,SAAS,YAAYA,EAAS,QAAQ,SAAS,GAAG;GAC/D,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IAGd,OAAOR,EAAG;IACV;IACA;IACA,QAAQA,EAAG;IACX,GAAIA,EAAG,eAAeA,EAAG,UAAU,WAAW,EAAE,aAAaA,EAAG,YAAY,IAAI,CAAC;IACjF,GAAIA,EAAG,SAAS,EAAE,QAAQA,EAAG,OAAO,IAAI,CAAC;GAC3C,CAAC;GACD;EACF;EACA,KAAK;GACH,IAAIA,EAAG,OAAO,SAAS,GAAG;GAC1B,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,QAAQA,EAAG;IACX,MAAMA,EAAG,QAAQ;GACnB,CAAC;CAGL;CAEF,OAAOD;AACT"}
+{"version":3,"file":"resolveOverlays.js","names":[],"sources":["../../../src/interactions/actions/resolveOverlays.ts"],"sourcesContent":["/**\n * What an in-flight gesture is proposing to paint *beside* the scene, resolved\n * to geometry.\n *\n * The sibling of `resolvePreviews`: that one answers for the ghosts of scene\n * nodes a gesture is displacing, this one for the chrome a gesture draws that\n * is no node at all — a marquee rect, a lasso trail, the outline of a shape\n * being dragged out.\n *\n * What stays out, as in `resolvePreviews`: no view, no screen projection, no\n * `DrawCommand`, no style, no React, no dispatcher. World coordinates only.\n */\n\nimport type { InsertPreviewGeometry } from '../../canvas/insertPreviewExtent';\nimport { insertPreviewExtent } from '../../canvas/insertPreviewExtent';\nimport type { Bounds } from '../../core/viewport/fitViewToBounds';\nimport type { KitInsertShape } from '../../core/shapeKinds';\nimport type { OngoingOverlay, OverlayRole } from '@weasel-js/routing';\n\ntype Point = { x: number; y: number };\n\n/**\n * The chrome-caps id a surface consults before painting each variant. The\n * gating itself is the painter's — two views of one surface may disagree about\n * whether to show an in-flight marquee — but the id is not something a caller\n * should have to guess.\n */\nexport type OverlayVisibilityId =\n  | 'action.marquee'\n  | 'action.lasso'\n  | 'action.insert-preview'\n  | 'action.polyline'\n  | 'action.brush';\n\n/**\n * One in-flight overlay, in world coordinates.\n *\n * Every degenerate overlay is already gone: a marquee of zero size, a lasso\n * under two vertices, a zero-area insert of anything but a pencil, a pencil\n * under two samples, a run of fewer than two points. Whatever is in this list\n * is worth painting.\n */\nexport type ResolvedOverlay =\n  | {\n      kind: 'marquee';\n      visibilityId: 'action.marquee';\n      /** The drag normalized: `start`/`current` in either order, one AABB. */\n      bounds: Bounds;\n      /** Additive intent. Core's 2D layer paints the same rect either way. */\n      shiftHeld: boolean;\n    }\n  | {\n      kind: 'lasso';\n      visibilityId: 'action.lasso';\n      /** The trail so far, at least two long. The region it encloses is the\n       *  trail closed back to its first vertex. */\n      vertices: ReadonlyArray<Point>;\n      /** Live pointer position — the trail's last vertex until it advances. */\n      current: Point;\n      shiftHeld: boolean;\n    }\n  | {\n      kind: 'insertPreview';\n      visibilityId: 'action.insert-preview';\n      shape: KitInsertShape;\n      /** Extent of `geometry`, which for a radial or freehand shape is not the\n       *  drag rect. See `insertPreviewExtent`. */\n      bounds: Bounds;\n      geometry: InsertPreviewGeometry;\n      /** The drag's anchor — a growth axis to mark. Absent for a pencil, which\n       *  has none. */\n      anchorPoint?: Point;\n      /** World affines the shape will also be drawn under, as the action gave them. */\n      copies?: readonly (readonly [number, number, number, number, number, number])[];\n      /** The action's per-shape payload, verbatim. Carries what geometry\n       *  cannot: an image insert's `src`, say. */\n      extras: unknown;\n    }\n  | {\n      kind: 'polyline';\n      visibilityId: 'action.polyline';\n      /** The run, at least two long, open — the last point does not join the\n       *  first. A closed sweep is a `lasso`. */\n      points: ReadonlyArray<Point>;\n      /** What the run is, for a painter choosing a style. Never defaulted\n       *  away: `'chrome'` when the action named none. A role the painter has\n       *  no style for is drawn as plain chrome, not dropped. */\n      role: OverlayRole;\n    }\n  | {\n      kind: 'brush';\n      visibilityId: 'action.brush';\n      /** The brush's path, at least one point; the last is where it is now. */\n      points: ReadonlyArray<Point>;\n      /** On screen: a painter draws it at this size at every zoom. */\n      radiusPx: number;\n    };\n\n/** The overlays worth painting, in the order the handles published them. */\nexport function resolveOverlays(overlays: Iterable<OngoingOverlay>): ResolvedOverlay[] {\n  const out: ResolvedOverlay[] = [];\n  for (const ov of overlays) {\n    switch (ov.kind) {\n      case 'marquee': {\n        const x = Math.min(ov.start.x, ov.current.x);\n        const y = Math.min(ov.start.y, ov.current.y);\n        const width = Math.abs(ov.current.x - ov.start.x);\n        const height = Math.abs(ov.current.y - ov.start.y);\n        if (width === 0 && height === 0) break;\n        out.push({\n          kind: 'marquee',\n          visibilityId: 'action.marquee',\n          bounds: { x, y, width, height },\n          shiftHeld: ov.shiftHeld,\n        });\n        break;\n      }\n      case 'lasso': {\n        if (ov.vertices.length < 2) break;\n        out.push({\n          kind: 'lasso',\n          visibilityId: 'action.lasso',\n          vertices: ov.vertices,\n          current: ov.current,\n          shiftHeld: ov.shiftHeld,\n        });\n        break;\n      }\n      case 'insertPreview': {\n        const { bounds, geometry } = insertPreviewExtent(ov);\n        // A pencil can be meaningful at zero AABB — a closed loop, a\n        // sub-threshold gesture — where every other shape cannot.\n        if (bounds.width === 0 && bounds.height === 0 && ov.shape !== 'pencil') break;\n        if (geometry.kind === 'pencil' && geometry.samples.length < 2) break;\n        out.push({\n          kind: 'insertPreview',\n          visibilityId: 'action.insert-preview',\n          // Routing types the insert shape as an open string; a\n          // consumer-defined kind is legal there.\n          shape: ov.shape as KitInsertShape,\n          bounds,\n          geometry,\n          extras: ov.extras,\n          ...(ov.anchorPoint && ov.shape !== 'pencil' ? { anchorPoint: ov.anchorPoint } : {}),\n          ...(ov.copies ? { copies: ov.copies } : {}),\n        });\n        break;\n      }\n      case 'polyline': {\n        if (ov.points.length < 2) break;\n        out.push({\n          kind: 'polyline',\n          visibilityId: 'action.polyline',\n          points: ov.points,\n          role: ov.role ?? 'chrome',\n        });\n        break;\n      }\n      case 'brush': {\n        if (ov.points.length === 0 || !(ov.radiusPx > 0)) break;\n        out.push({ kind: 'brush', visibilityId: 'action.brush', points: ov.points, radiusPx: ov.radiusPx });\n        break;\n      }\n    }\n  }\n  return out;\n}\n"],"mappings":";;;;AAmGA,SAAgB,gBAAgB,UAAuD;CACrF,MAAM,MAAyB,CAAC;CAChC,KAAK,MAAM,MAAM,UACf,QAAQ,GAAG,MAAX;EACE,KAAK,WAAW;GACd,MAAM,IAAI,KAAK,IAAI,GAAG,MAAM,GAAG,GAAG,QAAQ,CAAC;GAC3C,MAAM,IAAI,KAAK,IAAI,GAAG,MAAM,GAAG,GAAG,QAAQ,CAAC;GAC3C,MAAM,QAAQ,KAAK,IAAI,GAAG,QAAQ,IAAI,GAAG,MAAM,CAAC;GAChD,MAAM,SAAS,KAAK,IAAI,GAAG,QAAQ,IAAI,GAAG,MAAM,CAAC;GACjD,IAAI,UAAU,KAAK,WAAW,GAAG;GACjC,IAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,QAAQ;KAAE;KAAG;KAAG;KAAO;IAAO;IAC9B,WAAW,GAAG;GAChB,CAAC;GACD;EACF;EACA,KAAK;GACH,IAAI,GAAG,SAAS,SAAS,GAAG;GAC5B,IAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,UAAU,GAAG;IACb,SAAS,GAAG;IACZ,WAAW,GAAG;GAChB,CAAC;GACD;EAEF,KAAK,iBAAiB;GACpB,MAAM,EAAE,QAAQ,aAAa,oBAAoB,EAAE;GAGnD,IAAI,OAAO,UAAU,KAAK,OAAO,WAAW,KAAK,GAAG,UAAU,UAAU;GACxE,IAAI,SAAS,SAAS,YAAY,SAAS,QAAQ,SAAS,GAAG;GAC/D,IAAI,KAAK;IACP,MAAM;IACN,cAAc;IAGd,OAAO,GAAG;IACV;IACA;IACA,QAAQ,GAAG;IACX,GAAI,GAAG,eAAe,GAAG,UAAU,WAAW,EAAE,aAAa,GAAG,YAAY,IAAI,CAAC;IACjF,GAAI,GAAG,SAAS,EAAE,QAAQ,GAAG,OAAO,IAAI,CAAC;GAC3C,CAAC;GACD;EACF;EACA,KAAK;GACH,IAAI,GAAG,OAAO,SAAS,GAAG;GAC1B,IAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,QAAQ,GAAG;IACX,MAAM,GAAG,QAAQ;GACnB,CAAC;GACD;EAEF,KAAK;GACH,IAAI,GAAG,OAAO,WAAW,KAAK,EAAE,GAAG,WAAW,IAAI;GAClD,IAAI,KAAK;IAAE,MAAM;IAAS,cAAc;IAAgB,QAAQ,GAAG;IAAQ,UAAU,GAAG;GAAS,CAAC;CAGtG;CAEF,OAAO;AACT"}

package/dist/interactions/actions/resolvePreviews.js

@@ -1,61 +1,78 @@
-import { asNodeId as e } from "../../core/scene/types.js";
+import { effectivePose } from "../../core/scene/effectivePose.js";
+import { asNodeId } from "../../core/scene/types.js";
+
 //#region src/interactions/actions/resolvePreviews.ts
-function t(e, t, n) {
-	for (let r of e) {
-		let e = n(r, t);
-		if (e != null) return e;
+/** First non-null answer across sources, in the order given. */
+function firstNonNull(sources, id, read) {
+	for (const source of sources) {
+		const value = read(source, id);
+		if (value != null) return value;
 	}
 	return null;
 }
-function n(n, r) {
-	let i = [...n], a = /* @__PURE__ */ new Set();
-	for (let e of i) {
-		let t = e.previewIds?.();
-		if (t) for (let e of t) a.add(e);
+/**
+* The previewing subtrees, as roots. A previewed node whose parent is also
+* previewing is a child of that parent's entry rather than a root of its own,
+* which is what lets a caller draw a container and its contents as one thing.
+*
+* An id with no node is skipped: an insert previews before the node it will
+* create exists.
+*/
+function resolvePreviews(sources, scene) {
+	const list = [...sources];
+	const ids = /* @__PURE__ */ new Set();
+	for (const source of list) {
+		const previewing = source.previewIds?.();
+		if (!previewing) continue;
+		for (const id of previewing) ids.add(id);
 	}
-	if (a.size === 0) return [];
-	let o = /* @__PURE__ */ new Set();
-	for (let e of i) {
-		let t = e.previewOpaqueIds?.();
-		if (t) for (let e of t) o.add(e);
+	if (ids.size === 0) return [];
+	const opaque = /* @__PURE__ */ new Set();
+	for (const source of list) {
+		const settled = source.previewOpaqueIds?.();
+		if (!settled) continue;
+		for (const id of settled) opaque.add(id);
 	}
-	let s = (n) => {
-		let c = r.get(e(n));
-		if (!c) return null;
-		let l = t(i, n, (e, t) => e.previewPose?.(t)), u = t(i, n, (e, t) => e.previewData?.(t));
-		if (l == null && u == null) return null;
-		let d = [];
-		for (let t of r.childrenOf(e(n))) {
-			if (!a.has(t)) continue;
-			let e = s(t);
-			e && d.push(e);
+	const build = (id) => {
+		const node = scene.get(asNodeId(id));
+		if (!node) return null;
+		const pose = firstNonNull(list, id, (s, i) => s.previewPose?.(i));
+		const data = firstNonNull(list, id, (s, i) => s.previewData?.(i));
+		const children = [];
+		for (const childId of scene.childrenOf(asNodeId(id))) {
+			if (!ids.has(childId)) continue;
+			const child = build(childId);
+			if (child) children.push(child);
 		}
 		return {
-			id: e(n),
-			node: c,
-			pose: l ?? c.pose,
-			data: u ?? c.data,
-			opaque: o.has(n),
-			children: d
+			id: asNodeId(id),
+			node,
+			pose: pose ?? effectivePose(scene, node),
+			data: data ?? node.data,
+			opaque: opaque.has(id),
+			children
 		};
-	}, c = [];
-	for (let t of a) {
-		let n = r.get(e(t))?.parent;
-		if (n != null && a.has(n)) continue;
-		let i = s(t);
-		i && c.push(i);
+	};
+	const roots = [];
+	for (const id of ids) {
+		const parent = scene.get(asNodeId(id))?.parent;
+		if (parent != null && ids.has(parent)) continue;
+		const root = build(id);
+		if (root) roots.push(root);
 	}
-	return c;
+	return roots;
 }
-function r(e) {
-	let t = [], n = (e) => {
-		t.push(e);
-		for (let t of e.children) n(t);
+/** Every entry in the forest, parents before their children. */
+function flattenPreviews(roots) {
+	const out = [];
+	const walk = (entry) => {
+		out.push(entry);
+		for (const child of entry.children) walk(child);
 	};
-	for (let t of e) n(t);
-	return t;
+	for (const root of roots) walk(root);
+	return out;
 }
-//#endregion
-export { r as flattenPreviews, n as resolvePreviews };
 
+//#endregion
+export { flattenPreviews, resolvePreviews };
 //# sourceMappingURL=resolvePreviews.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"resolvePreviews.js","names":["firstNonNull","source","sources","value","read","id","resolvePreviews","list","ids","previewing","opaque","settled","build","node","scene","asNodeId","pose","s","i","data","children","childId","child","roots","parent","root","flattenPreviews","out","walk","entry"],"sources":["../../../src/interactions/actions/resolvePreviews.ts"],"sourcesContent":["/**\n * What an in-flight gesture is proposing, resolved against the committed scene.\n *\n * An ongoing action publishes interim poses on its handle rather than writing\n * them to the scene, and `<SceneCanvas>`'s ghost layer used to be the only\n * thing that knew how to read them: which ids are in flight, which of those are\n * roots, whose preview wins when two sources name the same id, and which are\n * merely displaced rather than dragged. None of that is about drawing, and a\n * consumer with its own renderer needs all of it.\n */\n\nimport type { GesturePreviewSource } from '../../canvas/gestureBounds';\nimport type { Node, NodeId, Scene } from '../../core/scene/types';\nimport { asNodeId } from '../../core/scene/types';\n\n/** One node an in-flight gesture is previewing, as {@link resolvePreviews} returns it. */\nexport interface PreviewNode<TData, TLayer extends string, TPose> {\n  id: NodeId;\n  /** The node as committed — the gesture has not touched the scene. */\n  node: Node<TData, TLayer, TPose>;\n  /** The interim pose, or the committed one when only data is in flight. */\n  pose: TPose;\n  /** The interim data, or the committed one when only the pose is in flight. */\n  data: TData;\n  /**\n   * The gesture is not carrying this one under the pointer — a layout sibling\n   * reflowing into its destination slot. It reads better painted settled.\n   */\n  opaque: boolean;\n  /** Previewed descendants, so a container's ghost brings its children. */\n  children: PreviewNode<TData, TLayer, TPose>[];\n}\n\n/** First non-null answer across sources, in the order given. */\nfunction firstNonNull<T>(\n  sources: readonly GesturePreviewSource[],\n  id: string,\n  read: (source: GesturePreviewSource, id: string) => unknown,\n): T | null {\n  for (const source of sources) {\n    const value = read(source, id);\n    if (value != null) return value as T;\n  }\n  return null;\n}\n\n/**\n * The previewing subtrees, as roots. A previewed node whose parent is also\n * previewing is a child of that parent's entry rather than a root of its own,\n * which is what lets a caller draw a container and its contents as one thing.\n *\n * An id with no node is skipped: an insert previews before the node it will\n * create exists. So is an id no source has a pose or data for.\n */\nexport function resolvePreviews<TData, TLayer extends string, TPose>(\n  sources: Iterable<GesturePreviewSource>,\n  scene: Scene<TData, TLayer, TPose>,\n): PreviewNode<TData, TLayer, TPose>[] {\n  const list = [...sources];\n  const ids = new Set<string>();\n  for (const source of list) {\n    const previewing = source.previewIds?.();\n    if (!previewing) continue;\n    for (const id of previewing) ids.add(id);\n  }\n  if (ids.size === 0) return [];\n\n  const opaque = new Set<string>();\n  for (const source of list) {\n    const settled = source.previewOpaqueIds?.();\n    if (!settled) continue;\n    for (const id of settled) opaque.add(id);\n  }\n\n  const build = (id: string): PreviewNode<TData, TLayer, TPose> | null => {\n    const node = scene.get(asNodeId(id));\n    if (!node) return null;\n    const pose = firstNonNull<TPose>(list, id, (s, i) => s.previewPose?.(i));\n    const data = firstNonNull<TData>(list, id, (s, i) => s.previewData?.(i));\n    if (pose == null && data == null) return null;\n\n    const children: PreviewNode<TData, TLayer, TPose>[] = [];\n    for (const childId of scene.childrenOf(asNodeId(id))) {\n      if (!ids.has(childId)) continue;\n      const child = build(childId);\n      if (child) children.push(child);\n    }\n\n    return {\n      id: asNodeId(id),\n      node,\n      pose: pose ?? node.pose,\n      data: data ?? node.data,\n      opaque: opaque.has(id),\n      children,\n    };\n  };\n\n  const roots: PreviewNode<TData, TLayer, TPose>[] = [];\n  for (const id of ids) {\n    const parent = scene.get(asNodeId(id))?.parent;\n    if (parent != null && ids.has(parent)) continue;\n    const root = build(id);\n    if (root) roots.push(root);\n  }\n  return roots;\n}\n\n/** Every entry in the forest, parents before their children. */\nexport function flattenPreviews<TData, TLayer extends string, TPose>(\n  roots: readonly PreviewNode<TData, TLayer, TPose>[],\n): PreviewNode<TData, TLayer, TPose>[] {\n  const out: PreviewNode<TData, TLayer, TPose>[] = [];\n  const walk = (entry: PreviewNode<TData, TLayer, TPose>) => {\n    out.push(entry);\n    for (const child of entry.children) walk(child);\n  };\n  for (const root of roots) walk(root);\n  return out;\n}\n"],"mappings":";;AAkCA,SAASA,EACP,GACA,GACA,GACU;CACV,KAAK,IAAMC,KAAUC,GAAS;EAC5B,IAAMC,IAAQC,EAAKH,GAAQI,CAAE;EAC7B,IAAIF,KAAS,MAAM,OAAOA;CAC5B;CACA,OAAO;AACT;AAUA,SAAgBG,EACd,GACA,GACqC;CACrC,IAAMC,IAAO,CAAC,GAAGL,CAAO,GAClBM,oBAAM,IAAI,IAAY;CAC5B,KAAK,IAAMP,KAAUM,GAAM;EACzB,IAAME,IAAaR,EAAO,aAAa;EACvC,IAAKQ,GACL,KAAK,IAAMJ,KAAMI,GAAY,EAAI,IAAIJ,CAAE;CACzC;CACA,IAAIG,EAAI,SAAS,GAAG,OAAO,CAAC;CAE5B,IAAME,oBAAS,IAAI,IAAY;CAC/B,KAAK,IAAMT,KAAUM,GAAM;EACzB,IAAMI,IAAUV,EAAO,mBAAmB;EAC1C,IAAKU,GACL,KAAK,IAAMN,KAAMM,GAAS,EAAO,IAAIN,CAAE;CACzC;CAEA,IAAMO,KAAS,MAAyD;EACtE,IAAMC,IAAOC,EAAM,IAAIC,EAASV,CAAE,CAAC;EACnC,IAAI,CAACQ,GAAM,OAAO;EAClB,IAAMG,IAAOhB,EAAoBO,GAAMF,IAAK,GAAG,MAAMY,EAAE,cAAcC,CAAC,CAAC,GACjEC,IAAOnB,EAAoBO,GAAMF,IAAK,GAAG,MAAMY,EAAE,cAAcC,CAAC,CAAC;EACvE,IAAIF,KAAQ,QAAQG,KAAQ,MAAM,OAAO;EAEzC,IAAMC,IAAgD,CAAC;EACvD,KAAK,IAAMC,KAAWP,EAAM,WAAWC,EAASV,CAAE,CAAC,GAAG;GACpD,IAAI,CAACG,EAAI,IAAIa,CAAO,GAAG;GACvB,IAAMC,IAAQV,EAAMS,CAAO;GAC3B,AAAIC,KAAOF,EAAS,KAAKE,CAAK;EAChC;EAEA,OAAO;GACL,IAAIP,EAASV,CAAE;GACf;GACA,MAAMW,KAAQH,EAAK;GACnB,MAAMM,KAAQN,EAAK;GACnB,QAAQH,EAAO,IAAIL,CAAE;GACrB;EACF;CACF,GAEMkB,IAA6C,CAAC;CACpD,KAAK,IAAMlB,KAAMG,GAAK;EACpB,IAAMgB,IAASV,EAAM,IAAIC,EAASV,CAAE,CAAC,CAAC,EAAE;EACxC,IAAImB,KAAU,QAAQhB,EAAI,IAAIgB,CAAM,GAAG;EACvC,IAAMC,IAAOb,EAAMP,CAAE;EACrB,AAAIoB,KAAMF,EAAM,KAAKE,CAAI;CAC3B;CACA,OAAOF;AACT;AAGA,SAAgBG,EACd,GACqC;CACrC,IAAMC,IAA2C,CAAC,GAC5CC,KAAQ,MAA6C;EACzD,EAAI,KAAKC,CAAK;EACd,KAAK,IAAMP,KAASO,EAAM,UAAU,EAAKP,CAAK;CAChD;CACA,KAAK,IAAMG,KAAQF,GAAO,EAAKE,CAAI;CACnC,OAAOE;AACT"}
+{"version":3,"file":"resolvePreviews.js","names":[],"sources":["../../../src/interactions/actions/resolvePreviews.ts"],"sourcesContent":["/**\n * What an in-flight gesture is proposing, resolved against the scene.\n *\n * An ongoing action names the ids it previews on its handle. A transform —\n * move, resize, rotate — publishes their poses to the scene's overrides, and\n * other actions answer `previewPose` on the handle. Resolving them means\n * knowing which ids are in flight, which of those are roots, whose preview\n * wins when two sources name the same id, and which are merely displaced\n * rather than dragged. None of that is about drawing, and a consumer with its\n * own renderer needs all of it.\n */\n\nimport type { GesturePreviewSource } from '../../canvas/gestureBounds';\nimport type { Node, NodeId, Scene } from '../../core/scene/types';\nimport { asNodeId } from '../../core/scene/types';\nimport { effectivePose } from '../../core/scene/effectivePose';\n\n/** One node an in-flight gesture is previewing, as {@link resolvePreviews} returns it. */\nexport interface PreviewNode<TData, TLayer extends string, TPose> {\n  id: NodeId;\n  /** The node as committed. */\n  node: Node<TData, TLayer, TPose>;\n  /** The pose a source previews, else the node's effective pose — where the\n   *  scene's overrides put it mid-transform. */\n  pose: TPose;\n  /** The interim data, or the committed one when only the pose is in flight. */\n  data: TData;\n  /**\n   * The gesture is not carrying this one under the pointer — a layout sibling\n   * reflowing into its destination slot. It reads better painted settled.\n   */\n  opaque: boolean;\n  /** Previewed descendants, so a container's ghost brings its children. */\n  children: PreviewNode<TData, TLayer, TPose>[];\n}\n\n/** First non-null answer across sources, in the order given. */\nfunction firstNonNull<T>(\n  sources: readonly GesturePreviewSource[],\n  id: string,\n  read: (source: GesturePreviewSource, id: string) => unknown,\n): T | null {\n  for (const source of sources) {\n    const value = read(source, id);\n    if (value != null) return value as T;\n  }\n  return null;\n}\n\n/**\n * The previewing subtrees, as roots. A previewed node whose parent is also\n * previewing is a child of that parent's entry rather than a root of its own,\n * which is what lets a caller draw a container and its contents as one thing.\n *\n * An id with no node is skipped: an insert previews before the node it will\n * create exists.\n */\nexport function resolvePreviews<TData, TLayer extends string, TPose>(\n  sources: Iterable<GesturePreviewSource>,\n  scene: Scene<TData, TLayer, TPose>,\n): PreviewNode<TData, TLayer, TPose>[] {\n  const list = [...sources];\n  const ids = new Set<string>();\n  for (const source of list) {\n    const previewing = source.previewIds?.();\n    if (!previewing) continue;\n    for (const id of previewing) ids.add(id);\n  }\n  if (ids.size === 0) return [];\n\n  const opaque = new Set<string>();\n  for (const source of list) {\n    const settled = source.previewOpaqueIds?.();\n    if (!settled) continue;\n    for (const id of settled) opaque.add(id);\n  }\n\n  const build = (id: string): PreviewNode<TData, TLayer, TPose> | null => {\n    const node = scene.get(asNodeId(id));\n    if (!node) return null;\n    const pose = firstNonNull<TPose>(list, id, (s, i) => s.previewPose?.(i));\n    const data = firstNonNull<TData>(list, id, (s, i) => s.previewData?.(i));\n\n    const children: PreviewNode<TData, TLayer, TPose>[] = [];\n    for (const childId of scene.childrenOf(asNodeId(id))) {\n      if (!ids.has(childId)) continue;\n      const child = build(childId);\n      if (child) children.push(child);\n    }\n\n    return {\n      id: asNodeId(id),\n      node,\n      pose: pose ?? effectivePose(scene, node),\n      data: data ?? node.data,\n      opaque: opaque.has(id),\n      children,\n    };\n  };\n\n  const roots: PreviewNode<TData, TLayer, TPose>[] = [];\n  for (const id of ids) {\n    const parent = scene.get(asNodeId(id))?.parent;\n    if (parent != null && ids.has(parent)) continue;\n    const root = build(id);\n    if (root) roots.push(root);\n  }\n  return roots;\n}\n\n/** Every entry in the forest, parents before their children. */\nexport function flattenPreviews<TData, TLayer extends string, TPose>(\n  roots: readonly PreviewNode<TData, TLayer, TPose>[],\n): PreviewNode<TData, TLayer, TPose>[] {\n  const out: PreviewNode<TData, TLayer, TPose>[] = [];\n  const walk = (entry: PreviewNode<TData, TLayer, TPose>) => {\n    out.push(entry);\n    for (const child of entry.children) walk(child);\n  };\n  for (const root of roots) walk(root);\n  return out;\n}\n"],"mappings":";;;;;AAqCA,SAAS,aACP,SACA,IACA,MACU;CACV,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,QAAQ,KAAK,QAAQ,EAAE;EAC7B,IAAI,SAAS,MAAM,OAAO;CAC5B;CACA,OAAO;AACT;;;;;;;;;AAUA,SAAgB,gBACd,SACA,OACqC;CACrC,MAAM,OAAO,CAAC,GAAG,OAAO;CACxB,MAAM,sBAAM,IAAI,IAAY;CAC5B,KAAK,MAAM,UAAU,MAAM;EACzB,MAAM,aAAa,OAAO,aAAa;EACvC,IAAI,CAAC,YAAY;EACjB,KAAK,MAAM,MAAM,YAAY,IAAI,IAAI,EAAE;CACzC;CACA,IAAI,IAAI,SAAS,GAAG,OAAO,CAAC;CAE5B,MAAM,yBAAS,IAAI,IAAY;CAC/B,KAAK,MAAM,UAAU,MAAM;EACzB,MAAM,UAAU,OAAO,mBAAmB;EAC1C,IAAI,CAAC,SAAS;EACd,KAAK,MAAM,MAAM,SAAS,OAAO,IAAI,EAAE;CACzC;CAEA,MAAM,SAAS,OAAyD;EACtE,MAAM,OAAO,MAAM,IAAI,SAAS,EAAE,CAAC;EACnC,IAAI,CAAC,MAAM,OAAO;EAClB,MAAM,OAAO,aAAoB,MAAM,KAAK,GAAG,MAAM,EAAE,cAAc,CAAC,CAAC;EACvE,MAAM,OAAO,aAAoB,MAAM,KAAK,GAAG,MAAM,EAAE,cAAc,CAAC,CAAC;EAEvE,MAAM,WAAgD,CAAC;EACvD,KAAK,MAAM,WAAW,MAAM,WAAW,SAAS,EAAE,CAAC,GAAG;GACpD,IAAI,CAAC,IAAI,IAAI,OAAO,GAAG;GACvB,MAAM,QAAQ,MAAM,OAAO;GAC3B,IAAI,OAAO,SAAS,KAAK,KAAK;EAChC;EAEA,OAAO;GACL,IAAI,SAAS,EAAE;GACf;GACA,MAAM,QAAQ,cAAc,OAAO,IAAI;GACvC,MAAM,QAAQ,KAAK;GACnB,QAAQ,OAAO,IAAI,EAAE;GACrB;EACF;CACF;CAEA,MAAM,QAA6C,CAAC;CACpD,KAAK,MAAM,MAAM,KAAK;EACpB,MAAM,SAAS,MAAM,IAAI,SAAS,EAAE,CAAC,CAAC,EAAE;EACxC,IAAI,UAAU,QAAQ,IAAI,IAAI,MAAM,GAAG;EACvC,MAAM,OAAO,MAAM,EAAE;EACrB,IAAI,MAAM,MAAM,KAAK,IAAI;CAC3B;CACA,OAAO;AACT;;AAGA,SAAgB,gBACd,OACqC;CACrC,MAAM,MAA2C,CAAC;CAClD,MAAM,QAAQ,UAA6C;EACzD,IAAI,KAAK,KAAK;EACd,KAAK,MAAM,SAAS,MAAM,UAAU,KAAK,KAAK;CAChD;CACA,KAAK,MAAM,QAAQ,OAAO,KAAK,IAAI;CACnC,OAAO;AACT"}