@weasel-js/geom 1.11.0 → 1.11.1

package/dist/index.js

@@ -1,18 +1,18 @@
-import { carryCorners, evalSeg, parseSubpaths, keepCorners, anchorRange, subSeg, writePath, derivSeg } from './chunk-7KLJZFBY.js';
-export { CORNER_RESTORE_TOLERANCE, cornerTraces, keepCorners, restoreCorners } from './chunk-7KLJZFBY.js';
+import { carryCorners, evalSeg, parseSubpaths, keepCorners, anchorRange, subSeg, writePath, derivSeg } from './chunk-4Y67BZL5.js';
+export { CORNER_RESTORE_TOLERANCE, cornerTraces, keepCorners, restoreCorners } from './chunk-4Y67BZL5.js';
 import { PORT_REACH, portControls, portCurvePoints } from './chunk-YQADYJJ7.js';
 export { PORT_REACH } from './chunk-YQADYJJ7.js';
 import { cubicDerivativeAt, cubicCurvatureAt } from './chunk-UI3FUWXM.js';
 export { SPIRO_KINDS, combTeeth, cubicCurvatureAt, cubicCurvatureSource, cubicDerivativeAt, curvatureComb, eulerAngleAt, eulerCurvatureAt, eulerCurvatureDerivativesAt, eulerPointAt, fitEulerSegment, isSpiroKind, placeEulerSegment, solveSpiro, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath } from './chunk-UI3FUWXM.js';
-import { extractPolylines } from './chunk-6XSJY3TC.js';
-import { boundsOfPath, fitPointRun, keepCorner } from './chunk-HGF5OVEN.js';
-export { boundsOfPath } from './chunk-HGF5OVEN.js';
+import { extractPolylines } from './chunk-7F66PQCJ.js';
+import { boundsOfPath, fitPointRun, keepCorner } from './chunk-6FGQML7D.js';
+export { boundsOfPath } from './chunk-6FGQML7D.js';
 import { countPathAnchors, pathToAnchors, anchorsToPath, isAnchorSmooth, segmentEnds, isStraightSegment, nearestSegmentT } from './chunk-Q66NA2FU.js';
 export { anchorsToPath, countPathAnchors, isAnchorSmooth, isStraightSegment, nearestSegmentT, pathToAnchors, segmentEnds } from './chunk-Q66NA2FU.js';
 import { nearestOnPath, nearestOnLine, nearestOnQuadratic, nearestOnCubic } from './chunk-CE7IY7TB.js';
 export { nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic } from './chunk-CE7IY7TB.js';
-import { pointInPolygon, resolveCorners, cornerCuts, fillsOpenSubpaths, schneiderFit, fitCubicWithTangents, pointSegmentDist2, flattenQuadratic, flattenCubic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross } from './chunk-J2O2B54M.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-J2O2B54M.js';
+import { pointInPolygon, resolveCorners, cornerCuts, fillsOpenSubpaths, schneiderFit, fitCubicWithTangents, flattenCubic, pointSegmentDist2, flattenQuadratic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross } from './chunk-EAKE3N7W.js';
+export { CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, DEFAULT_FLATTEN_TOLERANCE, cornerCenter, cornerCuts, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerShapePoint, defaultOpenFill, fillsOpenSubpaths, fitCubicWithTangents, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, isCornerShape, nextCornerShape, pointInPolygon, pointSegmentDist2, remapPerAnchor, resolveCorners, resolveCornersWithSources, schneiderFit, segmentsCross, setDefaultOpenFill } from './chunk-EAKE3N7W.js';
 import { SINGULAR_RATIO } from './chunk-755Y4YZS.js';
 export { EPS, approxEq, clamp, cross, dot, len2, sign, sub } from './chunk-755Y4YZS.js';
 import { PathBuilder, withCorner, scaleCorners, forEachSegment, pathCommandCoordCount, withoutCorners, PATH_M, PATH_Z, PATH_L, PATH_C, PATH_Q, elevateQuadraticToCubic, cubicEvalAt, cubicPointAt, splitCubicAtT, cubicAxisExtremaTs, rectToContour, splitCubicAt } from './chunk-B53BERKG.js';
