@weasel-js/core 1.10.1 → 1.11.0

package/dist/core/scene/lockGuard.js

@@ -1,37 +1,45 @@
+import { nodeGates } from "./nodeGates.js";
+
 //#region src/core/scene/lockGuard.ts
-function e(e) {
-	let t = 0;
-	function n(t) {
-		if (!e.layers.some((e) => e.locked)) return !1;
-		let n = e.nodes.get(t);
-		for (; n !== void 0;) {
-			if (e.layers[e.layerIndex.get(n.layer) ?? -1]?.locked) return !0;
-			n = n.parent === null ? void 0 : e.nodes.get(n.parent);
-		}
-		return !1;
-	}
+/**
+* The scene's lock guard: what a lock refuses, what the selection may hold,
+* and how a caller that is restoring an already-legal state gets past it.
+*/
+function createLockGuard(state) {
+	let bypass = 0;
+	const source = {
+		get layers() {
+			return state.layers;
+		},
+		get: (id) => state.nodes.get(id)
+	};
+	const isLocked = (id) => nodeGates(source).locked(id);
 	return {
-		isLocked: n,
-		refuse(e, r) {
-			if (!(t > 0 || !n(e))) throw Error(`Scene: cannot ${r} "${e}" — it is on a locked layer`);
+		isLocked,
+		isHidden: (id) => nodeGates(source).hidden(id),
+		refuse(id, verb) {
+			if (bypass > 0 || !isLocked(id)) return;
+			throw new Error(`Scene: cannot ${verb} "${id}" — it is locked`);
 		},
-		refuseLayer(n, r) {
-			if (!(t > 0 || !e.layers[e.layerIndex.get(n) ?? -1]?.locked)) throw Error(`Scene: cannot ${r} layer "${n}" — it is locked`);
+		refuseLayer(layer, verb) {
+			if (bypass > 0 || !state.layers[state.layerIndex.get(layer) ?? -1]?.locked) return;
+			throw new Error(`Scene: cannot ${verb} layer "${layer}" — it is locked`);
 		},
-		reachable(t) {
-			return e.layers.some((e) => e.locked) ? t.filter((e) => !n(e)) : t;
+		reachable(ids) {
+			const gates = nodeGates(source);
+			return ids.some((id) => gates.locked(id) || gates.hidden(id)) ? ids.filter((id) => !gates.locked(id) && !gates.hidden(id)) : ids;
 		},
-		lifted(e) {
-			t++;
+		lifted(fn) {
+			bypass++;
 			try {
-				return e();
+				return fn();
 			} finally {
-				t--;
+				bypass--;
 			}
 		}
 	};
 }
-//#endregion
-export { e as createLockGuard };
 
+//#endregion
+export { createLockGuard };
 //# sourceMappingURL=lockGuard.js.map

package/dist/core/scene/lockGuard.js.map

@@ -1 +1 @@
-{"version":3,"file":"lockGuard.js","names":["createLockGuard","bypass","isLocked","state","l","cur","id","verb","layer","ids","fn"],"sources":["../../../src/core/scene/lockGuard.ts"],"sourcesContent":["/**\n * The scene's lock guard: what a locked layer refuses, and how a caller that\n * is restoring an already-legal state gets past it.\n */\nimport type { Node, NodeId } from './types';\n\n/** What the guard reads of a scene's state. */\nexport interface LockGuardState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  layers: { locked: boolean }[];\n  layerIndex: Map<TLayer, number>;\n}\n\nexport interface LockGuard<TLayer extends string> {\n  /** Whether `id` sits on a locked layer, or inside a node that does. */\n  isLocked(id: NodeId): boolean;\n  /** Throw when `id` is locked and the guard is not lifted. */\n  refuse(id: NodeId, verb: string): void;\n  /** Throw when `layer` is locked and the guard is not lifted. */\n  refuseLayer(layer: TLayer, verb: string): void;\n  /** `ids` less the locked ones: the scene's selection never holds a locked\n   *  node, whoever writes it. */\n  reachable(ids: readonly NodeId[]): readonly NodeId[];\n  /** Run `fn` with the guard lifted: `unlocked()`, `removeLayer`, and every\n   *  replay — undo, redo, a journal stepping, a rollback — which restores a\n   *  state that was legal when it was recorded. */\n  lifted<T>(fn: () => T): T;\n}\n\nexport function createLockGuard<TData, TLayer extends string, TPose>(\n  state: LockGuardState<TData, TLayer, TPose>,\n): LockGuard<TLayer> {\n  let bypass = 0;\n\n  function isLocked(id: NodeId): boolean {\n    if (!state.layers.some((l) => l.locked)) return false;\n    let cur = state.nodes.get(id);\n    while (cur !== undefined) {\n      if (state.layers[state.layerIndex.get(cur.layer) ?? -1]?.locked) return true;\n      cur = cur.parent === null ? undefined : state.nodes.get(cur.parent);\n    }\n    return false;\n  }\n\n  return {\n    isLocked,\n    refuse(id, verb) {\n      if (bypass > 0 || !isLocked(id)) return;\n      throw new Error(`Scene: cannot ${verb} \"${id}\" — it is on a locked layer`);\n    },\n    refuseLayer(layer, verb) {\n      if (bypass > 0 || !state.layers[state.layerIndex.get(layer) ?? -1]?.locked) return;\n      throw new Error(`Scene: cannot ${verb} layer \"${layer}\" — it is locked`);\n    },\n    reachable(ids) {\n      if (!state.layers.some((l) => l.locked)) return ids;\n      return ids.filter((id) => !isLocked(id));\n    },\n    lifted(fn) {\n      bypass++;\n      try {\n        return fn();\n      } finally {\n        bypass--;\n      }\n    },\n  };\n}\n"],"mappings":";AA6BA,SAAgBA,EACd,GACmB;CACnB,IAAIC,IAAS;CAEb,SAASC,EAAS,GAAqB;EACrC,IAAI,CAACC,EAAM,OAAO,MAAM,MAAMC,EAAE,MAAM,GAAG,OAAO;EAChD,IAAIC,IAAMF,EAAM,MAAM,IAAIG,CAAE;EAC5B,OAAOD,MAAQ,KAAA,IAAW;GACxB,IAAIF,EAAM,OAAOA,EAAM,WAAW,IAAIE,EAAI,KAAK,KAAK,GAAG,EAAE,QAAQ,OAAO;GACxE,IAAMA,EAAI,WAAW,OAAO,KAAA,IAAYF,EAAM,MAAM,IAAIE,EAAI,MAAM;EACpE;EACA,OAAO;CACT;CAEA,OAAO;EACL;EACA,OAAO,GAAI,GAAM;GACf,IAAI,MAAS,KAAK,CAACH,EAASI,CAAE,IAC9B,MAAU,MAAM,iBAAiBC,EAAK,IAAID,EAAG,4BAA4B;EAC3E;EACA,YAAY,GAAO,GAAM;GACvB,IAAI,MAAS,KAAK,CAACH,EAAM,OAAOA,EAAM,WAAW,IAAIK,CAAK,KAAK,GAAG,EAAE,SACpE,MAAU,MAAM,iBAAiBD,EAAK,UAAUC,EAAM,iBAAiB;EACzE;EACA,UAAU,GAAK;GAEb,OADKL,EAAM,OAAO,MAAM,MAAMC,EAAE,MAAM,IAC/BK,EAAI,QAAQ,MAAO,CAACP,EAASI,CAAE,CAAC,IADSG;EAElD;EACA,OAAO,GAAI;GACT;GACA,IAAI;IACF,OAAOC,EAAG;GACZ,UAAU;IACR;GACF;EACF;CACF;AACF"}
+{"version":3,"file":"lockGuard.js","names":[],"sources":["../../../src/core/scene/lockGuard.ts"],"sourcesContent":["/**\n * The scene's lock guard: what a lock refuses, what the selection may hold,\n * and how a caller that is restoring an already-legal state gets past it.\n */\nimport { nodeGates } from './nodeGates';\nimport type { Node, NodeId } from './types';\n\n/** What the guard reads of a scene's state. */\nexport interface LockGuardState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  layers: { id: string; visible: boolean; locked: boolean }[];\n  layerIndex: Map<TLayer, number>;\n}\n\nexport interface LockGuard<TLayer extends string> {\n  /** See `Scene.isLocked`. */\n  isLocked(id: NodeId): boolean;\n  /** See `Scene.isHidden`. */\n  isHidden(id: NodeId): boolean;\n  /** Throw when `id` is locked and the guard is not lifted. */\n  refuse(id: NodeId, verb: string): void;\n  /** Throw when `layer` is locked and the guard is not lifted. */\n  refuseLayer(layer: TLayer, verb: string): void;\n  /** `ids` less the locked and hidden ones: the scene's selection never\n   *  holds either, whoever writes it. */\n  reachable(ids: readonly NodeId[]): readonly NodeId[];\n  /** Run `fn` with the guard lifted: `unlocked()`, `removeLayer`, and every\n   *  replay — undo, redo, a journal stepping, a rollback — which restores a\n   *  state that was legal when it was recorded. */\n  lifted<T>(fn: () => T): T;\n}\n\nexport function createLockGuard<TData, TLayer extends string, TPose>(\n  state: LockGuardState<TData, TLayer, TPose>,\n): LockGuard<TLayer> {\n  let bypass = 0;\n\n  const source = { get layers() { return state.layers; }, get: (id: NodeId) => state.nodes.get(id) };\n  const isLocked = (id: NodeId): boolean => nodeGates(source).locked(id);\n\n  return {\n    isLocked,\n    isHidden: (id) => nodeGates(source).hidden(id),\n    refuse(id, verb) {\n      if (bypass > 0 || !isLocked(id)) return;\n      throw new Error(`Scene: cannot ${verb} \"${id}\" — it is locked`);\n    },\n    refuseLayer(layer, verb) {\n      if (bypass > 0 || !state.layers[state.layerIndex.get(layer) ?? -1]?.locked) return;\n      throw new Error(`Scene: cannot ${verb} layer \"${layer}\" — it is locked`);\n    },\n    reachable(ids) {\n      const gates = nodeGates(source);\n      return ids.some((id) => gates.locked(id) || gates.hidden(id))\n        ? ids.filter((id) => !gates.locked(id) && !gates.hidden(id))\n        : ids;\n    },\n    lifted(fn) {\n      bypass++;\n      try {\n        return fn();\n      } finally {\n        bypass--;\n      }\n    },\n  };\n}\n"],"mappings":";;;;;;;AAgCA,SAAgB,gBACd,OACmB;CACnB,IAAI,SAAS;CAEb,MAAM,SAAS;EAAE,IAAI,SAAS;GAAE,OAAO,MAAM;EAAQ;EAAG,MAAM,OAAe,MAAM,MAAM,IAAI,EAAE;CAAE;CACjG,MAAM,YAAY,OAAwB,UAAU,MAAM,CAAC,CAAC,OAAO,EAAE;CAErE,OAAO;EACL;EACA,WAAW,OAAO,UAAU,MAAM,CAAC,CAAC,OAAO,EAAE;EAC7C,OAAO,IAAI,MAAM;GACf,IAAI,SAAS,KAAK,CAAC,SAAS,EAAE,GAAG;GACjC,MAAM,IAAI,MAAM,iBAAiB,KAAK,IAAI,GAAG,iBAAiB;EAChE;EACA,YAAY,OAAO,MAAM;GACvB,IAAI,SAAS,KAAK,CAAC,MAAM,OAAO,MAAM,WAAW,IAAI,KAAK,KAAK,GAAG,EAAE,QAAQ;GAC5E,MAAM,IAAI,MAAM,iBAAiB,KAAK,UAAU,MAAM,iBAAiB;EACzE;EACA,UAAU,KAAK;GACb,MAAM,QAAQ,UAAU,MAAM;GAC9B,OAAO,IAAI,MAAM,OAAO,MAAM,OAAO,EAAE,KAAK,MAAM,OAAO,EAAE,CAAC,IACxD,IAAI,QAAQ,OAAO,CAAC,MAAM,OAAO,EAAE,KAAK,CAAC,MAAM,OAAO,EAAE,CAAC,IACzD;EACN;EACA,OAAO,IAAI;GACT;GACA,IAAI;IACF,OAAO,GAAG;GACZ,UAAU;IACR;GACF;EACF;CACF;AACF"}

package/dist/core/scene/minSize.js

@@ -0,0 +1,17 @@
+//#region src/core/scene/minSize.ts
+/** A node's minimum, from `data.minSize`, or `null` when it has none. A
+*  side that is not a positive number holds nothing. */
+function minSizeOf(data) {
+	const m = data?.minSize;
+	if (!m) return null;
+	const width = typeof m.width === "number" && m.width > 0 ? m.width : 0;
+	const height = typeof m.height === "number" && m.height > 0 ? m.height : 0;
+	return width > 0 || height > 0 ? {
+		width,
+		height
+	} : null;
+}
+
+//#endregion
+export { minSizeOf };
+//# sourceMappingURL=minSize.js.map

package/dist/core/scene/minSize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minSize.js","names":[],"sources":["../../../src/core/scene/minSize.ts"],"sourcesContent":["/** The smallest box a node may be drawn or resized to, in world units. */\nexport interface MinSize {\n  width: number;\n  height: number;\n}\n\n/** A node's minimum, from `data.minSize`, or `null` when it has none. A\n *  side that is not a positive number holds nothing. */\nexport function minSizeOf(data: unknown): MinSize | null {\n  const m = (data as { minSize?: Partial<MinSize> } | null | undefined)?.minSize;\n  if (!m) return null;\n  const width = typeof m.width === 'number' && m.width > 0 ? m.width : 0;\n  const height = typeof m.height === 'number' && m.height > 0 ? m.height : 0;\n  return width > 0 || height > 0 ? { width, height } : null;\n}\n"],"mappings":";;;AAQA,SAAgB,UAAU,MAA+B;CACvD,MAAM,IAAK,MAA4D;CACvE,IAAI,CAAC,GAAG,OAAO;CACf,MAAM,QAAQ,OAAO,EAAE,UAAU,YAAY,EAAE,QAAQ,IAAI,EAAE,QAAQ;CACrE,MAAM,SAAS,OAAO,EAAE,WAAW,YAAY,EAAE,SAAS,IAAI,EAAE,SAAS;CACzE,OAAO,QAAQ,KAAK,SAAS,IAAI;EAAE;EAAO;CAAO,IAAI;AACvD"}

package/dist/core/scene/nestedHit.js

@@ -1,40 +1,54 @@
-import { worldPoseLookup as e } from "./composePose.js";
-import { poseDescriptorForNode as t } from "../geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as n } from "../geometry/autoPoseDescriptor.js";
+import { worldPoseLookup } from "./composePose.js";
+import { poseDescriptorForNode } from "../geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR } from "../geometry/autoPoseDescriptor.js";
+
 //#region src/core/scene/nestedHit.ts
-function r(r, i) {
-	let a = i.poseDescriptor ?? n, o = i.isGroup ?? (() => !1), s = e(r, i.composePose), c = (e) => {
-		let t = [], n = e;
-		for (; n !== null;) t.unshift(n), n = r.getParent(n);
-		return t;
-	}, l = (e, n) => {
-		let i = r.getNodes();
-		for (let r = i.length - 1; r >= 0; r--) {
-			let c = i[r];
-			if (o(c.id, c)) continue;
-			let l = s(c.id);
-			if (!l) continue;
-			let u = t(a, c).getBounds(l);
-			if (e >= u.x && e <= u.x + u.width && n >= u.y && n <= u.y + u.height) return c.id;
+/** Build hit-testers that respect containers: a plain click selects the
+*  top-level ancestor, and alt-clicking descends one level at a time toward
+*  the leaf actually under the pointer. */
+function nestedHitTester(adapter, opts) {
+	const d = opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
+	const isGroup = opts.isGroup ?? (() => false);
+	const worldOf = worldPoseLookup(adapter, opts.composePose);
+	const ancestorChain = (id) => {
+		const chain = [];
+		let cur = id;
+		while (cur !== null) {
+			chain.unshift(cur);
+			cur = adapter.getParent(cur);
+		}
+		return chain;
+	};
+	const hitLeaf = (wx, wy) => {
+		const objs = adapter.getNodes();
+		for (let i = objs.length - 1; i >= 0; i--) {
+			const o = objs[i];
+			if (isGroup(o.id, o)) continue;
+			const w = worldOf(o.id);
+			if (!w) continue;
+			const b = poseDescriptorForNode(d, o).getBounds(w);
+			if (wx >= b.x && wx <= b.x + b.width && wy >= b.y && wy <= b.y + b.height) return o.id;
 		}
 		return null;
 	};
+	const pickOutermost = (wx, wy) => {
+		const leaf = hitLeaf(wx, wy);
+		return leaf === null ? null : ancestorChain(leaf)[0];
+	};
+	const pickBest = (wx, wy, alt, selection) => {
+		const leaf = hitLeaf(wx, wy);
+		if (leaf === null) return null;
+		const chain = ancestorChain(leaf);
+		if (!alt) return chain[0];
+		for (let i = chain.length - 1; i >= 0; i--) if (selection.includes(chain[i])) return chain[Math.min(i + 1, chain.length - 1)];
+		return chain[chain.length - 1];
+	};
 	return {
-		pickOutermost: (e, t) => {
-			let n = l(e, t);
-			return n === null ? null : c(n)[0];
-		},
-		pickBest: (e, t, n, r) => {
-			let i = l(e, t);
-			if (i === null) return null;
-			let a = c(i);
-			if (!n) return a[0];
-			for (let e = a.length - 1; e >= 0; e--) if (r.includes(a[e])) return a[Math.min(e + 1, a.length - 1)];
-			return a[a.length - 1];
-		}
+		pickOutermost,
+		pickBest
 	};
 }
-//#endregion
-export { r as nestedHitTester };
 
+//#endregion
+export { nestedHitTester };
 //# sourceMappingURL=nestedHit.js.map

package/dist/core/scene/nestedHit.js.map

@@ -1 +1 @@
-{"version":3,"file":"nestedHit.js","names":["nestedHitTester","d","opts","AUTO_POSE_DESCRIPTOR","isGroup","worldOf","worldPoseLookup","adapter","ancestorChain","chain","cur","id","hitLeaf","objs","i","o","w","b","poseDescriptorForNode","wx","wy","leaf","alt","selection"],"sources":["../../../src/core/scene/nestedHit.ts"],"sourcesContent":["import { worldPoseLookup } from 'core/scene/composePose';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\n\n/** @internal */\ninterface HitAdapter<TNode extends { id: string }, TPose> {\n  getNode: (id: string) => TNode | undefined;\n  getNodes: () => TNode[];\n  getPose: (id: string) => TPose;\n  getParent: (id: string) => string | null;\n}\n\n/** Options for `nestedHitTester`. */\nexport interface NestedHitOpts<TNode extends { id: string }, TPose> {\n  /** Compose a child's local pose into world coords given its parent's world\n   *  pose. Same shape as `composeRectPose` (the default expectation). */\n  composePose: (parent: TPose, child: TPose) => TPose;\n  /** How to read world poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** Predicate for \"this object is a nesting parent body\". The leaf scan\n   *  skips objects for which this returns true so a click on a parent's\n   *  painted body resolves to a child leaf, not the parent itself. Default:\n   *  never (treat every object as hittable). */\n  isGroup?: (id: string, obj: TNode | undefined) => boolean;\n}\n\n/** Hit-test entry points for a nested scene: one that always picks the\n *  outermost ancestor, and one that steps deeper on alt-click. */\nexport interface NestedHitTester {\n  /** Outermost-ancestor pick. Suitable as the chrome-level `pickEvery`: a\n   *  casual click selects the whole top-level ancestor. Returns `null` on\n   *  empty space. */\n  pickOutermost: (worldX: number, worldY: number) => string | null;\n  /** Alt-aware selection-update pick. Without `alt`, returns the outermost\n   *  ancestor (same as `pickOutermost`). With `alt`, returns one level\n   *  deeper than the deepest currently-selected ancestor in the leaf's\n   *  chain — repeated alt-clicks step ancestor → descendant → leaf. With\n   *  `alt` and nothing in the chain selected, jumps straight to the leaf.\n   *  Plug into `useSelectTool({ pickBest })`. */\n  pickBest: (\n    worldX: number,\n    worldY: number,\n    alt: boolean,\n    selection: readonly string[],\n  ) => string | null;\n}\n\n/** Build hit-testers that respect containers: a plain click selects the\n *  top-level ancestor, and alt-clicking descends one level at a time toward\n *  the leaf actually under the pointer. */\nexport function nestedHitTester<TNode extends { id: string }, TPose>(\n  adapter: HitAdapter<TNode, TPose>,\n  opts: NestedHitOpts<TNode, TPose>,\n): NestedHitTester {\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const isGroup = opts.isGroup ?? (() => false);\n  const worldOf = worldPoseLookup(adapter, opts.composePose);\n\n  const ancestorChain = (id: string): string[] => {\n    const chain: string[] = [];\n    let cur: string | null = id;\n    while (cur !== null) {\n      chain.unshift(cur);\n      cur = adapter.getParent(cur);\n    }\n    return chain;\n  };\n\n  const hitLeaf = (wx: number, wy: number): string | null => {\n    const objs = adapter.getNodes();\n    for (let i = objs.length - 1; i >= 0; i--) {\n      const o = objs[i];\n      if (isGroup(o.id, o)) continue;\n      const w = worldOf(o.id);\n      if (!w) continue;\n      const b = poseDescriptorForNode(d, o).getBounds(w);\n      if (wx >= b.x && wx <= b.x + b.width && wy >= b.y && wy <= b.y + b.height) {\n        return o.id;\n      }\n    }\n    return null;\n  };\n\n  const pickOutermost = (wx: number, wy: number): string | null => {\n    const leaf = hitLeaf(wx, wy);\n    return leaf === null ? null : ancestorChain(leaf)[0];\n  };\n\n  const pickBest = (\n    wx: number,\n    wy: number,\n    alt: boolean,\n    selection: readonly string[],\n  ): string | null => {\n    const leaf = hitLeaf(wx, wy);\n    if (leaf === null) return null;\n    const chain = ancestorChain(leaf);\n    if (!alt) return chain[0];\n    for (let i = chain.length - 1; i >= 0; i--) {\n      if (selection.includes(chain[i])) {\n        return chain[Math.min(i + 1, chain.length - 1)];\n      }\n    }\n    return chain[chain.length - 1];\n  };\n\n  return { pickOutermost, pickBest };\n}\n"],"mappings":";;;;AAkDA,SAAgBA,EACd,GACA,GACiB;CACjB,IAAMC,IAAKC,EAAK,kBAAkBC,GAC5BC,IAAUF,EAAK,kBAAkB,KACjCG,IAAUC,EAAgBC,GAASL,EAAK,WAAW,GAEnDM,KAAiB,MAAyB;EAC9C,IAAMC,IAAkB,CAAC,GACrBC,IAAqBC;EACzB,OAAOD,MAAQ,OAEb,AADAD,EAAM,QAAQC,CAAG,GACjB,IAAMH,EAAQ,UAAUG,CAAG;EAE7B,OAAOD;CACT,GAEMG,KAAW,GAAY,MAA8B;EACzD,IAAMC,IAAON,EAAQ,SAAS;EAC9B,KAAK,IAAIO,IAAID,EAAK,SAAS,GAAGC,KAAK,GAAG,KAAK;GACzC,IAAMC,IAAIF,EAAKC;GACf,IAAIV,EAAQW,EAAE,IAAIA,CAAC,GAAG;GACtB,IAAMC,IAAIX,EAAQU,EAAE,EAAE;GACtB,IAAI,CAACC,GAAG;GACR,IAAMC,IAAIC,EAAsBjB,GAAGc,CAAC,CAAC,CAAC,UAAUC,CAAC;GACjD,IAAIG,KAAMF,EAAE,KAAKE,KAAMF,EAAE,IAAIA,EAAE,SAASG,KAAMH,EAAE,KAAKG,KAAMH,EAAE,IAAIA,EAAE,QACjE,OAAOF,EAAE;EAEb;EACA,OAAO;CACT;CAyBA,OAAO;EAAE,gBAvBc,GAAY,MAA8B;GAC/D,IAAMM,IAAOT,EAAQO,GAAIC,CAAE;GAC3B,OAAOC,MAAS,OAAO,OAAOb,EAAca,CAAI,CAAC,CAAC;EACpD;EAoBwB,WAjBtB,GACA,GACA,GACA,MACkB;GAClB,IAAMA,IAAOT,EAAQO,GAAIC,CAAE;GAC3B,IAAIC,MAAS,MAAM,OAAO;GAC1B,IAAMZ,IAAQD,EAAca,CAAI;GAChC,IAAI,CAACC,GAAK,OAAOb,EAAM;GACvB,KAAK,IAAIK,IAAIL,EAAM,SAAS,GAAGK,KAAK,GAAG,KACrC,IAAIS,EAAU,SAASd,EAAMK,EAAE,GAC7B,OAAOL,EAAM,KAAK,IAAIK,IAAI,GAAGL,EAAM,SAAS,CAAC;GAGjD,OAAOA,EAAMA,EAAM,SAAS;EAC9B;CAEiC;AACnC"}
+{"version":3,"file":"nestedHit.js","names":[],"sources":["../../../src/core/scene/nestedHit.ts"],"sourcesContent":["import { worldPoseLookup } from 'core/scene/composePose';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\n\n/** @internal */\ninterface HitAdapter<TNode extends { id: string }, TPose> {\n  getNode: (id: string) => TNode | undefined;\n  getNodes: () => TNode[];\n  getPose: (id: string) => TPose;\n  getParent: (id: string) => string | null;\n}\n\n/** Options for `nestedHitTester`. */\nexport interface NestedHitOpts<TNode extends { id: string }, TPose> {\n  /** Compose a child's local pose into world coords given its parent's world\n   *  pose. Same shape as `composeRectPose` (the default expectation). */\n  composePose: (parent: TPose, child: TPose) => TPose;\n  /** How to read world poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** Predicate for \"this object is a nesting parent body\". The leaf scan\n   *  skips objects for which this returns true so a click on a parent's\n   *  painted body resolves to a child leaf, not the parent itself. Default:\n   *  never (treat every object as hittable). */\n  isGroup?: (id: string, obj: TNode | undefined) => boolean;\n}\n\n/** Hit-test entry points for a nested scene: one that always picks the\n *  outermost ancestor, and one that steps deeper on alt-click. */\nexport interface NestedHitTester {\n  /** Outermost-ancestor pick. Suitable as the chrome-level `pickEvery`: a\n   *  casual click selects the whole top-level ancestor. Returns `null` on\n   *  empty space. */\n  pickOutermost: (worldX: number, worldY: number) => string | null;\n  /** Alt-aware selection-update pick. Without `alt`, returns the outermost\n   *  ancestor (same as `pickOutermost`). With `alt`, returns one level\n   *  deeper than the deepest currently-selected ancestor in the leaf's\n   *  chain — repeated alt-clicks step ancestor → descendant → leaf. With\n   *  `alt` and nothing in the chain selected, jumps straight to the leaf.\n   *  Plug into `useSelectTool({ pickBest })`. */\n  pickBest: (\n    worldX: number,\n    worldY: number,\n    alt: boolean,\n    selection: readonly string[],\n  ) => string | null;\n}\n\n/** Build hit-testers that respect containers: a plain click selects the\n *  top-level ancestor, and alt-clicking descends one level at a time toward\n *  the leaf actually under the pointer. */\nexport function nestedHitTester<TNode extends { id: string }, TPose>(\n  adapter: HitAdapter<TNode, TPose>,\n  opts: NestedHitOpts<TNode, TPose>,\n): NestedHitTester {\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const isGroup = opts.isGroup ?? (() => false);\n  const worldOf = worldPoseLookup(adapter, opts.composePose);\n\n  const ancestorChain = (id: string): string[] => {\n    const chain: string[] = [];\n    let cur: string | null = id;\n    while (cur !== null) {\n      chain.unshift(cur);\n      cur = adapter.getParent(cur);\n    }\n    return chain;\n  };\n\n  const hitLeaf = (wx: number, wy: number): string | null => {\n    const objs = adapter.getNodes();\n    for (let i = objs.length - 1; i >= 0; i--) {\n      const o = objs[i];\n      if (isGroup(o.id, o)) continue;\n      const w = worldOf(o.id);\n      if (!w) continue;\n      const b = poseDescriptorForNode(d, o).getBounds(w);\n      if (wx >= b.x && wx <= b.x + b.width && wy >= b.y && wy <= b.y + b.height) {\n        return o.id;\n      }\n    }\n    return null;\n  };\n\n  const pickOutermost = (wx: number, wy: number): string | null => {\n    const leaf = hitLeaf(wx, wy);\n    return leaf === null ? null : ancestorChain(leaf)[0];\n  };\n\n  const pickBest = (\n    wx: number,\n    wy: number,\n    alt: boolean,\n    selection: readonly string[],\n  ): string | null => {\n    const leaf = hitLeaf(wx, wy);\n    if (leaf === null) return null;\n    const chain = ancestorChain(leaf);\n    if (!alt) return chain[0];\n    for (let i = chain.length - 1; i >= 0; i--) {\n      if (selection.includes(chain[i])) {\n        return chain[Math.min(i + 1, chain.length - 1)];\n      }\n    }\n    return chain[chain.length - 1];\n  };\n\n  return { pickOutermost, pickBest };\n}\n"],"mappings":";;;;;;;;AAkDA,SAAgB,gBACd,SACA,MACiB;CACjB,MAAM,IAAK,KAAK,kBAAkB;CAClC,MAAM,UAAU,KAAK,kBAAkB;CACvC,MAAM,UAAU,gBAAgB,SAAS,KAAK,WAAW;CAEzD,MAAM,iBAAiB,OAAyB;EAC9C,MAAM,QAAkB,CAAC;EACzB,IAAI,MAAqB;EACzB,OAAO,QAAQ,MAAM;GACnB,MAAM,QAAQ,GAAG;GACjB,MAAM,QAAQ,UAAU,GAAG;EAC7B;EACA,OAAO;CACT;CAEA,MAAM,WAAW,IAAY,OAA8B;EACzD,MAAM,OAAO,QAAQ,SAAS;EAC9B,KAAK,IAAI,IAAI,KAAK,SAAS,GAAG,KAAK,GAAG,KAAK;GACzC,MAAM,IAAI,KAAK;GACf,IAAI,QAAQ,EAAE,IAAI,CAAC,GAAG;GACtB,MAAM,IAAI,QAAQ,EAAE,EAAE;GACtB,IAAI,CAAC,GAAG;GACR,MAAM,IAAI,sBAAsB,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC;GACjD,IAAI,MAAM,EAAE,KAAK,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,KAAK,MAAM,EAAE,IAAI,EAAE,QACjE,OAAO,EAAE;EAEb;EACA,OAAO;CACT;CAEA,MAAM,iBAAiB,IAAY,OAA8B;EAC/D,MAAM,OAAO,QAAQ,IAAI,EAAE;EAC3B,OAAO,SAAS,OAAO,OAAO,cAAc,IAAI,CAAC,CAAC;CACpD;CAEA,MAAM,YACJ,IACA,IACA,KACA,cACkB;EAClB,MAAM,OAAO,QAAQ,IAAI,EAAE;EAC3B,IAAI,SAAS,MAAM,OAAO;EAC1B,MAAM,QAAQ,cAAc,IAAI;EAChC,IAAI,CAAC,KAAK,OAAO,MAAM;EACvB,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KACrC,IAAI,UAAU,SAAS,MAAM,EAAE,GAC7B,OAAO,MAAM,KAAK,IAAI,IAAI,GAAG,MAAM,SAAS,CAAC;EAGjD,OAAO,MAAM,MAAM,SAAS;CAC9B;CAEA,OAAO;EAAE;EAAe;CAAS;AACnC"}

package/dist/core/scene/nodeFlags.js

@@ -0,0 +1,43 @@
+//#region src/core/scene/nodeFlags.ts
+/** Stored only while set, so a snapshot of an unflagged node carries neither. */
+function write(node, flag, to) {
+	if (to) node[flag] = true;
+	else delete node[flag];
+}
+var KIND = {
+	hidden: "kit:setHidden",
+	locked: "kit:setLocked"
+};
+/** Register `kit:setHidden` and `kit:setLocked`, and answer with the scene
+*  methods that record them. Neither is refused by a lock: like a layer's,
+*  a node's lock is what lifts it. */
+function createNodeFlags(env) {
+	for (const flag of ["hidden", "locked"]) env.register(KIND[flag], {
+		apply: (p) => {
+			const { id, to } = p;
+			write(env.requireNode(id), flag, to);
+			if (to) env.narrowSelection();
+		},
+		revert: (p) => {
+			const { id, from } = p;
+			write(env.requireNode(id), flag, from);
+		}
+	});
+	const set = (flag, label) => (id, to) => {
+		const from = env.requireNode(id)[flag] === true;
+		if (from === to) return;
+		env.record(KIND[flag], {
+			id,
+			from,
+			to
+		}, label);
+	};
+	return {
+		setHidden: set("hidden", "setHidden"),
+		setLocked: set("locked", "setLocked")
+	};
+}
+
+//#endregion
+export { createNodeFlags };
+//# sourceMappingURL=nodeFlags.js.map

package/dist/core/scene/nodeFlags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeFlags.js","names":[],"sources":["../../../src/core/scene/nodeFlags.ts"],"sourcesContent":["/**\n * A node's own `hidden` and `locked` flags: the kit ops that write them, and\n * the scene methods that record those ops. What the flags mean to every\n * reader is `nodeGates`.\n */\nimport type { Node, NodeId, RegisteredOp, Scene } from './types';\n\n/** The two per-node flags. */\nexport type NodeFlag = 'hidden' | 'locked';\n\nexport interface NodeFlagsEnv<TData, TLayer extends string, TPose> {\n  register(kind: string, handler: RegisteredOp<unknown>): void;\n  requireNode(id: NodeId): Node<TData, TLayer, TPose>;\n  record(kind: string, payload: unknown, label: string): void;\n  /** Drop from the selection whatever is now hidden or locked. */\n  narrowSelection(): void;\n}\n\ninterface FlagPayload { id: NodeId; from: boolean; to: boolean }\n\n/** Stored only while set, so a snapshot of an unflagged node carries neither. */\nfunction write(node: { hidden?: boolean; locked?: boolean }, flag: NodeFlag, to: boolean): void {\n  if (to) node[flag] = true;\n  else delete node[flag];\n}\n\nconst KIND: Record<NodeFlag, string> = { hidden: 'kit:setHidden', locked: 'kit:setLocked' };\n\n/** Register `kit:setHidden` and `kit:setLocked`, and answer with the scene\n *  methods that record them. Neither is refused by a lock: like a layer's,\n *  a node's lock is what lifts it. */\nexport function createNodeFlags<TData, TLayer extends string, TPose>(\n  env: NodeFlagsEnv<TData, TLayer, TPose>,\n): Pick<Scene<TData, TLayer, TPose>, 'setHidden' | 'setLocked'> {\n  for (const flag of ['hidden', 'locked'] as const) {\n    env.register(KIND[flag], {\n      apply: (p) => {\n        const { id, to } = p as FlagPayload;\n        write(env.requireNode(id), flag, to);\n        if (to) env.narrowSelection();\n      },\n      revert: (p) => {\n        const { id, from } = p as FlagPayload;\n        write(env.requireNode(id), flag, from);\n      },\n    });\n  }\n\n  const set = (flag: NodeFlag, label: string) => (id: NodeId, to: boolean): void => {\n    const from = env.requireNode(id)[flag] === true;\n    if (from === to) return;\n    env.record(KIND[flag], { id, from, to } satisfies FlagPayload, label);\n  };\n\n  return { setHidden: set('hidden', 'setHidden'), setLocked: set('locked', 'setLocked') };\n}\n"],"mappings":";;AAqBA,SAAS,MAAM,MAA8C,MAAgB,IAAmB;CAC9F,IAAI,IAAI,KAAK,QAAQ;MAChB,OAAO,KAAK;AACnB;AAEA,IAAM,OAAiC;CAAE,QAAQ;CAAiB,QAAQ;AAAgB;;;;AAK1F,SAAgB,gBACd,KAC8D;CAC9D,KAAK,MAAM,QAAQ,CAAC,UAAU,QAAQ,GACpC,IAAI,SAAS,KAAK,OAAO;EACvB,QAAQ,MAAM;GACZ,MAAM,EAAE,IAAI,OAAO;GACnB,MAAM,IAAI,YAAY,EAAE,GAAG,MAAM,EAAE;GACnC,IAAI,IAAI,IAAI,gBAAgB;EAC9B;EACA,SAAS,MAAM;GACb,MAAM,EAAE,IAAI,SAAS;GACrB,MAAM,IAAI,YAAY,EAAE,GAAG,MAAM,IAAI;EACvC;CACF,CAAC;CAGH,MAAM,OAAO,MAAgB,WAAmB,IAAY,OAAsB;EAChF,MAAM,OAAO,IAAI,YAAY,EAAE,CAAC,CAAC,UAAU;EAC3C,IAAI,SAAS,IAAI;EACjB,IAAI,OAAO,KAAK,OAAO;GAAE;GAAI;GAAM;EAAG,GAAyB,KAAK;CACtE;CAEA,OAAO;EAAE,WAAW,IAAI,UAAU,WAAW;EAAG,WAAW,IAAI,UAAU,WAAW;CAAE;AACxF"}

package/dist/core/scene/nodeFnFields.js

@@ -1,89 +1,106 @@
 //#region src/core/scene/nodeFnFields.ts
-var e = [
+var NODE_FN_FIELDS = [
 	{
 		field: "clipFromPose",
 		opKey: "clipKey",
 		jsonKey: "clipFromPoseKey",
-		containersOnly: !0,
+		containersOnly: true,
 		lost: "clip"
 	},
 	{
 		field: "copiesFromPose",
 		opKey: "copiesKey",
 		jsonKey: "copiesFromPoseKey",
-		containersOnly: !0,
+		containersOnly: true,
 		lost: "copies"
 	},
 	{
 		field: "derivePath",
 		opKey: "derivePathKey",
 		jsonKey: "derivePathKey",
-		containersOnly: !1,
+		containersOnly: false,
 		lost: "derived path"
 	},
 	{
 		field: "derivePose",
 		opKey: "derivePoseKey",
 		jsonKey: "derivePoseKey",
-		containersOnly: !1,
+		containersOnly: false,
 		lost: "derived pose"
 	},
 	{
 		field: "layout",
 		opKey: "layoutKey",
 		jsonKey: "layoutKey",
-		containersOnly: !0,
+		containersOnly: true,
 		lost: "layout"
 	}
 ];
-function t(t, n) {
-	return e.map((e) => {
-		let r = t[e.field], i = /* @__PURE__ */ new Map();
-		if (r) for (let [e, t] of Object.entries(r)) i.set(t, e);
-		let a = (t) => !e.containersOnly || t.kind === "container";
+function createNodeFnFields(registry, onWrite) {
+	return NODE_FN_FIELDS.map((spec) => {
+		const table = registry[spec.field];
+		const reverse = /* @__PURE__ */ new Map();
+		if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);
+		const applies = (node) => !spec.containersOnly || node.kind === "container";
 		return {
-			spec: e,
-			keyOf: (e) => i.get(e),
-			fnOf: (e) => r?.[e],
-			read: (t) => a(t) ? t[e.field] : void 0,
-			write: (t, r) => {
-				a(t) && (t[e.field] = r, n?.(e.field, t));
+			spec,
+			keyOf: (fn) => reverse.get(fn),
+			fnOf: (key) => table?.[key],
+			read: (node) => applies(node) ? node[spec.field] : void 0,
+			write: (node, fn) => {
+				if (!applies(node)) return;
+				node[spec.field] = fn;
+				onWrite?.(spec.field, node);
 			}
 		};
 	});
 }
-function n(e, t, n, r, i) {
-	let a = e.fnOf(n);
-	if (a === void 0) {
-		i("scene", `${r}: ${e.spec.opKey} "${n}" not in this scene's registry — node "${t.id}" restored without its ${e.spec.lost}. Register a function with this key in the registry option to restore it.`);
+/**
+* Attach the function `key` names to `node`. Warns and leaves the field
+* unset when the key is not in this scene's registry — a snapshot outliving
+* the code that registered its functions must still load.
+*/
+function restoreFn(field, node, key, site, warn) {
+	const fn = field.fnOf(key);
+	if (fn === void 0) {
+		warn("scene", `${site}: ${field.spec.opKey} "${key}" not in this scene's registry — node "${node.id}" restored without its ${field.spec.lost}. Register a function with this key in the registry option to restore it.`);
 		return;
 	}
-	e.write(t, a);
+	field.write(node, fn);
 }
-function r(e, t, n, r) {
-	let i = {};
-	for (let a of e) {
-		let e = a.read(t);
-		if (e === void 0) continue;
-		let o = a.keyOf(e);
-		if (o === void 0) {
-			r?.(a);
+/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries
+*  for `node`. Empty when the node has no keyed function on it. */
+function fnKeysOf(fields, node, which, onUnregistered) {
+	const out = {};
+	for (const field of fields) {
+		const fn = field.read(node);
+		if (fn === void 0) continue;
+		const key = field.keyOf(fn);
+		if (key === void 0) {
+			onUnregistered?.(field);
 			continue;
 		}
-		i[a.spec[n]] = o;
+		out[field.spec[which]] = key;
 	}
-	return i;
+	return out;
 }
-function i(t) {
-	let n = t, r = {};
-	for (let i of e) {
-		if (i.containersOnly && t.kind !== "container") continue;
-		let e = n[i.field];
-		e !== void 0 && (r[i.field] = e);
+/**
+* The function fields to carry from a live node into an `AddNodeSpec`. An
+* insert that drops them brings an edge back as a static path that never
+* follows its endpoints again, and a clipped container back with nothing
+* clipped.
+*/
+function fnFieldsOfNode(node) {
+	const src = node;
+	const out = {};
+	for (const spec of NODE_FN_FIELDS) {
+		if (spec.containersOnly && node.kind !== "container") continue;
+		const fn = src[spec.field];
+		if (fn !== void 0) out[spec.field] = fn;
 	}
-	return r;
+	return out;
 }
-//#endregion
-export { e as NODE_FN_FIELDS, t as createNodeFnFields, i as fnFieldsOfNode, r as fnKeysOf, n as restoreFn };
 
+//#endregion
+export { NODE_FN_FIELDS, createNodeFnFields, fnFieldsOfNode, fnKeysOf, restoreFn };
 //# sourceMappingURL=nodeFnFields.js.map

package/dist/core/scene/nodeFnFields.js.map

@@ -1 +1 @@
-{"version":3,"file":"nodeFnFields.js","names":["NODE_FN_FIELDS","createNodeFnFields","table","registry","spec","reverse","key","fn","applies","node","onWrite","restoreFn","field","site","fnKeysOf","out","fields","which","fnFieldsOfNode","src"],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * These fields are live functions on a node, and a function travels through\n * neither a serializable op payload nor a JSON snapshot. Each one therefore\n * needs the same things: a function→key reverse map, a name in the op\n * payload, a name in the snapshot, and a registry lookup on restore.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. A container's `layout` is an object rather\n *  than a function, and rides the same table for the same reason. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the function fields on it. */\nexport type FnBearingNode = { id: NodeId; kind: 'leaf' | 'container' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'copiesFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** True for a field only a `ContainerNode` can carry. */\n  readonly containersOnly: boolean;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    containersOnly: true,\n    lost: 'clip',\n  },\n  {\n    field: 'copiesFromPose',\n    opKey: 'copiesKey',\n    jsonKey: 'copiesFromPoseKey',\n    containersOnly: true,\n    lost: 'copies',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    containersOnly: false,\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    containersOnly: false,\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    containersOnly: true,\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined` — including when the field is\n   *  container-only and `node` is a leaf. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`, ignoring a container-only field on a leaf. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n}\n\nexport function createNodeFnFields<TPose>(\n  registry: SceneRegistry<TPose>,\n  /** Called after a field is written onto a node it applies to. */\n  onWrite?: (field: NodeFnFieldName, node: FnBearingNode) => void,\n): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    const applies = (node: FnBearingNode): boolean =>\n      !spec.containersOnly || node.kind === 'container';\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => (applies(node) ? node[spec.field] : undefined),\n      write: (node, fn) => {\n        if (!applies(node)) return;\n        node[spec.field] = fn;\n        onWrite?.(spec.field, node);\n      },\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped container back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'leaf' | 'container' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && node.kind !== 'container') continue;\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AAqCA,IAAaA,IAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;AACF;AAgBA,SAAgBC,EACd,GAEA,GACwB;CACxB,OAAOD,EAAe,KAAK,MAAS;EAClC,IAAME,IAAQC,EAASC,EAAK,QACtBC,oBAAU,IAAI,IAAoB;EACxC,IAAIH,GAAO,KAAK,IAAM,CAACI,GAAKC,MAAO,OAAO,QAAQL,CAAK,GAAG,EAAQ,IAAIK,GAAID,CAAG;EAC7E,IAAME,KAAW,MACf,CAACJ,EAAK,kBAAkBK,EAAK,SAAS;EACxC,OAAO;GACL;GACA,QAAQ,MAAOJ,EAAQ,IAAIE,CAAE;GAC7B,OAAO,MAAQL,IAAQI;GACvB,OAAO,MAAUE,EAAQC,CAAI,IAAIA,EAAKL,EAAK,SAAS,KAAA;GACpD,QAAQ,GAAM,MAAO;IACnB,AAAKI,EAAQC,CAAI,MACjB,EAAKL,EAAK,SAASG,GACnBG,IAAUN,EAAK,OAAOK,CAAI;GAC5B;EACF;CACF,CAAC;AACH;AAOA,SAAgBE,EACd,GACA,GACA,GACA,GACA,GACM;CACN,IAAMJ,IAAKK,EAAM,KAAKN,CAAG;CACzB,IAAIC,MAAO,KAAA,GAAW;EACpB,EACE,SACA,GAAGM,EAAK,IAAID,EAAM,KAAK,MAAM,IAAIN,EAAI,yCAAyCG,EAAK,GAAG,yBAC5DG,EAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CACA,EAAM,MAAMH,GAAMF,CAAE;AACtB;AAIA,SAAgBO,EACd,GACA,GACA,GACA,GACwB;CACxB,IAAMC,IAA8B,CAAC;CACrC,KAAK,IAAMH,KAASI,GAAQ;EAC1B,IAAMT,IAAKK,EAAM,KAAKH,CAAI;EAC1B,IAAIF,MAAO,KAAA,GAAW;EACtB,IAAMD,IAAMM,EAAM,MAAML,CAAE;EAC1B,IAAID,MAAQ,KAAA,GAAW;GACrB,IAAiBM,CAAK;GACtB;EACF;EACA,EAAIA,EAAM,KAAKK,MAAUX;CAC3B;CACA,OAAOS;AACT;AAQA,SAAgBG,EACd,GACqD;CACrD,IAAMC,IAAMV,GACNM,IAA+B,CAAC;CACtC,KAAK,IAAMX,KAAQJ,GAAgB;EACjC,IAAII,EAAK,kBAAkBK,EAAK,SAAS,aAAa;EACtD,IAAMF,IAAKY,EAAIf,EAAK;EACpB,AAAIG,MAAO,KAAA,MAAW,EAAIH,EAAK,SAASG;CAC1C;CACA,OAAOQ;AACT"}
+{"version":3,"file":"nodeFnFields.js","names":[],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * These fields are live functions on a node, and a function travels through\n * neither a serializable op payload nor a JSON snapshot. Each one therefore\n * needs the same things: a function→key reverse map, a name in the op\n * payload, a name in the snapshot, and a registry lookup on restore.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. A container's `layout` is an object rather\n *  than a function, and rides the same table for the same reason. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the function fields on it. */\nexport type FnBearingNode = { id: NodeId; kind: 'leaf' | 'container' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'copiesFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** True for a field only a `ContainerNode` can carry. */\n  readonly containersOnly: boolean;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    containersOnly: true,\n    lost: 'clip',\n  },\n  {\n    field: 'copiesFromPose',\n    opKey: 'copiesKey',\n    jsonKey: 'copiesFromPoseKey',\n    containersOnly: true,\n    lost: 'copies',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    containersOnly: false,\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    containersOnly: false,\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    containersOnly: true,\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined` — including when the field is\n   *  container-only and `node` is a leaf. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`, ignoring a container-only field on a leaf. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n}\n\nexport function createNodeFnFields<TPose>(\n  registry: SceneRegistry<TPose>,\n  /** Called after a field is written onto a node it applies to. */\n  onWrite?: (field: NodeFnFieldName, node: FnBearingNode) => void,\n): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    const applies = (node: FnBearingNode): boolean =>\n      !spec.containersOnly || node.kind === 'container';\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => (applies(node) ? node[spec.field] : undefined),\n      write: (node, fn) => {\n        if (!applies(node)) return;\n        node[spec.field] = fn;\n        onWrite?.(spec.field, node);\n      },\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped container back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'leaf' | 'container' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && node.kind !== 'container') continue;\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AAqCA,IAAa,iBAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;AACF;AAgBA,SAAgB,mBACd,UAEA,SACwB;CACxB,OAAO,eAAe,KAAK,SAAS;EAClC,MAAM,QAAQ,SAAS,KAAK;EAC5B,MAAM,0BAAU,IAAI,IAAoB;EACxC,IAAI,OAAO,KAAK,MAAM,CAAC,KAAK,OAAO,OAAO,QAAQ,KAAK,GAAG,QAAQ,IAAI,IAAI,GAAG;EAC7E,MAAM,WAAW,SACf,CAAC,KAAK,kBAAkB,KAAK,SAAS;EACxC,OAAO;GACL;GACA,QAAQ,OAAO,QAAQ,IAAI,EAAE;GAC7B,OAAO,QAAQ,QAAQ;GACvB,OAAO,SAAU,QAAQ,IAAI,IAAI,KAAK,KAAK,SAAS;GACpD,QAAQ,MAAM,OAAO;IACnB,IAAI,CAAC,QAAQ,IAAI,GAAG;IACpB,KAAK,KAAK,SAAS;IACnB,UAAU,KAAK,OAAO,IAAI;GAC5B;EACF;CACF,CAAC;AACH;;;;;;AAOA,SAAgB,UACd,OACA,MACA,KACA,MACA,MACM;CACN,MAAM,KAAK,MAAM,KAAK,GAAG;CACzB,IAAI,OAAO,QAAW;EACpB,KACE,SACA,GAAG,KAAK,IAAI,MAAM,KAAK,MAAM,IAAI,IAAI,yCAAyC,KAAK,GAAG,yBAC5D,MAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CACA,MAAM,MAAM,MAAM,EAAE;AACtB;;;AAIA,SAAgB,SACd,QACA,MACA,OACA,gBACwB;CACxB,MAAM,MAA8B,CAAC;CACrC,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,KAAK,MAAM,KAAK,IAAI;EAC1B,IAAI,OAAO,QAAW;EACtB,MAAM,MAAM,MAAM,MAAM,EAAE;EAC1B,IAAI,QAAQ,QAAW;GACrB,iBAAiB,KAAK;GACtB;EACF;EACA,IAAI,MAAM,KAAK,UAAU;CAC3B;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,eACd,MACqD;CACrD,MAAM,MAAM;CACZ,MAAM,MAA+B,CAAC;CACtC,KAAK,MAAM,QAAQ,gBAAgB;EACjC,IAAI,KAAK,kBAAkB,KAAK,SAAS,aAAa;EACtD,MAAM,KAAK,IAAI,KAAK;EACpB,IAAI,OAAO,QAAW,IAAI,KAAK,SAAS;CAC1C;CACA,OAAO;AACT"}

package/dist/core/scene/nodeGates.js

@@ -0,0 +1,58 @@
+//#region src/core/scene/nodeGates.ts
+/** Whether `node`'s own flag hides it and its subtree. A walk from the roots
+*  down prunes where this holds instead of asking {@link NodeGates.hidden}
+*  per node; the two agree because this is the flag that answer climbs for. */
+function hidesSubtree(node) {
+	return node.hidden === true;
+}
+/**
+* The gates over `scene` as it stands now. Ancestor answers are remembered,
+* so a walk over every node climbs each chain once: build one per walk, and
+* a fresh one after an edit.
+*/
+function nodeGates(scene) {
+	const hiddenLayers = /* @__PURE__ */ new Set();
+	const lockedLayers = /* @__PURE__ */ new Set();
+	for (const l of scene.layers ?? []) {
+		if (l.visible === false) hiddenLayers.add(l.id);
+		if (l.locked === true) lockedLayers.add(l.id);
+	}
+	/** Whether `flag` holds on the node at `id` or any ancestor, the node's
+	*  layer counting when `layers` holds it. */
+	const inherited = (flag, layers) => {
+		const memo = /* @__PURE__ */ new Map();
+		const climb = (id, seen) => {
+			const known = memo.get(id);
+			if (known !== void 0) return known;
+			const node = scene.get(id);
+			if (node === void 0 || seen.has(id)) return false;
+			seen.add(id);
+			const parent = node.parent ?? null;
+			const out = (flag === "hidden" ? hidesSubtree(node) : node.locked === true) || layers !== null && layers.has(node.layer) || parent !== null && climb(parent, seen);
+			memo.set(id, out);
+			return out;
+		};
+		return (id) => climb(id, /* @__PURE__ */ new Set());
+	};
+	const flaggedHidden = inherited("hidden", null);
+	return {
+		hidden(id) {
+			const node = scene.get(id);
+			if (node === void 0) return false;
+			return hiddenLayers.has(node.layer) || flaggedHidden(id);
+		},
+		locked: inherited("locked", lockedLayers)
+	};
+}
+/** {@link NodeGates.hidden} for one id. */
+function isNodeHidden(scene, id) {
+	return nodeGates(scene).hidden(id);
+}
+/** {@link NodeGates.locked} for one id. */
+function isNodeLocked(scene, id) {
+	return nodeGates(scene).locked(id);
+}
+
+//#endregion
+export { hidesSubtree, isNodeHidden, isNodeLocked, nodeGates };
+//# sourceMappingURL=nodeGates.js.map

package/dist/core/scene/nodeGates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeGates.js","names":[],"sources":["../../../src/core/scene/nodeGates.ts"],"sourcesContent":["/**\n * Whether a node is shown, and whether it is in reach — the one place either\n * question is answered. Painting, picking, area selection, select-all,\n * snapping, export, and the scene's own lock guard all ask here.\n *\n * - **Hidden**: its own layer is not visible, or it or any ancestor carries\n *   `hidden`. A layer hides only the nodes tagged to it; a hidden node hides\n *   its whole subtree, as SVG's `display=\"none\"` does.\n * - **Locked**: it or any ancestor carries `locked`, or sits on a locked\n *   layer. A lock covers the whole subtree, whatever layers it spans.\n */\nimport type { NodeId } from './types';\n\n/** The node fields the gates read. A partial scene stand-in may leave `parent` out. */\nexport interface GatedNode {\n  readonly layer: string;\n  readonly parent?: string | null;\n  readonly hidden?: boolean;\n  readonly locked?: boolean;\n}\n\n/** The layer fields the gates read. Only an explicit `visible: false` hides. */\nexport interface GatedLayer {\n  readonly id: string;\n  readonly visible?: boolean;\n  readonly locked?: boolean;\n}\n\n/** What the gates read of a scene. A `Scene` is one. */\nexport interface GateSource {\n  readonly layers?: readonly GatedLayer[];\n  get(id: NodeId): GatedNode | undefined;\n}\n\n/** Whether `node`'s own flag hides it and its subtree. A walk from the roots\n *  down prunes where this holds instead of asking {@link NodeGates.hidden}\n *  per node; the two agree because this is the flag that answer climbs for. */\nexport function hidesSubtree(node: { readonly hidden?: boolean }): boolean {\n  return node.hidden === true;\n}\n\n/** Both answers, for one read of a scene. */\nexport interface NodeGates {\n  /** Whether `id` is not drawn. An id not in the scene is not hidden. */\n  hidden(id: string): boolean;\n  /** Whether `id` is out of reach. An id not in the scene is not locked. */\n  locked(id: string): boolean;\n}\n\n/**\n * The gates over `scene` as it stands now. Ancestor answers are remembered,\n * so a walk over every node climbs each chain once: build one per walk, and\n * a fresh one after an edit.\n */\nexport function nodeGates(scene: GateSource): NodeGates {\n  const hiddenLayers = new Set<string>();\n  const lockedLayers = new Set<string>();\n  for (const l of scene.layers ?? []) {\n    if (l.visible === false) hiddenLayers.add(l.id);\n    if (l.locked === true) lockedLayers.add(l.id);\n  }\n\n  /** Whether `flag` holds on the node at `id` or any ancestor, the node's\n   *  layer counting when `layers` holds it. */\n  const inherited = (flag: 'hidden' | 'locked', layers: Set<string> | null) => {\n    const memo = new Map<string, boolean>();\n    const climb = (id: string, seen: Set<string>): boolean => {\n      const known = memo.get(id);\n      if (known !== undefined) return known;\n      const node = scene.get(id as NodeId);\n      if (node === undefined || seen.has(id)) return false;\n      seen.add(id);\n      const parent = node.parent ?? null;\n      const out = (flag === 'hidden' ? hidesSubtree(node) : node.locked === true)\n        || (layers !== null && layers.has(node.layer))\n        || (parent !== null && climb(parent, seen));\n      memo.set(id, out);\n      return out;\n    };\n    return (id: string) => climb(id, new Set());\n  };\n\n  const flaggedHidden = inherited('hidden', null);\n  const locked = inherited('locked', lockedLayers);\n  return {\n    hidden(id) {\n      const node = scene.get(id as NodeId);\n      if (node === undefined) return false;\n      return hiddenLayers.has(node.layer) || flaggedHidden(id);\n    },\n    locked,\n  };\n}\n\n/** {@link NodeGates.hidden} for one id. */\nexport function isNodeHidden(scene: GateSource, id: NodeId): boolean {\n  return nodeGates(scene).hidden(id);\n}\n\n/** {@link NodeGates.locked} for one id. */\nexport function isNodeLocked(scene: GateSource, id: NodeId): boolean {\n  return nodeGates(scene).locked(id);\n}\n"],"mappings":";;;;AAqCA,SAAgB,aAAa,MAA8C;CACzE,OAAO,KAAK,WAAW;AACzB;;;;;;AAeA,SAAgB,UAAU,OAA8B;CACtD,MAAM,+BAAe,IAAI,IAAY;CACrC,MAAM,+BAAe,IAAI,IAAY;CACrC,KAAK,MAAM,KAAK,MAAM,UAAU,CAAC,GAAG;EAClC,IAAI,EAAE,YAAY,OAAO,aAAa,IAAI,EAAE,EAAE;EAC9C,IAAI,EAAE,WAAW,MAAM,aAAa,IAAI,EAAE,EAAE;CAC9C;;;CAIA,MAAM,aAAa,MAA2B,WAA+B;EAC3E,MAAM,uBAAO,IAAI,IAAqB;EACtC,MAAM,SAAS,IAAY,SAA+B;GACxD,MAAM,QAAQ,KAAK,IAAI,EAAE;GACzB,IAAI,UAAU,QAAW,OAAO;GAChC,MAAM,OAAO,MAAM,IAAI,EAAY;GACnC,IAAI,SAAS,UAAa,KAAK,IAAI,EAAE,GAAG,OAAO;GAC/C,KAAK,IAAI,EAAE;GACX,MAAM,SAAS,KAAK,UAAU;GAC9B,MAAM,OAAO,SAAS,WAAW,aAAa,IAAI,IAAI,KAAK,WAAW,SAChE,WAAW,QAAQ,OAAO,IAAI,KAAK,KAAK,KACxC,WAAW,QAAQ,MAAM,QAAQ,IAAI;GAC3C,KAAK,IAAI,IAAI,GAAG;GAChB,OAAO;EACT;EACA,QAAQ,OAAe,MAAM,oBAAI,IAAI,IAAI,CAAC;CAC5C;CAEA,MAAM,gBAAgB,UAAU,UAAU,IAAI;CAE9C,OAAO;EACL,OAAO,IAAI;GACT,MAAM,OAAO,MAAM,IAAI,EAAY;GACnC,IAAI,SAAS,QAAW,OAAO;GAC/B,OAAO,aAAa,IAAI,KAAK,KAAK,KAAK,cAAc,EAAE;EACzD;EACA,QAPa,UAAU,UAAU,YAOjC;CACF;AACF;;AAGA,SAAgB,aAAa,OAAmB,IAAqB;CACnE,OAAO,UAAU,KAAK,CAAC,CAAC,OAAO,EAAE;AACnC;;AAGA,SAAgB,aAAa,OAAmB,IAAqB;CACnE,OAAO,UAAU,KAAK,CAAC,CAAC,OAAO,EAAE;AACnC"}