@weasel-js/geom 1.11.0 → 1.12.0

package/dist/index.js

@@ -1,21 +1,21 @@
-import { carryCorners, evalSeg, parseSubpaths, keepCorners, anchorRange, subSeg, writePath, derivSeg } from './chunk-7KLJZFBY.js';
-export { CORNER_RESTORE_TOLERANCE, cornerTraces, keepCorners, restoreCorners } from './chunk-7KLJZFBY.js';
+import { carryCorners, evalSeg, parseSubpaths, keepCorners, anchorRange, subSeg, writePath, derivSeg } from './chunk-YPWFGFQX.js';
+export { CORNER_RESTORE_TOLERANCE, cornerTraces, keepCorners, restoreCorners } from './chunk-YPWFGFQX.js';
 import { PORT_REACH, portControls, portCurvePoints } from './chunk-YQADYJJ7.js';
 export { PORT_REACH } from './chunk-YQADYJJ7.js';
 import { cubicDerivativeAt, cubicCurvatureAt } from './chunk-UI3FUWXM.js';
 export { SPIRO_KINDS, combTeeth, cubicCurvatureAt, cubicCurvatureSource, cubicDerivativeAt, curvatureComb, eulerAngleAt, eulerCurvatureAt, eulerCurvatureDerivativesAt, eulerPointAt, fitEulerSegment, isSpiroKind, placeEulerSegment, solveSpiro, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath } from './chunk-UI3FUWXM.js';
-import { extractPolylines } from './chunk-6XSJY3TC.js';
-import { boundsOfPath, fitPointRun, keepCorner } from './chunk-HGF5OVEN.js';
-export { boundsOfPath } from './chunk-HGF5OVEN.js';
+import { extractPolylines } from './chunk-VHXOCDZ2.js';
+import { boundsOfPath, fitPointRun, keepCorner } from './chunk-STGSBIOL.js';
+export { boundsOfPath } from './chunk-STGSBIOL.js';
 import { countPathAnchors, pathToAnchors, anchorsToPath, isAnchorSmooth, segmentEnds, isStraightSegment, nearestSegmentT } from './chunk-Q66NA2FU.js';
 export { anchorsToPath, countPathAnchors, isAnchorSmooth, isStraightSegment, nearestSegmentT, pathToAnchors, segmentEnds } from './chunk-Q66NA2FU.js';
-import { nearestOnPath, nearestOnLine, nearestOnQuadratic, nearestOnCubic } from './chunk-CE7IY7TB.js';
+import { nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestOnCubic } from './chunk-CE7IY7TB.js';
 export { nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic } from './chunk-CE7IY7TB.js';
-import { pointInPolygon, resolveCorners, cornerCuts, fillsOpenSubpaths, schneiderFit, fitCubicWithTangents, pointSegmentDist2, flattenQuadratic, flattenCubic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross } from './chunk-J2O2B54M.js';
-export { CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, DEFAULT_FLATTEN_TOLERANCE, cornerCenter, cornerCuts, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerShapePoint, defaultOpenFill, fillsOpenSubpaths, fitCubicWithTangents, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, isCornerShape, nextCornerShape, pointInPolygon, pointSegmentDist2, remapPerAnchor, resolveCorners, resolveCornersWithSources, schneiderFit, segmentsCross, setDefaultOpenFill } from './chunk-J2O2B54M.js';
-import { SINGULAR_RATIO } from './chunk-755Y4YZS.js';
+import { resolveCorners, pointInPolygon, cornerCuts, fillsOpenSubpaths, schneiderFit, fitCubicWithTangents, flattenCubic, pointSegmentDist2, flattenQuadratic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross } from './chunk-2PKPKU4P.js';
+export { CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, DEFAULT_FLATTEN_TOLERANCE, cornerCenter, cornerCuts, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerShapePoint, defaultOpenFill, fillsOpenSubpaths, fitCubicWithTangents, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, isCornerShape, nextCornerShape, pointInPolygon, pointSegmentDist2, remapPerAnchor, resolveCorners, resolveCornersWithSources, schneiderFit, segmentsCross, setDefaultOpenFill } from './chunk-2PKPKU4P.js';
+import { SINGULAR_RATIO, clamp } from './chunk-755Y4YZS.js';
 export { EPS, approxEq, clamp, cross, dot, len2, sign, sub } from './chunk-755Y4YZS.js';
-import { PathBuilder, withCorner, scaleCorners, forEachSegment, pathCommandCoordCount, withoutCorners, PATH_M, PATH_Z, PATH_L, PATH_C, PATH_Q, elevateQuadraticToCubic, cubicEvalAt, cubicPointAt, splitCubicAtT, cubicAxisExtremaTs, rectToContour, splitCubicAt } from './chunk-B53BERKG.js';
+import { PATH_M, PATH_L, PATH_C, PATH_Q, PATH_Z, PathBuilder, withCorner, scaleCorners, forEachSegment, pathCommandCoordCount, withoutCorners, elevateQuadraticToCubic, cubicEvalAt, cubicPointAt, splitCubicAtT, cubicAxisExtremaTs, rectToContour, splitCubicAt } from './chunk-B53BERKG.js';
 export { PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, PathBuilder, asPolygonPath, boundsOfCoords, boxContainsBox, boxContainsPoint, compactCorners, cornerAt, cornerSpecAt, cubicAxisExtremaTs, cubicBounds, cubicEvalAt, cubicPointAt, elevateQuadraticToCubic, ellipsePath, forEachSegment, hasCorners, lerpCorners, linePath, pathCommandCoordCount, polygonFromPoints, polylineFromPoints, quadraticEvalAt, rectPath, rectToContour, regularPolygonPath, scaleCorners, splitCubicAt, splitCubicAtT, splitLineAt, splitQuadraticAt, starPath, unionBox, withCorner, withoutCorners } from './chunk-B53BERKG.js';
 
 // src/view.ts
@@ -82,6 +82,516 @@ function transformCoords(coords, m) {
   return out;
 }
 
