@weasel-js/geom 1.15.1 → 1.16.0

package/dist/index.js

@@ -1,29 +1,50 @@
-import { carryCorners, parseSubpaths, intersectSegments, evalSeg, keepCorners, anchorRange, subSeg, writePath, derivSeg } from './chunk-3YH5XU3H.js';
-export { CORNER_RESTORE_TOLERANCE, cornerTraces, intersectSegments, keepCorners, restoreCorners } from './chunk-3YH5XU3H.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 { eulerAngleAt, eulerSegmentCubic, eulerCubicError, integrateEuler, eulerPointAt, eulerCurvatureAt, cubicDerivativeAt, cubicCurvatureAt } from './chunk-HNLJO3E7.js';
-export { SPIRO_KINDS, combTeeth, cubicCurvatureAt, cubicCurvatureSource, cubicDerivativeAt, curvatureComb, eulerAngleAt, eulerCurvatureAt, eulerCurvatureDerivativesAt, eulerPointAt, fitEulerSegment, isSpiroKind, placeEulerSegment, solveSpiro, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath } from './chunk-HNLJO3E7.js';
-import { extractPolylines } from './chunk-FROQPADA.js';
-import { boundsOfPath, fitPointRun, keepCorner } from './chunk-ZOMUTU7J.js';
-export { boundsOfPath } from './chunk-ZOMUTU7J.js';
-import { countPathAnchors, pathToAnchors, anchorsToPath, isAnchorSmooth, segmentEnds, isStraightSegment, nearestSegmentT } from './chunk-3HQJGI63.js';
-export { anchorsToPath, countPathAnchors, isAnchorSmooth, isStraightSegment, nearestSegmentT, pathToAnchors, segmentEnds } from './chunk-3HQJGI63.js';
-import { nearestOnLine, nearestOnPath, nearestOnCubic, nearestOnQuadratic } from './chunk-2N6OWA7E.js';
-export { nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic } from './chunk-2N6OWA7E.js';
-import { resolveCorners, pointInPolygon, cornerCuts, fillsOpenSubpaths, schneiderFit, fitCubicWithTangents, flattenCubic, pointSegmentDist2, flattenQuadratic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross, tangentAt } from './chunk-EURWZUNY.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-EURWZUNY.js';
-import { SINGULAR_RATIO, clamp } from './chunk-755Y4YZS.js';
-export { EPS, approxEq, clamp, cross, dot, len2, sign, sub } from './chunk-755Y4YZS.js';
-import { worldCoords, PATH_M, PATH_L, PATH_C, PATH_Q, PATH_Z, PathBuilder, withCorner, scaleCorners, originFor, coordsFrom, forEachSegment, pathCommandCoordCount, withoutCorners, elevateQuadraticToCubic, cubicEvalAt, cubicPointAt, splitCubicAtT, cubicAxisExtremaTs, rectToContour, splitCubicAt } from './chunk-B3D6KWW3.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, compactCorners, coordsFrom, cornerAt, cornerSpecAt, cubicAxisExtremaTs, cubicBounds, cubicEvalAt, cubicPointAt, elevateQuadraticToCubic, ellipsePath, forEachSegment, hasCorners, joinPaths, lerpCorners, linePath, originFor, originOf, pathCommandCoordCount, pathPoint, polygonFromPoints, polylineFromPoints, quadraticEvalAt, rectPath, rectToContour, regularPolygonPath, scaleCorners, splitCubicAt, splitCubicAtT, splitLineAt, splitQuadraticAt, starPath, unionBox, withCorner, withoutCorners, worldCoords } from './chunk-B3D6KWW3.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, 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 { 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';
 
 // src/view.ts
 var ZOOM_FLOOR = 1e-9;
 function normalizeZoom(zoom) {
   return zoom >= ZOOM_FLOOR && zoom < Infinity ? zoom : ZOOM_FLOOR;
 }
+function viewWorldToScreen(view, p) {
+  return { x: (p.x - view.x) * view.scale.x, y: (p.y - view.y) * view.scale.y };
+}
+function viewScreenToWorld(view, p) {
+  return { x: p.x / view.scale.x + view.x, y: p.y / view.scale.y + view.y };
+}
+function viewRectToScreen(view, r) {
+  const x0 = (r.x - view.x) * view.scale.x;
+  const y0 = (r.y - view.y) * view.scale.y;
+  const w = r.width * view.scale.x;
+  const h = r.height * view.scale.y;
+  return {
+    x: w < 0 ? x0 + w : x0,
+    y: h < 0 ? y0 + h : y0,
+    width: Math.abs(w),
+    height: Math.abs(h)
+  };
+}
 
 // src/affine.ts
 function identity() {
@@ -87,12 +108,12 @@ function transformCoords(coords, m) {
 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 length = Math.hypot(dx2, dy2);
+  const tangent = length === 0 ? { x: 1, y: 0 } : { x: dx2 / length, y: dy2 / length };
   const normal2 = { x: tangent.y, y: -tangent.x };
   return {
     kind: "line",
-    length: length2,
+    length,
     closed: false,
     at(f, options) {
       const t = options?.open ? f : clamp(f, 0, 1);
@@ -104,25 +125,23 @@ function lineShape(from, to) {
     },
     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);
+      if (!options?.open || length === 0) return { f: n.t, dist: n.dist };
+      const f = ((p.x - from.x) * dx2 + (p.y - from.y) * dy2) / (length * length);
       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 raw = wrapPositive(sign2 * (spec.end - start), 360);
   const sweep = raw === 0 ? 360 : raw;
-  const length2 = radius * sweep * RAD;
+  const length = radius * sweep * DEG_TO_RAD;
   const at2 = (f, options) => {
     const t = options?.open ? f : clamp(f, 0, 1);
-    const theta = (start + sign2 * t * sweep) * RAD;
+    const theta = (start + sign2 * t * sweep) * DEG_TO_RAD;
     const s = Math.sin(theta);
     const c = Math.cos(theta);
     return {
@@ -133,14 +152,14 @@ function arcShape(spec) {
   };
   const shape = {
     kind: "arc",
-    length: length2,
+    length,
     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));
+      const angle = dx2 === 0 && dy2 === 0 ? 0 : Math.atan2(dx2, -dy2) / DEG_TO_RAD;
+      const offset2 = wrapPositive(sign2 * (angle - start), 360);
       let f;
       if (offset2 <= sweep) f = offset2 / sweep;
       else f = 360 - offset2 < offset2 - sweep ? 0 : 1;
@@ -148,7 +167,7 @@ function arcShape(spec) {
       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;
+      const unwrapped = mid + wrapPositive(offset2 - mid + 180, 360) - 180;
       return { f: unwrapped / sweep, dist };
     }
   };
@@ -157,20 +176,18 @@ function arcShape(spec) {
 }
 
 // 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;
+  const t = (t0 + sign2 * u) * DEG_TO_RAD;
   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;
+  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);
@@ -180,7 +197,7 @@ function lengthTable(e, sweep) {
   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 length = table[PIECES];
   const lengthTo = (u) => {
     if (u >= 0 && u <= sweep) {
       const i = Math.min(PIECES - 1, Math.floor(u / du));
@@ -192,8 +209,8 @@ function lengthTable(e, sweep) {
     return s;
   };
   const offsetAt = (f) => {
-    if (length2 === 0) return f * sweep;
-    const s = f * length2;
+    if (length === 0) return f * sweep;
+    const s = f * length;
     let lo = 0;
     let hi = PIECES;
     while (hi - lo > 1) {
@@ -210,7 +227,7 @@ function lengthTable(e, sweep) {
     }
     return u;
   };
-  return { length: length2, lengthTo, offsetAt };
+  return { length, lengthTo, offsetAt };
 }
 var dist2 = (e, p, u) => {
   const q = pointAt(e, u);
@@ -230,13 +247,13 @@ function footBetween(e, p, lo, hi, n, late) {
   const dy2 = p.y - e.center.y;
   let u = best;
   for (let i = 0; i < 12; i++) {
-    const t = (t0 + sign2 * u) * RAD2;
+    const t = (t0 + sign2 * u) * DEG_TO_RAD;
     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));
+    const next = clamp(u - sign2 * g / g1 / DEG_TO_RAD, Math.max(lo, best - step), Math.min(hi, best + step));
     if (Math.abs(next - u) < 1e-12) break;
     u = next;
   }
@@ -245,24 +262,24 @@ function footBetween(e, p, lo, hi, n, late) {
 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 param = (seenDeg) => Math.atan2(b * Math.sin(seenDeg * DEG_TO_RAD), a * Math.cos(seenDeg * DEG_TO_RAD)) / DEG_TO_RAD;
   const e = { center, a, b, t0: param(spec.start), sign: sign2 };
-  const raw = mod3602(sign2 * (param(spec.end) - e.t0));
+  const raw = wrapPositive(sign2 * (param(spec.end) - e.t0), 360);
   const sweep = raw === 0 ? 360 : raw;
-  const { length: length2, 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;
     for (let i = 0; i < 8; i++) {
       const v = speed(e, u);
       if (!(v > 0)) break;
-      u -= (lengthTo(u) - f * length2) / v;
+      u -= (lengthTo(u) - f * length) / 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 t = (e.t0 + sign2 * u) * DEG_TO_RAD;
     const s = Math.sin(t);
     const c = Math.cos(t);
     const k = Math.hypot(a * c, b * s);
@@ -272,56 +289,94 @@ function ellipseShape(spec) {
   };
   const shape = {
     kind: "ellipse",
-    length: length2,
+    length,
     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 f = length === 0 ? 0 : clamp(lengthTo(u) / length, 0, 1);
       const dist = Math.sqrt(dist2(e, p, u));
-      if (!options?.open || length2 === 0) return { f, dist };
+      if (!options?.open || length === 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 };
+      return { f: lengthTo(footBetween(e, p, mid - 180, mid + 180, RING, false)) / length, dist };
     }
   };
   Object.defineProperty(shape, "ellipse", { value: spec, enumerable: false });
   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;
@@ -338,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);
@@ -365,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;
@@ -413,22 +516,22 @@ function segmentAt(segments, s) {
 function pathShape(path, options = {}) {
   const measure2 = measurePath(path, { ...options, keepCorners: true });
   if (!measure2) return null;
-  const { length: length2, closed } = measure2;
+  const { length, closed } = measure2;
   const shape = {
     kind: "path",
-    length: length2,
+    length,
     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;
+      const { point, tangent } = measure2.at(g * length, true);
+      const past = open && !closed ? (f - g) * length : 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 f = length === 0 ? 0 : n.s / length;
+      if (!opts?.open || !closed || length === 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 };
@@ -456,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,
@@ -556,7 +659,7 @@ function trackShapeD(shape, from = 0, to = 1) {
     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);
+    const raw = wrapPositive(sign2 * Math.sign(to - from) * (param(b) - param(a)));
     return arcsD(a, b, m, radiusX, radiusY, whole ? 2 * Math.PI : raw, direction === "ccw" === to < from ? 1 : 0);
   }
   let d = `M ${pt(a)}`;
@@ -591,15 +694,15 @@ function shiftTrack(shape, shift) {
     table[i] = table[i - 1] + Math.hypot(step.x, step.y);
     prev = next;
   }
-  const length2 = table[SAMPLES2];
+  const length = 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;
+    const d = f * length;
+    if (length <= 0 || shape.length <= 0) return f;
     if (d < 0) return d * startRatio / shape.length;
-    if (d > length2) return 1 + (d - length2) * endRatio / shape.length;
+    if (d > length) return 1 + (d - length) * endRatio / shape.length;
     let lo = 0;
     let hi = SAMPLES2;
     while (hi - lo > 1) {
@@ -611,17 +714,17 @@ function shiftTrack(shape, shift) {
     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;
+    if (length <= 0 || shape.length <= 0) return g;
+    if (g < 0) return g * shape.length / startRatio / length;
+    if (g > 1) return (length + (g - 1) * shape.length / endRatio) / length;
     const x = g * SAMPLES2;
     const i = Math.min(SAMPLES2 - 1, Math.floor(x));
-    return (table[i] + (x - i) * (table[i + 1] - table[i])) / length2;
+    return (table[i] + (x - i) * (table[i + 1] - table[i])) / length;
   };
   const at2 = (f, options) => moved2(shape.at(toBase(options?.open ? f : clamp(f, 0, 1)), options));
   return {
     kind: shape.kind,
-    length: length2,
+    length,
     closed: shape.closed,
     at: at2,
     nearest(p, options) {
@@ -634,8 +737,7 @@ function shiftTrack(shape, shift) {
 }
 
 // src/track/slice.ts
-var RAD3 = Math.PI / 180;
-var seen = (c, p) => Math.atan2(p.x - c.x, c.y - p.y) / RAD3;
+var seen = (c, p) => Math.atan2(p.x - c.x, c.y - p.y) / DEG_TO_RAD;
 function trackSlice(shape, from, to) {
   const lo = clamp(Math.min(from, to), 0, 1);
   const hi = clamp(Math.max(from, to), 0, 1);
@@ -675,25 +777,25 @@ function runPlaces(lengths, gap, room, align, offset2, at2) {
   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) => {
+  return lengths.map((length) => {
     const start = lo;
-    const hi = start + length2;
+    const hi = start + length;
     lo = hi + gap;
-    return { center: start + length2 / 2, clipped: fits ? "none" : clipOf(start, hi, 0, room) };
+    return { center: start + length / 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);
+  return lengths.reduce((sum, length, i) => sum + length + (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 });
+function runStationAt(run2, distance3, shift = 0, past = "extend") {
+  const { length } = run2;
+  if (past === "follow" && length > 0) {
+    const place2 = run2.at(distance3 / length, { 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 place = run2.at(length === 0 ? 0 : distance3 / length);
+  const beyond = distance3 < 0 ? distance3 : distance3 > length ? distance3 - length : 0;
   const { point, tangent, normal: normal2 } = place;
   return {
     ...place,
@@ -702,22 +804,22 @@ function runStationAt(run2, distance, shift = 0, past = "extend") {
 }
 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 { length } = 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;
+  const spots = runPlaces(lengths, gap, length, align, offset2, at2);
+  const lap = wrap && run2.closed && spots.length > 0 ? wrapWindow(spots[0], lengths[0], length) : 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 };
+    let distance3 = spot.center;
+    if (past === "hold" && clipped === "past") distance3 = clamp(distance3, lap?.start ?? 0, lap?.end ?? length);
+    if (lap && length > 0) distance3 = (distance3 % length + length) % length;
+    return { ...runStationAt(run2, mirror ? length - distance3 : distance3, shift, past === "extend" ? "extend" : "follow"), center: spot.center, clipped };
   });
 }
-function wrapWindow(first, firstLength, length2) {
+function wrapWindow(first, firstLength, length) {
   const start = first.center - firstLength / 2;
-  return { start, end: start + length2, hair: 1e-9 * Math.max(1, length2) };
+  return { start, end: start + length, hair: 1e-9 * Math.max(1, length) };
 }
 
 // src/portCurve2.ts
@@ -734,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);
@@ -802,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;
@@ -933,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 [
@@ -1128,8 +1327,8 @@ function polygonIntersectsPath(polygon, path, opts = {}) {
 }
 
 // src/paths/cornerOffset.ts
-function offsetCornerTraces(path, distance) {
-  if (path.kind !== "polygon" || distance === 0) return [];
+function offsetCornerTraces(path, distance3) {
+  if (path.kind !== "polygon" || distance3 === 0) return [];
   const drawn = resolveCorners(path);
   const out = [];
   for (const cut of cornerCuts(path)) {
@@ -1146,9 +1345,9 @@ function offsetCornerTraces(path, distance) {
     const half = Math.acos(Math.max(-1, Math.min(1, din.x * b.x + din.y * b.y)));
     const probe = Math.min(inLen, outLen) * 0.01;
     const sign2 = pointInPath(drawn, v.x + b.x * probe, v.y + b.y * probe) ? -1 : 1;
-    const radius = spec.radius + sign2 * distance / Math.tan(half);
+    const radius = spec.radius + sign2 * distance3 / Math.tan(half);
     if (!(radius > 0)) continue;
-    const at2 = { x: v.x - b.x * sign2 * distance / Math.sin(half), y: v.y - b.y * sign2 * distance / Math.sin(half) };
+    const at2 = { x: v.x - b.x * sign2 * distance3 / Math.sin(half), y: v.y - b.y * sign2 * distance3 / Math.sin(half) };
     const reach = radius * 2 + 1;
     const wedge = new PathBuilder().moveTo(at2.x + din.x * reach, at2.y + din.y * reach).lineTo(at2.x, at2.y).lineTo(at2.x + dout.x * reach, at2.y + dout.y * reach).build();
     const [moved2] = cornerCuts(withCorner(wedge, 1, { shape: spec.shape, radius }));
@@ -1704,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;
@@ -2306,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, length2) {
-  const total = segmentLength(s);
-  if (length2 <= 0 || !(total > 0)) return 0;
-  if (length2 >= total) return 1;
-  if (s.length === 2) return length2 / total;
-  let lo = 0, hi = 1, t = length2 / total;
-  for (let i = 0; i < 30; i++) {
-    const err = segmentLength(s, 0, t) - length2;
-    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;
@@ -2559,8 +2705,8 @@ function findPathSnaps(index, probe, query) {
   const skip = query.skip ?? (() => false);
   const hits = [];
   const offer = (kind, x, y, paths) => {
-    const distance = metric(x - probe.x, y - probe.y);
-    if (distance <= r) hits.push({ kind, x, y, distance, paths });
+    const distance3 = metric(x - probe.x, y - probe.y);
+    if (distance3 <= r) hits.push({ kind, x, y, distance: distance3, paths });
   };
   const rx = sx > 0 ? r / sx : Infinity, ry = sy > 0 ? r / sy : Infinity;
   const box = [probe.x - rx, probe.y - ry, probe.x + rx, probe.y + ry];
@@ -3057,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);
 }
@@ -3142,12 +3288,12 @@ var FULL = 2 * Math.PI;
 var FIT_SHARE = 1e-4;
 var FIT_FLOOR = 1e-3;
 var MAX_SPLITS = 6;
-function extensionPieces(frame, distance, mode, opts = {}) {
-  if (!(distance > 0)) return [];
-  const bends = Math.abs(frame.curvature) * distance > STRAIGHT_TURN;
-  if (mode === "curvature" && bends) return arcPieces(frame, distance);
-  if (mode === "eased" && bends) return easedPieces(frame, distance, easeTurnOf(opts));
-  return [line(frame.point, frame.tangent, distance)];
+function extensionPieces(frame, distance3, mode, opts = {}) {
+  if (!(distance3 > 0)) return [];
+  const bends = Math.abs(frame.curvature) * distance3 > STRAIGHT_TURN;
+  if (mode === "curvature" && bends) return arcPieces(frame, distance3);
+  if (mode === "eased" && bends) return easedPieces(frame, distance3, easeTurnOf(opts));
+  return [line(frame.point, frame.tangent, distance3)];
 }
 function easeLength(frame, opts = {}) {
   const k = Math.abs(frame.curvature);
@@ -3157,16 +3303,16 @@ function easeTurnOf(opts) {
   const turn = opts.easeTurn;
   return turn !== void 0 && Number.isFinite(turn) && turn > 0 ? Math.min(turn, QUARTER) : DEFAULT_EASE_TURN;
 }
-function line(from, dir, length2) {
-  return { pts: [from, { x: from.x + dir.x * length2, y: from.y + dir.y * length2 }], length: length2 };
+function line(from, dir, length) {
+  return { pts: [from, { x: from.x + dir.x * length, y: from.y + dir.y * length }], length };
 }
 function arcCenter({ point, tangent, curvature }) {
   return { x: point.x - tangent.y / curvature, y: point.y + tangent.x / curvature };
 }
-function arcPieces(frame, distance) {
+function arcPieces(frame, distance3) {
   const s = Math.sign(frame.curvature);
   const r = 1 / Math.abs(frame.curvature);
-  const sweep = Math.min(distance / r, FULL);
+  const sweep = Math.min(distance3 / r, FULL);
   const count = Math.max(1, Math.ceil(sweep / QUARTER - 1e-9));
   const step = sweep / count;
   const reach = 4 / 3 * Math.tan(step / 4) * r;
@@ -3197,7 +3343,7 @@ function arcPieces(frame, distance) {
   }
   return out;
 }
-function easeSpiral(frame, length2, turn) {
+function easeSpiral(frame, length, turn) {
   const sign2 = Math.sign(frame.curvature);
   const k0 = sign2 * turn;
   const k1 = -2 * sign2 * turn;
@@ -3212,19 +3358,19 @@ function easeSpiral(frame, length2, turn) {
     chordAngle: Math.atan2(c.y, c.x),
     p0: frame.point,
     p1: frame.point,
-    length: length2,
+    length,
     rotation
   };
   return { ...seg, p1: eulerPointAt(seg, 1) };
 }
-function easedPieces(frame, distance, turn) {
+function easedPieces(frame, distance3, turn) {
   const ease = 2 * turn / Math.abs(frame.curvature);
   const spiral = easeSpiral(frame, ease, turn);
-  const drawn = distance < ease ? spiralPiece(spiral, 0, distance / ease) : spiral;
+  const drawn = distance3 < ease ? spiralPiece(spiral, 0, distance3 / ease) : spiral;
   const out = fitSpiral(drawn, Math.max(FIT_FLOOR, FIT_SHARE * ease), 0);
-  if (distance > ease) {
+  if (distance3 > ease) {
     const a = eulerAngleAt(spiral, 1);
-    out.push(line(spiral.p1, { x: Math.cos(a), y: Math.sin(a) }, distance - ease));
+    out.push(line(spiral.p1, { x: Math.cos(a), y: Math.sin(a) }, distance3 - ease));
   }
   return out;
 }
@@ -3291,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
@@ -3315,9 +3462,9 @@ function pathEndAnchorIndex(set, end) {
 function pathEndFrame(set, end) {
   return atTail(set, end, tailFrame) ?? null;
 }
-function lengthenPathEnd(set, end, distance, mode, opts = {}) {
-  if (!(distance !== 0 && Number.isFinite(distance))) return false;
-  return atTail(set, end, (sub3) => distance < 0 ? trimTail(sub3, -distance) : growTail(sub3, distance, mode, opts)) ?? false;
+function lengthenPathEnd(set, end, distance3, mode, opts = {}) {
+  if (!(distance3 !== 0 && Number.isFinite(distance3))) return false;
+  return atTail(set, end, (sub3) => distance3 < 0 ? trimTail(sub3, -distance3) : growTail(sub3, distance3, mode, opts)) ?? false;
 }
 function lengthToward(set, end, mode, point, near2 = 0, opts = {}) {
   const frame = pathEndFrame(set, end);
@@ -3393,10 +3540,10 @@ function lengthAlongEased(frame, point, opts) {
   }
   return best.length;
 }
-function growTail(sub3, distance, mode, opts) {
+function growTail(sub3, distance3, mode, opts) {
   const frame = tailFrame(sub3);
   if (!frame) return false;
-  const pieces = extensionPieces(frame, distance, mode, opts);
+  const pieces = extensionPieces(frame, distance3, mode, opts);
   const end = sub3[sub3.length - 1];
   const first = pieces[0];
   if (pieces.length === 1 && first.pts.length === 2 && isStraightSegment(sub3[sub3.length - 2], end)) {
@@ -3423,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;
@@ -3453,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];
@@ -3479,9 +3626,9 @@ function segmentsBesideEnd(path, end) {
     return s === end.sub ? segs.filter((g) => g.index !== (end.end === "last" ? g.count - 1 : 0)) : segs;
   });
 }
-function lengthenOpenEnd(path, end, distance, mode = "tangent", opts = {}) {
-  if (!(distance > 0) || path.kind !== "polygon") return null;
-  return editAnchorSetTracked(path, (set) => lengthenPathEnd(set, end, distance, mode, opts))?.path ?? null;
+function lengthenOpenEnd(path, end, distance3, mode = "tangent", opts = {}) {
+  if (!(distance3 > 0) || path.kind !== "polygon") return null;
+  return editAnchorSetTracked(path, (set) => lengthenPathEnd(set, end, distance3, mode, opts))?.path ?? null;
 }
 function extendToMeet(path, boundaries, end, opts = {}) {
   if (path.kind !== "polygon") return null;
@@ -3564,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) {
@@ -3649,12 +3796,12 @@ function unit(p) {
 // src/paths/growRegion.ts
 var MAX_DEPTH = 6;
 var SAMPLES3 = [0.2, 0.35, 0.5, 0.65, 0.8];
-function growRegion(path, distance, opts = {}) {
+function growRegion(path, distance3, opts = {}) {
   const b = new PathBuilder();
-  if (!(distance > 0)) return b.build();
+  if (!(distance3 > 0)) return b.build();
   const sigma = pathSignedArea(path) < 0 ? -1 : 1;
   const ctx = {
-    d: distance,
+    d: distance3,
     sigma,
     tol: opts.tolerance ?? 0.1,
     join: opts.join ?? "miter",
@@ -3887,7 +4034,7 @@ function segmentCrossings(segs) {
   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;
+      if (!boxesIntersect(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++) {
@@ -3921,7 +4068,6 @@ function boxOf(pts) {
   }
   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;
@@ -4204,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;
@@ -4221,21 +4367,21 @@ function paramAt(seg, d) {
 function arcRun(sub3, from, to) {
   const n = sub3.length;
   const segs = [];
-  let length2 = 0;
+  let length = 0;
   for (let i = from; i < to; i++) {
-    const seg = measure(sub3[i % n], sub3[(i + 1) % n], length2);
+    const seg = measure(sub3[i % n], sub3[(i + 1) % n], length);
     segs.push(seg);
-    length2 += seg.len;
+    length += seg.len;
   }
   const locate = (s, arriving) => {
-    const d = Math.min(Math.max(s, 0), length2);
+    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 {
-    length: length2,
+    length,
     pointAt(s) {
       if (segs.length === 0) return start;
       const { seg, t } = locate(s, false);
@@ -5179,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;
@@ -5189,17 +5338,13 @@ function pathThroughPoseFrame(path, pose) {
 function anchorsUnderBrush(set, from, to, opts) {
   const scale3 = opts.scale ?? { x: 1, y: 1 };
   const ax = from.x * scale3.x, ay = from.y * scale3.y;
-  const dx2 = to.x * scale3.x - ax, dy2 = to.y * scale3.y - ay;
-  const len22 = dx2 * dx2 + dy2 * dy2;
+  const bx = to.x * scale3.x, by = to.y * scale3.y;
   const r2 = opts.radiusPx * opts.radiusPx;
   const hits = [];
   let flat = 0;
   for (const sub3 of set.anchors) {
     for (const a of sub3) {
-      const px = a.x * scale3.x - ax, py = a.y * scale3.y - ay;
-      const t = len22 === 0 ? 0 : Math.max(0, Math.min(1, (px * dx2 + py * dy2) / len22));
-      const ex = px - t * dx2, ey = py - t * dy2;
-      if (ex * ex + ey * ey <= r2) hits.push(flat);
+      if (pointSegmentDist2(a.x * scale3.x, a.y * scale3.y, ax, ay, bx, by) <= r2) hits.push(flat);
       flat++;
     }
   }
@@ -5321,8 +5466,8 @@ function bendSegment(set, grip, dx2, dy2) {
   const aSmooth = isAnchorSmooth(a);
   const bSmooth = isAnchorSmooth(b);
   const straight = isStraightSegment(a, b);
-  const p1 = a.outHandle ?? (straight ? lerp(a, b, 1 / 3) : { x: a.x, y: a.y });
-  const p2 = b.inHandle ?? (straight ? lerp(a, b, 2 / 3) : { x: b.x, y: b.y });
+  const p1 = a.outHandle ?? (straight ? lerpPoint(a, b, 1 / 3) : { x: a.x, y: a.y });
+  const p2 = b.inHandle ?? (straight ? lerpPoint(a, b, 2 / 3) : { x: b.x, y: b.y });
   const t = Math.min(1 - T_MARGIN, Math.max(T_MARGIN, grip.t));
   const u = 1 - t;
   const k = 1 / (3 * t * u * (u * u + t * t));
@@ -5332,9 +5477,6 @@ function bendSegment(set, grip, dx2, dy2) {
   if (bSmooth) b.outHandle = alignedOpposite(b, b.inHandle, b.outHandle);
   return true;
 }
-function lerp(a, b, f) {
-  return { x: a.x + (b.x - a.x) * f, y: a.y + (b.y - a.y) * f };
-}
 function alignedOpposite(anchor, moved2, other2) {
   const mx = moved2.x - anchor.x;
   const my = moved2.y - anchor.y;
@@ -5483,10 +5625,10 @@ function same2(p, q) {
 }
 
 // src/paths/softSelection.ts
-function softFalloff(falloff, distance, radius) {
-  if (!(radius > 0) || distance >= radius) return 0;
-  if (distance <= 0) return 1;
-  const u = distance / radius;
+function softFalloff(falloff, distance3, radius) {
+  if (!(radius > 0) || distance3 >= radius) return 0;
+  if (distance3 <= 0) return 1;
+  const u = distance3 / radius;
   switch (falloff) {
     case "linear":
       return 1 - u;
@@ -5581,7 +5723,7 @@ function softSelectionBand(measure2, set, selected, radius) {
     sub3.segments.forEach((seg, i) => {
       const c = segmentControls2(anchors, sub3.closed, i);
       if (!c) return;
-      const at2 = (t) => isStraight(c) ? lerp2(c[0], c[3], t) : cubicPointAt(c[0], c[1], c[2], c[3], t);
+      const at2 = (t) => isStraight(c) ? lerpPoint(c[0], c[3], t) : cubicPointAt(c[0], c[1], c[2], c[3], t);
       const steps = seg.lengths.length - 1;
       for (let k = 0; k <= steps; k++) {
         const len = seg.lengths[k];
@@ -5631,9 +5773,6 @@ function crossing2(a, b, aIn, inside) {
   }
   return (lo + hi) / 2;
 }
-function lerp2(a, b, t) {
-  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
-}
 
 // src/paths/balanceHandles.ts
 function handleBalances(set) {
@@ -5661,7 +5800,7 @@ function segmentHandles(set, sub3, segIdx) {
   if (!ends || isStraightSegment(ends.a, ends.b)) return null;
   const { a, b } = ends;
   if (!a.outHandle || !b.inHandle) return null;
-  if (length(a, a.outHandle) === 0 || length(b, b.inHandle) === 0) return null;
+  if (distance(a, a.outHandle) === 0 || distance(b, b.inHandle) === 0) return null;
   return { a, b, from: a.outHandle, to: b.inHandle };
 }
 function scaleSegmentHandles(set, sub3, segIdx, factor, syms = []) {
@@ -5691,8 +5830,8 @@ function equalizeSegmentHandles(set, sub3, segIdx) {
   const handles = segmentHandles(set, sub3, segIdx);
   if (!handles) return false;
   const { a, b, from, to } = handles;
-  const lenA = length(a, from);
-  const lenB = length(b, to);
+  const lenA = distance(a, from);
+  const lenB = distance(b, to);
   const ua = { x: (from.x - a.x) / lenA, y: (from.y - a.y) / lenA };
   const ub = { x: (to.x - b.x) / lenB, y: (to.y - b.y) / lenB };
   const corner = rayCrossing(a, ua, b, ub);
@@ -5719,9 +5858,6 @@ function rayCrossing(p, u, q, v) {
   const tb = (dx2 * u.y - dy2 * u.x) / den;
   return ta > 0 && tb > 0 ? { ta, tb } : null;
 }
-function length(a, b) {
-  return Math.hypot(b.x - a.x, b.y - a.y);
-}
 function scaledFrom(anchor, handle, k) {
   return { x: anchor.x + (handle.x - anchor.x) * k, y: anchor.y + (handle.y - anchor.y) * k };
 }
@@ -6917,11 +7053,11 @@ function handleOf(a, side) {
 function handleTarget(a, h, part, entry) {
   if (part === "X") return { x: apply2(h.x, entry), y: h.y };
   if (part === "Y") return { x: h.x, y: apply2(h.y, entry) };
-  const length2 = Math.hypot(h.x - a.x, h.y - a.y);
+  const length = Math.hypot(h.x - a.x, h.y - a.y);
   const angle = angleOf(a, h);
   const nextAngle = part === "Angle" ? apply2(angle, entry) : angle;
-  const nextLength = part === "Length" ? Math.max(0, apply2(length2, entry)) : length2;
-  const rad = nextAngle * Math.PI / 180;
+  const nextLength = part === "Length" ? Math.max(0, apply2(length, entry)) : length;
+  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) {
@@ -6929,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];
@@ -7020,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, viewToMat3, 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