@weasel-js/geom 1.11.1 → 1.13.0-rc.0

package/dist/index.js

@@ -1,21 +1,21 @@
-import { carryCorners, evalSeg, parseSubpaths, keepCorners, anchorRange, subSeg, writePath, derivSeg } from './chunk-4Y67BZL5.js';
-export { CORNER_RESTORE_TOLERANCE, cornerTraces, keepCorners, restoreCorners } from './chunk-4Y67BZL5.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-7F66PQCJ.js';
-import { boundsOfPath, fitPointRun, keepCorner } from './chunk-6FGQML7D.js';
-export { boundsOfPath } from './chunk-6FGQML7D.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, flattenCubic, pointSegmentDist2, flattenQuadratic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross } from './chunk-EAKE3N7W.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-EAKE3N7W.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,640 @@ 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, options) {
+      const t = options?.open ? f : 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, options) => {
+    const t = options?.open ? f : 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 offsetPast = (f) => {
+    if (raw === 0) return offsetAt((f % 1 + 1) % 1);
+    let u = f * sweep;
+    for (let i = 0; i < 8; i++) {
+      const v = speed(e, u);
+      if (!(v > 0)) break;
+      u -= (lengthTo(u) - f * length2) / v;
+    }
+    return u;
+  };
+  const at2 = (f, options) => {
+    const u = options?.open && (f < 0 || f > 1) ? offsetPast(f) : 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, options2) {
+      const open = options2?.open === true && (f < 0 || f > 1);
+      const g = open && closed ? (f % 1 + 1) % 1 : clamp(f, 0, 1);
+      const { point, tangent } = measure2.at(g * length2, true);
+      const past = open && !closed ? (f - g) * length2 : 0;
+      return { point: { x: point.x + past * tangent.x, y: point.y + past * tangent.y }, 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
+var pointsDown = (normal2) => normal2.y > 1e-9;
+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" ? pointsDown(mid.normal) : 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, options2) => {
+    const s = options2?.open ? shape.at(toF(g), options2) : shape.at(toF(clamp(g, 0, 1)));
+    const dir = reading(s.normal);
+    const angle = Math.atan2(dir.y, dir.x) * 180 / Math.PI;
+    const normal2 = { x: sgn * s.normal.x, y: sgn * s.normal.y };
+    return {
+      point: s.point,
+      tangent: dir,
+      normal: normal2,
+      angle: angle === 0 ? 0 : angle === -180 ? 180 : angle,
+      turned: pointsDown(normal2)
+    };
+  };
+  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/shift.ts
+var SAMPLES2 = 256;
+var dot2 = (a, b) => a.x * b.x + a.y * b.y;
+function bendSide(shape) {
+  let turn = 0;
+  let prev = shape.at(0);
+  for (let i = 1; i <= SAMPLES2; i++) {
+    const next = shape.at(i / SAMPLES2);
+    turn += dot2({ x: next.tangent.x - prev.tangent.x, y: next.tangent.y - prev.tangent.y }, prev.normal);
+    prev = next;
+  }
+  return Math.abs(turn) < 1e-9 ? 0 : turn > 0 ? 1 : -1;
+}
+function shiftTrack(shape, shift) {
+  if (shift === 0) return shape;
+  const moved2 = (s) => ({ ...s, point: { x: s.point.x + shift * s.normal.x, y: s.point.y + shift * s.normal.y } });
+  const table = new Float64Array(SAMPLES2 + 1);
+  let prev = moved2(shape.at(0));
+  for (let i = 1; i <= SAMPLES2; i++) {
+    const next = moved2(shape.at(i / SAMPLES2));
+    const step = { x: next.point.x - prev.point.x, y: next.point.y - prev.point.y };
+    const tangent = { x: prev.tangent.x + next.tangent.x, y: prev.tangent.y + next.tangent.y };
+    if (shape.length > 0 && dot2(step, tangent) <= 0) return null;
+    table[i] = table[i - 1] + Math.hypot(step.x, step.y);
+    prev = next;
+  }
+  const length2 = table[SAMPLES2];
+  const per = shape.length / SAMPLES2;
+  const startRatio = table[1] > 0 ? per / table[1] : 1;
+  const endRatio = table[SAMPLES2] - table[SAMPLES2 - 1] > 0 ? per / (table[SAMPLES2] - table[SAMPLES2 - 1]) : 1;
+  const toBase = (f) => {
+    const d = f * length2;
+    if (length2 <= 0 || shape.length <= 0) return f;
+    if (d < 0) return d * startRatio / shape.length;
+    if (d > length2) return 1 + (d - length2) * endRatio / shape.length;
+    let lo = 0;
+    let hi = SAMPLES2;
+    while (hi - lo > 1) {
+      const mid = lo + hi >> 1;
+      if (table[mid] <= d) lo = mid;
+      else hi = mid;
+    }
+    const span = table[hi] - table[lo];
+    return (lo + (span > 0 ? (d - table[lo]) / span : 0)) / SAMPLES2;
+  };
+  const fromBase = (g) => {
+    if (length2 <= 0 || shape.length <= 0) return g;
+    if (g < 0) return g * shape.length / startRatio / length2;
+    if (g > 1) return (length2 + (g - 1) * shape.length / endRatio) / length2;
+    const x = g * SAMPLES2;
+    const i = Math.min(SAMPLES2 - 1, Math.floor(x));
+    return (table[i] + (x - i) * (table[i + 1] - table[i])) / length2;
+  };
+  const at2 = (f, options) => moved2(shape.at(toBase(options?.open ? f : clamp(f, 0, 1)), options));
+  return {
+    kind: shape.kind,
+    length: length2,
+    closed: shape.closed,
+    at: at2,
+    nearest(p, options) {
+      const base = shape.nearest(p, options?.open ? { open: true, about: toBase(options.about ?? 0.5) } : void 0);
+      const f = fromBase(base.f);
+      const q = at2(f, options).point;
+      return { f, dist: Math.hypot(p.x - q.x, p.y - q.y) };
+    }
+  };
+}
+
+// src/track/slice.ts
+var RAD3 = Math.PI / 180;
+var seen = (c, p) => Math.atan2(p.x - c.x, c.y - p.y) / RAD3;
+function trackSlice(shape, from, to) {
+  const lo = clamp(Math.min(from, to), 0, 1);
+  const hi = clamp(Math.max(from, to), 0, 1);
+  if (lo === 0 && hi === 1) return shape;
+  const a = shape.at(lo).point;
+  const b = shape.at(hi).point;
+  if (shape.kind === "line") return lineShape(a, b);
+  if (shape.kind === "arc" && "arc" in shape) {
+    const { center, radius, direction } = shape.arc;
+    if (hi === lo) return arcShape({ center, radius: 0, start: 0, end: 0 });
+    return arcShape({ center, radius, start: seen(center, a), end: seen(center, b), direction });
+  }
+  if (shape.kind === "ellipse" && "ellipse" in shape) {
+    const { center, radiusX, radiusY, direction } = shape.ellipse;
+    if (hi === lo) return ellipseShape({ center, radiusX: 0, radiusY: 0, start: 0, end: 0 });
+    return ellipseShape({ center, radiusX, radiusY, start: seen(center, a), end: seen(center, b), direction });
+  }
+  const span = hi - lo;
+  return {
+    kind: shape.kind,
+    length: shape.length * span,
+    closed: false,
+    at: (f, options) => shape.at(lo + (options?.open ? f : clamp(f, 0, 1)) * span, options),
+    nearest(p) {
+      const n = shape.nearest(p);
+      const f = clamp(n.f, lo, hi);
+      const q = shape.at(f).point;
+      return { f: span === 0 ? 0 : (f - lo) / span, dist: Math.hypot(p.x - q.x, p.y - q.y) };
+    }
+  };
+}
+
+// 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, past = "extend") {
+  const { length: length2 } = run2;
+  if (past === "follow" && length2 > 0) {
+    const place2 = run2.at(distance / length2, { open: true });
+    const { point: point2, normal: normal3 } = place2;
+    return { ...place2, point: { x: point2.x + shift * normal3.x, y: point2.y + shift * normal3.y } };
+  }
+  const place = run2.at(length2 === 0 ? 0 : distance / length2);
+  const beyond = distance < 0 ? distance : distance > length2 ? distance - length2 : 0;
+  const { point, tangent, normal: normal2 } = place;
+  return {
+    ...place,
+    point: { x: point.x + beyond * tangent.x + shift * normal2.x, y: point.y + beyond * 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, past === "extend" ? "extend" : "follow"), 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);
@@ -1074,17 +1708,17 @@ function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep,
     rys = ryFixed * ryFixed;
   }
   const sign2 = largeArc === sweep ? -1 : 1;
-  const num2 = 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, num2 / 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;
   const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
   const angle = (ux, uy, vx, vy) => {
-    const dot2 = ux * vx + uy * vy;
+    const dot3 = ux * vx + uy * vy;
     const len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
-    let a = Math.acos(Math.max(-1, Math.min(1, dot2 / len)));
+    let a = Math.acos(Math.max(-1, Math.min(1, dot3 / len)));
     if (ux * vy - uy * vx < 0) a = -a;
     return a;
   };
@@ -1124,157 +1758,6 @@ function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep,
   }
 }
 