+// src/track/shape.ts
+function lineShape(from, to) {
+  const dx2 = to.x - from.x;
+  const dy2 = to.y - from.y;
+  const length2 = Math.hypot(dx2, dy2);
+  const tangent = length2 === 0 ? { x: 1, y: 0 } : { x: dx2 / length2, y: dy2 / length2 };
+  const normal2 = { x: tangent.y, y: -tangent.x };
+  return {
+    kind: "line",
+    length: length2,
+    closed: false,
+    at(f) {
+      const t = clamp(f, 0, 1);
+      return {
+        point: { x: from.x + t * dx2, y: from.y + t * dy2 },
+        tangent: { ...tangent },
+        normal: { ...normal2 }
+      };
+    },
+    nearest(p, options) {
+      const n = nearestOnLine(p.x, p.y, from.x, from.y, to.x, to.y);
+      if (!options?.open || length2 === 0) return { f: n.t, dist: n.dist };
+      const f = ((p.x - from.x) * dx2 + (p.y - from.y) * dy2) / (length2 * length2);
+      return { f, dist: n.dist };
+    }
+  };
+}
+
+// src/track/arc.ts
+var RAD = Math.PI / 180;
+var mod360 = (a) => (a % 360 + 360) % 360;
+function arcShape(spec) {
+  const { center, radius, start } = spec;
+  const sign2 = spec.direction === "ccw" ? -1 : 1;
+  const raw = mod360(sign2 * (spec.end - start));
+  const sweep = raw === 0 ? 360 : raw;
+  const length2 = radius * sweep * RAD;
+  const at2 = (f) => {
+    const t = clamp(f, 0, 1);
+    const theta = (start + sign2 * t * sweep) * RAD;
+    const s = Math.sin(theta);
+    const c = Math.cos(theta);
+    return {
+      point: { x: center.x + radius * s, y: center.y - radius * c },
+      tangent: { x: sign2 * c, y: sign2 * s },
+      normal: { x: s, y: -c }
+    };
+  };
+  const shape = {
+    kind: "arc",
+    length: length2,
+    closed: raw === 0,
+    at: at2,
+    nearest(p, options) {
+      const dx2 = p.x - center.x;
+      const dy2 = p.y - center.y;
+      const angle = dx2 === 0 && dy2 === 0 ? 0 : Math.atan2(dx2, -dy2) / RAD;
+      const offset2 = mod360(sign2 * (angle - start));
+      let f;
+      if (offset2 <= sweep) f = offset2 / sweep;
+      else f = 360 - offset2 < offset2 - sweep ? 0 : 1;
+      const q = at2(f).point;
+      const dist = Math.hypot(p.x - q.x, p.y - q.y);
+      if (!options?.open) return { f, dist };
+      const mid = (options.about ?? 0.5) * sweep;
+      const unwrapped = mid + mod360(offset2 - mid + 180) - 180;
+      return { f: unwrapped / sweep, dist };
+    }
+  };
+  Object.defineProperty(shape, "arc", { value: spec, enumerable: false });
+  return shape;
+}
+
+// src/track/ellipse.ts
+var RAD2 = Math.PI / 180;
+var mod3602 = (a) => (a % 360 + 360) % 360;
+var PIECES = 128;
+var PANELS = 4;
+var RING = 256;
+var pointAt = ({ center, a, b, t0, sign: sign2 }, u) => {
+  const t = (t0 + sign2 * u) * RAD2;
+  return { x: center.x + a * Math.sin(t), y: center.y - b * Math.cos(t) };
+};
+var speed = ({ a, b, t0, sign: sign2 }, u) => {
+  const t = (t0 + sign2 * u) * RAD2;
+  return Math.hypot(a * Math.cos(t), b * Math.sin(t)) * RAD2;
+};
+function lengthTable(e, sweep) {
+  const simpson = (u0, u1) => {
+    const h = (u1 - u0) / PANELS;
+    let sum = speed(e, u0) + speed(e, u1);
+    for (let i = 1; i < PANELS; i++) sum += speed(e, u0 + i * h) * (i % 2 ? 4 : 2);
+    return sum * h / 3;
+  };
+  const du = sweep / PIECES;
+  const table = [0];
+  for (let i = 0; i < PIECES; i++) table.push(table[i] + simpson(i * du, (i + 1) * du));
+  const length2 = table[PIECES];
+  const lengthTo = (u) => {
+    if (u >= 0 && u <= sweep) {
+      const i = Math.min(PIECES - 1, Math.floor(u / du));
+      return table[i] + simpson(i * du, u);
+    }
+    const n = Math.max(1, Math.ceil(Math.abs(u) / du));
+    let s = 0;
+    for (let i = 0; i < n; i++) s += simpson(u * i / n, u * (i + 1) / n);
+    return s;
+  };
+  const offsetAt = (f) => {
+    if (length2 === 0) return f * sweep;
+    const s = f * length2;
+    let lo = 0;
+    let hi = PIECES;
+    while (hi - lo > 1) {
+      const mid = lo + hi >> 1;
+      if (table[mid] <= s) lo = mid;
+      else hi = mid;
+    }
+    const piece = table[lo + 1] - table[lo];
+    let u = (lo + (piece === 0 ? 0 : (s - table[lo]) / piece)) * du;
+    for (let i = 0; i < 3; i++) {
+      const v = speed(e, u);
+      if (!(v > 0)) break;
+      u -= (lengthTo(u) - s) / v;
+    }
+    return u;
+  };
+  return { length: length2, lengthTo, offsetAt };
+}
+var dist2 = (e, p, u) => {
+  const q = pointAt(e, u);
+  return (p.x - q.x) ** 2 + (p.y - q.y) ** 2;
+};
+function footBetween(e, p, lo, hi, n, late) {
+  let best = lo;
+  let bestD = dist2(e, p, lo);
+  const step = (hi - lo) / n;
+  for (let i = 1; i <= n; i++) {
+    const v = i === n ? hi : lo + i * step;
+    const d = dist2(e, p, v);
+    if (late ? d <= bestD * (1 + 1e-12) : d < bestD * (1 - 1e-12)) [best, bestD] = [v, d];
+  }
+  const { a, b, t0, sign: sign2 } = e;
+  const dx2 = p.x - e.center.x;
+  const dy2 = p.y - e.center.y;
+  let u = best;
+  for (let i = 0; i < 12; i++) {
+    const t = (t0 + sign2 * u) * RAD2;
+    const s = Math.sin(t);
+    const c = Math.cos(t);
+    const g = (a * a - b * b) * s * c - dx2 * a * c - dy2 * b * s;
+    const g1 = (a * a - b * b) * (c * c - s * s) + dx2 * a * s - dy2 * b * c;
+    if (!(g1 > 0)) break;
+    const next = clamp(u - sign2 * g / g1 / RAD2, Math.max(lo, best - step), Math.min(hi, best + step));
+    if (Math.abs(next - u) < 1e-12) break;
+    u = next;
+  }
+  return dist2(e, p, u) <= bestD ? u : best;
+}
+function ellipseShape(spec) {
+  const { center, radiusX: a, radiusY: b } = spec;
+  const sign2 = spec.direction === "ccw" ? -1 : 1;
+  const param = (seenDeg) => Math.atan2(b * Math.sin(seenDeg * RAD2), a * Math.cos(seenDeg * RAD2)) / RAD2;
+  const e = { center, a, b, t0: param(spec.start), sign: sign2 };
+  const raw = mod3602(sign2 * (param(spec.end) - e.t0));
+  const sweep = raw === 0 ? 360 : raw;
+  const { length: length2, lengthTo, offsetAt } = lengthTable(e, sweep);
+  const at2 = (f) => {
+    const u = offsetAt(clamp(f, 0, 1));
+    const t = (e.t0 + sign2 * u) * RAD2;
+    const s = Math.sin(t);
+    const c = Math.cos(t);
+    const k = Math.hypot(a * c, b * s);
+    const tangent = k === 0 ? { x: sign2 * c, y: sign2 * s } : { x: sign2 * a * c / k, y: sign2 * b * s / k };
+    const normal2 = k === 0 ? { x: s, y: -c } : { x: b * s / k, y: -a * c / k };
+    return { point: pointAt(e, u), tangent, normal: normal2 };
+  };
+  const shape = {
+    kind: "ellipse",
+    length: length2,
+    closed: raw === 0,
+    at: at2,
+    nearest(p, options) {
+      const u = footBetween(e, p, 0, sweep, PIECES, true);
+      const f = length2 === 0 ? 0 : clamp(lengthTo(u) / length2, 0, 1);
+      const dist = Math.sqrt(dist2(e, p, u));
+      if (!options?.open || length2 === 0) return { f, dist };
+      const mid = offsetAt(options.about ?? 0.5);
+      return { f: lengthTo(footBetween(e, p, mid - 180, mid + 180, RING, false)) / length2, dist };
+    }
+  };
+  Object.defineProperty(shape, "ellipse", { value: spec, enumerable: false });
+  return shape;
+}
+
+// src/paths/pathMeasure.ts
+function measurePath(path, opts = {}) {
+  const polylines = extractPolylines(
+    path,
+    opts.flattenTolerance === void 0 ? {} : { flattenTolerance: opts.flattenTolerance }
+  );
+  const segments = [];
+  let total = 0;
+  let first;
+  let contours = 0;
+  let lastClosed = false;
+  for (const pl of polylines) {
+    const count = pl.points.length / 2;
+    if (count === 0) continue;
+    contours++;
+    lastClosed = pl.closed;
+    first ??= { x: pl.points[0], y: pl.points[1] };
+    const startIndex = segments.length;
+    const last = pl.closed ? count : count - 1;
+    for (let i = 0; i < last; 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;
+      const tx = (bx - ax) / len;
+      const ty = (by - ay) / len;
+      segments.push({ ax, ay, bx, by, start: total, len, tx, ty, t0x: tx, t0y: ty, t1x: tx, t1y: ty });
+      total += len;
+    }
+    smoothVertexHeadings(segments, startIndex, pl.closed, opts.keepCorners ? opts.flattenTolerance ?? 0.5 : null);
+  }
+  if (first === void 0) return null;
+  const origin = first;
+  const closed = contours === 1 && lastClosed;
+  if (segments.length === 0) {
+    return {
+      length: 0,
+      closed,
+      at: () => ({ point: { ...origin }, tangent: { x: 1, y: 0 } }),
+      nearest: (p) => ({
+        s: 0,
+        dist: Math.hypot(p.x - origin.x, p.y - origin.y),
+        point: { ...origin },
+        tangent: { x: 1, y: 0 }
+      })
+    };
+  }
+  return {
+    length: total,
+    closed,
+    at(s, smooth = false) {
+      const target = Math.min(Math.max(s, 0), total);
+      const seg = segments[segmentAt(segments, target)];
+      const u = Math.min(Math.max((target - seg.start) / seg.len, 0), 1);
+      const point = { x: seg.ax + (seg.bx - seg.ax) * u, y: seg.ay + (seg.by - seg.ay) * u };
+      if (!smooth) return { point, tangent: { x: seg.tx, y: seg.ty } };
+      const x = seg.t0x + (seg.t1x - seg.t0x) * u;
+      const y = seg.t0y + (seg.t1y - seg.t0y) * u;
+      const l = Math.hypot(x, y);
+      return { point, tangent: l === 0 ? { x: seg.tx, y: seg.ty } : { x: x / l, y: y / l } };
+    },
+    nearest(p) {
+      let best = segments[0];
+      let bestU = 0;
+      let bestDist = Infinity;
+      for (const seg of segments) {
+        const u = Math.min(Math.max(((p.x - seg.ax) * seg.tx + (p.y - seg.ay) * seg.ty) / seg.len, 0), 1);
+        const d = Math.hypot(p.x - (seg.ax + (seg.bx - seg.ax) * u), p.y - (seg.ay + (seg.by - seg.ay) * u));
+        if (d < bestDist) {
+          best = seg;
+          bestU = u;
+          bestDist = d;
+        }
+      }
+      return {
+        s: best.start + best.len * bestU,
+        dist: bestDist,
+        point: { x: best.ax + (best.bx - best.ax) * bestU, y: best.ay + (best.by - best.ay) * bestU },
+        tangent: { x: best.tx, y: best.ty }
+      };
+    }
+  };
+}
+function smoothVertexHeadings(segments, from, closed, cornerTolerance) {
+  const n = segments.length - from;
+  if (n < 2) return;
+  const pairs = closed ? n : n - 1;
+  for (let k = 0; k < pairs; k++) {
+    const a = segments[from + k];
+    const b = segments[from + (k + 1) % n];
+    if (cornerTolerance !== null && isCorner(a, b, cornerTolerance)) continue;
+    let x = a.tx + b.tx;
+    let y = a.ty + b.ty;
+    const l = Math.hypot(x, y);
+    if (l < 1e-9) continue;
+    x /= l;
+    y /= l;
+    a.t1x = x;
+    a.t1y = y;
+    b.t0x = x;
+    b.t0y = y;
+  }
+}
+function isCorner(a, b, tolerance) {
+  const turn = Math.acos(Math.min(1, Math.max(-1, a.tx * b.tx + a.ty * b.ty)));
+  return turn > 16 * tolerance / Math.min(a.len, b.len);
+}
+function segmentAt(segments, s) {
+  let lo = 0;
+  let hi = segments.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (segments[mid].start <= s) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo;
+}
+
+// src/track/path.ts
+function pathShape(path, options = {}) {
+  const measure2 = measurePath(path, { ...options, keepCorners: true });
+  if (!measure2) return null;
+  const { length: length2, closed } = measure2;
+  const shape = {
+    kind: "path",
+    length: length2,
+    closed,
+    at(f) {
+      const { point, tangent } = measure2.at(clamp(f, 0, 1) * length2, true);
+      return { point, tangent, normal: { x: tangent.y, y: -tangent.x } };
+    },
+    nearest(p, opts) {
+      const n = measure2.nearest(p);
+      const f = length2 === 0 ? 0 : n.s / length2;
+      if (!opts?.open || !closed || length2 === 0) return { f, dist: n.dist };
+      const about = opts.about ?? 0.5;
+      const unwrapped = [f - 1, f + 1].reduce((best, g) => Math.abs(g - about) < Math.abs(best - about) ? g : best, f);
+      return { f: unwrapped, dist: n.dist };
+    }
+  };
+  Object.defineProperty(shape, "path", { value: path, enumerable: false });
+  return shape;
+}
+
+// src/track/run.ts
+function trackRun(shape, from = 0, to = 1, options = {}) {
+  const { side = "auto", about = (from + to) / 2 } = options;
+  const mid = shape.at(about);
+  const flipped = side === "auto" ? mid.normal.y > 1e-9 : side === "flipped";
+  const sgn = flipped ? -1 : 1;
+  const reading = (n) => ({ x: -(sgn * n.y), y: sgn * n.x });
+  const r0 = reading(mid.normal);
+  const reversed3 = r0.x * mid.tangent.x + r0.y * mid.tangent.y < 0;
+  const span = to - from;
+  const lo = Math.min(from, to);
+  const hi = Math.max(from, to);
+  const toF = (g) => reversed3 ? to - g * span : from + g * span;
+  const at2 = (g) => {
+    const s = shape.at(toF(clamp(g, 0, 1)));
+    const dir = reading(s.normal);
+    const angle = Math.atan2(dir.y, dir.x) * 180 / Math.PI;
+    return {
+      point: s.point,
+      tangent: dir,
+      normal: { x: sgn * s.normal.x, y: sgn * s.normal.y },
+      angle: angle === 0 ? 0 : angle === -180 ? 180 : angle
+    };
+  };
+  const toG = (f) => span === 0 ? 0 : reversed3 ? (to - f) / span : (f - from) / span;
+  const nearest = (p, options2) => {
+    const f = clamp(shape.nearest(p).f, lo, hi);
+    const q = shape.at(f).point;
+    const dist = Math.hypot(p.x - q.x, p.y - q.y);
+    if (!options2?.open) return { f: toG(f), dist };
+    return { f: toG(shape.nearest(p, { open: true, about: toF(options2.about ?? 0.5) }).f), dist };
+  };
+  return {
+    kind: shape.kind,
+    length: shape.length * Math.abs(span),
+    closed: shape.closed && Math.abs(span) === 1,
+    shape,
+    from,
+    to,
+    flipped,
+    reversed: reversed3,
+    at: at2,
+    nearest
+  };
+}
+
+// src/paths/pathToD.ts
+var num = (n) => Number.isFinite(n) ? String(Math.round(n * 1e6) / 1e6) : "0";
+function pathToD(given) {
+  const path = resolveCorners(given);
+  if (path.kind === "rect") {
+    const { x, y, width, height } = path;
+    return `M${num(x)} ${num(y)}h${num(width)}v${num(height)}h${num(-width)}Z`;
+  }
+  const cmds = path.commands;
+  const xs = path.coords;
+  const out = [];
+  let ci = 0;
+  for (let i = 0; i < cmds.length; i++) {
+    const c = cmds[i];
+    if (c === PATH_M) {
+      out.push(`M${num(xs[ci])} ${num(xs[ci + 1])}`);
+      ci += 2;
+    } else if (c === PATH_L) {
+      out.push(`L${num(xs[ci])} ${num(xs[ci + 1])}`);
+      ci += 2;
+    } else if (c === PATH_C) {
+      out.push(
+        `C${num(xs[ci])} ${num(xs[ci + 1])} ${num(xs[ci + 2])} ${num(xs[ci + 3])} ${num(xs[ci + 4])} ${num(xs[ci + 5])}`
+      );
+      ci += 6;
+    } else if (c === PATH_Q) {
+      out.push(`Q${num(xs[ci])} ${num(xs[ci + 1])} ${num(xs[ci + 2])} ${num(xs[ci + 3])}`);
+      ci += 4;
+    } else if (c === PATH_Z) {
+      out.push("Z");
+    }
+  }
+  return out.join("");
+}
+
+// src/track/pathData.ts
+var SAMPLES = 64;
+var num2 = (v) => {
+  const r = Math.round(v * 1e4) / 1e4;
+  return String(r === 0 ? 0 : r);
+};
+var pt = (p) => `${num2(p.x)} ${num2(p.y)}`;
+var isArc = (s) => s.kind === "arc" && "arc" in s;
+var isPath = (s) => s.kind === "path" && "path" in s;
+var isEllipse = (s) => s.kind === "ellipse" && "ellipse" in s;
+function arcsD(a, b, m, rx, ry, turn, sweep) {
+  const r = `${num2(rx)} ${num2(ry)}`;
+  if (turn >= 2 * Math.PI - 1e-9) return `M ${pt(a)} A ${r} 0 0 ${sweep} ${pt(m())} A ${r} 0 0 ${sweep} ${pt(b)}`;
+  return `M ${pt(a)} A ${r} 0 ${turn > Math.PI + 1e-9 ? 1 : 0} ${sweep} ${pt(b)}`;
+}
+function trackShapeD(shape, from = 0, to = 1) {
+  if (isPath(shape) && from === 0 && to === 1) return pathToD(shape.path);
+  const a = shape.at(from).point;
+  const b = shape.at(to).point;
+  if (shape.kind === "line") return `M ${pt(a)} L ${pt(b)}`;
+  const m = () => shape.at((from + to) / 2).point;
+  if (isArc(shape)) {
+    const { radius, direction } = shape.arc;
+    const turn = shape.length * Math.abs(to - from) / radius;
+    return arcsD(a, b, m, radius, radius, turn, direction === "ccw" === to < from ? 1 : 0);
+  }
+  if (isEllipse(shape)) {
+    const { radiusX, radiusY, direction, center } = shape.ellipse;
+    const param = (p) => Math.atan2((p.x - center.x) / radiusX, (center.y - p.y) / radiusY);
+    const sign2 = direction === "ccw" ? -1 : 1;
+    const whole = (shape.ellipse.start - shape.ellipse.end) % 360 === 0 && Math.abs(to - from) >= 1 - 1e-12;
+    const raw = (sign2 * Math.sign(to - from) * (param(b) - param(a)) + 4 * Math.PI) % (2 * Math.PI);
+    return arcsD(a, b, m, radiusX, radiusY, whole ? 2 * Math.PI : raw, direction === "ccw" === to < from ? 1 : 0);
+  }
+  let d = `M ${pt(a)}`;
+  for (let i = 1; i <= SAMPLES; i++)
+    d += ` L ${pt(shape.at(from + (to - from) * i / SAMPLES).point)}`;
+  return d;
+}
+
+// src/track/place.ts
+var clipOf = (lo, hi, start, end, hair = 0) => lo >= start - hair && hi <= end + hair ? "none" : hi <= start + hair || lo >= end - hair ? "past" : "part";
+function runPlaces(lengths, gap, room, align, offset2, at2) {
+  const total = runLength(lengths, gap);
+  const fits = at2 === void 0 && total <= room;
+  const lead = align === "start" ? 0 : align === "end" ? total : total / 2;
+  let lo = at2 !== void 0 ? at2 - offset2 - lead : !fits ? -offset2 : align === "start" ? 0 : align === "end" ? room - total : (room - total) / 2;
+  return lengths.map((length2) => {
+    const start = lo;
+    const hi = start + length2;
+    lo = hi + gap;
+    return { center: start + length2 / 2, clipped: fits ? "none" : clipOf(start, hi, 0, room) };
+  });
+}
+function runLength(lengths, gap) {
+  return lengths.reduce((sum, length2, i) => sum + length2 + (i > 0 ? gap : 0), 0);
+}
+function runStationAt(run2, distance, shift = 0) {
+  const { length: length2 } = run2;
+  const place = run2.at(length2 === 0 ? 0 : distance / length2);
+  const past = distance < 0 ? distance : distance > length2 ? distance - length2 : 0;
+  const { point, tangent, normal: normal2 } = place;
+  return {
+    ...place,
+    point: { x: point.x + past * tangent.x + shift * normal2.x, y: point.y + past * tangent.y + shift * normal2.y }
+  };
+}
+function placeAlongRun(run2, lengths, options = {}) {
+  const { gap = 0, align = "center", offset: offset2 = 0, at: at2, shift = 0, wrap = false, past = "extend", order = "reading" } = options;
+  const { length: length2 } = run2;
+  const mirror = order === "track" && run2.reversed;
+  const spots = runPlaces(lengths, gap, length2, align, offset2, at2);
+  const lap = wrap && run2.closed && spots.length > 0 ? wrapWindow(spots[0], lengths[0], length2) : null;
+  return spots.map((spot, i) => {
+    const half = lengths[i] / 2;
+    const clipped = lap ? clipOf(spot.center - half, spot.center + half, lap.start, lap.end, lap.hair) : spot.clipped;
+    let distance = spot.center;
+    if (past === "hold" && clipped === "past") distance = clamp(distance, lap?.start ?? 0, lap?.end ?? length2);
+    if (lap && length2 > 0) distance = (distance % length2 + length2) % length2;
+    return { ...runStationAt(run2, mirror ? length2 - distance : distance, shift), center: spot.center, clipped };
+  });
+}
+function wrapWindow(first, firstLength, length2) {
+  const start = first.center - firstLength / 2;
+  return { start, end: start + length2, hair: 1e-9 * Math.max(1, length2) };
+}
+
 // src/portCurve2.ts
 function portControls2(ax, ay, bx, by, outNormal, inNormal, reach = PORT_REACH) {
   const [c1, c2] = portControls([ax, ay], [bx, by], outNormal, inNormal, reach);
@@ -270,7 +780,7 @@ function pointInPath(path, x, y, opts = {}) {
     return x >= path.x && x <= path.x + path.width && y >= path.y && y <= path.y + path.height;
   }
   let crossings = 0;
-  let winding = 0;
+  let winding2 = 0;
   for (const sub3 of closedSubpaths(path, opts)) {
     const n = sub3.length;
     for (let i = 0; i < n; i += 2) {
@@ -280,10 +790,10 @@ function pointInPath(path, x, y, opts = {}) {
       const ax = sub3[i], bx = sub3[j];
       if (x >= ax + (y - ay) / (by - ay) * (bx - ax)) continue;
       crossings++;
-      winding += ay <= y ? 1 : -1;
+      winding2 += ay <= y ? 1 : -1;
     }
   }
-  return path.fillRule === "evenodd" ? (crossings & 1) === 1 : winding !== 0;
+  return path.fillRule === "evenodd" ? (crossings & 1) === 1 : winding2 !== 0;
 }
 function strokeHitTest(path, x, y, threshold, opts = {}) {
   const slop = opts.slop;
@@ -620,7 +1130,7 @@ function splitSubpaths(path) {
   let coordStart = 0;
   let anchorStart = 0;
   let anchors = 0;
-  const emit = (end, coordEnd) => {
+  const emit2 = (end, coordEnd) => {
     const sub3 = { ...bare, commands: commands.slice(cmdStart, end), coords: coords.slice(coordStart, coordEnd) };
     const count = anchors - anchorStart;
     out.push(path.corners ? carryCorners(path, sub3, anchorRange(anchorStart, count)) : sub3);
@@ -628,13 +1138,13 @@ function splitSubpaths(path) {
   };
   forEachSegment(commands, coords, (cmd, ci, _px, _py, i) => {
     if (cmd === PATH_M && i > cmdStart) {
-      emit(i, ci);
+      emit2(i, ci);
       cmdStart = i;
       coordStart = ci;
     }
     if (cmd !== PATH_Z) anchors++;
   });
-  emit(commands.length, coords.length);
+  emit2(commands.length, coords.length);
   return out;
 }
 
@@ -812,8 +1322,8 @@ function reversePath(path) {
     anchor++;
   });
   flush(false);
-  const reversed2 = { ...path, commands: new Uint8Array(cmds), coords: new Float32Array(out) };
-  return path.corners ? carryCorners(path, reversed2, sources) : reversed2;
+  const reversed3 = { ...path, commands: new Uint8Array(cmds), coords: new Float32Array(out) };
+  return path.corners ? carryCorners(path, reversed3, sources) : reversed3;
 }
 
 // src/paths/pathFromD.ts
@@ -1074,9 +1584,9 @@ function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep,
     rys = ryFixed * ryFixed;
   }
   const sign2 = largeArc === sweep ? -1 : 1;
-  const num = rxs * rys - rxs * y1ps - rys * x1ps;
+  const num3 = rxs * rys - rxs * y1ps - rys * x1ps;
   const den = rxs * y1ps + rys * x1ps;
-  const factor = sign2 * Math.sqrt(Math.max(0, num / den));
+  const factor = sign2 * Math.sqrt(Math.max(0, num3 / den));
   const cxp = factor * (rxFixed * y1p) / ryFixed;
   const cyp = factor * -(ryFixed * x1p) / rxFixed;
   const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
@@ -1124,92 +1634,6 @@ function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep,
   }
 }
 