@@ -270,7 +270,7 @@ function pointInPath(path, x, y, opts = {}) {
     return x >= path.x && x <= path.x + path.width && y >= path.y && y <= path.y + path.height;
   }
   let crossings = 0;
-  let winding = 0;
+  let winding2 = 0;
   for (const sub3 of closedSubpaths(path, opts)) {
     const n = sub3.length;
     for (let i = 0; i < n; i += 2) {
@@ -280,10 +280,10 @@ function pointInPath(path, x, y, opts = {}) {
       const ax = sub3[i], bx = sub3[j];
       if (x >= ax + (y - ay) / (by - ay) * (bx - ax)) continue;
       crossings++;
-      winding += ay <= y ? 1 : -1;
+      winding2 += ay <= y ? 1 : -1;
     }
   }
-  return path.fillRule === "evenodd" ? (crossings & 1) === 1 : winding !== 0;
+  return path.fillRule === "evenodd" ? (crossings & 1) === 1 : winding2 !== 0;
 }
 function strokeHitTest(path, x, y, threshold, opts = {}) {
   const slop = opts.slop;
@@ -620,7 +620,7 @@ function splitSubpaths(path) {
   let coordStart = 0;
   let anchorStart = 0;
   let anchors = 0;
-  const emit = (end, coordEnd) => {
+  const emit2 = (end, coordEnd) => {
     const sub3 = { ...bare, commands: commands.slice(cmdStart, end), coords: coords.slice(coordStart, coordEnd) };
     const count = anchors - anchorStart;
     out.push(path.corners ? carryCorners(path, sub3, anchorRange(anchorStart, count)) : sub3);
@@ -628,13 +628,13 @@ function splitSubpaths(path) {
   };
   forEachSegment(commands, coords, (cmd, ci, _px, _py, i) => {
     if (cmd === PATH_M && i > cmdStart) {
-      emit(i, ci);
+      emit2(i, ci);
       cmdStart = i;
       coordStart = ci;
     }
     if (cmd !== PATH_Z) anchors++;
   });
-  emit(commands.length, coords.length);
+  emit2(commands.length, coords.length);
   return out;
 }
 
@@ -812,8 +812,8 @@ function reversePath(path) {
     anchor++;
   });
   flush(false);
-  const reversed2 = { ...path, commands: new Uint8Array(cmds), coords: new Float32Array(out) };
-  return path.corners ? carryCorners(path, reversed2, sources) : reversed2;
+  const reversed3 = { ...path, commands: new Uint8Array(cmds), coords: new Float32Array(out) };
+  return path.corners ? carryCorners(path, reversed3, sources) : reversed3;
 }
 
 // src/paths/pathFromD.ts
@@ -1074,9 +1074,9 @@ function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep,
     rys = ryFixed * ryFixed;
   }
   const sign2 = largeArc === sweep ? -1 : 1;
-  const num = rxs * rys - rxs * y1ps - rys * x1ps;
+  const num2 = rxs * rys - rxs * y1ps - rys * x1ps;
   const den = rxs * y1ps + rys * x1ps;
-  const factor = sign2 * Math.sqrt(Math.max(0, num / den));
+  const factor = sign2 * Math.sqrt(Math.max(0, num2 / den));
   const cxp = factor * (rxFixed * y1p) / ryFixed;
   const cyp = factor * -(ryFixed * x1p) / rxFixed;
   const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
@@ -1124,6 +1124,41 @@ function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep,
   }
 }
 
