@weasel-js/core 1.10.1 → 1.11.1

package/dist/canvas/pickWalk.js

@@ -1,120 +1,169 @@
-import { planeMap as e } from "../core/viewport/parallax.js";
-import { resolveDerivedPath as t } from "../core/scene/derivedPath.js";
-import { clipCarrier as n } from "./planeClips.js";
-import { findShapeSilhouette as r } from "./NodeShape.js";
-import { asNodeId as i } from "../core/scene/types.js";
-import { sceneDerivedPathOf as a, scenePaintedPoseOf as o, showsComputedPath as s } from "./derivedPath.js";
-import { reaches as c } from "./pickReach.js";
-import { adapterPickSource as l } from "./adapterPickSource.js";
-import { invert as u } from "@weasel-js/geom";
+import { planeMap } from "../core/viewport/parallax.js";
+import { resolveDerivedPath } from "../core/scene/derivedPath.js";
+import { findShapeSilhouette } from "./NodeShape.js";
+import { clipCarrier } from "./planeClips.js";
+import { asNodeId } from "../core/scene/types.js";
+import { annotationLayerIds } from "../core/scene/annotation.js";
+import { nodeGates } from "../core/scene/nodeGates.js";
+import { sceneDerivedPathOf, scenePaintedPoseOf, showsComputedPath } from "./derivedPath.js";
+import { reaches } from "./pickReach.js";
+import { adapterPickSource } from "./adapterPickSource.js";
+import { invert } from "@weasel-js/geom";
+
 //#region src/canvas/pickWalk.ts
