@weasel-js/core 1.9.3 → 1.10.0

package/dist/features/paths/markers.js

@@ -1,95 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,36 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/pathInWorld.js

@@ -1,41 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/poseDescriptor.js

@@ -1,39 +0,0 @@
-import { boundsOfPath as e, boxToBox as t, transformPath as n, translatePath as r } from "@weasel-js/geom";
-//#region src/features/paths/poseDescriptor.ts
-var i = {
-	getBounds: (t) => e(t),
-	remapBounds: (e, r, i) => n(e, t(r.x, r.y, r.width, r.height, i.x, i.y, i.width, i.height)),
-	fromBounds: (e) => ({
-		kind: "rect",
-		x: e.x,
-		y: e.y,
-		width: e.width,
-		height: e.height
-	}),
-	translate: (e, t, n) => r(e, t, n),
-	lerp: (e, t, n) => {
-		if (e.kind === "rect" && t.kind === "rect") return {
-			kind: "rect",
-			x: e.x + (t.x - e.x) * n,
-			y: e.y + (t.y - e.y) * n,
-			width: e.width + (t.width - e.width) * n,
-			height: e.height + (t.height - e.height) * n
-		};
-		if (e.kind === "polygon" && t.kind === "polygon" && e.coords.length === t.coords.length) {
-			let r = new Float32Array(e.coords.length);
-			for (let i = 0; i < e.coords.length; i++) r[i] = e.coords[i] + (t.coords[i] - e.coords[i]) * n;
-			return {
-				kind: "polygon",
-				commands: e.commands,
-				coords: r,
-				fillRule: e.fillRule
-			};
-		}
-		throw Error("pathPoseDescriptor.lerp: incompatible path shapes");
-	},
-	supportsRotation: () => !1
-};
-//#endregion
-export { i as pathPoseDescriptor };
-
-//# sourceMappingURL=poseDescriptor.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"poseDescriptor.js","names":["pathPoseDescriptor","boundsOfPath","path","transformPath","boxToBox","src","dst","b","translatePath","dx","dy","a","t","next"],"sources":["../../../src/features/paths/poseDescriptor.ts"],"sourcesContent":["import {\n  boxToBox,\n  boundsOfPath,\n  translatePath,\n  transformPath,\n  type Path,\n} from '@weasel-js/geom';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\n\n/**\n * `PoseDescriptor` for `Path` poses — wires `useResize` to operate\n * on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel\n * the rest of the kit uses.\n *\n * `remapBounds` mirrors `scalePathToBounds` but takes `src` explicitly: the\n * resize hook knows the group's origin AABB and uses it for every leaf,\n * instead of each leaf scaling against its own AABB (which would ignore\n * group context).\n */\nexport const pathPoseDescriptor: PoseDescriptor<Path> = {\n  getBounds: (path) => boundsOfPath(path),\n  remapBounds: (path, src, dst) => transformPath(\n    path,\n    boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height),\n  ),\n  fromBounds: (b) => ({ kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (path, dx, dy) => translatePath(path, dx, dy),\n  lerp: (a, b, t) => {\n    if (a.kind === 'rect' && b.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: a.x + (b.x - a.x) * t,\n        y: a.y + (b.y - a.y) * t,\n        width: a.width + (b.width - a.width) * t,\n        height: a.height + (b.height - a.height) * t,\n      };\n    }\n    if (a.kind === 'polygon' && b.kind === 'polygon' && a.coords.length === b.coords.length) {\n      const next = new Float32Array(a.coords.length);\n      for (let i = 0; i < a.coords.length; i++) {\n        next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;\n      }\n      return { kind: 'polygon', commands: a.commands, coords: next, fillRule: a.fillRule };\n    }\n    throw new Error('pathPoseDescriptor.lerp: incompatible path shapes');\n  },\n  // Path poses carry no x/y/width/height/rotation fields — the kit's\n  // `wrapWithPoseRotation` helper has nothing to bind a rotation to, and\n  // `remapBounds` would drop a synthetic rotation field on every commit.\n  // Returning false here hides the rotation affordance for Path consumers\n  // so the rotate cursor doesn't appear without a working interaction.\n  supportsRotation: () => false,\n};\n"],"mappings":";;AAmBA,IAAaA,IAA2C;CACtD,YAAY,MAASC,EAAaC,CAAI;CACtC,cAAc,GAAM,GAAK,MAAQC,EAC/BD,GACAE,EAASC,EAAI,GAAGA,EAAI,GAAGA,EAAI,OAAOA,EAAI,QAAQC,EAAI,GAAGA,EAAI,GAAGA,EAAI,OAAOA,EAAI,MAAM,CACnF;CACA,aAAa,OAAO;EAAE,MAAM;EAAQ,GAAGC,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;CACrF,YAAY,GAAM,GAAI,MAAOC,EAAcN,GAAMO,GAAIC,CAAE;CACvD,OAAO,GAAG,GAAG,MAAM;EACjB,IAAIC,EAAE,SAAS,UAAUJ,EAAE,SAAS,QAClC,OAAO;GACL,MAAM;GACN,GAAGI,EAAE,KAAKJ,EAAE,IAAII,EAAE,KAAKC;GACvB,GAAGD,EAAE,KAAKJ,EAAE,IAAII,EAAE,KAAKC;GACvB,OAAOD,EAAE,SAASJ,EAAE,QAAQI,EAAE,SAASC;GACvC,QAAQD,EAAE,UAAUJ,EAAE,SAASI,EAAE,UAAUC;EAC7C;EAEF,IAAID,EAAE,SAAS,aAAaJ,EAAE,SAAS,aAAaI,EAAE,OAAO,WAAWJ,EAAE,OAAO,QAAQ;GACvF,IAAMM,IAAO,IAAI,aAAaF,EAAE,OAAO,MAAM;GAC7C,KAAK,IAAI,IAAI,GAAG,IAAIA,EAAE,OAAO,QAAQ,KACnC,EAAK,KAAKA,EAAE,OAAO,MAAMJ,EAAE,OAAO,KAAKI,EAAE,OAAO,MAAMC;GAExD,OAAO;IAAE,MAAM;IAAW,UAAUD,EAAE;IAAU,QAAQE;IAAM,UAAUF,EAAE;GAAS;EACrF;EACA,MAAU,MAAM,mDAAmD;CACrE;CAMA,wBAAwB;AAC1B"}

