@weasel-js/core 1.5.0 → 1.5.1

package/dist/chunk-HAGOFNP5.js

@@ -0,0 +1,162 @@
+import { isPathLike, translatePath, boundsOfPath } from './chunk-3LPQ2XZG.js';
+
+// src/core/units.ts
+function resolveUnit(v, unitSystem) {
+  if (typeof v === "number") return v;
+  if (!unitSystem) {
+    throw new Error(
+      `resolveUnit: tagged value { value: ${v.value}, unit: '${v.unit}' } requires a UnitSystem`
+    );
+  }
+  const factor = unitSystem.units[v.unit];
+  if (factor === void 0) {
+    const known = Object.keys(unitSystem.units).join(", ") || "(none)";
+    throw new Error(
+      `resolveUnit: unknown unit '${v.unit}' (system base: '${unitSystem.base}', known units: ${known})`
+    );
+  }
+  return v.value * factor;
+}
+function formatUnit(baseValue, displayUnit, unitSystem, opts) {
+  const factor = unitSystem.units[displayUnit];
+  if (factor === void 0) {
+    const known = Object.keys(unitSystem.units).join(", ") || "(none)";
+    throw new Error(
+      `formatUnit: unknown unit '${displayUnit}' (system base: '${unitSystem.base}', known units: ${known})`
+    );
+  }
+  const precision = opts?.precision ?? 2;
+  const suffix = opts?.suffix ?? true;
+  const display = baseValue / factor;
+  let s = display.toFixed(precision);
+  if (s.includes(".")) {
+    s = s.replace(/0+$/, "").replace(/\.$/, "");
+  }
+  return suffix ? `${s}${displayUnit}` : s;
+}
+var IMPERIAL_INCHES = {
+  base: "in",
+  units: { in: 1, ft: 12, yd: 36, mi: 63360 }
+};
+var METRIC_MM = {
+  base: "mm",
+  units: { mm: 1, cm: 10, m: 1e3, km: 1e6 }
+};
+var ANGLE_RADIANS = {
+  base: "rad",
+  units: { rad: 1, deg: Math.PI / 180, turn: Math.PI * 2 }
+};
+var PIXELS = {
+  base: "px",
+  units: { px: 1 }
+};
+
+// src/interactions/gestures/shared/strategies/grid.ts
+var RECT_ORIGIN_PROJECTION = {
+  getOrigin: (p) => ({ x: p.x, y: p.y }),
+  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy })
+};
+var AUTO_ORIGIN_PROJECTION = {
+  getOrigin: (p) => {
+    if (isPathLike(p)) {
+      const b = boundsOfPath(p);
+      return { x: b.x, y: b.y };
+    }
+    const r = p;
+    return { x: r.x, y: r.y };
+  },
+  translate: (p, dx, dy) => {
+    if (isPathLike(p)) return translatePath(p, dx, dy);
+    const r = p;
+    return { ...r, x: r.x + dx, y: r.y + dy };
+  }
+};
+function gridSnapStrategy(spacing, arg) {
+  const isOpts = typeof arg === "object" && arg !== null && ("origin" in arg || "debug" in arg || "unitSystem" in arg) && !("base" in arg);
+  const optsArg = isOpts ? arg : null;
+  const unitSystem = optsArg ? optsArg.unitSystem : arg;
+  const proj = optsArg && optsArg.origin ? optsArg.origin : AUTO_ORIGIN_PROJECTION;
+  const debug = optsArg ? optsArg.debug : void 0;
+  const c = resolveUnit(spacing, unitSystem);
+  return {
+    snap(pose) {
+      const o = proj.getOrigin(pose);
+      const sx = Math.round(o.x / c) * c;
+      const sy = Math.round(o.y / c) * c;
+      debug?.recordSnapCandidate({ x: sx, y: sy }, true);
+      return proj.translate(pose, sx - o.x, sy - o.y);
+    }
+  };
+}
+function pointToGridCell(point, spacing, unitSystem, origin = { x: 0, y: 0 }) {
+  const s = resolveUnit(spacing, unitSystem);
+  return {
+    col: Math.floor((point.x - origin.x) / s),
+    row: Math.floor((point.y - origin.y) / s)
+  };
+}
+
+// src/core/viewport/pxExtent.ts
+function pxExtent(px, scale) {
+  return {
+    x: px / Math.abs(scale.x),
+    y: px / Math.abs(scale.y)
+  };
+}
+function scaleDelta(dx, dy, scale) {
+  return { x: dx * scale.x, y: dy * scale.y };
+}
+function withinPxBox(dx, dy, px, scale) {
+  const s = scaleDelta(dx, dy, scale);
+  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;
+}
+function withinPxRadius(dx, dy, px, scale) {
+  const s = scaleDelta(dx, dy, scale);
+  return s.x * s.x + s.y * s.y <= px * px;
+}
+
+// src/interactions/gestures/shared/strategies/guides.ts
+var DEFAULT_GUIDE_TOLERANCE_PX = 6;
+function guideSnapStrategy(getGuides, options = {}) {
+  const tolerance = options.tolerance ?? DEFAULT_GUIDE_TOLERANCE_PX;
+  const getView = options.getView;
+  const proj = options.origin ?? RECT_ORIGIN_PROJECTION;
+  return {
+    snap(pose) {
+      const guides = getGuides();
+      if (guides.length === 0) return null;
+      const tol = getView ? pxExtent(tolerance, getView().scale) : { x: tolerance, y: tolerance };
+      const o = proj.getOrigin(pose);
+      let bestDx = 0;
+      let bestAbsDx = Infinity;
+      let bestDy = 0;
+      let bestAbsDy = Infinity;
+      for (const g of guides) {
+        if (g.axis === "x") {
+          const d = g.offset - o.x;
+          const ad = Math.abs(d);
+          if (ad <= tol.x && ad < bestAbsDx) {
+            bestAbsDx = ad;
+            bestDx = d;
+          }
+        } else {
+          const d = g.offset - o.y;
+          const ad = Math.abs(d);
+          if (ad <= tol.y && ad < bestAbsDy) {
+            bestAbsDy = ad;
+            bestDy = d;
+          }
+        }
+      }
+      if (bestAbsDx === Infinity && bestAbsDy === Infinity) return null;
+      const dx = bestAbsDx === Infinity ? 0 : bestDx;
+      const dy = bestAbsDy === Infinity ? 0 : bestDy;
+      if (dx === 0 && dy === 0) return null;
+      return proj.translate(pose, dx, dy);
+    }
+  };
+}
+
+export { ANGLE_RADIANS, DEFAULT_GUIDE_TOLERANCE_PX, IMPERIAL_INCHES, METRIC_MM, PIXELS, RECT_ORIGIN_PROJECTION, formatUnit, gridSnapStrategy, guideSnapStrategy, pointToGridCell, pxExtent, resolveUnit, scaleDelta, withinPxBox, withinPxRadius };
+//# sourceMappingURL=chunk-HAGOFNP5.js.map
+//# sourceMappingURL=chunk-HAGOFNP5.js.map

