@weasel-js/core 1.10.1 → 1.11.1

package/dist/interactions/actions/defaults/selectAll.js.map

@@ -1 +1 @@
-{"version":3,"file":"selectAll.js","names":["selectAllAction","scene","deps","view","skipped","l","all","n"],"sources":["../../../../src/interactions/actions/defaults/selectAll.ts"],"sourcesContent":["import type { NodeId } from 'core/scene/types';\nimport type { Action } from '@weasel-js/routing';\n\n/**\n * @experimental\n * Static descriptor for the `selectAll` Action. Selects every scene node the\n * user can see and reach — nodes on a hidden or locked layer, or on a layer\n * the asking view does not paint, are left out, so Cmd+A then Delete cannot\n * take content that is off screen or locked.\n */\nexport const selectAllAction: Action & { requires: string[] } = {\n  id: 'selectAll',\n  label: 'Select All',\n  defaultBinding: { kind: 'key', key: 'a', mods: { mod: true } },\n  eligible: { capability: 'creates-selection' },\n  requires: ['scene', 'selection', 'view'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const scene = deps.scene;\n      const view = deps.view;\n      const skipped = new Set(\n        (scene?.layers ?? []).filter((l) => !l.visible || l.locked === true).map((l) => l.id),\n      );\n      // Scene exposes `renderOrder()` (bottom→top iterable of NodeIds), not\n      // the never-implemented `listAll()`. The node walk is the same sequence\n      // and carries the layer each id sits on, which the id walk cannot.\n      const filtered = skipped.size > 0 || view?.layerIsPainted !== undefined;\n      const all: NodeId[] = !filtered || !scene?.renderOrderNodes\n        ? (scene?.renderOrder ? [...scene.renderOrder()] : [])\n        : scene.renderOrderNodes()\n          .filter((n) => !skipped.has(n.layer)\n            && view?.layerIsPainted?.(n.layer) !== false\n            && scene.isLocked?.(n.id) !== true)\n          .map((n) => n.id);\n      if (all.length === 0) return;\n      deps.selection?.set(all);\n    },\n  },\n};\n"],"mappings":";AAUA,IAAaA,IAAmD;CAC9D,IAAI;CACJ,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM,EAAE,KAAK,GAAK;CAAE;CAC7D,UAAU,EAAE,YAAY,oBAAoB;CAC5C,UAAU;EAAC;EAAS;EAAa;CAAM;CACvC,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,IAAMC,IAAQC,EAAK,OACbC,IAAOD,EAAK,MACZE,IAAU,IAAI,KACjBH,GAAO,UAAU,CAAC,EAAA,CAAG,QAAQ,MAAM,CAACI,EAAE,WAAWA,EAAE,WAAW,EAAI,CAAC,CAAC,KAAK,MAAMA,EAAE,EAAE,CACtF,GAKMC,IAAgB,EADLF,EAAQ,OAAO,KAAKD,GAAM,mBAAmB,KAAA,MAC3B,CAACF,GAAO,mBACtCA,GAAO,cAAc,CAAC,GAAGA,EAAM,YAAY,CAAC,IAAI,CAAC,IAClDA,EAAM,iBAAiB,CAAC,CACvB,QAAQ,MAAM,CAACG,EAAQ,IAAIG,EAAE,KAAK,KAC9BJ,GAAM,iBAAiBI,EAAE,KAAK,MAAM,MACpCN,EAAM,WAAWM,EAAE,EAAE,MAAM,EAAI,CAAC,CACpC,KAAK,MAAMA,EAAE,EAAE;GACpB,AAAID,EAAI,WAAW,KACnBJ,EAAK,WAAW,IAAII,CAAG;EACzB;CACF;AACF"}
+{"version":3,"file":"selectAll.js","names":[],"sources":["../../../../src/interactions/actions/defaults/selectAll.ts"],"sourcesContent":["import type { NodeId } from 'core/scene/types';\nimport type { Action } from '@weasel-js/routing';\nimport { isAnnotationLayer } from 'core/scene/annotation';\nimport { nodeGates } from 'core/scene/nodeGates';\n\n/**\n * Static descriptor for the `selectAll` Action. Selects every scene node the\n * user can see and reach — hidden and locked nodes (`nodeGates`), and nodes on\n * a layer the asking view does not paint, are left out, so Cmd+A then Delete cannot\n * take content that is off screen or locked.\n */\nexport const selectAllAction: Action & { requires: string[] } = {\n  id: 'selectAll',\n  label: 'Select All',\n  defaultBinding: { kind: 'key', key: 'a', mods: { mod: true } },\n  eligible: { capability: 'creates-selection' },\n  requires: ['scene', 'selection', 'view'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const scene = deps.scene;\n      const view = deps.view;\n      if (!scene) return;\n      // The node walk carries the layer each id sits on, which `view` gates.\n      const gates = nodeGates(scene);\n      const all: NodeId[] = scene.renderOrderNodes()\n        .filter((n) => !isAnnotationLayer(scene.layers.find((l) => l.id === n.layer))\n          && view?.layerIsPainted?.(n.layer) !== false\n          && !gates.hidden(n.id)\n          && !gates.locked(n.id))\n        .map((n) => n.id);\n      if (all.length === 0) return;\n      deps.selection?.set(all);\n    },\n  },\n};\n"],"mappings":";;;;;;;;;;AAWA,IAAa,kBAAmD;CAC9D,IAAI;CACJ,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM,EAAE,KAAK,KAAK;CAAE;CAC7D,UAAU,EAAE,YAAY,oBAAoB;CAC5C,UAAU;EAAC;EAAS;EAAa;CAAM;CACvC,SAAS;EACP,QAAQ;EACR,MAAM,SAAS;GACb,MAAM,QAAQ,KAAK;GACnB,MAAM,OAAO,KAAK;GAClB,IAAI,CAAC,OAAO;GAEZ,MAAM,QAAQ,UAAU,KAAK;GAC7B,MAAM,MAAgB,MAAM,iBAAiB,CAAC,CAC3C,QAAQ,MAAM,CAAC,kBAAkB,MAAM,OAAO,MAAM,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,KACvE,MAAM,iBAAiB,EAAE,KAAK,MAAM,SACpC,CAAC,MAAM,OAAO,EAAE,EAAE,KAClB,CAAC,MAAM,OAAO,EAAE,EAAE,CAAC,CAAC,CACxB,KAAK,MAAM,EAAE,EAAE;GAClB,IAAI,IAAI,WAAW,GAAG;GACtB,KAAK,WAAW,IAAI,GAAG;EACzB;CACF;AACF"}

package/dist/interactions/actions/defaults/setFill.js

@@ -1,33 +1,49 @@
-import { DEFAULT_FILL_COLOR as e, paintWithColor as t } from "../../../util/paint.js";
-import { createPaintAction as n } from "./createPaintAction.js";
+import { DEFAULT_FILL_COLOR, paintWithColor } from "../../../util/paint.js";
+import { createPaintAction } from "./createPaintAction.js";
+
 //#region src/interactions/actions/defaults/setFill.ts