package/dist/features/paths/tessellate/dash.js

@@ -1,52 +0,0 @@
-//#region src/features/paths/tessellate/dash.ts
-function e(e, n) {
-	let r = [], i = e.anchorA ?? new Uint32Array(e.points.length / 2), a = e.anchorB ?? new Uint32Array(e.points.length / 2), o = e.anchorT ?? new Float32Array(e.points.length / 2), s = 0, c = n[0], l = !0, u = l ? [e.points[0], e.points[1]] : null, d = l ? [i[0]] : null, f = l ? [a[0]] : null, p = l ? [o[0]] : null, m = () => {
-		u && u.length >= 4 && r.push({
-			points: u,
-			closed: !1,
-			anchorA: new Uint32Array(d),
-			anchorB: new Uint32Array(f),
-			anchorT: new Float32Array(p)
-		}), u = null, d = null, f = null, p = null, s = (s + 1) % n.length, c = n[s], l = !l;
-	}, h = e.points[0], g = e.points[1], _ = e.points.length / 2, v = e.closed ? _ : _ - 1;
-	for (let t = 0; t < v; t++) {
-		let n = (t + 1) % _, r = e.points[n * 2], s = e.points[n * 2 + 1], v = i[t], y = a[t], b = o[t], x = i[n], S = a[n], C = o[n], w = r - h, T = s - g, E = Math.hypot(w, T), D = w, O = T, k = E, A = 0;
-		for (; k > 1e-9;) if (k <= c) l && u && (u.push(r, s), d.push(x), f.push(S), p.push(C)), c -= k, h = r, g = s, A = E, k = 0, c <= 1e-9 && (m(), l && (u = [h, g], d = [x], f = [S], p = [C]));
-		else {
-			let e = c / k, t = h + D * e, n = g + O * e;
-			A += c;
-			let i = A / E, a, o, _;
-			v === x && y === S ? (a = v, o = y, _ = b + (C - b) * i) : i < .5 ? (a = v, o = y, _ = b) : (a = x, o = S, _ = C), l && u && (u.push(t, n), d.push(a), f.push(o), p.push(_)), h = t, g = n, D = r - h, O = s - g, k = Math.hypot(D, O), m(), l && (u = [h, g], d = [a], f = [o], p = [_]);
-		}
-	}
-	if (u && u.length >= 4) {
-		let n = {
-			points: u,
-			closed: !1,
-			anchorA: new Uint32Array(d),
-			anchorB: new Uint32Array(f),
-			anchorT: new Float32Array(p)
-		}, i = u[u.length - 2], a = u[u.length - 1], o = (e, t) => Math.hypot(i - e, a - t) <= 1e-9;
-		e.closed && r.length > 0 && o(r[0].points[0], r[0].points[1]) ? r[0] = t(n, r[0]) : e.closed && r.length === 0 && o(u[0], u[1]) ? r.push({
-			points: u.slice(0, -2),
-			closed: !0,
-			anchorA: n.anchorA.slice(0, -1),
-			anchorB: n.anchorB.slice(0, -1),
-			anchorT: n.anchorT.slice(0, -1)
-		}) : r.push(n);
-	}
-	return r;
-}
-function t(e, t) {
-	return {
-		points: [...e.points, ...t.points.slice(2)],
-		closed: !1,
-		anchorA: Uint32Array.from([...e.anchorA, ...t.anchorA.subarray(1)]),
-		anchorB: Uint32Array.from([...e.anchorB, ...t.anchorB.subarray(1)]),
-		anchorT: Float32Array.from([...e.anchorT, ...t.anchorT.subarray(1)])
-	};
-}
-//#endregion
-export { e as splitForDash };
-
-//# sourceMappingURL=dash.js.map

