@weasel-js/core 1.9.3 → 1.10.0

package/dist/features/paths/anchorEdits.js

@@ -1,156 +0,0 @@
-import { withinPxRadius as e } from "../../core/viewport/pxExtent.js";
-import { anchorsToPath as t, isAnchorSmooth as n, isStraightSegment as r, nearestSegmentT as i, pathToAnchors as a, segmentEnds as o } from "./anchors.js";
-import { cubicPointAt as s, fitCubicThroughDeletion as c, splitCubicAtT as l } from "@weasel-js/geom";
-//#region src/features/paths/anchorEdits.ts
-function u(e, t) {
-	if (t < 0) return null;
-	let n = t;
-	for (let t = 0; t < e.anchors.length; t++) {
-		let r = e.anchors[t].length;
-		if (n < r) return {
-			sub: t,
-			idx: n
-		};
-		n -= r;
-	}
-	return null;
-}
-function d(e, t, n) {
-	if (t < 0 || t >= e.anchors.length || n < 0 || n >= e.anchors[t].length) return -1;
-	let r = 0;
-	for (let n = 0; n < t; n++) r += e.anchors[n].length;
-	return r + n;
-}
-function f(e, t) {
-	let n = u(e, t);
-	return n ? e.anchors[n.sub][n.idx] ?? null : null;
-}
-function p(e, n) {
-	let r = a(e);
-	return n(r) === !1 ? null : t(r.anchors, r.closed);
-}
-function m(e, t, n, r) {
-	let i = f(e, t);
-	return i ? (i.x += n, i.y += r, i.inHandle && (i.inHandle.x += n, i.inHandle.y += r), i.outHandle && (i.outHandle.x += n, i.outHandle.y += r), !0) : !1;
-}
-function h(e, t, r, i, a, o) {
-	let s = f(e, t);
-	if (!s) return !1;
-	let c = n(s), l = {
-		x: i,
-		y: a
-	};
-	r === "out" ? s.outHandle = l : s.inHandle = l;
-	let u = r === "out" ? "in" : "out", d = u === "in" ? s.inHandle : s.outHandle;
-	if (!o && c && d) {
-		let e = {
-			x: 2 * s.x - l.x,
-			y: 2 * s.y - l.y
-		};
-		u === "in" ? s.inHandle = e : s.outHandle = e;
-	}
-	return !0;
-}
-function g(e, t) {
-	let n = o(e.anchors, e.closed, t.sub, t.segIdx);
-	if (!n) return -1;
-	let { a: i, b: a } = n, s = t.segIdx + 1;
-	if (r(i, a)) return e.anchors[t.sub].splice(s, 0, {
-		x: i.x + (a.x - i.x) * t.t,
-		y: i.y + (a.y - i.y) * t.t
-	}), d(e, t.sub, s);
-	let c = i, u = i.outHandle ?? i, f = a.inHandle ?? a, { left: p, right: m } = l(c, u, f, a, t.t);
-	return i.outHandle = {
-		x: p[1].x,
-		y: p[1].y
-	}, a.inHandle = {
-		x: m[2].x,
-		y: m[2].y
-	}, e.anchors[t.sub].splice(s, 0, {
-		x: p[3].x,
-		y: p[3].y,
-		inHandle: {
-			x: p[2].x,
-			y: p[2].y
-		},
-		outHandle: {
-			x: m[1].x,
-			y: m[1].y
-		}
-	}), d(e, t.sub, s);
-}
-function _(t, n, r, a) {
-	let s = a.scale ?? {
-		x: 1,
-		y: 1
-	}, c = (e) => ({
-		x: e.x * s.x,
-		y: e.y * s.y
-	}), l = t.anchors.map((e) => e.map((e) => ({
-		...c(e),
-		...e.inHandle ? { inHandle: c(e.inHandle) } : {},
-		...e.outHandle ? { outHandle: c(e.outHandle) } : {}
-	}))), u = i(l, n * s.x, r * s.y, t.closed);
-	if (!u) return null;
-	let d = o(t.anchors, t.closed, u.sub, u.segIdx), f = v(d.a, d.b, u.t), p = a.tolerancePx;
-	return !e(f.x - n, f.y - r, p, s) || e(f.x - d.a.x, f.y - d.a.y, p, s) || e(f.x - d.b.x, f.y - d.b.y, p, s) ? null : {
-		sub: u.sub,
-		segIdx: u.segIdx,
-		t: u.t,
-		x: f.x,
-		y: f.y
-	};
-}
-function v(e, t, n) {
-	return r(e, t) ? {
-		x: e.x + (t.x - e.x) * n,
-		y: e.y + (t.y - e.y) * n
-	} : s(e, e.outHandle ?? e, t.inHandle ?? t, t, n);
-}
-function y(e, t) {
-	let n = /* @__PURE__ */ new Map();
-	for (let r of t) {
-		let t = u(e, r);
-		if (!t) continue;
-		let i = n.get(t.sub);
-		i ? i.push(t.idx) : n.set(t.sub, [t.idx]);
-	}
-	if (n.size === 0) return !1;
-	let r = 0;
-	for (let t = 0; t < e.anchors.length; t++) {
-		let i = n.get(t)?.length ?? 0;
-		e.anchors[t].length - i >= 2 && r++;
-	}
-	if (r === 0) return !1;
-	for (let [t, r] of n) {
-		let n = e.anchors[t];
-		if (n) {
-			r.sort((e, t) => t - e);
-			for (let e of r) {
-				let t = n[e - 1], r = n[e + 1];
-				if (t && r) {
-					let { c1: e, c2: n } = c(t, r);
-					t.outHandle = e, r.inHandle = n;
-				}
-				n.splice(e, 1);
-			}
-		}
-	}
-	for (let t = e.anchors.length - 1; t >= 0; t--) e.anchors[t].length < 2 && (e.anchors.splice(t, 1), e.closed.splice(t, 1));
-	return !0;
-}
-function b(e, t) {
-	let n = u(e, t);
-	if (!n || !e.closed[n.sub]) return !1;
-	let r = e.anchors[n.sub];
-	return r ? (e.anchors[n.sub] = [...r.slice(n.idx), ...r.slice(0, n.idx)], e.closed[n.sub] = !1, !0) : !1;
-}
-function x(e, t) {
-	let n = t.x + t.width, r = t.y + t.height, i = [], a = 0;
-	for (let o of e.anchors) for (let e of o) e.x >= t.x && e.x <= n && e.y >= t.y && e.y <= r && i.push(a), a++;
-	return i;
-}
-//#endregion
-export { f as anchorAt, x as anchorsInRect, y as deleteAnchorsAt, p as editAnchorSet, d as flatAnchorIndex, g as insertAnchorOnSegment, u as locateAnchor, h as moveHandleTo, b as openSubpathAt, _ as segmentAt, m as translateAnchorBy };
-
-//# sourceMappingURL=anchorEdits.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"anchorEdits.js","names":["p3","locateAnchor","flatIndex","remaining","sub","set","len","flatAnchorIndex","idx","base","s","anchorAt","loc","editAnchorSet","pathToAnchors","path","edit","anchorsToPath","translateAnchorBy","a","dx","dy","moveHandleTo","wasSmooth","isAnchorSmooth","target","toX","toY","side","oppositeSide","opposite","breakSmoothness","mirrored","insertAnchorOnSegment","ends","segmentEnds","args","at","isStraightSegment","b","p0","p1","p2","splitCubicAtT","left","right","segmentAt","scale","opts","onScreen","p","screenAnchors","hit","nearestSegmentT","x","y","point","pointOnSegment","tol","withinPxRadius","t","cubicPointAt","deleteAnchorsAt","bySub","flat","flatIndexes","list","survivors","doomed","indices","i","prev","next","fitCubicThroughDeletion","c1","c2","openSubpathAt","anchorsInRect","x2","rect","y2","hits"],"sources":["../../../src/features/paths/anchorEdits.ts"],"sourcesContent":["/**\n * Pure anchor-set edits — the geometry half of path editing, with no\n * dependency on any tool's scratch or on the action layer.\n *\n * The model is the one `pathToAnchors` produces: subpath-major\n * `PenAnchor[][]` plus a parallel `closed: boolean[]`. Every function here\n * mutates that structure in place; callers decode with `pathToAnchors`,\n * apply, and re-encode with `anchorsToPath` (see {@link editAnchorSet}).\n *\n * ## Two ways to name an anchor\n *\n * Callers address anchors by **flat index** — the sequential position in\n * walk order across all subpaths, which is exactly what\n * `enumerateAnchors` reports and therefore what the dispatcher's\n * `anchor:N` / `controlIn:N` / `controlOut:N` affordance kinds carry.\n * Internally, operations that have to reason about subpath structure\n * (deletion, scissors) need the `(sub, idx)` pair instead.\n * {@link locateAnchor} and {@link flatAnchorIndex} convert.\n *\n * The two orders agree because `pathToAnchors` and `enumerateAnchors`\n * walk the same command stream and emit one anchor per M/L/C/Q — see the\n * invariant test in `anchorEdits.test.ts`. If you change either walker,\n * that test is the tripwire.\n */\n\nimport { cubicPointAt, fitCubicThroughDeletion, splitCubicAtT, type PolygonPath } from '@weasel-js/geom';\nimport {\n  pathToAnchors,\n  anchorsToPath,\n  isAnchorSmooth,\n  isStraightSegment,\n  nearestSegmentT,\n  segmentEnds,\n  type PenAnchor,\n} from './anchors';\nimport { withinPxRadius, type Scale2 } from 'core/viewport/pxExtent';\n\n/** Subpath-major anchor model — the decoded form of a `PolygonPath`. */\nexport interface AnchorSet {\n  anchors: PenAnchor[][];\n  closed: boolean[];\n}\n\n/** A world-space rectangle, as produced by a drag-rect gesture. */\nexport interface AnchorRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n// ---------------------------------------------------------------------------\n// Addressing\n// ---------------------------------------------------------------------------\n\n/** Total anchors across every subpath. */\nexport function anchorCount(set: AnchorSet): number {\n  let n = 0;\n  for (const sub of set.anchors) n += sub.length;\n  return n;\n}\n\n/** Flat index → `(sub, idx)`. Returns null when out of range. */\nexport function locateAnchor(\n  set: AnchorSet,\n  flatIndex: number,\n): { sub: number; idx: number } | null {\n  if (flatIndex < 0) return null;\n  let remaining = flatIndex;\n  for (let sub = 0; sub < set.anchors.length; sub++) {\n    const len = set.anchors[sub].length;\n    if (remaining < len) return { sub, idx: remaining };\n    remaining -= len;\n  }\n  return null;\n}\n\n/** `(sub, idx)` → flat index. Returns -1 when out of range. */\nexport function flatAnchorIndex(set: AnchorSet, sub: number, idx: number): number {\n  if (sub < 0 || sub >= set.anchors.length) return -1;\n  if (idx < 0 || idx >= set.anchors[sub].length) return -1;\n  let base = 0;\n  for (let s = 0; s < sub; s++) base += set.anchors[s].length;\n  return base + idx;\n}\n\n/** Resolve a flat index to the anchor itself. Null when out of range. */\nexport function anchorAt(set: AnchorSet, flatIndex: number): PenAnchor | null {\n  const loc = locateAnchor(set, flatIndex);\n  if (!loc) return null;\n  return set.anchors[loc.sub][loc.idx] ?? null;\n}\n\n// ---------------------------------------------------------------------------\n// Decode / apply / encode\n// ---------------------------------------------------------------------------\n\n/**\n * Decode `path`, hand the mutable anchor set to `edit`, and re-encode.\n * Returns the new path, or null when `edit` reports that it changed\n * nothing (returning `false`) — callers use that to skip a no-op commit\n * and avoid pushing an empty history entry.\n */\nexport function editAnchorSet(\n  path: PolygonPath,\n  edit: (set: AnchorSet) => boolean | void,\n): PolygonPath | null {\n  const set = pathToAnchors(path) as AnchorSet;\n  const changed = edit(set);\n  if (changed === false) return null;\n  return anchorsToPath(set.anchors, set.closed);\n}\n\n// ---------------------------------------------------------------------------\n// Edits\n// ---------------------------------------------------------------------------\n\n/** Translate an anchor and both of its handles by `(dx, dy)`. */\nexport function translateAnchorBy(\n  set: AnchorSet,\n  flatIndex: number,\n  dx: number,\n  dy: number,\n): boolean {\n  const a = anchorAt(set, flatIndex);\n  if (!a) return false;\n  a.x += dx;\n  a.y += dy;\n  if (a.inHandle) {\n    a.inHandle.x += dx;\n    a.inHandle.y += dy;\n  }\n  if (a.outHandle) {\n    a.outHandle.x += dx;\n    a.outHandle.y += dy;\n  }\n  return true;\n}\n\n/**\n * Move one control handle to an absolute world position.\n *\n * When the anchor was smooth (handles collinear through the anchor) and\n * `breakSmoothness` is false, the opposite handle is mirrored so the curve\n * stays smooth — Illustrator's default. Alt-drag sets `breakSmoothness`\n * and the two handles become independent.\n */\nexport function moveHandleTo(\n  set: AnchorSet,\n  flatIndex: number,\n  side: 'in' | 'out',\n  toX: number,\n  toY: number,\n  breakSmoothness: boolean,\n): boolean {\n  const a = anchorAt(set, flatIndex);\n  if (!a) return false;\n  const wasSmooth = isAnchorSmooth(a);\n  const target = { x: toX, y: toY };\n  if (side === 'out') a.outHandle = target;\n  else a.inHandle = target;\n  const oppositeSide = side === 'out' ? 'in' : 'out';\n  const opposite = oppositeSide === 'in' ? a.inHandle : a.outHandle;\n  if (!breakSmoothness && wasSmooth && opposite) {\n    const mirrored = { x: 2 * a.x - target.x, y: 2 * a.y - target.y };\n    if (oppositeSide === 'in') a.inHandle = mirrored;\n    else a.outHandle = mirrored;\n  }\n  return true;\n}\n\n/**\n * Split the segment `(sub, segIdx) → (sub, segIdx + 1)` at parameter `t`,\n * inserting a new anchor there. On a closed subpath `segIdx` may also name\n * the closing segment (`sub.length - 1`); its new anchor is appended.\n *\n * A straight segment splits linearly and stays straight — the new anchor\n * has no handles. A curved one splits by de Casteljau, which preserves the\n * curve exactly: the two halves trace the original path.\n *\n * Returns the new anchor's flat index, or -1 when the segment doesn't\n * exist.\n */\nexport function insertAnchorOnSegment(\n  set: AnchorSet,\n  args: { sub: number; segIdx: number; t: number },\n): number {\n  const ends = segmentEnds(set.anchors, set.closed, args.sub, args.segIdx);\n  if (!ends) return -1;\n  const { a, b } = ends;\n  const at = args.segIdx + 1;\n  if (isStraightSegment(a, b)) {\n    set.anchors[args.sub].splice(at, 0, {\n      x: a.x + (b.x - a.x) * args.t,\n      y: a.y + (b.y - a.y) * args.t,\n    });\n    return flatAnchorIndex(set, args.sub, at);\n  }\n  const p0 = a, p1 = a.outHandle ?? a, p2 = b.inHandle ?? b, p3 = b;\n  const { left, right } = splitCubicAtT(p0, p1, p2, p3, args.t);\n  a.outHandle = { x: left[1].x, y: left[1].y };\n  b.inHandle = { x: right[2].x, y: right[2].y };\n  set.anchors[args.sub].splice(at, 0, {\n    x: left[3].x,\n    y: left[3].y,\n    inHandle: { x: left[2].x, y: left[2].y },\n    outHandle: { x: right[1].x, y: right[1].y },\n  });\n  return flatAnchorIndex(set, args.sub, at);\n}\n\n/** A point on a segment, as {@link segmentAt} reports it. */\nexport interface SegmentHit {\n  sub: number;\n  segIdx: number;\n  /** Parameter on the segment — what {@link insertAnchorOnSegment} takes. */\n  t: number;\n  /** The point on the path at `t`, in the set's own space. */\n  x: number;\n  y: number;\n}\n\n/**\n * The segment point under `(x, y)`, when it lies within `tolerancePx` of\n * the path on screen and no nearer than that to either of the segment's\n * own anchors — a press on an anchor is about the anchor, not the segment\n * beside it.\n *\n * `scale` is the view's, so the tolerance holds per axis under\n * non-uniform zoom. The search runs in screen-scaled space: scaling is\n * affine, so the curve's parameterization, and therefore `t`, carries\n * straight back to world space.\n */\nexport function segmentAt(\n  set: AnchorSet,\n  x: number,\n  y: number,\n  opts: { tolerancePx: number; scale?: Scale2 },\n): SegmentHit | null {\n  const scale = opts.scale ?? { x: 1, y: 1 };\n  const onScreen = (p: { x: number; y: number }) => ({ x: p.x * scale.x, y: p.y * scale.y });\n  const screenAnchors = set.anchors.map((sub) => sub.map((a) => ({\n    ...onScreen(a),\n    ...(a.inHandle ? { inHandle: onScreen(a.inHandle) } : {}),\n    ...(a.outHandle ? { outHandle: onScreen(a.outHandle) } : {}),\n  })));\n  const hit = nearestSegmentT(screenAnchors, x * scale.x, y * scale.y, set.closed);\n  if (!hit) return null;\n  const ends = segmentEnds(set.anchors, set.closed, hit.sub, hit.segIdx)!;\n  const point = pointOnSegment(ends.a, ends.b, hit.t);\n  const tol = opts.tolerancePx;\n  if (!withinPxRadius(point.x - x, point.y - y, tol, scale)) return null;\n  if (withinPxRadius(point.x - ends.a.x, point.y - ends.a.y, tol, scale)) return null;\n  if (withinPxRadius(point.x - ends.b.x, point.y - ends.b.y, tol, scale)) return null;\n  return { sub: hit.sub, segIdx: hit.segIdx, t: hit.t, x: point.x, y: point.y };\n}\n\nfunction pointOnSegment(a: PenAnchor, b: PenAnchor, t: number): { x: number; y: number } {\n  if (isStraightSegment(a, b)) return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };\n  return cubicPointAt(a, a.outHandle ?? a, b.inHandle ?? b, b, t);\n}\n\n/**\n * Delete the anchors at `flatIndexes`. Where a deleted anchor had\n * neighbors on both sides, the surviving segment is refitted through the\n * gap (`fitCubicThroughDeletion`) so the path keeps its shape instead of\n * snapping to a straight line.\n *\n * Subpaths left with fewer than two anchors are dropped entirely — a\n * one-anchor subpath has no segments and would serialize to a stray `M`.\n *\n * If that would leave the path with **no** subpaths at all, the whole\n * deletion is refused (returns false, `set` untouched). Committing an\n * empty path turns the node into an invisible zombie: still selected,\n * still in the scene, nothing on screen and no anchors left to grab it\n * by. Deleting the object is the node-level Delete action's job, and the\n * user asked to delete anchors.\n */\nexport function deleteAnchorsAt(set: AnchorSet, flatIndexes: Iterable<number>): boolean {\n  const bySub = new Map<number, number[]>();\n  for (const flat of flatIndexes) {\n    const loc = locateAnchor(set, flat);\n    if (!loc) continue;\n    const list = bySub.get(loc.sub);\n    if (list) list.push(loc.idx);\n    else bySub.set(loc.sub, [loc.idx]);\n  }\n  if (bySub.size === 0) return false;\n\n  // Refuse up front if this would wipe the path out — cheaper and safer\n  // than mutating and rolling back.\n  let survivors = 0;\n  for (let s = 0; s < set.anchors.length; s++) {\n    const doomed = bySub.get(s)?.length ?? 0;\n    if (set.anchors[s].length - doomed >= 2) survivors++;\n  }\n  if (survivors === 0) return false;\n\n  for (const [s, indices] of bySub) {\n    const sub = set.anchors[s];\n    if (!sub) continue;\n    // Descending so each splice leaves the not-yet-processed indices valid.\n    indices.sort((a, b) => b - a);\n    for (const i of indices) {\n      const prev = sub[i - 1];\n      const next = sub[i + 1];\n      if (prev && next) {\n        const { c1, c2 } = fitCubicThroughDeletion(prev, next);\n        prev.outHandle = c1;\n        next.inHandle = c2;\n      }\n      sub.splice(i, 1);\n    }\n  }\n\n  // Drop degenerate subpaths, back to front so indices stay valid.\n  for (let s = set.anchors.length - 1; s >= 0; s--) {\n    if (set.anchors[s].length < 2) {\n      set.anchors.splice(s, 1);\n      set.closed.splice(s, 1);\n    }\n  }\n  return true;\n}\n\n/**\n * Scissors: open a closed subpath at the given anchor, rotating the\n * anchor list so the cut point becomes the new start/end. No-ops on an\n * already-open subpath — there's nothing to cut.\n */\nexport function openSubpathAt(set: AnchorSet, flatIndex: number): boolean {\n  const loc = locateAnchor(set, flatIndex);\n  if (!loc) return false;\n  if (!set.closed[loc.sub]) return false;\n  const sub = set.anchors[loc.sub];\n  if (!sub) return false;\n  set.anchors[loc.sub] = [...sub.slice(loc.idx), ...sub.slice(0, loc.idx)];\n  set.closed[loc.sub] = false;\n  return true;\n}\n\n/** Flat indices of every anchor whose on-curve point falls inside `rect`. */\nexport function anchorsInRect(set: AnchorSet, rect: AnchorRect): number[] {\n  const x2 = rect.x + rect.width;\n  const y2 = rect.y + rect.height;\n  const hits: number[] = [];\n  let flat = 0;\n  for (const sub of set.anchors) {\n    for (const a of sub) {\n      if (a.x >= rect.x && a.x <= x2 && a.y >= rect.y && a.y <= y2) hits.push(flat);\n      flat++;\n    }\n  }\n  return hits;\n}\n"],"mappings":"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"}

