@weasel-js/core 1.7.0 → 1.7.1

package/dist/features/paths/markerSites.js

@@ -0,0 +1,59 @@
+//#region src/features/paths/markerSites.ts
+var e = 1e-9;
+function t(t, n, r) {
+	let i = t.points[r * 2] - t.points[n * 2], a = t.points[r * 2 + 1] - t.points[n * 2 + 1], o = Math.hypot(i, a);
+	return o < e ? null : {
+		x: i / o,
+		y: a / o
+	};
+}
+function n(e, n, r) {
+	for (let i = n + 1; i < r; i++) if (t(e, n, i)) return i;
+	return -1;
+}
+function r(e, n) {
+	for (let r = n - 1; r >= 0; r--) if (t(e, r, n)) return r;
+	return -1;
+}
+function i(i, a) {
+	let o = [], s = i.points.length / 2;
+	if (s < 2) return o;
+	if (a.start && !i.closed) {
+		let e = n(i, 0, s), r = e >= 0 ? t(i, 0, e) : null;
+		r && o.push({
+			x: i.points[0],
+			y: i.points[1],
+			angle: Math.atan2(-r.y, -r.x),
+			role: "start"
+		});
+	}
+	if (a.mid) {
+		let a = i.anchorA, c = i.anchorB, l = i.anchorT;
+		if (a && c && l) for (let u = 1; u < s - 1; u++) {
+			if (a[u] !== c[u] || l[u] !== 0) continue;
+			let d = r(i, u), f = n(i, u, s);
+			if (d < 0 || f < 0) continue;
+			let p = t(i, d, u), m = t(i, u, f), h = p.x + m.x, g = p.y + m.y;
+			Math.hypot(h, g) < e && (h = p.x, g = p.y), o.push({
+				x: i.points[u * 2],
+				y: i.points[u * 2 + 1],
+				angle: Math.atan2(g, h),
+				role: "mid"
+			});
+		}
+	}
+	if (a.end && !i.closed) {
+		let e = s - 1, n = r(i, e), a = n >= 0 ? t(i, n, e) : null;
+		a && o.push({
+			x: i.points[e * 2],
+			y: i.points[e * 2 + 1],
+			angle: Math.atan2(a.y, a.x),
+			role: "end"
+		});
+	}
+	return o;
+}
+//#endregion
+export { i as markerSites };
+
+//# sourceMappingURL=markerSites.js.map

