@weasel-js/geom 1.14.1 → 1.15.0

package/dist/index.js

@@ -3,14 +3,14 @@ export { CORNER_RESTORE_TOLERANCE, cornerTraces, intersectSegments, keepCorners,
 import { createBvh } from './chunk-XXNK4N7Z.js';
 import { PORT_REACH, portControls, portCurvePoints } from './chunk-YQADYJJ7.js';
 export { PORT_REACH } from './chunk-YQADYJJ7.js';
-import { cubicDerivativeAt, cubicCurvatureAt } from './chunk-42TZDN5C.js';
-export { SPIRO_KINDS, combTeeth, cubicCurvatureAt, cubicCurvatureSource, cubicDerivativeAt, curvatureComb, eulerAngleAt, eulerCurvatureAt, eulerCurvatureDerivativesAt, eulerPointAt, fitEulerSegment, isSpiroKind, placeEulerSegment, solveSpiro, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath } from './chunk-42TZDN5C.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, nearestOnQuadratic, nearestOnCubic } from './chunk-2N6OWA7E.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';
@@ -1872,8 +1872,8 @@ function cubicContoursToPath(contours, fillRule = "nonzero") {
   for (const { segs, closed } of contours) {
     if (segs.length === 0) continue;
     b.moveTo(segs[0].c[0], segs[0].c[1]);
-    for (const { c, line } of segs) {
-      if (line) b.lineTo(c[6], c[7]);
+    for (const { c, line: line2 } of segs) {
+      if (line2) b.lineTo(c[6], c[7]);
       else b.curveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
     }
     if (closed) b.close();
@@ -1890,9 +1890,9 @@ function splitSegment(seg, t) {
 function reverseContour(contour) {
   return {
     closed: contour.closed,
-    segs: contour.segs.slice().reverse().map(({ c, line }) => ({
+    segs: contour.segs.slice().reverse().map(({ c, line: line2 }) => ({
       c: [c[6], c[7], c[4], c[5], c[2], c[3], c[0], c[1]],
-      line
+      line: line2
     }))
   };
 }
@@ -1928,7 +1928,7 @@ function collapsed(contour) {
   const [cx, cy] = centroid(contour);
   return {
     closed: contour.closed,
-    segs: contour.segs.map(({ line }) => ({ c: [cx, cy, cx, cy, cx, cy, cx, cy], line }))
+    segs: contour.segs.map(({ line: line2 }) => ({ c: [cx, cy, cx, cy, cx, cy, cx, cy], line: line2 }))
   };
 }
 function centroid(contour) {
@@ -2126,9 +2126,9 @@ function repeatAlongPath(shape, path, opts = {}) {
 }
 
 // src/paths/contourSamples.ts
-function sampleAt({ c, line }, t) {
+function sampleAt({ c, line: line2 }, t) {
   const [x, y] = cubicEvalAt(...c, t);
-  const seg = { line, p0: { x: c[0], y: c[1] }, c1: { x: c[2], y: c[3] }, c2: { x: c[4], y: c[5] }, p3: { x: c[6], y: c[7] } };
+  const seg = { line: line2, p0: { x: c[0], y: c[1] }, c1: { x: c[2], y: c[3] }, c2: { x: c[4], y: c[5] }, p3: { x: c[6], y: c[7] } };
   return { at: { x, y }, dir: tangentAt(seg, t) };
 }
 function sampleContour(contour, pieces) {
@@ -2492,9 +2492,9 @@ function quadrantPoints(segs) {
     const y0 = Math.min(...sub3.map((s) => s.box.y0)), y1 = Math.max(...sub3.map((s) => s.box.y1));
     const cx = (x0 + x1) / 2, cy = (y0 + y1) / 2;
     const across = [[{ x: x0 - 1, y: cy }, { x: x1 + 1, y: cy }], [{ x: cx, y: y0 - 1 }, { x: cx, y: y1 + 1 }]];
-    for (const line of across) {
+    for (const line2 of across) {
       for (const s of sub3) {
-        for (const h of intersectSegments(s.pts, line)) {
+        for (const h of intersectSegments(s.pts, line2)) {
           if (!out.some((p) => Math.hypot(p.x - h.x, p.y - h.y) < 1e-6)) out.push({ x: h.x, y: h.y });
         }
       }
@@ -3134,11 +3134,170 @@ function anchorsInRect(set, rect) {
   return hits;
 }
 
-// src/paths/lengthenPathEnd.ts
+// src/paths/pathEndExtension.ts
+var DEFAULT_EASE_TURN = Math.PI / 6;
 var STRAIGHT_TURN = 1e-6;
-var MIN_KEEP = 1e-3;
 var QUARTER = Math.PI / 2;
 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 easeLength(frame, opts = {}) {
+  const k = Math.abs(frame.curvature);
+  return k > 0 ? 2 * easeTurnOf(opts) / k : Infinity;
+}
+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 arcCenter({ point, tangent, curvature }) {
+  return { x: point.x - tangent.y / curvature, y: point.y + tangent.x / curvature };
+}
+function arcPieces(frame, distance) {
+  const s = Math.sign(frame.curvature);
+  const r = 1 / Math.abs(frame.curvature);
+  const sweep = Math.min(distance / 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;
+  const c = arcCenter(frame);
+  const rx = frame.point.x - c.x;
+  const ry = frame.point.y - c.y;
+  const at2 = (turn) => {
+    const cos = Math.cos(s * turn);
+    const sin = Math.sin(s * turn);
+    return {
+      p: { x: c.x + rx * cos - ry * sin, y: c.y + rx * sin + ry * cos },
+      t: { x: frame.tangent.x * cos - frame.tangent.y * sin, y: frame.tangent.x * sin + frame.tangent.y * cos }
+    };
+  };
+  const out = [];
+  for (let i = 1; i <= count; i++) {
+    const from = at2((i - 1) * step);
+    const to = at2(i * step);
+    out.push({
+      pts: [
+        from.p,
+        { x: from.p.x + from.t.x * reach, y: from.p.y + from.t.y * reach },
+        { x: to.p.x - to.t.x * reach, y: to.p.y - to.t.y * reach },
+        to.p
+      ],
+      length: step * r
+    });
+  }
+  return out;
+}
+function easeSpiral(frame, length2, turn) {
+  const sign2 = Math.sign(frame.curvature);
+  const k0 = sign2 * turn;
+  const k1 = -2 * sign2 * turn;
+  const rotation = Math.atan2(frame.tangent.y, frame.tangent.x) + 3 / 4 * k0;
+  const c = integrateEuler(k0, k1);
+  const seg = {
+    k0,
+    k1,
+    k2: 0,
+    k3: 0,
+    ratio: Math.hypot(c.x, c.y),
+    chordAngle: Math.atan2(c.y, c.x),
+    p0: frame.point,
+    p1: frame.point,
+    length: length2,
+    rotation
+  };
+  return { ...seg, p1: eulerPointAt(seg, 1) };
+}
+function easedPieces(frame, distance, 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 out = fitSpiral(drawn, Math.max(FIT_FLOOR, FIT_SHARE * ease), 0);
+  if (distance > ease) {
+    const a = eulerAngleAt(spiral, 1);
+    out.push(line(spiral.p1, { x: Math.cos(a), y: Math.sin(a) }, distance - ease));
+  }
+  return out;
+}
+function fitSpiral(seg, tol, depth) {
+  const fitted = g2Cubic(seg) ?? eulerSegmentCubic(seg);
+  if (depth < MAX_SPLITS && eulerCubicError(seg, fitted.c1, fitted.c2) > tol) {
+    return [...fitSpiral(spiralPiece(seg, 0, 0.5), tol, depth + 1), ...fitSpiral(spiralPiece(seg, 0.5, 1), tol, depth + 1)];
+  }
+  return [{ pts: [seg.p0, fitted.c1, fitted.c2, seg.p1], length: seg.length }];
+}
+function spiralPiece(seg, s0, s1) {
+  const d = s1 - s0;
+  const m = (s0 + s1) / 2 - 0.5;
+  const k0 = (seg.k0 + seg.k1 * m) * d;
+  const k1 = seg.k1 * d * d;
+  const c = integrateEuler(k0, k1);
+  return {
+    k0,
+    k1,
+    k2: 0,
+    k3: 0,
+    ratio: Math.hypot(c.x, c.y),
+    chordAngle: Math.atan2(c.y, c.x),
+    p0: eulerPointAt(seg, s0),
+    p1: eulerPointAt(seg, s1),
+    length: seg.length * d,
+    rotation: eulerAngleAt(seg, s0) + k0 / 2 - k1 / 8
+  };
+}
+var cross2 = (a, b) => a.x * b.y - a.y * b.x;
+function g2Cubic(seg) {
+  const a0 = eulerAngleAt(seg, 0);
+  const a1 = eulerAngleAt(seg, 1);
+  const u0 = { x: Math.cos(a0), y: Math.sin(a0) };
+  const u1 = { x: Math.cos(a1), y: Math.sin(a1) };
+  const k0 = eulerCurvatureAt(seg, 0);
+  const k1 = eulerCurvatureAt(seg, 1);
+  const d = { x: seg.p1.x - seg.p0.x, y: seg.p1.y - seg.p0.y };
+  const c = cross2(u0, u1);
+  const d0 = cross2(u0, d);
+  const d1 = cross2(d, u1);
+  const chord = Math.hypot(d.x, d.y);
+  if (!(chord > 0) || Math.abs(c) < 1e-9) return null;
+  const start = eulerSegmentCubic(seg);
+  let a = Math.hypot(start.c1.x - seg.p0.x, start.c1.y - seg.p0.y);
+  let b = Math.hypot(start.c2.x - seg.p1.x, start.c2.y - seg.p1.y);
+  for (let i = 0; i < 30; i++) {
+    const f02 = 1.5 * k0 * a * a - d0 + b * c;
+    const f12 = 1.5 * k1 * b * b - d1 + a * c;
+    if (Math.abs(f02) + Math.abs(f12) < 1e-12 * chord * chord) break;
+    const j00 = 3 * k0 * a, j11 = 3 * k1 * b;
+    const det = j00 * j11 - c * c;
+    if (Math.abs(det) < 1e-18) return null;
+    a -= (f02 * j11 - f12 * c) / det;
+    b -= (j00 * f12 - c * f02) / det;
+  }
+  const f0 = 1.5 * k0 * a * a - d0 + b * c;
+  const f1 = 1.5 * k1 * b * b - d1 + a * c;
+  if (!(a > 0 && b > 0) || Math.abs(f0) + Math.abs(f1) > 1e-9 * chord * chord) return null;
+  return {
+    c1: { x: seg.p0.x + a * u0.x, y: seg.p0.y + a * u0.y },
+    c2: { x: seg.p1.x - b * u1.x, y: seg.p1.y - b * u1.y }
+  };
+}
+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;
+}
+
+// src/paths/lengthenPathEnd.ts
+var MIN_KEEP = 1e-3;
+var FULL2 = 2 * Math.PI;
 function openEndAt(set, flatIndex) {
   const loc = locateAnchor(set, flatIndex);
   if (!loc || set.closed[loc.sub]) return null;
@@ -3156,25 +3315,27 @@ function pathEndAnchorIndex(set, end) {
 function pathEndFrame(set, end) {
   return atTail(set, end, tailFrame) ?? null;
 }
-function lengthenPathEnd(set, end, distance, mode) {
+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)) ?? false;
+  return atTail(set, end, (sub3) => distance < 0 ? trimTail(sub3, -distance) : growTail(sub3, distance, mode, opts)) ?? false;
 }
-function lengthToward(set, end, mode, point, near2 = 0) {
+function lengthToward(set, end, mode, point, near2 = 0, opts = {}) {
   const frame = pathEndFrame(set, end);
   if (!frame) return 0;
   const { point: p, tangent: t, curvature } = frame;
   const vx = point.x - p.x;
   const vy = point.y - p.y;
-  if (mode === "tangent" || curvature === 0) return vx * t.x + vy * t.y;
+  const ahead = vx * t.x + vy * t.y;
+  if (mode === "tangent" || curvature === 0 || mode === "eased" && ahead <= 0) return ahead;
+  if (mode === "eased") return lengthAlongEased(frame, point, opts);
   const s = Math.sign(curvature);
   const r = 1 / Math.abs(curvature);
-  const c = arcCenter(frame);
+  const c = arcCenter2(frame);
   const ax = p.x - c.x, ay = p.y - c.y;
   const bx = point.x - c.x, by = point.y - c.y;
   const angle = s * Math.atan2(ax * by - ay * bx, ax * bx + ay * by);
-  const turns = Math.round((near2 / r - angle) / FULL);
-  return (angle + turns * FULL) * r;
+  const turns = Math.round((near2 / r - angle) / FULL2);
+  return (angle + turns * FULL2) * r;
 }
 function atTail(set, end, edit) {
   const sub3 = set.anchors[end.sub];
@@ -3216,50 +3377,45 @@ function frameHeading(point, dx2, dy2, curvature) {
   if (!(len > 1e-9)) return null;
   return { point, tangent: { x: dx2 / len, y: dy2 / len }, curvature };
 }
-function arcCenter({ point, tangent, curvature }) {
+function arcCenter2({ point, tangent, curvature }) {
   return { x: point.x - tangent.y / curvature, y: point.y + tangent.x / curvature };
 }
-function growTail(sub3, distance, mode) {
+function lengthAlongEased(frame, point, opts) {
+  const far = Math.hypot(point.x - frame.point.x, point.y - frame.point.y);
+  const reach = Math.min(easeLength(frame, opts), far * 2) + far;
+  let best = { dist: Infinity, length: 0 };
+  let walked = 0;
+  for (const piece of extensionPieces(frame, reach, "eased", opts)) {
+    const [q0, q1, q2, q3] = piece.pts;
+    const hit = piece.pts.length === 2 ? nearestOnLine(point.x, point.y, q0.x, q0.y, q1.x, q1.y) : nearestOnCubic(point.x, point.y, q0.x, q0.y, q1.x, q1.y, q2.x, q2.y, q3.x, q3.y);
+    if (hit.dist < best.dist) best = { dist: hit.dist, length: walked + pieceLengthAt(piece, hit.t) };
+    walked += piece.length;
+  }
+  return best.length;
+}
+function growTail(sub3, distance, mode, opts) {
   const frame = tailFrame(sub3);
   if (!frame) return false;
-  if (mode === "curvature" && Math.abs(frame.curvature) * distance > STRAIGHT_TURN) {
-    appendArc(sub3, frame, distance);
-    return true;
-  }
-  const to = { x: frame.point.x + frame.tangent.x * distance, y: frame.point.y + frame.tangent.y * distance };
+  const pieces = extensionPieces(frame, distance, mode, opts);
   const end = sub3[sub3.length - 1];
-  if (isStraightSegment(sub3[sub3.length - 2], end)) {
-    end.x = to.x;
-    end.y = to.y;
-  } else {
-    sub3.push(to);
+  const first = pieces[0];
+  if (pieces.length === 1 && first.pts.length === 2 && isStraightSegment(sub3[sub3.length - 2], end)) {
+    end.x = first.pts[1].x;
+    end.y = first.pts[1].y;
+    return true;
   }
-  return true;
+  appendPieces(sub3, pieces);
+  return pieces.length > 0;
 }
-function appendArc(sub3, frame, distance) {
-  const s = Math.sign(frame.curvature);
-  const r = 1 / Math.abs(frame.curvature);
-  const sweep = Math.min(distance / r, FULL);
-  const pieces = Math.max(1, Math.ceil(sweep / QUARTER - 1e-9));
-  const step = sweep / pieces;
-  const reach = 4 / 3 * Math.tan(step / 4) * r;
-  const c = arcCenter(frame);
-  const rx = frame.point.x - c.x;
-  const ry = frame.point.y - c.y;
-  const at2 = (turn) => {
-    const cos = Math.cos(s * turn);
-    const sin = Math.sin(s * turn);
-    return {
-      p: { x: c.x + rx * cos - ry * sin, y: c.y + rx * sin + ry * cos },
-      t: { x: frame.tangent.x * cos - frame.tangent.y * sin, y: frame.tangent.x * sin + frame.tangent.y * cos }
-    };
-  };
+function appendPieces(sub3, pieces) {
   let prev = sub3[sub3.length - 1];
-  for (let i = 1; i <= pieces; i++) {
-    const from = at2((i - 1) * step);
-    const to = at2(i * step);
-    prev.outHandle = { x: from.p.x + from.t.x * reach, y: from.p.y + from.t.y * reach };
-    const next = { x: to.p.x, y: to.p.y, inHandle: { x: to.p.x - to.t.x * reach, y: to.p.y - to.t.y * reach } };
+  for (const { pts } of pieces) {
+    const to = pts[pts.length - 1];
+    const next = { x: to.x, y: to.y };
+    if (pts.length === 4) {
+      prev.outHandle = { ...pts[1] };
+      next.inHandle = { ...pts[2] };
+    }
     sub3.push(next);
     prev = next;
   }
@@ -3323,33 +3479,41 @@ 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) {
+function lengthenOpenEnd(path, end, distance, mode = "tangent", opts = {}) {
   if (!(distance > 0) || path.kind !== "polygon") return null;
-  return editAnchorSetTracked(path, (set) => lengthenPathEnd(set, end, distance, "tangent"))?.path ?? null;
+  return editAnchorSetTracked(path, (set) => lengthenPathEnd(set, end, distance, mode, opts))?.path ?? null;
 }
 function extendToMeet(path, boundaries, end, opts = {}) {
-  const ray = openEndRay(path, end);
-  if (!ray || path.kind !== "polygon") return null;
+  if (path.kind !== "polygon") return null;
+  const frame = pathEndFrame(pathToAnchors(path), end);
+  if (!frame) return null;
+  const mode = opts.mode ?? "eased";
   const all = [...boundaries.flatMap((b) => pathSegments(b)), ...segmentsBesideEnd(path, end)];
   let reach = opts.maxDistance ?? 0;
   if (opts.maxDistance === void 0) {
     for (const s of all) {
-      for (const p of s.pts) reach = Math.max(reach, Math.hypot(p.x - ray.at.x, p.y - ray.at.y));
+      for (const p of s.pts) reach = Math.max(reach, Math.hypot(p.x - frame.point.x, p.y - frame.point.y));
     }
+    if (mode === "eased") reach += Math.min(easeLength(frame, opts), reach);
+    if (mode === "curvature") reach = Infinity;
   }
   if (!(reach > 0)) return null;
-  const line = [ray.at, { x: ray.at.x + ray.dir.x * reach, y: ray.at.y + ray.dir.y * reach }];
-  let best = Infinity;
-  for (const s of all) {
-    for (const h of intersectSegments(line, s.pts)) {
-      const d = h.ta * reach;
-      if (d > 1e-6 && d < best) best = d;
+  let best = null;
+  let walked = 0;
+  for (const piece of extensionPieces(frame, reach, mode, opts)) {
+    for (const s of all) {
+      for (const h of intersectSegments(piece.pts, s.pts)) {
+        const d = walked + pieceLengthAt(piece, h.ta);
+        if (d > 1e-6 && (best === null || d < best)) best = d;
+      }
     }
+    if (best !== null) break;
+    walked += piece.length;
   }
-  if (!Number.isFinite(best)) return null;
-  const next = lengthenOpenEnd(path, end, best);
-  if (!next) return null;
-  return { path: next, at: { x: ray.at.x + ray.dir.x * best, y: ray.at.y + ray.dir.y * best }, distance: best };
+  if (best === null) return null;
+  const next = lengthenOpenEnd(path, end, best, mode, opts);
+  const at2 = next && pathEndFrame(pathToAnchors(next), end)?.point;
+  return next && at2 ? { path: next, at: at2, distance: best } : null;
 }
 
 // src/paths/simplifyPath.ts
@@ -3522,16 +3686,16 @@ function joinPieces(prev, next, v, tin, tout, ctx) {
   const a = endOf(prev.pieces.at(-1)), b = startOf(next.pieces[0]);
   const gap = Math.hypot(b[0] - a[0], b[1] - a[1]);
   if (gap <= ctx.tol * 1e-3) return [];
-  const cross2 = tin[0] * tout[1] - tin[1] * tout[0];
+  const cross3 = tin[0] * tout[1] - tin[1] * tout[0];
   const dot3 = tin[0] * tout[0] + tin[1] * tout[1];
-  const convex = ctx.sigma * cross2 > 0 || Math.abs(cross2) < 1e-9 && dot3 < 0;
+  const convex = ctx.sigma * cross3 > 0 || Math.abs(cross3) < 1e-9 && dot3 < 0;
   if (gap <= ctx.tol) return snap(prev, next, a);
   if (!convex) {
     if (trimAtCrossing(prev, next)) return [];
     return [lineSegment(a[0], a[1], v[0], v[1]), lineSegment(v[0], v[1], b[0], b[1])];
   }
   const nin = normal(tin, ctx.sigma), nout = normal(tout, ctx.sigma);
-  if (ctx.join === "round") return arc(v, ctx.d, nin, Math.atan2(cross2, dot3));
+  if (ctx.join === "round") return arc(v, ctx.d, nin, Math.atan2(cross3, dot3));
   const cos = nin[0] * nout[0] + nin[1] * nout[1];
   if (1 + cos < 1e-9 || Math.sqrt(2 / (1 + cos)) > ctx.miterLimit) return [lineSegment(a[0], a[1], b[0], b[1])];
   const k = ctx.d / (1 + cos);
@@ -3879,13 +4043,13 @@ function reversed2(s) {
 function flattenAll(segs, tol) {
   const rings = [];
   let ring = [];
-  for (const { c, line } of segs) {
+  for (const { c, line: line2 } of segs) {
     if (ring.length === 0) ring.push(c[0], c[1]);
     else if (ring[ring.length - 2] !== c[0] || ring[ring.length - 1] !== c[1]) {
       rings.push(ring);
       ring = [c[0], c[1]];
     }
-    if (line) ring.push(c[6], c[7]);
+    if (line2) ring.push(c[6], c[7]);
     else flattenCubic(...c, tol, ring);
   }
   if (ring.length > 0) rings.push(ring);
@@ -3943,9 +4107,9 @@ function emit(b, ring) {
   if (ring.length === 0) return;
   const [x0, y0] = ring[0].c;
   b.moveTo(x0, y0);
-  for (const [i, { c, line }] of ring.entries()) {
-    if (line && i === ring.length - 1 && c[6] === x0 && c[7] === y0) break;
-    if (line) b.lineTo(c[6], c[7]);
+  for (const [i, { c, line: line2 }] of ring.entries()) {
+    if (line2 && i === ring.length - 1 && c[6] === x0 && c[7] === y0) break;
+    if (line2) b.lineTo(c[6], c[7]);
     else b.curveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
   }
   b.close();
@@ -4202,17 +4366,17 @@ function worst(samples, dist) {
 
 // src/paths/extremaAnchors.ts
 var END_SLOP = 1e-4;
-function segmentExtremaTs(a, b) {
+function segmentExtremaTs(a, b, axes = "xy") {
   if (isStraightSegment(a, b)) return [];
   const c1 = a.outHandle ?? a;
   const c2 = b.inHandle ?? b;
   const ts = [
-    ...cubicAxisExtremaTs(a.x, c1.x, c2.x, b.x),
-    ...cubicAxisExtremaTs(a.y, c1.y, c2.y, b.y)
+    ...axes === "y" ? [] : cubicAxisExtremaTs(a.x, c1.x, c2.x, b.x),
+    ...axes === "x" ? [] : cubicAxisExtremaTs(a.y, c1.y, c2.y, b.y)
   ].filter((t) => t > END_SLOP && t < 1 - END_SLOP).sort((p, q) => p - q);
   return ts.filter((t, i) => i === 0 || t - ts[i - 1] > END_SLOP);
 }
-function addExtremaAnchors(set, include) {
+function addExtremaAnchors(set, include, axes = "xy") {
   const added = /* @__PURE__ */ new Set();
   set.anchors.forEach((sub3, s) => {
     const segCount = sub3.length - (set.closed[s] && sub3.length > 1 ? 0 : 1);
@@ -4221,7 +4385,7 @@ function addExtremaAnchors(set, include) {
       const ends = segmentEnds(set.anchors, set.closed, s, segIdx);
       if (!ends) continue;
       let end = 1;
-      for (const t of segmentExtremaTs(ends.a, ends.b).reverse()) {
+      for (const t of segmentExtremaTs(ends.a, ends.b, axes).reverse()) {
         const at2 = insertAnchorOnSegment(set, { sub: s, segIdx, t: t / end });
         if (at2 >= 0) added.add(sub3[segIdx + 1]);
         end = t;
@@ -5565,7 +5729,8 @@ function scaledFrom(anchor, handle, k) {
 // src/paths/harmonize.ts
 var MAX_PASSES = 64;
 var SETTLED = 1e-12;
-var UNCHANGED = 1e-6;
+var UNCHANGED = 1e-4;
+var UNCHANGED_STEPS = 64;
 function harmonizeAnchors(set, flatIndexes) {
   const targets = flatIndexes ? [...new Set(flatIndexes)] : Array.from({ length: anchorCount(set) }, (_, i) => i);
   const located = targets.map((flat) => locateAnchor(set, flat)).filter((loc) => loc !== null);
@@ -5588,7 +5753,9 @@ function harmonizeAnchors(set, flatIndexes) {
 function movedFar(a, from, to) {
   if (!from || !to || from === to) return false;
   const len = Math.hypot(from.x - a.x, from.y - a.y);
-  return Math.hypot(to.x - from.x, to.y - from.y) > UNCHANGED * Math.max(len, 1e-9);
+  const magnitude = Math.max(Math.abs(from.x), Math.abs(from.y), Math.abs(a.x), Math.abs(a.y));
+  const tolerance = Math.max(UNCHANGED * len, UNCHANGED_STEPS * magnitude * 2 ** -23, 1e-9);
+  return Math.hypot(to.x - from.x, to.y - from.y) > tolerance;
 }
 function harmonizeOne(set, sub3, idx) {
   const anchors = set.anchors[sub3];
@@ -5803,7 +5970,7 @@ function lengthOf(x, s, grad, row, sign2) {
   if (grad && len > 1e-12) segmentGrad(grad, row, s, sign2 * ux / len, sign2 * uy / len);
   return len;
 }
-function angleRow(x, s, cross2, grad, row) {
+function angleRow(x, s, cross3, grad, row) {
   const ux = dx(x, s[0]);
   const uy = dy(x, s[0]);
   const vx = dx(x, s[1]);
@@ -5812,10 +5979,10 @@ function angleRow(x, s, cross2, grad, row) {
   const vv = vx * vx + vy * vy;
   const scale3 = Math.sqrt(Math.sqrt(uu) * Math.sqrt(vv));
   if (scale3 < 1e-9) return 0;
-  const g = cross2 ? ux * vy - uy * vx : ux * vx + uy * vy;
+  const g = cross3 ? ux * vy - uy * vx : ux * vx + uy * vy;
   const f = g / scale3;
   if (grad) {
-    const [gux, guy, gvx, gvy] = cross2 ? [vy, -vx, -uy, ux] : [vx, vy, ux, uy];
+    const [gux, guy, gvx, gvy] = cross3 ? [vy, -vx, -uy, ux] : [vx, vy, ux, uy];
     segmentGrad(grad, row, s[0], gux / scale3 - f / 2 * (ux / uu), guy / scale3 - f / 2 * (uy / uu));
     segmentGrad(grad, row, s[1], gvx / scale3 - f / 2 * (vx / vv), gvy / scale3 - f / 2 * (vy / vv));
   }
@@ -6853,6 +7020,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, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSet, editAnchorSetTracked, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, 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, viewToMat3, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField, zigzagPath };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map