-function r(e, n) {
-	return n.paint === null ? null : {
-		...e,
-		paint: n.paint ?? t(e?.paint, n.color)
+/** Repaint a node's fill, keeping whatever else the fill carries. */
+function repaint(prev, state) {
+	if (state.paint === null) return null;
+	return {
+		...prev,
+		paint: state.paint ?? paintWithColor(prev?.paint, state.color)
 	};
 }
-var i = n({
+/**
+* Static descriptor for the `setFill` Action.
+*
+* Takes either `color` (a hex string) or `paint` (a whole `Paint`, for
+* gradients and patterns). `paint` wins when both are present.
+*
+* Alpha semantics: alpha lives on the paint's `opacity`. A 6-char (no-alpha)
+* color adopts the alpha of the node's existing paint; an 8-char color states
+* its own. A `paint` is written verbatim.
+*/
+var setFillAction = createPaintAction({
 	id: "setFill",
 	label: "Set fill",
 	dataKey: "fill",
-	initialState: (t) => ({
-		color: t("color") ?? e,
-		paint: t("paint")
+	initialState: (pick) => ({
+		color: pick("color") ?? DEFAULT_FILL_COLOR,
+		paint: pick("paint")
 	}),
-	readParams: (e, t) => {
-		let n = t?.color, r = t?.paint;
-		return n === void 0 && r === void 0 ? null : n === void 0 ? {
-			...e,
-			paint: r
-		} : {
-			color: n,
-			paint: r
+	readParams: (prev, params) => {
+		const color = params?.color;
+		const paint = params?.paint;
+		if (color === void 0 && paint === void 0) return null;
+		if (color === void 0) return {
+			...prev,
+			paint
+		};
+		return {
+			color,
+			paint
 		};
 	},
-	merge: r
+	merge: repaint
 });
-//#endregion
-export { i as setFillAction };
 
+//#endregion
+export { setFillAction };
 //# sourceMappingURL=setFill.js.map

package/dist/interactions/actions/defaults/setFill.js.map

@@ -1 +1 @@
-{"version":3,"file":"setFill.js","names":["repaint","state","prev","paintWithColor","setFillAction","createPaintAction","pick","DEFAULT_FILL_COLOR","color","params","paint"],"sources":["../../../../src/interactions/actions/defaults/setFill.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Fill, Paint } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithColor, DEFAULT_FILL_COLOR } from '../../../util/paint';\n\n/** `setFill`'s gesture state. A `paint` shadows the color until a later color\n *  supersedes it. */\ninterface SetFillState {\n  /** May be 6- or 8-char hex. Ignored while `paint` is set. */\n  color: string;\n  /** `null` is an explicit no-fill, distinct from `undefined`, which means\n   *  this gesture carries no paint and the color applies. */\n  paint?: Paint | null;\n}\n\n/** Repaint a node's fill, keeping whatever else the fill carries. */\nfunction repaint(prev: Fill | null | undefined, state: SetFillState): Fill | null {\n  // `??` would read an explicit no-fill as \"no paint given\" and repaint the\n  // node with the state's color, so absence has to be tested for.\n  if (state.paint === null) return null;\n  return { ...prev, paint: state.paint ?? paintWithColor(prev?.paint, state.color) };\n}\n\n/**\n * Static descriptor for the `setFill` Action.\n *\n * Takes either `color` (a hex string) or `paint` (a whole `Paint`, for\n * gradients and patterns). `paint` wins when both are present.\n *\n * Alpha semantics: alpha lives on the paint's `opacity`. A 6-char (no-alpha)\n * color adopts the alpha of the node's existing paint; an 8-char color states\n * its own. A `paint` is written verbatim.\n */\nexport const setFillAction: Action & { requires: string[] } = createPaintAction<\n  SetFillState,\n  Fill,\n  'fill'\n>({\n  id: 'setFill',\n  label: 'Set fill',\n  dataKey: 'fill',\n  initialState: (pick) => ({\n    color: pick<string>('color') ?? DEFAULT_FILL_COLOR,\n    paint: pick<Paint | null>('paint'),\n  }),\n  readParams: (prev, params) => {\n    const color = params?.color as string | undefined;\n    const paint = params?.paint as Paint | null | undefined;\n    if (color === undefined && paint === undefined) return null;\n    if (color === undefined) return { ...prev, paint };\n    // An explicit color supersedes a paint from an earlier tick; otherwise a\n    // picker drag after a gradient would do nothing.\n    return { color, paint };\n  },\n  merge: repaint,\n});\n"],"mappings":";;;AAgBA,SAASA,EAAQ,GAA+B,GAAkC;CAIhF,OADIC,EAAM,UAAU,OAAa,OAC1B;EAAE,GAAGC;EAAM,OAAOD,EAAM,SAASE,EAAeD,GAAM,OAAOD,EAAM,KAAK;CAAE;AACnF;AAYA,IAAaG,IAAiDC,EAI5D;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,OAAU;EACvB,OAAOC,EAAa,OAAO,KAAKC;EAChC,OAAOD,EAAmB,OAAO;CACnC;CACA,aAAa,GAAM,MAAW;EAC5B,IAAME,IAAQC,GAAQ,OAChBC,IAAQD,GAAQ;EAKtB,OAJID,MAAU,KAAA,KAAaE,MAAU,KAAA,IAAkB,OACnDF,MAAU,KAAA,IAAkB;GAAE,GAAGN;GAAM;EAAM,IAG1C;GAAE;GAAO;EAAM;CACxB;CACA,OAAOF;AACT,CAAC"}
+{"version":3,"file":"setFill.js","names":[],"sources":["../../../../src/interactions/actions/defaults/setFill.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Fill, Paint } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithColor, DEFAULT_FILL_COLOR } from '../../../util/paint';\n\n/** `setFill`'s gesture state. A `paint` shadows the color until a later color\n *  supersedes it. */\ninterface SetFillState {\n  /** May be 6- or 8-char hex. Ignored while `paint` is set. */\n  color: string;\n  /** `null` is an explicit no-fill, distinct from `undefined`, which means\n   *  this gesture carries no paint and the color applies. */\n  paint?: Paint | null;\n}\n\n/** Repaint a node's fill, keeping whatever else the fill carries. */\nfunction repaint(prev: Fill | null | undefined, state: SetFillState): Fill | null {\n  // `??` would read an explicit no-fill as \"no paint given\" and repaint the\n  // node with the state's color, so absence has to be tested for.\n  if (state.paint === null) return null;\n  return { ...prev, paint: state.paint ?? paintWithColor(prev?.paint, state.color) };\n}\n\n/**\n * Static descriptor for the `setFill` Action.\n *\n * Takes either `color` (a hex string) or `paint` (a whole `Paint`, for\n * gradients and patterns). `paint` wins when both are present.\n *\n * Alpha semantics: alpha lives on the paint's `opacity`. A 6-char (no-alpha)\n * color adopts the alpha of the node's existing paint; an 8-char color states\n * its own. A `paint` is written verbatim.\n */\nexport const setFillAction: Action & { requires: string[] } = createPaintAction<\n  SetFillState,\n  Fill,\n  'fill'\n>({\n  id: 'setFill',\n  label: 'Set fill',\n  dataKey: 'fill',\n  initialState: (pick) => ({\n    color: pick<string>('color') ?? DEFAULT_FILL_COLOR,\n    paint: pick<Paint | null>('paint'),\n  }),\n  readParams: (prev, params) => {\n    const color = params?.color as string | undefined;\n    const paint = params?.paint as Paint | null | undefined;\n    if (color === undefined && paint === undefined) return null;\n    if (color === undefined) return { ...prev, paint };\n    // An explicit color supersedes a paint from an earlier tick; otherwise a\n    // picker drag after a gradient would do nothing.\n    return { color, paint };\n  },\n  merge: repaint,\n});\n"],"mappings":";;;;;AAgBA,SAAS,QAAQ,MAA+B,OAAkC;CAGhF,IAAI,MAAM,UAAU,MAAM,OAAO;CACjC,OAAO;EAAE,GAAG;EAAM,OAAO,MAAM,SAAS,eAAe,MAAM,OAAO,MAAM,KAAK;CAAE;AACnF;;;;;;;;;;;AAYA,IAAa,gBAAiD,kBAI5D;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,UAAU;EACvB,OAAO,KAAa,OAAO,KAAK;EAChC,OAAO,KAAmB,OAAO;CACnC;CACA,aAAa,MAAM,WAAW;EAC5B,MAAM,QAAQ,QAAQ;EACtB,MAAM,QAAQ,QAAQ;EACtB,IAAI,UAAU,UAAa,UAAU,QAAW,OAAO;EACvD,IAAI,UAAU,QAAW,OAAO;GAAE,GAAG;GAAM;EAAM;EAGjD,OAAO;GAAE;GAAO;EAAM;CACxB;CACA,OAAO;AACT,CAAC"}

package/dist/interactions/actions/defaults/setFillOpacity.js

@@ -1,18 +1,27 @@
-import { DEFAULT_FILL_COLOR as e, paintWithAlpha as t, solid as n } from "../../../util/paint.js";
-import { createPaintAction as r } from "./createPaintAction.js";
+import { DEFAULT_FILL_COLOR, paintWithAlpha, solid } from "../../../util/paint.js";
+import { createPaintAction } from "./createPaintAction.js";
+
 //#region src/interactions/actions/defaults/setFillOpacity.ts
-var i = r({
+/**
+* Static descriptor for the `setFillOpacity` Action.
+*
+* `params.alpha01` (0..1) becomes each node's fill paint `opacity`, leaving
+* the rest of the paint — color, gradient stops, pattern — alone. That is the
+* one alpha slot a gradient or a pattern has, so it is the slot all of them
+* use. A node with no fill yet takes the kit's default one.
+*/
+var setFillOpacityAction = createPaintAction({
 	id: "setFillOpacity",
 	label: "Set fill opacity",
 	dataKey: "fill",
-	initialState: (e) => e("alpha01") ?? 1,
-	readParams: (e, t) => t?.alpha01 ?? null,
-	merge: (r, i) => ({
-		...r,
-		paint: t(r?.paint ?? n(e), i)
+	initialState: (pick) => pick("alpha01") ?? 1,
+	readParams: (_prev, params) => params?.alpha01 ?? null,
+	merge: (prev, alpha01) => ({
+		...prev,
+		paint: paintWithAlpha(prev?.paint ?? solid(DEFAULT_FILL_COLOR), alpha01)
 	})
 });
-//#endregion
-export { i as setFillOpacityAction };
 
+//#endregion
+export { setFillOpacityAction };
 //# sourceMappingURL=setFillOpacity.js.map

package/dist/interactions/actions/defaults/setFillOpacity.js.map

@@ -1 +1 @@
-{"version":3,"file":"setFillOpacity.js","names":["setFillOpacityAction","createPaintAction","pick","params","prev","paintWithAlpha","solid","DEFAULT_FILL_COLOR","alpha01"],"sources":["../../../../src/interactions/actions/defaults/setFillOpacity.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Fill } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithAlpha, solid, DEFAULT_FILL_COLOR } from '../../../util/paint';\n\n/**\n * Static descriptor for the `setFillOpacity` Action.\n *\n * `params.alpha01` (0..1) becomes each node's fill paint `opacity`, leaving\n * the rest of the paint — color, gradient stops, pattern — alone. That is the\n * one alpha slot a gradient or a pattern has, so it is the slot all of them\n * use. A node with no fill yet takes the kit's default one.\n */\nexport const setFillOpacityAction: Action & { requires: string[] } = createPaintAction<\n  number,\n  Fill,\n  'fill'\n>({\n  id: 'setFillOpacity',\n  label: 'Set fill opacity',\n  dataKey: 'fill',\n  initialState: (pick) => pick<number>('alpha01') ?? 1,\n  readParams: (_prev, params) => (params?.alpha01 as number | undefined) ?? null,\n  merge: (prev, alpha01) => ({ ...prev, paint: paintWithAlpha(prev?.paint ?? solid(DEFAULT_FILL_COLOR), alpha01) }),\n});\n"],"mappings":";;;AAaA,IAAaA,IAAwDC,EAInE;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,MAASC,EAAa,SAAS,KAAK;CACnD,aAAa,GAAO,MAAYC,GAAQ,WAAkC;CAC1E,QAAQ,GAAM,OAAa;EAAE,GAAGC;EAAM,OAAOC,EAAeD,GAAM,SAASE,EAAMC,CAAkB,GAAGC,CAAO;CAAE;AACjH,CAAC"}
+{"version":3,"file":"setFillOpacity.js","names":[],"sources":["../../../../src/interactions/actions/defaults/setFillOpacity.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Fill } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithAlpha, solid, DEFAULT_FILL_COLOR } from '../../../util/paint';\n\n/**\n * Static descriptor for the `setFillOpacity` Action.\n *\n * `params.alpha01` (0..1) becomes each node's fill paint `opacity`, leaving\n * the rest of the paint — color, gradient stops, pattern — alone. That is the\n * one alpha slot a gradient or a pattern has, so it is the slot all of them\n * use. A node with no fill yet takes the kit's default one.\n */\nexport const setFillOpacityAction: Action & { requires: string[] } = createPaintAction<\n  number,\n  Fill,\n  'fill'\n>({\n  id: 'setFillOpacity',\n  label: 'Set fill opacity',\n  dataKey: 'fill',\n  initialState: (pick) => pick<number>('alpha01') ?? 1,\n  readParams: (_prev, params) => (params?.alpha01 as number | undefined) ?? null,\n  merge: (prev, alpha01) => ({ ...prev, paint: paintWithAlpha(prev?.paint ?? solid(DEFAULT_FILL_COLOR), alpha01) }),\n});\n"],"mappings":";;;;;;;;;;;;AAaA,IAAa,uBAAwD,kBAInE;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,SAAS,KAAa,SAAS,KAAK;CACnD,aAAa,OAAO,WAAY,QAAQ,WAAkC;CAC1E,QAAQ,MAAM,aAAa;EAAE,GAAG;EAAM,OAAO,eAAe,MAAM,SAAS,MAAM,kBAAkB,GAAG,OAAO;CAAE;AACjH,CAAC"}

package/dist/interactions/actions/defaults/setStroke.js

@@ -1,36 +1,57 @@
-import { DEFAULT_STROKE_COLOR as e, paintWithColor as t, strokeOf as n, strokeWith as r } from "../../../util/paint.js";
-import { createPaintAction as i } from "./createPaintAction.js";
+import { DEFAULT_STROKE_COLOR, paintWithColor, strokeOf, strokeWith } from "../../../util/paint.js";
+import { createPaintAction } from "./createPaintAction.js";
+
 //#region src/interactions/actions/defaults/setStroke.ts
-function a(e, i) {
-	return i.paint === null ? null : i.paint ? e ? {
-		...e,
-		paint: i.paint
-	} : r(i.paint) : e ? {
-		...e,
-		paint: t(e.paint, i.color)
-	} : n(i.color);
+/** Repaint a node's stroke, keeping its width, cap, join, dash and align, so
+*  picking a paint does not discard the rest of the stroke. A node with no
+*  stroke yet gets a hairline one. */
+function repaint(prev, state) {
+	if (state.paint === null) return null;
+	if (state.paint) return prev ? {
+		...prev,
+		paint: state.paint
+	} : strokeWith(state.paint);
+	if (!prev) return strokeOf(state.color);
+	return {
+		...prev,
+		paint: paintWithColor(prev.paint, state.color)
+	};
 }
-var o = i({
+/**
+* Static descriptor for the `setStroke` Action.
+*
+* Takes either `color` (a hex string) or `paint` (a whole `Paint`, for
+* gradients and patterns). `paint` wins when both are present. A stroke's
+* width, cap, join, dash and align survive either.
+*
+* Alpha semantics: alpha lives on the stroke paint's `opacity`. A 6-char
+* (no-alpha) color adopts the alpha of the node's existing stroke paint; an
+* 8-char color states its own. A `paint` is written verbatim.
+*/
+var setStrokeAction = createPaintAction({
 	id: "setStroke",
 	label: "Set stroke",
 	dataKey: "stroke",
-	initialState: (t) => ({
-		color: t("color") ?? e,
-		paint: t("paint")
+	initialState: (pick) => ({
+		color: pick("color") ?? DEFAULT_STROKE_COLOR,
+		paint: pick("paint")
 	}),
-	readParams: (e, t) => {
-		let n = t?.color, r = t?.paint;
-		return n === void 0 && r === void 0 ? null : n === void 0 ? {
-			...e,
-			paint: r
-		} : {
-			color: n,
-			paint: r
+	readParams: (prev, params) => {
+		const color = params?.color;
+		const paint = params?.paint;
+		if (color === void 0 && paint === void 0) return null;
+		if (color === void 0) return {
+			...prev,
+			paint
+		};
+		return {
+			color,
+			paint
 		};
 	},
-	merge: a
+	merge: repaint
 });
-//#endregion
-export { o as setStrokeAction };
 
+//#endregion
+export { setStrokeAction };
 //# sourceMappingURL=setStroke.js.map

package/dist/interactions/actions/defaults/setStroke.js.map

@@ -1 +1 @@
-{"version":3,"file":"setStroke.js","names":["repaint","state","prev","strokeWith","paintWithColor","strokeOf","setStrokeAction","createPaintAction","pick","DEFAULT_STROKE_COLOR","color","params","paint"],"sources":["../../../../src/interactions/actions/defaults/setStroke.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Paint, Stroke } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithColor, strokeOf, strokeWith, DEFAULT_STROKE_COLOR } from '../../../util/paint';\n\n/** `setStroke`'s gesture state — `setFill`'s, against a stroke. */\ninterface SetStrokeState {\n  /** May be 6- or 8-char hex. Ignored while `paint` is set. */\n  color: string;\n  /** `null` is an explicit no-stroke, distinct from `undefined`, which means\n   *  this gesture carries no paint and the color applies. */\n  paint?: Paint | null;\n}\n\n/** Repaint a node's stroke, keeping its width, cap, join, dash and align, so\n *  picking a paint does not discard the rest of the stroke. A node with no\n *  stroke yet gets a hairline one. */\nfunction repaint(prev: Stroke | null | undefined, state: SetStrokeState): Stroke | null {\n  // A stroke whose paint is none paints nothing, so the whole stroke goes\n  // rather than being kept as a widthful thing that draws no ink.\n  if (state.paint === null) return null;\n  if (state.paint) return prev ? { ...prev, paint: state.paint } : strokeWith(state.paint);\n  if (!prev) return strokeOf(state.color);\n  return { ...prev, paint: paintWithColor(prev.paint, state.color) };\n}\n\n/**\n * Static descriptor for the `setStroke` Action.\n *\n * Takes either `color` (a hex string) or `paint` (a whole `Paint`, for\n * gradients and patterns). `paint` wins when both are present. A stroke's\n * width, cap, join, dash and align survive either.\n *\n * Alpha semantics: alpha lives on the stroke paint's `opacity`. A 6-char\n * (no-alpha) color adopts the alpha of the node's existing stroke paint; an\n * 8-char color states its own. A `paint` is written verbatim.\n */\nexport const setStrokeAction: Action & { requires: string[] } = createPaintAction<\n  SetStrokeState,\n  Stroke,\n  'stroke'\n>({\n  id: 'setStroke',\n  label: 'Set stroke',\n  dataKey: 'stroke',\n  initialState: (pick) => ({\n    color: pick<string>('color') ?? DEFAULT_STROKE_COLOR,\n    paint: pick<Paint | null>('paint'),\n  }),\n  readParams: (prev, params) => {\n    const color = params?.color as string | undefined;\n    const paint = params?.paint as Paint | null | undefined;\n    if (color === undefined && paint === undefined) return null;\n    if (color === undefined) return { ...prev, paint };\n    // An explicit color supersedes a paint from an earlier tick; otherwise a\n    // picker drag after a gradient would do nothing.\n    return { color, paint };\n  },\n  merge: repaint,\n});\n"],"mappings":";;;AAiBA,SAASA,EAAQ,GAAiC,GAAsC;CAMtF,OAHIC,EAAM,UAAU,OAAa,OAC7BA,EAAM,QAAcC,IAAO;EAAE,GAAGA;EAAM,OAAOD,EAAM;CAAM,IAAIE,EAAWF,EAAM,KAAK,IAClFC,IACE;EAAE,GAAGA;EAAM,OAAOE,EAAeF,EAAK,OAAOD,EAAM,KAAK;CAAE,IAD/CI,EAASJ,EAAM,KAAK;AAExC;AAaA,IAAaK,IAAmDC,EAI9D;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,OAAU;EACvB,OAAOC,EAAa,OAAO,KAAKC;EAChC,OAAOD,EAAmB,OAAO;CACnC;CACA,aAAa,GAAM,MAAW;EAC5B,IAAME,IAAQC,GAAQ,OAChBC,IAAQD,GAAQ;EAKtB,OAJID,MAAU,KAAA,KAAaE,MAAU,KAAA,IAAkB,OACnDF,MAAU,KAAA,IAAkB;GAAE,GAAGR;GAAM;EAAM,IAG1C;GAAE;GAAO;EAAM;CACxB;CACA,OAAOF;AACT,CAAC"}
+{"version":3,"file":"setStroke.js","names":[],"sources":["../../../../src/interactions/actions/defaults/setStroke.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Paint, Stroke } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithColor, strokeOf, strokeWith, DEFAULT_STROKE_COLOR } from '../../../util/paint';\n\n/** `setStroke`'s gesture state — `setFill`'s, against a stroke. */\ninterface SetStrokeState {\n  /** May be 6- or 8-char hex. Ignored while `paint` is set. */\n  color: string;\n  /** `null` is an explicit no-stroke, distinct from `undefined`, which means\n   *  this gesture carries no paint and the color applies. */\n  paint?: Paint | null;\n}\n\n/** Repaint a node's stroke, keeping its width, cap, join, dash and align, so\n *  picking a paint does not discard the rest of the stroke. A node with no\n *  stroke yet gets a hairline one. */\nfunction repaint(prev: Stroke | null | undefined, state: SetStrokeState): Stroke | null {\n  // A stroke whose paint is none paints nothing, so the whole stroke goes\n  // rather than being kept as a widthful thing that draws no ink.\n  if (state.paint === null) return null;\n  if (state.paint) return prev ? { ...prev, paint: state.paint } : strokeWith(state.paint);\n  if (!prev) return strokeOf(state.color);\n  return { ...prev, paint: paintWithColor(prev.paint, state.color) };\n}\n\n/**\n * Static descriptor for the `setStroke` Action.\n *\n * Takes either `color` (a hex string) or `paint` (a whole `Paint`, for\n * gradients and patterns). `paint` wins when both are present. A stroke's\n * width, cap, join, dash and align survive either.\n *\n * Alpha semantics: alpha lives on the stroke paint's `opacity`. A 6-char\n * (no-alpha) color adopts the alpha of the node's existing stroke paint; an\n * 8-char color states its own. A `paint` is written verbatim.\n */\nexport const setStrokeAction: Action & { requires: string[] } = createPaintAction<\n  SetStrokeState,\n  Stroke,\n  'stroke'\n>({\n  id: 'setStroke',\n  label: 'Set stroke',\n  dataKey: 'stroke',\n  initialState: (pick) => ({\n    color: pick<string>('color') ?? DEFAULT_STROKE_COLOR,\n    paint: pick<Paint | null>('paint'),\n  }),\n  readParams: (prev, params) => {\n    const color = params?.color as string | undefined;\n    const paint = params?.paint as Paint | null | undefined;\n    if (color === undefined && paint === undefined) return null;\n    if (color === undefined) return { ...prev, paint };\n    // An explicit color supersedes a paint from an earlier tick; otherwise a\n    // picker drag after a gradient would do nothing.\n    return { color, paint };\n  },\n  merge: repaint,\n});\n"],"mappings":";;;;;;;AAiBA,SAAS,QAAQ,MAAiC,OAAsC;CAGtF,IAAI,MAAM,UAAU,MAAM,OAAO;CACjC,IAAI,MAAM,OAAO,OAAO,OAAO;EAAE,GAAG;EAAM,OAAO,MAAM;CAAM,IAAI,WAAW,MAAM,KAAK;CACvF,IAAI,CAAC,MAAM,OAAO,SAAS,MAAM,KAAK;CACtC,OAAO;EAAE,GAAG;EAAM,OAAO,eAAe,KAAK,OAAO,MAAM,KAAK;CAAE;AACnE;;;;;;;;;;;;AAaA,IAAa,kBAAmD,kBAI9D;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,UAAU;EACvB,OAAO,KAAa,OAAO,KAAK;EAChC,OAAO,KAAmB,OAAO;CACnC;CACA,aAAa,MAAM,WAAW;EAC5B,MAAM,QAAQ,QAAQ;EACtB,MAAM,QAAQ,QAAQ;EACtB,IAAI,UAAU,UAAa,UAAU,QAAW,OAAO;EACvD,IAAI,UAAU,QAAW,OAAO;GAAE,GAAG;GAAM;EAAM;EAGjD,OAAO;GAAE;GAAO;EAAM;CACxB;CACA,OAAO;AACT,CAAC"}

package/dist/interactions/actions/defaults/setStrokeOpacity.js

@@ -1,21 +1,29 @@
-import { DEFAULT_STROKE_COLOR as e, paintWithAlpha as t, solid as n, strokeOf as r } from "../../../util/paint.js";
-import { createPaintAction as i } from "./createPaintAction.js";
+import { DEFAULT_STROKE_COLOR, paintWithAlpha, solid, strokeOf } from "../../../util/paint.js";
+import { createPaintAction } from "./createPaintAction.js";
+
 //#region src/interactions/actions/defaults/setStrokeOpacity.ts
-var a = i({
+/**
+* Static descriptor for the `setStrokeOpacity` Action.
+*
+* `params.alpha01` (0..1) becomes each node's stroke paint `opacity`, leaving
+* the rest of the stroke — color, width, cap, join, dash — alone. A node with
+* no stroke yet gets a hairline one.
+*/
+var setStrokeOpacityAction = createPaintAction({
 	id: "setStrokeOpacity",
 	label: "Set stroke opacity",
 	dataKey: "stroke",
-	initialState: (e) => e("alpha01") ?? 1,
-	readParams: (e, t) => t?.alpha01 ?? null,
-	merge: (i, a) => {
-		let o = i ?? r(e);
+	initialState: (pick) => pick("alpha01") ?? 1,
+	readParams: (_prev, params) => params?.alpha01 ?? null,
+	merge: (prev, alpha01) => {
+		const base = prev ?? strokeOf(DEFAULT_STROKE_COLOR);
 		return {
-			...o,
-			paint: t(o.paint ?? n(e), a)
+			...base,
+			paint: paintWithAlpha(base.paint ?? solid(DEFAULT_STROKE_COLOR), alpha01)
 		};
 	}
 });
-//#endregion
-export { a as setStrokeOpacityAction };
 
+//#endregion
+export { setStrokeOpacityAction };
 //# sourceMappingURL=setStrokeOpacity.js.map

package/dist/interactions/actions/defaults/setStrokeOpacity.js.map

@@ -1 +1 @@
-{"version":3,"file":"setStrokeOpacity.js","names":["setStrokeOpacityAction","createPaintAction","pick","params","base","prev","strokeOf","DEFAULT_STROKE_COLOR","paintWithAlpha","solid","alpha01"],"sources":["../../../../src/interactions/actions/defaults/setStrokeOpacity.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Stroke } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithAlpha, solid, strokeOf, DEFAULT_STROKE_COLOR } from '../../../util/paint';\n\n/**\n * Static descriptor for the `setStrokeOpacity` Action.\n *\n * `params.alpha01` (0..1) becomes each node's stroke paint `opacity`, leaving\n * the rest of the stroke — color, width, cap, join, dash — alone. A node with\n * no stroke yet gets a hairline one.\n */\nexport const setStrokeOpacityAction: Action & { requires: string[] } = createPaintAction<\n  number,\n  Stroke,\n  'stroke'\n>({\n  id: 'setStrokeOpacity',\n  label: 'Set stroke opacity',\n  dataKey: 'stroke',\n  initialState: (pick) => pick<number>('alpha01') ?? 1,\n  readParams: (_prev, params) => (params?.alpha01 as number | undefined) ?? null,\n  merge: (prev, alpha01) => {\n    const base = prev ?? strokeOf(DEFAULT_STROKE_COLOR);\n    // A stroke with no paint has no opacity to set; seed the same default\n    // colour a strokeless node gets, keeping the width and joins it has.\n    return { ...base, paint: paintWithAlpha(base.paint ?? solid(DEFAULT_STROKE_COLOR), alpha01) };\n  },\n});\n"],"mappings":";;;AAYA,IAAaA,IAA0DC,EAIrE;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,MAASC,EAAa,SAAS,KAAK;CACnD,aAAa,GAAO,MAAYC,GAAQ,WAAkC;CAC1E,QAAQ,GAAM,MAAY;EACxB,IAAMC,IAAOC,KAAQC,EAASC,CAAoB;EAGlD,OAAO;GAAE,GAAGH;GAAM,OAAOI,EAAeJ,EAAK,SAASK,EAAMF,CAAoB,GAAGG,CAAO;EAAE;CAC9F;AACF,CAAC"}
+{"version":3,"file":"setStrokeOpacity.js","names":[],"sources":["../../../../src/interactions/actions/defaults/setStrokeOpacity.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Stroke } from '@weasel-js/paint';\nimport { createPaintAction } from './createPaintAction';\nimport { paintWithAlpha, solid, strokeOf, DEFAULT_STROKE_COLOR } from '../../../util/paint';\n\n/**\n * Static descriptor for the `setStrokeOpacity` Action.\n *\n * `params.alpha01` (0..1) becomes each node's stroke paint `opacity`, leaving\n * the rest of the stroke — color, width, cap, join, dash — alone. A node with\n * no stroke yet gets a hairline one.\n */\nexport const setStrokeOpacityAction: Action & { requires: string[] } = createPaintAction<\n  number,\n  Stroke,\n  'stroke'\n>({\n  id: 'setStrokeOpacity',\n  label: 'Set stroke opacity',\n  dataKey: 'stroke',\n  initialState: (pick) => pick<number>('alpha01') ?? 1,\n  readParams: (_prev, params) => (params?.alpha01 as number | undefined) ?? null,\n  merge: (prev, alpha01) => {\n    const base = prev ?? strokeOf(DEFAULT_STROKE_COLOR);\n    // A stroke with no paint has no opacity to set; seed the same default\n    // colour a strokeless node gets, keeping the width and joins it has.\n    return { ...base, paint: paintWithAlpha(base.paint ?? solid(DEFAULT_STROKE_COLOR), alpha01) };\n  },\n});\n"],"mappings":";;;;;;;;;;;AAYA,IAAa,yBAA0D,kBAIrE;CACA,IAAI;CACJ,OAAO;CACP,SAAS;CACT,eAAe,SAAS,KAAa,SAAS,KAAK;CACnD,aAAa,OAAO,WAAY,QAAQ,WAAkC;CAC1E,QAAQ,MAAM,YAAY;EACxB,MAAM,OAAO,QAAQ,SAAS,oBAAoB;EAGlD,OAAO;GAAE,GAAG;GAAM,OAAO,eAAe,KAAK,SAAS,MAAM,oBAAoB,GAAG,OAAO;EAAE;CAC9F;AACF,CAAC"}

package/dist/interactions/actions/defaults/slice.js

@@ -1,39 +1,64 @@
-import { ActionDisabledReason as e, resolveParams as t } from "@weasel-js/routing";
+import { pathOperationTags } from "../pathGestureTags.js";
+import { ActionDisabledReason, resolveParams } from "@weasel-js/routing";
+
 //#region src/interactions/actions/defaults/slice.ts
-var n = {
+/**
+* Static descriptor for the `slice` Action.
+*
+* Ongoing drag invoker: tracks the cut while the gesture is in flight,
+* publishes it as a `'cut'` overlay, and on commit hands it to
+* `SliceDep.commit(cut)`. No-ops gracefully when the `slice` dep is absent.
+*
+* The cut is a straight line from drag start to the pointer by default. With
+* the binding param `cut: 'freehand'` it is the whole drag trail instead.
+*/
+var sliceAction = {
 	id: "slice",
 	label: "Slice",
+	tags: pathOperationTags("click"),
 	group: "edit",
 	eligible: { capability: "edits-page" },
 	requires: ["slice"],
 	invoker: {
 		timing: "ongoing",
-		start(e, n) {
-			let r = e.deps.slice, i = e.drag?.start ?? e.world, a = e.drag?.current ?? e.world, o, s = !0, c = () => t(n?.params)?.cut === "freehand", l = () => c() && o && o.length >= 2 ? o.map((e) => ({
-				x: e.x,
-				y: e.y
-			})) : [i, a];
+		start(ctx, opts) {
+			const dep = ctx.deps.slice;
+			const a = ctx.drag?.start ?? ctx.world;
+			let current = ctx.drag?.current ?? ctx.world;
+			let trail;
+			let open = true;
+			const freehand = () => resolveParams(opts?.params)?.["cut"] === "freehand";
+			const cut = () => freehand() && trail && trail.length >= 2 ? trail.map((p) => ({
+				x: p.x,
+				y: p.y
+			})) : [a, current];
 			return {
 				kind: "slice",
-				onMove(e) {
-					a = e.drag?.current ?? e.world, o = e.drag?.points;
+				onMove(moveCtx) {
+					current = moveCtx.drag?.current ?? moveCtx.world;
+					trail = moveCtx.drag?.points;
 				},
 				overlay() {
-					return s ? {
+					if (!open) return null;
+					return {
 						kind: "polyline",
-						points: l(),
+						points: cut(),
 						role: "cut"
-					} : null;
+					};
 				},
-				onEnd(e, t) {
-					s = !1, t !== "cancel" && r && (a = e.drag?.current ?? e.world, o = e.drag?.points ?? o, r.commit(l()));
+				onEnd(endCtx, reason) {
+					open = false;
+					if (reason === "cancel" || !dep) return;
+					current = endCtx.drag?.current ?? endCtx.world;
+					trail = endCtx.drag?.points ?? trail;
+					dep.commit(cut());
 				}
 			};
 		}
 	},
-	enabled: (t) => t?.slice ? !0 : e.NotApplicable
+	enabled: (deps) => deps?.["slice"] ? true : ActionDisabledReason.NotApplicable
 };
-//#endregion
-export { n as sliceAction };
 
+//#endregion
+export { sliceAction };
 //# sourceMappingURL=slice.js.map

package/dist/interactions/actions/defaults/slice.js.map

@@ -1 +1 @@
-{"version":3,"file":"slice.js","names":["sliceAction","dep","ctx","a","current","trail","open","freehand","resolveParams","opts","\"cut\"","cut","p","moveCtx","reason","endCtx","deps","\"slice\"","ActionDisabledReason"],"sources":["../../../../src/interactions/actions/defaults/slice.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason, resolveParams } from '@weasel-js/routing';\nimport type { BindingOpts, InvocationCtx, OngoingHandle, OngoingOverlay, Point2 } from '@weasel-js/routing';\n\n/**\n * @experimental\n * Static descriptor for the `slice` Action.\n *\n * Ongoing drag invoker: tracks the cut while the gesture is in flight,\n * publishes it as a `'cut'` overlay, and on commit hands it to\n * `SliceDep.commit(cut)`. No-ops gracefully when the `slice` dep is absent.\n *\n * The cut is a straight line from drag start to the pointer by default. With\n * the binding param `cut: 'freehand'` it is the whole drag trail instead.\n */\nexport const sliceAction: Action & { requires: string[] } = {\n  id: 'slice',\n  label: 'Slice',\n  group: 'edit',\n  eligible: { capability: 'edits-page' },\n  requires: ['slice'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const dep = ctx.deps.slice;\n      const a: Point2 = ctx.drag?.start ?? ctx.world;\n      let current: Point2 = ctx.drag?.current ?? ctx.world;\n      let trail: ReadonlyArray<Point2> | undefined;\n      let open = true;\n\n      const freehand = () => resolveParams(opts?.params)?.['cut'] === 'freehand';\n      const cut = (): Point2[] =>\n        freehand() && trail && trail.length >= 2\n          ? trail.map((p) => ({ x: p.x, y: p.y }))\n          : [a, current];\n\n      return {\n        kind: 'slice',\n        onMove(moveCtx: InvocationCtx): void {\n          current = moveCtx.drag?.current ?? moveCtx.world;\n          trail = moveCtx.drag?.points;\n        },\n        overlay(): OngoingOverlay | null {\n          if (!open) return null;\n          return { kind: 'polyline', points: cut(), role: 'cut' };\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          open = false;\n          if (reason === 'cancel' || !dep) return;\n          current = endCtx.drag?.current ?? endCtx.world;\n          trail = endCtx.drag?.points ?? trail;\n          dep.commit(cut());\n        },\n      };\n    },\n  },\n  // Slice can only act when a `slice` dep is wired (its `onEnd` no-ops\n  // otherwise), so reflect dep presence for any UI reading action-enabled\n  // state. The dispatcher still self-guards via the empty-handle path.\n  enabled: (deps) => (deps?.['slice'] ? true : ActionDisabledReason.NotApplicable),\n};\n"],"mappings":";;AAeA,IAAaA,IAA+C;CAC1D,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,aAAa;CACrC,UAAU,CAAC,OAAO;CAClB,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAMC,IAAMC,EAAI,KAAK,OACfC,IAAYD,EAAI,MAAM,SAASA,EAAI,OACrCE,IAAkBF,EAAI,MAAM,WAAWA,EAAI,OAC3CG,GACAC,IAAO,IAELC,UAAiBC,EAAcC,GAAM,MAAM,CAAC,EAAGC,QAAW,YAC1DC,UACJJ,EAAS,KAAKF,KAASA,EAAM,UAAU,IACnCA,EAAM,KAAK,OAAO;IAAE,GAAGO,EAAE;IAAG,GAAGA,EAAE;GAAE,EAAE,IACrC,CAACT,GAAGC,CAAO;GAEjB,OAAO;IACL,MAAM;IACN,OAAO,GAA8B;KAEnC,AADA,IAAUS,EAAQ,MAAM,WAAWA,EAAQ,OAC3C,IAAQA,EAAQ,MAAM;IACxB;IACA,UAAiC;KAE/B,OADKP,IACE;MAAE,MAAM;MAAY,QAAQK,EAAI;MAAG,MAAM;KAAM,IADpC;IAEpB;IACA,MAAM,GAAuB,GAAmC;KAE9D,AADA,IAAO,IACHG,MAAW,YAAab,MAC5B,IAAUc,EAAO,MAAM,WAAWA,EAAO,OACzC,IAAQA,EAAO,MAAM,UAAUV,GAC/BJ,EAAI,OAAOU,EAAI,CAAC;IAClB;GACF;EACF;CACF;CAIA,UAAU,MAAUK,GAAOC,QAAW,KAAOC,EAAqB;AACpE"}
+{"version":3,"file":"slice.js","names":[],"sources":["../../../../src/interactions/actions/defaults/slice.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason, resolveParams } from '@weasel-js/routing';\nimport type { BindingOpts, InvocationCtx, OngoingHandle, OngoingOverlay, Point2 } from '@weasel-js/routing';\nimport { pathOperationTags } from '../pathGestureTags';\n\n/**\n * Static descriptor for the `slice` Action.\n *\n * Ongoing drag invoker: tracks the cut while the gesture is in flight,\n * publishes it as a `'cut'` overlay, and on commit hands it to\n * `SliceDep.commit(cut)`. No-ops gracefully when the `slice` dep is absent.\n *\n * The cut is a straight line from drag start to the pointer by default. With\n * the binding param `cut: 'freehand'` it is the whole drag trail instead.\n */\nexport const sliceAction: Action & { requires: string[] } = {\n  id: 'slice',\n  label: 'Slice',\n  tags: pathOperationTags('click'),\n  group: 'edit',\n  eligible: { capability: 'edits-page' },\n  requires: ['slice'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const dep = ctx.deps.slice;\n      const a: Point2 = ctx.drag?.start ?? ctx.world;\n      let current: Point2 = ctx.drag?.current ?? ctx.world;\n      let trail: ReadonlyArray<Point2> | undefined;\n      let open = true;\n\n      const freehand = () => resolveParams(opts?.params)?.['cut'] === 'freehand';\n      const cut = (): Point2[] =>\n        freehand() && trail && trail.length >= 2\n          ? trail.map((p) => ({ x: p.x, y: p.y }))\n          : [a, current];\n\n      return {\n        kind: 'slice',\n        onMove(moveCtx: InvocationCtx): void {\n          current = moveCtx.drag?.current ?? moveCtx.world;\n          trail = moveCtx.drag?.points;\n        },\n        overlay(): OngoingOverlay | null {\n          if (!open) return null;\n          return { kind: 'polyline', points: cut(), role: 'cut' };\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          open = false;\n          if (reason === 'cancel' || !dep) return;\n          current = endCtx.drag?.current ?? endCtx.world;\n          trail = endCtx.drag?.points ?? trail;\n          dep.commit(cut());\n        },\n      };\n    },\n  },\n  // Slice can only act when a `slice` dep is wired (its `onEnd` no-ops\n  // otherwise), so reflect dep presence for any UI reading action-enabled\n  // state. The dispatcher still self-guards via the empty-handle path.\n  enabled: (deps) => (deps?.['slice'] ? true : ActionDisabledReason.NotApplicable),\n};\n"],"mappings":";;;;;;;;;;;;;;AAeA,IAAa,cAA+C;CAC1D,IAAI;CACJ,OAAO;CACP,MAAM,kBAAkB,OAAO;CAC/B,OAAO;CACP,UAAU,EAAE,YAAY,aAAa;CACrC,UAAU,CAAC,OAAO;CAClB,SAAS;EACP,QAAQ;EACR,MAAM,KAAoB,MAAmC;GAC3D,MAAM,MAAM,IAAI,KAAK;GACrB,MAAM,IAAY,IAAI,MAAM,SAAS,IAAI;GACzC,IAAI,UAAkB,IAAI,MAAM,WAAW,IAAI;GAC/C,IAAI;GACJ,IAAI,OAAO;GAEX,MAAM,iBAAiB,cAAc,MAAM,MAAM,CAAC,GAAG,WAAW;GAChE,MAAM,YACJ,SAAS,KAAK,SAAS,MAAM,UAAU,IACnC,MAAM,KAAK,OAAO;IAAE,GAAG,EAAE;IAAG,GAAG,EAAE;GAAE,EAAE,IACrC,CAAC,GAAG,OAAO;GAEjB,OAAO;IACL,MAAM;IACN,OAAO,SAA8B;KACnC,UAAU,QAAQ,MAAM,WAAW,QAAQ;KAC3C,QAAQ,QAAQ,MAAM;IACxB;IACA,UAAiC;KAC/B,IAAI,CAAC,MAAM,OAAO;KAClB,OAAO;MAAE,MAAM;MAAY,QAAQ,IAAI;MAAG,MAAM;KAAM;IACxD;IACA,MAAM,QAAuB,QAAmC;KAC9D,OAAO;KACP,IAAI,WAAW,YAAY,CAAC,KAAK;KACjC,UAAU,OAAO,MAAM,WAAW,OAAO;KACzC,QAAQ,OAAO,MAAM,UAAU;KAC/B,IAAI,OAAO,IAAI,CAAC;IAClB;GACF;EACF;CACF;CAIA,UAAU,SAAU,OAAO,WAAW,OAAO,qBAAqB;AACpE"}

package/dist/interactions/actions/defaults/sliceOps.js

@@ -1,58 +1,79 @@
-import { createDeleteOp as e } from "../../../core/ops/delete.js";
-import { createInsertOp as t } from "../../../core/ops/create.js";
-import { boundsOfPath as n, hasOpenSubpath as r } from "@weasel-js/geom";
-import { snipPathByPolyline as i, splitPathByPolyline as a } from "@weasel-js/geom/booleans";
+import { createDeleteOp } from "../../../core/ops/delete.js";
+import { createInsertOp } from "../../../core/ops/create.js";
+import { boundsOfPath, hasOpenSubpath } from "@weasel-js/geom";
+import { snipPathByPolyline, splitPathByPolyline } from "@weasel-js/geom/booleans";
+
 //#region src/interactions/actions/defaults/sliceOps.ts
-function o(o) {
-	let { cut: c, nextId: l, selection: u } = o, d = o.placePiece ?? ((e, t) => ({
-		pose: s(e.node.pose, n(t)),
-		path: t
-	})), f = [], p = new Set(u ?? []), m = /* @__PURE__ */ new Set(), h = [], g = o.leaves.map((e, t) => ({
-		leaf: e,
-		i: t
-	})).sort((e, t) => t.leaf.index - e.leaf.index || e.i - t.i);
-	for (let { leaf: n } of g) {
-		let o = r(n.worldPath) ? i(n.worldPath, c) : a(n.worldPath, c);
-		if (!o) continue;
-		let s = n.node.id;
-		m.add(s), f.push(e({
-			node: n.node,
-			index: n.index,
+/**
+* Cut `leaves` along `cut` and return the ops that swap each crossed leaf for
+* its pieces.
+*
+* A path with an open subpath is snipped along its stroke
+* (`snipPathByPolyline`); a closed one is knifed into closed pieces
+* (`splitPathByPolyline`), which is also where a closed loop cuts out the
+* region it encloses. Each piece copies its source's node with the piece as
+* `data.path` and a fresh id. Leaves the cut misses produce nothing.
+*/
+function computeSliceOps(args) {
+	const { cut, nextId, selection } = args;
+	const placePiece = args.placePiece ?? ((leaf, piece) => ({
+		pose: piecePose(leaf.node.pose, boundsOfPath(piece)),
+		path: piece
+	}));
+	const ops = [];
+	const selected = new Set(selection ?? []);
+	const cutIds = /* @__PURE__ */ new Set();
+	const inherited = [];
+	const ordered = args.leaves.map((leaf, i) => ({
+		leaf,
+		i
+	})).sort((a, b) => b.leaf.index - a.leaf.index || a.i - b.i);
+	for (const { leaf } of ordered) {
+		const pieces = hasOpenSubpath(leaf.worldPath) ? snipPathByPolyline(leaf.worldPath, cut) : splitPathByPolyline(leaf.worldPath, cut);
+		if (!pieces) continue;
+		const sourceId = leaf.node.id;
+		cutIds.add(sourceId);
+		ops.push(createDeleteOp({
+			node: leaf.node,
+			index: leaf.index,
 			label: "Slice"
 		}));
-		for (let e of o) {
-			let r = d(n, e), i = {
-				...n.node,
-				id: l(),
-				pose: r.pose,
+		for (const piece of pieces) {
+			const stored = placePiece(leaf, piece);
+			const node = {
+				...leaf.node,
+				id: nextId(),
+				pose: stored.pose,
 				data: {
-					...n.node.data,
-					path: r.path
+					...leaf.node.data,
+					path: stored.path
 				}
 			};
-			f.push(t({
-				node: i,
-				index: n.index,
+			ops.push(createInsertOp({
+				node,
+				index: leaf.index,
 				label: "Slice"
-			})), p.has(s) && h.push(i.id);
+			}));
+			if (selected.has(sourceId)) inherited.push(node.id);
 		}
 	}
 	return {
-		ops: f,
-		nextSelection: u && m.size > 0 ? [...u.filter((e) => !m.has(e)), ...h] : null
+		ops,
+		nextSelection: selection && cutIds.size > 0 ? [...selection.filter((id) => !cutIds.has(id)), ...inherited] : null
 	};
 }
-function s(e, t) {
-	let n = e && typeof e == "object" ? { ...e } : {};
-	return delete n.rotation, {
-		...n,
-		x: t.x,
-		y: t.y,
-		width: t.width,
-		height: t.height
+function piecePose(source, b) {
+	const rest = source && typeof source === "object" ? { ...source } : {};
+	delete rest["rotation"];
+	return {
+		...rest,
+		x: b.x,
+		y: b.y,
+		width: b.width,
+		height: b.height
 	};
 }
-//#endregion
-export { o as computeSliceOps };
 
+//#endregion
+export { computeSliceOps };
 //# sourceMappingURL=sliceOps.js.map

package/dist/interactions/actions/defaults/sliceOps.js.map

@@ -1 +1 @@
-{"version":3,"file":"sliceOps.js","names":["computeSliceOps","args","placePiece","piecePose","leaf","boundsOfPath","piece","ops","selected","selection","cutIds","inherited","ordered","b","a","pieces","hasOpenSubpath","snipPathByPolyline","cut","splitPathByPolyline","sourceId","createDeleteOp","stored","node","nextId","createInsertOp","id","rest","source","\"rotation\""],"sources":["../../../../src/interactions/actions/defaults/sliceOps.ts"],"sourcesContent":["import { boundsOfPath, hasOpenSubpath, type Path } from '@weasel-js/geom';\nimport { splitPathByPolyline, snipPathByPolyline } from '@weasel-js/geom/booleans';\nimport type { Op } from 'core/ops/types';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { createInsertOp } from 'core/ops/create';\n\n/** The fields a slice reads from and writes to a node. */\nexport interface SliceableNode {\n  id: string;\n  pose: unknown;\n  data: unknown;\n}\n\n/** One scene leaf a cut is tested against. */\nexport interface SliceLeaf<TNode extends SliceableNode = SliceableNode> {\n  /** The whole node, which the delete op carries so undo restores it intact. */\n  node: TNode;\n  /** Its ordinal among its siblings: where the delete's undo puts it back,\n   *  and where its pieces go in. */\n  index: number;\n  /** Its path with every pose above it baked in: the space the cut is in. */\n  worldPath: Path;\n}\n\ninterface SliceBounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Arguments to {@link computeSliceOps}. */\nexport interface ComputeSliceOpsArgs<TNode extends SliceableNode = SliceableNode> {\n  leaves: readonly SliceLeaf<TNode>[];\n  /** The cut, a polyline in world space. A last point equal to the first\n   *  closes it into a loop. */\n  cut: ReadonlyArray<{ x: number; y: number }>;\n  /** Mints the id of each piece. */\n  nextId: () => string;\n  /** The selection before the cut. Given, the result carries the selection\n   *  after it; omitted, `nextSelection` is `null`. */\n  selection?: readonly string[];\n  /** How a piece, cut in world space, is stored on its node. By default the\n   *  pose is the source's with the piece's bounds and no rotation, and the\n   *  path is the world piece itself, so any rotation is baked into it. A\n   *  scene with rotated poses or parent frames maps the piece back into the\n   *  node's own frame here. */\n  placePiece?: (leaf: SliceLeaf<TNode>, piece: Path) => SlicePiece;\n}\n\n/** One piece as it is stored: the node's pose and its `data.path`. */\nexport interface SlicePiece {\n  pose: unknown;\n  path: Path;\n}\n\n/** Result of {@link computeSliceOps}. */\nexport interface ComputeSliceResult {\n  /** A delete per cut leaf followed by an insert per piece, as one batch. */\n  ops: Op[];\n  /**\n   * The selection after the cut: the cut sources dropped, the pieces of each\n   * selected one added, everything else kept. `null` when no selection was\n   * given or nothing was cut. It is not an op, so the caller sets it after\n   * the batch commits; undo restores the one before either way.\n   */\n  nextSelection: string[] | null;\n}\n\n/**\n * Cut `leaves` along `cut` and return the ops that swap each crossed leaf for\n * its pieces.\n *\n * A path with an open subpath is snipped along its stroke\n * (`snipPathByPolyline`); a closed one is knifed into closed pieces\n * (`splitPathByPolyline`), which is also where a closed loop cuts out the\n * region it encloses. Each piece copies its source's node with the piece as\n * `data.path` and a fresh id. Leaves the cut misses produce nothing.\n */\nexport function computeSliceOps<TNode extends SliceableNode>(\n  args: ComputeSliceOpsArgs<TNode>,\n): ComputeSliceResult {\n  const { cut, nextId, selection } = args;\n  const placePiece = args.placePiece\n    ?? ((leaf: SliceLeaf<TNode>, piece: Path): SlicePiece => ({ pose: piecePose(leaf.node.pose, boundsOfPath(piece)), path: piece }));\n  const ops: Op[] = [];\n  const selected = new Set(selection ?? []);\n  const cutIds = new Set<string>();\n  const inherited: string[] = [];\n\n  // Highest slot first: swapping a leaf changes how many siblings sit below\n  // the next one only when the next one is above it.\n  const ordered = args.leaves.map((leaf, i) => ({ leaf, i })).sort((a, b) => b.leaf.index - a.leaf.index || a.i - b.i);\n\n  for (const { leaf } of ordered) {\n    const pieces = hasOpenSubpath(leaf.worldPath)\n      ? snipPathByPolyline(leaf.worldPath, cut)\n      : splitPathByPolyline(leaf.worldPath, cut);\n    if (!pieces) continue;\n\n    const sourceId = leaf.node.id;\n    cutIds.add(sourceId);\n    ops.push(createDeleteOp({ node: leaf.node, index: leaf.index, label: 'Slice' }));\n    for (const piece of pieces) {\n      const stored = placePiece(leaf, piece);\n      const node = {\n        ...leaf.node,\n        id: nextId(),\n        pose: stored.pose,\n        data: { ...(leaf.node.data as object), path: stored.path },\n      };\n      ops.push(createInsertOp({ node, index: leaf.index, label: 'Slice' }));\n      if (selected.has(sourceId)) inherited.push(node.id);\n    }\n  }\n\n  const nextSelection = selection && cutIds.size > 0\n    ? [...selection.filter((id) => !cutIds.has(id)), ...inherited]\n    : null;\n  return { ops, nextSelection };\n}\n\nfunction piecePose(source: unknown, b: SliceBounds): SliceBounds {\n  const rest = source && typeof source === 'object' ? { ...(source as Record<string, unknown>) } : {};\n  delete rest['rotation'];\n  return { ...rest, x: b.x, y: b.y, width: b.width, height: b.height };\n}\n"],"mappings":";;;;;AA+EA,SAAgBA,EACd,GACoB;CACpB,IAAM,EAAE,QAAK,WAAQ,iBAAcC,GAC7BC,IAAaD,EAAK,gBACjB,GAAwB,OAA6B;EAAE,MAAME,EAAUC,EAAK,KAAK,MAAMC,EAAaC,CAAK,CAAC;EAAG,MAAMA;CAAM,KAC1HC,IAAY,CAAC,GACbC,IAAW,IAAI,IAAIC,KAAa,CAAC,CAAC,GAClCC,oBAAS,IAAI,IAAY,GACzBC,IAAsB,CAAC,GAIvBC,IAAUX,EAAK,OAAO,KAAK,GAAM,OAAO;EAAE;EAAM;CAAE,EAAE,CAAC,CAAC,MAAM,GAAG,MAAMY,EAAE,KAAK,QAAQC,EAAE,KAAK,SAASA,EAAE,IAAID,EAAE,CAAC;CAEnH,KAAK,IAAM,EAAE,aAAUD,GAAS;EAC9B,IAAMG,IAASC,EAAeZ,EAAK,SAAS,IACxCa,EAAmBb,EAAK,WAAWc,CAAG,IACtCC,EAAoBf,EAAK,WAAWc,CAAG;EAC3C,IAAI,CAACH,GAAQ;EAEb,IAAMK,IAAWhB,EAAK,KAAK;EAE3B,AADAM,EAAO,IAAIU,CAAQ,GACnBb,EAAI,KAAKc,EAAe;GAAE,MAAMjB,EAAK;GAAM,OAAOA,EAAK;GAAO,OAAO;EAAQ,CAAC,CAAC;EAC/E,KAAK,IAAME,KAASS,GAAQ;GAC1B,IAAMO,IAASpB,EAAWE,GAAME,CAAK,GAC/BiB,IAAO;IACX,GAAGnB,EAAK;IACR,IAAIoB,EAAO;IACX,MAAMF,EAAO;IACb,MAAM;KAAE,GAAIlB,EAAK,KAAK;KAAiB,MAAMkB,EAAO;IAAK;GAC3D;GAEA,AADAf,EAAI,KAAKkB,EAAe;IAAE;IAAM,OAAOrB,EAAK;IAAO,OAAO;GAAQ,CAAC,CAAC,GAChEI,EAAS,IAAIY,CAAQ,KAAGT,EAAU,KAAKY,EAAK,EAAE;EACpD;CACF;CAKA,OAAO;EAAE;EAAK,eAHQd,KAAaC,EAAO,OAAO,IAC7C,CAAC,GAAGD,EAAU,QAAQ,MAAO,CAACC,EAAO,IAAIgB,CAAE,CAAC,GAAG,GAAGf,CAAS,IAC3D;CACwB;AAC9B;AAEA,SAASR,EAAU,GAAiB,GAA6B;CAC/D,IAAMwB,IAAOC,KAAU,OAAOA,KAAW,WAAW,EAAE,GAAIA,EAAmC,IAAI,CAAC;CAElG,OADA,OAAOD,EAAKE,UACL;EAAE,GAAGF;EAAM,GAAGd,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;AACrE"}
+{"version":3,"file":"sliceOps.js","names":[],"sources":["../../../../src/interactions/actions/defaults/sliceOps.ts"],"sourcesContent":["import { boundsOfPath, hasOpenSubpath, type Path } from '@weasel-js/geom';\nimport { splitPathByPolyline, snipPathByPolyline } from '@weasel-js/geom/booleans';\nimport type { Op } from 'core/ops/types';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { createInsertOp } from 'core/ops/create';\n\n/** The fields a slice reads from and writes to a node. */\nexport interface SliceableNode {\n  id: string;\n  pose: unknown;\n  data: unknown;\n}\n\n/** One scene leaf a cut is tested against. */\nexport interface SliceLeaf<TNode extends SliceableNode = SliceableNode> {\n  /** The whole node, which the delete op carries so undo restores it intact. */\n  node: TNode;\n  /** Its ordinal among its siblings: where the delete's undo puts it back,\n   *  and where its pieces go in. */\n  index: number;\n  /** Its path with every pose above it baked in: the space the cut is in. */\n  worldPath: Path;\n}\n\ninterface SliceBounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Arguments to {@link computeSliceOps}. */\nexport interface ComputeSliceOpsArgs<TNode extends SliceableNode = SliceableNode> {\n  leaves: readonly SliceLeaf<TNode>[];\n  /** The cut, a polyline in world space. A last point equal to the first\n   *  closes it into a loop. */\n  cut: ReadonlyArray<{ x: number; y: number }>;\n  /** Mints the id of each piece. */\n  nextId: () => string;\n  /** The selection before the cut. Given, the result carries the selection\n   *  after it; omitted, `nextSelection` is `null`. */\n  selection?: readonly string[];\n  /** How a piece, cut in world space, is stored on its node. By default the\n   *  pose is the source's with the piece's bounds and no rotation, and the\n   *  path is the world piece itself, so any rotation is baked into it. A\n   *  scene with rotated poses or parent frames maps the piece back into the\n   *  node's own frame here. */\n  placePiece?: (leaf: SliceLeaf<TNode>, piece: Path) => SlicePiece;\n}\n\n/** One piece as it is stored: the node's pose and its `data.path`. */\nexport interface SlicePiece {\n  pose: unknown;\n  path: Path;\n}\n\n/** Result of {@link computeSliceOps}. */\nexport interface ComputeSliceResult {\n  /** A delete per cut leaf followed by an insert per piece, as one batch. */\n  ops: Op[];\n  /**\n   * The selection after the cut: the cut sources dropped, the pieces of each\n   * selected one added, everything else kept. `null` when no selection was\n   * given or nothing was cut. It is not an op, so the caller sets it after\n   * the batch commits; undo restores the one before either way.\n   */\n  nextSelection: string[] | null;\n}\n\n/**\n * Cut `leaves` along `cut` and return the ops that swap each crossed leaf for\n * its pieces.\n *\n * A path with an open subpath is snipped along its stroke\n * (`snipPathByPolyline`); a closed one is knifed into closed pieces\n * (`splitPathByPolyline`), which is also where a closed loop cuts out the\n * region it encloses. Each piece copies its source's node with the piece as\n * `data.path` and a fresh id. Leaves the cut misses produce nothing.\n */\nexport function computeSliceOps<TNode extends SliceableNode>(\n  args: ComputeSliceOpsArgs<TNode>,\n): ComputeSliceResult {\n  const { cut, nextId, selection } = args;\n  const placePiece = args.placePiece\n    ?? ((leaf: SliceLeaf<TNode>, piece: Path): SlicePiece => ({ pose: piecePose(leaf.node.pose, boundsOfPath(piece)), path: piece }));\n  const ops: Op[] = [];\n  const selected = new Set(selection ?? []);\n  const cutIds = new Set<string>();\n  const inherited: string[] = [];\n\n  // Highest slot first: swapping a leaf changes how many siblings sit below\n  // the next one only when the next one is above it.\n  const ordered = args.leaves.map((leaf, i) => ({ leaf, i })).sort((a, b) => b.leaf.index - a.leaf.index || a.i - b.i);\n\n  for (const { leaf } of ordered) {\n    const pieces = hasOpenSubpath(leaf.worldPath)\n      ? snipPathByPolyline(leaf.worldPath, cut)\n      : splitPathByPolyline(leaf.worldPath, cut);\n    if (!pieces) continue;\n\n    const sourceId = leaf.node.id;\n    cutIds.add(sourceId);\n    ops.push(createDeleteOp({ node: leaf.node, index: leaf.index, label: 'Slice' }));\n    for (const piece of pieces) {\n      const stored = placePiece(leaf, piece);\n      const node = {\n        ...leaf.node,\n        id: nextId(),\n        pose: stored.pose,\n        data: { ...(leaf.node.data as object), path: stored.path },\n      };\n      ops.push(createInsertOp({ node, index: leaf.index, label: 'Slice' }));\n      if (selected.has(sourceId)) inherited.push(node.id);\n    }\n  }\n\n  const nextSelection = selection && cutIds.size > 0\n    ? [...selection.filter((id) => !cutIds.has(id)), ...inherited]\n    : null;\n  return { ops, nextSelection };\n}\n\nfunction piecePose(source: unknown, b: SliceBounds): SliceBounds {\n  const rest = source && typeof source === 'object' ? { ...(source as Record<string, unknown>) } : {};\n  delete rest['rotation'];\n  return { ...rest, x: b.x, y: b.y, width: b.width, height: b.height };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA+EA,SAAgB,gBACd,MACoB;CACpB,MAAM,EAAE,KAAK,QAAQ,cAAc;CACnC,MAAM,aAAa,KAAK,gBACjB,MAAwB,WAA6B;EAAE,MAAM,UAAU,KAAK,KAAK,MAAM,aAAa,KAAK,CAAC;EAAG,MAAM;CAAM;CAChI,MAAM,MAAY,CAAC;CACnB,MAAM,WAAW,IAAI,IAAI,aAAa,CAAC,CAAC;CACxC,MAAM,yBAAS,IAAI,IAAY;CAC/B,MAAM,YAAsB,CAAC;CAI7B,MAAM,UAAU,KAAK,OAAO,KAAK,MAAM,OAAO;EAAE;EAAM;CAAE,EAAE,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,IAAI,EAAE,CAAC;CAEnH,KAAK,MAAM,EAAE,UAAU,SAAS;EAC9B,MAAM,SAAS,eAAe,KAAK,SAAS,IACxC,mBAAmB,KAAK,WAAW,GAAG,IACtC,oBAAoB,KAAK,WAAW,GAAG;EAC3C,IAAI,CAAC,QAAQ;EAEb,MAAM,WAAW,KAAK,KAAK;EAC3B,OAAO,IAAI,QAAQ;EACnB,IAAI,KAAK,eAAe;GAAE,MAAM,KAAK;GAAM,OAAO,KAAK;GAAO,OAAO;EAAQ,CAAC,CAAC;EAC/E,KAAK,MAAM,SAAS,QAAQ;GAC1B,MAAM,SAAS,WAAW,MAAM,KAAK;GACrC,MAAM,OAAO;IACX,GAAG,KAAK;IACR,IAAI,OAAO;IACX,MAAM,OAAO;IACb,MAAM;KAAE,GAAI,KAAK,KAAK;KAAiB,MAAM,OAAO;IAAK;GAC3D;GACA,IAAI,KAAK,eAAe;IAAE;IAAM,OAAO,KAAK;IAAO,OAAO;GAAQ,CAAC,CAAC;GACpE,IAAI,SAAS,IAAI,QAAQ,GAAG,UAAU,KAAK,KAAK,EAAE;EACpD;CACF;CAKA,OAAO;EAAE;EAAK,eAHQ,aAAa,OAAO,OAAO,IAC7C,CAAC,GAAG,UAAU,QAAQ,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,GAAG,GAAG,SAAS,IAC3D;CACwB;AAC9B;AAEA,SAAS,UAAU,QAAiB,GAA6B;CAC/D,MAAM,OAAO,UAAU,OAAO,WAAW,WAAW,EAAE,GAAI,OAAmC,IAAI,CAAC;CAClG,OAAO,KAAK;CACZ,OAAO;EAAE,GAAG;EAAM,GAAG,EAAE;EAAG,GAAG,EAAE;EAAG,OAAO,EAAE;EAAO,QAAQ,EAAE;CAAO;AACrE"}