@weasel-js/geom 1.15.2 → 1.16.0

package/dist/index.js

@@ -1,18 +1,23 @@
-import { carryCorners, parseSubpaths, intersectSegments, evalSeg, keepCorners, anchorRange, subSeg, writePath, derivSeg } from './chunk-OQP5M5VD.js';
-export { CORNER_RESTORE_TOLERANCE, cornerTraces, intersectSegments, keepCorners, restoreCorners } from './chunk-OQP5M5VD.js';
+import { carryCorners, parseSubpaths, intersectSegments, evalSeg, keepCorners, anchorRange, subSeg, writePath, derivSeg } from './chunk-OBPXEPUH.js';
+export { CORNER_RESTORE_TOLERANCE, cornerTraces, intersectSegments, keepCorners, restoreCorners } from './chunk-OBPXEPUH.js';
+import { lengthTable, closingAnchor, tableInternals, segmentArc, pointOnSegment } from './chunk-FOXMA54X.js';
+export { anchorAtLength, closingAnchor, lengthAtAnchor, lengthAtSegmentFraction, lengthAtSubpath, lengthTable, pointAtLength } from './chunk-FOXMA54X.js';
 import { createBvh } from './chunk-XXNK4N7Z.js';
 import { PORT_REACH, portControls, portCurvePoints } from './chunk-YQADYJJ7.js';
 export { PORT_REACH } from './chunk-YQADYJJ7.js';
-import { wrapPositive, eulerAngleAt, eulerSegmentCubic, eulerCubicError, integrateEuler, eulerPointAt, eulerCurvatureAt, DEG_TO_RAD, cubicDerivativeAt, cubicCurvatureAt } from './chunk-MOCSUHEI.js';
+import { wrapPositive, eulerAngleAt, eulerSegmentCubic, eulerCubicError, integrateEuler, eulerPointAt, eulerCurvatureAt, DEG_TO_RAD, RAD_TO_DEG, cubicDerivativeAt, cubicCurvatureAt } from './chunk-MOCSUHEI.js';
 export { DEG_TO_RAD, RAD_TO_DEG, SPIRO_KINDS, combTeeth, cubicCurvatureAt, cubicCurvatureSource, cubicDerivativeAt, curvatureComb, eulerAngleAt, eulerCurvatureAt, eulerCurvatureDerivativesAt, eulerPointAt, fitEulerSegment, isSpiroKind, placeEulerSegment, solveSpiro, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath, wrapAngle, wrapPositive } from './chunk-MOCSUHEI.js';
-import { extractPolylines } from './chunk-IDSKOHA4.js';
-import { boundsOfPath, fitPointRun, keepCorner } from './chunk-STYO7J4Y.js';
-export { boundsOfPath } from './chunk-STYO7J4Y.js';
+import { extractPolylines, polylineAtCurve } from './chunk-5W425HJA.js';
+import './chunk-QSVZO7QZ.js';
+import { boundsOfPath, fitPointRun, keepCorner } from './chunk-ZV24QZ6X.js';
+export { boundsOfPath } from './chunk-ZV24QZ6X.js';
 import { countPathAnchors, pathToAnchors, anchorsToPath, isAnchorSmooth, segmentEnds, isStraightSegment, nearestSegmentT } from './chunk-HTT5AQIU.js';
 export { anchorsToPath, countPathAnchors, isAnchorSmooth, isStraightSegment, nearestSegmentT, pathToAnchors, segmentEnds } from './chunk-HTT5AQIU.js';
