@weasel-js/geom 1.15.0 → 1.15.2

package/dist/index.js

@@ -1,29 +1,45 @@
-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-OQP5M5VD.js';
+export { CORNER_RESTORE_TOLERANCE, cornerTraces, intersectSegments, keepCorners, restoreCorners } from './chunk-OQP5M5VD.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, 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 { 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';
+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 +103,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 +120,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 +147,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 +162,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,18 +171,16 @@ 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) {
   const simpson = (u0, u1) => {
@@ -180,7 +192,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 +204,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 +222,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 +242,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 +257,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 } = lengthTable(e, sweep);
   const offsetPast = (f) => {
     if (raw === 0) return offsetAt((f % 1 + 1) % 1);
     let u = f * sweep;
     for (let i = 0; i < 8; i++) {
       const v = speed(e, u);
       if (!(v > 0)) break;
-      u -= (lengthTo(u) - f * length2) / v;
+      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,16 +284,16 @@ 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 });
@@ -413,22 +425,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 };
@@ -556,7 +568,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 +603,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 +623,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 +646,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 +686,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 +713,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
@@ -1128,8 +1139,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 +1157,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 }));
@@ -2341,14 +2352,14 @@ function segmentLength(s, a = 0, b = 1) {
   }
   return sum * h / 2;
 }
-function segmentTAtLength(s, length2) {
+function segmentTAtLength(s, length) {
   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;
+  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) - length2;
+    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;
@@ -2559,8 +2570,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];
@@ -3142,12 +3153,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 +3168,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 +3208,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 +3223,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;
 }
@@ -3315,9 +3326,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 +3404,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)) {
@@ -3479,9 +3490,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;
@@ -3649,12 +3660,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 +3898,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 +3932,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;
@@ -4221,21 +4231,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) };
   };
   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);
@@ -5189,17 +5199,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 +5327,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 +5338,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 +5486,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 +5584,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 +5634,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 +5661,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 +5691,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 +5719,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,10 +6914,10 @@ 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 nextLength = part === "Length" ? Math.max(0, apply2(length, entry)) : length;
   const rad = nextAngle * Math.PI / 180;
   return { x: a.x + Math.cos(rad) * nextLength, y: a.y - Math.sin(rad) * nextLength };
 }
@@ -7020,6 +7017,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, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map