package/dist/features/paths/anchors.js

@@ -1,154 +0,0 @@
-import { PATH_C as e, PATH_L as t, PATH_M as n, PATH_Q as r, PATH_Z as i, PathBuilder as a, forEachSegment as o, nearestOnCubic as s, nearestOnLine as c } from "@weasel-js/geom";
-//#region src/features/paths/anchors.ts
-function l(a) {
-	let { commands: s, coords: c } = a, l = [], u = [], d = null;
-	return o(s, c, (a, o) => {
-		switch (a) {
-			case n:
-				d && (l.push(d), u.push(!1)), d = [{
-					x: c[o],
-					y: c[o + 1]
-				}];
-				break;
-			case t:
-				if (!d) throw Error("pathToAnchors: L without prior M");
-				d.push({
-					x: c[o],
-					y: c[o + 1]
-				});
-				break;
-			case e: {
-				if (!d) throw Error("pathToAnchors: C without prior M");
-				let e = d[d.length - 1];
-				e.outHandle = {
-					x: c[o],
-					y: c[o + 1]
-				}, d.push({
-					x: c[o + 4],
-					y: c[o + 5],
-					inHandle: {
-						x: c[o + 2],
-						y: c[o + 3]
-					}
-				});
-				break;
-			}
-			case r: {
-				if (!d) throw Error("pathToAnchors: Q without prior M");
-				let e = {
-					x: c[o],
-					y: c[o + 1]
-				}, t = d[d.length - 1];
-				t.outHandle = e, d.push({
-					x: c[o + 2],
-					y: c[o + 3],
-					inHandle: { ...e }
-				});
-				break;
-			}
-			case i:
-				d &&= (l.push(d), u.push(!0), null);
-				break;
-			default: throw Error(`pathToAnchors: unknown command ${a}`);
-		}
-	}), d && (l.push(d), u.push(!1)), {
-		anchors: l,
-		closed: u
-	};
-}
-function u(e, t) {
-	let n = new a();
-	for (let r = 0; r < e.length; r++) {
-		let i = e[r];
-		if (i.length !== 0) {
-			n.moveTo(i[0].x, i[0].y);
-			for (let e = 1; e < i.length; e++) {
-				let t = i[e - 1], r = i[e];
-				if (t.outHandle == null && r.inHandle == null) n.lineTo(r.x, r.y);
-				else {
-					let e = t.outHandle ?? {
-						x: t.x,
-						y: t.y
-					}, i = r.inHandle ?? {
-						x: r.x,
-						y: r.y
-					};
-					n.curveTo(e.x, e.y, i.x, i.y, r.x, r.y);
-				}
-			}
-			if (t[r]) {
-				let e = i[i.length - 1], t = i[0];
-				if (e.outHandle != null || t.inHandle != null) {
-					let r = e.outHandle ?? {
-						x: e.x,
-						y: e.y
-					}, i = t.inHandle ?? {
-						x: t.x,
-						y: t.y
-					};
-					n.curveTo(r.x, r.y, i.x, i.y, t.x, t.y);
-				}
-				n.close();
-			}
-		}
-	}
-	return n.build();
-}
-var d = .001;
-function f(e) {
-	if (!e.inHandle || !e.outHandle) return !1;
-	let t = e.inHandle.x - e.x, n = e.inHandle.y - e.y, r = e.outHandle.x - e.x, i = e.outHandle.y - e.y, a = Math.hypot(t, n), o = Math.hypot(r, i);
-	if (a === 0 || o === 0) return !1;
-	let s = (t * i - n * r) / (a * o);
-	return Math.abs(s) < d;
-}
-function p(i) {
-	if (i.kind === "rect") return 4;
-	let a = i.commands, o = 0;
-	for (let i = 0; i < a.length; i++) {
-		let s = a[i];
-		(s === n || s === t || s === e || s === r) && o++;
-	}
-	return o;
-}
-function m(e, t, n, r) {
-	let i = e[n];
-	return !i || r < 0 ? null : r + 1 < i.length ? {
-		a: i[r],
-		b: i[r + 1]
-	} : t?.[n] && i.length > 1 && r === i.length - 1 ? {
-		a: i[r],
-		b: i[0]
-	} : null;
-}
-function h(e, t) {
-	return e.outHandle == null && t.inHandle == null;
-}
-function g(e, t, n, r) {
-	let i = e.outHandle ?? e, a = t.inHandle ?? t, o = h(e, t) ? c(n, r, e.x, e.y, t.x, t.y) : s(n, r, e.x, e.y, i.x, i.y, a.x, a.y, t.x, t.y);
-	return {
-		t: o.t,
-		d2: o.dist * o.dist
-	};
-}
-function _(e, t, n, r) {
-	let i = Infinity, a = null;
-	for (let o = 0; o < e.length; o++) {
-		let s = e[o].length - +!r?.[o];
-		for (let c = 0; c < s; c++) {
-			let s = m(e, r, o, c);
-			if (!s) continue;
-			let l = g(s.a, s.b, t, n);
-			l.d2 < i && (i = l.d2, a = {
-				sub: o,
-				segIdx: c,
-				t: l.t
-			});
-		}
-	}
-	return a;
-}
-//#endregion
-export { u as anchorsToPath, p as countPathAnchors, f as isAnchorSmooth, h as isStraightSegment, _ as nearestSegmentT, l as pathToAnchors, m as segmentEnds };
-
-//# sourceMappingURL=anchors.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"anchors.js","names":["pathToAnchors","path","anchors","closed","current","forEachSegment","commands","coords","cmd","PATH_M","ci","PATH_L","PATH_C","prev","PATH_Q","handle","PATH_Z","anchorsToPath","b","PathBuilder","s","sub","i","cur","c1","c2","last","first","SMOOTH_THRESHOLD","isAnchorSmooth","a","inDX","inDY","outDX","outDY","inLen","outLen","cross","countPathAnchors","cmds","n","c","segmentEnds","segIdx","isStraightSegment","nearestOnSegment","p1","p2","hit","nearestOnLine","x","y","nearestOnCubic","nearestSegmentT","bestD2","best","segCount","ends","wx","wy"],"sources":["../../../src/features/paths/anchors.ts"],"sourcesContent":["/**\n * Counts the path anchors used by the per-anchor coloring surface. An\n * \"anchor\" is the destination point of a path command: M, L, C, Q each\n * contribute one (the (x, y) where the pen ends up); Z contributes none\n * (it closes back to the subpath's first M). RectPath has four implicit\n * anchors — the corners — matching its M/L/L/L/Z stroke tessellation.\n *\n * Consumers use this to size their per-anchor color array; the renderer\n * uses it to validate the array length in dev builds.\n */\n\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type Path,\n  type PolygonPath,\n  forEachSegment,\n  nearestOnCubic,\n  nearestOnLine,\n  PathBuilder,\n} from '@weasel-js/geom';\n\n/** One anchor of an editable path: its on-curve point plus the two control\n *  handles that shape the segments either side of it. Handles are in the same\n *  space as the point, and absent when the adjoining segment is straight. */\nexport interface PenAnchor {\n  x: number;\n  y: number;\n  inHandle?: { x: number; y: number };\n  outHandle?: { x: number; y: number };\n}\n\n/**\n * Derive a per-subpath anchor model from a PolygonPath. Subpaths split on\n * every `M` command; a subpath is closed iff it ends with `Z`.\n *\n * Cubic-segment control points become the outHandle of the previous anchor\n * and the inHandle of the next anchor. Quadratic segments are upgraded to\n * cubics (each control reused for both adjacent handles) — this loses no\n * geometry. Linear segments produce anchors with no handles.\n */\nexport function pathToAnchors(\n  path: PolygonPath,\n): { anchors: PenAnchor[][]; closed: boolean[] } {\n  const { commands, coords } = path;\n  const anchors: PenAnchor[][] = [];\n  const closed: boolean[] = [];\n  let current: PenAnchor[] | null = null;\n\n  forEachSegment(commands, coords, (cmd, ci) => {\n    switch (cmd) {\n      case PATH_M: {\n        if (current) { anchors.push(current); closed.push(false); }\n        current = [{ x: coords[ci], y: coords[ci + 1] }];\n        break;\n      }\n      case PATH_L: {\n        if (!current) throw new Error('pathToAnchors: L without prior M');\n        current.push({ x: coords[ci], y: coords[ci + 1] });\n        break;\n      }\n      case PATH_C: {\n        if (!current) throw new Error('pathToAnchors: C without prior M');\n        const prev = current[current.length - 1];\n        prev.outHandle = { x: coords[ci], y: coords[ci + 1] };\n        current.push({\n          x: coords[ci + 4], y: coords[ci + 5],\n          inHandle: { x: coords[ci + 2], y: coords[ci + 3] },\n        });\n        break;\n      }\n      case PATH_Q: {\n        if (!current) throw new Error('pathToAnchors: Q without prior M');\n        // Quadratic → cubic: handle is the same control point on both sides.\n        const handle = { x: coords[ci], y: coords[ci + 1] };\n        const prev = current[current.length - 1];\n        prev.outHandle = handle;\n        current.push({ x: coords[ci + 2], y: coords[ci + 3], inHandle: { ...handle } });\n        break;\n      }\n      case PATH_Z: {\n        if (current) { anchors.push(current); closed.push(true); current = null; }\n        break;\n      }\n      default:\n        throw new Error(`pathToAnchors: unknown command ${cmd}`);\n    }\n  });\n  if (current) { anchors.push(current); closed.push(false); }\n  return { anchors, closed };\n}\n\n/**\n * Serialize the per-subpath anchor model back to a PolygonPath. Inverse of\n * `pathToAnchors`. Curve-vs-line decision per segment:\n *   - Both adjacent handles absent → straight L segment.\n *   - Either handle present → C segment, with missing handles defaulting to\n *     the anchor point itself (degenerate but valid; renders as a near-line).\n */\nexport function anchorsToPath(\n  anchors: PenAnchor[][],\n  closed: boolean[],\n): PolygonPath {\n  const b = new PathBuilder();\n  for (let s = 0; s < anchors.length; s++) {\n    const sub = anchors[s];\n    if (sub.length === 0) continue;\n    b.moveTo(sub[0].x, sub[0].y);\n    for (let i = 1; i < sub.length; i++) {\n      const prev = sub[i - 1];\n      const cur = sub[i];\n      const hasHandle = prev.outHandle != null || cur.inHandle != null;\n      if (!hasHandle) {\n        b.lineTo(cur.x, cur.y);\n      } else {\n        const c1 = prev.outHandle ?? { x: prev.x, y: prev.y };\n        const c2 = cur.inHandle ?? { x: cur.x, y: cur.y };\n        b.curveTo(c1.x, c1.y, c2.x, c2.y, cur.x, cur.y);\n      }\n    }\n    if (closed[s]) {\n      // Bridge last → first if they have curve handles; either way emit Z.\n      const last = sub[sub.length - 1];\n      const first = sub[0];\n      const hasHandle = last.outHandle != null || first.inHandle != null;\n      if (hasHandle) {\n        const c1 = last.outHandle ?? { x: last.x, y: last.y };\n        const c2 = first.inHandle ?? { x: first.x, y: first.y };\n        b.curveTo(c1.x, c1.y, c2.x, c2.y, first.x, first.y);\n      }\n      b.close();\n    }\n  }\n  return b.build();\n}\n\nconst SMOOTH_THRESHOLD = 0.001;\n\n/**\n * Returns true if the anchor's in-handle and out-handle are collinear with\n * the anchor point, indicating \"smooth\" (mirror-drag) behavior. Detected via\n * the magnitude of the normalized cross product of the two handle vectors.\n *\n * Edge cases:\n *   - Missing in or out handle → false (corner by definition).\n *   - Either handle at zero distance from anchor → false.\n */\nexport function isAnchorSmooth(a: PenAnchor): boolean {\n  if (!a.inHandle || !a.outHandle) return false;\n  const inDX = a.inHandle.x - a.x;\n  const inDY = a.inHandle.y - a.y;\n  const outDX = a.outHandle.x - a.x;\n  const outDY = a.outHandle.y - a.y;\n  const inLen = Math.hypot(inDX, inDY);\n  const outLen = Math.hypot(outDX, outDY);\n  if (inLen === 0 || outLen === 0) return false;\n  // For collinear handles on opposite sides of the anchor, the cross product\n  // of the two handle vectors should be zero. Normalize by both magnitudes.\n  const cross = (inDX * outDY - inDY * outDX) / (inLen * outLen);\n  return Math.abs(cross) < SMOOTH_THRESHOLD;\n}\n\n/** How many anchors a path has. Matches the per-anchor arrays the renderer\n *  expects for `vertexColors`. */\nexport function countPathAnchors(path: Path): number {\n  if (path.kind === 'rect') return 4;\n  const cmds = path.commands;\n  let n = 0;\n  for (let i = 0; i < cmds.length; i++) {\n    const c = cmds[i];\n    if (c === PATH_M || c === PATH_L || c === PATH_C || c === PATH_Q) n++;\n  }\n  return n;\n}\n\n/** The segment `(sub, segIdx)` as its two end anchors, or null when it\n *  doesn't exist. `segIdx === sub.length - 1` names a closed subpath's\n *  closing segment, which runs from the last anchor back to the first. */\nexport function segmentEnds(\n  anchors: readonly PenAnchor[][],\n  closed: readonly boolean[] | undefined,\n  sub: number,\n  segIdx: number,\n): { a: PenAnchor; b: PenAnchor } | null {\n  const s = anchors[sub];\n  if (!s || segIdx < 0) return null;\n  if (segIdx + 1 < s.length) return { a: s[segIdx], b: s[segIdx + 1] };\n  if (closed?.[sub] && s.length > 1 && segIdx === s.length - 1) return { a: s[segIdx], b: s[0] };\n  return null;\n}\n\n/** Whether the segment from `a` to `b` is a straight line (no handles). */\nexport function isStraightSegment(a: PenAnchor, b: PenAnchor): boolean {\n  return a.outHandle == null && b.inHandle == null;\n}\n\n/** Nearest parameter on one segment to `(x, y)`, with its squared distance.\n *  A straight segment is parameterized by arc length (`t` is the fraction of\n *  the way from `a` to `b`), matching how {@link insertAnchorOnSegment}\n *  splits one. */\nfunction nearestOnSegment(a: PenAnchor, b: PenAnchor, x: number, y: number): { t: number; d2: number } {\n  const p1 = a.outHandle ?? a;\n  const p2 = b.inHandle ?? b;\n  const hit = isStraightSegment(a, b)\n    ? nearestOnLine(x, y, a.x, a.y, b.x, b.y)\n    : nearestOnCubic(x, y, a.x, a.y, p1.x, p1.y, p2.x, p2.y, b.x, b.y);\n  return { t: hit.t, d2: hit.dist * hit.dist };\n}\n\n/** The segment of a decoded path nearest `(wx, wy)`, and the parameter `t`\n *  on it closest to that point. Pass `closed` (from `pathToAnchors`) to\n *  include each closed subpath's closing segment, reported as\n *  `segIdx === sub.length - 1`. `t` spans `[0, 1]`, endpoints included.\n *  Returns `null` only when there are no segments. */\nexport function nearestSegmentT(\n  anchors: PenAnchor[][],\n  wx: number,\n  wy: number,\n  closed?: readonly boolean[],\n): { sub: number; segIdx: number; t: number } | null {\n  let bestD2 = Infinity;\n  let best: { sub: number; segIdx: number; t: number } | null = null;\n  for (let s = 0; s < anchors.length; s++) {\n    const segCount = anchors[s].length - (closed?.[s] ? 0 : 1);\n    for (let i = 0; i < segCount; i++) {\n      const ends = segmentEnds(anchors, closed, s, i);\n      if (!ends) continue;\n      const hit = nearestOnSegment(ends.a, ends.b, wx, wy);\n      if (hit.d2 < bestD2) {\n        bestD2 = hit.d2;\n        best = { sub: s, segIdx: i, t: hit.t };\n      }\n    }\n  }\n  return best;\n}\n"],"mappings":";;AA4CA,SAAgBA,EACd,GAC+C;CAC/C,IAAM,EAAE,aAAU,cAAWC,GACvBC,IAAyB,CAAC,GAC1BC,IAAoB,CAAC,GACvBC,IAA8B;CA0ClC,OAxCAC,EAAeC,GAAUC,IAAS,GAAK,MAAO;EAC5C,QAAQC,GAAR;GACE,KAAKC;IAEH,AADIL,MAAWF,EAAQ,KAAKE,CAAO,GAAGD,EAAO,KAAK,EAAK,IACvD,IAAU,CAAC;KAAE,GAAGI,EAAOG;KAAK,GAAGH,EAAOG,IAAK;IAAG,CAAC;IAC/C;GAEF,KAAKC;IACH,IAAI,CAACP,GAAS,MAAU,MAAM,kCAAkC;IAChE,EAAQ,KAAK;KAAE,GAAGG,EAAOG;KAAK,GAAGH,EAAOG,IAAK;IAAG,CAAC;IACjD;GAEF,KAAKE,GAAQ;IACX,IAAI,CAACR,GAAS,MAAU,MAAM,kCAAkC;IAChE,IAAMS,IAAOT,EAAQA,EAAQ,SAAS;IAEtC,AADA,EAAK,YAAY;KAAE,GAAGG,EAAOG;KAAK,GAAGH,EAAOG,IAAK;IAAG,GACpDN,EAAQ,KAAK;KACX,GAAGG,EAAOG,IAAK;KAAI,GAAGH,EAAOG,IAAK;KAClC,UAAU;MAAE,GAAGH,EAAOG,IAAK;MAAI,GAAGH,EAAOG,IAAK;KAAG;IACnD,CAAC;IACD;GACF;GACA,KAAKI,GAAQ;IACX,IAAI,CAACV,GAAS,MAAU,MAAM,kCAAkC;IAEhE,IAAMW,IAAS;KAAE,GAAGR,EAAOG;KAAK,GAAGH,EAAOG,IAAK;IAAG,GAC5CG,IAAOT,EAAQA,EAAQ,SAAS;IAEtC,AADA,EAAK,YAAYW,GACjBX,EAAQ,KAAK;KAAE,GAAGG,EAAOG,IAAK;KAAI,GAAGH,EAAOG,IAAK;KAAI,UAAU,EAAE,GAAGK,EAAO;IAAE,CAAC;IAC9E;GACF;GACA,KAAKC;IACH,AAAyDZ,OAA1CF,EAAQ,KAAKE,CAAO,GAAGD,EAAO,KAAK,EAAI,GAAa;IACnE;GAEF,SACE,MAAU,MAAM,kCAAkCK,GAAK;EAC3D;CACF,CAAC,GACGJ,MAAWF,EAAQ,KAAKE,CAAO,GAAGD,EAAO,KAAK,EAAK,IAChD;EAAE;EAAS;CAAO;AAC3B;AASA,SAAgBc,EACd,GACA,GACa;CACb,IAAMC,IAAI,IAAIC,EAAY;CAC1B,KAAK,IAAIC,IAAI,GAAGA,IAAIlB,EAAQ,QAAQ,KAAK;EACvC,IAAMmB,IAAMnB,EAAQkB;EACpB,IAAIC,EAAI,WAAW,GACnB;KAAE,OAAOA,EAAI,EAAE,CAAC,GAAGA,EAAI,EAAE,CAAC,CAAC;GAC3B,KAAK,IAAIC,IAAI,GAAGA,IAAID,EAAI,QAAQ,KAAK;IACnC,IAAMR,IAAOQ,EAAIC,IAAI,IACfC,IAAMF,EAAIC;IAEhB,IADkBT,EAAK,aAAa,QAAQU,EAAI,YAAY,MAE1D,EAAE,OAAOA,EAAI,GAAGA,EAAI,CAAC;SAChB;KACL,IAAMC,IAAKX,EAAK,aAAa;MAAE,GAAGA,EAAK;MAAG,GAAGA,EAAK;KAAE,GAC9CY,IAAKF,EAAI,YAAY;MAAE,GAAGA,EAAI;MAAG,GAAGA,EAAI;KAAE;KAChD,EAAE,QAAQC,EAAG,GAAGA,EAAG,GAAGC,EAAG,GAAGA,EAAG,GAAGF,EAAI,GAAGA,EAAI,CAAC;IAChD;GACF;GACA,IAAIpB,EAAOiB,IAAI;IAEb,IAAMM,IAAOL,EAAIA,EAAI,SAAS,IACxBM,IAAQN,EAAI;IAElB,IADkBK,EAAK,aAAa,QAAQC,EAAM,YAAY,MAC/C;KACb,IAAMH,IAAKE,EAAK,aAAa;MAAE,GAAGA,EAAK;MAAG,GAAGA,EAAK;KAAE,GAC9CD,IAAKE,EAAM,YAAY;MAAE,GAAGA,EAAM;MAAG,GAAGA,EAAM;KAAE;KACtD,EAAE,QAAQH,EAAG,GAAGA,EAAG,GAAGC,EAAG,GAAGA,EAAG,GAAGE,EAAM,GAAGA,EAAM,CAAC;IACpD;IACA,EAAE,MAAM;GACV;EAxB2B;CAyB7B;CACA,OAAOT,EAAE,MAAM;AACjB;AAEA,IAAMU,IAAmB;AAWzB,SAAgBC,EAAe,GAAuB;CACpD,IAAI,CAACC,EAAE,YAAY,CAACA,EAAE,WAAW,OAAO;CACxC,IAAMC,IAAOD,EAAE,SAAS,IAAIA,EAAE,GACxBE,IAAOF,EAAE,SAAS,IAAIA,EAAE,GACxBG,IAAQH,EAAE,UAAU,IAAIA,EAAE,GAC1BI,IAAQJ,EAAE,UAAU,IAAIA,EAAE,GAC1BK,IAAQ,KAAK,MAAMJ,GAAMC,CAAI,GAC7BI,IAAS,KAAK,MAAMH,GAAOC,CAAK;CACtC,IAAIC,MAAU,KAAKC,MAAW,GAAG,OAAO;CAGxC,IAAMC,KAASN,IAAOG,IAAQF,IAAOC,MAAUE,IAAQC;CACvD,OAAO,KAAK,IAAIC,CAAK,IAAIT;AAC3B;AAIA,SAAgBU,EAAiB,GAAoB;CACnD,IAAIrC,EAAK,SAAS,QAAQ,OAAO;CACjC,IAAMsC,IAAOtC,EAAK,UACduC,IAAI;CACR,KAAK,IAAI,IAAI,GAAG,IAAID,EAAK,QAAQ,KAAK;EACpC,IAAME,IAAIF,EAAK;EACf,CAAIE,MAAMhC,KAAUgC,MAAM9B,KAAU8B,MAAM7B,KAAU6B,MAAM3B,MAAQ;CACpE;CACA,OAAO0B;AACT;AAKA,SAAgBE,EACd,GACA,GACA,GACA,GACuC;CACvC,IAAMtB,IAAIlB,EAAQmB;CAIlB,OAHI,CAACD,KAAKuB,IAAS,IAAU,OACzBA,IAAS,IAAIvB,EAAE,SAAe;EAAE,GAAGA,EAAEuB;EAAS,GAAGvB,EAAEuB,IAAS;CAAG,IAC/DxC,IAASkB,MAAQD,EAAE,SAAS,KAAKuB,MAAWvB,EAAE,SAAS,IAAU;EAAE,GAAGA,EAAEuB;EAAS,GAAGvB,EAAE;CAAG,IACtF;AACT;AAGA,SAAgBwB,EAAkB,GAAc,GAAuB;CACrE,OAAOd,EAAE,aAAa,QAAQZ,EAAE,YAAY;AAC9C;AAMA,SAAS2B,EAAiB,GAAc,GAAc,GAAW,GAAsC;CACrG,IAAMC,IAAKhB,EAAE,aAAaA,GACpBiB,IAAK7B,EAAE,YAAYA,GACnB8B,IAAMJ,EAAkBd,GAAGZ,CAAC,IAC9B+B,EAAcC,GAAGC,GAAGrB,EAAE,GAAGA,EAAE,GAAGZ,EAAE,GAAGA,EAAE,CAAC,IACtCkC,EAAeF,GAAGC,GAAGrB,EAAE,GAAGA,EAAE,GAAGgB,EAAG,GAAGA,EAAG,GAAGC,EAAG,GAAGA,EAAG,GAAG7B,EAAE,GAAGA,EAAE,CAAC;CACnE,OAAO;EAAE,GAAG8B,EAAI;EAAG,IAAIA,EAAI,OAAOA,EAAI;CAAK;AAC7C;AAOA,SAAgBK,EACd,GACA,GACA,GACA,GACmD;CACnD,IAAIC,IAAS,UACTC,IAA0D;CAC9D,KAAK,IAAInC,IAAI,GAAGA,IAAIlB,EAAQ,QAAQ,KAAK;EACvC,IAAMsD,IAAWtD,EAAQkB,EAAE,CAAC,SAAU,MAASA;EAC/C,KAAK,IAAIE,IAAI,GAAGA,IAAIkC,GAAU,KAAK;GACjC,IAAMC,IAAOf,EAAYxC,GAASC,GAAQiB,GAAGE,CAAC;GAC9C,IAAI,CAACmC,GAAM;GACX,IAAMT,IAAMH,EAAiBY,EAAK,GAAGA,EAAK,GAAGC,GAAIC,CAAE;GACnD,AAAIX,EAAI,KAAKM,MACX,IAASN,EAAI,IACb,IAAO;IAAE,KAAK5B;IAAG,QAAQE;IAAG,GAAG0B,EAAI;GAAE;EAEzC;CACF;CACA,OAAOO;AACT"}