package/dist/chunk-HAGOFNP5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/units.ts","../src/interactions/gestures/shared/strategies/grid.ts","../src/core/viewport/pxExtent.ts","../src/interactions/gestures/shared/strategies/guides.ts"],"names":[],"mappings":"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","file":"chunk-HAGOFNP5.js","sourcesContent":["/**\n * Units — a tiny customizable unit system for canvas-kit APIs.\n *\n * The kit stores all coordinates as bare numbers in a single base unit\n * chosen by the consumer app. To make API call sites self-documenting,\n * the public surface accepts `UnitValue` — either a bare number (interpreted\n * as base units) or a `{ value, unit }` tag that's resolved against a\n * `UnitSystem` at the API boundary. Internals never see units.\n *\n * Linear factors only. No per-axis units. No mixed-unit arithmetic.\n */\n\n/** A unit name (e.g. `'in'`, `'ft'`, `'mm'`). Looked up in a `UnitSystem`. */\nexport type Unit = string;\n\n/** Conversion table mapping unit names to factors against a base unit. */\nexport interface UnitSystem {\n  /** Name of the base unit, e.g. 'in'. All conversions resolve to this. */\n  base: Unit;\n  /** Factor to multiply a value in `unit` by to get base units. base unit's factor is 1. */\n  units: Record<Unit, number>;\n}\n\n/** Value at a unit-aware API boundary: bare number (in base units) or `{ value, unit }` tag. */\nexport type UnitValue = number | { value: number; unit: Unit };\n\n/**\n * Resolve a UnitValue to a number in base units.\n *  - bare number: returned as-is (assumed base)\n *  - tagged: looks up factor; throws if unit not in unit system\n */\nexport function resolveUnit(v: UnitValue, unitSystem?: UnitSystem): number {\n  if (typeof v === 'number') return v;\n  if (!unitSystem) {\n    throw new Error(\n      `resolveUnit: tagged value { value: ${v.value}, unit: '${v.unit}' } requires a UnitSystem`,\n    );\n  }\n  const factor = unitSystem.units[v.unit];\n  if (factor === undefined) {\n    const known = Object.keys(unitSystem.units).join(', ') || '(none)';\n    throw new Error(\n      `resolveUnit: unknown unit '${v.unit}' (system base: '${unitSystem.base}', known units: ${known})`,\n    );\n  }\n  return v.value * factor;\n}\n\n/**\n * Format a base-unit number as a string in the named display unit.\n *  e.g. formatUnit(36, 'ft', IMPERIAL_INCHES) => '3ft'\n *  Default precision: 2. Trailing zeros trimmed.\n */\nexport function formatUnit(\n  baseValue: number,\n  displayUnit: Unit,\n  unitSystem: UnitSystem,\n  opts?: { precision?: number; suffix?: boolean },\n): string {\n  const factor = unitSystem.units[displayUnit];\n  if (factor === undefined) {\n    const known = Object.keys(unitSystem.units).join(', ') || '(none)';\n    throw new Error(\n      `formatUnit: unknown unit '${displayUnit}' (system base: '${unitSystem.base}', known units: ${known})`,\n    );\n  }\n  const precision = opts?.precision ?? 2;\n  const suffix = opts?.suffix ?? true;\n  const display = baseValue / factor;\n  // Trim trailing zeros (and a dangling decimal point) without losing precision.\n  let s = display.toFixed(precision);\n  if (s.includes('.')) {\n    s = s.replace(/0+$/, '').replace(/\\.$/, '');\n  }\n  return suffix ? `${s}${displayUnit}` : s;\n}\n\n/** Imperial unit system with base 'in'. */\nexport const IMPERIAL_INCHES: UnitSystem = {\n  base: 'in',\n  units: { in: 1, ft: 12, yd: 36, mi: 63360 },\n};\n\n/** Metric unit system with base 'mm'. */\nexport const METRIC_MM: UnitSystem = {\n  base: 'mm',\n  units: { mm: 1, cm: 10, m: 1000, km: 1_000_000 },\n};\n\n/** Angle unit system with base 'rad'. */\nexport const ANGLE_RADIANS: UnitSystem = {\n  base: 'rad',\n  units: { rad: 1, deg: Math.PI / 180, turn: Math.PI * 2 },\n};\n\n/** Pixel unit system — sole unit is the base. */\nexport const PIXELS: UnitSystem = {\n  base: 'px',\n  units: { px: 1 },\n};\n","import type { SnapStrategy } from '../../types';\nimport { resolveUnit, type UnitSystem, type UnitValue } from 'core/units';\nimport type { DebugSink } from '../../../../debug/types';\nimport { isPathLike } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { boundsOfPath } from 'features/paths/bounds';\nimport { translatePath } from 'features/paths/transform';\nimport type { Path } from 'features/paths/types';\n\n/**\n * Projection used by `gridSnapStrategy` when `TPose` doesn't expose `{x,y}`\n * directly (Path, polygon, etc.). The strategy reads the snap point via\n * `getOrigin`, rounds it to the grid, then asks `translate` to move the\n * pose by the resulting delta.\n */\nexport interface OriginProjection<TPose> {\n  getOrigin(pose: TPose): { x: number; y: number };\n  translate(pose: TPose, dx: number, dy: number): TPose;\n}\n\n/** Identity projection for `TPose extends { x; y }`. */\nexport const RECT_ORIGIN_PROJECTION: OriginProjection<{ x: number; y: number }> = {\n  getOrigin: (p) => ({ x: p.x, y: p.y }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n};\n\n/** Per-call dispatch: routes Path-shaped poses to the path origin/translate\n *  helpers and everything else to `RECT_ORIGIN_PROJECTION`. Default for\n *  `gridSnapStrategy` so consumers with Path TPose don't have to thread\n *  `pathOriginProjection` explicitly. */\nexport const AUTO_ORIGIN_PROJECTION: OriginProjection<unknown> = {\n  getOrigin: (p) => {\n    if (isPathLike(p)) {\n      const b = boundsOfPath(p as Path);\n      return { x: b.x, y: b.y };\n    }\n    const r = p as { x: number; y: number };\n    return { x: r.x, y: r.y };\n  },\n  translate: (p, dx, dy) => {\n    if (isPathLike(p)) return translatePath(p as Path, dx, dy);\n    const r = p as { x: number; y: number };\n    return { ...r, x: r.x + dx, y: r.y + dy };\n  },\n};\n\n/** Snap-strategy that rounds the pose's origin to the nearest multiple of\n *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an\n *  `OriginProjection` so the strategy knows how to read/write the origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  unitSystem?: UnitSystem,\n): SnapStrategy<TPose>;\n/** As above, additionally reporting each candidate to a debug sink. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  opts: { unitSystem?: UnitSystem; debug?: DebugSink },\n): SnapStrategy<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the strategy how\n *  to read and write the pose's origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  opts: { unitSystem?: UnitSystem; origin: OriginProjection<TPose>; debug?: DebugSink },\n): SnapStrategy<TPose>;\n/** Snap-strategy that rounds the pose's origin to the nearest multiple of\n *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an\n *  `OriginProjection` so the strategy knows how to read/write the origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  arg?: UnitSystem | { unitSystem?: UnitSystem; origin?: OriginProjection<TPose>; debug?: DebugSink },\n): SnapStrategy<TPose> {\n  const isOpts =\n    typeof arg === 'object' &&\n    arg !== null &&\n    ('origin' in arg || 'debug' in arg || 'unitSystem' in arg) &&\n    !('base' in arg);\n  const optsArg = isOpts\n    ? (arg as { unitSystem?: UnitSystem; origin?: OriginProjection<TPose>; debug?: DebugSink })\n    : null;\n  const unitSystem = optsArg ? optsArg.unitSystem : (arg as UnitSystem | undefined);\n  const proj: OriginProjection<TPose> = optsArg && optsArg.origin\n    ? optsArg.origin\n    : (AUTO_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n  const debug: DebugSink | undefined = optsArg ? optsArg.debug : undefined;\n  const c = resolveUnit(spacing, unitSystem);\n  return {\n    snap(pose) {\n      const o = proj.getOrigin(pose);\n      const sx = Math.round(o.x / c) * c;\n      const sy = Math.round(o.y / c) * c;\n      debug?.recordSnapCandidate({ x: sx, y: sy }, true);\n      return proj.translate(pose, sx - o.x, sy - o.y);\n    },\n  };\n}\n\n/**\n * Compute the integer cell `{col, row}` that contains `point`, given a grid\n * `spacing` and optional `origin` and `unitSystem`. Pair with\n * `createCellHighlightLayer` (its `getCell` callback) to draw a snap-target\n * preview that uses the same spacing as `gridSnapStrategy` — so the visual\n * and behavioral grids stay in lockstep:\n *\n *     const SPACING = 20;\n *     const snap = gridSnapStrategy(SPACING);\n *     // visual grid:\n *     createGridLayer({ spacing: SPACING, bounds: () => ... });\n *     // hover-preview overlay:\n *     createCellHighlightLayer({\n *       spacing: SPACING,\n *       getCell: () => hoverPoint && pointToGridCell(hoverPoint, SPACING),\n *     });\n */\nexport function pointToGridCell(\n  point: { x: number; y: number },\n  spacing: UnitValue,\n  unitSystem?: UnitSystem,\n  origin: { x: number; y: number } = { x: 0, y: 0 },\n): { col: number; row: number } {\n  const s = resolveUnit(spacing, unitSystem);\n  return {\n    col: Math.floor((point.x - origin.x) / s),\n    row: Math.floor((point.y - origin.y) / s),\n  };\n}\n","/**\n * Screen-pixel lengths in world units, per axis.\n *\n * Chrome declares its hit zones in screen pixels — an 8px handle stays 8px at\n * every zoom, because it paints in screen space. Converting one such length to\n * world units with a single scalar (see `meanScale`) is exact only under\n * uniform zoom; per-axis it is too generous on one axis and too mean on the\n * other, so the pickable region stops matching the painted one.\n *\n * Prefer {@link withinPxBox} / {@link withinPxRadius}, which compare in screen\n * space and so can't drift from the paint at all. {@link pxExtent} is for the\n * cases that must stay in world units — a tolerance handed to geometry that\n * doesn't know about the view.\n */\n\nexport interface Scale2 {\n  x: number;\n  y: number;\n}\n\n/** One screen-pixel length as world-space extents, per axis. `scale` is a\n *  view's, so neither axis is zero (see `View`). */\nexport function pxExtent(px: number, scale: Scale2): { x: number; y: number } {\n  return {\n    x: px / Math.abs(scale.x),\n    y: px / Math.abs(scale.y),\n  };\n}\n\n/** World delta → screen delta. Only the scale participates: translation\n *  cancels in a difference, and the kit's views carry no skew. */\nexport function scaleDelta(dx: number, dy: number, scale: Scale2): { x: number; y: number } {\n  return { x: dx * scale.x, y: dy * scale.y };\n}\n\n/**\n * Is a world-space delta inside a screen-space square of half-extent `px`?\n *\n * The square is axis-aligned **on screen**, which is what a handle painted in\n * screen space actually is — so this stays true under non-uniform zoom and\n * under a rotated target, where an axis-aligned world-space test is a rotated\n * rectangle on screen.\n */\nexport function withinPxBox(dx: number, dy: number, px: number, scale: Scale2): boolean {\n  const s = scaleDelta(dx, dy, scale);\n  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;\n}\n\n/** Is a world-space delta inside a screen-space circle of radius `px`? */\nexport function withinPxRadius(dx: number, dy: number, px: number, scale: Scale2): boolean {\n  const s = scaleDelta(dx, dy, scale);\n  return s.x * s.x + s.y * s.y <= px * px;\n}\n","import type { SnapStrategy } from '../../types';\nimport type { Guide } from 'features/guides/types';\nimport type { View } from 'core/viewport/view';\nimport { pxExtent } from 'core/viewport/pxExtent';\nimport type { OriginProjection } from './grid';\nimport { RECT_ORIGIN_PROJECTION } from './grid';\n\n/** Default snap tolerance (screen pixels). */\nexport const DEFAULT_GUIDE_TOLERANCE_PX = 6;\n\n/** Options for `guideSnapStrategy`. */\nexport interface GuideSnapOptions<TPose> {\n  /**\n   * Tolerance, in screen pixels (CSS px) when `getView` is provided, or in\n   * world units otherwise. Defaults to `DEFAULT_GUIDE_TOLERANCE_PX`.\n   */\n  tolerance?: number;\n  /**\n   * Read the active view transform. When supplied, `tolerance` is interpreted\n   * in screen pixels and divided by `view.scale` so the trigger zone stays\n   * the same on screen as the user zooms in/out. Without it, `tolerance`\n   * is treated as world units.\n   */\n  getView?: () => View;\n  /**\n   * Projection used when `TPose` doesn't expose `{x, y}` directly (Path,\n   * polygon, etc.) — same contract as `gridSnapStrategy`. Defaults to the\n   * rect-pose identity projection.\n   */\n  origin?: OriginProjection<TPose>;\n}\n\n/**\n * Snap-strategy that snaps the pose's origin to the nearest guide line on\n * each axis when within tolerance. Each axis is considered independently:\n * a vertical guide (`axis: 'x'`) constrains X, a horizontal guide\n * (`axis: 'y'`) constrains Y. When multiple guides are within range on the\n * same axis, the closest wins.\n *\n * Pair with `useGuides` for storage and `createGuidesLayer` for rendering.\n *\n * **Composition:** combining with `gridSnapStrategy` is left to the\n * consumer in v1 — typically by picking one based on a modifier key, or\n * by stacking two move/resize/insert behaviors in priority order.\n */\nexport function guideSnapStrategy<TPose extends { x: number; y: number }>(\n  getGuides: () => readonly Guide[],\n  options?: Omit<GuideSnapOptions<TPose>, 'origin'>,\n): SnapStrategy<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the strategy how\n *  to read and write the pose's origin. */\nexport function guideSnapStrategy<TPose>(\n  getGuides: () => readonly Guide[],\n  options: GuideSnapOptions<TPose> & { origin: OriginProjection<TPose> },\n): SnapStrategy<TPose>;\n/** Snap a pose's origin to the nearest guide line within tolerance, per axis. */\nexport function guideSnapStrategy<TPose>(\n  getGuides: () => readonly Guide[],\n  options: GuideSnapOptions<TPose> = {},\n): SnapStrategy<TPose> {\n  const tolerance = options.tolerance ?? DEFAULT_GUIDE_TOLERANCE_PX;\n  const getView = options.getView;\n  const proj: OriginProjection<TPose> =\n    options.origin ?? (RECT_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n\n  return {\n    snap(pose) {\n      const guides = getGuides();\n      if (guides.length === 0) return null;\n\n      // Convert tolerance to world units, per axis: a guide on the x axis is\n      // matched by a horizontal distance, so it answers to `scale.x` alone.\n      // With no view, treat tolerance as already-world.\n      const tol = getView ? pxExtent(tolerance, getView().scale) : { x: tolerance, y: tolerance };\n\n      const o = proj.getOrigin(pose);\n\n      let bestDx = 0;\n      let bestAbsDx = Infinity;\n      let bestDy = 0;\n      let bestAbsDy = Infinity;\n\n      for (const g of guides) {\n        if (g.axis === 'x') {\n          const d = g.offset - o.x;\n          const ad = Math.abs(d);\n          if (ad <= tol.x && ad < bestAbsDx) {\n            bestAbsDx = ad;\n            bestDx = d;\n          }\n        } else {\n          const d = g.offset - o.y;\n          const ad = Math.abs(d);\n          if (ad <= tol.y && ad < bestAbsDy) {\n            bestAbsDy = ad;\n            bestDy = d;\n          }\n        }\n      }\n\n      if (bestAbsDx === Infinity && bestAbsDy === Infinity) return null;\n      const dx = bestAbsDx === Infinity ? 0 : bestDx;\n      const dy = bestAbsDy === Infinity ? 0 : bestDy;\n      if (dx === 0 && dy === 0) return null;\n      return proj.translate(pose, dx, dy);\n    },\n  };\n}\n"]}

package/dist/chunk-LXJDWBEL.js

@@ -0,0 +1,318 @@
+import { rectToContour, DEFAULT_FLATTEN_TOLERANCE, forEachSegment, PATH_Z, PATH_C, flattenCubicWithArcLen, PATH_Q, flattenQuadraticWithArcLen, PATH_L, PATH_M } from '@weasel-js/geom';
+
+// src/features/simulation/types.ts
+var DEFAULT_ALPHA_DECAY = 1 - Math.pow(1e-3, 1 / 300);
+var DEFAULT_ALPHA_MIN = 1e-3;
+var DEFAULT_VELOCITY_DECAY = 0.4;
+
+// src/features/simulation/createSimulation.ts
+function createSimulation(opts) {
+  let nodes = opts.nodes;
+  let forces = opts.forces ?? [];
+  let alpha = opts.alpha ?? 1;
+  let alphaMin = opts.alphaMin ?? DEFAULT_ALPHA_MIN;
+  let alphaDecay = opts.alphaDecay ?? DEFAULT_ALPHA_DECAY;
+  let alphaTarget = opts.alphaTarget ?? 0;
+  let velocityDecay = opts.velocityDecay ?? DEFAULT_VELOCITY_DECAY;
+  const random = opts.random ?? Math.random;
+  function prime(list) {
+    list.forEach((n, i) => {
+      n.index = i;
+      if (n.vx == null) n.vx = 0;
+      if (n.vy == null) n.vy = 0;
+    });
+  }
+  prime(nodes);
+  for (const f of forces) f.initialize?.(nodes, random);
+  function step() {
+    alpha += (alphaTarget - alpha) * alphaDecay;
+    for (const f of forces) f(alpha);
+    const friction = 1 - velocityDecay;
+    for (const n of nodes) {
+      if (n.fx == null) {
+        n.vx = (n.vx ?? 0) * friction;
+        if (!Number.isFinite(n.vx)) n.vx = 0;
+        n.x += n.vx;
+        if (!Number.isFinite(n.x)) n.x = 0;
+      } else {
+        n.x = n.fx;
+        n.vx = 0;
+      }
+      if (n.fy == null) {
+        n.vy = (n.vy ?? 0) * friction;
+        if (!Number.isFinite(n.vy)) n.vy = 0;
+        n.y += n.vy;
+        if (!Number.isFinite(n.y)) n.y = 0;
+      } else {
+        n.y = n.fy;
+        n.vy = 0;
+      }
+    }
+  }
+  const core = {
+    get nodes() {
+      return nodes;
+    },
+    setNodes(next) {
+      nodes = next;
+      prime(nodes);
+      for (const f of forces) f.initialize?.(nodes, random);
+      return core;
+    },
+    setForces(next) {
+      const old = forces;
+      forces = next;
+      for (const f of next) {
+        if (!old.includes(f)) f.initialize?.(nodes, random);
+      }
+      return core;
+    },
+    alpha(value) {
+      if (value === void 0) return alpha;
+      alpha = value;
+      return core;
+    },
+    alphaTarget(value) {
+      if (value === void 0) return alphaTarget;
+      alphaTarget = value;
+      return core;
+    },
+    alphaDecay(value) {
+      if (value === void 0) return alphaDecay;
+      alphaDecay = value;
+      return core;
+    },
+    alphaMin(value) {
+      if (value === void 0) return alphaMin;
+      alphaMin = value;
+      return core;
+    },
+    velocityDecay(value) {
+      if (value === void 0) return velocityDecay;
+      velocityDecay = value;
+      return core;
+    },
+    tick(iterations = 1) {
+      for (let i = 0; i < iterations; i++) step();
+      return core;
+    },
+    isSettled() {
+      return alpha < alphaMin && alphaTarget === 0;
+    }
+  };
+  return core;
+}
+
+// src/interactions/actions/rotate/geometry.ts
+function aabbCenter(bounds) {
+  return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };
+}
+function rotatePoint(px, py, cx, cy, angle) {
+  const c = Math.cos(angle);
+  const s = Math.sin(angle);
+  const dx = px - cx;
+  const dy = py - cy;
+  return { x: cx + dx * c - dy * s, y: cy + dx * s + dy * c };
+}
+function rectCorners(bounds) {
+  return [
+    { x: bounds.x, y: bounds.y },
+    { x: bounds.x + bounds.width, y: bounds.y },
+    { x: bounds.x + bounds.width, y: bounds.y + bounds.height },
+    { x: bounds.x, y: bounds.y + bounds.height }
+  ];
+}
+function rotatedRectCorners(pose) {
+  const c = aabbCenter(pose);
+  return rectCorners(pose).map((p) => rotatePoint(p.x, p.y, c.x, c.y, pose.rotation));
+}
+function pointInRotatedRect(pose, worldX, worldY) {
+  const c = aabbCenter(pose);
+  const local = rotatePoint(worldX, worldY, c.x, c.y, -pose.rotation);
+  return local.x >= pose.x && local.x <= pose.x + pose.width && local.y >= pose.y && local.y <= pose.y + pose.height;
+}
+function extractPolylines(path, opts = {}) {
+  if (path.kind === "rect") return [extractRect(path)];
+  return extractPolygon(path, opts);
+}
+function extractRect(p) {
+  const { x, y, width: w, height: h } = p;
+  return {
+    points: Array.from(rectToContour(x, y, w, h)),
+    closed: true,
+    anchorA: new Uint32Array([0, 1, 2, 3]),
+    anchorB: new Uint32Array([0, 1, 2, 3]),
+    anchorT: new Float32Array([0, 0, 0, 0])
+  };
+}
+function extractPolygon(p, opts) {
+  const tolerance = opts.flattenTolerance ?? DEFAULT_FLATTEN_TOLERANCE;
+  const { commands, coords } = p;
+  const out = [];
+  let anchorCounter = 0;
+  let pts = null;
+  let aA = null;
+  let aB = null;
+  let aT = null;
+  let current = null;
+  let prevAnchor = -1;
+  const beginContour = () => {
+    pts = [];
+    aA = [];
+    aB = [];
+    aT = [];
+    const next = { points: pts, closed: false };
+    out.push(next);
+    return next;
+  };
+  const dropDuplicateClosingPoint = () => {
+    if (!pts || !aA || !aB || !aT) return;
+    const n = pts.length / 2;
+    if (n < 2) return;
+    if (pts[0] !== pts[(n - 1) * 2] || pts[1] !== pts[(n - 1) * 2 + 1]) return;
+    pts.length -= 2;
+    aA.length -= 1;
+    aB.length -= 1;
+    aT.length -= 1;
+  };
+  const commit = (target) => {
+    if (!pts || !aA || !aB || !aT) return;
+    target.anchorA = new Uint32Array(aA);
+    target.anchorB = new Uint32Array(aB);
+    target.anchorT = new Float32Array(aT);
+  };
+  const pushCurveAnchors = (segStart, arcAccum, total, target) => {
+    for (let k = 0; k < arcAccum.length; k++) {
+      aA.push(prevAnchor);
+      aB.push(target);
+      aT.push(total > 0 ? arcAccum[k] / total : 0);
+    }
+    const lastIdx = segStart + arcAccum.length - 1;
+    aA[lastIdx] = target;
+    aB[lastIdx] = target;
+    aT[lastIdx] = 0;
+  };
+  forEachSegment(commands, coords, (cmd, coordIdx, prevX, prevY) => {
+    switch (cmd) {
+      case PATH_M:
+      case PATH_L: {
+        if (cmd === PATH_M) {
+          if (current) commit(current);
+          current = beginContour();
+        }
+        pts.push(coords[coordIdx], coords[coordIdx + 1]);
+        aA.push(anchorCounter);
+        aB.push(anchorCounter);
+        aT.push(0);
+        prevAnchor = anchorCounter;
+        anchorCounter++;
+        break;
+      }
+      case PATH_Q: {
+        const target = anchorCounter;
+        const segStart = pts.length / 2;
+        const arcAccum = [];
+        const total = flattenQuadraticWithArcLen(
+          prevX,
+          prevY,
+          coords[coordIdx],
+          coords[coordIdx + 1],
+          coords[coordIdx + 2],
+          coords[coordIdx + 3],
+          tolerance,
+          pts,
+          arcAccum
+        );
+        pushCurveAnchors(segStart, arcAccum, total, target);
+        prevAnchor = target;
+        anchorCounter++;
+        break;
+      }
+      case PATH_C: {
+        const target = anchorCounter;
+        const segStart = pts.length / 2;
+        const arcAccum = [];
+        const total = flattenCubicWithArcLen(
+          prevX,
+          prevY,
+          coords[coordIdx],
+          coords[coordIdx + 1],
+          coords[coordIdx + 2],
+          coords[coordIdx + 3],
+          coords[coordIdx + 4],
+          coords[coordIdx + 5],
+          tolerance,
+          pts,
+          arcAccum
+        );
+        pushCurveAnchors(segStart, arcAccum, total, target);
+        prevAnchor = target;
+        anchorCounter++;
+        break;
+      }
+      case PATH_Z: {
+        if (current) {
+          current.closed = true;
+          dropDuplicateClosingPoint();
+        }
+        break;
+      }
+      default:
+        throw new Error(`extractPolylines: unknown command code ${cmd}`);
+    }
+  });
+  if (current) commit(current);
+  return out;
+}
+
+// src/features/paths/pathAt.ts
+function pointAlongPath(path, t, opts = {}) {
+  const polylines = extractPolylines(
+    path,
+    opts.flattenTolerance === void 0 ? {} : { flattenTolerance: opts.flattenTolerance }
+  );
+  const segments = [];
+  let total = 0;
+  let first;
+  for (const pl of polylines) {
+    const count = pl.points.length / 2;
+    if (count === 0) continue;
+    first ??= { x: pl.points[0], y: pl.points[1] };
+    const last2 = pl.closed ? count : count - 1;
+    for (let i = 0; i < last2; i++) {
+      const j = (i + 1) % count;
+      const ax = pl.points[i * 2];
+      const ay = pl.points[i * 2 + 1];
+      const bx = pl.points[j * 2];
+      const by = pl.points[j * 2 + 1];
+      const len = Math.hypot(bx - ax, by - ay);
+      if (len === 0) continue;
+      segments.push({ ax, ay, bx, by, len });
+      total += len;
+    }
+  }
+  if (first === void 0) return null;
+  if (segments.length === 0) return { point: first, tangent: { x: 1, y: 0 } };
+  const target = Math.min(Math.max(t, 0), 1) * total;
+  let walked = 0;
+  for (const seg of segments) {
+    if (walked + seg.len < target) {
+      walked += seg.len;
+      continue;
+    }
+    const u = (target - walked) / seg.len;
+    return {
+      point: { x: seg.ax + (seg.bx - seg.ax) * u, y: seg.ay + (seg.by - seg.ay) * u },
+      tangent: { x: (seg.bx - seg.ax) / seg.len, y: (seg.by - seg.ay) / seg.len }
+    };
+  }
+  const last = segments[segments.length - 1];
+  return {
+    point: { x: last.bx, y: last.by },
+    tangent: { x: (last.bx - last.ax) / last.len, y: (last.by - last.ay) / last.len }
+  };
+}
+
+export { DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_VELOCITY_DECAY, aabbCenter, createSimulation, extractPolylines, pointAlongPath, pointInRotatedRect, rectCorners, rotatePoint, rotatedRectCorners };
+//# sourceMappingURL=chunk-LXJDWBEL.js.map
+//# sourceMappingURL=chunk-LXJDWBEL.js.map