package/dist/features/paths/tessellate/dash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dash.js","names":["splitForDash","out","plA","pl","plB","plT","dashIdx","dashRemaining","dash","onPhase","curPts","curA","curB","curT","flushAndAdvance","prevX","prevY","ptCount","segCount","i","nextIdx","cx","cy","startA","startB","startT","endA","endB","endT","segFullDx","segFullDy","segFullLen","segDx","segDy","segLen","traveled","tConsume","ix","iy","frac","mA","mB","mT","tail","tx","ty","meets","x","y","joinAtSeam","head"],"sources":["../../../../src/features/paths/tessellate/dash.ts"],"sourcesContent":["import type { Polyline } from '@weasel-js/geom/tessellate';\n\n/**\n * Split a polyline into open sub-polylines for the \"on\" portions of a dash\n * pattern. Each output sub-polyline gets caps from the stroke's `cap` setting.\n * The \"off\" portions become invisible gaps. Anchor params are carried through:\n * sub-polyline endpoints inherit their source polyline-point's anchor params;\n * dash boundaries that land mid-segment (between two polyline points) snap\n * their anchor params to whichever endpoint they're closer to when the\n * segment crosses a path-anchor boundary, otherwise interpolate `t` linearly.\n */\nexport function splitForDash(pl: Polyline, dash: number[]): Polyline[] {\n  const out: Polyline[] = [];\n  const plA = pl.anchorA ?? new Uint32Array(pl.points.length / 2);\n  const plB = pl.anchorB ?? new Uint32Array(pl.points.length / 2);\n  const plT = pl.anchorT ?? new Float32Array(pl.points.length / 2);\n\n  let dashIdx = 0;\n  let dashRemaining = dash[0];\n  let onPhase = true;\n  let curPts: number[] | null = onPhase ? [pl.points[0], pl.points[1]] : null;\n  let curA: number[] | null = onPhase ? [plA[0]] : null;\n  let curB: number[] | null = onPhase ? [plB[0]] : null;\n  let curT: number[] | null = onPhase ? [plT[0]] : null;\n\n  const flushAndAdvance = () => {\n    if (curPts && curPts.length >= 4) {\n      out.push({\n        points: curPts,\n        closed: false,\n        anchorA: new Uint32Array(curA!),\n        anchorB: new Uint32Array(curB!),\n        anchorT: new Float32Array(curT!),\n      });\n    }\n    curPts = null; curA = null; curB = null; curT = null;\n    dashIdx = (dashIdx + 1) % dash.length;\n    dashRemaining = dash[dashIdx];\n    onPhase = !onPhase;\n  };\n\n  let prevX = pl.points[0], prevY = pl.points[1];\n  const ptCount = pl.points.length / 2;\n  const segCount = pl.closed ? ptCount : ptCount - 1;\n\n  for (let i = 0; i < segCount; i++) {\n    const nextIdx = (i + 1) % ptCount;\n    const cx = pl.points[nextIdx * 2], cy = pl.points[nextIdx * 2 + 1];\n    const startA = plA[i], startB = plB[i], startT = plT[i];\n    const endA = plA[nextIdx], endB = plB[nextIdx], endT = plT[nextIdx];\n    const segFullDx = cx - prevX, segFullDy = cy - prevY;\n    const segFullLen = Math.hypot(segFullDx, segFullDy);\n    let segDx = segFullDx, segDy = segFullDy;\n    let segLen = segFullLen;\n    let traveled = 0;\n\n    while (segLen > 1e-9) {\n      if (segLen <= dashRemaining) {\n        if (onPhase && curPts) {\n          curPts.push(cx, cy);\n          curA!.push(endA); curB!.push(endB); curT!.push(endT);\n        }\n        dashRemaining -= segLen;\n        prevX = cx; prevY = cy;\n        traveled = segFullLen;\n        segLen = 0;\n        if (dashRemaining <= 1e-9) {\n          flushAndAdvance();\n          if (onPhase) {\n            curPts = [prevX, prevY];\n            curA = [endA]; curB = [endB]; curT = [endT];\n          }\n        }\n      } else {\n        const tConsume = dashRemaining / segLen;\n        const ix = prevX + segDx * tConsume;\n        const iy = prevY + segDy * tConsume;\n        traveled += dashRemaining;\n        const frac = traveled / segFullLen;\n        let mA: number, mB: number, mT: number;\n        if (startA === endA && startB === endB) {\n          mA = startA; mB = startB;\n          mT = startT + (endT - startT) * frac;\n        } else {\n          // Cross-anchor segment: pick the nearer endpoint's params.\n          if (frac < 0.5) { mA = startA; mB = startB; mT = startT; }\n          else            { mA = endA; mB = endB; mT = endT; }\n        }\n        if (onPhase && curPts) {\n          curPts.push(ix, iy);\n          curA!.push(mA); curB!.push(mB); curT!.push(mT);\n        }\n        prevX = ix; prevY = iy;\n        segDx = cx - prevX; segDy = cy - prevY;\n        segLen = Math.hypot(segDx, segDy);\n        flushAndAdvance();\n        if (onPhase) {\n          curPts = [prevX, prevY];\n          curA = [mA]; curB = [mB]; curT = [mT];\n        }\n      }\n    }\n  }\n\n  if (curPts && curPts.length >= 4) {\n    const tail: Polyline = {\n      points: curPts,\n      closed: false,\n      anchorA: new Uint32Array(curA!),\n      anchorB: new Uint32Array(curB!),\n      anchorT: new Float32Array(curT!),\n    };\n    // A closed subpath's walk ends at the vertex it started from, so the run\n    // still open there and the run that started there are one dash. Pushed\n    // separately they are two butt-capped ribbons meeting at the seam — the\n    // visible artifact whenever the pattern doesn't divide the perimeter.\n    const tx = curPts[curPts.length - 2], ty = curPts[curPts.length - 1];\n    const meets = (x: number, y: number) => Math.hypot(tx - x, ty - y) <= 1e-9;\n    if (pl.closed && out.length > 0 && meets(out[0].points[0], out[0].points[1])) {\n      out[0] = joinAtSeam(tail, out[0]);\n    } else if (pl.closed && out.length === 0 && meets(curPts[0], curPts[1])) {\n      // Every gap fell outside the perimeter: the dash is the whole loop, and\n      // a loop stroked as an open run seams at its own start vertex too.\n      out.push({\n        points: curPts.slice(0, -2),\n        closed: true,\n        anchorA: tail.anchorA!.slice(0, -1),\n        anchorB: tail.anchorB!.slice(0, -1),\n        anchorT: tail.anchorT!.slice(0, -1),\n      });\n    } else {\n      out.push(tail);\n    }\n  }\n  return out;\n}\n\n/** `tail` continued by `head`, which starts where `tail` ends — the shared\n *  vertex is carried once. */\nfunction joinAtSeam(tail: Polyline, head: Polyline): Polyline {\n  return {\n    points: [...tail.points, ...head.points.slice(2)],\n    closed: false,\n    anchorA: Uint32Array.from([...tail.anchorA!, ...head.anchorA!.subarray(1)]),\n    anchorB: Uint32Array.from([...tail.anchorB!, ...head.anchorB!.subarray(1)]),\n    anchorT: Float32Array.from([...tail.anchorT!, ...head.anchorT!.subarray(1)]),\n  };\n}\n"],"mappings":"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"}

package/dist/features/paths/tessellate/insets.js

@@ -1,32 +0,0 @@
-import { polylineIntoMetric as e, polylineOutOfMetric as t, sameMetric as n } from "./metric.js";
-import { trimPolyline as r } from "@weasel-js/geom/tessellate";
-//#region src/features/paths/tessellate/insets.ts
-var i = (e, t) => e === void 0 ? {
-	length: 0,
-	metric: t
-} : typeof e == "number" ? {
-	length: e,
-	metric: t
-} : e;
-function a(a, o, s, c, l) {
-	let u = i(c, s), d = i(l, s), f = a, p = o, m = (r) => {
-		f === null || n(p, r) || (p !== null && t(f, p), r !== null && e(f, r), p = r);
-	};
-	if (u.length > 0 || d.length > 0) {
-		if (n(u.metric, d.metric)) m(u.metric), f = r(f, u.length, d.length);
-		else for (let [e, t, n] of [[
-			u.length,
-			u.metric,
-			!0
-		], [
-			d.length,
-			d.metric,
-			!1
-		]]) e > 0 && f !== null && (m(t), f = r(f, n ? e : 0, n ? 0 : e));
-	}
-	return m(s), f;
-}
-//#endregion
-export { a as trimInSpace };
-
-//# sourceMappingURL=insets.js.map

package/dist/features/paths/tessellate/insets.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"insets.js","names":["trimOf","inset","ribbon","trimInSpace","s","start","e","end","cur","pl","space","from","moveTo","sameMetric","to","polylineOutOfMetric","polylineIntoMetric","trimPolyline","len","metric","atStart"],"sources":["../../../../src/features/paths/tessellate/insets.ts"],"sourcesContent":["/**\n * Trimming a stroke's ends where each inset is measured.\n *\n * A head stops the line by a length in the head's own space, which need not be\n * the ribbon's: a world-sized head on a `{ px }` stroke stops it a world\n * distance short, a `{ px }` head on a world-width stroke a screen distance.\n * Under a stretching view one length means different distances in the two\n * spaces depending on which way the line runs, so each end is trimmed in its\n * own space rather than converted.\n */\nimport { type Polyline, trimPolyline } from '@weasel-js/geom/tessellate';\nimport {\n  type StrokeMetric, polylineIntoMetric, polylineOutOfMetric, sameMetric,\n} from './metric';\n\n/** A length along the line measured in `metric`'s space, or in world where\n *  `metric` is `null`. */\nexport interface MeasuredLength {\n  readonly length: number;\n  readonly metric: StrokeMetric | null;\n}\n\n/** A plain number is a length in the ribbon's own space. */\nexport type InsetLength = number | MeasuredLength;\n\ninterface Trim {\n  length: number;\n  metric: StrokeMetric | null;\n}\n\nconst trimOf = (inset: InsetLength | undefined, ribbon: StrokeMetric | null): Trim =>\n  inset === undefined ? { length: 0, metric: ribbon }\n    : typeof inset === 'number' ? { length: inset, metric: ribbon }\n      : inset;\n\n/**\n * `pl`, whose points are in `from`'s space, trimmed by `start` and `end` and\n * carried into `ribbon`'s — `null` for world in both. `pl` may be mapped in\n * place. Returns `null` when the insets consume the whole run.\n */\nexport function trimInSpace(\n  pl: Polyline,\n  from: StrokeMetric | null,\n  ribbon: StrokeMetric | null,\n  start: InsetLength | undefined,\n  end: InsetLength | undefined,\n): Polyline | null {\n  const s = trimOf(start, ribbon);\n  const e = trimOf(end, ribbon);\n  let cur: Polyline | null = pl;\n  let space = from;\n  const moveTo = (to: StrokeMetric | null) => {\n    if (cur === null || sameMetric(space, to)) return;\n    if (space !== null) polylineOutOfMetric(cur, space);\n    if (to !== null) polylineIntoMetric(cur, to);\n    space = to;\n  };\n  if (s.length > 0 || e.length > 0) {\n    if (sameMetric(s.metric, e.metric)) {\n      moveTo(s.metric);\n      cur = trimPolyline(cur, s.length, e.length);\n    } else {\n      for (const [len, metric, atStart] of [[s.length, s.metric, true], [e.length, e.metric, false]] as const) {\n        if (!(len > 0) || cur === null) continue;\n        moveTo(metric);\n        cur = trimPolyline(cur, atStart ? len : 0, atStart ? 0 : len);\n      }\n    }\n  }\n  moveTo(ribbon);\n  return cur;\n}\n"],"mappings":";;;AA8BA,IAAMA,KAAU,GAAgC,MAC9CC,MAAU,KAAA,IAAY;CAAE,QAAQ;CAAG,QAAQC;AAAO,IAC9C,OAAOD,KAAU,WAAW;CAAE,QAAQA;CAAO,QAAQC;AAAO,IAC1DD;AAOR,SAAgBE,EACd,GACA,GACA,GACA,GACA,GACiB;CACjB,IAAMC,IAAIJ,EAAOK,GAAOH,CAAM,GACxBI,IAAIN,EAAOO,GAAKL,CAAM,GACxBM,IAAuBC,GACvBC,IAAQC,GACNC,KAAU,MAA4B;EAC1C,AAAIJ,MAAQ,QAAQK,EAAWH,GAAOI,CAAE,MACpCJ,MAAU,QAAMK,EAAoBP,GAAKE,CAAK,GAC9CI,MAAO,QAAME,EAAmBR,GAAKM,CAAE,GAC3C,IAAQA;CACV;CACA,IAAIV,EAAE,SAAS,KAAKE,EAAE,SAAS,GAAG;EAChC,IAAIO,EAAWT,EAAE,QAAQE,EAAE,MAAM,GAE/B,AADAM,EAAOR,EAAE,MAAM,GACf,IAAMa,EAAaT,GAAKJ,EAAE,QAAQE,EAAE,MAAM;OAE1C,KAAK,IAAM,CAACY,GAAKC,GAAQC,MAAY,CAAC;GAAChB,EAAE;GAAQA,EAAE;GAAQ;EAAI,GAAG;GAACE,EAAE;GAAQA,EAAE;GAAQ;EAAK,CAAC,GAC3F,AAAMY,IAAM,KAAMV,MAAQ,SAC1BI,EAAOO,CAAM,GACb,IAAMF,EAAaT,GAAKY,IAAUF,IAAM,GAAGE,IAAU,IAAIF,CAAG;CAGlE;CAEA,OADAN,EAAOV,CAAM,GACNM;AACT"}

package/dist/features/paths/tessellate/metric.js

@@ -1,72 +0,0 @@
-//#region src/features/paths/tessellate/metric.ts
-function e(e) {
-	return e === void 0 ? "" : `${r(e.metric)}@${e.pxPerUnit}`;
-}
-var t = 1e-9;
-function n(e, n, r, i) {
-	let a = Math.abs(e * i - n * r), o = Math.sqrt(a);
-	if (!(a > 0) || !Number.isFinite(a)) return {
-		scale: 0,
-		metric: null
-	};
-	let s = (e * e + n * n) / a, c = (e * r + n * i) / a, l = (r * r + i * i) / a, u = Math.sqrt(s + l + 2), d = (s + 1) / u, f = c / u, p = (l + 1) / u;
-	return Math.abs(f) < t && Math.abs(d - p) < t ? {
-		scale: o,
-		metric: null
-	} : {
-		scale: o,
-		metric: {
-			p: d,
-			q: f,
-			r: p
-		}
-	};
-}
-function r(e) {
-	return e === void 0 ? "" : `${e.p},${e.q},${e.r}`;
-}
-function i(e, t) {
-	let n = e.points;
-	for (let e = 0; e < n.length; e += 2) {
-		let r = n[e], i = n[e + 1];
-		n[e] = t.p * r + t.q * i, n[e + 1] = t.q * r + t.r * i;
-	}
-}
-function a(e, t) {
-	let n = e.points;
-	for (let e = 0; e < n.length; e += 2) {
-		let r = n[e], i = n[e + 1];
-		n[e] = t.r * r - t.q * i, n[e + 1] = t.p * i - t.q * r;
-	}
-}
-function o(e, t) {
-	return e === t || e !== null && t !== null && e.p === t.p && e.q === t.q && e.r === t.r;
-}
-function s(e, t, n) {
-	return Math.hypot(e.r * t - e.q * n, e.p * n - e.q * t);
-}
-function c(e, t, n) {
-	return 1 / Math.hypot(e.p * t + e.q * n, e.q * t + e.r * n);
-}
-function l(e, t) {
-	for (let n = 0; n < e.length; n += 2) {
-		let r = e[n], i = e[n + 1];
-		e[n] = t.r * r - t.q * i, e[n + 1] = t.p * i - t.q * r;
-	}
-}
-function u(e) {
-	return e.q === 0;
-}
-function d(e, t) {
-	return u(t) ? {
-		kind: "rect",
-		x: t.p * e.x,
-		y: t.r * e.y,
-		width: t.p * e.width,
-		height: t.r * e.height
-	} : null;
-}
-//#endregion
-export { l as coordsOutOfMetric, u as metricKeepsRects, r as metricKey, i as polylineIntoMetric, a as polylineOutOfMetric, d as rectIntoMetric, o as sameMetric, e as screenSpaceKey, n as strokeSpaceOf, s as worldWidthInMetric, c as worldWidthInMetricAlongWorld };
-
-//# sourceMappingURL=metric.js.map

package/dist/features/paths/tessellate/metric.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"metric.js","names":["screenSpaceKey","space","metricKey","CONFORMAL_EPSILON","strokeSpaceOf","det2","a","d","b","c","scale","g11","g12","g22","s","p","q","r","metric","polylineIntoMetric","pts","pl","i","x","y","m","polylineOutOfMetric","sameMetric","worldWidthInMetric","tx","ty","worldWidthInMetricAlongWorld","ux","uy","coordsOutOfMetric","coords","metricKeepsRects","rectIntoMetric","rect"],"sources":["../../../../src/features/paths/tessellate/metric.ts"],"sourcesContent":["/**\n * The space a screen-pixel stroke is built in.\n *\n * A `{ px }` stroke is exact on screen only when its ribbon is offset in a\n * space that measures lengths the way the screen does. The transform's linear\n * part is `scale · R · P`: a uniform scale, a rotation (or reflection) that\n * moves no lengths, and `P`, the symmetric unit-determinant stretch left over.\n * Offsetting the ribbon after `P` and mapping it back through `P⁻¹` gives a\n * world-space mesh that the full transform turns into a ribbon of exactly\n * `width · scale` pixels in every direction — and keeps the mesh drawable by\n * every path that draws a world-space ribbon.\n *\n * `P` depends only on the lengths the transform induces (`LᵀL`), not on any\n * rotation applied after it, so a view that only pans or zooms uniformly keeps\n * the same metric and the ribbon cache keeps hitting.\n */\nimport type { Polyline } from '@weasel-js/geom/tessellate';\n\n/** `P` = [[p, q], [q, r]], with `pr − q² = 1`. */\nexport interface StrokeMetric {\n  readonly p: number;\n  readonly q: number;\n  readonly r: number;\n}\n\n/** A space a screen-sized part of a stroke is built in: the metric, and how\n *  many screen pixels one of its units is. */\nexport interface ScreenSpace {\n  readonly metric: StrokeMetric;\n  readonly pxPerUnit: number;\n}\n\n/**\n * Where each part of a stroke is built. An absent part is built in world:\n * everything is under a similarity, and otherwise a part whose size is a world\n * length. The ribbon is screen-sized for a `{ px }` width; a head for a\n * `{ px }` size, or for no size on a screen-sized ribbon, since it then takes\n * the stroke width.\n */\nexport interface StrokeSpaces {\n  readonly ribbon?: ScreenSpace;\n  readonly start?: ScreenSpace;\n  readonly mid?: ScreenSpace;\n  readonly end?: ScreenSpace;\n}\n\n/** A cache-key fragment naming `space`; empty for world. */\nexport function screenSpaceKey(space: ScreenSpace | undefined): string {\n  return space === undefined ? '' : `${metricKey(space.metric)}@${space.pxPerUnit}`;\n}\n\n/** Below this, a stretch is a rounding error and the transform a similarity. */\nconst CONFORMAL_EPSILON = 1e-9;\n\n/**\n * Split the linear map `x' = a·x + c·y, y' = b·x + d·y` — a GL `mat3`'s\n * `m[0], m[1], m[3], m[4]` — into its geometric-mean scale and its stroke\n * metric. `metric` is `null` when the map is a similarity, where world space\n * already measures like the screen; `scale` is `0` for a singular map.\n */\nexport function strokeSpaceOf(\n  a: number, b: number, c: number, d: number,\n): { scale: number; metric: StrokeMetric | null } {\n  const det2 = Math.abs(a * d - b * c);\n  const scale = Math.sqrt(det2);\n  if (!(det2 > 0) || !Number.isFinite(det2)) return { scale: 0, metric: null };\n  // G = LᵀL / det, whose determinant is 1, so √G = (G + I) / √(tr G + 2).\n  const g11 = (a * a + b * b) / det2;\n  const g12 = (a * c + b * d) / det2;\n  const g22 = (c * c + d * d) / det2;\n  const s = Math.sqrt(g11 + g22 + 2);\n  const p = (g11 + 1) / s;\n  const q = g12 / s;\n  const r = (g22 + 1) / s;\n  if (Math.abs(q) < CONFORMAL_EPSILON && Math.abs(p - r) < CONFORMAL_EPSILON) {\n    return { scale, metric: null };\n  }\n  return { scale, metric: { p, q, r } };\n}\n\n/** A cache-key fragment naming `metric`; empty for none. */\nexport function metricKey(metric: StrokeMetric | undefined): string {\n  return metric === undefined ? '' : `${metric.p},${metric.q},${metric.r}`;\n}\n\n/** Map `pl`'s points through `P`, in place. */\nexport function polylineIntoMetric(pl: Polyline, m: StrokeMetric): void {\n  const pts = pl.points;\n  for (let i = 0; i < pts.length; i += 2) {\n    const x = pts[i], y = pts[i + 1];\n    pts[i] = m.p * x + m.q * y;\n    pts[i + 1] = m.q * x + m.r * y;\n  }\n}\n\n/** Map `pl`'s points back out through `P⁻¹`, in place. */\nexport function polylineOutOfMetric(pl: Polyline, m: StrokeMetric): void {\n  const pts = pl.points;\n  for (let i = 0; i < pts.length; i += 2) {\n    const x = pts[i], y = pts[i + 1];\n    pts[i] = m.r * x - m.q * y;\n    pts[i + 1] = m.p * y - m.q * x;\n  }\n}\n\n/** Whether two spaces are the same — world being `null`. */\nexport function sameMetric(a: StrokeMetric | null, b: StrokeMetric | null): boolean {\n  if (a === b) return true;\n  return a !== null && b !== null && a.p === b.p && a.q === b.q && a.r === b.r;\n}\n\n/**\n * What one world unit of width, across a line running along the unit\n * direction `(tx, ty)` of the metric's own space, measures in that space.\n * `P` keeps areas, so a strip keeps its area while its length stretches by\n * `|P u|` (`u` the line's world direction): its width shrinks by the same,\n * and `1 / |P u|` is `|P⁻¹ t|`.\n */\nexport function worldWidthInMetric(m: StrokeMetric, tx: number, ty: number): number {\n  return Math.hypot(m.r * tx - m.q * ty, m.p * ty - m.q * tx);\n}\n\n/** The same, for a line running along the unit world direction `(ux, uy)`. */\nexport function worldWidthInMetricAlongWorld(m: StrokeMetric, ux: number, uy: number): number {\n  return 1 / Math.hypot(m.p * ux + m.q * uy, m.q * ux + m.r * uy);\n}\n\n/** Map interleaved x,y pairs back out through `P⁻¹` = [[r, −q], [−q, p]], in\n *  place. */\nexport function coordsOutOfMetric(coords: Float32Array, m: StrokeMetric): void {\n  for (let i = 0; i < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    coords[i] = m.r * x - m.q * y;\n    coords[i + 1] = m.p * y - m.q * x;\n  }\n}\n\n/** Whether `P` takes an axis-aligned rect to another one. */\nexport function metricKeepsRects(m: StrokeMetric): boolean {\n  return m.q === 0;\n}\n\n/** `rect` in the metric's space, while `P` keeps it axis-aligned; otherwise\n *  `null`, and the rect has to be carried as a polygon. */\nexport function rectIntoMetric(\n  rect: { x: number; y: number; width: number; height: number },\n  m: StrokeMetric,\n): { kind: 'rect'; x: number; y: number; width: number; height: number } | null {\n  if (!metricKeepsRects(m)) return null;\n  return { kind: 'rect', x: m.p * rect.x, y: m.r * rect.y, width: m.p * rect.width, height: m.r * rect.height };\n}\n"],"mappings":"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"}