package/dist/features/paths/booleans.js

@@ -1,2 +0,0 @@
-import { pathCrop as e, pathDivide as t, pathExclude as n, pathIntersect as r, pathSubtract as i, pathUnion as a } from "@weasel-js/geom/booleans";
-export { e as pathCrop, t as pathDivide, n as pathExclude, r as pathIntersect, i as pathSubtract, a as pathUnion };

package/dist/features/paths/markerCommands.js

@@ -1,148 +0,0 @@
-import { coordsOutOfMetric as e, polylineIntoMetric as t } from "./tessellate/metric.js";
-import { getMarker as n } from "../../core/strokeMarkers.js";
-import { markerKeyOf as r, resolveMarkerSize as i } from "../../core/markerInset.js";
-import { markerSites as a } from "./markerSites.js";
-import { boundsOfPath as o } from "@weasel-js/geom";
-import { extractPolylines as s } from "@weasel-js/geom/tessellate";
-//#region src/features/paths/markerCommands.ts
-function c(e, t) {
-	let n = e, r = Math.cos(t.angle), i = Math.sin(t.angle), a = new Float32Array(n.coords.length);
-	for (let e = 0; e < n.coords.length; e += 2) {
-		let o = n.coords[e], s = n.coords[e + 1];
-		a[e] = t.x + o * r - s * i, a[e + 1] = t.y + o * i + s * r;
-	}
-	return {
-		kind: "polygon",
-		commands: n.commands,
-		coords: a,
-		fillRule: n.fillRule
-	};
-}
-function l(e, t, n) {
-	let r = e ?? n;
-	if (r !== "none") return r === "line" ? t.paint : r;
-}
-function u(o, l, u, d, f = {}) {
-	let p = {
-		start: l.markerStart,
-		mid: l.markerMid,
-		end: l.markerEnd
-	};
-	if (p.start === void 0 && p.mid === void 0 && p.end === void 0) return [];
-	let m = /* @__PURE__ */ new Map();
-	for (let e of [
-		"start",
-		"mid",
-		"end"
-	]) {
-		if (p[e] === void 0) continue;
-		let t = f[e], n = m.get(t);
-		n === void 0 && m.set(t, n = {
-			start: !1,
-			mid: !1,
-			end: !1
-		}), n[e] = !0;
-	}
-	let h = [];
-	for (let f of s(o, { flattenTolerance: d })) for (let [o, s] of m) {
-		let d = o ? {
-			...f,
-			points: f.points.slice()
-		} : f;
-		o && t(d, o.metric);
-		for (let t of a(d, s)) {
-			let a = p[t.role];
-			if (a === void 0) continue;
-			let s = n(r(a));
-			if (s === void 0) continue;
-			let d = i(a, u), f = s.orient === void 0 || s.orient === "auto" ? t.angle : s.orient, m = c(s.path({
-				size: d,
-				stroke: l
-			}), {
-				...t,
-				angle: f
-			});
-			o && e(m.coords, o.metric), h.push(o ? {
-				entry: s,
-				size: d,
-				path: m,
-				space: o
-			} : {
-				entry: s,
-				size: d,
-				path: m
-			});
-		}
-	}
-	return h;
-}
-function d(e, t) {
-	let n = [];
-	for (let { entry: r, path: i, size: a, space: o } of e) {
-		let e = l(r.fill, t, "line"), s = r.outline ? r.outline.width * a : 0, c = r.outline ? {
-			paint: l(r.outline.paint, t, "line"),
-			width: o ? { px: s * o.pxPerUnit } : s
-		} : null;
-		(e !== void 0 || c !== null && c.paint !== void 0) && n.push({
-			kind: "path",
-			path: i,
-			...e ? { fill: e } : {},
-			...c && c.paint ? { stroke: {
-				paint: c.paint,
-				width: c.width,
-				cap: "round",
-				join: "round"
-			} } : {}
-		});
-	}
-	return n;
-}
-function f(e, t) {
-	if (e.reads === void 0) return null;
-	let n = "";
-	for (let r of e.reads) n += `${JSON.stringify(t[r]) ?? ""}|`;
-	return n;
-}
-var p = 64, m = /* @__PURE__ */ new WeakMap(), h = /* @__PURE__ */ new WeakMap();
-function g(e, t) {
-	let n = o(e.path({
-		size: 1,
-		stroke: t
-	}));
-	return Math.max(Math.abs(n.x), Math.abs(n.x + n.width), Math.abs(n.y), Math.abs(n.y + n.height)) + (e.outline ? e.outline.width / 2 : 0);
-}
-function _(e, t) {
-	let n = f(e, t);
-	if (n === null) {
-		let n = h.get(e);
-		n === void 0 && h.set(e, n = /* @__PURE__ */ new WeakMap());
-		let r = n.get(t);
-		return r === void 0 && n.set(t, r = g(e, t)), r;
-	}
-	let r = m.get(e);
-	r === void 0 && m.set(e, r = /* @__PURE__ */ new Map());
-	let i = r.get(n);
-	return i === void 0 && (r.size >= p && r.clear(), r.set(n, i = g(e, t))), i;
-}
-function v(e) {
-	let t = {
-		world: 0,
-		px: 0
-	}, i = e.width ?? 1;
-	for (let a of [
-		e.markerStart,
-		e.markerMid,
-		e.markerEnd
-	]) {
-		if (a === void 0) continue;
-		let o = n(r(a));
-		if (o === void 0) continue;
-		let s = typeof a == "string" || a.size === void 0 ? i : a.size, c = _(o, e);
-		typeof s == "number" ? t.world = Math.max(t.world, c * s) : t.px = Math.max(t.px, c * s.px);
-	}
-	return t;
-}
-//#endregion
-export { d as headCommands, u as markerHeads, v as markerReach, f as markerReadsKey };
-
-//# sourceMappingURL=markerCommands.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"markerCommands.js","names":["placed","src","path","cos","site","sin","coords","i","x","y","resolvePaint","v","p","fallback","stroke","markerHeads","refs","groups","role","space","spaces","want","out","pl","extractPolylines","inSpace","polylineIntoMetric","markerSites","ref","entry","getMarker","markerKeyOf","size","resolveMarkerSize","strokeWidth","angle","head","coordsOutOfMetric","headCommands","heads","fill","width","outline","markerReadsKey","key","field","READINGS_PER_ENTRY","REACH_BY_READING","REACH_BY_STROKE","measureUnitReach","b","boundsOfPath","unitReach","byStroke","reach","byReading","markerReach","unit"],"sources":["../../../src/features/paths/markerCommands.ts"],"sourcesContent":["/**\n * Turning a stroke's markers into draw commands.\n *\n * Separate `PathDrawCommand`s rather than triangles appended to the stroke\n * ribbon: an entry may carry a fill and an outline at once, or a paint that\n * differs from the line's, neither of which one mesh can express — and folding\n * them in would drag the whole marker vocabulary into the ribbon cache key.\n */\n\nimport type { MarkerRef, Stroke } from '@weasel-js/paint';\nimport { type Path, type PolygonPath, boundsOfPath } from '@weasel-js/geom';\nimport type { PathDrawCommand } from '../../renderer/DrawCommand';\nimport { getMarker, type MarkerEntry, type MarkerPaint } from '../../core/strokeMarkers';\nimport { markerKeyOf, resolveMarkerSize } from '../../core/markerInset';\nimport { extractPolylines } from '@weasel-js/geom/tessellate';\nimport { markerSites, type MarkerSite } from './markerSites';\nimport {\n  coordsOutOfMetric, polylineIntoMetric, type ScreenSpace, type StrokeSpaces,\n} from './tessellate/metric';\n\n/** Rotate + translate a marker's geometry onto its site. */\nfunction placed(path: Path, site: MarkerSite): PolygonPath {\n  const src = path as PolygonPath;\n  const cos = Math.cos(site.angle);\n  const sin = Math.sin(site.angle);\n  const coords = new Float32Array(src.coords.length);\n  for (let i = 0; i < src.coords.length; i += 2) {\n    const x = src.coords[i], y = src.coords[i + 1];\n    coords[i] = site.x + x * cos - y * sin;\n    coords[i + 1] = site.y + x * sin + y * cos;\n  }\n  return { kind: 'polygon', commands: src.commands, coords, fillRule: src.fillRule };\n}\n\nfunction resolvePaint(p: MarkerPaint | undefined, stroke: Stroke, fallback: MarkerPaint) {\n  const v = p ?? fallback;\n  if (v === 'none') return undefined;\n  return v === 'line' ? stroke.paint : v;\n}\n\n/** One head's placed geometry, before any paint is applied. */\nexport interface MarkerHead {\n  readonly entry: MarkerEntry;\n  readonly path: PolygonPath;\n  readonly size: number;\n  /** Where it was built, when not in world — `size` is in this space's units. */\n  readonly space?: ScreenSpace;\n}\n\n/**\n * Every marker head for `path` under `stroke`, placed but unpainted.\n * `strokeWidth` is the already width-resolved stroke width; `flattenTolerance`\n * matches what the ribbon used, so heads land on the same flattened vertices\n * the stroke did. A head `spaces` puts in a screen space is placed and sized\n * there and comes back in world units, so it meets the line it caps.\n */\nexport function markerHeads(\n  path: Path,\n  stroke: Stroke,\n  strokeWidth: number,\n  flattenTolerance: number | undefined,\n  spaces: StrokeSpaces = {},\n): MarkerHead[] {\n  const refs = { start: stroke.markerStart, mid: stroke.markerMid, end: stroke.markerEnd };\n  if (refs.start === undefined && refs.mid === undefined && refs.end === undefined) return [];\n\n  // Heads sharing a space share one pass over the polyline mapped into it.\n  const groups = new Map<ScreenSpace | undefined, { start: boolean; mid: boolean; end: boolean }>();\n  for (const role of ['start', 'mid', 'end'] as const) {\n    if (refs[role] === undefined) continue;\n    const space = spaces[role];\n    let want = groups.get(space);\n    if (want === undefined) groups.set(space, (want = { start: false, mid: false, end: false }));\n    want[role] = true;\n  }\n\n  const out: MarkerHead[] = [];\n  for (const pl of extractPolylines(path, { flattenTolerance })) {\n    for (const [space, want] of groups) {\n      const inSpace = space ? { ...pl, points: pl.points.slice() } : pl;\n      if (space) polylineIntoMetric(inSpace, space.metric);\n      for (const site of markerSites(inSpace, want)) {\n        const ref: MarkerRef | undefined = refs[site.role];\n        if (ref === undefined) continue;\n        const entry = getMarker(markerKeyOf(ref));\n        if (entry === undefined) continue;\n        const size = resolveMarkerSize(ref, strokeWidth);\n        const angle = entry.orient === undefined || entry.orient === 'auto' ? site.angle : entry.orient;\n        const head = placed(entry.path({ size, stroke }), { ...site, angle });\n        if (space) coordsOutOfMetric(head.coords, space.metric);\n        out.push(space ? { entry, size, path: head, space } : { entry, size, path: head });\n      }\n    }\n  }\n  return out;\n}\n\n/** `heads` as draw commands in `stroke`'s paint. A head whose fill and outline\n *  both resolve to no paint is dropped. */\nexport function headCommands(heads: readonly MarkerHead[], stroke: Stroke): PathDrawCommand[] {\n  const out: PathDrawCommand[] = [];\n  for (const { entry, path, size, space } of heads) {\n    const fill = resolvePaint(entry.fill, stroke, 'line');\n    // A head built in a screen space is in world once placed, but its outline\n    // width is still in that space's units — so it goes out as the screen\n    // width it stands for, and is stroked as exactly as the line.\n    const width = entry.outline ? entry.outline.width * size : 0;\n    const outline = entry.outline\n      ? { paint: resolvePaint(entry.outline.paint, stroke, 'line'), width: space ? { px: width * space.pxPerUnit } : width }\n      : null;\n    if (fill === undefined && (outline === null || outline.paint === undefined)) continue;\n    out.push({\n      kind: 'path',\n      path,\n      ...(fill ? { fill } : {}),\n      ...(outline && outline.paint\n        ? { stroke: { paint: outline.paint, width: outline.width, cap: 'round', join: 'round' } }\n        : {}),\n    });\n  }\n  return out;\n}\n\n/** Every marker command for `path` under `stroke`; see {@link markerHeads}. */\nexport function markerDrawCommands(\n  path: Path,\n  stroke: Stroke,\n  strokeWidth: number,\n  flattenTolerance: number | undefined,\n): PathDrawCommand[] {\n  return headCommands(markerHeads(path, stroke, strokeWidth, flattenTolerance), stroke);\n}\n\n/**\n * A key for the stroke fields `entry`'s geometry reads, or `null` when the\n * entry does not say which it reads and only the stroke's identity can stand\n * in for them.\n */\nexport function markerReadsKey(entry: MarkerEntry, stroke: Stroke): string | null {\n  if (entry.reads === undefined) return null;\n  let key = '';\n  for (const field of entry.reads) key += `${JSON.stringify(stroke[field]) ?? ''}|`;\n  return key;\n}\n\n/** Distinct stroke readings kept per entry before its map is dropped. */\nconst READINGS_PER_ENTRY = 64;\n\n/** Each entry's farthest reach from its anchor at `size` 1, outline included,\n *  per value of the fields it reads — or per stroke object, when it does not\n *  say which. */\nconst REACH_BY_READING = new WeakMap<MarkerEntry, Map<string, number>>();\nconst REACH_BY_STROKE = new WeakMap<MarkerEntry, WeakMap<Stroke, number>>();\n\nfunction measureUnitReach(entry: MarkerEntry, stroke: Stroke): number {\n  const b = boundsOfPath(entry.path({ size: 1, stroke }));\n  return Math.max(Math.abs(b.x), Math.abs(b.x + b.width), Math.abs(b.y), Math.abs(b.y + b.height))\n    + (entry.outline ? entry.outline.width / 2 : 0);\n}\n\nfunction unitReach(entry: MarkerEntry, stroke: Stroke): number {\n  const key = markerReadsKey(entry, stroke);\n  if (key === null) {\n    let byStroke = REACH_BY_STROKE.get(entry);\n    if (byStroke === undefined) REACH_BY_STROKE.set(entry, (byStroke = new WeakMap()));\n    let reach = byStroke.get(stroke);\n    if (reach === undefined) byStroke.set(stroke, (reach = measureUnitReach(entry, stroke)));\n    return reach;\n  }\n  let byReading = REACH_BY_READING.get(entry);\n  if (byReading === undefined) REACH_BY_READING.set(entry, (byReading = new Map()));\n  let reach = byReading.get(key);\n  if (reach === undefined) {\n    if (byReading.size >= READINGS_PER_ENTRY) byReading.clear();\n    byReading.set(key, (reach = measureUnitReach(entry, stroke)));\n  }\n  return reach;\n}\n\n/**\n * How far `stroke`'s markers can paint from the vertex each sits on, split by\n * where each is built: `world` in world units for a head with a world size,\n * `px` in screen pixels for one with a `{ px }` size. A head with no size\n * takes the stroke width, and with it the width's units. Culling and a path\n * node's grab reach both measure through here.\n */\nexport function markerReach(stroke: Stroke): { world: number; px: number } {\n  const reach = { world: 0, px: 0 };\n  const width = stroke.width ?? 1;\n  for (const ref of [stroke.markerStart, stroke.markerMid, stroke.markerEnd]) {\n    if (ref === undefined) continue;\n    const entry = getMarker(markerKeyOf(ref));\n    if (entry === undefined) continue;\n    const size = typeof ref === 'string' || ref.size === undefined ? width : ref.size;\n    const unit = unitReach(entry, stroke);\n    if (typeof size === 'number') reach.world = Math.max(reach.world, unit * size);\n    else reach.px = Math.max(reach.px, unit * size.px);\n  }\n  return reach;\n}\n"],"mappings":"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"}

package/dist/features/paths/markerSites.js

@@ -1,59 +0,0 @@
-//#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

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