-import { resolveCorners, pointInPolygon, cornerCuts, fillsOpenSubpaths, schneiderFit, fitCubicWithTangents, flattenCubic, flattenQuadratic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross, tangentAt } from './chunk-GA5R5KWD.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, remapPerAnchor, resolveCorners, resolveCornersWithSources, ringSignedArea, schneiderFit, segmentsCross, setDefaultOpenFill } from './chunk-GA5R5KWD.js';
-import { nearestOnLine, worldCoords, PATH_M, PATH_L, PATH_C, PATH_Q, PATH_Z, PathBuilder, withCorner, scaleCorners, originFor, coordsFrom, forEachSegment, pathCommandCoordCount, withoutCorners, elevateQuadraticToCubic, cubicEvalAt, nearestOnPath, cubicPointAt, splitCubicAtT, nearestOnCubic, cubicAxisExtremaTs, rectToContour, pointSegmentDist2, lerpPoint, distance, splitCubicAt, nearestOnQuadratic, boxesIntersect } from './chunk-346XYYMX.js';
+import { resolveCornersWithSources, resolveCorners, pointInPolygon, cornerCuts, fillsOpenSubpaths, schneiderFit, fitCubicWithTangents, flattenCubic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross, flattenQuadratic, tangentAt } from './chunk-TBS4NHGQ.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, remapPerAnchor, resolveCorners, resolveCornersWithSources, ringSignedArea, schneiderFit, segmentsCross, setDefaultOpenFill } from './chunk-TBS4NHGQ.js';
+import { lookupLength, lookupT, flatPoints, segmentLength, segmentTAtLength } from './chunk-IOD2NFHQ.js';
+export { segmentLength, segmentTAtLength } from './chunk-IOD2NFHQ.js';
+import { nearestOnLine, forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, worldCoords, PATH_Z, PathBuilder, withCorner, scaleCorners, originFor, coordsFrom, pathCommandCoordCount, withoutCorners, elevateQuadraticToCubic, cubicEvalAt, nearestOnPath, cubicPointAt, splitCubicAtT, nearestOnCubic, cubicAxisExtremaTs, rectToContour, pointSegmentDist2, lerpPoint, distance, originOf, splitCubicAt, nearestOnQuadratic, boxesIntersect } from './chunk-346XYYMX.js';
 export { ORIGIN_THRESHOLD, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, PathBuilder, addOrigin, asPolygonPath, boundsOfCoords, boxContainsBox, boxContainsPoint, boxesIntersect, compactCorners, coordsFrom, cornerAt, cornerSpecAt, cubicAxisExtremaTs, cubicBounds, cubicEvalAt, cubicPointAt, distance, distance2, elevateQuadraticToCubic, ellipsePath, forEachSegment, hasCorners, joinPaths, lerpCorners, lerpPoint, linePath, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, originFor, originOf, pathCommandCoordCount, pathPoint, pointSegmentDist, pointSegmentDist2, polygonFromPoints, polylineFromPoints, quadraticEvalAt, rectContainsPoint, rectContainsPointHalfOpen, rectPath, rectToContour, rectsIntersect, rectsOverlap, regularPolygonPath, scaleCorners, segmentT, splitCubicAt, splitCubicAtT, splitLineAt, splitQuadraticAt, starPath, unionBox, unionRects, withCorner, withoutCorners, worldCoords } from './chunk-346XYYMX.js';
 import { SINGULAR_RATIO, clamp } from './chunk-DNX24KBT.js';
 export { EPS, approxEq, clamp, clamp01, cross, dot, len2, lerp, sign, sub } from './chunk-DNX24KBT.js';
@@ -182,7 +187,7 @@ var speed = ({ a, b, t0, sign: sign2 }, u) => {
   const t = (t0 + sign2 * u) * DEG_TO_RAD;
   return Math.hypot(a * Math.cos(t), b * Math.sin(t)) * DEG_TO_RAD;
 };
