@weasel-js/core 1.10.1 → 1.11.1

package/dist/canvas/overChildren.js

@@ -1,29 +1,40 @@
 //#region src/canvas/overChildren.ts
-var e = /* @__PURE__ */ new WeakSet();
-function t(t) {
-	let n = {
+var OVER = /* @__PURE__ */ new WeakSet();
+/**
+* `cmds` as one command a scene walk paints after the node's children. Return
+* it among a `drawOne`'s other commands. Outside a scene walk it is an
+* ordinary group, painted where it sits in the list.
+*/
+function overChildren(cmds) {
+	const group = {
 		kind: "group",
-		children: t
+		children: cmds
 	};
-	return e.add(n), n;
+	OVER.add(group);
+	return group;
 }
-function n(t) {
-	return e.has(t);
+/** Whether `cmd` came from {@link overChildren}. */
+function isOverChildren(cmd) {
+	return OVER.has(cmd);
 }
-var r = [];
-function i(e) {
-	if (!e.some(n)) return {
-		under: e,
-		over: r
+var NOTHING = [];
+/** `cmds` as what paints under the node's children and what paints over them.
+*  A list asking for nothing over comes back as `under` itself. */
+function splitOverChildren(cmds) {
+	if (!cmds.some(isOverChildren)) return {
+		under: cmds,
+		over: NOTHING
 	};
-	let t = [], i = [];
-	for (let r of e) n(r) ? i.push(...r.children) : t.push(r);
+	const under = [];
+	const over = [];
+	for (const cmd of cmds) if (isOverChildren(cmd)) over.push(...cmd.children);
+	else under.push(cmd);
 	return {
-		under: t,
-		over: i
+		under,
+		over
 	};
 }
-//#endregion
-export { n as isOverChildren, t as overChildren, i as splitOverChildren };
 
+//#endregion
+export { isOverChildren, overChildren, splitOverChildren };
 //# sourceMappingURL=overChildren.js.map

package/dist/canvas/overChildren.js.map

@@ -1 +1 @@
-{"version":3,"file":"overChildren.js","names":["OVER","overChildren","group","cmds","isOverChildren","cmd","NOTHING","splitOverChildren","under","over"],"sources":["../../src/canvas/overChildren.ts"],"sourcesContent":["/**\n * How a painter asks for part of a node's paint to land on top of the node's\n * children: a container's label, a frame's title, a badge. A scene walk draws\n * a node before its children, so anything else a container paints is covered\n * by them.\n */\nimport type { DrawCommand, GroupDrawCommand } from '@weasel-js/renderer';\n\nconst OVER = new WeakSet<object>();\n\n/**\n * `cmds` as one command a scene walk paints after the node's children. Return\n * it among a `drawOne`'s other commands. Outside a scene walk it is an\n * ordinary group, painted where it sits in the list.\n */\nexport function overChildren(cmds: DrawCommand[]): DrawCommand {\n  const group: GroupDrawCommand = { kind: 'group', children: cmds };\n  OVER.add(group);\n  return group;\n}\n\n/** Whether `cmd` came from {@link overChildren}. */\nexport function isOverChildren(cmd: DrawCommand): boolean {\n  return OVER.has(cmd);\n}\n\nconst NOTHING: DrawCommand[] = [];\n\n/** `cmds` as what paints under the node's children and what paints over them.\n *  A list asking for nothing over comes back as `under` itself. */\nexport function splitOverChildren(cmds: DrawCommand[]): { under: DrawCommand[]; over: DrawCommand[] } {\n  if (!cmds.some(isOverChildren)) return { under: cmds, over: NOTHING };\n  const under: DrawCommand[] = [];\n  const over: DrawCommand[] = [];\n  for (const cmd of cmds) {\n    if (isOverChildren(cmd)) over.push(...(cmd as GroupDrawCommand).children);\n    else under.push(cmd);\n  }\n  return { under, over };\n}\n"],"mappings":";AAQA,IAAMA,oBAAO,IAAI,QAAgB;AAOjC,SAAgBC,EAAa,GAAkC;CAC7D,IAAMC,IAA0B;EAAE,MAAM;EAAS,UAAUC;CAAK;CAEhE,OADAH,EAAK,IAAIE,CAAK,GACPA;AACT;AAGA,SAAgBE,EAAe,GAA2B;CACxD,OAAOJ,EAAK,IAAIK,CAAG;AACrB;AAEA,IAAMC,IAAyB,CAAC;AAIhC,SAAgBC,EAAkB,GAAoE;CACpG,IAAI,CAACJ,EAAK,KAAKC,CAAc,GAAG,OAAO;EAAE,OAAOD;EAAM,MAAMG;CAAQ;CACpE,IAAME,IAAuB,CAAC,GACxBC,IAAsB,CAAC;CAC7B,KAAK,IAAMJ,KAAOF,GAChB,AAAIC,EAAeC,CAAG,IAAGI,EAAK,KAAK,GAAIJ,EAAyB,QAAQ,IACnEG,EAAM,KAAKH,CAAG;CAErB,OAAO;EAAE;EAAO;CAAK;AACvB"}
+{"version":3,"file":"overChildren.js","names":[],"sources":["../../src/canvas/overChildren.ts"],"sourcesContent":["/**\n * How a painter asks for part of a node's paint to land on top of the node's\n * children: a container's label, a frame's title, a badge. A scene walk draws\n * a node before its children, so anything else a container paints is covered\n * by them.\n */\nimport type { DrawCommand, GroupDrawCommand } from '@weasel-js/renderer';\n\nconst OVER = new WeakSet<object>();\n\n/**\n * `cmds` as one command a scene walk paints after the node's children. Return\n * it among a `drawOne`'s other commands. Outside a scene walk it is an\n * ordinary group, painted where it sits in the list.\n */\nexport function overChildren(cmds: DrawCommand[]): DrawCommand {\n  const group: GroupDrawCommand = { kind: 'group', children: cmds };\n  OVER.add(group);\n  return group;\n}\n\n/** Whether `cmd` came from {@link overChildren}. */\nexport function isOverChildren(cmd: DrawCommand): boolean {\n  return OVER.has(cmd);\n}\n\nconst NOTHING: DrawCommand[] = [];\n\n/** `cmds` as what paints under the node's children and what paints over them.\n *  A list asking for nothing over comes back as `under` itself. */\nexport function splitOverChildren(cmds: DrawCommand[]): { under: DrawCommand[]; over: DrawCommand[] } {\n  if (!cmds.some(isOverChildren)) return { under: cmds, over: NOTHING };\n  const under: DrawCommand[] = [];\n  const over: DrawCommand[] = [];\n  for (const cmd of cmds) {\n    if (isOverChildren(cmd)) over.push(...(cmd as GroupDrawCommand).children);\n    else under.push(cmd);\n  }\n  return { under, over };\n}\n"],"mappings":";AAQA,IAAM,uBAAO,IAAI,QAAgB;;;;;;AAOjC,SAAgB,aAAa,MAAkC;CAC7D,MAAM,QAA0B;EAAE,MAAM;EAAS,UAAU;CAAK;CAChE,KAAK,IAAI,KAAK;CACd,OAAO;AACT;;AAGA,SAAgB,eAAe,KAA2B;CACxD,OAAO,KAAK,IAAI,GAAG;AACrB;AAEA,IAAM,UAAyB,CAAC;;;AAIhC,SAAgB,kBAAkB,MAAoE;CACpG,IAAI,CAAC,KAAK,KAAK,cAAc,GAAG,OAAO;EAAE,OAAO;EAAM,MAAM;CAAQ;CACpE,MAAM,QAAuB,CAAC;CAC9B,MAAM,OAAsB,CAAC;CAC7B,KAAK,MAAM,OAAO,MAChB,IAAI,eAAe,GAAG,GAAG,KAAK,KAAK,GAAI,IAAyB,QAAQ;MACnE,MAAM,KAAK,GAAG;CAErB,OAAO;EAAE;EAAO;CAAK;AACvB"}

package/dist/canvas/overlayRoleStrokes.js

@@ -1,5 +1,8 @@
 //#region src/canvas/overlayRoleStrokes.ts
-var e = {
+/** How each `polyline` overlay role reads. An action publishes the run and
+*  the word; this table is the whole of the paint, for the dispatcher overlay
+*  and for any tool previewing the same kind of run between gestures. */
+var OVERLAY_ROLE_STROKES = {
 	cut: {
 		paint: { color: "#e23b3b" },
 		width: 1,
@@ -9,9 +12,35 @@ var e = {
 		paint: { color: "#7ba7c7" },
 		width: 2,
 		dash: [4, 4]
+	},
+	falloff: {
+		paint: { color: "rgba(52, 120, 246, 0.28)" },
+		width: 10,
+		cap: "round",
+		join: "round"
+	},
+	measure: {
+		paint: { color: "#1f8fff" },
+		width: 1
+	},
+	lock: {
+		paint: { color: "#d9480f" },
+		width: 1.5
+	},
+	/** Where a dragged item would land. */
+	insert: {
+		paint: { color: "#1f8fff" },
+		width: 3,
+		cap: "round"
+	},
+	/** Where a dragged item is over but cannot land. */
+	refused: {
+		paint: { color: "#ff5d5d" },
+		width: 3,
+		cap: "round"
 	}
 };
-//#endregion
-export { e as OVERLAY_ROLE_STROKES };
 
+//#endregion
+export { OVERLAY_ROLE_STROKES };
 //# sourceMappingURL=overlayRoleStrokes.js.map

package/dist/canvas/overlayRoleStrokes.js.map

@@ -1 +1 @@
-{"version":3,"file":"overlayRoleStrokes.js","names":["OVERLAY_ROLE_STROKES"],"sources":["../../src/canvas/overlayRoleStrokes.ts"],"sourcesContent":["import type { CommandPaint, CommandStroke } from '@weasel-js/paint';\n\n/** How each `polyline` overlay role reads. An action publishes the run and\n *  the word; this table is the whole of the paint, for the dispatcher overlay\n *  and for any tool previewing the same kind of run between gestures. */\nexport const OVERLAY_ROLE_STROKES: Readonly<Record<string, CommandStroke & { paint: CommandPaint }>> = {\n  cut: { paint: { color: '#e23b3b' }, width: 1, dash: [6, 4] },\n  connector: { paint: { color: '#7ba7c7' }, width: 2, dash: [4, 4] },\n};\n"],"mappings":";AAKA,IAAaA,IAA0F;CACrG,KAAK;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;CAC3D,WAAW;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;AACnE"}
+{"version":3,"file":"overlayRoleStrokes.js","names":[],"sources":["../../src/canvas/overlayRoleStrokes.ts"],"sourcesContent":["import type { CommandPaint, CommandStroke } from '@weasel-js/paint';\n\n/** How each `polyline` overlay role reads. An action publishes the run and\n *  the word; this table is the whole of the paint, for the dispatcher overlay\n *  and for any tool previewing the same kind of run between gestures. */\nexport const OVERLAY_ROLE_STROKES: Readonly<Record<string, CommandStroke & { paint: CommandPaint }>> = {\n  cut: { paint: { color: '#e23b3b' }, width: 1, dash: [6, 4] },\n  connector: { paint: { color: '#7ba7c7' }, width: 2, dash: [4, 4] },\n  falloff: { paint: { color: 'rgba(52, 120, 246, 0.28)' }, width: 10, cap: 'round', join: 'round' },\n  measure: { paint: { color: '#1f8fff' }, width: 1 },\n  lock: { paint: { color: '#d9480f' }, width: 1.5 },\n  /** Where a dragged item would land. */\n  insert: { paint: { color: '#1f8fff' }, width: 3, cap: 'round' },\n  /** Where a dragged item is over but cannot land. */\n  refused: { paint: { color: '#ff5d5d' }, width: 3, cap: 'round' },\n};\n"],"mappings":";;;;AAKA,IAAa,uBAA0F;CACrG,KAAK;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;CAC3D,WAAW;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;CACjE,SAAS;EAAE,OAAO,EAAE,OAAO,2BAA2B;EAAG,OAAO;EAAI,KAAK;EAAS,MAAM;CAAQ;CAChG,SAAS;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;CAAE;CACjD,MAAM;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;CAAI;;CAEhD,QAAQ;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,KAAK;CAAQ;;CAE9D,SAAS;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,KAAK;CAAQ;AACjE"}

package/dist/canvas/paintCull.js

@@ -1,17 +1,29 @@
-import { boundsMissRect as e } from "@weasel-js/renderer";
-import { mat3 as t, poseFrameOf as n, viewToMat3 as r } from "@weasel-js/geom";
+import { boundsMissRect } from "@weasel-js/renderer";
+import { mat3 as mat3$1, poseFrameOf, viewToMat3 as viewToMat3$1 } from "@weasel-js/geom";
+
 //#region src/canvas/paintCull.ts
-function i(i, a, o) {
-	let s = a, c = r(a);
-	return (l, u, d = a) => {
-		d !== s && (s = d, c = r(d));
-		let f = i(l, u, d);
-		if (!f) return !1;
-		let p = n(u), m = p ? t.multiply(c, t.fromAffine(p)) : c;
-		return e(f, m, o);
+/**
+* A predicate true for the nodes whose paint cannot reach `rect` (screen
+* pixels) under `view`, by `paintBounds` taken through the pose frame
+* (`poseFrameOf`) `wrapNodeOutput` applies and then the view. A node `paintBounds` cannot
+* bound is never culled.
+*/
+function paintMissesView(paintBounds, view, rect) {
+	let last = view;
+	let toScreen = viewToMat3$1(view);
+	return (node, pose, layerView = view) => {
+		if (layerView !== last) {
+			last = layerView;
+			toScreen = viewToMat3$1(layerView);
+		}
+		const b = paintBounds(node, pose, layerView);
+		if (!b) return false;
+		const frame = poseFrameOf(pose);
+		const m = frame ? mat3$1.multiply(toScreen, mat3$1.fromAffine(frame)) : toScreen;
+		return boundsMissRect(b, m, rect);
 	};
 }
-//#endregion
-export { i as paintMissesView };
 
+//#endregion
+export { paintMissesView };
 //# sourceMappingURL=paintCull.js.map

package/dist/canvas/paintCull.js.map

@@ -1 +1 @@
-{"version":3,"file":"paintCull.js","names":["viewToMat3","mat3","mat3$1","viewToMat3$1","paintMissesView","last","view","toScreen","layerView","b","paintBounds","node","pose","frame","poseFrameOf","boundsMissRect","rect"],"sources":["../../src/canvas/paintCull.ts"],"sourcesContent":["import type { View } from 'core/viewport/view';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { poseFrameOf } from '@weasel-js/geom';\nimport { boundsMissRect, type CullRect } from '@weasel-js/renderer';\nimport { mat3, viewToMat3 } from '@weasel-js/geom';\n\n/** Where a node's paint can reach, before its pose frame — the scene\n *  slot's `paintBounds`. `null` means unknown, and the node is painted. */\nexport type PaintBoundsFn<TNode, TPose> = (node: TNode, pose: TPose, view: View) => Bounds | null;\n\n/**\n * A predicate true for the nodes whose paint cannot reach `rect` (screen\n * pixels) under `view`, by `paintBounds` taken through the pose frame\n * (`poseFrameOf`) `wrapNodeOutput` applies and then the view. A node `paintBounds` cannot\n * bound is never culled.\n */\nexport function paintMissesView<TNode, TPose>(\n  paintBounds: PaintBoundsFn<TNode, TPose>,\n  view: View,\n  rect: CullRect,\n): (node: TNode, pose: TPose, layerView?: View) => boolean {\n  // `layerView` is a parallax plane's own view; planes are few, so one slot\n  // of memo covers a walk that meets them layer by layer.\n  let last = view;\n  let toScreen = viewToMat3(view);\n  return (node, pose, layerView = view) => {\n    if (layerView !== last) { last = layerView; toScreen = viewToMat3(layerView); }\n    const b = paintBounds(node, pose, layerView);\n    if (!b) return false;\n    const frame = poseFrameOf(pose);\n    const m = frame ? mat3.multiply(toScreen, mat3.fromAffine(frame)) : toScreen;\n    return boundsMissRect(b, m, rect);\n  };\n}\n"],"mappings":";;;AAgBA,SAAgBI,EACd,GACA,GACA,GACyD;CAGzD,IAAIC,IAAOC,GACPC,IAAWP,EAAWM,CAAI;CAC9B,QAAQ,GAAM,GAAM,IAAYA,MAAS;EACvC,AAAIE,MAAcH,MAAQ,IAAOG,GAAW,IAAWR,EAAWQ,CAAS;EAC3E,IAAMC,IAAIC,EAAYC,GAAMC,GAAMJ,CAAS;EAC3C,IAAI,CAACC,GAAG,OAAO;EACf,IAAMI,IAAQC,EAAYF,CAAI,GACxB,IAAIC,IAAQZ,EAAK,SAASM,GAAUN,EAAK,WAAWY,CAAK,CAAC,IAAIN;EACpE,OAAOQ,EAAeN,GAAG,GAAGO,CAAI;CAClC;AACF"}
+{"version":3,"file":"paintCull.js","names":["viewToMat3","mat3"],"sources":["../../src/canvas/paintCull.ts"],"sourcesContent":["import type { View } from 'core/viewport/view';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { poseFrameOf } from '@weasel-js/geom';\nimport { boundsMissRect, type CullRect } from '@weasel-js/renderer';\nimport { mat3, viewToMat3 } from '@weasel-js/geom';\n\n/** Where a node's paint can reach, before its pose frame — the scene\n *  slot's `paintBounds`. `null` means unknown, and the node is painted. */\nexport type PaintBoundsFn<TNode, TPose> = (node: TNode, pose: TPose, view: View) => Bounds | null;\n\n/**\n * A predicate true for the nodes whose paint cannot reach `rect` (screen\n * pixels) under `view`, by `paintBounds` taken through the pose frame\n * (`poseFrameOf`) `wrapNodeOutput` applies and then the view. A node `paintBounds` cannot\n * bound is never culled.\n */\nexport function paintMissesView<TNode, TPose>(\n  paintBounds: PaintBoundsFn<TNode, TPose>,\n  view: View,\n  rect: CullRect,\n): (node: TNode, pose: TPose, layerView?: View) => boolean {\n  // `layerView` is a parallax plane's own view; planes are few, so one slot\n  // of memo covers a walk that meets them layer by layer.\n  let last = view;\n  let toScreen = viewToMat3(view);\n  return (node, pose, layerView = view) => {\n    if (layerView !== last) { last = layerView; toScreen = viewToMat3(layerView); }\n    const b = paintBounds(node, pose, layerView);\n    if (!b) return false;\n    const frame = poseFrameOf(pose);\n    const m = frame ? mat3.multiply(toScreen, mat3.fromAffine(frame)) : toScreen;\n    return boundsMissRect(b, m, rect);\n  };\n}\n"],"mappings":";;;;;;;;;;AAgBA,SAAgB,gBACd,aACA,MACA,MACyD;CAGzD,IAAI,OAAO;CACX,IAAI,WAAWA,aAAW,IAAI;CAC9B,QAAQ,MAAM,MAAM,YAAY,SAAS;EACvC,IAAI,cAAc,MAAM;GAAE,OAAO;GAAW,WAAWA,aAAW,SAAS;EAAG;EAC9E,MAAM,IAAI,YAAY,MAAM,MAAM,SAAS;EAC3C,IAAI,CAAC,GAAG,OAAO;EACf,MAAM,QAAQ,YAAY,IAAI;EAC9B,MAAM,IAAI,QAAQC,OAAK,SAAS,UAAUA,OAAK,WAAW,KAAK,CAAC,IAAI;EACpE,OAAO,eAAe,GAAG,GAAG,IAAI;CAClC;AACF"}

package/dist/canvas/paintedCursorLayer.js

@@ -1,60 +1,84 @@
-import { pathFromD as e } from "@weasel-js/geom";
-import { GLYPHS as t, chromeLineWidthScale as n, cursorPaintMatrix as r, cursorPaintOps as i, cursorWorldSize as a } from "@weasel-js/cursor";
+import { pathFromD } from "@weasel-js/geom";
+import { GLYPHS, chromeLineWidthScale, cursorPaintMatrix, cursorPaintOps, cursorWorldSize } from "@weasel-js/cursor";
+
 //#region src/canvas/paintedCursorLayer.ts
-var o = "painted-cursor", s = /* @__PURE__ */ new Map();
-function c(t) {
-	let n = s.get(t);
-	return n === void 0 && (n = e(t), s.set(t, n)), n;
+/**
+* The painted tier: draws a cursor glyph into the scene when it is too big,
+* or too tied to the view, to be a CSS `url()` cursor.
+*
+* Screen-space: the glyph is chrome at the pointer, so it must not pan or zoom
+* with the camera. What *does* track the camera is a world-sized glyph's size,
+* and `view.scale` is read for that.
+*/
+/** Layer id, so a consumer can order or hide it like any other. */
+var PAINTED_CURSOR_LAYER_ID = "painted-cursor";
+/** Handing the renderer the same `Path` object every frame lets its mesh cache hit. */
+var pathCache = /* @__PURE__ */ new Map();
+function pathFor(d) {
+	let p = pathCache.get(d);
+	if (p === void 0) {
+		p = pathFromD(d);
+		pathCache.set(d, p);
+	}
+	return p;
 }
-function l(e) {
+function commandFor(op) {
 	return {
 		kind: "path",
-		path: c(e.d),
-		...e.fill === void 0 ? {} : { fill: { paint: { color: e.fill } } },
-		...e.stroke === void 0 ? {} : { stroke: {
-			paint: { color: e.stroke.color },
-			width: e.stroke.width,
+		path: pathFor(op.d),
+		...op.fill !== void 0 ? { fill: { paint: { color: op.fill } } } : {},
+		...op.stroke !== void 0 ? { stroke: {
+			paint: { color: op.stroke.color },
+			width: op.stroke.width,
 			cap: "round",
 			join: "round"
-		} }
+		} } : {}
 	};
 }
-function u(e) {
+/**
+* A screen-space layer that draws the glyph `state` currently holds at the pointer,
+* or nothing when it holds none. `<Canvas>` mounts one over its own state already.
+*/
+function createPaintedCursorLayer(state) {
 	return {
-		id: o,
+		id: PAINTED_CURSOR_LAYER_ID,
 		label: "Painted cursor",
 		space: "screen",
-		draw: (o, s) => {
-			let c = e.current();
-			if (!c) return [];
-			let { cursor: u, at: d } = c, f = t[u.glyph];
-			if (!f) return [];
-			let p = (s.scale.x + s.scale.y) / 2, m = u.worldRadius !== void 0, h = m ? a(f, u.worldRadius, p) : u.size ?? 24;
-			if (!(h > 0) || !Number.isFinite(h)) return [];
-			let g = i(f, m ? { lineWidthScale: n(f, h) } : {}), [_, v, y, b, x, S] = r(f, {
-				size: h,
-				angle: u.angle,
-				at: d
+		draw: (_data, view) => {
+			const frame = state.current();
+			if (!frame) return [];
+			const { cursor, at } = frame;
+			const glyph = GLYPHS[cursor.glyph];
+			if (!glyph) return [];
+			const scale = (view.scale.x + view.scale.y) / 2;
+			const worldSized = cursor.worldRadius !== void 0;
+			const size = worldSized ? cursorWorldSize(glyph, cursor.worldRadius, scale) : cursor.size ?? 24;
+			if (!(size > 0) || !Number.isFinite(size)) return [];
+			const ops = cursorPaintOps(glyph, worldSized ? { lineWidthScale: chromeLineWidthScale(glyph, size) } : {});
+			const [a, b, c, d, e, f] = cursorPaintMatrix(glyph, {
+				size,
+				angle: cursor.angle,
+				at
 			});
 			return [{
 				kind: "group",
 				transform: new Float32Array([
-					_,
-					v,
-					0,
-					y,
+					a,
 					b,
 					0,
-					x,
-					S,
+					c,
+					d,
+					0,
+					e,
+					f,
 					1
 				]),
-				children: g.map(l)
+				children: ops.map(commandFor)
 			}];
 		}
 	};
 }
-//#endregion
-export { o as PAINTED_CURSOR_LAYER_ID, u as createPaintedCursorLayer };
 
+//#endregion
+export { PAINTED_CURSOR_LAYER_ID, createPaintedCursorLayer };
 //# sourceMappingURL=paintedCursorLayer.js.map

package/dist/canvas/paintedCursorLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"paintedCursorLayer.js","names":["PAINTED_CURSOR_LAYER_ID","pathCache","pathFor","p","d","pathFromD","commandFor","op","createPaintedCursorLayer","frame","state","glyph","GLYPHS","cursor","scale","view","worldSized","size","cursorWorldSize","ops","cursorPaintOps","chromeLineWidthScale","a","b","c","e","f","cursorPaintMatrix"],"sources":["../../src/canvas/paintedCursorLayer.ts"],"sourcesContent":["/**\n * The painted tier: draws a cursor glyph into the scene when it is too big,\n * or too tied to the view, to be a CSS `url()` cursor.\n *\n * Screen-space: the glyph is chrome at the pointer, so it must not pan or zoom\n * with the camera. What *does* track the camera is a world-sized glyph's size,\n * and `view.scale` is read for that.\n */\n\nimport { GLYPHS } from '@weasel-js/cursor';\nimport {\n  chromeLineWidthScale,\n  cursorPaintMatrix,\n  cursorPaintOps,\n  cursorWorldSize,\n} from '@weasel-js/cursor';\nimport type { CursorPaintOp } from '@weasel-js/cursor';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { pathFromD, type Path } from '@weasel-js/geom';\nimport type { PaintedCursorState } from '@weasel-js/cursor';\n\n/** Layer id, so a consumer can order or hide it like any other. */\nexport const PAINTED_CURSOR_LAYER_ID = 'painted-cursor';\n\n/** Handing the renderer the same `Path` object every frame lets its mesh cache hit. */\nconst pathCache = new Map<string, Path>();\nfunction pathFor(d: string): Path {\n  let p = pathCache.get(d);\n  if (p === undefined) {\n    p = pathFromD(d);\n    pathCache.set(d, p);\n  }\n  return p;\n}\n\nfunction commandFor(op: CursorPaintOp): PathDrawCommand {\n  return {\n    kind: 'path',\n    path: pathFor(op.d),\n    ...(op.fill !== undefined ? { fill: { paint: { color: op.fill } } } : {}),\n    ...(op.stroke !== undefined\n      ? {\n          stroke: {\n            paint: { color: op.stroke.color },\n            width: op.stroke.width,\n            cap: 'round' as const,\n            join: 'round' as const,\n          },\n        }\n      : {}),\n  };\n}\n\n/**\n * A screen-space layer that draws the glyph `state` currently holds at the pointer,\n * or nothing when it holds none. `<Canvas>` mounts one over its own state already.\n */\nexport function createPaintedCursorLayer(state: PaintedCursorState): RenderLayer<unknown> {\n  return {\n    id: PAINTED_CURSOR_LAYER_ID,\n    label: 'Painted cursor',\n    space: 'screen',\n    draw: (_data, view) => {\n      const frame = state.current();\n      if (!frame) return [];\n      const { cursor, at } = frame;\n      const glyph = GLYPHS[cursor.glyph];\n      if (!glyph) return [];\n\n      // A world-sized glyph holds its line weight in CSS px while its geometry\n      // grows — a ring at a 400px radius drawn with scaled weight is a filled\n      // blob. A single radius needs one scale factor, so average the axes.\n      const scale = (view.scale.x + view.scale.y) / 2;\n      const worldSized = cursor.worldRadius !== undefined;\n      const size = worldSized\n        ? cursorWorldSize(glyph, cursor.worldRadius as number, scale)\n        : (cursor.size ?? 24);\n      if (!(size > 0) || !Number.isFinite(size)) return [];\n\n      const ops = cursorPaintOps(\n        glyph,\n        worldSized ? { lineWidthScale: chromeLineWidthScale(glyph, size) } : {},\n      );\n      const [a, b, c, d, e, f] = cursorPaintMatrix(glyph, {\n        size,\n        angle: cursor.angle,\n        at,\n      });\n      // Column-major, the layout `GlMat3` documents.\n      const transform = new Float32Array([a, b, 0, c, d, 0, e, f, 1]);\n      const children: DrawCommand[] = ops.map(commandFor);\n      return [{ kind: 'group', transform, children }];\n    },\n  };\n}\n"],"mappings":";;;AAuBA,IAAaA,IAA0B,kBAGjCC,oBAAY,IAAI,IAAkB;AACxC,SAASC,EAAQ,GAAiB;CAChC,IAAIC,IAAIF,EAAU,IAAIG,CAAC;CAKvB,OAJID,MAAM,KAAA,MACR,IAAIE,EAAUD,CAAC,GACfH,EAAU,IAAIG,GAAGD,CAAC,IAEbA;AACT;AAEA,SAASG,EAAW,GAAoC;CACtD,OAAO;EACL,MAAM;EACN,MAAMJ,EAAQK,EAAG,CAAC;EAClB,GAAIA,EAAG,SAAS,KAAA,IAAsD,CAAC,IAA3C,EAAE,MAAM,EAAE,OAAO,EAAE,OAAOA,EAAG,KAAK,EAAE,EAAE;EAClE,GAAIA,EAAG,WAAW,KAAA,IASd,CAAC,IARD,EACE,QAAQ;GACN,OAAO,EAAE,OAAOA,EAAG,OAAO,MAAM;GAChC,OAAOA,EAAG,OAAO;GACjB,KAAK;GACL,MAAM;EACR,EACF;CAEN;AACF;AAMA,SAAgBC,EAAyB,GAAiD;CACxF,OAAO;EACL,IAAIR;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAO,MAAS;GACrB,IAAMS,IAAQC,EAAM,QAAQ;GAC5B,IAAI,CAACD,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,WAAQ,UAAOA,GACjBE,IAAQC,EAAOC,EAAO;GAC5B,IAAI,CAACF,GAAO,OAAO,CAAC;GAKpB,IAAMG,KAASC,EAAK,MAAM,IAAIA,EAAK,MAAM,KAAK,GACxCC,IAAaH,EAAO,gBAAgB,KAAA,GACpCI,IAAOD,IACTE,EAAgBP,GAAOE,EAAO,aAAuBC,CAAK,IACzDD,EAAO,QAAQ;GACpB,IAAI,EAAEI,IAAO,MAAM,CAAC,OAAO,SAASA,CAAI,GAAG,OAAO,CAAC;GAEnD,IAAME,IAAMC,EACVT,GACAK,IAAa,EAAE,gBAAgBK,EAAqBV,GAAOM,CAAI,EAAE,IAAI,CAAC,CACxE,GACM,CAACK,GAAGC,GAAGC,GAAGpB,GAAGqB,GAAGC,KAAKC,EAAkBhB,GAAO;IAClD;IACA,OAAOE,EAAO;IACd;GACF,CAAC;GAID,OAAO,CAAC;IAAE,MAAM;IAAS,WAAA,IAFH,aAAa;KAACS;KAAGC;KAAG;KAAGC;KAAGpB;KAAG;KAAGqB;KAAGC;KAAG;IAAC,CAEpC;IAAW,UADJP,EAAI,IAAIb,CACJ;GAAS,CAAC;EAChD;CACF;AACF"}
+{"version":3,"file":"paintedCursorLayer.js","names":[],"sources":["../../src/canvas/paintedCursorLayer.ts"],"sourcesContent":["/**\n * The painted tier: draws a cursor glyph into the scene when it is too big,\n * or too tied to the view, to be a CSS `url()` cursor.\n *\n * Screen-space: the glyph is chrome at the pointer, so it must not pan or zoom\n * with the camera. What *does* track the camera is a world-sized glyph's size,\n * and `view.scale` is read for that.\n */\n\nimport { GLYPHS } from '@weasel-js/cursor';\nimport {\n  chromeLineWidthScale,\n  cursorPaintMatrix,\n  cursorPaintOps,\n  cursorWorldSize,\n} from '@weasel-js/cursor';\nimport type { CursorPaintOp } from '@weasel-js/cursor';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { pathFromD, type Path } from '@weasel-js/geom';\nimport type { PaintedCursorState } from '@weasel-js/cursor';\n\n/** Layer id, so a consumer can order or hide it like any other. */\nexport const PAINTED_CURSOR_LAYER_ID = 'painted-cursor';\n\n/** Handing the renderer the same `Path` object every frame lets its mesh cache hit. */\nconst pathCache = new Map<string, Path>();\nfunction pathFor(d: string): Path {\n  let p = pathCache.get(d);\n  if (p === undefined) {\n    p = pathFromD(d);\n    pathCache.set(d, p);\n  }\n  return p;\n}\n\nfunction commandFor(op: CursorPaintOp): PathDrawCommand {\n  return {\n    kind: 'path',\n    path: pathFor(op.d),\n    ...(op.fill !== undefined ? { fill: { paint: { color: op.fill } } } : {}),\n    ...(op.stroke !== undefined\n      ? {\n          stroke: {\n            paint: { color: op.stroke.color },\n            width: op.stroke.width,\n            cap: 'round' as const,\n            join: 'round' as const,\n          },\n        }\n      : {}),\n  };\n}\n\n/**\n * A screen-space layer that draws the glyph `state` currently holds at the pointer,\n * or nothing when it holds none. `<Canvas>` mounts one over its own state already.\n */\nexport function createPaintedCursorLayer(state: PaintedCursorState): RenderLayer<unknown> {\n  return {\n    id: PAINTED_CURSOR_LAYER_ID,\n    label: 'Painted cursor',\n    space: 'screen',\n    draw: (_data, view) => {\n      const frame = state.current();\n      if (!frame) return [];\n      const { cursor, at } = frame;\n      const glyph = GLYPHS[cursor.glyph];\n      if (!glyph) return [];\n\n      // A world-sized glyph holds its line weight in CSS px while its geometry\n      // grows — a ring at a 400px radius drawn with scaled weight is a filled\n      // blob. A single radius needs one scale factor, so average the axes.\n      const scale = (view.scale.x + view.scale.y) / 2;\n      const worldSized = cursor.worldRadius !== undefined;\n      const size = worldSized\n        ? cursorWorldSize(glyph, cursor.worldRadius as number, scale)\n        : (cursor.size ?? 24);\n      if (!(size > 0) || !Number.isFinite(size)) return [];\n\n      const ops = cursorPaintOps(\n        glyph,\n        worldSized ? { lineWidthScale: chromeLineWidthScale(glyph, size) } : {},\n      );\n      const [a, b, c, d, e, f] = cursorPaintMatrix(glyph, {\n        size,\n        angle: cursor.angle,\n        at,\n      });\n      // Column-major, the layout `GlMat3` documents.\n      const transform = new Float32Array([a, b, 0, c, d, 0, e, f, 1]);\n      const children: DrawCommand[] = ops.map(commandFor);\n      return [{ kind: 'group', transform, children }];\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAuBA,IAAa,0BAA0B;;AAGvC,IAAM,4BAAY,IAAI,IAAkB;AACxC,SAAS,QAAQ,GAAiB;CAChC,IAAI,IAAI,UAAU,IAAI,CAAC;CACvB,IAAI,MAAM,QAAW;EACnB,IAAI,UAAU,CAAC;EACf,UAAU,IAAI,GAAG,CAAC;CACpB;CACA,OAAO;AACT;AAEA,SAAS,WAAW,IAAoC;CACtD,OAAO;EACL,MAAM;EACN,MAAM,QAAQ,GAAG,CAAC;EAClB,GAAI,GAAG,SAAS,SAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,KAAK,EAAE,EAAE,IAAI,CAAC;EACvE,GAAI,GAAG,WAAW,SACd,EACE,QAAQ;GACN,OAAO,EAAE,OAAO,GAAG,OAAO,MAAM;GAChC,OAAO,GAAG,OAAO;GACjB,KAAK;GACL,MAAM;EACR,EACF,IACA,CAAC;CACP;AACF;;;;;AAMA,SAAgB,yBAAyB,OAAiD;CACxF,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,OAAO,SAAS;GACrB,MAAM,QAAQ,MAAM,QAAQ;GAC5B,IAAI,CAAC,OAAO,OAAO,CAAC;GACpB,MAAM,EAAE,QAAQ,OAAO;GACvB,MAAM,QAAQ,OAAO,OAAO;GAC5B,IAAI,CAAC,OAAO,OAAO,CAAC;GAKpB,MAAM,SAAS,KAAK,MAAM,IAAI,KAAK,MAAM,KAAK;GAC9C,MAAM,aAAa,OAAO,gBAAgB;GAC1C,MAAM,OAAO,aACT,gBAAgB,OAAO,OAAO,aAAuB,KAAK,IACzD,OAAO,QAAQ;GACpB,IAAI,EAAE,OAAO,MAAM,CAAC,OAAO,SAAS,IAAI,GAAG,OAAO,CAAC;GAEnD,MAAM,MAAM,eACV,OACA,aAAa,EAAE,gBAAgB,qBAAqB,OAAO,IAAI,EAAE,IAAI,CAAC,CACxE;GACA,MAAM,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,kBAAkB,OAAO;IAClD;IACA,OAAO,OAAO;IACd;GACF,CAAC;GAID,OAAO,CAAC;IAAE,MAAM;IAAS,eAFH,aAAa;KAAC;KAAG;KAAG;KAAG;KAAG;KAAG;KAAG;KAAG;KAAG;IAAC,CAEpC;IAAW,UADJ,IAAI,IAAI,UACJ;GAAS,CAAC;EAChD;CACF;AACF"}

package/dist/canvas/pathOverlay.js

@@ -0,0 +1,83 @@
+import { commandFill, commandStroke } from "@weasel-js/renderer";
+import { boundsOfPath } from "@weasel-js/geom";
+import { createEmitter } from "@weasel-js/registry";
+
+//#region src/canvas/pathOverlay.ts
+/**
+* Paths that are no node, drawn over the scene: a region a tool would take,
+* the result an operation would make before it is applied.
+*/
+/**
+* The kit's roles: `'chrome'` for a path shown for reference, `'picked'` for
+* one a gesture has taken, and `'remove'` for one it would delete.
+*/
+var PATH_OVERLAY_ROLES = {
+	chrome: {
+		fill: { color: "rgba(164, 139, 212, 0.18)" },
+		stroke: { color: "#a48bd4" }
+	},
+	picked: {
+		fill: { color: "rgba(164, 139, 212, 0.45)" },
+		stroke: { color: "#7d5fc0" }
+	},
+	remove: {
+		fill: { color: "rgba(226, 59, 59, 0.35)" },
+		stroke: { color: "#e23b3b" }
+	}
+};
+/** A store of transient paths and the layer that draws it; hand the layer to
+*  a tool's `overlay` or a canvas's `layers`. */
+function createPathOverlay({ id, label = "Transient paths", roles }) {
+	const styles = {
+		...PATH_OVERLAY_ROLES,
+		...roles
+	};
+	const changed = createEmitter();
+	let current = [];
+	const set = (paths) => {
+		if (paths.length === 0 && current.length === 0) return;
+		current = paths;
+		changed.emit();
+	};
+	return {
+		get: () => current,
+		set,
+		clear: () => set([]),
+		layer: {
+			id,
+			label,
+			space: "world",
+			subscribe: changed.subscribe,
+			draw: () => current.flatMap(({ path, role = "chrome", paint }) => {
+				const style = styles[role] ?? styles["chrome"];
+				const outline = style.stroke ? { stroke: {
+					paint: style.stroke,
+					width: { px: 1 }
+				} } : {};
+				if (!paint) return [{
+					kind: "path",
+					path,
+					...style.fill ? { fill: { paint: style.fill } } : {},
+					...outline
+				}];
+				const box = boundsOfPath(path);
+				const fill = paint.fill && commandFill(paint.fill, box);
+				const stroke = paint.stroke && commandStroke(paint.stroke, box);
+				return [{
+					kind: "path",
+					path,
+					...fill ? { fill } : {},
+					...stroke ? { stroke } : {}
+				}, ...style.stroke ? [{
+					kind: "path",
+					path,
+					...outline
+				}] : []];
+			})
+		}
+	};
+}
+
+//#endregion
+export { PATH_OVERLAY_ROLES, createPathOverlay };
+//# sourceMappingURL=pathOverlay.js.map

package/dist/canvas/pathOverlay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathOverlay.js","names":[],"sources":["../../src/canvas/pathOverlay.ts"],"sourcesContent":["/**\n * Paths that are no node, drawn over the scene: a region a tool would take,\n * the result an operation would make before it is applied.\n */\nimport { boundsOfPath, type Path } from '@weasel-js/geom';\nimport type { CommandPaint } from '@weasel-js/paint';\nimport { commandFill, commandStroke, type DrawCommand } from '@weasel-js/renderer';\nimport type { OverlayRole } from '@weasel-js/routing';\nimport { createEmitter } from '@weasel-js/registry';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { PathPaint } from './nodeShapes/nodePaint';\n\n/** One path to draw, in world coordinates, and what it is. */\nexport interface TransientPath {\n  path: Path;\n  /** Omitted reads as `'chrome'`. */\n  role?: OverlayRole;\n  /** Paint the path wears, drawn in place of the role's fill and under the\n   *  role's outline: a result shown as it will look once made. */\n  paint?: PathPaint;\n}\n\n/** How one role reads. The stroke is one screen pixel wide at any zoom. */\nexport interface PathOverlayStyle {\n  fill?: CommandPaint;\n  stroke?: CommandPaint;\n}\n\n/**\n * The kit's roles: `'chrome'` for a path shown for reference, `'picked'` for\n * one a gesture has taken, and `'remove'` for one it would delete.\n */\nexport const PATH_OVERLAY_ROLES: Readonly<Record<string, PathOverlayStyle>> = {\n  chrome: { fill: { color: 'rgba(164, 139, 212, 0.18)' }, stroke: { color: '#a48bd4' } },\n  picked: { fill: { color: 'rgba(164, 139, 212, 0.45)' }, stroke: { color: '#7d5fc0' } },\n  remove: { fill: { color: 'rgba(226, 59, 59, 0.35)' }, stroke: { color: '#e23b3b' } },\n};\n\n/** The paths an overlay holds, and the layer that draws them. */\nexport interface PathOverlay {\n  get(): readonly TransientPath[];\n  /** Replace every path. */\n  set(paths: readonly TransientPath[]): void;\n  clear(): void;\n  /** A world-space layer drawing the paths in order, repainting on each change. */\n  layer: RenderLayer<unknown>;\n}\n\n/** Options for {@link createPathOverlay}. */\nexport interface PathOverlayOptions {\n  /** The layer's id; see `RenderLayer.id`. */\n  id: string;\n  label?: string;\n  /** Styles per role, merged over {@link PATH_OVERLAY_ROLES}. A role with\n   *  none paints as `'chrome'`. */\n  roles?: Readonly<Record<string, PathOverlayStyle>>;\n}\n\n/** A store of transient paths and the layer that draws it; hand the layer to\n *  a tool's `overlay` or a canvas's `layers`. */\nexport function createPathOverlay({ id, label = 'Transient paths', roles }: PathOverlayOptions): PathOverlay {\n  const styles = { ...PATH_OVERLAY_ROLES, ...roles };\n  const changed = createEmitter();\n  let current: readonly TransientPath[] = [];\n  const set = (paths: readonly TransientPath[]): void => {\n    if (paths.length === 0 && current.length === 0) return;\n    current = paths;\n    changed.emit();\n  };\n  return {\n    get: () => current,\n    set,\n    clear: () => set([]),\n    layer: {\n      id,\n      label,\n      space: 'world',\n      subscribe: changed.subscribe,\n      draw: () =>\n        current.flatMap(({ path, role = 'chrome', paint }): DrawCommand[] => {\n          const style = styles[role] ?? styles['chrome']!;\n          const outline = style.stroke ? { stroke: { paint: style.stroke, width: { px: 1 } } } : {};\n          if (!paint) return [{ kind: 'path', path, ...(style.fill ? { fill: { paint: style.fill } } : {}), ...outline }];\n          const box = boundsOfPath(path);\n          const fill = paint.fill && commandFill(paint.fill, box);\n          const stroke = paint.stroke && commandStroke(paint.stroke, box);\n          return [\n            { kind: 'path', path, ...(fill ? { fill } : {}), ...(stroke ? { stroke } : {}) },\n            ...(style.stroke ? [{ kind: 'path', path, ...outline } as DrawCommand] : []),\n          ];\n        }),\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAgCA,IAAa,qBAAiE;CAC5E,QAAQ;EAAE,MAAM,EAAE,OAAO,4BAA4B;EAAG,QAAQ,EAAE,OAAO,UAAU;CAAE;CACrF,QAAQ;EAAE,MAAM,EAAE,OAAO,4BAA4B;EAAG,QAAQ,EAAE,OAAO,UAAU;CAAE;CACrF,QAAQ;EAAE,MAAM,EAAE,OAAO,0BAA0B;EAAG,QAAQ,EAAE,OAAO,UAAU;CAAE;AACrF;;;AAwBA,SAAgB,kBAAkB,EAAE,IAAI,QAAQ,mBAAmB,SAA0C;CAC3G,MAAM,SAAS;EAAE,GAAG;EAAoB,GAAG;CAAM;CACjD,MAAM,UAAU,cAAc;CAC9B,IAAI,UAAoC,CAAC;CACzC,MAAM,OAAO,UAA0C;EACrD,IAAI,MAAM,WAAW,KAAK,QAAQ,WAAW,GAAG;EAChD,UAAU;EACV,QAAQ,KAAK;CACf;CACA,OAAO;EACL,WAAW;EACX;EACA,aAAa,IAAI,CAAC,CAAC;EACnB,OAAO;GACL;GACA;GACA,OAAO;GACP,WAAW,QAAQ;GACnB,YACE,QAAQ,SAAS,EAAE,MAAM,OAAO,UAAU,YAA2B;IACnE,MAAM,QAAQ,OAAO,SAAS,OAAO;IACrC,MAAM,UAAU,MAAM,SAAS,EAAE,QAAQ;KAAE,OAAO,MAAM;KAAQ,OAAO,EAAE,IAAI,EAAE;IAAE,EAAE,IAAI,CAAC;IACxF,IAAI,CAAC,OAAO,OAAO,CAAC;KAAE,MAAM;KAAQ;KAAM,GAAI,MAAM,OAAO,EAAE,MAAM,EAAE,OAAO,MAAM,KAAK,EAAE,IAAI,CAAC;KAAI,GAAG;IAAQ,CAAC;IAC9G,MAAM,MAAM,aAAa,IAAI;IAC7B,MAAM,OAAO,MAAM,QAAQ,YAAY,MAAM,MAAM,GAAG;IACtD,MAAM,SAAS,MAAM,UAAU,cAAc,MAAM,QAAQ,GAAG;IAC9D,OAAO,CACL;KAAE,MAAM;KAAQ;KAAM,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;KAAI,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;IAAG,GAC/E,GAAI,MAAM,SAAS,CAAC;KAAE,MAAM;KAAQ;KAAM,GAAG;IAAQ,CAAgB,IAAI,CAAC,CAC5E;GACF,CAAC;EACL;CACF;AACF"}

package/dist/canvas/pickReach.js

@@ -1,23 +1,40 @@
 //#region src/canvas/pickReach.ts
-function e(e, t, n, r, i, a, o) {
-	let s = (r, i) => {
-		let a = o.clipOf(i);
-		return a === null || r.clipAdmits(o.carry(a, i.layer, e.layer), e, t, n);
-	}, c = a && r.inCopy !== void 0 ? i() : null;
-	if (c === null || !c.some((e) => o.copiesOf(e).length > 0)) return r.hits(e, t, n) ? (c ?? i()).every((e) => s(r, e)) : !1;
-	let l = [...c].reverse(), u = (r, i) => {
-		if (r === l.length) return i.hits(e, t, n);
-		let a = l[r];
-		if (s(i, a) && u(r + 1, i)) return !0;
-		for (let e of o.copiesOf(a)) {
-			let t = i.inCopy?.(e);
-			if (t !== void 0 && s(t, a) && u(r + 1, t)) return !0;
+/**
+* Whether `q` lands on `node` anywhere it is painted: as authored, or in any
+* copy an ancestor draws of it. `parents` is innermost first.
+*
+* A copy is the clipped content transformed, so the query is carried into the
+* copy's source frame before the copying container's own clip is asked, and
+* every clip below it is asked in that frame too.
+*
+* `parents` is called only when the answer needs it — always when
+* `copying` says some container in the walk draws copies, otherwise only
+* after the node hits as authored.
+*/
+function reaches(node, pose, derived, q, parentsOf, copying, look) {
+	const admits = (query, ancestor) => {
+		const clip = look.clipOf(ancestor);
+		return clip === null || query.clipAdmits(look.carry(clip, ancestor.layer, node.layer), node, pose, derived);
+	};
+	const parents = copying && q.inCopy !== void 0 ? parentsOf() : null;
+	if (parents === null || !parents.some((a) => look.copiesOf(a).length > 0)) {
+		if (!q.hits(node, pose, derived)) return false;
+		return (parents ?? parentsOf()).every((a) => admits(q, a));
+	}
+	const outermostFirst = [...parents].reverse();
+	const from = (i, query) => {
+		if (i === outermostFirst.length) return query.hits(node, pose, derived);
+		const ancestor = outermostFirst[i];
+		if (admits(query, ancestor) && from(i + 1, query)) return true;
+		for (const m of look.copiesOf(ancestor)) {
+			const inCopy = query.inCopy?.(m);
+			if (inCopy !== void 0 && admits(inCopy, ancestor) && from(i + 1, inCopy)) return true;
 		}
-		return !1;
+		return false;
 	};
-	return u(0, r);
+	return from(0, q);
 }
-//#endregion
-export { e as reaches };
 
+//#endregion
+export { reaches };
 //# sourceMappingURL=pickReach.js.map

package/dist/canvas/pickReach.js.map

@@ -1 +1 @@
-{"version":3,"file":"pickReach.js","names":["reaches","admits","clip","look","ancestor","query","node","pose","derived","parents","copying","q","parentsOf","a","outermostFirst","from","i","m","inCopy"],"sources":["../../src/canvas/pickReach.ts"],"sourcesContent":["import type { Affine, Path } from '@weasel-js/geom';\nimport type { PickCandidate, PickQuery } from './pickWalk';\n\n/** What {@link reaches} needs from the walk, each memoized per walk there. */\nexport interface ReachLookups<TPose> {\n  /** An ancestor's own clip, or null. */\n  clipOf(ancestor: PickCandidate<TPose>): Path | null;\n  /** The maps from world into the source frame of each copy `ancestor` draws:\n   *  the inverses of its `copiesFromPose`. Empty when it draws none. */\n  copiesOf(ancestor: PickCandidate<TPose>): readonly Affine[];\n  /** A clip carried from its container's plane into the node's. */\n  carry(clip: Path, fromLayer: string | undefined, toLayer: string | undefined): Path;\n}\n\n/**\n * Whether `q` lands on `node` anywhere it is painted: as authored, or in any\n * copy an ancestor draws of it. `parents` is innermost first.\n *\n * A copy is the clipped content transformed, so the query is carried into the\n * copy's source frame before the copying container's own clip is asked, and\n * every clip below it is asked in that frame too.\n *\n * `parents` is called only when the answer needs it — always when\n * `copying` says some container in the walk draws copies, otherwise only\n * after the node hits as authored.\n */\nexport function reaches<TPose>(\n  node: PickCandidate<TPose>,\n  pose: TPose,\n  derived: Path | null | undefined,\n  q: PickQuery<TPose>,\n  parentsOf: () => readonly PickCandidate<TPose>[],\n  copying: boolean,\n  look: ReachLookups<TPose>,\n): boolean {\n  const admits = (query: PickQuery<TPose>, ancestor: PickCandidate<TPose>): boolean => {\n    const clip = look.clipOf(ancestor);\n    return clip === null\n      || query.clipAdmits(look.carry(clip, ancestor.layer, node.layer), node, pose, derived);\n  };\n\n  const parents = copying && q.inCopy !== undefined ? parentsOf() : null;\n  if (parents === null || !parents.some((a) => look.copiesOf(a).length > 0)) {\n    if (!q.hits(node, pose, derived)) return false;\n    return (parents ?? parentsOf()).every((a) => admits(q, a));\n  }\n\n  const outermostFirst = [...parents].reverse();\n  const from = (i: number, query: PickQuery<TPose>): boolean => {\n    if (i === outermostFirst.length) return query.hits(node, pose, derived);\n    const ancestor = outermostFirst[i];\n    if (admits(query, ancestor) && from(i + 1, query)) return true;\n    for (const m of look.copiesOf(ancestor)) {\n      const inCopy = query.inCopy?.(m);\n      if (inCopy !== undefined && admits(inCopy, ancestor) && from(i + 1, inCopy)) return true;\n    }\n    return false;\n  };\n  return from(0, q);\n}\n"],"mappings":";AA0BA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACS;CACT,IAAMC,KAAU,GAAyB,MAA4C;EACnF,IAAMC,IAAOC,EAAK,OAAOC,CAAQ;EACjC,OAAOF,MAAS,QACXG,EAAM,WAAWF,EAAK,MAAMD,GAAME,EAAS,OAAOE,EAAK,KAAK,GAAGA,GAAMC,GAAMC,CAAO;CACzF,GAEMC,IAAUC,KAAWC,EAAE,WAAW,KAAA,IAAYC,EAAU,IAAI;CAClE,IAAIH,MAAY,QAAQ,CAACA,EAAQ,MAAM,MAAMN,EAAK,SAASU,CAAC,CAAC,CAAC,SAAS,CAAC,GAEtE,OADKF,EAAE,KAAKL,GAAMC,GAAMC,CAAO,KACvBC,KAAWG,EAAU,EAAA,CAAG,OAAO,MAAMX,EAAOU,GAAGE,CAAC,CAAC,IADhB;CAI3C,IAAMC,IAAiB,CAAC,GAAGL,CAAO,CAAC,CAAC,QAAQ,GACtCM,KAAQ,GAAW,MAAqC;EAC5D,IAAIC,MAAMF,EAAe,QAAQ,OAAOT,EAAM,KAAKC,GAAMC,GAAMC,CAAO;EACtE,IAAMJ,IAAWU,EAAeE;EAChC,IAAIf,EAAOI,GAAOD,CAAQ,KAAKW,EAAKC,IAAI,GAAGX,CAAK,GAAG,OAAO;EAC1D,KAAK,IAAMY,KAAKd,EAAK,SAASC,CAAQ,GAAG;GACvC,IAAMc,IAASb,EAAM,SAASY,CAAC;GAC/B,IAAIC,MAAW,KAAA,KAAajB,EAAOiB,GAAQd,CAAQ,KAAKW,EAAKC,IAAI,GAAGE,CAAM,GAAG,OAAO;EACtF;EACA,OAAO;CACT;CACA,OAAOH,EAAK,GAAGJ,CAAC;AAClB"}
+{"version":3,"file":"pickReach.js","names":[],"sources":["../../src/canvas/pickReach.ts"],"sourcesContent":["import type { Affine, Path } from '@weasel-js/geom';\nimport type { PickCandidate, PickQuery } from './pickWalk';\n\n/** What {@link reaches} needs from the walk, each memoized per walk there. */\nexport interface ReachLookups<TPose> {\n  /** An ancestor's own clip, or null. */\n  clipOf(ancestor: PickCandidate<TPose>): Path | null;\n  /** The maps from world into the source frame of each copy `ancestor` draws:\n   *  the inverses of its `copiesFromPose`. Empty when it draws none. */\n  copiesOf(ancestor: PickCandidate<TPose>): readonly Affine[];\n  /** A clip carried from its container's plane into the node's. */\n  carry(clip: Path, fromLayer: string | undefined, toLayer: string | undefined): Path;\n}\n\n/**\n * Whether `q` lands on `node` anywhere it is painted: as authored, or in any\n * copy an ancestor draws of it. `parents` is innermost first.\n *\n * A copy is the clipped content transformed, so the query is carried into the\n * copy's source frame before the copying container's own clip is asked, and\n * every clip below it is asked in that frame too.\n *\n * `parents` is called only when the answer needs it — always when\n * `copying` says some container in the walk draws copies, otherwise only\n * after the node hits as authored.\n */\nexport function reaches<TPose>(\n  node: PickCandidate<TPose>,\n  pose: TPose,\n  derived: Path | null | undefined,\n  q: PickQuery<TPose>,\n  parentsOf: () => readonly PickCandidate<TPose>[],\n  copying: boolean,\n  look: ReachLookups<TPose>,\n): boolean {\n  const admits = (query: PickQuery<TPose>, ancestor: PickCandidate<TPose>): boolean => {\n    const clip = look.clipOf(ancestor);\n    return clip === null\n      || query.clipAdmits(look.carry(clip, ancestor.layer, node.layer), node, pose, derived);\n  };\n\n  const parents = copying && q.inCopy !== undefined ? parentsOf() : null;\n  if (parents === null || !parents.some((a) => look.copiesOf(a).length > 0)) {\n    if (!q.hits(node, pose, derived)) return false;\n    return (parents ?? parentsOf()).every((a) => admits(q, a));\n  }\n\n  const outermostFirst = [...parents].reverse();\n  const from = (i: number, query: PickQuery<TPose>): boolean => {\n    if (i === outermostFirst.length) return query.hits(node, pose, derived);\n    const ancestor = outermostFirst[i];\n    if (admits(query, ancestor) && from(i + 1, query)) return true;\n    for (const m of look.copiesOf(ancestor)) {\n      const inCopy = query.inCopy?.(m);\n      if (inCopy !== undefined && admits(inCopy, ancestor) && from(i + 1, inCopy)) return true;\n    }\n    return false;\n  };\n  return from(0, q);\n}\n"],"mappings":";;;;;;;;;;;;;AA0BA,SAAgB,QACd,MACA,MACA,SACA,GACA,WACA,SACA,MACS;CACT,MAAM,UAAU,OAAyB,aAA4C;EACnF,MAAM,OAAO,KAAK,OAAO,QAAQ;EACjC,OAAO,SAAS,QACX,MAAM,WAAW,KAAK,MAAM,MAAM,SAAS,OAAO,KAAK,KAAK,GAAG,MAAM,MAAM,OAAO;CACzF;CAEA,MAAM,UAAU,WAAW,EAAE,WAAW,SAAY,UAAU,IAAI;CAClE,IAAI,YAAY,QAAQ,CAAC,QAAQ,MAAM,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG;EACzE,IAAI,CAAC,EAAE,KAAK,MAAM,MAAM,OAAO,GAAG,OAAO;EACzC,QAAQ,WAAW,UAAU,EAAA,CAAG,OAAO,MAAM,OAAO,GAAG,CAAC,CAAC;CAC3D;CAEA,MAAM,iBAAiB,CAAC,GAAG,OAAO,CAAC,CAAC,QAAQ;CAC5C,MAAM,QAAQ,GAAW,UAAqC;EAC5D,IAAI,MAAM,eAAe,QAAQ,OAAO,MAAM,KAAK,MAAM,MAAM,OAAO;EACtE,MAAM,WAAW,eAAe;EAChC,IAAI,OAAO,OAAO,QAAQ,KAAK,KAAK,IAAI,GAAG,KAAK,GAAG,OAAO;EAC1D,KAAK,MAAM,KAAK,KAAK,SAAS,QAAQ,GAAG;GACvC,MAAM,SAAS,MAAM,SAAS,CAAC;GAC/B,IAAI,WAAW,UAAa,OAAO,QAAQ,QAAQ,KAAK,KAAK,IAAI,GAAG,MAAM,GAAG,OAAO;EACtF;EACA,OAAO;CACT;CACA,OAAO,KAAK,GAAG,CAAC;AAClB"}