package/dist/features/paths/markerSites.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markerSites.js","names":["EPS","dir","dx","pl","j","i","dy","len","nextDistinct","k","n","prevDistinct","markerSites","out","want","d","A","B","T","p","q","inDir","outDir","bx","by","last"],"sources":["../../../src/features/paths/markerSites.ts"],"sourcesContent":["/**\n * Where a stroke's markers sit and which way they point.\n *\n * Computed from the *untrimmed* polyline: trimming moves the endpoint, and a\n * marker anchors to where the line was authored to end, not to where the\n * ribbon was cut.\n */\n\nimport type { Polyline } from '@weasel-js/geom/tessellate';\n\n/** One marker placement, in the polyline's own coordinates. */\nexport interface MarkerSite {\n  x: number;\n  y: number;\n  /** Radians. The direction the marker's +X axis should point — outward at a\n   *  start or end, along the bisector at an interior vertex. */\n  angle: number;\n  role: 'start' | 'mid' | 'end';\n}\n\n/** Which marker roles to place. `start` and `end` are ignored on a closed polyline. */\nexport interface MarkerSiteRequest {\n  start: boolean;\n  mid: boolean;\n  end: boolean;\n}\n\nconst EPS = 1e-9;\n\n/** Unit direction from point `i` to point `j`, or null if they coincide. */\nfunction dir(pl: Polyline, i: number, j: number): { x: number; y: number } | null {\n  const dx = pl.points[j * 2] - pl.points[i * 2];\n  const dy = pl.points[j * 2 + 1] - pl.points[i * 2 + 1];\n  const len = Math.hypot(dx, dy);\n  if (len < EPS) return null;\n  return { x: dx / len, y: dy / len };\n}\n\n/** The first index after `i` whose point differs from `i`'s. */\nfunction nextDistinct(pl: Polyline, i: number, n: number): number {\n  for (let k = i + 1; k < n; k++) if (dir(pl, i, k)) return k;\n  return -1;\n}\nfunction prevDistinct(pl: Polyline, i: number): number {\n  for (let k = i - 1; k >= 0; k--) if (dir(pl, k, i)) return k;\n  return -1;\n}\n\n/**\n * Where each requested marker sits on `pl` and the angle it points at.\n * Mid sites fall only on authored vertices, never on flattened curve samples,\n * and need the polyline to carry anchor data; without it no mid sites are returned.\n */\nexport function markerSites(pl: Polyline, want: MarkerSiteRequest): MarkerSite[] {\n  const out: MarkerSite[] = [];\n  const n = pl.points.length / 2;\n  if (n < 2) return out;\n\n  if (want.start && !pl.closed) {\n    const j = nextDistinct(pl, 0, n);\n    const d = j >= 0 ? dir(pl, 0, j) : null;\n    if (d) {\n      // Reversed, so a start head points away from the line body the way an\n      // end head does. SVG spells this `auto-start-reverse`; here it is the\n      // only behavior.\n      out.push({ x: pl.points[0], y: pl.points[1], angle: Math.atan2(-d.y, -d.x), role: 'start' });\n    }\n  }\n\n  if (want.mid) {\n    const A = pl.anchorA, B = pl.anchorB, T = pl.anchorT;\n    if (A && B && T) {\n      for (let i = 1; i < n - 1; i++) {\n        // An authored anchor, not a flattened curve sample.\n        if (A[i] !== B[i] || T[i] !== 0) continue;\n        const p = prevDistinct(pl, i);\n        const q = nextDistinct(pl, i, n);\n        if (p < 0 || q < 0) continue;\n        const inDir = dir(pl, p, i)!;\n        const outDir = dir(pl, i, q)!;\n        let bx = inDir.x + outDir.x;\n        let by = inDir.y + outDir.y;\n        // A 180° reversal leaves no bisector; fall back to the arriving direction.\n        if (Math.hypot(bx, by) < EPS) { bx = inDir.x; by = inDir.y; }\n        out.push({ x: pl.points[i * 2], y: pl.points[i * 2 + 1], angle: Math.atan2(by, bx), role: 'mid' });\n      }\n    }\n  }\n\n  if (want.end && !pl.closed) {\n    const last = n - 1;\n    const p = prevDistinct(pl, last);\n    const d = p >= 0 ? dir(pl, p, last) : null;\n    if (d) {\n      out.push({ x: pl.points[last * 2], y: pl.points[last * 2 + 1], angle: Math.atan2(d.y, d.x), role: 'end' });\n    }\n  }\n\n  return out;\n}\n"],"mappings":";AA2BA,IAAMA,IAAM;AAGZ,SAASC,EAAI,GAAc,GAAW,GAA4C;CAChF,IAAMC,IAAKC,EAAG,OAAOC,IAAI,KAAKD,EAAG,OAAOE,IAAI,IACtCC,IAAKH,EAAG,OAAOC,IAAI,IAAI,KAAKD,EAAG,OAAOE,IAAI,IAAI,IAC9CE,IAAM,KAAK,MAAML,GAAII,CAAE;CAE7B,OADIC,IAAMP,IAAY,OACf;EAAE,GAAGE,IAAKK;EAAK,GAAGD,IAAKC;CAAI;AACpC;AAGA,SAASC,EAAa,GAAc,GAAW,GAAmB;CAChE,KAAK,IAAIC,IAAIJ,IAAI,GAAGI,IAAIC,GAAG,KAAK,IAAIT,EAAIE,GAAIE,GAAGI,CAAC,GAAG,OAAOA;CAC1D,OAAO;AACT;AACA,SAASE,EAAa,GAAc,GAAmB;CACrD,KAAK,IAAIF,IAAIJ,IAAI,GAAGI,KAAK,GAAG,KAAK,IAAIR,EAAIE,GAAIM,GAAGJ,CAAC,GAAG,OAAOI;CAC3D,OAAO;AACT;AAOA,SAAgBG,EAAY,GAAc,GAAuC;CAC/E,IAAMC,IAAoB,CAAC,GACrBH,IAAIP,EAAG,OAAO,SAAS;CAC7B,IAAIO,IAAI,GAAG,OAAOG;CAElB,IAAIC,EAAK,SAAS,CAACX,EAAG,QAAQ;EAC5B,IAAMC,IAAII,EAAaL,GAAI,GAAGO,CAAC,GACzBK,IAAIX,KAAK,IAAIH,EAAIE,GAAI,GAAGC,CAAC,IAAI;EACnC,AAAIW,KAIFF,EAAI,KAAK;GAAE,GAAGV,EAAG,OAAO;GAAI,GAAGA,EAAG,OAAO;GAAI,OAAO,KAAK,MAAM,CAACY,EAAE,GAAG,CAACA,EAAE,CAAC;GAAG,MAAM;EAAQ,CAAC;CAE/F;CAEA,IAAID,EAAK,KAAK;EACZ,IAAME,IAAIb,EAAG,SAASc,IAAId,EAAG,SAASe,IAAIf,EAAG;EAC7C,IAAIa,KAAKC,KAAKC,GACZ,KAAK,IAAIb,IAAI,GAAGA,IAAIK,IAAI,GAAG,KAAK;GAE9B,IAAIM,EAAEX,OAAOY,EAAEZ,MAAMa,EAAEb,OAAO,GAAG;GACjC,IAAMc,IAAIR,EAAaR,GAAIE,CAAC,GACtBe,IAAIZ,EAAaL,GAAIE,GAAGK,CAAC;GAC/B,IAAIS,IAAI,KAAKC,IAAI,GAAG;GACpB,IAAMC,IAAQpB,EAAIE,GAAIgB,GAAGd,CAAC,GACpBiB,IAASrB,EAAIE,GAAIE,GAAGe,CAAC,GACvBG,IAAKF,EAAM,IAAIC,EAAO,GACtBE,IAAKH,EAAM,IAAIC,EAAO;GAG1B,AADI,KAAK,MAAMC,GAAIC,CAAE,IAAIxB,MAAO,IAAKqB,EAAM,GAAG,IAAKA,EAAM,IACzDR,EAAI,KAAK;IAAE,GAAGV,EAAG,OAAOE,IAAI;IAAI,GAAGF,EAAG,OAAOE,IAAI,IAAI;IAAI,OAAO,KAAK,MAAMmB,GAAID,CAAE;IAAG,MAAM;GAAM,CAAC;EACnG;CAEJ;CAEA,IAAIT,EAAK,OAAO,CAACX,EAAG,QAAQ;EAC1B,IAAMsB,IAAOf,IAAI,GACXS,IAAIR,EAAaR,GAAIsB,CAAI,GACzBV,IAAII,KAAK,IAAIlB,EAAIE,GAAIgB,GAAGM,CAAI,IAAI;EACtC,AAAIV,KACFF,EAAI,KAAK;GAAE,GAAGV,EAAG,OAAOsB,IAAO;GAAI,GAAGtB,EAAG,OAAOsB,IAAO,IAAI;GAAI,OAAO,KAAK,MAAMV,EAAE,GAAGA,EAAE,CAAC;GAAG,MAAM;EAAM,CAAC;CAE7G;CAEA,OAAOF;AACT"}

package/dist/features/paths/markers.js

@@ -0,0 +1,95 @@
+import { PATH_L as e, PATH_M as t, PATH_Z as n, rectToContour as r } from "@weasel-js/geom";
+//#region src/features/paths/markers.ts
+function i(r, i, a, o = 32) {
+	let s = new Uint8Array(o + 1), c = new Float32Array(o * 2);
+	s[0] = t, c[0] = r + a, c[1] = i;
+	for (let t = 1; t < o; t++) {
+		s[t] = e;
+		let n = t / o * Math.PI * 2;
+		c[t * 2] = r + a * Math.cos(n), c[t * 2 + 1] = i + a * Math.sin(n);
+	}
+	return s[o] = n, {
+		kind: "polygon",
+		commands: s,
+		coords: c,
+		fillRule: "nonzero"
+	};
+}
+function a(r, i, a) {
+	let o = a / 2, s = r - o, c = i - o, l = r + o, u = i + o;
+	return {
+		kind: "polygon",
+		commands: new Uint8Array([
+			t,
+			e,
+			e,
+			e,
+			n
+		]),
+		coords: new Float32Array([
+			s,
+			c,
+			l,
+			c,
+			l,
+			u,
+			s,
+			u
+		]),
+		fillRule: "nonzero"
+	};
+}
+function o(i, a, o, s) {
+	return {
+		kind: "polygon",
+		commands: new Uint8Array([
+			t,
+			e,
+			e,
+			e,
+			n
+		]),
+		coords: Float32Array.from(r(i, a, o, s)),
+		fillRule: "nonzero"
+	};
+}
+function s(r, i, a, s, c, l = 8) {
+	let u = Math.max(0, Math.min(c, Math.min(a, s) / 2));
+	if (u === 0) return o(r, i, a, s);
+	let d = Math.PI / 2, f = [
+		[
+			r + u,
+			i + u,
+			Math.PI
+		],
+		[
+			r + a - u,
+			i + u,
+			-d
+		],
+		[
+			r + a - u,
+			i + s - u,
+			0
+		],
+		[
+			r + u,
+			i + s - u,
+			d
+		]
+	], p = l + 1, m = f.length * p, h = new Uint8Array(m + 1), g = new Float32Array(m * 2), _ = 0;
+	for (let [n, r, i] of f) for (let a = 0; a <= l; a++) {
+		let o = i + a / l * d;
+		h[_] = _ === 0 ? t : e, g[_ * 2] = n + u * Math.cos(o), g[_ * 2 + 1] = r + u * Math.sin(o), _++;
+	}
+	return h[m] = n, {
+		kind: "polygon",
+		commands: h,
+		coords: g,
+		fillRule: "nonzero"
+	};
+}
+//#endregion
+export { i as circlePath, o as rectMarkerPath, s as roundRectPath, a as squarePath };
+
+//# sourceMappingURL=markers.js.map

package/dist/features/paths/markers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markers.js","names":["circlePath","cmds","segments","coords","PATH_M","cx","r","cy","i","PATH_L","theta","PATH_Z","squarePath","half","size","x0","y0","x1","y1","rectMarkerPath","rectToContour","x","y","width","height","roundRectPath","radius","HALF_PI","corners","perCorner","cornerSamples","count","start","s"],"sources":["../../../src/features/paths/markers.ts"],"sourcesContent":["/**\n * Ergonomic builders for tiny shape paths used by chrome / overlays / markers.\n *\n * These don't expand the `DrawCommand` union — they all return `PolygonPath`,\n * which `PathDrawCommand.path` already accepts. The wins are:\n *   - One place owns the math (`circlePath`'s segment loop, `squarePath`'s\n *     corner unrolling), so consumers don't reinvent it.\n *   - Default segment counts can be tuned in one place if \"circles look\n *     facety\" feedback ever surfaces.\n *\n * Not appropriate for *user-drawn* shapes (those have a pose and live in the\n * scene). Use these for selection chrome, anchor markers, rubber-band rects,\n * and similar transient/decorative geometry.\n */\n\nimport { PATH_L, PATH_M, PATH_Z, type PolygonPath, rectToContour } from '@weasel-js/geom';\n\n/**\n * N-segment polygon approximation of a circle. Default 32 segments → max\n * radial deviation of ≈0.005·r (≈0.05 px at r=10). Bump higher for large\n * filled circles where the facets become visible; the default is fine for\n * the handle-dot / anchor-dot scale we use everywhere.\n */\nexport function circlePath(cx: number, cy: number, r: number, segments = 32): PolygonPath {\n  const cmds = new Uint8Array(segments + 1);\n  const coords = new Float32Array(segments * 2);\n  cmds[0] = PATH_M;\n  coords[0] = cx + r;\n  coords[1] = cy;\n  for (let i = 1; i < segments; i++) {\n    cmds[i] = PATH_L;\n    const theta = (i / segments) * Math.PI * 2;\n    coords[i * 2] = cx + r * Math.cos(theta);\n    coords[i * 2 + 1] = cy + r * Math.sin(theta);\n  }\n  cmds[segments] = PATH_Z;\n  return { kind: 'polygon', commands: cmds, coords, fillRule: 'nonzero' };\n}\n\n/** Axis-aligned square centred at (cx, cy) with side length `size`. */\nexport function squarePath(cx: number, cy: number, size: number): PolygonPath {\n  const half = size / 2;\n  const x0 = cx - half, y0 = cy - half;\n  const x1 = cx + half, y1 = cy + half;\n  return {\n    kind: 'polygon',\n    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n    coords: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),\n    fillRule: 'nonzero',\n  };\n}\n\n/** Axis-aligned rectangle. Top-left at (x, y), width/height as given. */\nexport function rectMarkerPath(x: number, y: number, width: number, height: number): PolygonPath {\n  return {\n    kind: 'polygon',\n    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n    coords: Float32Array.from(rectToContour(x, y, width, height)),\n    fillRule: 'nonzero',\n  };\n}\n\n/**\n * Axis-aligned rounded rectangle. Top-left at (x, y); `r` is clamped to half\n * the shorter side. Each corner is `cornerSamples` line segments, matching\n * `circlePath`'s polygonal approximation — the default 8 gives the same\n * angular resolution as `circlePath`'s 32.\n */\nexport function roundRectPath(\n  x: number,\n  y: number,\n  width: number,\n  height: number,\n  r: number,\n  cornerSamples = 8,\n): PolygonPath {\n  const radius = Math.max(0, Math.min(r, Math.min(width, height) / 2));\n  if (radius === 0) return rectMarkerPath(x, y, width, height);\n\n  const HALF_PI = Math.PI / 2;\n  // Corner centers paired with the arc's start angle, walked clockwise in\n  // screen space from the top-left.\n  const corners: Array<[number, number, number]> = [\n    [x + radius, y + radius, Math.PI],\n    [x + width - radius, y + radius, -HALF_PI],\n    [x + width - radius, y + height - radius, 0],\n    [x + radius, y + height - radius, HALF_PI],\n  ];\n\n  const perCorner = cornerSamples + 1;\n  const count = corners.length * perCorner;\n  const cmds = new Uint8Array(count + 1);\n  const coords = new Float32Array(count * 2);\n  let i = 0;\n  for (const [cx, cy, start] of corners) {\n    for (let s = 0; s <= cornerSamples; s++) {\n      const theta = start + (s / cornerSamples) * HALF_PI;\n      cmds[i] = i === 0 ? PATH_M : PATH_L;\n      coords[i * 2] = cx + radius * Math.cos(theta);\n      coords[i * 2 + 1] = cy + radius * Math.sin(theta);\n      i++;\n    }\n  }\n  cmds[count] = PATH_Z;\n  return { kind: 'polygon', commands: cmds, coords, fillRule: 'nonzero' };\n}\n"],"mappings":";;AAuBA,SAAgBA,EAAW,GAAY,GAAY,GAAW,IAAW,IAAiB;CACxF,IAAMC,IAAO,IAAI,WAAWC,IAAW,CAAC,GAClCC,IAAS,IAAI,aAAaD,IAAW,CAAC;CAG5C,AAFA,EAAK,KAAKE,GACV,EAAO,KAAKC,IAAKC,GACjB,EAAO,KAAKC;CACZ,KAAK,IAAIC,IAAI,GAAGA,IAAIN,GAAU,KAAK;EACjC,EAAKM,KAAKC;EACV,IAAMC,IAASF,IAAIN,IAAY,KAAK,KAAK;EAEzC,AADA,EAAOM,IAAI,KAAKH,IAAKC,IAAI,KAAK,IAAII,CAAK,GACvC,EAAOF,IAAI,IAAI,KAAKD,IAAKD,IAAI,KAAK,IAAII,CAAK;CAC7C;CAEA,OADA,EAAKR,KAAYS,GACV;EAAE,MAAM;EAAW,UAAUV;EAAM;EAAQ,UAAU;CAAU;AACxE;AAGA,SAAgBW,EAAW,GAAY,GAAY,GAA2B;CAC5E,IAAMC,IAAOC,IAAO,GACdC,IAAKV,IAAKQ,GAAMG,IAAKT,IAAKM,GAC1BI,IAAKZ,IAAKQ,GAAMK,IAAKX,IAAKM;CAChC,OAAO;EACL,MAAM;EACN,UAAU,IAAI,WAAW;GAACT;GAAQK;GAAQA;GAAQA;GAAQE;EAAM,CAAC;EACjE,QAAQ,IAAI,aAAa;GAACI;GAAIC;GAAIC;GAAID;GAAIC;GAAIC;GAAIH;GAAIG;EAAE,CAAC;EACzD,UAAU;CACZ;AACF;AAGA,SAAgBC,EAAe,GAAW,GAAW,GAAe,GAA6B;CAC/F,OAAO;EACL,MAAM;EACN,UAAU,IAAI,WAAW;GAACf;GAAQK;GAAQA;GAAQA;GAAQE;EAAM,CAAC;EACjE,QAAQ,aAAa,KAAKS,EAAcC,GAAGC,GAAGC,GAAOC,CAAM,CAAC;EAC5D,UAAU;CACZ;AACF;AAQA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACA,IAAgB,GACH;CACb,IAAMC,IAAS,KAAK,IAAI,GAAG,KAAK,IAAIpB,GAAG,KAAK,IAAIiB,GAAOC,CAAM,IAAI,CAAC,CAAC;CACnE,IAAIE,MAAW,GAAG,OAAOP,EAAeE,GAAGC,GAAGC,GAAOC,CAAM;CAE3D,IAAMG,IAAU,KAAK,KAAK,GAGpBC,IAA2C;EAC/C;GAACP,IAAIK;GAAQJ,IAAII;GAAQ,KAAK;EAAE;EAChC;GAACL,IAAIE,IAAQG;GAAQJ,IAAII;GAAQ,CAACC;EAAO;EACzC;GAACN,IAAIE,IAAQG;GAAQJ,IAAIE,IAASE;GAAQ;EAAC;EAC3C;GAACL,IAAIK;GAAQJ,IAAIE,IAASE;GAAQC;EAAO;CAC3C,GAEME,IAAYC,IAAgB,GAC5BC,IAAQH,EAAQ,SAASC,GACzB5B,IAAO,IAAI,WAAW8B,IAAQ,CAAC,GAC/B5B,IAAS,IAAI,aAAa4B,IAAQ,CAAC,GACrCvB,IAAI;CACR,KAAK,IAAM,CAACH,GAAIE,GAAIyB,MAAUJ,GAC5B,KAAK,IAAIK,IAAI,GAAGA,KAAKH,GAAe,KAAK;EACvC,IAAMpB,IAAQsB,IAASC,IAAIH,IAAiBH;EAI5C,AAHA,EAAKnB,KAAKA,MAAM,IAAIJ,IAASK,GAC7B,EAAOD,IAAI,KAAKH,IAAKqB,IAAS,KAAK,IAAIhB,CAAK,GAC5C,EAAOF,IAAI,IAAI,KAAKD,IAAKmB,IAAS,KAAK,IAAIhB,CAAK,GAChD;CACF;CAGF,OADA,EAAKqB,KAASpB,GACP;EAAE,MAAM;EAAW,UAAUV;EAAM;EAAQ,UAAU;CAAU;AACxE"}

package/dist/features/paths/nearestAnchor.js

@@ -0,0 +1,36 @@
+import { scaleDelta as e } from "../../core/viewport/pxExtent.js";
+import { pathToAnchors as t } from "./anchors.js";
+//#region src/features/paths/nearestAnchor.ts
+function n(n, r, i, a, o) {
+	let s = null, c = i * i;
+	for (let { id: i, path: l } of n) {
+		let { anchors: n, closed: u } = t(l);
+		for (let t = 0; t < n.length; t++) {
+			let l = n[t];
+			for (let n = 0; n < l.length; n++) {
+				let d = l[n], f = e(d.x - r.x, d.y - r.y, a), p = f.x * f.x + f.y * f.y;
+				if (p > c || s !== null && p === c) continue;
+				let m = u[t] ? null : n === l.length - 1 ? "last" : n === 0 ? "first" : null, h = {
+					id: i,
+					sub: t,
+					idx: n,
+					x: d.x,
+					y: d.y,
+					end: m
+				};
+				(!o || o(h)) && (s = h, c = p);
+			}
+		}
+	}
+	return s;
+}
+function r(e) {
+	return e.map((e) => {
+		let { inHandle: t, outHandle: n, ...r } = e, i = { ...r };
+		return n && (i.inHandle = { ...n }), t && (i.outHandle = { ...t }), i;
+	}).reverse();
+}
+//#endregion
+export { n as nearestPathAnchor, r as reverseAnchors };
+
+//# sourceMappingURL=nearestAnchor.js.map

package/dist/features/paths/nearestAnchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearestAnchor.js","names":["nearestPathAnchor","best","bestD2","px","paths","pathToAnchors","path","sub","anchors","list","idx","a","s","scaleDelta","point","scale","d2","end","closed","hit","accept","reverseAnchors","rest","r","outHandle","inHandle"],"sources":["../../../src/features/paths/nearestAnchor.ts"],"sourcesContent":["/**\n * Anchor lookup across several paths, measured on screen: which existing\n * anchor is nearest a point, and whether it ends an open subpath. Feeds the\n * pen's anchor snapping and its pick-up of an open path's endpoint.\n */\n\nimport { scaleDelta, type Scale2 } from 'core/viewport/pxExtent';\nimport { pathToAnchors, type PenAnchor } from './anchors';\nimport type { PolygonPath } from '@weasel-js/geom';\n\n/** An existing anchor found near a point. */\nexport interface PathAnchorHit {\n  /** The id the path was supplied under. */\n  id: string;\n  /** Subpath index, then anchor index within that subpath. */\n  sub: number;\n  idx: number;\n  x: number;\n  y: number;\n  /** Which end of an open subpath this anchor is, or null when it is an\n   *  interior anchor or its subpath is closed. A lone anchor reads `'last'`. */\n  end: 'first' | 'last' | null;\n}\n\n/**\n * The anchor nearest `point` within a screen-space circle of radius `px`,\n * across every subpath of every path in `paths`. Paths and `point` share one\n * world frame; `scale` is the view's, so the radius stays round under\n * non-uniform zoom. `accept` narrows the candidates (endpoints only, say).\n * Ties go to the earlier path, so pass paths front-to-back.\n */\nexport function nearestPathAnchor(\n  paths: Iterable<{ id: string; path: PolygonPath }>,\n  point: { x: number; y: number },\n  px: number,\n  scale: Scale2,\n  accept?: (hit: PathAnchorHit) => boolean,\n): PathAnchorHit | null {\n  let best: PathAnchorHit | null = null;\n  let bestD2 = px * px;\n  for (const { id, path } of paths) {\n    const { anchors, closed } = pathToAnchors(path);\n    for (let sub = 0; sub < anchors.length; sub++) {\n      const list = anchors[sub];\n      for (let idx = 0; idx < list.length; idx++) {\n        const a = list[idx];\n        const s = scaleDelta(a.x - point.x, a.y - point.y, scale);\n        const d2 = s.x * s.x + s.y * s.y;\n        if (d2 > bestD2 || (best !== null && d2 === bestD2)) continue;\n        const end = closed[sub]\n          ? null\n          : idx === list.length - 1 ? 'last' : idx === 0 ? 'first' : null;\n        const hit: PathAnchorHit = { id, sub, idx, x: a.x, y: a.y, end };\n        if (accept && !accept(hit)) continue;\n        best = hit;\n        bestD2 = d2;\n      }\n    }\n  }\n  return best;\n}\n\n/** Reverse a subpath's direction without changing its shape: the anchor\n *  order flips and each anchor's in and out handles trade places. */\nexport function reverseAnchors<A extends PenAnchor>(anchors: readonly A[]): A[] {\n  return anchors.map((a) => {\n    const { inHandle, outHandle, ...rest } = a;\n    const r = { ...rest } as A;\n    if (outHandle) r.inHandle = { ...outHandle };\n    if (inHandle) r.outHandle = { ...inHandle };\n    return r;\n  }).reverse();\n}\n"],"mappings":";;;AA+BA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACsB;CACtB,IAAIC,IAA6B,MAC7BC,IAASC,IAAKA;CAClB,KAAK,IAAM,EAAE,OAAI,aAAUC,GAAO;EAChC,IAAM,EAAE,YAAS,cAAWC,EAAcC,CAAI;EAC9C,KAAK,IAAIC,IAAM,GAAGA,IAAMC,EAAQ,QAAQ,KAAO;GAC7C,IAAMC,IAAOD,EAAQD;GACrB,KAAK,IAAIG,IAAM,GAAGA,IAAMD,EAAK,QAAQ,KAAO;IAC1C,IAAME,IAAIF,EAAKC,IACTE,IAAIC,EAAWF,EAAE,IAAIG,EAAM,GAAGH,EAAE,IAAIG,EAAM,GAAGC,CAAK,GAClDC,IAAKJ,EAAE,IAAIA,EAAE,IAAIA,EAAE,IAAIA,EAAE;IAC/B,IAAII,IAAKd,KAAWD,MAAS,QAAQe,MAAOd,GAAS;IACrD,IAAMe,IAAMC,EAAOX,KACf,OACAG,MAAQD,EAAK,SAAS,IAAI,SAASC,MAAQ,IAAI,UAAU,MACvDS,IAAqB;KAAE;KAAI;KAAK;KAAK,GAAGR,EAAE;KAAG,GAAGA,EAAE;KAAG;IAAI;IAC/D,CAAI,MAAWS,EAAOD,CAAG,OACzB,IAAOA,GACP,IAASH;GACX;EACF;CACF;CACA,OAAOf;AACT;AAIA,SAAgBoB,EAAoC,GAA4B;CAC9E,OAAOb,EAAQ,KAAK,MAAM;EACxB,IAAM,EAAE,aAAU,cAAW,GAAGc,MAASX,GACnCY,IAAI,EAAE,GAAGD,EAAK;EAGpB,OAFIE,MAAW,EAAE,WAAW,EAAE,GAAGA,EAAU,IACvCC,MAAU,EAAE,YAAY,EAAE,GAAGA,EAAS,IACnCF;CACT,CAAC,CAAC,CAAC,QAAQ;AACb"}

package/dist/features/paths/originProjection.js

@@ -0,0 +1,16 @@
+import { boundsOfPath as e, translatePath as t } from "@weasel-js/geom";
+//#region src/features/paths/originProjection.ts
+var n = {
+	getOrigin: (t) => {
+		let n = e(t);
+		return {
+			x: n.x,
+			y: n.y
+		};
+	},
+	translate: t
+};
+//#endregion
+export { n as pathOriginProjection };
+
+//# sourceMappingURL=originProjection.js.map

package/dist/features/paths/originProjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"originProjection.js","names":["pathOriginProjection","b","boundsOfPath","path","translatePath"],"sources":["../../../src/features/paths/originProjection.ts"],"sourcesContent":["import { boundsOfPath, translatePath, type Path } from '@weasel-js/geom';\nimport type { OriginProjection } from 'interactions/gestures/shared/originProjection';\n\n/**\n * `OriginProjection` for `Path` poses. The \"origin\" is the top-left of the\n * path's AABB; `translate` shifts every coord by the requested delta. Pair\n * with `@weasel-js/guides`' `gridSnapStrategy` to grid-snap a Path's bounds top-left:\n *\n *     gridSnapStrategy<Path>(20, { origin: pathOriginProjection })\n */\nexport const pathOriginProjection: OriginProjection<Path> = {\n  getOrigin: (path) => {\n    const b = boundsOfPath(path);\n    return { x: b.x, y: b.y };\n  },\n  translate: translatePath,\n};\n"],"mappings":";;AAUA,IAAaA,IAA+C;CAC1D,YAAY,MAAS;EACnB,IAAMC,IAAIC,EAAaC,CAAI;EAC3B,OAAO;GAAE,GAAGF,EAAE;GAAG,GAAGA,EAAE;EAAE;CAC1B;CACA,WAAWG;AACb"}

package/dist/features/paths/pathEditingOverlayLayer.js

@@ -0,0 +1,137 @@
+import { pathToAnchors as e } from "./anchors.js";
+import { isVisibleFrom as t, previewSourcesFrom as n } from "../../canvas/drawEnvelope.js";
+import { circlePath as r, rectMarkerPath as i, squarePath as a } from "./markers.js";
+import { linePath as o } from "@weasel-js/geom";
+//#region src/features/paths/pathEditingOverlayLayer.ts
+var s = {
+	anchorSizePx: 8,
+	handleDotRadiusPx: 5,
+	anchorFill: "#ffffff",
+	anchorStroke: "#3478f6",
+	handleStroke: "#7da7e8",
+	handleDotFill: "rgba(125, 167, 232, 0.5)",
+	anchorFillSelected: "#3478f6",
+	marqueeStroke: "#3478f6",
+	marqueeFill: "rgba(52, 120, 246, 0.08)"
+}, c = /* @__PURE__ */ new Set();
+function l(e, t, n) {
+	return [(e - n.x) * n.scale.x, (t - n.y) * n.scale.y];
+}
+function u(u) {
+	let d = {
+		...s,
+		...u.style ?? {}
+	};
+	return {
+		id: "path-editing-overlay",
+		label: "Path editing",
+		space: "screen",
+		draw: (s, f) => {
+			let p = u.getEditingId();
+			if (!p) return [];
+			let m = t(s);
+			if (m && !m("path-edit.anchors")) return [];
+			let h = u.getPose(p, n(s), f);
+			if (!h || h.kind !== "polygon") return [];
+			let { anchors: g } = e(h), _ = u.getSelectedAnchors?.() ?? c, v = [], y = 0;
+			for (let e of g) for (let t of e) {
+				let e = _.has(y);
+				y++;
+				let [n, i] = l(t.x, t.y, f);
+				if (t.inHandle) {
+					let [e, a] = l(t.inHandle.x, t.inHandle.y, f);
+					v.push({
+						kind: "path",
+						path: o({
+							x: n,
+							y: i
+						}, {
+							x: e,
+							y: a
+						}),
+						stroke: {
+							paint: {
+								fill: "solid",
+								color: d.handleStroke
+							},
+							width: 1
+						}
+					}), v.push({
+						kind: "path",
+						path: r(e, a, d.handleDotRadiusPx),
+						fill: {
+							fill: "solid",
+							color: d.handleDotFill
+						}
+					});
+				}
+				if (t.outHandle) {
+					let [e, a] = l(t.outHandle.x, t.outHandle.y, f);
+					v.push({
+						kind: "path",
+						path: o({
+							x: n,
+							y: i
+						}, {
+							x: e,
+							y: a
+						}),
+						stroke: {
+							paint: {
+								fill: "solid",
+								color: d.handleStroke
+							},
+							width: 1
+						}
+					}), v.push({
+						kind: "path",
+						path: r(e, a, d.handleDotRadiusPx),
+						fill: {
+							fill: "solid",
+							color: d.handleDotFill
+						}
+					});
+				}
+				v.push({
+					kind: "path",
+					path: a(n, i, d.anchorSizePx),
+					fill: {
+						fill: "solid",
+						color: e ? d.anchorFillSelected : d.anchorFill
+					},
+					stroke: {
+						paint: {
+							fill: "solid",
+							color: d.anchorStroke
+						},
+						width: 1
+					}
+				});
+			}
+			let b = u.getMarquee?.(f);
+			if (b) {
+				let [e, t] = l(b.x, b.y, f), [n, r] = l(b.x + b.width, b.y + b.height, f);
+				v.push({
+					kind: "path",
+					path: i(e, t, n - e, r - t),
+					fill: {
+						fill: "solid",
+						color: d.marqueeFill
+					},
+					stroke: {
+						paint: {
+							fill: "solid",
+							color: d.marqueeStroke
+						},
+						width: 1
+					}
+				});
+			}
+			return v;
+		}
+	};
+}
+//#endregion
+export { u as createPathEditingOverlayLayer };
+
+//# sourceMappingURL=pathEditingOverlayLayer.js.map

package/dist/features/paths/pathEditingOverlayLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathEditingOverlayLayer.js","names":["DEFAULT_STYLE","EMPTY_SELECTION","w2s","wx","view","wy","createPathEditingOverlayLayer","style","opts","id","isVisible","isVisibleFrom","data","pose","previewSourcesFrom","pathToAnchors","selected","out","flat","sub","anchors","a","isSelected","ax","ay","hx","hy","linePath","circlePath","squarePath","marquee","mx","my","mx2","my2","rectMarkerPath"],"sources":["../../../src/features/paths/pathEditingOverlayLayer.ts"],"sourcesContent":["/**\n * Screen-space render layer for path-editing chrome — anchor squares,\n * tangent lines, and control-point dots for a polygon path that is the\n * current edit target. Companion to the kit's `editAnchorsAction` /\n * `buildAffordanceAt` hit-test wiring: the gesture works without chrome,\n * but a human user needs to see what's hittable.\n *\n * The layer reads the live edit target each frame via the supplied\n * `getEditingId()` + `getPose(...)` thunks, resolving the path against the\n * drawing view's own previews. Returns `[]` when no editing target is set or\n * the target isn't a polygon — the layer never throws.\n *\n * Anchors render as small white-filled stroked squares — filled solid\n * when selected; control points as small filled circles connected to\n * their anchor by a thin stem line. This is the kit's only anchor\n * chrome; the pen tool's parallel overlay and `apps/draw`'s\n * mode-decoration painter both drew the same thing from different state\n * and have been removed.\n *\n * All coordinates are projected via `worldToScreen` so the marker sizes\n * stay constant regardless of zoom.\n */\n\nimport type { DrawCommand } from '../../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { type Path, type PolygonPath, linePath } from '@weasel-js/geom';\nimport type { GesturePreviewSource } from 'canvas/gestureBounds';\nimport { previewSourcesFrom, isVisibleFrom } from 'canvas/drawEnvelope';\nimport { pathToAnchors } from './anchors';\nimport { circlePath, rectMarkerPath, squarePath } from './markers';\n\ninterface View { x: number; y: number; scale: { x: number; y: number } }\n\n/** Options for `createPathEditingOverlayLayer`. Everything is read per frame,\n *  so the layer follows a changing edit target without being rebuilt. */\nexport interface CreatePathEditingOverlayLayerOptions {\n  /** Returns the id of the polygon currently in anchor-edit mode, or null\n   *  when no node is being edited. Read each frame so live selection /\n   *  edit-target changes show up without re-creating the layer. */\n  getEditingId(): string | null;\n  /**\n   * Returns the pose for an id, or null if the node has been deleted.\n   * Non-polygon poses are tolerated (the layer no-ops on them).\n   *\n   * `previews` are the drawing view's in-flight preview surfaces, so an\n   * anchor dragged in one panel does not move in the others. Resolve against\n   * them before falling back to the committed pose.\n   *\n   * `view` is the drawing view's camera. Answer in its world: a node whose\n   * layer is a parallax plane stores its path in the plane's.\n   */\n  getPose(id: string, previews: readonly GesturePreviewSource[], view: View): Path | null;\n  /** Flat indices of the selected anchors. Selected anchors render\n   *  filled; unselected ones hollow — the standard vector-editor cue for\n   *  \"these are what the arrow keys and Delete will act on\". Omit when\n   *  the consumer has no anchor selection to show. */\n  getSelectedAnchors?(): ReadonlySet<number>;\n  /** In-flight anchor-marquee rect in world coords, or null. Drawn as a\n   *  rubber band while `marqueeAnchorsAction` is dragging. */\n  getMarquee?(view: View): { x: number; y: number; width: number; height: number } | null;\n  /** Optional styling overrides. */\n  style?: PathEditingOverlayStyle;\n}\n\n/** Appearance of the anchor and handle markers. */\nexport interface PathEditingOverlayStyle {\n  anchorSizePx?: number;\n  handleDotRadiusPx?: number;\n  anchorFill?: string;\n  anchorStroke?: string;\n  handleStroke?: string;\n  /** Fill of the control-point circle. Defaults to the handleStroke color\n   *  at 50% alpha — keeps the marker readable but lets the underlying\n   *  curve / background show through, which matches Figma's \"translucent\n   *  handle dot\" idiom. */\n  handleDotFill?: string;\n  /** Fill of a selected anchor square. Defaults to the anchor stroke\n   *  color, so selection reads as \"the marker filled in\". */\n  anchorFillSelected?: string;\n  /** Stroke of the marquee rubber band. */\n  marqueeStroke?: string;\n  /** Fill of the marquee rubber band. */\n  marqueeFill?: string;\n}\n\nconst DEFAULT_STYLE: Required<PathEditingOverlayStyle> = {\n  anchorSizePx: 8,\n  // Control-point markers were 2px radius (4px diameter) — too small to\n  // grab reliably with a mouse and visually lost against the curve.\n  // 5px radius (10px diameter) is closer to typical Figma / Illustrator.\n  handleDotRadiusPx: 5,\n  anchorFill: '#ffffff',\n  anchorStroke: '#3478f6',\n  handleStroke: '#7da7e8',\n  // 50%-opacity handle-stroke color. #7da7e8 → rgba(125, 167, 232, 0.5).\n  handleDotFill: 'rgba(125, 167, 232, 0.5)',\n  anchorFillSelected: '#3478f6',\n  marqueeStroke: '#3478f6',\n  marqueeFill: 'rgba(52, 120, 246, 0.08)',\n};\n\nconst EMPTY_SELECTION: ReadonlySet<number> = new Set();\n\nfunction w2s(wx: number, wy: number, view: View): [number, number] {\n  return [(wx - view.x) * view.scale.x, (wy - view.y) * view.scale.y];\n}\n\n/** Render layer that draws the anchors and control handles of the path\n *  currently being anchor-edited. Draws nothing when no path is being\n *  edited. */\nexport function createPathEditingOverlayLayer(\n  opts: CreatePathEditingOverlayLayerOptions,\n): RenderLayer<unknown> {\n  const style = { ...DEFAULT_STYLE, ...(opts.style ?? {}) };\n\n  return {\n    id: 'path-editing-overlay',\n    label: 'Path editing',\n    space: 'screen',\n    draw: (data, view) => {\n      const id = opts.getEditingId();\n      if (!id) return [];\n      // Chrome-caps gate off the envelope, so paint and the anchor hit-test in\n      // `affordanceAt` consult the same rule — otherwise a consumer that hides\n      // the chrome still gets grabbable invisible anchors, or vice versa.\n      const isVisible = isVisibleFrom(data);\n      if (isVisible && !isVisible('path-edit.anchors')) return [];\n      const pose = opts.getPose(id, previewSourcesFrom(data), view);\n      if (!pose || pose.kind !== 'polygon') return [];\n\n      const { anchors } = pathToAnchors(pose as PolygonPath);\n      const selected = opts.getSelectedAnchors?.() ?? EMPTY_SELECTION;\n      const out: DrawCommand[] = [];\n\n      // Flat anchor index, incremented in walk order so it lines up with\n      // `enumerateAnchors` — the same numbering the affordances and the\n      // anchor selection use. See `anchorEdits` for why they agree.\n      let flat = 0;\n      for (const sub of anchors) {\n        for (const a of sub) {\n          const isSelected = selected.has(flat);\n          flat++;\n          const [ax, ay] = w2s(a.x, a.y, view);\n\n          // Tangent stems + handle dots first so the anchor square paints on top.\n          if (a.inHandle) {\n            const [hx, hy] = w2s(a.inHandle.x, a.inHandle.y, view);\n            out.push({\n              kind: 'path',\n              path: linePath({ x: ax, y: ay }, { x: hx, y: hy }),\n              stroke: { paint: { fill: 'solid', color: style.handleStroke }, width: 1 },\n            });\n            out.push({\n              kind: 'path',\n              path: circlePath(hx, hy, style.handleDotRadiusPx),\n              fill: { fill: 'solid', color: style.handleDotFill },\n            });\n          }\n          if (a.outHandle) {\n            const [hx, hy] = w2s(a.outHandle.x, a.outHandle.y, view);\n            out.push({\n              kind: 'path',\n              path: linePath({ x: ax, y: ay }, { x: hx, y: hy }),\n              stroke: { paint: { fill: 'solid', color: style.handleStroke }, width: 1 },\n            });\n            out.push({\n              kind: 'path',\n              path: circlePath(hx, hy, style.handleDotRadiusPx),\n              fill: { fill: 'solid', color: style.handleDotFill },\n            });\n          }\n\n          // Anchor square — drawn on top.\n          out.push({\n            kind: 'path',\n            path: squarePath(ax, ay, style.anchorSizePx),\n            fill: {\n              fill: 'solid',\n              color: isSelected ? style.anchorFillSelected : style.anchorFill,\n            },\n            stroke: { paint: { fill: 'solid', color: style.anchorStroke }, width: 1 },\n          });\n        }\n      }\n\n      // Marquee rubber band, on top of everything.\n      const marquee = opts.getMarquee?.(view);\n      if (marquee) {\n        const [mx, my] = w2s(marquee.x, marquee.y, view);\n        const [mx2, my2] = w2s(marquee.x + marquee.width, marquee.y + marquee.height, view);\n        out.push({\n          kind: 'path',\n          path: rectMarkerPath(mx, my, mx2 - mx, my2 - my),\n          fill: { fill: 'solid', color: style.marqueeFill },\n          stroke: { paint: { fill: 'solid', color: style.marqueeStroke }, width: 1 },\n        });\n      }\n\n      return out;\n    },\n  };\n}\n"],"mappings":";;;;;AAqFA,IAAMA,IAAmD;CACvD,cAAc;CAId,mBAAmB;CACnB,YAAY;CACZ,cAAc;CACd,cAAc;CAEd,eAAe;CACf,oBAAoB;CACpB,eAAe;CACf,aAAa;AACf,GAEMC,oBAAuC,IAAI,IAAI;AAErD,SAASC,EAAI,GAAY,GAAY,GAA8B;CACjE,OAAO,EAAEC,IAAKC,EAAK,KAAKA,EAAK,MAAM,IAAIC,IAAKD,EAAK,KAAKA,EAAK,MAAM,CAAC;AACpE;AAKA,SAAgBE,EACd,GACsB;CACtB,IAAMC,IAAQ;EAAE,GAAGP;EAAe,GAAIQ,EAAK,SAAS,CAAC;CAAG;CAExD,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAM,MAAS;GACpB,IAAMC,IAAKD,EAAK,aAAa;GAC7B,IAAI,CAACC,GAAI,OAAO,CAAC;GAIjB,IAAMC,IAAYC,EAAcC,CAAI;GACpC,IAAIF,KAAa,CAACA,EAAU,mBAAmB,GAAG,OAAO,CAAC;GAC1D,IAAMG,IAAOL,EAAK,QAAQC,GAAIK,EAAmBF,CAAI,GAAGR,CAAI;GAC5D,IAAI,CAACS,KAAQA,EAAK,SAAS,WAAW,OAAO,CAAC;GAE9C,IAAM,EAAE,eAAYE,EAAcF,CAAmB,GAC/CG,IAAWR,EAAK,qBAAqB,KAAKP,GAC1CgB,IAAqB,CAAC,GAKxBC,IAAO;GACX,KAAK,IAAMC,KAAOC,GAChB,KAAK,IAAMC,KAAKF,GAAK;IACnB,IAAMG,IAAaN,EAAS,IAAIE,CAAI;IACpC;IACA,IAAM,CAACK,GAAIC,KAAMtB,EAAImB,EAAE,GAAGA,EAAE,GAAGjB,CAAI;IAGnC,IAAIiB,EAAE,UAAU;KACd,IAAM,CAACI,GAAIC,KAAMxB,EAAImB,EAAE,SAAS,GAAGA,EAAE,SAAS,GAAGjB,CAAI;KAMrD,AALAa,EAAI,KAAK;MACP,MAAM;MACN,MAAMU,EAAS;OAAE,GAAGJ;OAAI,GAAGC;MAAG,GAAG;OAAE,GAAGC;OAAI,GAAGC;MAAG,CAAC;MACjD,QAAQ;OAAE,OAAO;QAAE,MAAM;QAAS,OAAOnB,EAAM;OAAa;OAAG,OAAO;MAAE;KAC1E,CAAC,GACDU,EAAI,KAAK;MACP,MAAM;MACN,MAAMW,EAAWH,GAAIC,GAAInB,EAAM,iBAAiB;MAChD,MAAM;OAAE,MAAM;OAAS,OAAOA,EAAM;MAAc;KACpD,CAAC;IACH;IACA,IAAIc,EAAE,WAAW;KACf,IAAM,CAACI,GAAIC,KAAMxB,EAAImB,EAAE,UAAU,GAAGA,EAAE,UAAU,GAAGjB,CAAI;KAMvD,AALAa,EAAI,KAAK;MACP,MAAM;MACN,MAAMU,EAAS;OAAE,GAAGJ;OAAI,GAAGC;MAAG,GAAG;OAAE,GAAGC;OAAI,GAAGC;MAAG,CAAC;MACjD,QAAQ;OAAE,OAAO;QAAE,MAAM;QAAS,OAAOnB,EAAM;OAAa;OAAG,OAAO;MAAE;KAC1E,CAAC,GACDU,EAAI,KAAK;MACP,MAAM;MACN,MAAMW,EAAWH,GAAIC,GAAInB,EAAM,iBAAiB;MAChD,MAAM;OAAE,MAAM;OAAS,OAAOA,EAAM;MAAc;KACpD,CAAC;IACH;IAGA,EAAI,KAAK;KACP,MAAM;KACN,MAAMsB,EAAWN,GAAIC,GAAIjB,EAAM,YAAY;KAC3C,MAAM;MACJ,MAAM;MACN,OAAOe,IAAaf,EAAM,qBAAqBA,EAAM;KACvD;KACA,QAAQ;MAAE,OAAO;OAAE,MAAM;OAAS,OAAOA,EAAM;MAAa;MAAG,OAAO;KAAE;IAC1E,CAAC;GACH;GAIF,IAAMuB,IAAUtB,EAAK,aAAaJ,CAAI;GACtC,IAAI0B,GAAS;IACX,IAAM,CAACC,GAAIC,KAAM9B,EAAI4B,EAAQ,GAAGA,EAAQ,GAAG1B,CAAI,GACzC,CAAC6B,GAAKC,KAAOhC,EAAI4B,EAAQ,IAAIA,EAAQ,OAAOA,EAAQ,IAAIA,EAAQ,QAAQ1B,CAAI;IAClF,EAAI,KAAK;KACP,MAAM;KACN,MAAM+B,EAAeJ,GAAIC,GAAIC,IAAMF,GAAIG,IAAMF,CAAE;KAC/C,MAAM;MAAE,MAAM;MAAS,OAAOzB,EAAM;KAAY;KAChD,QAAQ;MAAE,OAAO;OAAE,MAAM;OAAS,OAAOA,EAAM;MAAc;MAAG,OAAO;KAAE;IAC3E,CAAC;GACH;GAEA,OAAOU;EACT;CACF;AACF"}

package/dist/features/paths/pathInWorld.js

@@ -0,0 +1,41 @@
+import { poseRotationOf as e } from "../../core/geometry/poseRotation.js";
+import { applyToPoint as t, boundsOfPath as n, boxToBox as r, rotateAboutPoint as i, transformPath as a, translatePath as o } from "@weasel-js/geom";
+//#region src/features/paths/pathInWorld.ts
+function s(e, t) {
+	if (e.kind === "rect") return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height ? e : {
+		kind: "rect",
+		x: t.x,
+		y: t.y,
+		width: t.width,
+		height: t.height
+	};
+	let i = n(e);
+	if (i.x === t.x && i.y === t.y && i.width === t.width && i.height === t.height) return e;
+	let o = r(i.x, i.y, i.width, i.height, t.x, t.y, t.width, t.height);
+	return a(e, o);
+}
+function c(t, n) {
+	let r = s(t, n), o = e(n);
+	return o ? a(r, i(o.cx, o.cy, o.rotation)) : r;
+}
+function l(r, s) {
+	let c = e(r), l = c ? a(s, i(c.cx, c.cy, -c.rotation)) : s, u = n(l), d = o(l, -u.x, -u.y), f = u.x, p = u.y;
+	if (c) {
+		let [e, n] = t(i(c.cx, c.cy, c.rotation), u.x + u.width / 2, u.y + u.height / 2);
+		f = e - u.width / 2, p = n - u.height / 2;
+	}
+	return {
+		pose: {
+			...r,
+			x: f,
+			y: p,
+			width: u.width,
+			height: u.height
+		},
+		path: d
+	};
+}
+//#endregion
+export { s as pathInPoseFrame, c as pathInWorld, l as worldEditToStorage };
+
+//# sourceMappingURL=pathInWorld.js.map

package/dist/features/paths/pathInWorld.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathInWorld.js","names":["pathInPoseFrame","path","pose","b","boundsOfPath","m","boxToBox","transformPath","pathInWorld","local","r","poseRotationOf","rotateAboutPoint","worldEditToStorage","unrotated","worldPath","aligned","translatePath","x","y","cx","cy","applyToPoint"],"sources":["../../../src/features/paths/pathInWorld.ts"],"sourcesContent":["/**\n * Project a leaf path from its source frame into world coordinates given a\n * `{x, y, width, height, rotation?}` pose. Two transforms compose, in this\n * order:\n *\n *   1. Translate so the path's source AABB origin lands at `pose.x, pose.y`.\n *   2. If `pose.rotation` is nonzero, rotate every coord about the unrotated\n *      AABB center — i.e. `(pose.x + pose.width/2, pose.y + pose.height/2)`,\n *      matching `SceneCanvas.rotateAroundAABBCenter` so the baked geometry\n *      lines up with what the renderer draws.\n *\n * RectPaths can't carry rotation as-is (they're axis-aligned by definition);\n * a non-zero `pose.rotation` on a rect promotes the result to a polygon so\n * the four corners are baked into world coords. Callers that need to keep\n * the rect fast-path can pre-check `pose.rotation` themselves.\n *\n * Used by adapters that need true world geometry — most notably boolean ops,\n * where operating on the unrotated source path produces wrong shapes.\n */\n\nimport {\n  applyToPoint,\n  boxToBox,\n  rotateAboutPoint,\n  boundsOfPath,\n  type Path,\n  type PolygonPath,\n  translatePath,\n  transformPath,\n} from '@weasel-js/geom';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\n\n/** Subset of pose fields this helper consumes. Matches the kit's auto-rotate\n *  convention (`SceneCanvas.defaultDrawOne`): `x/y/width/height` define an\n *  AABB whose unrotated center is the rotation pivot. */\nexport interface PathInWorldPose {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n  rotation?: number;\n}\n\n/**\n * Project a stored path into the pose's **local frame** — translate (and, for\n * rects, rebase to the pose's `width`/`height`) so the path's AABB origin sits\n * at the pose origin. This is translate-only: it does NOT apply\n * `pose.rotation`. Callers that want the fully world-positioned (rotated) path\n * should use `pathInWorld`, which composes this with the rotation wrap.\n *\n * Rects rebase onto the pose's `width`/`height` because resize updates the pose,\n * not the stored `RectPath` — so the live size lives on the pose. Honoring it\n * here keeps this in lockstep with the renderer (`SceneCanvas` paints the rect\n * at `pose.width/height`); otherwise world-space consumers (slice, booleans,\n * release-compound) would operate on the stale pre-resize dimensions.\n *\n * Used by the local seams: the default painter (paint + silhouette), and as the\n * building block `pathInWorld`/`findShapeSilhouette` rotate on top of.\n */\nexport function pathInPoseFrame(path: Path, pose: PathInWorldPose): Path {\n  if (path.kind === 'rect') {\n    if (\n      path.x === pose.x && path.y === pose.y\n      && path.width === pose.width && path.height === pose.height\n    ) return path;\n    return { kind: 'rect', x: pose.x, y: pose.y, width: pose.width, height: pose.height };\n  }\n  // Polygon: rebase the path's own AABB into the pose box via a box→box affine.\n  // Identity when the bounds already equal the pose box (geometry already tracks\n  // the pose) — behavior-preserving there; for geometry-in-data nodes whose pose\n  // box was resized independently, it scales the contents to fill the box,\n  // fixing the anchor bug.\n  const b = boundsOfPath(path);\n  if (b.x === pose.x && b.y === pose.y && b.width === pose.width && b.height === pose.height) {\n    return path;\n  }\n  const m = boxToBox(b.x, b.y, b.width, b.height, pose.x, pose.y, pose.width, pose.height);\n  return transformPath(path, m);\n}\n\n/**\n * Bake `pose` into `path`'s coordinates so the returned path is positioned\n * in world space. Returns a fresh `Path` instance; never mutates inputs.\n */\nexport function pathInWorld(path: Path, pose: PathInWorldPose): Path {\n  // Step 1: project into the pose's local frame (translate; rebase rect dims).\n  // Shares `pathInPoseFrame` with the renderer so world geometry never diverges\n  // from what's painted — notably for resized rects (pose dims, not path dims).\n  const local = pathInPoseFrame(path, pose);\n\n  // Step 2: apply the pose's rotation about its AABB center, if any. The ≈0\n  // gate + AABB-center pivot come from `poseRotationOf` (the shared rotation\n  // convention); the rotation itself composes on the kernel — `transformPath`\n  // handles the rect->polygon promotion and bezier control-point rotation,\n  // identically to the bespoke `rotatePathAround` it replaces.\n  const r = poseRotationOf(pose);\n  if (!r) return local;\n  return transformPath(local, rotateAboutPoint(r.cx, r.cy, r.rotation)) as PolygonPath;\n}\n\n/**\n * Inverse of `pathInWorld` for a path in **world** space: the unrotated\n * stored path plus the pose that draws it there. Inverse-rotates about the\n * pose's AABB center, so the stored path is unrotated and the pose's\n * `rotation` is preserved, then fits the pose's AABB fields to the result.\n * The new box's center is placed where the old rotation carries it, since\n * the pivot moves with the box: `pathInWorld(result.path, result.pose)`\n * reproduces `worldPath` whether or not its bounds changed.\n *\n * Generic in the pose type so consumer-defined pose fields (including\n * `rotation`) survive the round-trip. Used by the anchor-edit commit, its\n * live preview, and the default slice dep.\n */\nexport function worldEditToStorage<P extends PathInWorldPose>(\n  pose: P,\n  worldPath: PolygonPath,\n): { pose: P; path: PolygonPath };\nexport function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPath: Path): { pose: P; path: Path };\nexport function worldEditToStorage<P extends PathInWorldPose>(\n  pose: P,\n  worldPath: Path,\n): { pose: P; path: Path } {\n  const r = poseRotationOf(pose);\n  // The exact inverse of `rotateAboutPoint(cx, cy, θ)` is the same pivot at\n  // -θ — exact by construction, and never `null` the way `invert` can be.\n  const unrotated = r ? transformPath(worldPath, rotateAboutPoint(r.cx, r.cy, -r.rotation)) : worldPath;\n  const b = boundsOfPath(unrotated);\n  const aligned = translatePath(unrotated, -b.x, -b.y);\n  let x = b.x, y = b.y;\n  if (r) {\n    const [cx, cy] = applyToPoint(\n      rotateAboutPoint(r.cx, r.cy, r.rotation), b.x + b.width / 2, b.y + b.height / 2,\n    );\n    x = cx - b.width / 2;\n    y = cy - b.height / 2;\n  }\n  return {\n    pose: { ...pose, x, y, width: b.width, height: b.height },\n    path: aligned,\n  };\n}\n"],"mappings":";;;AA2DA,SAAgBA,EAAgB,GAAY,GAA6B;CACvE,IAAIC,EAAK,SAAS,QAKhB,OAHEA,EAAK,MAAMC,EAAK,KAAKD,EAAK,MAAMC,EAAK,KAClCD,EAAK,UAAUC,EAAK,SAASD,EAAK,WAAWC,EAAK,SAC9CD,IACF;EAAE,MAAM;EAAQ,GAAGC,EAAK;EAAG,GAAGA,EAAK;EAAG,OAAOA,EAAK;EAAO,QAAQA,EAAK;CAAO;CAOtF,IAAMC,IAAIC,EAAaH,CAAI;CAC3B,IAAIE,EAAE,MAAMD,EAAK,KAAKC,EAAE,MAAMD,EAAK,KAAKC,EAAE,UAAUD,EAAK,SAASC,EAAE,WAAWD,EAAK,QAClF,OAAOD;CAET,IAAMI,IAAIC,EAASH,EAAE,GAAGA,EAAE,GAAGA,EAAE,OAAOA,EAAE,QAAQD,EAAK,GAAGA,EAAK,GAAGA,EAAK,OAAOA,EAAK,MAAM;CACvF,OAAOK,EAAcN,GAAMI,CAAC;AAC9B;AAMA,SAAgBG,EAAY,GAAY,GAA6B;CAInE,IAAMC,IAAQT,EAAgBC,GAAMC,CAAI,GAOlCQ,IAAIC,EAAeT,CAAI;CAE7B,OADKQ,IACEH,EAAcE,GAAOG,EAAiBF,EAAE,IAAIA,EAAE,IAAIA,EAAE,QAAQ,CAAC,IADrDD;AAEjB;AAoBA,SAAgBI,EACd,GACA,GACyB;CACzB,IAAMH,IAAIC,EAAeT,CAAI,GAGvBY,IAAYJ,IAAIH,EAAcQ,GAAWH,EAAiBF,EAAE,IAAIA,EAAE,IAAI,CAACA,EAAE,QAAQ,CAAC,IAAIK,GACtFZ,IAAIC,EAAaU,CAAS,GAC1BE,IAAUC,EAAcH,GAAW,CAACX,EAAE,GAAG,CAACA,EAAE,CAAC,GAC/Ce,IAAIf,EAAE,GAAGgB,IAAIhB,EAAE;CACnB,IAAIO,GAAG;EACL,IAAM,CAACU,GAAIC,KAAMC,EACfV,EAAiBF,EAAE,IAAIA,EAAE,IAAIA,EAAE,QAAQ,GAAGP,EAAE,IAAIA,EAAE,QAAQ,GAAGA,EAAE,IAAIA,EAAE,SAAS,CAChF;EAEA,AADA,IAAIiB,IAAKjB,EAAE,QAAQ,GACnB,IAAIkB,IAAKlB,EAAE,SAAS;CACtB;CACA,OAAO;EACL,MAAM;GAAE,GAAGD;GAAM;GAAG;GAAG,OAAOC,EAAE;GAAO,QAAQA,EAAE;EAAO;EACxD,MAAMa;CACR;AACF"}

package/dist/features/paths/pathLayer.js

@@ -0,0 +1,44 @@
+import { countPathAnchors as e } from "./anchors.js";
+import "@weasel-js/paint";
+//#region src/features/paths/pathLayer.ts
+var t = { color: "#ffffff" }, n = {
+	paint: { color: "#ffffff" },
+	width: 1
+};
+function r(r) {
+	let { id: i = "paths", label: a = "Paths", getNodes: o, getPath: s, getFill: c, getStroke: l, isHidden: u, getVertexColors: d, getStrokeVertexColors: f, getStrokeVertexWidths: p, colorOverrides: m, now: h = () => typeof performance < "u" ? performance.now() : Date.now() } = r;
+	return {
+		id: i,
+		label: a,
+		draw: () => {
+			let r = [], i = o();
+			for (let a = 0; a < i.length; a++) {
+				let o = i[a];
+				if (u?.(o)) continue;
+				let g = s(o), _ = c?.(o), v = l?.(o), y = d?.(o), b = f?.(o), x = p?.(o), S = o.id ?? String(a), C = m ? h() : 0, w = m ? m.resolve(S, "fill", y ?? void 0, C) : y, T = m ? m.resolve(S, "stroke", b ?? void 0, C) : b, E = e(g), D = 4 * E, O = null;
+				w != null && w.length === D && (O = w);
+				let k = null;
+				T != null && T.length === D && (k = T);
+				let A = _ ?? (O == null ? void 0 : t), j = null;
+				x != null && x.length === E && (j = x);
+				let M = v ?? (k != null || j != null ? n : void 0), N = M == null ? M : {
+					...M,
+					...k == null ? {} : { vertexColors: k },
+					...j == null ? {} : { vertexWidths: j }
+				};
+				(A != null || N != null) && r.push({
+					kind: "path",
+					path: g,
+					...A == null ? {} : { fill: A },
+					...N == null ? {} : { stroke: N },
+					...O == null ? {} : { vertexColors: O }
+				});
+			}
+			return r;
+		}
+	};
+}
+//#endregion
+export { r as createPathLayer };
+
+//# sourceMappingURL=pathLayer.js.map

package/dist/features/paths/pathLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathLayer.js","names":["PLACEHOLDER_FILL","PLACEHOLDER_STROKE","createPathLayer","opts","children","nodes","getNodes","idx","node","isHidden","path","getPath","fillFromHook","getFill","strokeFromHook","getStroke","baseVColors","getVertexColors","baseStrokeVColors","getStrokeVertexColors","strokeVWidths","getStrokeVertexWidths","nodeId","tMs","colorOverrides","now","vColors","strokeVColors","anchorCount","countPathAnchors","expectedLen","useVColors","useStrokeVColors","fill","useStrokeVWidths","baseStroke","stroke"],"sources":["../../../src/features/paths/pathLayer.ts"],"sourcesContent":["/**\n * `RenderLayer` that fills/strokes `Path` instances. Mirrors the shape of\n * `createTextLayer`: caller hands over a `getNodes()` enumerator and a\n * `getPath(node)` lookup; the layer iterates and renders. FillStyle and\n * stroke are looked up per node so consumers can keep the path geometry\n * separate from the visual style record (the typical scene-graph layout).\n */\n\nimport { type DrawCommand } from '../../renderer';\nimport { type FillStyle, type Stroke } from '@weasel-js/paint';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { Path } from '@weasel-js/geom';\nimport { countPathAnchors } from './anchors';\nimport type { ColorOverrideRegistry } from '../../animation/colorRegistry';\n\nconst PLACEHOLDER_FILL: FillStyle = { color: '#ffffff' };\nconst PLACEHOLDER_STROKE: Stroke = { paint: { color: '#ffffff' }, width: 1 };\n\n\n/** Options for `createPathLayer`. */\nexport interface CreatePathLayerOpts<T> {\n  id?: string;\n  label?: string;\n  getNodes: () => readonly T[];\n  getPath: (node: T) => Path;\n  /** Per-node fill paint. Return `null`/`undefined` to skip filling. */\n  getFill?: (node: T) => FillStyle | null | undefined;\n  /** Per-node stroke. Return `null`/`undefined` to skip stroking. */\n  getStroke?: (node: T) => Stroke | null | undefined;\n  /** Optional per-node hide hook (e.g., suppress while editing). */\n  isHidden?: (node: T) => boolean;\n  /**\n   * Per-node fill vertex-color array, flat RGBA-per-path-anchor, in\n   * 0..1 floats (same color space as `PathDrawCommand.vertexColors`).\n   * Length must be `4 × countPathAnchors(getPath(node))`. When set and\n   * `getFill` returns null/undefined, a white placeholder fill is\n   * synthesized so the renderer's per-vertex shader path activates.\n   */\n  getVertexColors?: (node: T) => number[] | null | undefined;\n  /**\n   * Per-node stroke vertex-color array, flat RGBA-per-path-anchor, in\n   * 0..1 floats (same color space as `Stroke.vertexColors`).\n   * Length must be `4 × countPathAnchors(getPath(node))`. When set and\n   * `getStroke` returns null/undefined, a white 1px placeholder stroke\n   * is synthesized.\n   */\n  getStrokeVertexColors?: (node: T) => number[] | null | undefined;\n  /**\n   * Per-node stroke vertex-width array (one width per anchor).\n   * Length must be `countPathAnchors(getPath(node))`. The tessellator\n   * interpolates half-widths along each segment for tapered strokes.\n   * When set and `getStroke` returns null/undefined, a 1px placeholder\n   * stroke is synthesized so the per-anchor widths take effect.\n   */\n  getStrokeVertexWidths?: (node: T) => number[] | null | undefined;\n  /**\n   * Optional color override registry, typically `animator.colorOverrides`.\n   * When set, the renderer consults it before falling back to\n   * `getVertexColors` / `getStrokeVertexColors`. Function-form overrides\n   * receive the base color array and the current animation timestamp.\n   */\n  colorOverrides?: ColorOverrideRegistry;\n  /** Clock used to timestamp function-form color overrides. Defaults to\n   *  `performance.now`. Override in tests. */\n  now?: () => number;\n}\n\n/** Build a `RenderLayer` that fills/strokes `Path` instances enumerated from a node list. */\nexport function createPathLayer<T>(opts: CreatePathLayerOpts<T>): RenderLayer<unknown> {\n  const {\n    id = 'paths', label = 'Paths',\n    getNodes, getPath, getFill, getStroke, isHidden,\n    getVertexColors, getStrokeVertexColors, getStrokeVertexWidths,\n    colorOverrides,\n    now = (): number => (typeof performance !== 'undefined' ? performance.now() : Date.now()),\n  } = opts;\n  const warned = new Set<string>();\n  const isDev = typeof import.meta !== 'undefined'\n    && (import.meta as unknown as { env?: { DEV?: boolean } }).env\n    && (import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV;\n\n  return {\n    id,\n    label,\n    draw: () => {\n      const children: DrawCommand[] = [];\n      const nodes = getNodes();\n      for (let idx = 0; idx < nodes.length; idx++) {\n        const node = nodes[idx];\n        if (isHidden?.(node)) continue;\n        const path = getPath(node);\n        const fillFromHook = getFill?.(node);\n        const strokeFromHook = getStroke?.(node);\n        const baseVColors = getVertexColors?.(node);\n        const baseStrokeVColors = getStrokeVertexColors?.(node);\n        const strokeVWidths = getStrokeVertexWidths?.(node);\n\n        const nodeId = (node as { id?: string }).id ?? String(idx);\n        const tMs = colorOverrides ? now() : 0;\n\n        const vColors = colorOverrides\n          ? colorOverrides.resolve(nodeId, 'fill', baseVColors ?? undefined, tMs)\n          : baseVColors;\n        const strokeVColors = colorOverrides\n          ? colorOverrides.resolve(nodeId, 'stroke', baseStrokeVColors ?? undefined, tMs)\n          : baseStrokeVColors;\n\n        const nodeKey = nodeId;\n        const anchorCount = countPathAnchors(path);\n        const expectedLen = 4 * anchorCount;\n\n        let useVColors: readonly number[] | null = null;\n        if (vColors != null) {\n          if (vColors.length === expectedLen) {\n            useVColors = vColors;\n          } else if (isDev) {\n            const key = `${id}:${nodeKey}:fill`;\n            if (!warned.has(key)) {\n              warned.add(key);\n              console.warn(\n                `[createPathLayer ${id}] node ${nodeKey}: fill vertexColors length ${vColors.length}, expected ${expectedLen}; dropping`,\n              );\n            }\n          }\n        }\n\n        let useStrokeVColors: readonly number[] | null = null;\n        if (strokeVColors != null) {\n          if (strokeVColors.length === expectedLen) {\n            useStrokeVColors = strokeVColors;\n          } else if (isDev) {\n            const key = `${id}:${nodeKey}:stroke`;\n            if (!warned.has(key)) {\n              warned.add(key);\n              console.warn(\n                `[createPathLayer ${id}] node ${nodeKey}: stroke vertexColors length ${strokeVColors.length}, expected ${expectedLen}; dropping`,\n              );\n            }\n          }\n        }\n\n        // Synthesize placeholder only when colors validate (useVColors != null),\n        // not on any raw hook return. Mismatched-length arrays drop both the\n        // colors and placeholder so the dev signal (console warning) isn't duplicated.\n        const fill: FillStyle | undefined =\n          fillFromHook != null ? fillFromHook\n          : (useVColors != null ? PLACEHOLDER_FILL : undefined);\n\n        let useStrokeVWidths: number[] | null = null;\n        if (strokeVWidths != null) {\n          if (strokeVWidths.length === anchorCount) {\n            useStrokeVWidths = strokeVWidths;\n          } else if (isDev) {\n            const key = `${id}:${nodeKey}:strokeWidths`;\n            if (!warned.has(key)) {\n              warned.add(key);\n              console.warn(\n                `[createPathLayer ${id}] node ${nodeKey}: stroke vertexWidths length ${strokeVWidths.length}, expected ${anchorCount}; dropping`,\n              );\n            }\n          }\n        }\n\n        const baseStroke: Stroke | undefined =\n          strokeFromHook != null ? strokeFromHook\n          : (useStrokeVColors != null || useStrokeVWidths != null ? PLACEHOLDER_STROKE : undefined);\n\n        const stroke: Stroke | undefined =\n          baseStroke != null\n            ? {\n                ...baseStroke,\n                ...(useStrokeVColors != null ? { vertexColors: useStrokeVColors as number[] } : {}),\n                ...(useStrokeVWidths != null ? { vertexWidths: useStrokeVWidths } : {}),\n              }\n            : baseStroke;\n\n        if (fill == null && stroke == null) continue;\n\n        children.push({\n          kind: 'path',\n          path,\n          ...(fill != null ? { fill } : {}),\n          ...(stroke != null ? { stroke } : {}),\n          ...(useVColors != null ? { vertexColors: useVColors as number[] } : {}),\n        });\n      }\n      // World-space commands; drawLayers wraps in viewToMat3 automatically.\n      return children;\n    },\n  };\n}\n"],"mappings":";;;AAeA,IAAMA,IAA8B,EAAE,OAAO,UAAU,GACjDC,IAA6B;CAAE,OAAO,EAAE,OAAO,UAAU;CAAG,OAAO;AAAE;AAoD3E,SAAgBC,EAAmB,GAAoD;CACrF,IAAM,EACJ,QAAK,SAAS,WAAQ,SACtB,aAAU,YAAS,YAAS,cAAW,aACvC,oBAAiB,0BAAuB,0BACxC,mBACA,eAAqB,OAAO,cAAgB,MAAc,YAAY,IAAI,IAAI,KAAK,IAAI,MACrFC;CAMJ,OAAO;EACL;EACA;EACA,YAAY;GACV,IAAMC,IAA0B,CAAC,GAC3BC,IAAQC,EAAS;GACvB,KAAK,IAAIC,IAAM,GAAGA,IAAMF,EAAM,QAAQ,KAAO;IAC3C,IAAMG,IAAOH,EAAME;IACnB,IAAIE,IAAWD,CAAI,GAAG;IACtB,IAAME,IAAOC,EAAQH,CAAI,GACnBI,IAAeC,IAAUL,CAAI,GAC7BM,IAAiBC,IAAYP,CAAI,GACjCQ,IAAcC,IAAkBT,CAAI,GACpCU,IAAoBC,IAAwBX,CAAI,GAChDY,IAAgBC,IAAwBb,CAAI,GAE5Cc,IAAUd,EAAyB,MAAM,OAAOD,CAAG,GACnDgB,IAAMC,IAAiBC,EAAI,IAAI,GAE/BC,IAAUF,IACZA,EAAe,QAAQF,GAAQ,QAAQN,KAAe,KAAA,GAAWO,CAAG,IACpEP,GACEW,IAAgBH,IAClBA,EAAe,QAAQF,GAAQ,UAAUJ,KAAqB,KAAA,GAAWK,CAAG,IAC5EL,GAGEU,IAAcC,EAAiBnB,CAAI,GACnCoB,IAAc,IAAIF,GAEpBG,IAAuC;IAC3C,AAAIL,KAAW,QACTA,EAAQ,WAAWI,MACrB,IAAaJ;IAYjB,IAAIM,IAA6C;IACjD,AAAIL,KAAiB,QACfA,EAAc,WAAWG,MAC3B,IAAmBH;IAevB,IAAMM,IACJrB,MACGmB,KAAc,OAA0B,KAAA,IAAnB/B,IAEtBkC,IAAoC;IACxC,AAAId,KAAiB,QACfA,EAAc,WAAWQ,MAC3B,IAAmBR;IAYvB,IAAMe,IACJrB,MACGkB,KAAoB,QAAQE,KAAoB,OAAOjC,IAAqB,KAAA,IAE3EmC,IACJD,KAAc,OAMVA,IALA;KACE,GAAGA;KACH,GAAIH,KAAoB,OAAwD,CAAC,IAAlD,EAAE,cAAcA,EAA6B;KAC5E,GAAIE,KAAoB,OAA4C,CAAC,IAAtC,EAAE,cAAcA,EAAiB;IAClE;IAGN,CAAID,KAAQ,QAAQG,KAAU,SAE9BhC,EAAS,KAAK;KACZ,MAAM;KACN;KACA,GAAI6B,KAAQ,OAAkB,CAAC,IAAZ,EAAE,QAAK;KAC1B,GAAIG,KAAU,OAAoB,CAAC,IAAd,EAAE,UAAO;KAC9B,GAAIL,KAAc,OAAkD,CAAC,IAA5C,EAAE,cAAcA,EAAuB;IAClE,CAAC;GACH;GAEA,OAAO3B;EACT;CACF;AACF"}