-function lengthTable(e, sweep) {
+function lengthTable2(e, sweep) {
   const simpson = (u0, u1) => {
     const h = (u1 - u0) / PANELS;
     let sum = speed(e, u0) + speed(e, u1);
@@ -261,7 +266,7 @@ function ellipseShape(spec) {
   const e = { center, a, b, t0: param(spec.start), sign: sign2 };
   const raw = wrapPositive(sign2 * (param(spec.end) - e.t0), 360);
   const sweep = raw === 0 ? 360 : raw;
-  const { length, lengthTo, offsetAt } = lengthTable(e, sweep);
+  const { length, lengthTo, offsetAt } = lengthTable2(e, sweep);
   const offsetPast = (f) => {
     if (raw === 0) return offsetAt((f % 1 + 1) % 1);
     let u = f * sweep;
@@ -300,40 +305,78 @@ function ellipseShape(spec) {
   return shape;
 }
 
+// src/along/pathTable.ts
+var tables = /* @__PURE__ */ new WeakMap();
+function pathLengthTable(path) {
+  const hit = tables.get(path);
+  if (hit) return hit;
+  let table;
+  if (path.kind === "rect") {
+    table = lengthTable(extractPolylines(path), 2);
+  } else {
+    const { path: resolved, anchorSources } = resolveCornersWithSources(path);
+    const controls2 = controlsByAnchor(resolved);
+    table = lengthTable(extractPolylines(resolved).map((pl) => anchorRun(pl, controls2)), 2, anchorSources);
+  }
+  tables.set(path, table);
+  return table;
+}
+function controlsByAnchor(path) {
+  const out = [];
+  const { commands, coords } = path;
+  forEachSegment(commands, coords, (cmd, ci) => {
+    if (cmd === PATH_M || cmd === PATH_L) out.push(null);
+    else if (cmd === PATH_Q) out.push([coords[ci], coords[ci + 1]]);
+    else if (cmd === PATH_C) out.push([coords[ci], coords[ci + 1], coords[ci + 2], coords[ci + 3]]);
+  });
+  return out;
+}
+function anchorRun(pl, controls2) {
+  const n = pl.points.length / 2;
+  const { anchorA: A, anchorB: B } = pl;
+  const points = [];
+  const ids = [];
+  for (let i = 0; i < n; i++) {
+    if (A && B && A[i] !== B[i]) continue;
+    points.push(pl.points[i * 2], pl.points[i * 2 + 1]);
+    ids.push(A ? A[i] : i);
+  }
+  const segControls = ids.slice(1).map((id) => controls2[id] ?? null);
+  const close = closingAnchor(pl);
+  if (pl.closed && n >= 2) segControls.push(close === void 0 ? null : controls2[close] ?? null);
+  const anchors = Uint32Array.from(ids);
+  return {
+    points,
+    closed: pl.closed,
+    anchorA: anchors,
+    anchorB: anchors.slice(),
+    anchorT: new Float32Array(ids.length),
+    ...close !== void 0 ? { closeAnchor: close } : {},
+    controls: segControls
+  };
+}
+
 // src/paths/pathMeasure.ts
 function measurePath(path, opts = {}) {
   const polylines = extractPolylines(
     path,
     opts.flattenTolerance === void 0 ? {} : { flattenTolerance: opts.flattenTolerance }
   );
+  const table = pathLengthTable(path);
+  const cornerTolerance = opts.keepCorners ? opts.flattenTolerance ?? 0.5 : null;
   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;
+  polylines.forEach((pl, r) => {
+    if (pl.points.length === 0) return;
     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);
-  }
+    pushChords(pl, r, table, segments);
+    smoothVertexHeadings(segments, startIndex, pl.closed, cornerTolerance);
+  });
   if (first === void 0) return null;
   const origin = first;
   const closed = contours === 1 && lastClosed;
@@ -350,15 +393,20 @@ function measurePath(path, opts = {}) {
       })
     };
   }
+  const total = table.total;
+  const pointAt2 = (seg, s) => {
+    const { point } = pointOnSegment(table, seg.run, seg.seg, s);
+    return { x: point[0], y: point[1] };
+  };
   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 };
+      const point = pointAt2(seg, target);
       if (!smooth) return { point, tangent: { x: seg.tx, y: seg.ty } };
+      const u = seg.arc > 0 ? Math.min(Math.max((target - seg.start) / seg.arc, 0), 1) : 0;
       const x = seg.t0x + (seg.t1x - seg.t0x) * u;
       const y = seg.t0y + (seg.t1y - seg.t0y) * u;
       const l = Math.hypot(x, y);
@@ -377,15 +425,58 @@ function measurePath(path, opts = {}) {
           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 }