-// 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/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 } }),
-      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) {
-  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);
@@ -1836,17 +2319,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;
 }
@@ -1861,7 +2344,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;
@@ -1952,12 +2435,12 @@ function createPathSnapIndex(paths, extra = []) {
     if (kind === "center") return out;
     if (kind === "anchor") {
       segments.forEach((segs, path) => {
-        const seen = /* @__PURE__ */ new Set();
+        const seen2 = /* @__PURE__ */ new Set();
         for (const s of segs) {
           for (const p of [s.pts[0], s.pts[s.pts.length - 1]]) {
             const key = `${p.x},${p.y}`;
-            if (seen.has(key)) continue;
-            seen.add(key);
+            if (seen2.has(key)) continue;
+            seen2.add(key);
             out.push({ kind: "anchor", x: p.x, y: p.y, paths: [path] });
           }
         }
@@ -2868,7 +3351,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);
@@ -2888,7 +3371,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];
@@ -2945,7 +3428,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 SAMPLES3 = [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();
@@ -2984,15 +3467,15 @@ function joinPieces(prev, next, v, tin, tout, ctx) {
   const gap = Math.hypot(b[0] - a[0], b[1] - a[1]);
   if (gap <= ctx.tol * 1e-3) return [];
   const cross2 = tin[0] * tout[1] - tin[1] * tout[0];
-  const dot2 = tin[0] * tout[0] + tin[1] * tout[1];
-  const convex = ctx.sigma * cross2 > 0 || Math.abs(cross2) < 1e-9 && dot2 < 0;
+  const dot3 = tin[0] * tout[0] + tin[1] * tout[1];
+  const convex = ctx.sigma * cross2 > 0 || Math.abs(cross2) < 1e-9 && dot3 < 0;
   if (gap <= ctx.tol) return snap(prev, next, a);
   if (!convex) {
     if (trimAtCrossing(prev, next)) return [];
     return [lineSegment(a[0], a[1], v[0], v[1]), lineSegment(v[0], v[1], b[0], b[1])];
   }
   const nin = normal(tin, ctx.sigma), nout = normal(tout, ctx.sigma);
-  if (ctx.join === "round") return arc(v, ctx.d, nin, Math.atan2(cross2, dot2));
+  if (ctx.join === "round") return arc(v, ctx.d, nin, Math.atan2(cross2, dot3));
   const cos = nin[0] * nout[0] + nin[1] * nout[1];
   if (1 + cos < 1e-9 || Math.sqrt(2 / (1 + cos)) > ctx.miterLimit) return [lineSegment(a[0], a[1], b[0], b[1])];
   const k = ctx.d / (1 + cos);
@@ -3118,7 +3601,7 @@ function offsetSeg(seg, ctx, depth) {
 }
 function offsetError(c, q, ctx) {
   let worst2 = 0;
-  for (const t of SAMPLES) {
+  for (const t of SAMPLES3) {
     const [dx2, dy2] = derivative(c, t);
     const len = Math.hypot(dx2, dy2);
     if (len < 1e-12) continue;
@@ -6304,6 +6787,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, 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, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, 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, bendSide, 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, shiftTrack, shrinkAnchorSelection, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, stationsAlongPath, strokeHitTest, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, trackRun, trackShapeD, trackSlice, 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