-// src/paths/pathMeasure.ts
-function measurePath(path, opts = {}) {
-  const polylines = extractPolylines(
-    path,
-    opts.flattenTolerance === void 0 ? {} : { flattenTolerance: opts.flattenTolerance }
-  );
-  const segments = [];
-  let total = 0;
-  let first;
-  let contours = 0;
-  let lastClosed = false;
-  for (const pl of polylines) {
-    const count = pl.points.length / 2;
-    if (count === 0) continue;
-    contours++;
-    lastClosed = pl.closed;
-    first ??= { x: pl.points[0], y: pl.points[1] };
-    const startIndex = segments.length;
-    const last = pl.closed ? count : count - 1;
-    for (let i = 0; i < last; 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;
-      const tx = (bx - ax) / len;
-      const ty = (by - ay) / len;
-      segments.push({ ax, ay, bx, by, start: total, len, tx, ty, t0x: tx, t0y: ty, t1x: tx, t1y: ty });
-      total += len;
-    }
-    smoothVertexHeadings(segments, startIndex, pl.closed);
-  }
-  if (first === void 0) return null;
-  const origin = first;
-  const closed = contours === 1 && lastClosed;
-  if (segments.length === 0) {
-    return { length: 0, closed, at: () => ({ point: { ...origin }, tangent: { x: 1, y: 0 } }) };
-  }
-  return {
-    length: total,
-    closed,
-    at(s, smooth = false) {
-      const target = Math.min(Math.max(s, 0), total);
-      const seg = segments[segmentAt(segments, target)];
-      const u = Math.min(Math.max((target - seg.start) / seg.len, 0), 1);
-      const point = { x: seg.ax + (seg.bx - seg.ax) * u, y: seg.ay + (seg.by - seg.ay) * u };
-      if (!smooth) return { point, tangent: { x: seg.tx, y: seg.ty } };
-      const x = seg.t0x + (seg.t1x - seg.t0x) * u;
-      const y = seg.t0y + (seg.t1y - seg.t0y) * u;
-      const l = Math.hypot(x, y);
-      return { point, tangent: l === 0 ? { x: seg.tx, y: seg.ty } : { x: x / l, y: y / l } };
-    }
-  };
-}
-function smoothVertexHeadings(segments, from, closed) {
-  const n = segments.length - from;
-  if (n < 2) return;
-  const pairs = closed ? n : n - 1;
-  for (let k = 0; k < pairs; k++) {
-    const a = segments[from + k];
-    const b = segments[from + (k + 1) % n];
-    let x = a.tx + b.tx;
-    let y = a.ty + b.ty;
-    const l = Math.hypot(x, y);
-    if (l < 1e-9) continue;
-    x /= l;
-    y /= l;
-    a.t1x = x;
-    a.t1y = y;
-    b.t0x = x;
-    b.t0y = y;
-  }
-}
-function segmentAt(segments, s) {
-  let lo = 0;
-  let hi = segments.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (segments[mid].start <= s) lo = mid;
-    else hi = mid - 1;
-  }
-  return lo;
-}
-
 // src/paths/pathAt.ts
 function pointAlongPath(path, t, opts = {}) {
   const measure2 = measurePath(path, opts);
@@ -1381,13 +1805,13 @@ function matchContours(a, b, opts) {
   const offset2 = Math.round(opts.startOffset ?? 0);
   const directions = opts.reverse !== void 0 ? [opts.reverse] : auto ? [false, true] : [false];
   let best = null;
-  for (const reversed2 of directions) {
-    const run3 = reversed2 ? reverseContour(y) : y;
+  for (const reversed3 of directions) {
+    const run3 = reversed3 ? reverseContour(y) : y;
     const turns = closed && auto ? run3.segs.length : 1;
     for (let k = 0; k < turns; k++) {
       const [ma, mb] = equalize(x, rotate2(run3, k));
       const score = auto ? correspondence(ma, mb) : 0;
-      if (best === null || score < best.score - 1e-9) best = { score, a: ma, b: mb, reversed: reversed2, turn: k };
+      if (best === null || score < best.score - 1e-9) best = { score, a: ma, b: mb, reversed: reversed3, turn: k };
     }
   }
   const chosen = best;
@@ -1771,17 +2195,17 @@ var GL_W2 = [
   0.2223810344533745,
   0.1012285362903763
 ];
-var speed = (s, t) => {
+var speed2 = (s, t) => {
   const d = derivSeg(s, t);
   return Math.hypot(d.x, d.y);
 };
 function segmentLength(s, a = 0, b = 1) {
-  if (s.length === 2) return speed(s, 0) * (b - a);
+  if (s.length === 2) return speed2(s, 0) * (b - a);
   const panels = 8, h = (b - a) / panels;
   let sum = 0;
   for (let k = 0; k < panels; k++) {
     const mid = a + (k + 0.5) * h;
-    for (let i = 0; i < GL_X.length; i++) sum += GL_W2[i] * speed(s, mid + GL_X[i] * h / 2);
+    for (let i = 0; i < GL_X.length; i++) sum += GL_W2[i] * speed2(s, mid + GL_X[i] * h / 2);
   }
   return sum * h / 2;
 }
@@ -1796,7 +2220,7 @@ function segmentTAtLength(s, length2) {
     if (Math.abs(err) < 1e-10 * Math.max(1, total)) break;
     if (err > 0) hi = t;
     else lo = t;
-    const v = speed(s, t);
+    const v = speed2(s, t);
     let next = v > 0 ? t - err / v : NaN;
     if (!(next > lo && next < hi)) next = (lo + hi) / 2;
     t = next;
@@ -2803,7 +3227,7 @@ function breaksOf(sub3, closed, cosCorner) {
   const n = sub3.length;
   const breaks = /* @__PURE__ */ new Set();
   for (let i = 0; i < n; i++) {
-    if (isCorner(sub3, i, closed, cosCorner)) breaks.add(i);
+    if (isCorner2(sub3, i, closed, cosCorner)) breaks.add(i);
     if (isLongStraight(sub3, i, closed)) {
       breaks.add(i);
       breaks.add((i + 1) % n);
@@ -2823,7 +3247,7 @@ function fitStops(sub3, stops, tol, out, closing) {
     if (!last) keepCorner(out[out.length - 1], sub3[stops[k + 1] % n]);
   }
 }
-function isCorner(sub3, i, closed, cosCorner) {
+function isCorner2(sub3, i, closed, cosCorner) {
   const n = sub3.length;
   const a = sub3[i];
   const prev = sub3[(i - 1 + n) % n];
@@ -2880,7 +3304,7 @@ function unit(p) {
 
 // src/paths/growRegion.ts
 var MAX_DEPTH2 = 6;
-var SAMPLES = [0.2, 0.35, 0.5, 0.65, 0.8];
+var SAMPLES2 = [0.2, 0.35, 0.5, 0.65, 0.8];
 function growRegion(path, distance, opts = {}) {
   const b = new PathBuilder();
   if (!(distance > 0)) return b.build();
@@ -3053,7 +3477,7 @@ function offsetSeg(seg, ctx, depth) {
 }
 function offsetError(c, q, ctx) {
   let worst2 = 0;
-  for (const t of SAMPLES) {
+  for (const t of SAMPLES2) {
     const [dx2, dy2] = derivative(c, t);
     const len = Math.hypot(dx2, dy2);
     if (len < 1e-12) continue;
@@ -3110,6 +3534,243 @@ function emitContour(b, grown) {
   b.close();
 }
 
+// src/paths/segmentCrossings.ts
+var STEPS = 16;
+var END2 = 1e-7;
+function segmentCrossings(segs) {
+  const flat = segs.map((s) => flatten2(s));
+  const boxes = flat.map(boxOf2);
+  const out = [];
+  for (let a = 0; a < segs.length; a++) {
+    for (let b = a + 1; b < segs.length; b++) {
+      if (!overlaps(boxes[a], boxes[b])) continue;
+      const pa = flat[a], pb = flat[b];
+      for (let i = 0; i + 1 < pa.length; i++) {
+        for (let j = 0; j + 1 < pb.length; j++) {
+          const hit = linesCross(pa[i], pa[i + 1], pb[j], pb[j + 1]);
+          if (hit === null) continue;
+          const guess = [(i + hit[0]) / (pa.length - 1), (j + hit[1]) / (pb.length - 1)];
+          const [s, t] = segs[a].line && segs[b].line ? guess : refine2(segs[a].c, segs[b].c, guess);
+          if (atEnd(s) && atEnd(t)) continue;
+          if (out.some((x) => x.a === a && x.b === b && Math.abs(x.s - s) < 1e-6 && Math.abs(x.t - t) < 1e-6)) continue;
+          out.push({ a, b, s, t });
+        }
+      }
+    }
+  }
+  return out;
+}
+var atEnd = (t) => t < END2 || t > 1 - END2;
+function flatten2(seg) {
+  if (seg.line) return [[seg.c[0], seg.c[1]], [seg.c[6], seg.c[7]]];
+  const out = [];
+  for (let i = 0; i <= STEPS; i++) out.push(cubicEvalAt(...seg.c, i / STEPS));
+  return out;
+}
+function boxOf2(pts) {
+  const b = [Infinity, Infinity, -Infinity, -Infinity];
+  for (const [x, y] of pts) {
+    b[0] = Math.min(b[0], x);
+    b[1] = Math.min(b[1], y);
+    b[2] = Math.max(b[2], x);
+    b[3] = Math.max(b[3], y);
+  }
+  return b;
+}
+var overlaps = (p, q) => p[0] <= q[2] && q[0] <= p[2] && p[1] <= q[3] && q[1] <= p[3];
+function linesCross(a, b, c, d) {
+  const rx = b[0] - a[0], ry = b[1] - a[1], sx = d[0] - c[0], sy = d[1] - c[1];
+  const den = rx * sy - ry * sx;
+  if (Math.abs(den) < 1e-18) return null;
+  const u = ((c[0] - a[0]) * sy - (c[1] - a[1]) * sx) / den;
+  const w = ((c[0] - a[0]) * ry - (c[1] - a[1]) * rx) / den;
+  return u >= 0 && u <= 1 && w >= 0 && w <= 1 ? [u, w] : null;
+}
+function refine2(a, b, guess) {
+  const gap = (s2, t2) => {
+    const p = cubicEvalAt(...a, s2), q = cubicEvalAt(...b, t2);
+    return [p[0] - q[0], p[1] - q[1]];
+  };
+  let [s, t] = guess;
+  let f = gap(s, t);
+  const start = Math.hypot(...f);
+  for (let k = 0; k < 8 && Math.hypot(...f) > 1e-13; k++) {
+    const da = derivative2(a, s), db = derivative2(b, t);
+    const det = -da[0] * db[1] + db[0] * da[1];
+    if (Math.abs(det) < 1e-18) break;
+    s = Math.min(1, Math.max(0, s - (-db[1] * f[0] + db[0] * f[1]) / det));
+    t = Math.min(1, Math.max(0, t - (-da[1] * f[0] + da[0] * f[1]) / det));
+    f = gap(s, t);
+  }
+  return Math.hypot(...f) <= start ? [s, t] : guess;
+}
+function derivative2(c, t) {
+  const u = 1 - t;
+  const a = 3 * u * u, b = 6 * u * t, e = 3 * t * t;
+  return [
+    a * (c[2] - c[0]) + b * (c[4] - c[2]) + e * (c[6] - c[4]),
+    a * (c[3] - c[1]) + b * (c[5] - c[3]) + e * (c[7] - c[5])
+  ];
+}
+
+// src/paths/mergeRegion.ts
+function mergeRegion(path, opts = {}) {
+  const tol = opts.tolerance ?? 0.01;
+  const contours = pathToCubicContours(path).filter((c) => c.segs.length > 0);
+  const segs = contours.flatMap((c) => closeContour(c.segs, tol * 1e-3));
+  const fillLeft = pathSignedArea(path) < 0;
+  const cuts = segs.map(() => []);
+  for (const x of segmentCrossings(segs)) {
+    const p = crossingPoint(segs[x.a], x.s, segs[x.b], x.t);
+    cuts[x.a].push({ t: x.s, p });
+    cuts[x.b].push({ t: x.t, p });
+  }
+  const rings = flattenAll(segs, tol / 4);
+  const pieces = [];
+  let changed = false;
+  segs.forEach((seg, i) => {
+    const parts = cutSegment(seg, cuts[i]);
+    if (parts.length > 1) changed = true;
+    for (const part of parts) {
+      const side = filledSide(part, rings, tol);
+      if (side === null) changed = true;
+      else if (side === fillLeft) pieces.push(part);
+      else {
+        changed = true;
+        pieces.push(reversed2(part));
+      }
+    }
+  });
+  const b = new PathBuilder();
+  if (!changed) {
+    for (const c of contours) emit(b, closeContour(c.segs, tol * 1e-3));
+    return b.build();
+  }
+  for (const ring of chain(pieces)) emit(b, ring);
+  return b.build();
+}
+function closeContour(given, snap2) {
+  const short = (s) => s.line && Math.hypot(s.c[6] - s.c[0], s.c[7] - s.c[1]) <= snap2;
+  const segs = given.filter((s) => !short(s));
+  if (segs.length === 0) return [];
+  for (let i = 0; i < segs.length; i++) {
+    const prev = segs[(i + segs.length - 1) % segs.length].c, s = segs[i];
+    if (prev[6] !== s.c[0] || prev[7] !== s.c[1]) {
+      if (Math.hypot(prev[6] - s.c[0], prev[7] - s.c[1]) <= snap2) segs[i] = moveEnds(s, [prev[6], prev[7]], [s.c[6], s.c[7]]);
+      else if (i === 0) segs.push(lineSegment(prev[6], prev[7], s.c[0], s.c[1]));
+    }
+  }
+  return segs;
+}
+function crossingPoint(a, s, b, t) {
+  const end = (seg, u) => u <= 1e-7 ? [seg.c[0], seg.c[1]] : u >= 1 - 1e-7 ? [seg.c[6], seg.c[7]] : null;
+  const fixed = end(a, s) ?? end(b, t);
+  if (fixed) return fixed;
+  const p = cubicEvalAt(...a.c, s), q = cubicEvalAt(...b.c, t);
+  return [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2];
+}
+function cutSegment(seg, cuts) {
+  const inner = cuts.filter((c) => c.t > 1e-7 && c.t < 1 - 1e-7).sort((x, y) => x.t - y.t);
+  const out = [];
+  let rest = seg, from = 0;
+  let start = [seg.c[0], seg.c[1]];
+  for (const cut of inner) {
+    if (cut.t - from < 1e-9) continue;
+    const [l, r] = splitSegment(rest, (cut.t - from) / (1 - from));
+    out.push(moveEnds(l, start, cut.p));
+    rest = r;
+    from = cut.t;
+    start = cut.p;
+  }
+  out.push(moveEnds(rest, start, [seg.c[6], seg.c[7]]));
+  return out;
+}
+function moveEnds(s, a, b) {
+  const c = s.c;
+  return {
+    c: [a[0], a[1], c[2] + a[0] - c[0], c[3] + a[1] - c[1], c[4] + b[0] - c[6], c[5] + b[1] - c[7], b[0], b[1]],
+    line: s.line
+  };
+}
+function reversed2(s) {
+  const c = s.c;
+  return { c: [c[6], c[7], c[4], c[5], c[2], c[3], c[0], c[1]], line: s.line };
+}
+function flattenAll(segs, tol) {
+  const rings = [];
+  let ring = [];
+  for (const { c, line } of segs) {
+    if (ring.length === 0) ring.push(c[0], c[1]);
+    else if (ring[ring.length - 2] !== c[0] || ring[ring.length - 1] !== c[1]) {
+      rings.push(ring);
+      ring = [c[0], c[1]];
+    }
+    if (line) ring.push(c[6], c[7]);
+    else flattenCubic(...c, tol, ring);
+  }
+  if (ring.length > 0) rings.push(ring);
+  return rings;
+}
+function winding(rings, x, y) {
+  let w = 0;
+  for (const r of rings) {
+    for (let i = 0; i + 3 < r.length; i += 2) {
+      const ay = r[i + 1], by = r[i + 3];
+      if (ay > y === by > y) continue;
+      const ax = r[i], bx = r[i + 2];
+      if (x >= ax + (y - ay) / (by - ay) * (bx - ax)) continue;
+      w += ay <= y ? 1 : -1;
+    }
+  }
+  return w;
+}
+function filledSide(seg, rings, tol) {
+  const c = seg.c;
+  const [x, y] = cubicEvalAt(...c, 0.5);
+  const dx2 = c[6] + c[4] - c[2] - c[0], dy2 = c[7] + c[5] - c[3] - c[1];
+  const len = Math.hypot(dx2, dy2);
+  if (len < 1e-12) return null;
+  const nx = dy2 / len * tol, ny = -dx2 / len * tol;
+  const left = winding(rings, x + nx, y + ny) !== 0, right = winding(rings, x - nx, y - ny) !== 0;
+  return left === right ? null : left;
+}
+function chain(pieces) {
+  const key = (x, y) => `${x},${y}`;
+  const from = /* @__PURE__ */ new Map();
+  pieces.forEach((p, i) => {
+    const k = key(p.c[0], p.c[1]);
+    const list = from.get(k);
+    if (list) list.push(i);
+    else from.set(k, [i]);
+  });
+  const used = new Uint8Array(pieces.length);
+  const rings = [];
+  for (let i = 0; i < pieces.length; i++) {
+    if (used[i]) continue;
+    const ring = [];
+    let at2 = i;
+    while (at2 !== void 0 && !used[at2]) {
+      used[at2] = 1;
+      const p = pieces[at2];
+      ring.push(p);
+      at2 = from.get(key(p.c[6], p.c[7]))?.find((j) => !used[j]);
+    }
+    rings.push(ring);
+  }
+  return rings;
+}
+function emit(b, ring) {
+  if (ring.length === 0) return;
+  const [x0, y0] = ring[0].c;
+  b.moveTo(x0, y0);
+  for (const [i, { c, line }] of ring.entries()) {
+    if (line && i === ring.length - 1 && c[6] === x0 && c[7] === y0) break;
+    if (line) b.lineTo(c[6], c[7]);
+    else b.curveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+  }
+  b.close();
+}
+
 // src/paths/simplifyAnchors.ts
 function simplifyAnchorsAt(set, flatIndexes, tolerance, opts = {}) {
   const bySub = /* @__PURE__ */ new Map();
@@ -3164,7 +3825,7 @@ var unit3 = (x, y) => {
   const len = Math.hypot(x, y);
   return len === 0 ? { x: 0, y: 0 } : { x: x / len, y: y / len };
 };
-function derivative2(seg, t) {
+function derivative3(seg, t) {
   const u = 1 - t;
   const { a, c1, c2, b } = seg;
   return {
@@ -3174,8 +3835,8 @@ function derivative2(seg, t) {
 }
 function headingOn(seg, t) {
   if (seg.straight) return unit3(seg.b.x - seg.a.x, seg.b.y - seg.a.y);
-  let d = derivative2(seg, t);
-  if (Math.hypot(d.x, d.y) < 1e-9) d = derivative2(seg, t < 0.5 ? t + 1e-3 : t - 1e-3);
+  let d = derivative3(seg, t);
+  if (Math.hypot(d.x, d.y) < 1e-9) d = derivative3(seg, t < 0.5 ? t + 1e-3 : t - 1e-3);
   const h = unit3(d.x, d.y);
   return h.x === 0 && h.y === 0 ? unit3(seg.b.x - seg.a.x, seg.b.y - seg.a.y) : h;
 }
@@ -4338,7 +4999,7 @@ function smudgePath(path, opts) {
   if (!(radius > 0) || strength === 0 || delta.x === 0 && delta.y === 0) return path;
   const detail = opts.detail ?? radius / 3;
   return editAnchorSet(path, (set) => {
-    refine2(set, center, radius, detail);
+    refine3(set, center, radius, detail);
     let touched = false;
     let flat = 0;
     for (const sub3 of set.anchors) {
@@ -4358,7 +5019,7 @@ function weight(p, c, radius) {
   const u2 = ((p.x - c.x) ** 2 + (p.y - c.y) ** 2) / (radius * radius);
   return u2 >= 1 ? 0 : (1 - u2) ** 2;
 }
-function refine2(set, c, radius, detail) {
+function refine3(set, c, radius, detail) {
   if (!Number.isFinite(detail) || detail <= 0) return;
   let added = 0;
   for (let sub3 = 0; sub3 < set.anchors.length; sub3++) {
@@ -5579,7 +6240,8 @@ function constrainPathsEdit(items, links = []) {
   const sliding = new Set(kept.flatMap((c) => c.kind === "onPath" ? [c.anchor] : []));
   const still = (i) => {
     const { item } = itemOf(i, nowStart);
-    return items.length > 1 && items[item].before === items[item].after && !sliding.has(i);
+    const it = items[item];
+    return items.length > 1 && it.before === it.after && !it.yields && !sliding.has(i);
   };
   const held = nowAll.flatMap((p, i) => {
     const r = reference[i];
@@ -6001,6 +6663,6 @@ function typedArrayReplacer(_key, value) {
   return tagTypedArray(value) ?? value;
 }
 
-export { ANCHOR_FIELDS, CONSTRAINT_TOLERANCE, EASINGS, PATH_SNAP_KINDS, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, addExtremaAnchors, anchorAt, anchorCount, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsInRect, anchorsUnderBrush, anchorsWhere, applyToPoint, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, blendPaths, boxToBox, circlePath, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, createPathSnapIndex, cubicBezierEasing, cubicContoursToPath, decomposePath, deleteAnchorsAt, directionMarks, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSet, editAnchorSetTracked, equalizeSegmentHandles, everyNthAnchor, extendToMeet, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, intersectSegments, invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, lengthToward, lengthenOpenEnd, lengthenPathEnd, linear, locateAnchor, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, moveHandleSymmetric, moveHandleTo, multiply, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, openSubpathAt, pathAnchorPoints, pathAwayFromAnchors, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonIntersectsPath, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, pxExtent, readAnchorFields, rectMarkerPath, remapAnchorValues, remapConstraints, remapPointValues, repeatAlongPath, resamplePath, resolveEasing, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, scale, scaleDelta, scalePathToBounds, scaleSegmentHandles, screenAngleOf, segmentAt2 as segmentAt, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, setSubpathStart, shrinkAnchorSelection, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, stationsAlongPath, strokeHitTest, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField };
+export { ANCHOR_FIELDS, CONSTRAINT_TOLERANCE, EASINGS, PATH_SNAP_KINDS, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, addExtremaAnchors, anchorAt, anchorCount, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsInRect, anchorsUnderBrush, anchorsWhere, applyToPoint, arcShape, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, blendPaths, boxToBox, circlePath, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, createPathSnapIndex, cubicBezierEasing, cubicContoursToPath, decomposePath, deleteAnchorsAt, directionMarks, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSet, editAnchorSetTracked, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, intersectSegments, invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, lengthToward, lengthenOpenEnd, lengthenPathEnd, lineShape, linear, locateAnchor, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, moveHandleTo, multiply, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, openSubpathAt, pathAnchorPoints, pathAwayFromAnchors, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathShape, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeAlongRun, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonIntersectsPath, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, pxExtent, readAnchorFields, rectMarkerPath, remapAnchorValues, remapConstraints, remapPointValues, repeatAlongPath, resamplePath, resolveEasing, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, runLength, runPlaces, runStationAt, scale, scaleDelta, scalePathToBounds, scaleSegmentHandles, screenAngleOf, segmentAt2 as segmentAt, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, setSubpathStart, shrinkAnchorSelection, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, stationsAlongPath, strokeHitTest, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, trackRun, trackShapeD, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map