package/dist/chunk-LXJDWBEL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/features/simulation/types.ts","../src/features/simulation/createSimulation.ts","../src/interactions/actions/rotate/geometry.ts","../src/features/paths/tessellate/polyline.ts","../src/features/paths/pathAt.ts"],"names":["last"],"mappings":"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","file":"chunk-LXJDWBEL.js","sourcesContent":["/**\n * Minimal node interface for the simulation primitive. Matches d3-force's\n * node shape exactly so d3-force's bundled forces work without translation.\n *\n * Consumers extend this with arbitrary additional fields (id, label, etc.).\n */\nexport interface SimulationNode {\n  x: number;\n  y: number;\n  vx?: number;\n  vy?: number;\n  /** Pin x to this value when non-null. The integrator skips x/vx for the node. */\n  fx?: number | null;\n  fy?: number | null;\n  /** Array index, written by `initialize`. Some forces (e.g. forceLink) rely on it. */\n  index?: number;\n}\n\n/**\n * Force protocol — contract-compatible with d3-force. A force is a function\n * called once per tick with the current alpha; it mutates `vx`/`vy` on nodes.\n * Optional `initialize` lets the force compute setup (link indices, etc.).\n */\nexport interface SimulationForce<TNode extends SimulationNode = SimulationNode> {\n  (alpha: number): void;\n  initialize?(nodes: TNode[], random?: () => number): void;\n}\n\n/** Options for `useSimulation`: everything {@link SimulationOptions} carries,\n *  plus the loop's own callbacks and clock. */\nexport interface UseSimulationOptions<TNode extends SimulationNode>\n  extends SimulationOptions<TNode> {\n  /** Fired after each integration step. */\n  onTick?: (nodes: TNode[]) => void;\n  /** Fired once when the sim settles (alpha < alphaMin && alphaTarget === 0). */\n  onEnd?: () => void;\n\n  // Test injection (mirrors useAnimator):\n  /** Optional rAF injection. Defaults to window.requestAnimationFrame. */\n  requestFrame?: (cb: (t: number) => void) => number;\n  cancelFrame?: (handle: number) => void;\n}\n\n/**\n * A force simulation over a set of nodes, with no clock of its own.\n *\n * Each tick applies every force and then integrates velocities, scaled by\n * `alpha` — a temperature that decays toward `alphaTarget` so the layout\n * settles instead of jittering forever. Raise `alphaTarget` to reheat it,\n * which is what a drag does.\n *\n * Nodes are mutated in place; the simulation holds the array, not a copy.\n *\n * Nothing here advances time. {@link Simulation} adds the frame loop; a caller\n * that wants the whole relaxation at once — a layout pass, a pre-warm, a test\n * — drives {@link SimulationCore.tick} itself.\n */\nexport interface SimulationCore<TNode extends SimulationNode> {\n  readonly nodes: TNode[];\n\n  setNodes(nodes: TNode[]): this;\n  setForces(forces: SimulationForce<TNode>[]): this;\n\n  alpha(): number;\n  alpha(value: number): this;\n  alphaTarget(): number;\n  alphaTarget(value: number): this;\n  alphaDecay(): number;\n  alphaDecay(value: number): this;\n  alphaMin(): number;\n  alphaMin(value: number): this;\n  velocityDecay(): number;\n  velocityDecay(value: number): this;\n\n  /**\n   * Run the tick body synchronously `iterations` times. Does NOT fire\n   * onTick or onEnd (matches d3-force). Used for offscreen pre-warm and tests.\n   */\n  tick(iterations?: number): this;\n\n  isSettled(): boolean;\n}\n\n/** A {@link SimulationCore} running on a frame loop. */\nexport interface Simulation<TNode extends SimulationNode> extends SimulationCore<TNode> {\n  /** Resume the RAF loop. If alpha < alphaMin, reset alpha to 1. */\n  restart(): this;\n  /** Cancel the RAF loop. Does not change alpha. */\n  stop(): this;\n}\n\n/** What {@link SimulationCore} needs: the nodes, the forces acting on them,\n *  and the cooling schedule. {@link UseSimulationOptions} adds the loop's. */\nexport interface SimulationOptions<TNode extends SimulationNode> {\n  /** Mutable array of nodes. Kit + forces mutate vx/vy/x/y in place. */\n  nodes: TNode[];\n  /** Forces applied per tick. Each may implement `initialize` for setup. */\n  forces?: SimulationForce<TNode>[];\n\n  /** Initial alpha. Default 1. */\n  alpha?: number;\n  /** Settle threshold. When alpha drops below and alphaTarget is 0, onEnd fires. Default 0.001. */\n  alphaMin?: number;\n  /** Per-tick decay rate toward alphaTarget. Default 1 - 0.001^(1/300) ≈ 0.0228. */\n  alphaDecay?: number;\n  /** Target alpha. Set above alphaMin to keep sim warm (e.g. during drag). Default 0. */\n  alphaTarget?: number;\n  /** Friction multiplier on velocity per tick: vx *= (1 - velocityDecay). Default 0.4. */\n  velocityDecay?: number;\n  /** Handed to each force's `initialize`. Default `Math.random`; pass a seeded\n   *  source to make a run reproducible. */\n  random?: () => number;\n}\n\n/** Default alpha decay: such that alpha drops from 1 to alphaMin (0.001) in 300 ticks. */\nexport const DEFAULT_ALPHA_DECAY = 1 - Math.pow(0.001, 1 / 300);\n/** Alpha below which a cooling simulation is considered settled. */\nexport const DEFAULT_ALPHA_MIN = 0.001;\n/** Fraction of velocity shed each tick — friction. Higher settles sooner and\n *  overshoots less. */\nexport const DEFAULT_VELOCITY_DECAY = 0.4;\n","/**\n * The integrator, with no clock attached.\n *\n * Velocity-Verlet over a pluggable force list, contract-compatible with\n * d3-force so d3's own bundled forces drop in untranslated. Nothing here\n * advances time: `tick()` is the only thing that moves a node, and the caller\n * decides how often to call it. `useSimulation` calls it once a frame; a\n * layout pass calls it a few hundred times in one go and reads the result.\n *\n * Splitting it out is what lets a *pure* function run a relaxation — a React\n * hook cannot, and the alternative was a second integrator drifting away from\n * this one.\n */\nimport {\n  DEFAULT_ALPHA_DECAY,\n  DEFAULT_ALPHA_MIN,\n  DEFAULT_VELOCITY_DECAY,\n  type SimulationCore,\n  type SimulationForce,\n  type SimulationNode,\n  type SimulationOptions,\n} from './types';\n\nexport function createSimulation<TNode extends SimulationNode>(\n  opts: SimulationOptions<TNode>,\n): SimulationCore<TNode> {\n  let nodes = opts.nodes;\n  let forces = opts.forces ?? [];\n  let alpha = opts.alpha ?? 1;\n  let alphaMin = opts.alphaMin ?? DEFAULT_ALPHA_MIN;\n  let alphaDecay = opts.alphaDecay ?? DEFAULT_ALPHA_DECAY;\n  let alphaTarget = opts.alphaTarget ?? 0;\n  let velocityDecay = opts.velocityDecay ?? DEFAULT_VELOCITY_DECAY;\n  const random = opts.random ?? Math.random;\n\n  /** `index` is what `forceLink` and friends address nodes by, and a d3 force\n   *  does `n.vx += …` without checking, so both must exist before the first\n   *  tick or the first tick produces NaN. */\n  function prime(list: TNode[]): void {\n    list.forEach((n, i) => {\n      n.index = i;\n      if (n.vx == null) n.vx = 0;\n      if (n.vy == null) n.vy = 0;\n    });\n  }\n\n  prime(nodes);\n  for (const f of forces) f.initialize?.(nodes, random);\n\n  function step(): void {\n    alpha += (alphaTarget - alpha) * alphaDecay;\n    for (const f of forces) f(alpha);\n\n    const friction = 1 - velocityDecay;\n    for (const n of nodes) {\n      if (n.fx == null) {\n        n.vx = (n.vx ?? 0) * friction;\n        // A non-finite velocity — force overflow, or two nodes exactly\n        // coincident — would reach the renderer as geometry and cost\n        // pathological tessellation work without throwing anywhere.\n        if (!Number.isFinite(n.vx)) n.vx = 0;\n        n.x += n.vx;\n        if (!Number.isFinite(n.x)) n.x = 0;\n      } else {\n        n.x = n.fx;\n        n.vx = 0;\n      }\n      if (n.fy == null) {\n        n.vy = (n.vy ?? 0) * friction;\n        if (!Number.isFinite(n.vy)) n.vy = 0;\n        n.y += n.vy;\n        if (!Number.isFinite(n.y)) n.y = 0;\n      } else {\n        n.y = n.fy;\n        n.vy = 0;\n      }\n    }\n  }\n\n  /* eslint-disable @typescript-eslint/no-explicit-any */\n  const core: any = {\n    get nodes() {\n      return nodes;\n    },\n    setNodes(next: TNode[]) {\n      nodes = next;\n      prime(nodes);\n      for (const f of forces) f.initialize?.(nodes, random);\n      return core;\n    },\n    setForces(next: SimulationForce<TNode>[]) {\n      const old = forces;\n      forces = next;\n      for (const f of next) {\n        if (!old.includes(f)) f.initialize?.(nodes, random);\n      }\n      return core;\n    },\n    alpha(value?: number) {\n      if (value === undefined) return alpha;\n      alpha = value;\n      return core;\n    },\n    alphaTarget(value?: number) {\n      if (value === undefined) return alphaTarget;\n      alphaTarget = value;\n      return core;\n    },\n    alphaDecay(value?: number) {\n      if (value === undefined) return alphaDecay;\n      alphaDecay = value;\n      return core;\n    },\n    alphaMin(value?: number) {\n      if (value === undefined) return alphaMin;\n      alphaMin = value;\n      return core;\n    },\n    velocityDecay(value?: number) {\n      if (value === undefined) return velocityDecay;\n      velocityDecay = value;\n      return core;\n    },\n    tick(iterations: number = 1) {\n      for (let i = 0; i < iterations; i++) step();\n      return core;\n    },\n    isSettled() {\n      return alpha < alphaMin && alphaTarget === 0;\n    },\n  };\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n  return core as SimulationCore<TNode>;\n}\n","import type { RotatedPose } from '../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** AABB center of an unrotated rect — the canonical rotation pivot. */\nexport function aabbCenter(bounds: Bounds): { x: number; y: number } {\n  return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };\n}\n\n/** Rotate `(px, py)` by `angle` (radians) around `(cx, cy)`. */\nexport function rotatePoint(\n  px: number,\n  py: number,\n  cx: number,\n  cy: number,\n  angle: number,\n): { x: number; y: number } {\n  const c = Math.cos(angle);\n  const s = Math.sin(angle);\n  const dx = px - cx;\n  const dy = py - cy;\n  return { x: cx + dx * c - dy * s, y: cy + dx * s + dy * c };\n}\n\n/** Four corners of an unrotated rect, in TL/TR/BR/BL order. */\nexport function rectCorners(bounds: Bounds): { x: number; y: number }[] {\n  return [\n    { x: bounds.x, y: bounds.y },\n    { x: bounds.x + bounds.width, y: bounds.y },\n    { x: bounds.x + bounds.width, y: bounds.y + bounds.height },\n    { x: bounds.x, y: bounds.y + bounds.height },\n  ];\n}\n\n/** Four corners of a rotated rect (rotation around AABB center), in\n *  TL/TR/BR/BL order. Useful for selection-overlay rendering. */\nexport function rotatedRectCorners(pose: RotatedPose): { x: number; y: number }[] {\n  const c = aabbCenter(pose);\n  return rectCorners(pose).map((p) => rotatePoint(p.x, p.y, c.x, c.y, pose.rotation));\n}\n\n/** Hit-test a world point against a rotated rect (rotation around AABB\n *  center). Standard pattern: invert the rotation and AABB-test in the\n *  rect's local frame. */\nexport function pointInRotatedRect(\n  pose: RotatedPose,\n  worldX: number,\n  worldY: number,\n): boolean {\n  const c = aabbCenter(pose);\n  const local = rotatePoint(worldX, worldY, c.x, c.y, -pose.rotation);\n  return (\n    local.x >= pose.x &&\n    local.x <= pose.x + pose.width &&\n    local.y >= pose.y &&\n    local.y <= pose.y + pose.height\n  );\n}\n","import { forEachSegment, rectToContour } from '@weasel-js/geom';\nimport {\n  PATH_M,\n  PATH_L,\n  PATH_Z,\n  PATH_C,\n  PATH_Q,\n  DEFAULT_FLATTEN_TOLERANCE,\n  flattenCubicWithArcLen,\n  flattenQuadraticWithArcLen,\n} from '@weasel-js/geom';\nimport type { Path, PolygonPath, RectPath } from '../../../core/geometry/path';\n\nexport interface Polyline {\n  /** Interleaved x,y vertices (length = 2 × point count). */\n  points: number[];\n  /** Whether the contour was closed (ends with Z, or is a RectPath). */\n  closed: boolean;\n  /** For each point, the previous anchor index. Anchor-aligned points set A === B. */\n  anchorA?: Uint32Array;\n  /** For each point, the next anchor index. */\n  anchorB?: Uint32Array;\n  /** For each point, the arc-length fraction along (A, B). 0 at anchor A; for anchor-aligned, set to 0. */\n  anchorT?: Float32Array;\n  /** Per-point stroke width, populated by the tessellator when the Stroke\n   *  carries `vertexWidths`. Undefined means uniform `Stroke.width`. */\n  widths?: Float32Array;\n}\n\nexport interface ExtractOptions {\n  flattenTolerance?: number;\n}\n\nexport function extractPolylines(path: Path, opts: ExtractOptions = {}): Polyline[] {\n  if (path.kind === 'rect') return [extractRect(path)];\n  return extractPolygon(path, opts);\n}\n\nfunction extractRect(p: RectPath): Polyline {\n  const { x, y, width: w, height: h } = p;\n  return {\n    points: Array.from(rectToContour(x, y, w, h)),\n    closed: true,\n    anchorA: new Uint32Array([0, 1, 2, 3]),\n    anchorB: new Uint32Array([0, 1, 2, 3]),\n    anchorT: new Float32Array([0, 0, 0, 0]),\n  };\n}\n\nfunction extractPolygon(p: PolygonPath, opts: ExtractOptions): Polyline[] {\n  const tolerance = opts.flattenTolerance ?? DEFAULT_FLATTEN_TOLERANCE;\n  const { commands, coords } = p;\n  const out: Polyline[] = [];\n  // Anchors are numbered globally (across all contours) in command-stream order.\n  let anchorCounter = 0;\n\n  // Builders for the current polyline.\n  let pts: number[] | null = null;\n  let aA: number[] | null = null;\n  let aB: number[] | null = null;\n  let aT: number[] | null = null;\n  let current: Polyline | null = null;\n\n  let prevAnchor = -1;\n\n  const beginContour = (): Polyline => {\n    pts = [];\n    aA = [];\n    aB = [];\n    aT = [];\n    const next: Polyline = { points: pts, closed: false };\n    out.push(next);\n    return next;\n  };\n\n  /**\n   * A closed contour's last point repeating its first is redundant — Z already\n   * says \"return to the start\" — and it is *harmful*: it leaves a zero-length\n   * closing segment, which the stroker discards along with the wrap-around\n   * join it should have carried, notching the ribbon at the contour's start.\n   *\n   * Every font outline serialized by opentype.js is written this way, as is a\n   * great deal of hand-written and exported SVG, so this is the common case\n   * rather than a defensive edge. Exact equality is the right test: the\n   * duplicate is a re-emission of the same number, not an approach to it, and\n   * a near-miss is a genuine (if tiny) segment the author asked for.\n   */\n  const dropDuplicateClosingPoint = (): void => {\n    if (!pts || !aA || !aB || !aT) return;\n    const n = pts.length / 2;\n    if (n < 2) return;\n    if (pts[0] !== pts[(n - 1) * 2] || pts[1] !== pts[(n - 1) * 2 + 1]) return;\n    pts.length -= 2;\n    aA.length -= 1;\n    aB.length -= 1;\n    aT.length -= 1;\n  };\n\n  const commit = (target: Polyline): void => {\n    if (!pts || !aA || !aB || !aT) return;\n    target.anchorA = new Uint32Array(aA);\n    target.anchorB = new Uint32Array(aB);\n    target.anchorT = new Float32Array(aT);\n  };\n\n  // Fill anchorA/B/T for each point a curve just appended: interior points\n  // interpolate (prevAnchor → target), and the final point is pinned to the\n  // target so the draw-time lerp returns anchor B's color exactly.\n  const pushCurveAnchors = (segStart: number, arcAccum: number[], total: number, target: number): void => {\n    for (let k = 0; k < arcAccum.length; k++) {\n      aA!.push(prevAnchor);\n      aB!.push(target);\n      aT!.push(total > 0 ? arcAccum[k] / total : 0);\n    }\n    const lastIdx = (segStart + arcAccum.length) - 1;\n    aA![lastIdx] = target;\n    aB![lastIdx] = target;\n    aT![lastIdx] = 0;\n  };\n\n  forEachSegment(commands, coords, (cmd, coordIdx, prevX, prevY) => {\n    switch (cmd) {\n      case PATH_M:\n      case PATH_L: {\n        if (cmd === PATH_M) {\n          if (current) commit(current);\n          current = beginContour();\n        }\n        pts!.push(coords[coordIdx], coords[coordIdx + 1]);\n        aA!.push(anchorCounter);\n        aB!.push(anchorCounter);\n        aT!.push(0);\n        prevAnchor = anchorCounter;\n        anchorCounter++;\n        break;\n      }\n      case PATH_Q: {\n        const target = anchorCounter;\n        const segStart = pts!.length / 2;\n        const arcAccum: number[] = [];\n        const total = flattenQuadraticWithArcLen(\n          prevX, prevY,\n          coords[coordIdx], coords[coordIdx + 1],\n          coords[coordIdx + 2], coords[coordIdx + 3],\n          tolerance, pts!, arcAccum,\n        );\n        pushCurveAnchors(segStart, arcAccum, total, target);\n        prevAnchor = target;\n        anchorCounter++;\n        break;\n      }\n      case PATH_C: {\n        const target = anchorCounter;\n        const segStart = pts!.length / 2;\n        const arcAccum: number[] = [];\n        const total = flattenCubicWithArcLen(\n          prevX, prevY,\n          coords[coordIdx], coords[coordIdx + 1],\n          coords[coordIdx + 2], coords[coordIdx + 3],\n          coords[coordIdx + 4], coords[coordIdx + 5],\n          tolerance, pts!, arcAccum,\n        );\n        pushCurveAnchors(segStart, arcAccum, total, target);\n        prevAnchor = target;\n        anchorCounter++;\n        break;\n      }\n      case PATH_Z: {\n        if (current) {\n          current.closed = true;\n          dropDuplicateClosingPoint();\n        }\n        break;\n      }\n      default:\n        throw new Error(`extractPolylines: unknown command code ${cmd}`);\n    }\n  });\n\n  if (current) commit(current);\n  return out;\n}\n","/**\n * A station along a path: where it is at a fraction of its length, and which\n * way it is heading there.\n *\n * For anything positioned *along* geometry rather than beside it — a label on a\n * routed edge, a tick on a curve, a badge near an arrowhead. Curves are\n * flattened first, so the fraction is arc length along the drawn shape rather\n * than a curve parameter, which is what makes 0.5 look like the middle.\n */\nimport type { Vec2 } from 'core/geometry/polygonHitTestRect';\nimport type { Path } from 'core/geometry/path';\nimport { extractPolylines } from './tessellate/polyline';\n\nexport interface PathStation {\n  point: Vec2;\n  /** Unit vector along the path at `point`, pointing toward the end. */\n  tangent: Vec2;\n}\n\nexport interface PointAlongPathOptions {\n  /** Curve flattening tolerance, in world units. Default 0.5. */\n  flattenTolerance?: number;\n}\n\n/**\n * Where `path` is at `t` of its total length, and its heading there.\n *\n * `t` is clamped to 0..1. Subpaths are measured in order and treated as one\n * run, the way a browser measures a whole `<path>`. Returns `null` for a path\n * with no points at all; a path of zero length answers at its single point,\n * heading along +X.\n */\nexport function pointAlongPath(\n  path: Path,\n  t: number,\n  opts: PointAlongPathOptions = {},\n): PathStation | null {\n  const polylines = extractPolylines(\n    path,\n    opts.flattenTolerance === undefined ? {} : { flattenTolerance: opts.flattenTolerance },\n  );\n\n  /** Every segment, in order, with the length it contributes. */\n  const segments: { ax: number; ay: number; bx: number; by: number; len: number }[] = [];\n  let total = 0;\n  let first: Vec2 | undefined;\n  for (const pl of polylines) {\n    const count = pl.points.length / 2;\n    if (count === 0) continue;\n    first ??= { x: pl.points[0]!, y: pl.points[1]! };\n    const last = pl.closed ? count : count - 1;\n    for (let i = 0; i < last; i++) {\n      const j = (i + 1) % count;\n      const ax = pl.points[i * 2]!;\n      const ay = pl.points[i * 2 + 1]!;\n      const bx = pl.points[j * 2]!;\n      const by = pl.points[j * 2 + 1]!;\n      const len = Math.hypot(bx - ax, by - ay);\n      if (len === 0) continue;\n      segments.push({ ax, ay, bx, by, len });\n      total += len;\n    }\n  }\n\n  if (first === undefined) return null;\n  if (segments.length === 0) return { point: first, tangent: { x: 1, y: 0 } };\n\n  const target = Math.min(Math.max(t, 0), 1) * total;\n  let walked = 0;\n  for (const seg of segments) {\n    if (walked + seg.len < target) {\n      walked += seg.len;\n      continue;\n    }\n    const u = (target - walked) / seg.len;\n    return {\n      point: { x: seg.ax + (seg.bx - seg.ax) * u, y: seg.ay + (seg.by - seg.ay) * u },\n      tangent: { x: (seg.bx - seg.ax) / seg.len, y: (seg.by - seg.ay) / seg.len },\n    };\n  }\n\n  // Float drift can leave `target` a hair past the last segment.\n  const last = segments[segments.length - 1]!;\n  return {\n    point: { x: last.bx, y: last.by },\n    tangent: { x: (last.bx - last.ax) / last.len, y: (last.by - last.ay) / last.len },\n  };\n}\n"]}

package/dist/{chunk-BDWAA634.js → chunk-P6MGECVO.js}

@@ -1,4 +1,4 @@
-import { RECT_ORIGIN_PROJECTION } from './chunk-UCPV7JXC.js';
+import { RECT_ORIGIN_PROJECTION } from './chunk-HAGOFNP5.js';
 import { registerOpFactory, captureSlot, slotFromIndex, resolveSlot } from './chunk-4RJP2N2L.js';
 
 // src/core/ops/transform.ts
@@ -124,5 +124,5 @@ function snap(strategy, opts = {}) {
 }
 
 export { createReparentOp, createTransformOp, snap };
-//# sourceMappingURL=chunk-BDWAA634.js.map
-//# sourceMappingURL=chunk-BDWAA634.js.map
+//# sourceMappingURL=chunk-P6MGECVO.js.map
+//# sourceMappingURL=chunk-P6MGECVO.js.map