-var d = [];
-function f(e, t, n) {
-	return e.kind === "container" ? typeof e.clipFromPose == "function" ? e.clipFromPose(t) : r(e, t, { derivedPath: n }) : null;
+/**
+* The one hit-test walk. Everything that decides whether a node *can* be hit lives here; a
+* query supplies only the shape test and the clip predicate for its own region.
+*
+* The gates, in the order the walk applies them:
+*   1. containers, when the query does not want them
+*   2. the node is painted at all — not hidden in the scene (`nodeGates`),
+*      and on a layer the asking view's `layerVisibility` / `layerOrder` paints
+*   3. painted alpha is above zero
+*   4. the node is not locked, unless the query asks for locked nodes
+*   5. the query's own shape test
+*   6. every ancestor clip admits the query region
+*
+* 2, 3 and 6 are all "the renderer did not put this on screen". A pick path
+* that skips one answers for a node the user cannot see. 4 is the other axis:
+* a locked node is on screen and still out of reach.
+*/
+/** Shared, never mutated: most scenes are flat and every node returns it. */
+var EMPTY_PARENTS = [];
+/** The clip a container imposes on its subtree, or null when it imposes none. */
+function ownClipOf(node, pose, derived) {
+	if (node.kind !== "container") return null;
+	if (typeof node.clipFromPose === "function") return node.clipFromPose(pose);
+	return findShapeSilhouette(node, pose, { derivedPath: derived });
 }
-function p(e, t) {
-	let r = t.includeContainers ?? !0, i = t.includeLocked === !0 ? void 0 : e.isLocked, a = [], o = /* @__PURE__ */ new Map(), s = n(e.planeOf ?? null), l = (t) => {
-		let n = o.get(t.id);
-		if (n !== void 0) return n;
-		let r = f(t, e.poseOf(t), e.derivedPathOf?.(t));
-		return o.set(t.id, r), r;
-	}, d = /* @__PURE__ */ new Map(), p = (t) => {
-		let n = d.get(t.id);
-		if (n === void 0) {
-			let r = t.kind === "container" ? t.copiesFromPose : void 0;
-			n = (r ? r(e.poseOf(t), t) ?? [] : []).map(u).filter((e) => e !== null), d.set(t.id, n);
-		}
-		return n;
-	}, m = /* @__PURE__ */ new Map(), h = (n) => {
-		if (n === void 0 || e.planeOf === void 0) return t;
-		let r = m.get(n);
-		if (r === void 0) {
-			let i = e.planeOf(n);
-			r = i === null ? t : t.inPlane?.(i) ?? null, m.set(n, r);
+/**
+* Collect every candidate the query hits, back-to-front — the last element is
+* the topmost, which is the order `pickTopMostHit` expects.
+*/
+function pickWalk(src, q) {
+	const includeContainers = q.includeContainers ?? true;
+	const isLocked = q.includeLocked === true ? void 0 : src.isLocked;
+	const out = [];
+	const clipPath = /* @__PURE__ */ new Map();
+	const carry = clipCarrier(src.planeOf ?? null);
+	const clipOf = (ancestor) => {
+		const cached = clipPath.get(ancestor.id);
+		if (cached !== void 0) return cached;
+		const resolved = ownClipOf(ancestor, src.poseOf(ancestor), src.derivedPathOf?.(ancestor));
+		clipPath.set(ancestor.id, resolved);
+		return resolved;
+	};
+	const copyMaps = /* @__PURE__ */ new Map();
+	const copiesOf = (ancestor) => {
+		let found = copyMaps.get(ancestor.id);
+		if (found === void 0) {
+			const fn = ancestor.kind === "container" ? ancestor.copiesFromPose : void 0;
+			found = (fn ? fn(src.poseOf(ancestor), ancestor) ?? [] : []).map(invert).filter((m) => m !== null);
+			copyMaps.set(ancestor.id, found);
 		}
-		return r;
-	}, g = e.order(), _ = g.some((e) => e.kind === "container" && typeof e.copiesFromPose == "function");
-	for (let t of g) {
-		if (!r && t.kind === "container" || t.pickable === !1 || t.layer !== void 0 && e.layerIsPainted?.(t.layer) === !1 || e.alphaOf !== void 0 && e.alphaOf(t.id) <= 0 || i !== void 0 && i(t)) continue;
-		let n = h(t.layer);
-		if (n === null) continue;
-		let o = e.poseOf(t), u = e.derivedPathOf?.(t);
-		c(t, o, u, n, () => e.parentsOf(t), _, {
-			clipOf: l,
-			copiesOf: p,
-			carry: s
-		}) && a.push(t.id);
-	}
-	return a;
-}
-function m(e) {
-	let t = null;
-	for (let n of e.layers ?? []) n.locked === !0 && (t ??= /* @__PURE__ */ new Set()).add(n.id);
-	if (t === null) return null;
-	let n = t;
-	return (t) => {
-		let r = e.get(i(t)), a = /* @__PURE__ */ new Set();
-		for (; r !== void 0 && !a.has(r.id);) {
-			if (n.has(r.layer)) return !0;
-			a.add(r.id), r = r.parent === null ? void 0 : e.get(r.parent);
+		return found;
+	};
+	const planeQueries = /* @__PURE__ */ new Map();
+	const queryFor = (layer) => {
+		if (layer === void 0 || src.planeOf === void 0) return q;
+		let found = planeQueries.get(layer);
+		if (found === void 0) {
+			const map = src.planeOf(layer);
+			found = map === null ? q : q.inPlane?.(map) ?? null;
+			planeQueries.set(layer, found);
 		}
-		return !1;
+		return found;
 	};
+	const order = src.order();
+	const copying = order.some((n) => n.kind === "container" && typeof n.copiesFromPose === "function");
+	for (const node of order) {
+		if (!includeContainers && node.kind === "container") continue;
+		if (node.pickable === false) continue;
+		if (src.isHidden?.(node) === true) continue;
+		if (node.layer !== void 0 && src.layerIsPainted?.(node.layer) === false) continue;
+		if (src.alphaOf !== void 0 && src.alphaOf(node.id) <= 0) continue;
+		if (isLocked !== void 0 && isLocked(node)) continue;
+		const query = queryFor(node.layer);
+		if (query === null) continue;
+		const pose = src.poseOf(node);
+		const derived = src.derivedPathOf?.(node);
+		if (!reaches(node, pose, derived, query, () => src.parentsOf(node), copying, {
+			clipOf,
+			copiesOf,
+			carry
+		})) continue;
+		out.push(node.id);
+	}
+	return out;
 }
-function h(e) {
-	let t = /* @__PURE__ */ new Set();
-	for (let n of e ?? []) n.visible === !1 && t.add(n.id);
-	return t;
-}
-function g(e, n = {}) {
-	let r = h(e.layers), c = m(e), { getPose: l, alphaOf: u, layerIsPainted: f } = n, p = null, g = typeof e.overrides?.ids == "function";
-	if (!u && g) for (let t of e.overrides.ids()) {
-		let n = e.overrides.read(t)?.alpha;
-		n !== void 0 && n <= 0 && (p ??= /* @__PURE__ */ new Set()).add(t);
+function scenePickSource(scene, opts = {}) {
+	const gates = nodeGates(scene);
+	const annotations = annotationLayerIds(scene.layers);
+	const { getPose, alphaOf, layerIsPainted } = opts;
+	let faded = null;
+	const enumerable = typeof scene.overrides?.ids === "function";
+	if (!alphaOf && enumerable) for (const id of scene.overrides.ids()) {
+		const a = scene.overrides.read(id)?.alpha;
+		if (a !== void 0 && a <= 0) (faded ??= /* @__PURE__ */ new Set()).add(id);
 	}
-	let v = u ?? (g ? p ? (e) => +!p.has(e) : void 0 : (t) => e.overrides.read(i(t))?.alpha ?? 1), y = o(e), b = l ? (e) => l(e.id) : (e) => y(e), x = (t) => e.childrenOf(t), S = (n) => {
-		let r = e.get(n);
-		if (r !== void 0) return {
-			node: r,
-			pose: b(r),
+	const readAlpha = alphaOf ?? (enumerable ? faded ? (id) => faded.has(id) ? 0 : 1 : void 0 : (id) => scene.overrides.read(asNodeId(id))?.alpha ?? 1);
+	const paintedPoseOf = scenePaintedPoseOf(scene);
+	const poseOf = getPose ? (node) => getPose(node.id) : (node) => paintedPoseOf(node);
+	const childrenOf = (id) => scene.childrenOf(id);
+	const depOf = (id) => {
+		const dep = scene.get(id);
+		if (dep === void 0) return void 0;
+		return {
+			node: dep,
+			pose: poseOf(dep),
 			get path() {
-				return t(r, S, x);
+				return resolveDerivedPath(dep, depOf, childrenOf);
 			}
 		};
-	}, C = l ? null : a(e), w = (n) => {
-		let r = n;
-		return C ? s(e, r) ? C(r) : null : r.dependsOn === void 0 ? null : t(r, S, x);
-	}, T = n.camera ? _(e.layers, n.camera) : null;
+	};
+	const sceneDerivedPath = getPose ? null : sceneDerivedPathOf(scene);
+	const derivedPathOf = (node) => {
+		const n = node;
+		if (!sceneDerivedPath) return n.dependsOn === void 0 ? null : resolveDerivedPath(n, depOf, childrenOf);
+		return showsComputedPath(scene, n) ? sceneDerivedPath(n) : null;
+	};
+	const planeOf = opts.camera ? scenePlaneOf(scene.layers, opts.camera) : null;
 	return {
-		...T ? { planeOf: T } : {},
-		order: () => e.renderOrderNodes(),
-		derivedPathOf: w,
-		poseOf: b,
-		parentsOf(t) {
-			let n = t.parent ?? null;
-			if (n === null) return d;
-			let r = [], a = /* @__PURE__ */ new Set();
-			for (; n !== null && !a.has(n);) {
-				a.add(n);
-				let t = e.get(i(n));
-				if (!t) break;
-				r.push(t), n = t.parent ?? null;
+		...planeOf ? { planeOf } : {},
+		order: () => scene.renderOrderNodes(),
+		derivedPathOf,
+		poseOf,
+		parentsOf(node) {
+			let parentId = node.parent ?? null;
+			if (parentId === null) return EMPTY_PARENTS;
+			const chain = [];
+			const seen = /* @__PURE__ */ new Set();
+			while (parentId !== null) {
+				if (seen.has(parentId)) break;
+				seen.add(parentId);
+				const parent = scene.get(asNodeId(parentId));
+				if (!parent) break;
+				chain.push(parent);
+				parentId = parent.parent ?? null;
 			}
-			return r;
+			return chain;
 		},
-		...v ? { alphaOf: v } : {},
-		...c ? { isLocked: (e) => c(e.id) } : {},
-		...r.size > 0 || f ? { layerIsPainted: (e) => !r.has(e) && (f === void 0 || f(e)) } : {}
+		...readAlpha ? { alphaOf: readAlpha } : {},
+		isLocked: (node) => gates.locked(node.id),
+		isHidden: (node) => gates.hidden(node.id),
+		...annotations.size > 0 || layerIsPainted ? { layerIsPainted: (layer) => !annotations.has(layer) && (layerIsPainted === void 0 || layerIsPainted(layer)) } : {}
 	};
 }
-function _(t, n) {
-	let r = null;
-	for (let i of t ?? []) i.parallax && (r ??= /* @__PURE__ */ new Map()).set(i.id, e(n, i.parallax));
-	if (r === null) return null;
-	let i = r;
-	return (e) => i.get(e) ?? null;
+/** Each parallax layer's plane map under `camera`, or null when no layer is a
+*  plane — which keeps the per-layer lookup off the walk entirely. */
+function scenePlaneOf(layers, camera) {
+	let maps = null;
+	for (const l of layers ?? []) if (l.parallax) (maps ??= /* @__PURE__ */ new Map()).set(l.id, planeMap(camera, l.parallax));
+	if (maps === null) return null;
+	const found = maps;
+	return (layer) => found.get(layer) ?? null;
 }
-//#endregion
-export { l as adapterPickSource, h as hiddenLayerIds, f as ownClipOf, p as pickWalk, g as scenePickSource, _ as scenePlaneOf };
 
+//#endregion
+export { adapterPickSource, ownClipOf, pickWalk, scenePickSource, scenePlaneOf };
 //# sourceMappingURL=pickWalk.js.map

package/dist/canvas/pickWalk.js.map

@@ -1 +1 @@
-{"version":3,"file":"pickWalk.js","names":["EMPTY_PARENTS","ownClipOf","node","pose","findShapeSilhouette","derived","pickWalk","includeContainers","q","isLocked","src","out","clipPath","carry","clipCarrier","clipOf","cached","ancestor","resolved","copyMaps","copiesOf","found","fn","invert","m","planeQueries","queryFor","layer","map","order","copying","n","query","reaches","lockedNodeTest","locked","scene","lockedLayers","cur","asNodeId","id","seen","hiddenLayerIds","layers","scenePickSource","hidden","opts","faded","enumerable","alphaOf","a","readAlpha","paintedPoseOf","scenePaintedPoseOf","poseOf","getPose","childrenOf","depOf","dep","resolveDerivedPath","sceneDerivedPath","sceneDerivedPathOf","derivedPathOf","showsComputedPath","planeOf","scenePlaneOf","parentId","chain","parent","layerIsPainted","maps","l","planeMap","camera","adapterPickSource"],"sources":["../../src/canvas/pickWalk.ts"],"sourcesContent":["/**\n * The one hit-test walk. Everything that decides whether a node *can* be hit lives here; a\n * query supplies only the shape test and the clip predicate for its own region.\n *\n * The gates, in the order the walk applies them:\n *   1. containers, when the query does not want them\n *   2. the layer is painted at all — scene visibility, and the asking view's\n *      `layerVisibility` / `layerOrder`\n *   3. painted alpha is above zero\n *   4. the node is not locked, unless the query asks for locked nodes\n *   5. the query's own shape test\n *   6. every ancestor clip admits the query region\n *\n * 2, 3 and 6 are all \"the renderer did not put this on screen\". A pick path\n * that skips one answers for a node the user cannot see. 4 is the other axis:\n * a locked node is on screen and still out of reach.\n */\n\nimport { invert, type Affine, type Path } from '@weasel-js/geom';\nimport { findShapeSilhouette } from 'canvas/NodeShape';\nimport type { ClipFromPoseFn, CopiesFromPoseFn, DerivedDep, Node, NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport { resolveDerivedPath, sceneDerivedPathOf, scenePaintedPoseOf, showsComputedPath } from './derivedPath';\nimport { planeMap, type ParallaxOpts, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { clipCarrier } from './planeClips';\nimport { reaches } from './pickReach';\n\n/** Shared, never mutated: most scenes are flat and every node returns it. */\nconst EMPTY_PARENTS: readonly never[] = [];\n\n/** The subset of a node the walk itself reads. Deliberately structural: a\n *  bare adapter's node satisfies it as readily as a `SceneNode`. */\nexport interface PickCandidate<TPose> {\n  id: string;\n  kind?: string;\n  layer?: string;\n  pose: TPose;\n  /** `false` makes the node transparent to the walk — see `SceneNode.pickable`. */\n  pickable?: boolean;\n  clipFromPose?: ClipFromPoseFn<TPose>;\n  copiesFromPose?: CopiesFromPoseFn<TPose>;\n}\n\n/**\n * Everything the walk reads that a **view** owns.\n *\n * A layer must not hold state a view owns, so none of these are closed over\n * at construction — each is asked per walk, of the view being dispatched to.\n */\nexport interface PickSource<TPose> {\n  /** Candidates in paint order, back-to-front. Containers included; the\n   *  query decides whether they can be hit. */\n  order(): readonly PickCandidate<TPose>[];\n  /** The pose the renderer draws — override-aware. Not `node.pose`, which is\n   *  how the render and pick paths came to disagree about where a node is. */\n  poseOf(node: PickCandidate<TPose>): TPose;\n  /** Ancestors, innermost first. Only walked for candidates that already\n   *  passed their own shape test. */\n  parentsOf(node: PickCandidate<TPose>): readonly PickCandidate<TPose>[];\n  /** Painted alpha for the asking view: the view's `alphaFor` times any\n   *  per-node override alpha. Omit when the source has no alpha concept. */\n  alphaOf?(id: string): number;\n  /** Whether this layer reaches the screen in the asking view. Omit for a\n   *  source with no layers. */\n  layerIsPainted?(layer: string): boolean;\n  /** Whether the node is locked — painted, but not something a pointer can\n   *  take. Omit for a source with no lock concept. */\n  isLocked?(node: PickCandidate<TPose>): boolean;\n  /** The path a node computes from its dependencies, or null for none. */\n  derivedPathOf?(node: PickCandidate<TPose>): Path | null;\n  /** How the asking view's world maps into a parallax layer's, or null for a\n   *  layer that moves with the camera. Omit for a source with no planes. */\n  planeOf?(layer: string): PlaneMap | null;\n}\n\n/** One hit-test question: what region, and what counts as covering it. */\nexport interface PickQuery<TPose> {\n  /** Default `true`. The area walks exclude containers so a marquee does not\n   *  return a container and its children both. */\n  includeContainers?: boolean;\n  /** Default `false`. Every selecting or editing query passes over locked\n   *  nodes; one that only samples what is painted can take them back. */\n  includeLocked?: boolean;\n  /** Does this node, drawn at this pose, cover the query region? `derived`\n   *  is the node's resolved path when it has one — a derived node's pose is a\n   *  placeholder, so a region test that reads only the pose answers for the\n   *  wrong box. */\n  hits(node: PickCandidate<TPose>, pose: TPose, derived?: Path | null): boolean;\n  /**\n   * Does an ancestor's clip leave anything of `node` for this query to hit?\n   *\n   * A point query asks point-in-clip and ignores the node. An area query has\n   * to ask about the node as well: the clip and the area can overlap where\n   * the node is not, and the node and the clip can overlap where the area is\n   * not, and only the two terms together reject both.\n   */\n  clipAdmits(\n    clip: Path,\n    node: PickCandidate<TPose>,\n    pose: TPose,\n    derived?: Path | null,\n  ): boolean;\n  /** The same question asked in a parallax plane's world: the region carried\n   *  through `map`, and any screen-pixel slop re-derived at the plane's scale.\n   *  A query without it cannot reach nodes on a plane — it would test them\n   *  where their poses sit rather than where they are painted. */\n  inPlane?(map: PlaneMap): PickQuery<TPose>;\n  /** The same question carried by `m`, an affine from world into the source\n   *  frame of a copy a container draws. A query without it cannot reach\n   *  copies — see `ContainerNode.copiesFromPose`. */\n  inCopy?(m: Affine): PickQuery<TPose>;\n}\n\n/** The clip a container imposes on its subtree, or null when it imposes none. */\nexport function ownClipOf<TPose>(\n  node: PickCandidate<TPose>,\n  pose: TPose,\n  derived?: Path | null,\n): Path | null {\n  if (node.kind !== 'container') return null;\n  if (typeof node.clipFromPose === 'function') return node.clipFromPose(pose);\n  return findShapeSilhouette(\n    node as unknown as Node<unknown, string, TPose>,\n    pose,\n    { derivedPath: derived },\n  );\n}\n\n/**\n * Collect every candidate the query hits, back-to-front — the last element is\n * the topmost, which is the order `pickTopMostHit` expects.\n */\nexport function pickWalk<TPose>(\n  src: PickSource<TPose>,\n  q: PickQuery<TPose>,\n): string[] {\n  const includeContainers = q.includeContainers ?? true;\n  const isLocked = q.includeLocked === true ? undefined : src.isLocked;\n  const out: string[] = [];\n\n  // Resolving a container's clip is the expensive half, so the *path* is memoized per\n  // container for the walk. The predicate re-runs per candidate: caching its answer per\n  // container would answer the wrong question for an area query.\n  const clipPath = new Map<string, Path | null>();\n  // A clip is in its container's plane; the query is in the candidate's.\n  const carry = clipCarrier(src.planeOf ?? null);\n\n  const clipOf = (ancestor: PickCandidate<TPose>): Path | null => {\n    const cached = clipPath.get(ancestor.id);\n    if (cached !== undefined) return cached;\n    const resolved = ownClipOf(\n      ancestor, src.poseOf(ancestor), src.derivedPathOf?.(ancestor),\n    );\n    clipPath.set(ancestor.id, resolved);\n    return resolved;\n  };\n\n  const copyMaps = new Map<string, readonly Affine[]>();\n  const copiesOf = (ancestor: PickCandidate<TPose>): readonly Affine[] => {\n    let found = copyMaps.get(ancestor.id);\n    if (found === undefined) {\n      const fn = ancestor.kind === 'container' ? ancestor.copiesFromPose : undefined;\n      const copies = fn ? fn(src.poseOf(ancestor), ancestor as never) ?? [] : [];\n      found = copies.map(invert).filter((m): m is Affine => m !== null);\n      copyMaps.set(ancestor.id, found);\n    }\n    return found;\n  };\n\n  // One reprojected query per plane per walk; `null` marks a plane this\n  // query cannot reach.\n  const planeQueries = new Map<string, PickQuery<TPose> | null>();\n  const queryFor = (layer: string | undefined): PickQuery<TPose> | null => {\n    if (layer === undefined || src.planeOf === undefined) return q;\n    let found = planeQueries.get(layer);\n    if (found === undefined) {\n      const map = src.planeOf(layer);\n      found = map === null ? q : (q.inPlane?.(map) ?? null);\n      planeQueries.set(layer, found);\n    }\n    return found;\n  };\n\n  const order = src.order();\n  const copying = order.some((n) => n.kind === 'container' && typeof n.copiesFromPose === 'function');\n  for (const node of order) {\n    if (!includeContainers && node.kind === 'container') continue;\n    // Transparent to picking: the click belongs to whatever is behind it,\n    // which for a label inside a box is the box.\n    if (node.pickable === false) continue;\n    if (node.layer !== undefined && src.layerIsPainted?.(node.layer) === false) continue;\n    if (src.alphaOf !== undefined && src.alphaOf(node.id) <= 0) continue;\n    if (isLocked !== undefined && isLocked(node)) continue;\n\n    const query = queryFor(node.layer);\n    if (query === null) continue;\n    const pose = src.poseOf(node);\n    const derived = src.derivedPathOf?.(node);\n    if (!reaches(node, pose, derived, query, () => src.parentsOf(node), copying, { clipOf, copiesOf, carry })) continue;\n    out.push(node.id);\n  }\n\n  return out;\n}\n\n/** Answers `Scene.isLocked` from the layer records and parent links alone,\n *  so a partial scene stand-in works too. Null when nothing is locked, which\n *  is what keeps the gate off the walk in the common case. */\nfunction lockedNodeTest(\n  scene: Pick<Scene<unknown, string, unknown>, 'layers' | 'get'>,\n): ((id: string) => boolean) | null {\n  let locked: Set<string> | null = null;\n  for (const layer of scene.layers ?? []) {\n    if (layer.locked === true) (locked ??= new Set()).add(layer.id);\n  }\n  if (locked === null) return null;\n  const lockedLayers = locked;\n  return (id) => {\n    let cur = scene.get(asNodeId(id));\n    const seen = new Set<string>();\n    while (cur !== undefined && !seen.has(cur.id)) {\n      if (lockedLayers.has(cur.layer)) return true;\n      seen.add(cur.id);\n      cur = cur.parent === null ? undefined : scene.get(cur.parent);\n    }\n    return false;\n  };\n}\n\n/** Layer ids the scene reports as hidden. Only an explicit `false` hides a\n *  layer: a partial scene stand-in that omits the flag stays pickable. */\nexport function hiddenLayerIds(\n  layers: readonly { id: string; visible?: boolean }[] | undefined,\n): Set<string> {\n  const out = new Set<string>();\n  for (const layer of layers ?? []) {\n    if (layer.visible === false) out.add(layer.id);\n  }\n  return out;\n}\n\n/**\n * The two answers a pick needs from the view it is asked for rather than from\n * the data behind it: how that view paints a node, and whether it paints a\n * layer at all. A scene and a bare adapter take the same pair.\n */\nexport interface ViewPickGates {\n  /** Painted alpha: the view's `alphaFor` times any per-node override alpha.\n   *  A node painted at alpha 0 cannot be hit. */\n  alphaOf?: (id: string) => number;\n  /** Whether a node's `layer` reaches the screen in the asking view. */\n  layerIsPainted?: (layer: string) => boolean;\n}\n\n/** The gates a bare adapter takes from its view, plus how that view's camera\n *  maps into each parallax layer — see `scenePlaneOf`. */\nexport interface AdapterPickGates extends ViewPickGates {\n  planeOf?: (layer: string) => PlaneMap | null;\n}\n\nexport interface ScenePickSourceOptions<TPose> extends ViewPickGates {\n  /** Pose lookup, when the caller holds an adapter that already resolves\n   *  overrides. Defaults to `effectivePose` against the scene's own. */\n  getPose?: (id: string) => TPose;\n  /** The asking view's composed alpha — `alphaFor(id)` times override alpha.\n   *  Defaults to the override alpha alone, which is all a bare scene knows. */\n  alphaOf?: (id: string) => number;\n  /** The asking view's answer to \"does this scene layer reach the screen\",\n   *  which is `layerVisibility` and `layerOrder` on top of the scene's own\n   *  `visible` flag. Consulted after the scene's flag, never instead of it. */\n  layerIsPainted?: (layer: string) => boolean;\n  /** The asking view's camera. With it, a layer carrying `parallax` is picked\n   *  through its plane; without it, every layer is taken to move with the\n   *  camera. */\n  camera?: View;\n}\n\nexport function scenePickSource<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  opts: ScenePickSourceOptions<TPose> = {},\n): PickSource<TPose> {\n  const hidden = hiddenLayerIds(scene.layers);\n  const locked = lockedNodeTest(scene as never);\n  const { getPose, alphaOf, layerIsPainted } = opts;\n\n  // Resolved once per walk rather than once per candidate. Needs enumeration — a\n  // partial scene stand-in carrying only `read` falls back to reading per node.\n  let faded: Set<string> | null = null;\n  const enumerable = typeof scene.overrides?.ids === 'function';\n  if (!alphaOf && enumerable) {\n    for (const id of scene.overrides.ids()) {\n      const a = scene.overrides.read(id)?.alpha;\n      if (a !== undefined && a <= 0) (faded ??= new Set()).add(id);\n    }\n  }\n  const readAlpha = alphaOf\n    ?? (enumerable\n      ? (faded ? (id: string) => (faded.has(id) ? 0 : 1) : undefined)\n      : (id: string) => scene.overrides.read(asNodeId(id))?.alpha ?? 1);\n\n  // A composing strategy makes a node's own pose local, so picking folds the\n  // parent chain the same way the render walk does: one definition of both.\n  const paintedPoseOf = scenePaintedPoseOf(scene);\n  const poseOf = getPose\n    ? (node: PickCandidate<TPose>) => getPose(node.id)\n    : (node: PickCandidate<TPose>) => paintedPoseOf(node as never);\n\n  // Through `poseOf`, not the document pose: a derived node has to be tested\n  // where the renderer draws its dependencies, which is what an override says.\n  const childrenOf = (id: NodeId): readonly NodeId[] => scene.childrenOf(id);\n  const depOf = (id: NodeId): DerivedDep<TPose> | undefined => {\n    const dep = scene.get(id);\n    if (dep === undefined) return undefined;\n    return {\n      node: dep as Node<unknown, string, TPose>,\n      pose: poseOf(dep as never),\n      get path(): Path | null {\n        return resolveDerivedPath(dep as never, depOf, childrenOf);\n      },\n    };\n  };\n\n  const sceneDerivedPath = getPose ? null : sceneDerivedPathOf(scene);\n  const derivedPathOf = (node: PickCandidate<TPose>): Path | null => {\n    const n = node as unknown as Node<TData, TLayer, TPose>;\n    if (!sceneDerivedPath) return n.dependsOn === undefined ? null : resolveDerivedPath(n, depOf, childrenOf);\n    return showsComputedPath(scene, n) ? sceneDerivedPath(n) : null;\n  };\n\n  const planeOf = opts.camera ? scenePlaneOf(scene.layers, opts.camera) : null;\n\n  return {\n    ...(planeOf ? { planeOf } : {}),\n    order: () => scene.renderOrderNodes() as unknown as readonly PickCandidate<TPose>[],\n    derivedPathOf,\n    poseOf,\n    parentsOf(node) {\n      let parentId = (node as { parent?: string | null }).parent ?? null;\n      if (parentId === null) return EMPTY_PARENTS;\n      const chain: PickCandidate<TPose>[] = [];\n      const seen = new Set<string>();\n      while (parentId !== null) {\n        if (seen.has(parentId)) break;\n        seen.add(parentId);\n        const parent = scene.get(asNodeId(parentId));\n        if (!parent) break;\n        chain.push(parent as unknown as PickCandidate<TPose>);\n        parentId = parent.parent ?? null;\n      }\n      return chain;\n    },\n    // Absent entirely when nothing is faded, so the walk skips the gate.\n    ...(readAlpha ? { alphaOf: readAlpha } : {}),\n    ...(locked ? { isLocked: (node: PickCandidate<TPose>) => locked(node.id) } : {}),\n    ...(hidden.size > 0 || layerIsPainted\n      ? {\n        layerIsPainted: (layer: string) =>\n          !hidden.has(layer) && (layerIsPainted === undefined || layerIsPainted(layer)),\n      }\n      : {}),\n  };\n}\n\n/** Each parallax layer's plane map under `camera`, or null when no layer is a\n *  plane — which keeps the per-layer lookup off the walk entirely. */\nexport function scenePlaneOf(\n  layers: readonly { id: string; parallax?: ParallaxOpts }[] | undefined,\n  camera: View,\n): ((layer: string) => PlaneMap | null) | null {\n  let maps: Map<string, PlaneMap> | null = null;\n  for (const l of layers ?? []) {\n    if (l.parallax) (maps ??= new Map()).set(l.id, planeMap(camera, l.parallax));\n  }\n  if (maps === null) return null;\n  const found = maps;\n  return (layer) => found.get(layer) ?? null;\n}\n\nexport { adapterPickSource } from './adapterPickSource';\n"],"mappings":"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"}
+{"version":3,"file":"pickWalk.js","names":[],"sources":["../../src/canvas/pickWalk.ts"],"sourcesContent":["/**\n * The one hit-test walk. Everything that decides whether a node *can* be hit lives here; a\n * query supplies only the shape test and the clip predicate for its own region.\n *\n * The gates, in the order the walk applies them:\n *   1. containers, when the query does not want them\n *   2. the node is painted at all — not hidden in the scene (`nodeGates`),\n *      and on a layer the asking view's `layerVisibility` / `layerOrder` paints\n *   3. painted alpha is above zero\n *   4. the node is not locked, unless the query asks for locked nodes\n *   5. the query's own shape test\n *   6. every ancestor clip admits the query region\n *\n * 2, 3 and 6 are all \"the renderer did not put this on screen\". A pick path\n * that skips one answers for a node the user cannot see. 4 is the other axis:\n * a locked node is on screen and still out of reach.\n */\n\nimport { invert, type Affine, type Path } from '@weasel-js/geom';\nimport { findShapeSilhouette } from 'canvas/NodeShape';\nimport type { ClipFromPoseFn, CopiesFromPoseFn, DerivedDep, Node, NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport { annotationLayerIds } from 'core/scene/annotation';\nimport { nodeGates } from 'core/scene/nodeGates';\nimport { resolveDerivedPath, sceneDerivedPathOf, scenePaintedPoseOf, showsComputedPath } from './derivedPath';\nimport { planeMap, type ParallaxOpts, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { clipCarrier } from './planeClips';\nimport { reaches } from './pickReach';\n\n/** Shared, never mutated: most scenes are flat and every node returns it. */\nconst EMPTY_PARENTS: readonly never[] = [];\n\n/** The subset of a node the walk itself reads. Deliberately structural: a\n *  bare adapter's node satisfies it as readily as a `SceneNode`. */\nexport interface PickCandidate<TPose> {\n  id: string;\n  kind?: string;\n  layer?: string;\n  pose: TPose;\n  /** `false` makes the node transparent to the walk — see `SceneNode.pickable`. */\n  pickable?: boolean;\n  clipFromPose?: ClipFromPoseFn<TPose>;\n  copiesFromPose?: CopiesFromPoseFn<TPose>;\n}\n\n/**\n * Everything the walk reads that a **view** owns.\n *\n * A layer must not hold state a view owns, so none of these are closed over\n * at construction — each is asked per walk, of the view being dispatched to.\n */\nexport interface PickSource<TPose> {\n  /** Candidates in paint order, back-to-front. Containers included; the\n   *  query decides whether they can be hit. */\n  order(): readonly PickCandidate<TPose>[];\n  /** The pose the renderer draws — override-aware. Not `node.pose`, which is\n   *  how the render and pick paths came to disagree about where a node is. */\n  poseOf(node: PickCandidate<TPose>): TPose;\n  /** Ancestors, innermost first. Only walked for candidates that already\n   *  passed their own shape test. */\n  parentsOf(node: PickCandidate<TPose>): readonly PickCandidate<TPose>[];\n  /** Painted alpha for the asking view: the view's `alphaFor` times any\n   *  per-node override alpha. Omit when the source has no alpha concept. */\n  alphaOf?(id: string): number;\n  /** Whether this layer reaches the screen in the asking view. Omit for a\n   *  source with no layers. */\n  layerIsPainted?(layer: string): boolean;\n  /** Whether the node is locked — painted, but not something a pointer can\n   *  take. Omit for a source with no lock concept. */\n  isLocked?(node: PickCandidate<TPose>): boolean;\n  /** Whether the source hides the node, so nothing of it is on screen. Omit\n   *  for a source that hides nothing. */\n  isHidden?(node: PickCandidate<TPose>): boolean;\n  /** The path a node computes from its dependencies, or null for none. */\n  derivedPathOf?(node: PickCandidate<TPose>): Path | null;\n  /** How the asking view's world maps into a parallax layer's, or null for a\n   *  layer that moves with the camera. Omit for a source with no planes. */\n  planeOf?(layer: string): PlaneMap | null;\n}\n\n/** One hit-test question: what region, and what counts as covering it. */\nexport interface PickQuery<TPose> {\n  /** Default `true`. The area walks exclude containers so a marquee does not\n   *  return a container and its children both. */\n  includeContainers?: boolean;\n  /** Default `false`. Every selecting or editing query passes over locked\n   *  nodes; one that only samples what is painted can take them back. */\n  includeLocked?: boolean;\n  /** Does this node, drawn at this pose, cover the query region? `derived`\n   *  is the node's resolved path when it has one — a derived node's pose is a\n   *  placeholder, so a region test that reads only the pose answers for the\n   *  wrong box. */\n  hits(node: PickCandidate<TPose>, pose: TPose, derived?: Path | null): boolean;\n  /**\n   * Does an ancestor's clip leave anything of `node` for this query to hit?\n   *\n   * A point query asks point-in-clip and ignores the node. An area query has\n   * to ask about the node as well: the clip and the area can overlap where\n   * the node is not, and the node and the clip can overlap where the area is\n   * not, and only the two terms together reject both.\n   */\n  clipAdmits(\n    clip: Path,\n    node: PickCandidate<TPose>,\n    pose: TPose,\n    derived?: Path | null,\n  ): boolean;\n  /** The same question asked in a parallax plane's world: the region carried\n   *  through `map`, and any screen-pixel slop re-derived at the plane's scale.\n   *  A query without it cannot reach nodes on a plane — it would test them\n   *  where their poses sit rather than where they are painted. */\n  inPlane?(map: PlaneMap): PickQuery<TPose>;\n  /** The same question carried by `m`, an affine from world into the source\n   *  frame of a copy a container draws. A query without it cannot reach\n   *  copies — see `ContainerNode.copiesFromPose`. */\n  inCopy?(m: Affine): PickQuery<TPose>;\n}\n\n/** The clip a container imposes on its subtree, or null when it imposes none. */\nexport function ownClipOf<TPose>(\n  node: PickCandidate<TPose>,\n  pose: TPose,\n  derived?: Path | null,\n): Path | null {\n  if (node.kind !== 'container') return null;\n  if (typeof node.clipFromPose === 'function') return node.clipFromPose(pose);\n  return findShapeSilhouette(\n    node as unknown as Node<unknown, string, TPose>,\n    pose,\n    { derivedPath: derived },\n  );\n}\n\n/**\n * Collect every candidate the query hits, back-to-front — the last element is\n * the topmost, which is the order `pickTopMostHit` expects.\n */\nexport function pickWalk<TPose>(\n  src: PickSource<TPose>,\n  q: PickQuery<TPose>,\n): string[] {\n  const includeContainers = q.includeContainers ?? true;\n  const isLocked = q.includeLocked === true ? undefined : src.isLocked;\n  const out: string[] = [];\n\n  // Resolving a container's clip is the expensive half, so the *path* is memoized per\n  // container for the walk. The predicate re-runs per candidate: caching its answer per\n  // container would answer the wrong question for an area query.\n  const clipPath = new Map<string, Path | null>();\n  // A clip is in its container's plane; the query is in the candidate's.\n  const carry = clipCarrier(src.planeOf ?? null);\n\n  const clipOf = (ancestor: PickCandidate<TPose>): Path | null => {\n    const cached = clipPath.get(ancestor.id);\n    if (cached !== undefined) return cached;\n    const resolved = ownClipOf(\n      ancestor, src.poseOf(ancestor), src.derivedPathOf?.(ancestor),\n    );\n    clipPath.set(ancestor.id, resolved);\n    return resolved;\n  };\n\n  const copyMaps = new Map<string, readonly Affine[]>();\n  const copiesOf = (ancestor: PickCandidate<TPose>): readonly Affine[] => {\n    let found = copyMaps.get(ancestor.id);\n    if (found === undefined) {\n      const fn = ancestor.kind === 'container' ? ancestor.copiesFromPose : undefined;\n      const copies = fn ? fn(src.poseOf(ancestor), ancestor as never) ?? [] : [];\n      found = copies.map(invert).filter((m): m is Affine => m !== null);\n      copyMaps.set(ancestor.id, found);\n    }\n    return found;\n  };\n\n  // One reprojected query per plane per walk; `null` marks a plane this\n  // query cannot reach.\n  const planeQueries = new Map<string, PickQuery<TPose> | null>();\n  const queryFor = (layer: string | undefined): PickQuery<TPose> | null => {\n    if (layer === undefined || src.planeOf === undefined) return q;\n    let found = planeQueries.get(layer);\n    if (found === undefined) {\n      const map = src.planeOf(layer);\n      found = map === null ? q : (q.inPlane?.(map) ?? null);\n      planeQueries.set(layer, found);\n    }\n    return found;\n  };\n\n  const order = src.order();\n  const copying = order.some((n) => n.kind === 'container' && typeof n.copiesFromPose === 'function');\n  for (const node of order) {\n    if (!includeContainers && node.kind === 'container') continue;\n    // Transparent to picking: the click belongs to whatever is behind it,\n    // which for a label inside a box is the box.\n    if (node.pickable === false) continue;\n    if (src.isHidden?.(node) === true) continue;\n    if (node.layer !== undefined && src.layerIsPainted?.(node.layer) === false) continue;\n    if (src.alphaOf !== undefined && src.alphaOf(node.id) <= 0) continue;\n    if (isLocked !== undefined && isLocked(node)) continue;\n\n    const query = queryFor(node.layer);\n    if (query === null) continue;\n    const pose = src.poseOf(node);\n    const derived = src.derivedPathOf?.(node);\n    if (!reaches(node, pose, derived, query, () => src.parentsOf(node), copying, { clipOf, copiesOf, carry })) continue;\n    out.push(node.id);\n  }\n\n  return out;\n}\n\n/**\n * The two answers a pick needs from the view it is asked for rather than from\n * the data behind it: how that view paints a node, and whether it paints a\n * layer at all. A scene and a bare adapter take the same pair.\n */\nexport interface ViewPickGates {\n  /** Painted alpha: the view's `alphaFor` times any per-node override alpha.\n   *  A node painted at alpha 0 cannot be hit. */\n  alphaOf?: (id: string) => number;\n  /** Whether a node's `layer` reaches the screen in the asking view. */\n  layerIsPainted?: (layer: string) => boolean;\n}\n\n/** The gates a bare adapter takes from its view, plus how that view's camera\n *  maps into each parallax layer — see `scenePlaneOf`. */\nexport interface AdapterPickGates extends ViewPickGates {\n  planeOf?: (layer: string) => PlaneMap | null;\n}\n\nexport interface ScenePickSourceOptions<TPose> extends ViewPickGates {\n  /** Pose lookup, when the caller holds an adapter that already resolves\n   *  overrides. Defaults to `effectivePose` against the scene's own. */\n  getPose?: (id: string) => TPose;\n  /** The asking view's composed alpha — `alphaFor(id)` times override alpha.\n   *  Defaults to the override alpha alone, which is all a bare scene knows. */\n  alphaOf?: (id: string) => number;\n  /** The asking view's answer to \"does this scene layer reach the screen\",\n   *  which is `layerVisibility` and `layerOrder` on top of the scene's own\n   *  `visible` flag. Consulted after the scene's flag, never instead of it. */\n  layerIsPainted?: (layer: string) => boolean;\n  /** The asking view's camera. With it, a layer carrying `parallax` is picked\n   *  through its plane; without it, every layer is taken to move with the\n   *  camera. */\n  camera?: View;\n}\n\nexport function scenePickSource<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  opts: ScenePickSourceOptions<TPose> = {},\n): PickSource<TPose> {\n  // Partial scene stand-ins carry only `layers` and `get`, which is all the gates read.\n  const gates = nodeGates(scene as never);\n  const annotations = annotationLayerIds(scene.layers);\n  const { getPose, alphaOf, layerIsPainted } = opts;\n\n  // Resolved once per walk rather than once per candidate. Needs enumeration — a\n  // partial scene stand-in carrying only `read` falls back to reading per node.\n  let faded: Set<string> | null = null;\n  const enumerable = typeof scene.overrides?.ids === 'function';\n  if (!alphaOf && enumerable) {\n    for (const id of scene.overrides.ids()) {\n      const a = scene.overrides.read(id)?.alpha;\n      if (a !== undefined && a <= 0) (faded ??= new Set()).add(id);\n    }\n  }\n  const readAlpha = alphaOf\n    ?? (enumerable\n      ? (faded ? (id: string) => (faded.has(id) ? 0 : 1) : undefined)\n      : (id: string) => scene.overrides.read(asNodeId(id))?.alpha ?? 1);\n\n  // A composing strategy makes a node's own pose local, so picking folds the\n  // parent chain the same way the render walk does: one definition of both.\n  const paintedPoseOf = scenePaintedPoseOf(scene);\n  const poseOf = getPose\n    ? (node: PickCandidate<TPose>) => getPose(node.id)\n    : (node: PickCandidate<TPose>) => paintedPoseOf(node as never);\n\n  // Through `poseOf`, not the document pose: a derived node has to be tested\n  // where the renderer draws its dependencies, which is what an override says.\n  const childrenOf = (id: NodeId): readonly NodeId[] => scene.childrenOf(id);\n  const depOf = (id: NodeId): DerivedDep<TPose> | undefined => {\n    const dep = scene.get(id);\n    if (dep === undefined) return undefined;\n    return {\n      node: dep as Node<unknown, string, TPose>,\n      pose: poseOf(dep as never),\n      get path(): Path | null {\n        return resolveDerivedPath(dep as never, depOf, childrenOf);\n      },\n    };\n  };\n\n  const sceneDerivedPath = getPose ? null : sceneDerivedPathOf(scene);\n  const derivedPathOf = (node: PickCandidate<TPose>): Path | null => {\n    const n = node as unknown as Node<TData, TLayer, TPose>;\n    if (!sceneDerivedPath) return n.dependsOn === undefined ? null : resolveDerivedPath(n, depOf, childrenOf);\n    return showsComputedPath(scene, n) ? sceneDerivedPath(n) : null;\n  };\n\n  const planeOf = opts.camera ? scenePlaneOf(scene.layers, opts.camera) : null;\n\n  return {\n    ...(planeOf ? { planeOf } : {}),\n    order: () => scene.renderOrderNodes() as unknown as readonly PickCandidate<TPose>[],\n    derivedPathOf,\n    poseOf,\n    parentsOf(node) {\n      let parentId = (node as { parent?: string | null }).parent ?? null;\n      if (parentId === null) return EMPTY_PARENTS;\n      const chain: PickCandidate<TPose>[] = [];\n      const seen = new Set<string>();\n      while (parentId !== null) {\n        if (seen.has(parentId)) break;\n        seen.add(parentId);\n        const parent = scene.get(asNodeId(parentId));\n        if (!parent) break;\n        chain.push(parent as unknown as PickCandidate<TPose>);\n        parentId = parent.parent ?? null;\n      }\n      return chain;\n    },\n    // Absent entirely when nothing is faded, so the walk skips the gate.\n    ...(readAlpha ? { alphaOf: readAlpha } : {}),\n    isLocked: (node: PickCandidate<TPose>) => gates.locked(node.id),\n    isHidden: (node: PickCandidate<TPose>) => gates.hidden(node.id),\n    ...(annotations.size > 0 || layerIsPainted\n      ? {\n        layerIsPainted: (layer: string) =>\n          !annotations.has(layer) && (layerIsPainted === undefined || layerIsPainted(layer)),\n      }\n      : {}),\n  };\n}\n\n/** Each parallax layer's plane map under `camera`, or null when no layer is a\n *  plane — which keeps the per-layer lookup off the walk entirely. */\nexport function scenePlaneOf(\n  layers: readonly { id: string; parallax?: ParallaxOpts }[] | undefined,\n  camera: View,\n): ((layer: string) => PlaneMap | null) | null {\n  let maps: Map<string, PlaneMap> | null = null;\n  for (const l of layers ?? []) {\n    if (l.parallax) (maps ??= new Map()).set(l.id, planeMap(camera, l.parallax));\n  }\n  if (maps === null) return null;\n  const found = maps;\n  return (layer) => found.get(layer) ?? null;\n}\n\nexport { adapterPickSource } from './adapterPickSource';\n"],"mappings":"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"}

package/dist/canvas/planeClips.js

@@ -1,29 +1,46 @@
-import { planeMatrix as e, planeToPlane as t } from "../core/viewport/parallax.js";
-import { mat3 as n, transformPath as r } from "@weasel-js/geom";
+import { planeMatrix, planeToPlane } from "../core/viewport/parallax.js";
+import { mat3, transformPath } from "@weasel-js/geom";
+
 //#region src/canvas/planeClips.ts
-function i(n) {
-	if (n === null) return (e) => e;
-	let i = (e) => e === void 0 ? null : n(e), a = /* @__PURE__ */ new WeakMap();
-	return (n, o, s) => {
-		let c = i(s), l = t(i(o), c);
-		if (l === null) return n;
-		let u = a.get(n);
-		u === void 0 && a.set(n, u = /* @__PURE__ */ new Map());
-		let d = u.get(c);
-		return d === void 0 && u.set(c, d = r(n, e(l))), d;
+/**
+* Carries a container's clip into the world a descendant is drawn or picked
+* in. A clip is built from the container's pose, so it is in the container's
+* plane; a child on another plane reads it in its own. Null `planeOf` means no
+* layer is a plane, and every clip passes through untouched.
+*
+* Memoized per clip path and target plane, so a container with many children
+* on one other plane maps its clip once.
+*/
+function clipCarrier(planeOf) {
+	if (planeOf === null) return (clip) => clip;
+	const mapOf = (layer) => layer === void 0 ? null : planeOf(layer);
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (clip, fromLayer, toLayer) => {
+		const to = mapOf(toLayer);
+		const m = planeToPlane(mapOf(fromLayer), to);
+		if (m === null) return clip;
+		let byTarget = cache.get(clip);
+		if (byTarget === void 0) cache.set(clip, byTarget = /* @__PURE__ */ new Map());
+		let out = byTarget.get(to);
+		if (out === void 0) byTarget.set(to, out = transformPath(clip, planeMatrix(m)));
+		return out;
 	};
 }
-function a(r, i) {
-	let a = t(r, i);
-	return a === null ? void 0 : n.fromAffine(e(a));
+/** The group transform that draws `from`'s world inside `to`'s, where `null`
+*  is the camera's. Undefined when they are the same world. */
+function planeTransform(from, to) {
+	const m = planeToPlane(from, to);
+	return m === null ? void 0 : mat3.fromAffine(planeMatrix(m));
 }
-function o(n, i) {
-	let a = n;
-	if (i === null || !a || a.kind !== "polygon" && a.kind !== "rect") return n;
-	let o = t(i, null);
-	return o === null ? n : r(n, e(o));
+/** A path in a plane's world, in the camera's. Anything that is not a path
+*  passes through. */
+function pathFromPlane(path, m) {
+	const p = path;
+	if (m === null || !p || p.kind !== "polygon" && p.kind !== "rect") return path;
+	const back = planeToPlane(m, null);
+	return back === null ? path : transformPath(path, planeMatrix(back));
 }
-//#endregion
-export { i as clipCarrier, o as pathFromPlane, a as planeTransform };
 
+//#endregion
+export { clipCarrier, pathFromPlane, planeTransform };
 //# sourceMappingURL=planeClips.js.map

package/dist/canvas/planeClips.js.map

@@ -1 +1 @@
-{"version":3,"file":"planeClips.js","names":["clipCarrier","planeOf","clip","mapOf","layer","cache","to","toLayer","m","planeToPlane","fromLayer","byTarget","out","transformPath","planeMatrix","planeTransform","from","mat3","pathFromPlane","p","path","back"],"sources":["../../src/canvas/planeClips.ts"],"sourcesContent":["import { type Path, transformPath, mat3, type GlMat3 } from '@weasel-js/geom';\nimport { planeMatrix, planeToPlane, type PlaneMap } from 'core/viewport/parallax';\n\n/**\n * Carries a container's clip into the world a descendant is drawn or picked\n * in. A clip is built from the container's pose, so it is in the container's\n * plane; a child on another plane reads it in its own. Null `planeOf` means no\n * layer is a plane, and every clip passes through untouched.\n *\n * Memoized per clip path and target plane, so a container with many children\n * on one other plane maps its clip once.\n */\nexport function clipCarrier(\n  planeOf: ((layer: string) => PlaneMap | null) | null,\n): (clip: Path, fromLayer: string | undefined, toLayer: string | undefined) => Path {\n  if (planeOf === null) return (clip) => clip;\n  const mapOf = (layer: string | undefined) => (layer === undefined ? null : planeOf(layer));\n  const cache = new WeakMap<Path, Map<PlaneMap | null, Path>>();\n  return (clip, fromLayer, toLayer) => {\n    const to = mapOf(toLayer);\n    const m = planeToPlane(mapOf(fromLayer), to);\n    if (m === null) return clip;\n    let byTarget = cache.get(clip);\n    if (byTarget === undefined) cache.set(clip, byTarget = new Map());\n    let out = byTarget.get(to);\n    if (out === undefined) byTarget.set(to, out = transformPath(clip, planeMatrix(m)));\n    return out;\n  };\n}\n\n/** The group transform that draws `from`'s world inside `to`'s, where `null`\n *  is the camera's. Undefined when they are the same world. */\nexport function planeTransform(from: PlaneMap | null, to: PlaneMap | null): GlMat3 | undefined {\n  const m = planeToPlane(from, to);\n  return m === null ? undefined : mat3.fromAffine(planeMatrix(m));\n}\n\n/** A path in a plane's world, in the camera's. Anything that is not a path\n *  passes through. */\nexport function pathFromPlane<T>(path: T, m: PlaneMap | null): T {\n  const p = path as { kind?: string } | null;\n  if (m === null || !p || (p.kind !== 'polygon' && p.kind !== 'rect')) return path;\n  const back = planeToPlane(m, null);\n  return back === null ? path : transformPath(path as unknown as Path, planeMatrix(back)) as unknown as T;\n}\n"],"mappings":";;;AAYA,SAAgBA,EACd,GACkF;CAClF,IAAIC,MAAY,MAAM,QAAQ,MAASC;CACvC,IAAMC,KAAS,MAA+BC,MAAU,KAAA,IAAY,OAAOH,EAAQG,CAAK,GAClFC,oBAAQ,IAAI,QAA0C;CAC5D,QAAQ,GAAM,GAAW,MAAY;EACnC,IAAMC,IAAKH,EAAMI,CAAO,GAClBC,IAAIC,EAAaN,EAAMO,CAAS,GAAGJ,CAAE;EAC3C,IAAIE,MAAM,MAAM,OAAON;EACvB,IAAIS,IAAWN,EAAM,IAAIH,CAAI;EAC7B,AAAIS,MAAa,KAAA,KAAWN,EAAM,IAAIH,GAAM,oBAAW,IAAI,IAAI,CAAC;EAChE,IAAIU,IAAMD,EAAS,IAAIL,CAAE;EAEzB,OADIM,MAAQ,KAAA,KAAWD,EAAS,IAAIL,GAAI,IAAMO,EAAcX,GAAMY,EAAYN,CAAC,CAAC,CAAC,GAC1EI;CACT;AACF;AAIA,SAAgBG,EAAe,GAAuB,GAAyC;CAC7F,IAAMP,IAAIC,EAAaO,GAAMV,CAAE;CAC/B,OAAOE,MAAM,OAAO,KAAA,IAAYS,EAAK,WAAWH,EAAYN,CAAC,CAAC;AAChE;AAIA,SAAgBU,EAAiB,GAAS,GAAuB;CAC/D,IAAMC,IAAIC;CACV,IAAIZ,MAAM,QAAQ,CAACW,KAAMA,EAAE,SAAS,aAAaA,EAAE,SAAS,QAAS,OAAOC;CAC5E,IAAMC,IAAOZ,EAAaD,GAAG,IAAI;CACjC,OAAOa,MAAS,OAAOD,IAAOP,EAAcO,GAAyBN,EAAYO,CAAI,CAAC;AACxF"}
+{"version":3,"file":"planeClips.js","names":[],"sources":["../../src/canvas/planeClips.ts"],"sourcesContent":["import { type Path, transformPath, mat3, type GlMat3 } from '@weasel-js/geom';\nimport { planeMatrix, planeToPlane, type PlaneMap } from 'core/viewport/parallax';\n\n/**\n * Carries a container's clip into the world a descendant is drawn or picked\n * in. A clip is built from the container's pose, so it is in the container's\n * plane; a child on another plane reads it in its own. Null `planeOf` means no\n * layer is a plane, and every clip passes through untouched.\n *\n * Memoized per clip path and target plane, so a container with many children\n * on one other plane maps its clip once.\n */\nexport function clipCarrier(\n  planeOf: ((layer: string) => PlaneMap | null) | null,\n): (clip: Path, fromLayer: string | undefined, toLayer: string | undefined) => Path {\n  if (planeOf === null) return (clip) => clip;\n  const mapOf = (layer: string | undefined) => (layer === undefined ? null : planeOf(layer));\n  const cache = new WeakMap<Path, Map<PlaneMap | null, Path>>();\n  return (clip, fromLayer, toLayer) => {\n    const to = mapOf(toLayer);\n    const m = planeToPlane(mapOf(fromLayer), to);\n    if (m === null) return clip;\n    let byTarget = cache.get(clip);\n    if (byTarget === undefined) cache.set(clip, byTarget = new Map());\n    let out = byTarget.get(to);\n    if (out === undefined) byTarget.set(to, out = transformPath(clip, planeMatrix(m)));\n    return out;\n  };\n}\n\n/** The group transform that draws `from`'s world inside `to`'s, where `null`\n *  is the camera's. Undefined when they are the same world. */\nexport function planeTransform(from: PlaneMap | null, to: PlaneMap | null): GlMat3 | undefined {\n  const m = planeToPlane(from, to);\n  return m === null ? undefined : mat3.fromAffine(planeMatrix(m));\n}\n\n/** A path in a plane's world, in the camera's. Anything that is not a path\n *  passes through. */\nexport function pathFromPlane<T>(path: T, m: PlaneMap | null): T {\n  const p = path as { kind?: string } | null;\n  if (m === null || !p || (p.kind !== 'polygon' && p.kind !== 'rect')) return path;\n  const back = planeToPlane(m, null);\n  return back === null ? path : transformPath(path as unknown as Path, planeMatrix(back)) as unknown as T;\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAgB,YACd,SACkF;CAClF,IAAI,YAAY,MAAM,QAAQ,SAAS;CACvC,MAAM,SAAS,UAA+B,UAAU,SAAY,OAAO,QAAQ,KAAK;CACxF,MAAM,wBAAQ,IAAI,QAA0C;CAC5D,QAAQ,MAAM,WAAW,YAAY;EACnC,MAAM,KAAK,MAAM,OAAO;EACxB,MAAM,IAAI,aAAa,MAAM,SAAS,GAAG,EAAE;EAC3C,IAAI,MAAM,MAAM,OAAO;EACvB,IAAI,WAAW,MAAM,IAAI,IAAI;EAC7B,IAAI,aAAa,QAAW,MAAM,IAAI,MAAM,2BAAW,IAAI,IAAI,CAAC;EAChE,IAAI,MAAM,SAAS,IAAI,EAAE;EACzB,IAAI,QAAQ,QAAW,SAAS,IAAI,IAAI,MAAM,cAAc,MAAM,YAAY,CAAC,CAAC,CAAC;EACjF,OAAO;CACT;AACF;;;AAIA,SAAgB,eAAe,MAAuB,IAAyC;CAC7F,MAAM,IAAI,aAAa,MAAM,EAAE;CAC/B,OAAO,MAAM,OAAO,SAAY,KAAK,WAAW,YAAY,CAAC,CAAC;AAChE;;;AAIA,SAAgB,cAAiB,MAAS,GAAuB;CAC/D,MAAM,IAAI;CACV,IAAI,MAAM,QAAQ,CAAC,KAAM,EAAE,SAAS,aAAa,EAAE,SAAS,QAAS,OAAO;CAC5E,MAAM,OAAO,aAAa,GAAG,IAAI;CACjC,OAAO,SAAS,OAAO,OAAO,cAAc,MAAyB,YAAY,IAAI,CAAC;AACxF"}

package/dist/canvas/poseCascade.js

@@ -1,41 +1,65 @@
-import { poseDescriptorForNode as e, translatePoseViaDescriptor as t } from "../core/geometry/poseDescriptor.js";
+import { poseDescriptorForNode, translatePoseViaDescriptor } from "../core/geometry/poseDescriptor.js";
+
 //#region src/canvas/poseCascade.ts
-function n(e, t) {
-	let n = [], r = (t) => {
-		for (let i of e.childrenOf(t)) n.push(i), r(i);
+/** Every node under `id`, each after its parent. */
+function descendantsOf(scene, id) {
+	const out = [];
+	const collect = (root) => {
+		for (const child of scene.childrenOf(root)) {
+			out.push(child);
+			collect(child);
+		}
 	};
-	return r(t), n;
+	collect(id);
+	return out;
 }
-function r(r, i, a, o) {
+/**
+* How container `id`'s pose target carries its descendants where each holds a pose of its own
+* in the same space: `write` commits a pose and moves them, and while the container shows
+* somewhere else each is shown moved by as much.
+*/
+function containerCascade(scene, id, d, write) {
 	return {
-		write: o,
-		*beside(o) {
-			let s = r.get(i);
-			if (!s) return;
-			let c = e(a, s), l = c.getBounds(s.pose), u = c.getBounds(o);
-			for (let o of n(r, i)) {
-				let n = r.get(o);
-				n && (yield [o, t(n.pose, u.x - l.x, u.y - l.y, e(a, n))]);
+		write,
+		*beside(pose) {
+			const node = scene.get(id);
+			if (!node) return;
+			const g = poseDescriptorForNode(d, node);
+			const from = g.getBounds(node.pose);
+			const to = g.getBounds(pose);
+			for (const child of descendantsOf(scene, id)) {
+				const n = scene.get(child);
+				if (!n) continue;
+				yield [child, translatePoseViaDescriptor(n.pose, to.x - from.x, to.y - from.y, poseDescriptorForNode(d, n))];
 			}
 		}
 	};
 }
-function i(r, i) {
-	return (a, o) => {
-		let s = r.get(a);
-		if (!s || s.kind !== "container") return r.setPose(a, o);
-		let c = e(i, s), l = c.getBounds(s.pose), u = c.getBounds(o), d = u.x - l.x, f = u.y - l.y;
-		if (d === 0 && f === 0) return r.setPose(a, o);
-		r.batch("move container", () => {
-			r.setPose(a, o);
-			for (let o of n(r, a)) {
-				let n = r.get(o);
-				n && r.setPose(o, t(n.pose, d, f, e(i, n)));
+/**
+* `setPose` for a scene of absolute poses: posing a container moves every
+* descendant by as much, in one undo step.
+*/
+function cascadingSetPose(scene, d) {
+	return (id, pose) => {
+		const node = scene.get(id);
+		if (!node || node.kind !== "container") return scene.setPose(id, pose);
+		const g = poseDescriptorForNode(d, node);
+		const from = g.getBounds(node.pose);
+		const to = g.getBounds(pose);
+		const dx = to.x - from.x;
+		const dy = to.y - from.y;
+		if (dx === 0 && dy === 0) return scene.setPose(id, pose);
+		scene.batch("move container", () => {
+			scene.setPose(id, pose);
+			for (const child of descendantsOf(scene, id)) {
+				const n = scene.get(child);
+				if (!n) continue;
+				scene.setPose(child, translatePoseViaDescriptor(n.pose, dx, dy, poseDescriptorForNode(d, n)));
 			}
 		});
 	};
 }
-//#endregion
-export { i as cascadingSetPose, r as containerCascade, n as descendantsOf };
 
+//#endregion
+export { cascadingSetPose, containerCascade, descendantsOf };
 //# sourceMappingURL=poseCascade.js.map

package/dist/canvas/poseCascade.js.map

@@ -1 +1 @@
-{"version":3,"file":"poseCascade.js","names":["descendantsOf","out","collect","child","scene","root","id","containerCascade","node","g","poseDescriptorForNode","d","from","to","pose","translatePoseViaDescriptor","cascadingSetPose","dx","dy"],"sources":["../../src/canvas/poseCascade.ts"],"sourcesContent":["import { poseDescriptorForNode, translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { NodeId } from 'core/scene/types';\nimport type { PoseCascade } from '../animation/poseTarget';\n\n/** The part of a scene a container's cascade reads. */\ninterface CascadeScene<TPose> {\n  get(id: NodeId): { pose: TPose; kind?: 'leaf' | 'container' } | undefined;\n  childrenOf(id: NodeId): readonly NodeId[];\n}\n\n/** The part of a scene a cascading `setPose` writes. */\ninterface CascadeTarget<TPose> extends CascadeScene<TPose> {\n  setPose(id: NodeId, pose: TPose): void;\n  batch<T>(label: string, fn: () => T): T;\n}\n\n/** Every node under `id`, each after its parent. */\nexport function descendantsOf(scene: Pick<CascadeScene<unknown>, 'childrenOf'>, id: NodeId): NodeId[] {\n  const out: NodeId[] = [];\n  const collect = (root: NodeId): void => {\n    for (const child of scene.childrenOf(root)) {\n      out.push(child);\n      collect(child);\n    }\n  };\n  collect(id);\n  return out;\n}\n\n/**\n * How container `id`'s pose target carries its descendants where each holds a pose of its own\n * in the same space: `write` commits a pose and moves them, and while the container shows\n * somewhere else each is shown moved by as much.\n */\nexport function containerCascade<TPose>(\n  scene: CascadeScene<TPose>,\n  id: NodeId,\n  d: PoseDescriptor<TPose>,\n  write: (pose: TPose) => void,\n): PoseCascade<TPose> {\n  return {\n    write,\n    *beside(pose) {\n      const node = scene.get(id);\n      if (!node) return;\n      const g = poseDescriptorForNode(d, node);\n      const from = g.getBounds(node.pose);\n      const to = g.getBounds(pose);\n      for (const child of descendantsOf(scene, id)) {\n        const n = scene.get(child);\n        if (!n) continue;\n        yield [child, translatePoseViaDescriptor(n.pose, to.x - from.x, to.y - from.y, poseDescriptorForNode(d, n))];\n      }\n    },\n  };\n}\n\n/**\n * `setPose` for a scene of absolute poses: posing a container moves every\n * descendant by as much, in one undo step.\n */\nexport function cascadingSetPose<TPose>(\n  scene: CascadeTarget<TPose>,\n  d: PoseDescriptor<TPose>,\n): (id: NodeId, pose: TPose) => void {\n  return (id, pose) => {\n    const node = scene.get(id);\n    if (!node || node.kind !== 'container') return scene.setPose(id, pose);\n    const g = poseDescriptorForNode(d, node);\n    const from = g.getBounds(node.pose);\n    const to = g.getBounds(pose);\n    const dx = to.x - from.x;\n    const dy = to.y - from.y;\n    if (dx === 0 && dy === 0) return scene.setPose(id, pose);\n    scene.batch('move container', () => {\n      scene.setPose(id, pose);\n      for (const child of descendantsOf(scene, id)) {\n        const n = scene.get(child);\n        if (!n) continue;\n        scene.setPose(child, translatePoseViaDescriptor(n.pose, dx, dy, poseDescriptorForNode(d, n)));\n      }\n    });\n  };\n}\n"],"mappings":";;AAiBA,SAAgBA,EAAc,GAAkD,GAAsB;CACpG,IAAMC,IAAgB,CAAC,GACjBC,KAAW,MAAuB;EACtC,KAAK,IAAMC,KAASC,EAAM,WAAWC,CAAI,GAEvC,AADAJ,EAAI,KAAKE,CAAK,GACdD,EAAQC,CAAK;CAEjB;CAEA,OADAD,EAAQI,CAAE,GACHL;AACT;AAOA,SAAgBM,EACd,GACA,GACA,GACA,GACoB;CACpB,OAAO;EACL;EACA,CAAC,OAAO,GAAM;GACZ,IAAMC,IAAOJ,EAAM,IAAIE,CAAE;GACzB,IAAI,CAACE,GAAM;GACX,IAAMC,IAAIC,EAAsBC,GAAGH,CAAI,GACjCI,IAAOH,EAAE,UAAUD,EAAK,IAAI,GAC5BK,IAAKJ,EAAE,UAAUK,CAAI;GAC3B,KAAK,IAAMX,KAASH,EAAcI,GAAOE,CAAE,GAAG;IAC5C,IAAM,IAAIF,EAAM,IAAID,CAAK;IACzB,AAAK,MACL,MAAM,CAACA,GAAOY,EAA2B,EAAE,MAAMF,EAAG,IAAID,EAAK,GAAGC,EAAG,IAAID,EAAK,GAAGF,EAAsBC,GAAG,CAAC,CAAC,CAAC;GAC7G;EACF;CACF;AACF;AAMA,SAAgBK,EACd,GACA,GACmC;CACnC,QAAQ,GAAI,MAAS;EACnB,IAAMR,IAAOJ,EAAM,IAAIE,CAAE;EACzB,IAAI,CAACE,KAAQA,EAAK,SAAS,aAAa,OAAOJ,EAAM,QAAQE,GAAIQ,CAAI;EACrE,IAAML,IAAIC,EAAsBC,GAAGH,CAAI,GACjCI,IAAOH,EAAE,UAAUD,EAAK,IAAI,GAC5BK,IAAKJ,EAAE,UAAUK,CAAI,GACrBG,IAAKJ,EAAG,IAAID,EAAK,GACjBM,IAAKL,EAAG,IAAID,EAAK;EACvB,IAAIK,MAAO,KAAKC,MAAO,GAAG,OAAOd,EAAM,QAAQE,GAAIQ,CAAI;EACvD,EAAM,MAAM,wBAAwB;GAClC,EAAM,QAAQR,GAAIQ,CAAI;GACtB,KAAK,IAAMX,KAASH,EAAcI,GAAOE,CAAE,GAAG;IAC5C,IAAM,IAAIF,EAAM,IAAID,CAAK;IACzB,AAAK,KACLC,EAAM,QAAQD,GAAOY,EAA2B,EAAE,MAAME,GAAIC,GAAIR,EAAsBC,GAAG,CAAC,CAAC,CAAC;GAC9F;EACF,CAAC;CACH;AACF"}
+{"version":3,"file":"poseCascade.js","names":[],"sources":["../../src/canvas/poseCascade.ts"],"sourcesContent":["import { poseDescriptorForNode, translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { NodeId } from 'core/scene/types';\nimport type { PoseCascade } from '../animation/poseTarget';\n\n/** The part of a scene a container's cascade reads. */\ninterface CascadeScene<TPose> {\n  get(id: NodeId): { pose: TPose; kind?: 'leaf' | 'container' } | undefined;\n  childrenOf(id: NodeId): readonly NodeId[];\n}\n\n/** The part of a scene a cascading `setPose` writes. */\ninterface CascadeTarget<TPose> extends CascadeScene<TPose> {\n  setPose(id: NodeId, pose: TPose): void;\n  batch<T>(label: string, fn: () => T): T;\n}\n\n/** Every node under `id`, each after its parent. */\nexport function descendantsOf(scene: Pick<CascadeScene<unknown>, 'childrenOf'>, id: NodeId): NodeId[] {\n  const out: NodeId[] = [];\n  const collect = (root: NodeId): void => {\n    for (const child of scene.childrenOf(root)) {\n      out.push(child);\n      collect(child);\n    }\n  };\n  collect(id);\n  return out;\n}\n\n/**\n * How container `id`'s pose target carries its descendants where each holds a pose of its own\n * in the same space: `write` commits a pose and moves them, and while the container shows\n * somewhere else each is shown moved by as much.\n */\nexport function containerCascade<TPose>(\n  scene: CascadeScene<TPose>,\n  id: NodeId,\n  d: PoseDescriptor<TPose>,\n  write: (pose: TPose) => void,\n): PoseCascade<TPose> {\n  return {\n    write,\n    *beside(pose) {\n      const node = scene.get(id);\n      if (!node) return;\n      const g = poseDescriptorForNode(d, node);\n      const from = g.getBounds(node.pose);\n      const to = g.getBounds(pose);\n      for (const child of descendantsOf(scene, id)) {\n        const n = scene.get(child);\n        if (!n) continue;\n        yield [child, translatePoseViaDescriptor(n.pose, to.x - from.x, to.y - from.y, poseDescriptorForNode(d, n))];\n      }\n    },\n  };\n}\n\n/**\n * `setPose` for a scene of absolute poses: posing a container moves every\n * descendant by as much, in one undo step.\n */\nexport function cascadingSetPose<TPose>(\n  scene: CascadeTarget<TPose>,\n  d: PoseDescriptor<TPose>,\n): (id: NodeId, pose: TPose) => void {\n  return (id, pose) => {\n    const node = scene.get(id);\n    if (!node || node.kind !== 'container') return scene.setPose(id, pose);\n    const g = poseDescriptorForNode(d, node);\n    const from = g.getBounds(node.pose);\n    const to = g.getBounds(pose);\n    const dx = to.x - from.x;\n    const dy = to.y - from.y;\n    if (dx === 0 && dy === 0) return scene.setPose(id, pose);\n    scene.batch('move container', () => {\n      scene.setPose(id, pose);\n      for (const child of descendantsOf(scene, id)) {\n        const n = scene.get(child);\n        if (!n) continue;\n        scene.setPose(child, translatePoseViaDescriptor(n.pose, dx, dy, poseDescriptorForNode(d, n)));\n      }\n    });\n  };\n}\n"],"mappings":";;;;AAiBA,SAAgB,cAAc,OAAkD,IAAsB;CACpG,MAAM,MAAgB,CAAC;CACvB,MAAM,WAAW,SAAuB;EACtC,KAAK,MAAM,SAAS,MAAM,WAAW,IAAI,GAAG;GAC1C,IAAI,KAAK,KAAK;GACd,QAAQ,KAAK;EACf;CACF;CACA,QAAQ,EAAE;CACV,OAAO;AACT;;;;;;AAOA,SAAgB,iBACd,OACA,IACA,GACA,OACoB;CACpB,OAAO;EACL;EACA,CAAC,OAAO,MAAM;GACZ,MAAM,OAAO,MAAM,IAAI,EAAE;GACzB,IAAI,CAAC,MAAM;GACX,MAAM,IAAI,sBAAsB,GAAG,IAAI;GACvC,MAAM,OAAO,EAAE,UAAU,KAAK,IAAI;GAClC,MAAM,KAAK,EAAE,UAAU,IAAI;GAC3B,KAAK,MAAM,SAAS,cAAc,OAAO,EAAE,GAAG;IAC5C,MAAM,IAAI,MAAM,IAAI,KAAK;IACzB,IAAI,CAAC,GAAG;IACR,MAAM,CAAC,OAAO,2BAA2B,EAAE,MAAM,GAAG,IAAI,KAAK,GAAG,GAAG,IAAI,KAAK,GAAG,sBAAsB,GAAG,CAAC,CAAC,CAAC;GAC7G;EACF;CACF;AACF;;;;;AAMA,SAAgB,iBACd,OACA,GACmC;CACnC,QAAQ,IAAI,SAAS;EACnB,MAAM,OAAO,MAAM,IAAI,EAAE;EACzB,IAAI,CAAC,QAAQ,KAAK,SAAS,aAAa,OAAO,MAAM,QAAQ,IAAI,IAAI;EACrE,MAAM,IAAI,sBAAsB,GAAG,IAAI;EACvC,MAAM,OAAO,EAAE,UAAU,KAAK,IAAI;EAClC,MAAM,KAAK,EAAE,UAAU,IAAI;EAC3B,MAAM,KAAK,GAAG,IAAI,KAAK;EACvB,MAAM,KAAK,GAAG,IAAI,KAAK;EACvB,IAAI,OAAO,KAAK,OAAO,GAAG,OAAO,MAAM,QAAQ,IAAI,IAAI;EACvD,MAAM,MAAM,wBAAwB;GAClC,MAAM,QAAQ,IAAI,IAAI;GACtB,KAAK,MAAM,SAAS,cAAc,OAAO,EAAE,GAAG;IAC5C,MAAM,IAAI,MAAM,IAAI,KAAK;IACzB,IAAI,CAAC,GAAG;IACR,MAAM,QAAQ,OAAO,2BAA2B,EAAE,MAAM,IAAI,IAAI,sBAAsB,GAAG,CAAC,CAAC,CAAC;GAC9F;EACF,CAAC;CACH;AACF"}