-      };
+      const s = best.start + best.arc * bestU;
+      const point = pointAt2(best, s);
+      return { s, dist: Math.hypot(p.x - point.x, p.y - point.y), point, tangent: { x: best.tx, y: best.ty } };
     }
   };
 }
+function pushChords(pl, r, table, segments) {
+  const c = tableInternals(table).cum[r];
+  const { points, anchorA: A, anchorB: B, anchorT: T } = pl;
+  const count = points.length / 2;
+  const segOf = new Int32Array(count);
+  const lenOf = new Float64Array(count);
+  let k = -1;
+  for (let i = 0; i < count; i++) {
+    const aligned = !A || !B || A[i] === B[i];
+    if (aligned) k++;
+    const at2 = Math.max(k, 0);
+    segOf[i] = Math.min(at2, c.length - 2);
+    lenOf[i] = aligned || !T ? c[at2] : c[at2] + T[i] * (c[at2 + 1] - c[at2]);
+  }
+  const last = pl.closed ? count : count - 1;
+  for (let i = 0; i < last; i++) {
+    const j = (i + 1) % count;
+    const ax = points[i * 2];
+    const ay = points[i * 2 + 1];
+    const bx = points[j * 2];
+    const by = 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;
+    const start = lenOf[i];
+    const arc2 = (j === 0 ? c[c.length - 1] : lenOf[j]) - start;
+    segments.push({
+      ax,
+      ay,
+      bx,
+      by,
+      len,
+      start,
+      arc: arc2,
+      run: r,
+      seg: segOf[i],
+      tx,
+      ty,
+      t0x: tx,
+      t0y: ty,
+      t1x: tx,
+      t1y: ty
+    });
+  }
+}
 function smoothVertexHeadings(segments, from, closed, cornerTolerance) {
   const n = segments.length - from;
   if (n < 2) return;
@@ -468,7 +559,7 @@ function trackRun(shape, from = 0, to = 1, options = {}) {
   const at2 = (g, options2) => {
     const s = options2?.open ? shape.at(toShape(g), options2) : shape.at(toShape(clamp(g, 0, 1)));
     const dir = reading(s.normal);
-    const angle = Math.atan2(dir.y, dir.x) * 180 / Math.PI;
+    const angle = Math.atan2(dir.y, dir.x) * RAD_TO_DEG;
     const normal2 = { x: sgn * s.normal.x, y: sgn * s.normal.y };
     return {
       point: s.point,
@@ -745,6 +836,52 @@ function portCurvePoints2(ax, ay, bx, by, outNormal, inNormal, samples, reach =
   );
 }
 
+// src/along/curvePosition.ts
+function runSegments(t, r) {
+  return tableInternals(t).cum[r].length - 1;
+}
+function curveSpan(t, span) {
+  const from = Math.max(span.from, 0);
+  const to = Math.min(span.to, t.total);
+  if (!(from < to)) return null;
+  const a = curveAtLength(t, from, true);
+  const b = curveAtLength(t, to, false);
+  return a && b ? { from: a, to: b } : null;
+}
+function lengthAtCurve(t, at2) {
+  const { cum } = tableInternals(t);
+  const r = Math.min(Math.max(at2.run, 0), t.runs.length - 1);
+  if (r < 0) return 0;
+  const c = cum[r];
+  const segs = c.length - 1;
+  if (segs <= 0) return c[0];
+  const k = Math.min(Math.max(Math.floor(at2.segment), 0), segs - 1);
+  const f = Math.min(Math.max(at2.t, 0), 1);
+  const len = c[k + 1] - c[k];
+  const arc2 = f <= 0 || f >= 1 || !(len > 0) ? null : segmentArc(t, r, k);
+  if (!arc2) return c[k] + f * len;
+  return c[k] + Math.min(lookupLength(arc2.coords, t.dim, arc2.lookup, f), len);
+}
+function curveAtLength(t, s, starts2) {
+  const { cum } = tableInternals(t);
+  for (let r = 0; r < cum.length; r++) {
+    const c = cum[r];
+    const end = c[c.length - 1];
+    if (c.length < 2 || !(end > c[0]) || (starts2 ? s >= end : s > end)) continue;
+    for (let k = 0; k < c.length - 1; k++) {
+      const len = c[k + 1] - c[k];
+      if (!(len > 0) || (starts2 ? s >= c[k + 1] : s > c[k + 1])) continue;
+      return { run: r, segment: k, t: paramAt(t, r, k, s - c[k], len) };
+    }
+  }
+  return null;
+}
+function paramAt(t, r, k, local, len) {
+  const arc2 = segmentArc(t, r, k);
+  if (!arc2) return Math.min(Math.max(local / len, 0), 1);
+  return lookupT(arc2.coords, t.dim, arc2.lookup, local);
+}
+
 // src/pathSubpaths.ts
 function flatSubpaths(path, tolerance) {
   const drawn = resolveCorners(path);
@@ -813,6 +950,71 @@ function closedSubpaths(path, opts) {
   return regionSubpaths(path, opts).closed;
 }
 
+// src/outlineSegments.ts
+function someSegment(path, tolerance, span, visit) {
+  if (path.kind === "rect") return someRectEdge(path, span, visit);
+  if (!span) return someFlatEdge(path, tolerance, visit);
+  const o = originOf(path);
+  const polylines = extractPolylines(path, { flattenTolerance: tolerance ?? DEFAULT_FLATTEN_TOLERANCE });
+  const { runs } = pathLengthTable(path);
+  for (let r = Math.max(span.from.run, 0); r <= Math.min(span.to.run, polylines.length - 1); r++) {
+    const pl = polylines[r];
+    const place = (at2) => polylineAtCurve(pl, at2.segment, at2.t, runs[r]);
+    const head = r === span.from.run ? place(span.from) : null;
+    const tail = r === span.to.run ? place(span.to) : null;
+    const from = head?.length ?? 0;
+    const to = tail?.length ?? Infinity;
+    if (!(from < to)) continue;
+    const p = pl.points;
+    const n = p.length / 2;
+    const end = pl.closed && n >= 2 ? n : n - 1;
+    let s = 0;
+    for (let i = 0; i < end; i++) {
+      const j = (i + 1) % n;
+      const ax = p[i * 2], ay = p[i * 2 + 1];
+      const bx = p[j * 2], by = p[j * 2 + 1];
+      const s0 = s;
+      s += Math.hypot(bx - ax, by - ay);
+      if (head && s <= from) continue;
+      if (tail && s0 >= to) break;
+      const [x0, y0] = head && s0 < from ? [head.x, head.y] : [ax, ay];
+      const [x1, y1] = tail && s > to ? [tail.x, tail.y] : [bx, by];
+      if (visit(x0 + o.x, y0 + o.y, x1 + o.x, y1 + o.y)) return true;
+    }
+  }
+  return false;
+}
+function someFlatEdge(path, tolerance, visit) {
+  const { closed, open } = flatSubpaths(path, tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+  const run2 = (sub3, wrap) => {
+    const n = sub3.length;
+    const last = wrap ? n : n - 2;
+    for (let i = 0; i < last; i += 2) {
+      const j = (i + 2) % n;
+      if (visit(sub3[i], sub3[i + 1], sub3[j], sub3[j + 1])) return true;
+    }
+    return false;
+  };
+  return closed.some((sub3) => run2(sub3, true)) || open.some((sub3) => run2(sub3, false));
+}
+function someRectEdge(rect, span, visit) {
+  const { x, y, width: w, height: h } = rect;
+  const cx = [x, x + w, x + w, x];
+  const cy = [y, y, y + h, y + h];
+  const lo = span ? span.from : { run: 0, segment: 0, t: 0 };
+  const hi = span ? span.to : { run: 0, segment: 3, t: 1 };
+  if (lo.run !== 0 || hi.run !== 0) return false;
+  for (let i = Math.max(lo.segment, 0); i <= Math.min(hi.segment, 3); i++) {
+    const j = i + 1 & 3;
+    const t0 = i === lo.segment ? lo.t : 0;
+    const t1 = i === hi.segment ? hi.t : 1;
+    if (!(t1 > t0) && lo.segment === hi.segment) return false;
+    const at2 = (f) => [cx[i] + (cx[j] - cx[i]) * f, cy[i] + (cy[j] - cy[i]) * f];
+    if (visit(...at2(t0), ...at2(t1))) return true;
+  }
+  return false;
+}
+
 // src/screenBand.ts
 function stretchOf(m) {
   const e = (m.a + m.d) / 2;
@@ -944,30 +1146,16 @@ function strokeHitTest(path, x, y, threshold, opts = {}) {
     const st = stretchOf(m);
     if (st.s1 === 0) return false;
     if (isSimilarity(st)) {
-      return strokeHitTest(path, x, y, threshold + slop.px / st.s1, { tolerance: opts.tolerance });
+      return strokeHitTest(path, x, y, threshold + slop.px / st.s1, { tolerance: opts.tolerance, span: opts.span });
     }
     const sx = a * x + c * y, sy = b * x + d * y;
-    return someSegment(path, opts.tolerance, (ax, ay, bx, by) => capsuleWithinPx(sx, sy, ax, ay, bx, by, threshold, slop.px, m, st));
+    return walk(path, opts, (ax, ay, bx, by) => capsuleWithinPx(sx, sy, ax, ay, bx, by, threshold, slop.px, m, st));
   }
   const t2 = threshold * threshold;
-  return someSegment(path, opts.tolerance, (ax, ay, bx, by) => pointSegmentDist2(x, y, ax, ay, bx, by) <= t2);
+  return walk(path, opts, (ax, ay, bx, by) => pointSegmentDist2(x, y, ax, ay, bx, by) <= t2);
 }
-function someSegment(path, tolerance, visit) {
-  if (path.kind === "rect") {
-    const { x: rx, y: ry, width: w, height: h } = path;
-    return visit(rx, ry, rx + w, ry) || visit(rx + w, ry, rx + w, ry + h) || visit(rx + w, ry + h, rx, ry + h) || visit(rx, ry + h, rx, ry);
-  }
-  const { closed, open } = flatSubpaths(path, tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
-  const run2 = (sub3, wrap) => {
-    const n = sub3.length;
-    const last = wrap ? n : n - 2;
-    for (let i = 0; i < last; i += 2) {
-      const j = (i + 2) % n;
-      if (visit(sub3[i], sub3[i + 1], sub3[j], sub3[j + 1])) return true;
-    }
-    return false;
-  };
-  return closed.some((sub3) => run2(sub3, true)) || open.some((sub3) => run2(sub3, false));
+function walk(path, opts, visit) {
+  return someSegment(path, opts.tolerance, opts.span, visit);
 }
 function rectToVerts(r) {
   return [
@@ -1715,7 +1903,7 @@ function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep,
     b.lineTo(x2, y2);
     return;
   }
-  const phi = xAxisRotationDeg * Math.PI / 180;
+  const phi = xAxisRotationDeg * DEG_TO_RAD;
   const cosPhi = Math.cos(phi);
   const sinPhi = Math.sin(phi);
   const dx2 = (x1 - x2) / 2;
@@ -2317,64 +2505,11 @@ function crossingStops(path, cutters) {
   return stops;
 }
 
-// src/paths/segmentLength.ts
-var GL_X = [
-  -0.9602898564975363,
-  -0.7966664774136267,
-  -0.525532409916329,
-  -0.1834346424956498,
-  0.1834346424956498,
-  0.525532409916329,
-  0.7966664774136267,
-  0.9602898564975363
-];
-var GL_W2 = [
-  0.1012285362903763,
-  0.2223810344533745,
-  0.3137066458778873,
-  0.362683783378362,
-  0.362683783378362,
-  0.3137066458778873,
-  0.2223810344533745,
-  0.1012285362903763
-];
-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 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] * speed2(s, mid + GL_X[i] * h / 2);
-  }
-  return sum * h / 2;
-}
-function segmentTAtLength(s, length) {
-  const total = segmentLength(s);
-  if (length <= 0 || !(total > 0)) return 0;
-  if (length >= total) return 1;
-  if (s.length === 2) return length / total;
-  let lo = 0, hi = 1, t = length / total;
-  for (let i = 0; i < 30; i++) {
-    const err = segmentLength(s, 0, t) - length;
-    if (Math.abs(err) < 1e-10 * Math.max(1, total)) break;
-    if (err > 0) hi = t;
-    else lo = 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;
-  }
-  return t;
-}
-
 // src/snap/segmentFeatures.ts
 function segmentMidT(s) {
   if (s.length === 2) return 0.5;
-  return segmentTAtLength(s, segmentLength(s) / 2);
+  const c = flatPoints(s);
+  return segmentTAtLength(c, 2, segmentLength(c, 2) / 2);
 }
 function unitQuadraticRoots(a, b, c) {
   const inside = (t) => t >= -1e-9 && t <= 1 + 1e-9;
@@ -3068,14 +3203,14 @@ function segmentAt2(set, x, y, opts) {
   const hit = nearestSegmentT(screenAnchors, x * scale3.x, y * scale3.y, set.closed);
   if (!hit) return null;
   const ends = segmentEnds(set.anchors, set.closed, hit.sub, hit.segIdx);
-  const point = pointOnSegment(ends.a, ends.b, hit.t);
+  const point = pointOnSegment2(ends.a, ends.b, hit.t);
   const tol = opts.tolerancePx;
   if (!withinPxRadius(point.x - x, point.y - y, tol, scale3)) return null;
   if (withinPxRadius(point.x - ends.a.x, point.y - ends.a.y, tol, scale3)) return null;
   if (withinPxRadius(point.x - ends.b.x, point.y - ends.b.y, tol, scale3)) return null;
   return { sub: hit.sub, segIdx: hit.segIdx, t: hit.t, x: point.x, y: point.y };
 }
-function pointOnSegment(a, b, t) {
+function pointOnSegment2(a, b, t) {
   if (isStraightSegment(a, b)) return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
   return cubicPointAt(a, a.outHandle ?? a, b.inHandle ?? b, b, t);
 }
@@ -3302,8 +3437,9 @@ function g2Cubic(seg) {
 }
 function pieceLengthAt(piece, t) {
   if (piece.pts.length === 2) return piece.length * t;
-  const whole = segmentLength(piece.pts);
-  return whole > 0 ? piece.length * segmentLength(piece.pts, 0, t) / whole : 0;
+  const c = flatPoints(piece.pts);
+  const whole = segmentLength(c, 2);
+  return whole > 0 ? piece.length * segmentLength(c, 2, 0, t) / whole : 0;
 }
 
 // src/paths/lengthenPathEnd.ts
@@ -3434,7 +3570,7 @@ function appendPieces(sub3, pieces) {
 function tailLength(sub3) {
   const [p0, p1, p2, p3] = tailCubic(sub3);
   if (isStraightSegment(p0, p3)) return Math.hypot(p3.x - p0.x, p3.y - p0.y);
-  return segmentLength([p0, p1, p2, p3]);
+  return segmentLength(flatPoints([p0, p1, p2, p3]), 2);
 }
 function subpathLength(sub3) {
   let total = 0;
@@ -3464,7 +3600,7 @@ function cutTail(sub3, keep, len) {
     p3.y = p0.y + (p3.y - p0.y) * f;
     return;
   }
-  const t = segmentTAtLength([p0, p1, p2, p3], keep);
+  const t = segmentTAtLength(flatPoints([p0, p1, p2, p3]), 2, keep);
   const { left } = splitCubicAtT(p0, p1, p2, p3, t);
   if (p0.outHandle) p0.outHandle = left[1];
   p3.inHandle = left[2];
@@ -3575,7 +3711,7 @@ function simplifySpan(sub3, closed, from, to, tolerance, opts = {}) {
 function fitParams(tolerance, opts) {
   return {
     tol: Math.max(tolerance, 1e-6),
-    cosCorner: Math.cos((opts.cornerAngle ?? 40) * Math.PI / 180)
+    cosCorner: Math.cos((opts.cornerAngle ?? 40) * DEG_TO_RAD)
   };
 }
 function breaksOf(sub3, closed, cosCorner) {
@@ -4214,7 +4350,7 @@ function measure(a, b, from) {
   }
   return { a, c1, c2, b, straight, from, len: table[LENGTH_SAMPLES], table };
 }
-function paramAt(seg, d) {
+function paramAt2(seg, d) {
   const { table } = seg;
   if (seg.len === 0) return 0;
   let lo = 0;
@@ -4241,7 +4377,7 @@ function arcRun(sub3, from, to) {
     const d = Math.min(Math.max(s, 0), length);
     let k = 0;
     while (k < segs.length - 1 && (arriving ? segs[k].from + segs[k].len < d : segs[k].from + segs[k].len <= d)) k++;
-    return { seg: segs[k], t: paramAt(segs[k], d - segs[k].from) };
+    return { seg: segs[k], t: paramAt2(segs[k], d - segs[k].from) };
   };
   const start = { x: sub3[from % n].x, y: sub3[from % n].y };
   return {
@@ -5189,7 +5325,10 @@ function poseFrameInverseOf(pose) {
 function pathThroughPoseFrame(path, pose) {
   if (poseLinearOf(pose)) {
     const frame = poseFrameOf(pose);
-    return frame ? transformPath(path, frame) : path;
+    if (!frame) return path;
+    const [a, b, c, d] = frame;
+    const uniform = isSimilarity(stretchOf({ a, b, c, d }));
+    return transformPath(path.kind === "polygon" && !uniform ? resolveCorners(path) : path, frame);
   }
   const r = poseRotationOf(pose);
   return r ? rotatePathAround(path, r.cx, r.cy, r.rotation) : path;
@@ -6918,7 +7057,7 @@ function handleTarget(a, h, part, entry) {
   const angle = angleOf(a, h);
   const nextAngle = part === "Angle" ? apply2(angle, entry) : angle;
   const nextLength = part === "Length" ? Math.max(0, apply2(length, entry)) : length;
-  const rad = nextAngle * Math.PI / 180;
+  const rad = nextAngle * DEG_TO_RAD;
   return { x: a.x + Math.cos(rad) * nextLength, y: a.y - Math.sin(rad) * nextLength };
 }
 function apply2(current, entry) {
@@ -6926,7 +7065,7 @@ function apply2(current, entry) {
 }
 function angleOf(a, h) {
   if (h.x === a.x && h.y === a.y) return 0;
-  return Math.atan2(a.y - h.y, h.x - a.x) * 180 / Math.PI;
+  return Math.atan2(a.y - h.y, h.x - a.x) * RAD_TO_DEG;
 }
 function agreed(values) {
   const first = values[0];
@@ -7017,6 +7156,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, arcShape, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, bendSide, blendPaths, boxFrameOf, 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, easeLength, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSet, editAnchorSetTracked, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, extensionPieces, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, 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, puckerBloatPath, pxExtent, pxExtentInFrame, readAnchorFields, rectMarkerPath, remapAnchorValues, remapConstraints, remapPointValues, repeatAlongPath, resamplePath, resolveEasing, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roughenPath, 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, viewRectToScreen, viewScreenToWorld, viewToMat3, viewWorldToScreen, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField, zigzagPath };
+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, boxFrameOf, boxToBox, circlePath, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, createPathSnapIndex, cubicBezierEasing, cubicContoursToPath, curveSpan, 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, easeLength, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSet, editAnchorSetTracked, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, extensionPieces, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, lengthAtCurve, 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, pathLengthTable, pathSegments, pathShape, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeAlongRun, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonIntersectsPath, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, puckerBloatPath, pxExtent, pxExtentInFrame, readAnchorFields, rectMarkerPath, remapAnchorValues, remapConstraints, remapPointValues, repeatAlongPath, resamplePath, resolveEasing, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roughenPath, roundRectPath, runLength, runPlaces, runSegments, 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, viewRectToScreen, viewScreenToWorld, viewToMat3, viewWorldToScreen, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField, zigzagPath };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map