+// src/paths/pathToD.ts
+var num = (n) => Number.isFinite(n) ? String(Math.round(n * 1e6) / 1e6) : "0";
+function pathToD(given) {
+  const path = resolveCorners(given);
+  if (path.kind === "rect") {
+    const { x, y, width, height } = path;
+    return `M${num(x)} ${num(y)}h${num(width)}v${num(height)}h${num(-width)}Z`;
+  }
+  const cmds = path.commands;
+  const xs = path.coords;
+  const out = [];
+  let ci = 0;
+  for (let i = 0; i < cmds.length; i++) {
+    const c = cmds[i];
+    if (c === PATH_M) {
+      out.push(`M${num(xs[ci])} ${num(xs[ci + 1])}`);
+      ci += 2;
+    } else if (c === PATH_L) {
+      out.push(`L${num(xs[ci])} ${num(xs[ci + 1])}`);
+      ci += 2;
+    } else if (c === PATH_C) {
+      out.push(
+        `C${num(xs[ci])} ${num(xs[ci + 1])} ${num(xs[ci + 2])} ${num(xs[ci + 3])} ${num(xs[ci + 4])} ${num(xs[ci + 5])}`
+      );
+      ci += 6;
+    } else if (c === PATH_Q) {
+      out.push(`Q${num(xs[ci])} ${num(xs[ci + 1])} ${num(xs[ci + 2])} ${num(xs[ci + 3])}`);
+      ci += 4;
+    } else if (c === PATH_Z) {
+      out.push("Z");
+    }
+  }
+  return out.join("");
+}
+
 // src/paths/pathMeasure.ts
 function measurePath(path, opts = {}) {
   const polylines = extractPolylines(
@@ -1162,7 +1197,17 @@ function measurePath(path, opts = {}) {
   const origin = first;
   const closed = contours === 1 && lastClosed;
   if (segments.length === 0) {
-    return { length: 0, closed, at: () => ({ point: { ...origin }, tangent: { x: 1, y: 0 } }) };
+    return {
+      length: 0,
+      closed,
+      at: () => ({ point: { ...origin }, tangent: { x: 1, y: 0 } }),
+      nearest: (p) => ({
+        s: 0,
+        dist: Math.hypot(p.x - origin.x, p.y - origin.y),
+        point: { ...origin },
+        tangent: { x: 1, y: 0 }
+      })
+    };
   }
   return {
     length: total,
@@ -1177,6 +1222,26 @@ function measurePath(path, opts = {}) {
       const y = seg.t0y + (seg.t1y - seg.t0y) * u;
       const l = Math.hypot(x, y);
       return { point, tangent: l === 0 ? { x: seg.tx, y: seg.ty } : { x: x / l, y: y / l } };
+    },
+    nearest(p) {
+      let best = segments[0];
+      let bestU = 0;
+      let bestDist = Infinity;
+      for (const seg of segments) {
+        const u = Math.min(Math.max(((p.x - seg.ax) * seg.tx + (p.y - seg.ay) * seg.ty) / seg.len, 0), 1);
+        const d = Math.hypot(p.x - (seg.ax + (seg.bx - seg.ax) * u), p.y - (seg.ay + (seg.by - seg.ay) * u));
+        if (d < bestDist) {
+          best = seg;
+          bestU = u;
+          bestDist = d;
+        }
+      }
+      return {
+        s: best.start + best.len * bestU,
+        dist: bestDist,
+        point: { x: best.ax + (best.bx - best.ax) * bestU, y: best.ay + (best.by - best.ay) * bestU },
+        tangent: { x: best.tx, y: best.ty }
+      };
     }
   };
 }
@@ -1381,13 +1446,13 @@ function matchContours(a, b, opts) {
   const offset2 = Math.round(opts.startOffset ?? 0);
   const directions = opts.reverse !== void 0 ? [opts.reverse] : auto ? [false, true] : [false];
   let best = null;
-  for (const reversed2 of directions) {
-    const run3 = reversed2 ? reverseContour(y) : y;
+  for (const reversed3 of directions) {
+    const run3 = reversed3 ? reverseContour(y) : y;
     const turns = closed && auto ? run3.segs.length : 1;
     for (let k = 0; k < turns; k++) {
       const [ma, mb] = equalize(x, rotate2(run3, k));
       const score = auto ? correspondence(ma, mb) : 0;
-      if (best === null || score < best.score - 1e-9) best = { score, a: ma, b: mb, reversed: reversed2, turn: k };
+      if (best === null || score < best.score - 1e-9) best = { score, a: ma, b: mb, reversed: reversed3, turn: k };
     }
   }
   const chosen = best;
@@ -3110,6 +3175,243 @@ function emitContour(b, grown) {
   b.close();
 }
 
+// src/paths/segmentCrossings.ts
+var STEPS = 16;
+var END2 = 1e-7;
+function segmentCrossings(segs) {
+  const flat = segs.map((s) => flatten2(s));
+  const boxes = flat.map(boxOf2);
+  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;
+      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++) {
+          const hit = linesCross(pa[i], pa[i + 1], pb[j], pb[j + 1]);
+          if (hit === null) continue;
+          const guess = [(i + hit[0]) / (pa.length - 1), (j + hit[1]) / (pb.length - 1)];
+          const [s, t] = segs[a].line && segs[b].line ? guess : refine2(segs[a].c, segs[b].c, guess);
+          if (atEnd(s) && atEnd(t)) continue;
+          if (out.some((x) => x.a === a && x.b === b && Math.abs(x.s - s) < 1e-6 && Math.abs(x.t - t) < 1e-6)) continue;
+          out.push({ a, b, s, t });
+        }
+      }
+    }
+  }
+  return out;
+}
+var atEnd = (t) => t < END2 || t > 1 - END2;
+function flatten2(seg) {
+  if (seg.line) return [[seg.c[0], seg.c[1]], [seg.c[6], seg.c[7]]];
+  const out = [];
+  for (let i = 0; i <= STEPS; i++) out.push(cubicEvalAt(...seg.c, i / STEPS));
+  return out;
+}
+function boxOf2(pts) {
+  const b = [Infinity, Infinity, -Infinity, -Infinity];
+  for (const [x, y] of pts) {
+    b[0] = Math.min(b[0], x);
+    b[1] = Math.min(b[1], y);
+    b[2] = Math.max(b[2], x);
+    b[3] = Math.max(b[3], y);
+  }
+  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;
+  if (Math.abs(den) < 1e-18) return null;
+  const u = ((c[0] - a[0]) * sy - (c[1] - a[1]) * sx) / den;
+  const w = ((c[0] - a[0]) * ry - (c[1] - a[1]) * rx) / den;
+  return u >= 0 && u <= 1 && w >= 0 && w <= 1 ? [u, w] : null;
+}
+function refine2(a, b, guess) {
+  const gap = (s2, t2) => {
+    const p = cubicEvalAt(...a, s2), q = cubicEvalAt(...b, t2);
+    return [p[0] - q[0], p[1] - q[1]];
+  };
+  let [s, t] = guess;
+  let f = gap(s, t);
+  const start = Math.hypot(...f);
+  for (let k = 0; k < 8 && Math.hypot(...f) > 1e-13; k++) {
+    const da = derivative2(a, s), db = derivative2(b, t);
+    const det = -da[0] * db[1] + db[0] * da[1];
+    if (Math.abs(det) < 1e-18) break;
+    s = Math.min(1, Math.max(0, s - (-db[1] * f[0] + db[0] * f[1]) / det));
+    t = Math.min(1, Math.max(0, t - (-da[1] * f[0] + da[0] * f[1]) / det));
+    f = gap(s, t);
+  }
+  return Math.hypot(...f) <= start ? [s, t] : guess;
+}
+function derivative2(c, t) {
+  const u = 1 - t;
+  const a = 3 * u * u, b = 6 * u * t, e = 3 * t * t;
+  return [
+    a * (c[2] - c[0]) + b * (c[4] - c[2]) + e * (c[6] - c[4]),
+    a * (c[3] - c[1]) + b * (c[5] - c[3]) + e * (c[7] - c[5])
+  ];
+}
+
+// src/paths/mergeRegion.ts
+function mergeRegion(path, opts = {}) {
+  const tol = opts.tolerance ?? 0.01;
+  const contours = pathToCubicContours(path).filter((c) => c.segs.length > 0);
+  const segs = contours.flatMap((c) => closeContour(c.segs, tol * 1e-3));
+  const fillLeft = pathSignedArea(path) < 0;
+  const cuts = segs.map(() => []);
+  for (const x of segmentCrossings(segs)) {
+    const p = crossingPoint(segs[x.a], x.s, segs[x.b], x.t);
+    cuts[x.a].push({ t: x.s, p });
+    cuts[x.b].push({ t: x.t, p });
+  }
+  const rings = flattenAll(segs, tol / 4);
+  const pieces = [];
+  let changed = false;
+  segs.forEach((seg, i) => {
+    const parts = cutSegment(seg, cuts[i]);
+    if (parts.length > 1) changed = true;
+    for (const part of parts) {
+      const side = filledSide(part, rings, tol);
+      if (side === null) changed = true;
+      else if (side === fillLeft) pieces.push(part);
+      else {
+        changed = true;
+        pieces.push(reversed2(part));
+      }
+    }
+  });
+  const b = new PathBuilder();
+  if (!changed) {
+    for (const c of contours) emit(b, closeContour(c.segs, tol * 1e-3));
+    return b.build();
+  }
+  for (const ring of chain(pieces)) emit(b, ring);
+  return b.build();
+}
+function closeContour(given, snap2) {
+  const short = (s) => s.line && Math.hypot(s.c[6] - s.c[0], s.c[7] - s.c[1]) <= snap2;
+  const segs = given.filter((s) => !short(s));
+  if (segs.length === 0) return [];
+  for (let i = 0; i < segs.length; i++) {
+    const prev = segs[(i + segs.length - 1) % segs.length].c, s = segs[i];
+    if (prev[6] !== s.c[0] || prev[7] !== s.c[1]) {
+      if (Math.hypot(prev[6] - s.c[0], prev[7] - s.c[1]) <= snap2) segs[i] = moveEnds(s, [prev[6], prev[7]], [s.c[6], s.c[7]]);
+      else if (i === 0) segs.push(lineSegment(prev[6], prev[7], s.c[0], s.c[1]));
+    }
+  }
+  return segs;
+}
+function crossingPoint(a, s, b, t) {
+  const end = (seg, u) => u <= 1e-7 ? [seg.c[0], seg.c[1]] : u >= 1 - 1e-7 ? [seg.c[6], seg.c[7]] : null;
+  const fixed = end(a, s) ?? end(b, t);
+  if (fixed) return fixed;
+  const p = cubicEvalAt(...a.c, s), q = cubicEvalAt(...b.c, t);
+  return [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2];
+}
+function cutSegment(seg, cuts) {
+  const inner = cuts.filter((c) => c.t > 1e-7 && c.t < 1 - 1e-7).sort((x, y) => x.t - y.t);
+  const out = [];
+  let rest = seg, from = 0;
+  let start = [seg.c[0], seg.c[1]];
+  for (const cut of inner) {
+    if (cut.t - from < 1e-9) continue;
+    const [l, r] = splitSegment(rest, (cut.t - from) / (1 - from));
+    out.push(moveEnds(l, start, cut.p));
+    rest = r;
+    from = cut.t;
+    start = cut.p;
+  }
+  out.push(moveEnds(rest, start, [seg.c[6], seg.c[7]]));
+  return out;
+}
+function moveEnds(s, a, b) {
+  const c = s.c;
+  return {
+    c: [a[0], a[1], c[2] + a[0] - c[0], c[3] + a[1] - c[1], c[4] + b[0] - c[6], c[5] + b[1] - c[7], b[0], b[1]],
+    line: s.line
+  };
+}
+function reversed2(s) {
+  const c = s.c;
+  return { c: [c[6], c[7], c[4], c[5], c[2], c[3], c[0], c[1]], line: s.line };
+}
+function flattenAll(segs, tol) {
+  const rings = [];
+  let ring = [];
+  for (const { c, line } 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]);
+    else flattenCubic(...c, tol, ring);
+  }
+  if (ring.length > 0) rings.push(ring);
+  return rings;
+}
+function winding(rings, x, y) {
+  let w = 0;
+  for (const r of rings) {
+    for (let i = 0; i + 3 < r.length; i += 2) {
+      const ay = r[i + 1], by = r[i + 3];
+      if (ay > y === by > y) continue;
+      const ax = r[i], bx = r[i + 2];
+      if (x >= ax + (y - ay) / (by - ay) * (bx - ax)) continue;
+      w += ay <= y ? 1 : -1;
+    }
+  }
+  return w;
+}
+function filledSide(seg, rings, tol) {
+  const c = seg.c;
+  const [x, y] = cubicEvalAt(...c, 0.5);
+  const dx2 = c[6] + c[4] - c[2] - c[0], dy2 = c[7] + c[5] - c[3] - c[1];
+  const len = Math.hypot(dx2, dy2);
+  if (len < 1e-12) return null;
+  const nx = dy2 / len * tol, ny = -dx2 / len * tol;
+  const left = winding(rings, x + nx, y + ny) !== 0, right = winding(rings, x - nx, y - ny) !== 0;
+  return left === right ? null : left;
+}
+function chain(pieces) {
+  const key = (x, y) => `${x},${y}`;
+  const from = /* @__PURE__ */ new Map();
+  pieces.forEach((p, i) => {
+    const k = key(p.c[0], p.c[1]);
+    const list = from.get(k);
+    if (list) list.push(i);
+    else from.set(k, [i]);
+  });
+  const used = new Uint8Array(pieces.length);
+  const rings = [];
+  for (let i = 0; i < pieces.length; i++) {
+    if (used[i]) continue;
+    const ring = [];
+    let at2 = i;
+    while (at2 !== void 0 && !used[at2]) {
+      used[at2] = 1;
+      const p = pieces[at2];
+      ring.push(p);
+      at2 = from.get(key(p.c[6], p.c[7]))?.find((j) => !used[j]);
+    }
+    rings.push(ring);
+  }
+  return rings;
+}
+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]);
+    else b.curveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+  }
+  b.close();
+}
+
 // src/paths/simplifyAnchors.ts
 function simplifyAnchorsAt(set, flatIndexes, tolerance, opts = {}) {
   const bySub = /* @__PURE__ */ new Map();
@@ -3164,7 +3466,7 @@ var unit3 = (x, y) => {
   const len = Math.hypot(x, y);
   return len === 0 ? { x: 0, y: 0 } : { x: x / len, y: y / len };
 };
-function derivative2(seg, t) {
+function derivative3(seg, t) {
   const u = 1 - t;
   const { a, c1, c2, b } = seg;
   return {
@@ -3174,8 +3476,8 @@ function derivative2(seg, t) {
 }
 function headingOn(seg, t) {
   if (seg.straight) return unit3(seg.b.x - seg.a.x, seg.b.y - seg.a.y);
-  let d = derivative2(seg, t);
-  if (Math.hypot(d.x, d.y) < 1e-9) d = derivative2(seg, t < 0.5 ? t + 1e-3 : t - 1e-3);
+  let d = derivative3(seg, t);
+  if (Math.hypot(d.x, d.y) < 1e-9) d = derivative3(seg, t < 0.5 ? t + 1e-3 : t - 1e-3);
   const h = unit3(d.x, d.y);
   return h.x === 0 && h.y === 0 ? unit3(seg.b.x - seg.a.x, seg.b.y - seg.a.y) : h;
 }
@@ -4338,7 +4640,7 @@ function smudgePath(path, opts) {
   if (!(radius > 0) || strength === 0 || delta.x === 0 && delta.y === 0) return path;
   const detail = opts.detail ?? radius / 3;
   return editAnchorSet(path, (set) => {
-    refine2(set, center, radius, detail);
+    refine3(set, center, radius, detail);
     let touched = false;
     let flat = 0;
     for (const sub3 of set.anchors) {
@@ -4358,7 +4660,7 @@ function weight(p, c, radius) {
   const u2 = ((p.x - c.x) ** 2 + (p.y - c.y) ** 2) / (radius * radius);
   return u2 >= 1 ? 0 : (1 - u2) ** 2;
 }
-function refine2(set, c, radius, detail) {
+function refine3(set, c, radius, detail) {
   if (!Number.isFinite(detail) || detail <= 0) return;
   let added = 0;
   for (let sub3 = 0; sub3 < set.anchors.length; sub3++) {
@@ -5579,7 +5881,8 @@ function constrainPathsEdit(items, links = []) {
   const sliding = new Set(kept.flatMap((c) => c.kind === "onPath" ? [c.anchor] : []));
   const still = (i) => {
     const { item } = itemOf(i, nowStart);
-    return items.length > 1 && items[item].before === items[item].after && !sliding.has(i);
+    const it = items[item];
+    return items.length > 1 && it.before === it.after && !it.yields && !sliding.has(i);
   };
   const held = nowAll.flatMap((p, i) => {
     const r = reference[i];
@@ -6001,6 +6304,6 @@ function typedArrayReplacer(_key, value) {
   return tagTypedArray(value) ?? value;
 }
 
-export { ANCHOR_FIELDS, CONSTRAINT_TOLERANCE, EASINGS, PATH_SNAP_KINDS, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, addExtremaAnchors, anchorAt, anchorCount, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsInRect, anchorsUnderBrush, anchorsWhere, applyToPoint, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, blendPaths, boxToBox, circlePath, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, createPathSnapIndex, cubicBezierEasing, cubicContoursToPath, decomposePath, deleteAnchorsAt, directionMarks, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSet, editAnchorSetTracked, equalizeSegmentHandles, everyNthAnchor, extendToMeet, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, intersectSegments, invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, lengthToward, lengthenOpenEnd, lengthenPathEnd, linear, locateAnchor, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, moveHandleSymmetric, moveHandleTo, multiply, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, openSubpathAt, pathAnchorPoints, pathAwayFromAnchors, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonIntersectsPath, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, pxExtent, readAnchorFields, rectMarkerPath, remapAnchorValues, remapConstraints, remapPointValues, repeatAlongPath, resamplePath, resolveEasing, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, scale, scaleDelta, scalePathToBounds, scaleSegmentHandles, screenAngleOf, segmentAt2 as segmentAt, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, setSubpathStart, shrinkAnchorSelection, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, stationsAlongPath, strokeHitTest, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField };
+export { ANCHOR_FIELDS, CONSTRAINT_TOLERANCE, EASINGS, PATH_SNAP_KINDS, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, addExtremaAnchors, anchorAt, anchorCount, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsInRect, anchorsUnderBrush, anchorsWhere, applyToPoint, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, blendPaths, boxToBox, circlePath, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, createPathSnapIndex, cubicBezierEasing, cubicContoursToPath, decomposePath, deleteAnchorsAt, directionMarks, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSet, editAnchorSetTracked, equalizeSegmentHandles, everyNthAnchor, extendToMeet, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, intersectSegments, invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, lengthToward, lengthenOpenEnd, lengthenPathEnd, linear, locateAnchor, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, moveHandleTo, multiply, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, openSubpathAt, pathAnchorPoints, pathAwayFromAnchors, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonIntersectsPath, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, pxExtent, readAnchorFields, rectMarkerPath, remapAnchorValues, remapConstraints, remapPointValues, repeatAlongPath, resamplePath, resolveEasing, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, scale, scaleDelta, scalePathToBounds, scaleSegmentHandles, screenAngleOf, segmentAt2 as segmentAt, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, setSubpathStart, shrinkAnchorSelection, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, stationsAlongPath, strokeHitTest, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map