@weasel-js/core 1.7.0 → 1.7.1

package/dist/features/overlays/useNodeOverlayFrame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeOverlayFrame.js","names":["useNodeOverlayFrame","useCanvasSize","containerRef","options","project","useCallback","box","worldBoxOf","scene","nodeId","compose","multiply","viewMatrix","resolveView","view","rotationMatrix","toScreen","m","p","x","y","applyToPoint","lastInverse","useRef","toLocal","inverse","invert","width","height","useInsertionEffect","nodes","composeWorldPose","effectivePose","id","composeRectPose","sx","sy","r","poseRotationOf","pose","c","s"],"sources":["../../../src/features/overlays/useNodeOverlayFrame.ts"],"sourcesContent":["/**\n * `useNodeOverlayFrame` — the coordinate frame a DOM overlay pinned to one\n * scene node needs: the node's world box, the projection from that box's\n * frame into overlay pixels, and the overlay's measured size.\n *\n * This is the frame half of `subscribeView`'s \"DOM pinned to world\n * coordinates\" case. Consumers positioning chrome over a node — gradient\n * handles, a badge, a caret — otherwise re-derive it, and the\n * translate-and-scale inverse that derivation usually reaches for drops\n * `pose.rotation`, so the chrome sits where the node would be unrotated.\n *\n * `toScreen` maps the node's **unrotated world box** frame, which is the\n * frame `fillInPoseFrame` resolves a `units: 'bounds'` paint into and the\n * one `pathInPoseFrame` projects geometry into. Rotation lives in this hook,\n * not in those: a node's stored geometry is pre-rotation by definition.\n */\nimport { useCallback, useInsertionEffect, useRef, type RefObject } from 'react';\nimport { applyToPoint, invert, multiply, type Mat3 } from '@weasel-js/geom';\nimport type { Node, RectPose, Scene } from '../../core/scene/types';\nimport { useCanvasSize } from '../../core/viewport/useCanvasSize';\nimport type { View } from '../../core/viewport/view';\nimport { composeRectPose, composeWorldPose } from '../groups/composePose';\nimport { effectivePose } from 'core/scene/effectivePose';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\n\n/** Structural point, matching every other `{ x, y }` the kit passes across a\n *  boundary. */\nexport interface OverlayPoint {\n  x: number;\n  y: number;\n}\n\n/** The overlay frame for one node. `null` from the hook means there is no\n *  frame yet — no node, or nothing measured to draw it on. */\nexport interface NodeOverlayFrame {\n  /** The node's composed world box, **unrotated**: the frame `toScreen` maps\n   *  from, and the box to hand `fillInPoseFrame` / `fillToBoundsFrame`. */\n  box: { x: number; y: number; width: number; height: number };\n  /** Node box frame → overlay pixels, rotation and view included. */\n  toScreen: (p: OverlayPoint) => OverlayPoint;\n  /** Overlay pixels → node box frame. Inverts `toScreen`; while a live view\n   *  flattens an axis, it keeps the last mapping that had an inverse. */\n  toLocal: (p: OverlayPoint) => OverlayPoint;\n  /** The container's size in CSS pixels — the overlay's own box. */\n  width: number;\n  height: number;\n}\n\n/** Options for `useNodeOverlayFrame`. */\nexport interface UseNodeOverlayFrameOptions<TPose> {\n  /**\n   * Current viewport. A thunk is re-read on every projection, which is what\n   * an uncontrolled `SceneCanvas` needs — its camera lives in a ref and moves\n   * without a render, so pass the handle's `getView`. A plain `View` is the\n   * value from the render that supplied it, correct for a controlled\n   * consumer. Omit it and world units are handed through as screen pixels.\n   */\n  view?: View | (() => View);\n  /** Fold a child pose into its parent's frame. Default `composeRectPose`. */\n  compose?: (parent: TPose, child: TPose) => TPose;\n}\n\n/**\n * Resolve the overlay frame for `nodeId` against `containerRef` — the element\n * the overlay is positioned in, which must be the canvas's own box for the\n * projection to land.\n *\n * Returns `null` when there is no node under `nodeId`, when the container has\n * not been measured, or when the view collapses an axis to zero — the three\n * states in which an overlay has nothing to draw.\n */\nexport function useNodeOverlayFrame<TData, TLayer extends string, TPose extends RectPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  containerRef: RefObject<HTMLElement | null>,\n  nodeId: string | null | undefined,\n  options: UseNodeOverlayFrameOptions<TPose> = {},\n): NodeOverlayFrame | null {\n  const { width, height } = useCanvasSize(containerRef);\n  const { view, compose } = options;\n\n  const project = useCallback((): Mat3 | null => {\n    const box = worldBoxOf(scene, nodeId, compose);\n    if (!box) return null;\n    return multiply(viewMatrix(resolveView(view)), rotationMatrix(box));\n  }, [scene, nodeId, compose, view]);\n\n  const toScreen = useCallback((p: OverlayPoint): OverlayPoint => {\n    const m = project();\n    if (!m) return p;\n    const [x, y] = applyToPoint(m, p.x, p.y);\n    return { x, y };\n  }, [project]);\n\n  const lastInverse = useRef<Mat3 | null>(null);\n\n  const toLocal = useCallback((p: OverlayPoint): OverlayPoint => {\n    const m = project();\n    const inverse = m && invert(m);\n    if (inverse) lastInverse.current = inverse;\n    // Published by the commit that handed this toLocal out, so there is one.\n    const [x, y] = applyToPoint(inverse ?? lastInverse.current!, p.x, p.y);\n    return { x, y };\n  }, [project]);\n\n  const box = worldBoxOf(scene, nodeId, compose);\n  const m = box && width !== 0 && height !== 0 ? project() : null;\n  const inverse = m && invert(m);\n  useInsertionEffect(() => {\n    if (inverse) lastInverse.current = inverse;\n  });\n\n  if (!box || !inverse) return null;\n  return { box: { x: box.x, y: box.y, width: box.width, height: box.height }, toScreen, toLocal, width, height };\n}\n\nfunction resolveView(view: View | (() => View) | undefined): View | undefined {\n  return typeof view === 'function' ? view() : view;\n}\n\nfunction worldBoxOf<TData, TLayer extends string, TPose extends RectPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  nodeId: string | null | undefined,\n  compose: ((parent: TPose, child: TPose) => TPose) | undefined,\n): TPose | null {\n  if (nodeId == null) return null;\n  const nodes = scene.nodes as ReadonlyMap<string, Node<TData, TLayer, TPose>>;\n  if (!nodes.has(nodeId)) return null;\n  // `effectivePose`, not `node.pose`: an overlay tracks what the renderer\n  // draws, and a gesture override or a derived pose is exactly the difference.\n  const adapter = {\n    getPose: (id: string) => effectivePose(scene, nodes.get(id)!),\n    getParent: (id: string) => nodes.get(id)?.parent ?? null,\n  };\n  return composeWorldPose(adapter, nodeId, compose ?? composeRectPose);\n}\n\n/** World → overlay pixels: `screen = (world − view) × view.scale`. */\nfunction viewMatrix(view: View | undefined): Mat3 {\n  if (!view) return [1, 0, 0, 1, 0, 0];\n  const { x: sx, y: sy } = view.scale;\n  return [sx, 0, 0, sy, -view.x * sx, -view.y * sy];\n}\n\n/** The pose→world leg the box frame omits, per `poseRotationOf`'s convention. */\nfunction rotationMatrix(pose: RectPose): Mat3 {\n  const r = poseRotationOf(pose);\n  if (!r) return [1, 0, 0, 1, 0, 0];\n  const c = Math.cos(r.rotation);\n  const s = Math.sin(r.rotation);\n  return [c, s, -s, c, r.cx - r.cx * c + r.cy * s, r.cy - r.cx * s - r.cy * c];\n}\n"],"mappings":";;;;;;;;AAuEA,SAAgBA,EACd,GACA,GACA,GACA,IAA6C,CAAC,GACrB;CACzB,IAAM,EAAE,UAAO,cAAWC,EAAcC,CAAY,GAC9C,EAAE,SAAM,eAAYC,GAEpBC,IAAUC,QAA+B;EAC7C,IAAMC,IAAMC,EAAWC,GAAOC,GAAQC,CAAO;EAE7C,OADKJ,IACEK,EAASC,EAAWC,EAAYC,CAAI,CAAC,GAAGC,EAAeT,CAAG,CAAC,IADjD;CAEnB,GAAG;EAACE;EAAOC;EAAQC;EAASI;CAAI,CAAC,GAE3BE,IAAWX,GAAa,MAAkC;EAC9D,IAAMY,IAAIb,EAAQ;EAClB,IAAI,CAACa,GAAG,OAAOC;EACf,IAAM,CAACC,GAAGC,KAAKC,EAAaJ,GAAGC,EAAE,GAAGA,EAAE,CAAC;EACvC,OAAO;GAAE;GAAG;EAAE;CAChB,GAAG,CAACd,CAAO,CAAC,GAENkB,IAAcC,EAAoB,IAAI,GAEtCC,IAAUnB,GAAa,MAAkC;EAC7D,IAAMY,IAAIb,EAAQ,GACZqB,IAAUR,KAAKS,EAAOT,CAAC;EAC7B,AAAIQ,MAAS,EAAY,UAAUA;EAEnC,IAAM,CAACN,GAAGC,KAAKC,EAAaI,KAAWH,EAAY,SAAUJ,EAAE,GAAGA,EAAE,CAAC;EACrE,OAAO;GAAE;GAAG;EAAE;CAChB,GAAG,CAACd,CAAO,CAAC,GAENE,IAAMC,EAAWC,GAAOC,GAAQC,CAAO,GACvCO,IAAIX,KAAOqB,MAAU,KAAKC,MAAW,IAAIxB,EAAQ,IAAI,MACrDqB,IAAUR,KAAKS,EAAOT,CAAC;CAM7B,OALAY,QAAyB;EACvB,AAAIJ,MAAS,EAAY,UAAUA;CACrC,CAAC,GAEG,CAACnB,KAAO,CAACmB,IAAgB,OACtB;EAAE,KAAK;GAAE,GAAGnB,EAAI;GAAG,GAAGA,EAAI;GAAG,OAAOA,EAAI;GAAO,QAAQA,EAAI;EAAO;EAAG;EAAU;EAAS;EAAO;CAAO;AAC/G;AAEA,SAASO,EAAY,GAAyD;CAC5E,OAAO,OAAOC,KAAS,aAAaA,EAAK,IAAIA;AAC/C;AAEA,SAASP,EACP,GACA,GACA,GACc;CACd,IAAIE,KAAU,MAAM,OAAO;CAC3B,IAAMqB,IAAQtB,EAAM;CAQpB,OAPKsB,EAAM,IAAIrB,CAAM,IAOdsB,EAAiB;EAHtB,UAAU,MAAeC,EAAcxB,GAAOsB,EAAM,IAAIG,CAAE,CAAE;EAC5D,YAAY,MAAeH,EAAM,IAAIG,CAAE,CAAC,EAAE,UAAU;CAE9B,GAASxB,GAAQC,KAAWwB,CAAe,IAPpC;AAQjC;AAGA,SAAStB,EAAW,GAA8B;CAChD,IAAI,CAACE,GAAM,OAAO;EAAC;EAAG;EAAG;EAAG;EAAG;EAAG;CAAC;CACnC,IAAM,EAAE,GAAGqB,GAAI,GAAGC,MAAOtB,EAAK;CAC9B,OAAO;EAACqB;EAAI;EAAG;EAAGC;EAAI,CAACtB,EAAK,IAAIqB;EAAI,CAACrB,EAAK,IAAIsB;CAAE;AAClD;AAGA,SAASrB,EAAe,GAAsB;CAC5C,IAAMsB,IAAIC,EAAeC,CAAI;CAC7B,IAAI,CAACF,GAAG,OAAO;EAAC;EAAG;EAAG;EAAG;EAAG;EAAG;CAAC;CAChC,IAAMG,IAAI,KAAK,IAAIH,EAAE,QAAQ,GACvBI,IAAI,KAAK,IAAIJ,EAAE,QAAQ;CAC7B,OAAO;EAACG;EAAGC;EAAG,CAACA;EAAGD;EAAGH,EAAE,KAAKA,EAAE,KAAKG,IAAIH,EAAE,KAAKI;EAAGJ,EAAE,KAAKA,EAAE,KAAKI,IAAIJ,EAAE,KAAKG;CAAC;AAC7E"}

package/dist/features/parallax/createParallaxLayer.js

@@ -0,0 +1,26 @@
+import { drawOneLayer as e, subscribeToSources as t } from "../../core/layers/render.js";
+import { deriveParallaxView as n } from "../../core/viewport/parallax.js";
+import { isParallaxSource as r } from "./createParallaxPlane.js";
+//#region src/features/parallax/createParallaxLayer.ts
+function i(i) {
+	let { id: a, label: o, source: s, parallax: c, getOuterView: l } = i, u = r(c) ? () => c.get() : () => c, d = t(s);
+	return {
+		id: a,
+		label: o,
+		space: "screen",
+		subscribe: r(c) ? (e) => {
+			let t = d(e), n = c.subscribe(e);
+			return () => {
+				t(), n();
+			};
+		} : d,
+		draw: (t, r, i) => {
+			let a = n(l?.() ?? r, u());
+			return s.flatMap((n) => e(n, t, a, i));
+		}
+	};
+}
+//#endregion
+export { i as createParallaxLayer };
+
+//# sourceMappingURL=createParallaxLayer.js.map

package/dist/features/parallax/createParallaxLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createParallaxLayer.js","names":["createParallaxLayer","opts","read","isParallaxSource","parallax","fromSources","subscribeToSources","source","offSources","listener","offPlane","inner","deriveParallaxView","getOuterView","outer","drawOneLayer","layer","data","dims"],"sources":["../../../src/features/parallax/createParallaxLayer.ts"],"sourcesContent":["import { drawOneLayer, subscribeToSources, type RenderLayer } from '../../core/layers/render';\nimport type { View } from '../../core/viewport/view';\nimport { deriveParallaxView, type ParallaxOpts } from '../../core/viewport/parallax';\nimport { isParallaxSource, type ParallaxSource } from './createParallaxPlane';\n\n/** Options for `createParallaxLayer`. */\nexport interface CreateParallaxLayerOpts<TData> {\n  id: string;\n  label: string;\n  /** Layers re-rendered through the derived inner view. */\n  source: RenderLayer<TData>[];\n  /** How the plane tracks the camera. Pass a `ParallaxSource` (such as\n   *  `createParallaxPlane`) to change it after the layer is built — an\n   *  animator tweening `pan` or `zoom` writes the plane, not the layer. */\n  parallax: ParallaxOpts | ParallaxSource;\n  /** Where the camera view comes from. Defaults to the view the Canvas hands\n   *  the layer — the `view` prop. A consumer running a 60 Hz camera through\n   *  refs pins that prop to identity, and would otherwise get identity back\n   *  for every `pan` value and a backdrop that never moves. */\n  getOuterView?: () => View;\n}\n\n/**\n * Wrap source RenderLayers in a parallax plane. The plane's inner view is\n * derived from the camera view per {@link deriveParallaxView}; each source\n * layer is drawn through it by `drawOneLayer`, so a `space: 'world'` source\n * gets the inner view's transform and a `space: 'screen'` one does not. The\n * plane itself is emitted as `space: 'screen'` — its children already carry\n * whatever transform they need, and the outer Canvas must add none.\n *\n * What this draws is paint: pointer events target the camera's view. Content\n * that should be clickable belongs on a scene layer carrying `parallax`\n * instead, which `<SceneCanvas>` renders and picks through the same view.\n *\n * **Screen-space source layers don't compose meaningfully** — they ignore\n * the derived view by definition. Same constraint as `createViewportLayer`.\n */\nexport function createParallaxLayer<TData>(\n  opts: CreateParallaxLayerOpts<TData>,\n): RenderLayer<TData> {\n  const { id, label, source, parallax, getOuterView } = opts;\n  const read = isParallaxSource(parallax) ? () => parallax.get() : () => parallax;\n  const fromSources = subscribeToSources(source);\n  return {\n    id,\n    label,\n    space: 'screen',\n    subscribe: isParallaxSource(parallax)\n      ? (listener) => {\n        const offSources = fromSources(listener);\n        const offPlane = parallax.subscribe(listener);\n        return () => { offSources(); offPlane(); };\n      }\n      : fromSources,\n    draw: (data, outer, dims) => {\n      const inner = deriveParallaxView(getOuterView?.() ?? outer, read());\n      return source.flatMap((layer) => drawOneLayer(layer, data, inner, dims));\n    },\n  };\n}\n"],"mappings":";;;;AAqCA,SAAgBA,EACd,GACoB;CACpB,IAAM,EAAE,OAAI,UAAO,WAAQ,aAAU,oBAAiBC,GAChDC,IAAOC,EAAiBC,CAAQ,UAAUA,EAAS,IAAI,UAAUA,GACjEC,IAAcC,EAAmBC,CAAM;CAC7C,OAAO;EACL;EACA;EACA,OAAO;EACP,WAAWJ,EAAiBC,CAAQ,KAC/B,MAAa;GACd,IAAMI,IAAaH,EAAYI,CAAQ,GACjCC,IAAWN,EAAS,UAAUK,CAAQ;GAC5C,aAAa;IAAgB,AAAdD,EAAW,GAAGE,EAAS;GAAG;EAC3C,IACEL;EACJ,OAAO,GAAM,GAAO,MAAS;GAC3B,IAAMM,IAAQC,EAAmBC,IAAe,KAAKC,GAAOZ,EAAK,CAAC;GAClE,OAAOK,EAAO,SAAS,MAAUQ,EAAaC,GAAOC,GAAMN,GAAOO,CAAI,CAAC;EACzE;CACF;AACF"}

package/dist/features/parallax/createParallaxPlane.js

@@ -0,0 +1,26 @@
+//#region src/features/parallax/createParallaxPlane.ts
+function e(e) {
+	let t = { ...e }, n = /* @__PURE__ */ new Set();
+	return {
+		get: () => t,
+		set(e) {
+			t = {
+				...t,
+				...e
+			};
+			for (let e of [...n]) e();
+		},
+		subscribe(e) {
+			return n.add(e), () => {
+				n.delete(e);
+			};
+		}
+	};
+}
+function t(e) {
+	return typeof e.get == "function";
+}
+//#endregion
+export { e as createParallaxPlane, t as isParallaxSource };
+
+//# sourceMappingURL=createParallaxPlane.js.map

package/dist/features/parallax/createParallaxPlane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createParallaxPlane.js","names":["createParallaxPlane","current","initial","listeners","patch","fn","isParallaxSource","p"],"sources":["../../../src/features/parallax/createParallaxPlane.ts"],"sourcesContent":["import type { RedrawSource } from '../../core/layers/render';\nimport type { ParallaxOpts } from '../../core/viewport/parallax';\n\n/** Parallax opts that can change after a layer is built. `get` is read on\n *  every draw, and a notification repaints whatever draws through it. */\nexport interface ParallaxSource extends RedrawSource {\n  get(): ParallaxOpts;\n}\n\n/** A {@link ParallaxSource} you write to — what an animator's `onTick` drives\n *  to tween a plane's `pan`, `zoom` or `anchor`. */\nexport interface ParallaxPlane extends ParallaxSource {\n  /** Merge `patch` over the current opts and notify. */\n  set(patch: Partial<ParallaxOpts>): void;\n}\n\n/** A {@link ParallaxPlane} starting at `initial`. Pass it as a parallax\n *  layer's `parallax` and write to it to move the plane. */\nexport function createParallaxPlane(initial: ParallaxOpts): ParallaxPlane {\n  let current: ParallaxOpts = { ...initial };\n  const listeners = new Set<() => void>();\n  return {\n    get: () => current,\n    set(patch) {\n      current = { ...current, ...patch };\n      for (const fn of [...listeners]) fn();\n    },\n    subscribe(fn) {\n      listeners.add(fn);\n      return () => { listeners.delete(fn); };\n    },\n  };\n}\n\n/** Whether `p` is a live source rather than a fixed set of opts. */\nexport function isParallaxSource(p: ParallaxOpts | ParallaxSource): p is ParallaxSource {\n  return typeof (p as ParallaxSource).get === 'function';\n}\n"],"mappings":";AAkBA,SAAgBA,EAAoB,GAAsC;CACxE,IAAIC,IAAwB,EAAE,GAAGC,EAAQ,GACnCC,oBAAY,IAAI,IAAgB;CACtC,OAAO;EACL,WAAWF;EACX,IAAI,GAAO;GACT,IAAU;IAAE,GAAGA;IAAS,GAAGG;GAAM;GACjC,KAAK,IAAMC,KAAM,CAAC,GAAGF,CAAS,GAAG,EAAG;EACtC;EACA,UAAU,GAAI;GAEZ,OADAA,EAAU,IAAIE,CAAE,SACH;IAAE,EAAU,OAAOA,CAAE;GAAG;EACvC;CACF;AACF;AAGA,SAAgBC,EAAiB,GAAuD;CACtF,OAAO,OAAQC,EAAqB,OAAQ;AAC9C"}

package/dist/features/paths/anchorEdits.js

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

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

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

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

package/dist/features/paths/booleans.js

@@ -0,0 +1,2 @@
+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/index.js

@@ -0,0 +1,15 @@
+import { poseRotationOf as e, rotatePathAround as t } from "../../core/geometry/poseRotation.js";
+import { pathPoseDescriptor as n } from "./poseDescriptor.js";
+import { countPathAnchors as r, pathToAnchors as i } from "./anchors.js";
+import "./anchorEdits.js";
+import { pathInPoseFrame as a, pathInWorld as o, worldEditToStorage as s } from "./pathInWorld.js";
+import "./booleans.js";
+import { circlePath as c, rectMarkerPath as l, roundRectPath as u, squarePath as d } from "./markers.js";
+import { createPenPreviewLayer as f } from "./penPreviewLayer.js";
+import { createPathEditingOverlayLayer as p } from "./pathEditingOverlayLayer.js";
+import { createPathLayer as m } from "./pathLayer.js";
+import { pathOriginProjection as h } from "./originProjection.js";
+import { DEFAULT_FLATTEN_TOLERANCE as g, PATH_C as _, PATH_CMD_LENGTHS as v, PATH_L as y, PATH_M as b, PATH_Q as x, PATH_Z as S, PathBuilder as C, boundsOfPath as w, composePath as T, decomposePath as E, ellipsePath as D, flattenCubic as O, flattenCubicWithArcLen as k, flattenQuadratic as A, flattenQuadraticWithArcLen as j, linePath as M, pathCommandCoordCount as N, pathContainsPoint as P, pathContainsPolygon as F, pathContainsRect as I, pathDistanceToPoint as L, pathFromD as R, pathIntersectsPolygon as z, pathIntersectsRect as B, pathSignedArea as V, pointAlongPath as H, pointInPath as U, polygonFromPoints as W, polylineFromPoints as G, rectPath as K, regularPolygonPath as q, reversePath as J, scalePathToBounds as Y, splitSubpaths as X, starPath as Z, transformPath as Q, translatePath as $, unionBoundsPath as ee } from "@weasel-js/geom";
+import { snipPathByPolyline as te, splitPathByPolyline as ne, splitPathBySegment as re } from "@weasel-js/geom/booleans";
+import "@weasel-js/geom/curves";
+export { g as DEFAULT_FLATTEN_TOLERANCE, _ as PATH_C, v as PATH_CMD_LENGTHS, y as PATH_L, b as PATH_M, x as PATH_Q, S as PATH_Z, C as PathBuilder, w as boundsOfPath, c as circlePath, T as composePath, r as countPathAnchors, p as createPathEditingOverlayLayer, m as createPathLayer, f as createPenPreviewLayer, E as decomposePath, D as ellipsePath, O as flattenCubic, k as flattenCubicWithArcLen, A as flattenQuadratic, j as flattenQuadraticWithArcLen, M as linePath, N as pathCommandCoordCount, P as pathContainsPoint, F as pathContainsPolygon, I as pathContainsRect, L as pathDistanceToPoint, R as pathFromD, a as pathInPoseFrame, o as pathInWorld, z as pathIntersectsPolygon, B as pathIntersectsRect, h as pathOriginProjection, n as pathPoseDescriptor, V as pathSignedArea, i as pathToAnchors, H as pointAlongPath, U as pointInPath, W as polygonFromPoints, G as polylineFromPoints, e as poseRotationOf, l as rectMarkerPath, K as rectPath, q as regularPolygonPath, J as reversePath, t as rotatePathAround, u as roundRectPath, Y as scalePathToBounds, te as snipPathByPolyline, ne as splitPathByPolyline, re as splitPathBySegment, X as splitSubpaths, d as squarePath, Z as starPath, Q as transformPath, $ as translatePath, ee as unionBoundsPath, s as worldEditToStorage };

package/dist/features/paths/markerCommands.js

@@ -0,0 +1,116 @@
+import { getMarker as e } from "../../core/strokeMarkers.js";
+import { markerKeyOf as t, resolveMarkerSize as n } from "../../core/markerInset.js";
+import { markerSites as r } from "./markerSites.js";
+import { boundsOfPath as i } from "@weasel-js/geom";
+import { extractPolylines as a } from "@weasel-js/geom/tessellate";
+//#region src/features/paths/markerCommands.ts
+function o(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 s(e, t, n) {
+	let r = e ?? n;
+	if (r !== "none") return r === "line" ? t.paint : r;
+}
+function c(i, s, c, l) {
+	let u = {
+		start: s.markerStart !== void 0,
+		mid: s.markerMid !== void 0,
+		end: s.markerEnd !== void 0
+	};
+	if (!u.start && !u.mid && !u.end) return [];
+	let d = (e) => e === "start" ? s.markerStart : e === "mid" ? s.markerMid : s.markerEnd, f = [];
+	for (let p of a(i, { flattenTolerance: l })) for (let i of r(p, u)) {
+		let r = d(i.role);
+		if (r === void 0) continue;
+		let a = e(t(r));
+		if (a === void 0) continue;
+		let l = n(r, c), u = a.orient === void 0 || a.orient === "auto" ? i.angle : a.orient;
+		f.push({
+			entry: a,
+			size: l,
+			path: o(a.path({
+				size: l,
+				stroke: s
+			}), {
+				...i,
+				angle: u
+			})
+		});
+	}
+	return f;
+}
+function l(e, t) {
+	let n = [];
+	for (let { entry: r, path: i, size: a } of e) {
+		let e = s(r.fill, t, "line"), o = r.outline ? {
+			paint: s(r.outline.paint, t, "line"),
+			width: r.outline.width * a
+		} : null;
+		(e !== void 0 || o !== null && o.paint !== void 0) && n.push({
+			kind: "path",
+			path: i,
+			...e ? { fill: e } : {},
+			...o && o.paint ? { stroke: {
+				paint: o.paint,
+				width: o.width,
+				cap: "round",
+				join: "round"
+			} } : {}
+		});
+	}
+	return n;
+}
+function u(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 d = 64, f = /* @__PURE__ */ new WeakMap(), p = /* @__PURE__ */ new WeakMap();
+function m(e, t) {
+	let n = i(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 h(e, t) {
+	let n = u(e, t);
+	if (n === null) {
+		let n = p.get(e);
+		n === void 0 && p.set(e, n = /* @__PURE__ */ new WeakMap());
+		let r = n.get(t);
+		return r === void 0 && n.set(t, r = m(e, t)), r;
+	}
+	let r = f.get(e);
+	r === void 0 && f.set(e, r = /* @__PURE__ */ new Map());
+	let i = r.get(n);
+	return i === void 0 && (r.size >= d && r.clear(), r.set(n, i = m(e, t))), i;
+}
+function g(r, i, a = 1) {
+	let o = 0;
+	for (let s of [
+		r.markerStart,
+		r.markerMid,
+		r.markerEnd
+	]) {
+		if (s === void 0) continue;
+		let c = e(t(s));
+		c !== void 0 && (o = Math.max(o, h(c, r) * n(s, i, a)));
+	}
+	return o;
+}
+//#endregion
+export { l as headCommands, c as markerHeads, g as markerReach, u as markerReadsKey };
+
+//# sourceMappingURL=markerCommands.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markerCommands.js","names":["placed","src","path","cos","site","sin","coords","i","x","y","resolvePaint","v","p","fallback","stroke","markerHeads","want","refFor","role","out","pl","extractPolylines","markerSites","ref","entry","getMarker","markerKeyOf","size","resolveMarkerSize","strokeWidth","angle","headCommands","heads","fill","outline","markerReadsKey","key","field","READINGS_PER_ENTRY","REACH_BY_READING","REACH_BY_STROKE","measureUnitReach","b","boundsOfPath","unitReach","byStroke","reach","byReading","markerReach","scale"],"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';\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}\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.\n */\nexport function markerHeads(\n  path: Path,\n  stroke: Stroke,\n  strokeWidth: number,\n  flattenTolerance: number | undefined,\n): MarkerHead[] {\n  const want = {\n    start: stroke.markerStart !== undefined,\n    mid: stroke.markerMid !== undefined,\n    end: stroke.markerEnd !== undefined,\n  };\n  if (!want.start && !want.mid && !want.end) return [];\n\n  const refFor = (role: MarkerSite['role']): MarkerRef | undefined =>\n    role === 'start' ? stroke.markerStart : role === 'mid' ? stroke.markerMid : stroke.markerEnd;\n\n  const out: MarkerHead[] = [];\n  for (const pl of extractPolylines(path, { flattenTolerance })) {\n    for (const site of markerSites(pl, want)) {\n      const ref = refFor(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      out.push({ entry, size, path: placed(entry.path({ size, stroke }), { ...site, angle }) });\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 } of heads) {\n    const fill = resolvePaint(entry.fill, stroke, 'line');\n    const outline = entry.outline\n      ? { paint: resolvePaint(entry.outline.paint, stroke, 'line'), width: entry.outline.width * size }\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 any of `stroke`'s markers can paint from the vertex it sits on, in\n * world units. `strokeWidth` is the resolved width and `scale` the view scale\n * a `{ px }` size resolves against. Culling and a path node's grab reach both\n * measure through here.\n */\nexport function markerReach(stroke: Stroke, strokeWidth: number, scale = 1): number {\n  let reach = 0;\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    reach = Math.max(reach, unitReach(entry, stroke) * resolveMarkerSize(ref, strokeWidth, scale));\n  }\n  return reach;\n}\n"],"mappings":"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"}