@weasel-js/geom 1.9.4 → 1.10.0

package/dist/index.js

@@ -1,17 +1,17 @@
 import { PORT_REACH, portControls, portCurvePoints } from './chunk-YQADYJJ7.js';
 export { PORT_REACH } from './chunk-YQADYJJ7.js';
-import { cubicPointAt } from './chunk-HPVINMOM.js';
-export { cubicPointAt, fitCubicThroughDeletion, splitCubicAtT } from './chunk-HPVINMOM.js';
+import { cubicPointAt, splitCubicAtT, fitCubicThroughDeletion } from './chunk-XS6ERH3X.js';
+export { cubicPointAt, fitCubicThroughDeletion, splitCubicAtT } from './chunk-XS6ERH3X.js';
 import { cubicEvalAt, elevateQuadraticToCubic, cubicBounds } from './chunk-URQMDR6Q.js';
 export { cubicBounds, cubicEvalAt, elevateQuadraticToCubic, quadraticEvalAt, splitCubicAt, splitLineAt, splitQuadraticAt } from './chunk-URQMDR6Q.js';
-import { extractPolylines } from './chunk-NL423YYZ.js';
-export { boundsOfCoords, boxContainsBox, boxContainsPoint, rectToContour, unionBox } from './chunk-NL423YYZ.js';
-import { DEFAULT_FLATTEN_TOLERANCE, pointInPolygon, pointSegmentDist2, flattenQuadratic, flattenCubic, segmentsCross } from './chunk-X6GJRIQD.js';
-export { DEFAULT_FLATTEN_TOLERANCE, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pointInPolygon, pointSegmentDist2, segmentsCross } from './chunk-X6GJRIQD.js';
-import { SINGULAR_RATIO } from './chunk-N5SYTHMR.js';
-export { EPS, approxEq, clamp, cross, dot, len2, sign, sub } from './chunk-N5SYTHMR.js';
-import { forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z, pathCommandCoordCount } from './chunk-E4TJRGJD.js';
-export { PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, forEachSegment, pathCommandCoordCount } from './chunk-E4TJRGJD.js';
+import { extractPolylines, rectToContour } from './chunk-MDT7F32A.js';
+export { boundsOfCoords, boxContainsBox, boxContainsPoint, rectToContour, unionBox } from './chunk-MDT7F32A.js';
+import { fillsOpenSubpaths, pointInPolygon, pointSegmentDist2, flattenQuadratic, flattenCubic, DEFAULT_FLATTEN_TOLERANCE, segmentsCross } from './chunk-WQMYOCFB.js';
+export { DEFAULT_FLATTEN_TOLERANCE, defaultOpenFill, fillsOpenSubpaths, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pointInPolygon, pointSegmentDist2, segmentsCross, setDefaultOpenFill } from './chunk-WQMYOCFB.js';
+import { SINGULAR_RATIO } from './chunk-755Y4YZS.js';
+export { EPS, approxEq, clamp, cross, dot, len2, sign, sub } from './chunk-755Y4YZS.js';
+import { forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z, pathCommandCoordCount } from './chunk-OXH3NOXC.js';
+export { PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, forEachSegment, pathCommandCoordCount } from './chunk-OXH3NOXC.js';
 
 // src/view.ts
 var ZOOM_FLOOR = 1e-9;
@@ -453,7 +453,7 @@ function translatePolygonCopy(path, dx, dy) {
       next[ci + k + 1] = coords[ci + k + 1] + dy;
     }
   });
-  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
+  return { ...path, coords: next };
 }
 function scalePathToBounds(path, target) {
   if (path.kind === "rect") {
@@ -483,54 +483,74 @@ function pathOrigin(path) {
 
 // src/paths/splitSubpaths.ts
 function splitSubpaths(path) {
-  const { commands, coords, fillRule } = path;
+  const { commands, coords } = path;
   const out = [];
   let cmdStart = 0;
   let coordStart = 0;
   forEachSegment(commands, coords, (cmd, ci, _px, _py, i) => {
     if (cmd !== PATH_M || i <= cmdStart) return;
-    out.push({
-      kind: "polygon",
-      commands: commands.slice(cmdStart, i),
-      coords: coords.slice(coordStart, ci),
-      fillRule
-    });
+    out.push({ ...path, commands: commands.slice(cmdStart, i), coords: coords.slice(coordStart, ci) });
     cmdStart = i;
     coordStart = ci;
   });
-  out.push({
-    kind: "polygon",
-    commands: commands.slice(cmdStart),
-    coords: coords.slice(coordStart),
-    fillRule
-  });
+  out.push({ ...path, commands: commands.slice(cmdStart), coords: coords.slice(coordStart) });
   return out;
 }
 
+// src/paths/splitByClosure.ts
+var endsInZ = (sub3) => sub3.commands[sub3.commands.length - 1] === PATH_Z;
+function hasOpenSubpath(path) {
+  return path.kind === "polygon" && path.commands.length > 0 && splitSubpaths(path).some((sub3) => !endsInZ(sub3));
+}
+function splitByClosure(path) {
+  const closed = [];
+  const open = [];
+  if (path.commands.length > 0) {
+    for (const sub3 of splitSubpaths(path)) (endsInZ(sub3) ? closed : open).push(sub3);
+  }
+  const join = (subs) => {
+    if (subs.length === 0) return null;
+    const commands = new Uint8Array(subs.reduce((n, s) => n + s.commands.length, 0));
+    const coords = new Float32Array(subs.reduce((n, s) => n + s.coords.length, 0));
+    let ci = 0, xi = 0;
+    for (const s of subs) {
+      commands.set(s.commands, ci);
+      coords.set(s.coords, xi);
+      ci += s.commands.length;
+      xi += s.coords.length;
+    }
+    return { ...path, commands, coords };
+  };
+  return { closed: join(closed), open: join(open) };
+}
+
 // src/paths/winding.ts
 var GL_T = [0.5 - Math.sqrt(15) / 10, 0.5, 0.5 + Math.sqrt(15) / 10];
 var GL_W = [5 / 18, 8 / 18, 5 / 18];
 function pathSignedArea(path) {
   if (path.kind === "rect") return path.width * path.height;
   const { commands, coords } = path;
+  const fillsOpen = fillsOpenSubpaths(path);
+  let total = 0;
   let twice = 0;
   let startX = 0, startY = 0;
   let open = false;
   let endX = 0, endY = 0;
-  const close = () => {
-    if (open) twice += endX * startY - startX * endY;
+  const close = (drawn) => {
+    if (open && (drawn || fillsOpen)) total += twice + endX * startY - startX * endY;
+    twice = 0;
     open = false;
   };
   forEachSegment(commands, coords, (cmd, ci, px, py) => {
     if (cmd === PATH_M) {
-      close();
+      close(false);
       startX = endX = coords[ci];
       startY = endY = coords[ci + 1];
       open = true;
       return;
     }
     if (cmd === PATH_Z) {
-      close();
+      close(true);
       endX = startX;
       endY = startY;
       return;
@@ -569,8 +589,8 @@ function pathSignedArea(path) {
     endX = x3;
     endY = y3;
   });
-  close();
-  return twice / 2;
+  close(false);
+  return total / 2;
 }
 function reversePath(path) {
   const cmds = [];
@@ -627,12 +647,7 @@ function reversePath(path) {
     segs.push({ cmd, args: Array.from(coords.subarray(ci, ci + n)), fromX: px, fromY: py });
   });
   flush(false);
-  return {
-    kind: "polygon",
-    commands: new Uint8Array(cmds),
-    coords: new Float32Array(out),
-    fillRule: path.fillRule
-  };
+  return { ...path, commands: new Uint8Array(cmds), coords: new Float32Array(out) };
 }
 
 // src/paths/pathFromD.ts
@@ -1174,6 +1189,72 @@ function emitStraightCubic(b, a, c) {
   b.curveTo(cp1x, cp1y, cp2x, cp2y, c.x, c.y);
 }
 
+// src/pathSubpaths.ts
+function flatSubpaths(path, tolerance) {
+  const { commands, coords } = path;
+  const closed = [];
+  const open = [];
+  let sub3 = [];
+  forEachSegment(commands, coords, (cmd, ci, curX, curY, _i, opensSubpath) => {
+    if (opensSubpath) sub3 = [curX, curY];
+    switch (cmd) {
+      case PATH_M:
+        if (sub3.length >= 2) open.push(sub3);
+        sub3 = [coords[ci], coords[ci + 1]];
+        break;
+      case PATH_L:
+        sub3.push(coords[ci], coords[ci + 1]);
+        break;
+      case PATH_C:
+        flattenCubic(
+          curX,
+          curY,
+          coords[ci],
+          coords[ci + 1],
+          coords[ci + 2],
+          coords[ci + 3],
+          coords[ci + 4],
+          coords[ci + 5],
+          tolerance,
+          sub3
+        );
+        break;
+      case PATH_Q:
+        flattenQuadratic(
+          curX,
+          curY,
+          coords[ci],
+          coords[ci + 1],
+          coords[ci + 2],
+          coords[ci + 3],
+          tolerance,
+          sub3
+        );
+        break;
+      case PATH_Z:
+        if (sub3.length >= 6) closed.push(sub3);
+        else if (sub3.length >= 2) open.push(sub3);
+        sub3 = [];
+        break;
+      default:
+        throw new Error(`pathHitTest: unknown command ${cmd}`);
+    }
+  });
+  if (sub3.length >= 2) open.push(sub3);
+  return { closed, open };
+}
+function regionSubpaths(path, opts) {
+  const flat = flatSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+  if (!fillsOpenSubpaths(path)) return flat;
+  return {
+    closed: [...flat.closed, ...flat.open.filter((sub3) => sub3.length >= 6)],
+    open: flat.open.filter((sub3) => sub3.length < 6)
+  };
+}
+function closedSubpaths(path, opts) {
+  return regionSubpaths(path, opts).closed;
+}
+
 // src/screenBand.ts
 function stretchOf(m) {
   const e = (m.a + m.d) / 2;
@@ -1277,62 +1358,6 @@ function distToEllipse(e0, e1, y0, y1) {
 }
 
 // src/pathHitTest.ts
-function flatSubpaths(path, tolerance) {
-  const { commands, coords } = path;
-  const closed = [];
-  const open = [];
-  let sub3 = [];
-  forEachSegment(commands, coords, (cmd, ci, curX, curY, _i, opensSubpath) => {
-    if (opensSubpath) sub3 = [curX, curY];
-    switch (cmd) {
-      case PATH_M:
-        if (sub3.length >= 2) open.push(sub3);
-        sub3 = [coords[ci], coords[ci + 1]];
-        break;
-      case PATH_L:
-        sub3.push(coords[ci], coords[ci + 1]);
-        break;
-      case PATH_C:
-        flattenCubic(
-          curX,
-          curY,
-          coords[ci],
-          coords[ci + 1],
-          coords[ci + 2],
-          coords[ci + 3],
-          coords[ci + 4],
-          coords[ci + 5],
-          tolerance,
-          sub3
-        );
-        break;
-      case PATH_Q:
-        flattenQuadratic(
-          curX,
-          curY,
-          coords[ci],
-          coords[ci + 1],
-          coords[ci + 2],
-          coords[ci + 3],
-          tolerance,
-          sub3
-        );
-        break;
-      case PATH_Z:
-        if (sub3.length >= 6) closed.push(sub3);
-        else if (sub3.length >= 2) open.push(sub3);
-        sub3 = [];
-        break;
-      default:
-        throw new Error(`pathHitTest: unknown command ${cmd}`);
-    }
-  });
-  if (sub3.length >= 2) open.push(sub3);
-  return { closed, open };
-}
-function closedSubpaths(path, opts) {
-  return flatSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE).closed;
-}
 function pointInPath(path, x, y, opts = {}) {
   if (path.kind === "rect") {
     return x >= path.x && x <= path.x + path.width && y >= path.y && y <= path.y + path.height;
@@ -1530,7 +1555,7 @@ function polygonContainsPath(polygon, path, opts = {}) {
   if (path.kind === "rect") {
     subpaths = [flattenVerts(rectToVerts(path))];
   } else {
-    const { closed, open } = flatSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+    const { closed, open } = regionSubpaths(path, opts);
     subpaths = [...closed, ...open];
   }
   if (subpaths.length === 0) return false;
@@ -1544,14 +1569,349 @@ function polygonContainsPath(polygon, path, opts = {}) {
 }
 function polygonIntersectsPath(polygon, path, opts = {}) {
   if (polygon.length < 3) return false;
-  if (path.kind === "rect") return polygonsIntersect(rectToVerts(path), polygon);
-  const { closed, open } = flatSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+  const filled = opts.filled !== false;
+  if (path.kind === "rect" && filled) return polygonsIntersect(rectToVerts(path), polygon);
+  const { closed, open } = path.kind === "rect" ? { closed: [flattenVerts(rectToVerts(path))], open: [] } : regionSubpaths(path, opts);
   const flatPoly = flattenVerts(polygon);
   if (anyVertexInPolygon(closed, flatPoly) || anyVertexInPolygon(open, flatPoly)) return true;
   if (anyEdgeCrossesPolygon(closed, polygon) || anyOpenEdgeCrossesPolygon(open, polygon)) {
     return true;
   }
-  return closed.length > 0 && pointInPath(path, polygon[0].x, polygon[0].y, opts);
+  return filled && closed.length > 0 && pointInPath(path, polygon[0].x, polygon[0].y, opts);
+}
+
+// src/paths/markers.ts
+function circlePath(cx, cy, r, segments = 32) {
+  const cmds = new Uint8Array(segments + 1);
+  const coords = new Float32Array(segments * 2);
+  cmds[0] = PATH_M;
+  coords[0] = cx + r;
+  coords[1] = cy;
+  for (let i = 1; i < segments; i++) {
+    cmds[i] = PATH_L;
+    const theta = i / segments * Math.PI * 2;
+    coords[i * 2] = cx + r * Math.cos(theta);
+    coords[i * 2 + 1] = cy + r * Math.sin(theta);
+  }
+  cmds[segments] = PATH_Z;
+  return { kind: "polygon", commands: cmds, coords, fillRule: "nonzero" };
+}
+function squarePath(cx, cy, size) {
+  const half = size / 2;
+  const x0 = cx - half, y0 = cy - half;
+  const x1 = cx + half, y1 = cy + half;
+  return {
+    kind: "polygon",
+    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),
+    coords: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),
+    fillRule: "nonzero"
+  };
+}
+function rectMarkerPath(x, y, width, height) {
+  return {
+    kind: "polygon",
+    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),
+    coords: Float32Array.from(rectToContour(x, y, width, height)),
+    fillRule: "nonzero"
+  };
+}
+function roundRectPath(x, y, width, height, r, cornerSamples = 8) {
+  const radius = Math.max(0, Math.min(r, Math.min(width, height) / 2));
+  if (radius === 0) return rectMarkerPath(x, y, width, height);
+  const HALF_PI = Math.PI / 2;
+  const corners = [
+    [x + radius, y + radius, Math.PI],
+    [x + width - radius, y + radius, -HALF_PI],
+    [x + width - radius, y + height - radius, 0],
+    [x + radius, y + height - radius, HALF_PI]
+  ];
+  const perCorner = cornerSamples + 1;
+  const count = corners.length * perCorner;
+  const cmds = new Uint8Array(count + 1);
+  const coords = new Float32Array(count * 2);
+  let i = 0;
+  for (const [cx, cy, start] of corners) {
+    for (let s = 0; s <= cornerSamples; s++) {
+      const theta = start + s / cornerSamples * HALF_PI;
+      cmds[i] = i === 0 ? PATH_M : PATH_L;
+      coords[i * 2] = cx + radius * Math.cos(theta);
+      coords[i * 2 + 1] = cy + radius * Math.sin(theta);
+      i++;
+    }
+  }
+  cmds[count] = PATH_Z;
+  return { kind: "polygon", commands: cmds, coords, fillRule: "nonzero" };
+}
+
+// src/paths/anchors.ts
+function pathToAnchors(path) {
+  const { commands, coords } = path;
+  const anchors = [];
+  const closed = [];
+  let current = null;
+  forEachSegment(commands, coords, (cmd, ci) => {
+    switch (cmd) {
+      case PATH_M: {
+        if (current) {
+          anchors.push(current);
+          closed.push(false);
+        }
+        current = [{ x: coords[ci], y: coords[ci + 1] }];
+        break;
+      }
+      case PATH_L: {
+        if (!current) throw new Error("pathToAnchors: L without prior M");
+        current.push({ x: coords[ci], y: coords[ci + 1] });
+        break;
+      }
+      case PATH_C: {
+        if (!current) throw new Error("pathToAnchors: C without prior M");
+        const prev = current[current.length - 1];
+        prev.outHandle = { x: coords[ci], y: coords[ci + 1] };
+        current.push({
+          x: coords[ci + 4],
+          y: coords[ci + 5],
+          inHandle: { x: coords[ci + 2], y: coords[ci + 3] }
+        });
+        break;
+      }
+      case PATH_Q: {
+        if (!current) throw new Error("pathToAnchors: Q without prior M");
+        const handle = { x: coords[ci], y: coords[ci + 1] };
+        const prev = current[current.length - 1];
+        prev.outHandle = handle;
+        current.push({ x: coords[ci + 2], y: coords[ci + 3], inHandle: { ...handle } });
+        break;
+      }
+      case PATH_Z: {
+        if (current) {
+          foldClosingCurve(current);
+          anchors.push(current);
+          closed.push(true);
+          current = null;
+        }
+        break;
+      }
+      default:
+        throw new Error(`pathToAnchors: unknown command ${cmd}`);
+    }
+  });
+  if (current) {
+    anchors.push(current);
+    closed.push(false);
+  }
+  return { anchors, closed };
+}
+function foldClosingCurve(sub3) {
+  if (sub3.length < 2) return;
+  const first = sub3[0];
+  const last = sub3[sub3.length - 1];
+  if (!last.inHandle || last.x !== first.x || last.y !== first.y) return;
+  sub3.pop();
+  first.inHandle = last.inHandle;
+}
+function anchorsToPath(anchors, closed, like) {
+  const b = new PathBuilder();
+  for (let s = 0; s < anchors.length; s++) {
+    const sub3 = anchors[s];
+    if (sub3.length === 0) continue;
+    b.moveTo(sub3[0].x, sub3[0].y);
+    for (let i = 1; i < sub3.length; i++) {
+      const prev = sub3[i - 1];
+      const cur = sub3[i];
+      const hasHandle = prev.outHandle != null || cur.inHandle != null;
+      if (!hasHandle) {
+        b.lineTo(cur.x, cur.y);
+      } else {
+        const c1 = prev.outHandle ?? { x: prev.x, y: prev.y };
+        const c2 = cur.inHandle ?? { x: cur.x, y: cur.y };
+        b.curveTo(c1.x, c1.y, c2.x, c2.y, cur.x, cur.y);
+      }
+    }
+    if (closed[s]) {
+      const last = sub3[sub3.length - 1];
+      const first = sub3[0];
+      const hasHandle = last.outHandle != null || first.inHandle != null;
+      if (hasHandle) {
+        const c1 = last.outHandle ?? { x: last.x, y: last.y };
+        const c2 = first.inHandle ?? { x: first.x, y: first.y };
+        b.curveTo(c1.x, c1.y, c2.x, c2.y, first.x, first.y);
+      }
+      b.close();
+    }
+  }
+  const built = b.build();
+  return like ? { ...like, commands: built.commands, coords: built.coords } : built;
+}
+var SMOOTH_THRESHOLD = 1e-3;
+function isAnchorSmooth(a) {
+  if (!a.inHandle || !a.outHandle) return false;
+  const inDX = a.inHandle.x - a.x;
+  const inDY = a.inHandle.y - a.y;
+  const outDX = a.outHandle.x - a.x;
+  const outDY = a.outHandle.y - a.y;
+  const inLen = Math.hypot(inDX, inDY);
+  const outLen = Math.hypot(outDX, outDY);
+  if (inLen === 0 || outLen === 0) return false;
+  const cross2 = (inDX * outDY - inDY * outDX) / (inLen * outLen);
+  return Math.abs(cross2) < SMOOTH_THRESHOLD;
+}
+function countPathAnchors(path) {
+  if (path.kind === "rect") return 4;
+  const cmds = path.commands;
+  let n = 0;
+  for (let i = 0; i < cmds.length; i++) {
+    const c = cmds[i];
+    if (c === PATH_M || c === PATH_L || c === PATH_C || c === PATH_Q) n++;
+  }
+  return n;
+}
+function segmentEnds(anchors, closed, sub3, segIdx) {
+  const s = anchors[sub3];
+  if (!s || segIdx < 0) return null;
+  if (segIdx + 1 < s.length) return { a: s[segIdx], b: s[segIdx + 1] };
+  if (closed?.[sub3] && s.length > 1 && segIdx === s.length - 1) return { a: s[segIdx], b: s[0] };
+  return null;
+}
+function isStraightSegment(a, b) {
+  return a.outHandle == null && b.inHandle == null;
+}
+function nearestOnSegment(a, b, x, y) {
+  const p1 = a.outHandle ?? a;
+  const p2 = b.inHandle ?? b;
+  const hit = isStraightSegment(a, b) ? nearestOnLine(x, y, a.x, a.y, b.x, b.y) : nearestOnCubic(x, y, a.x, a.y, p1.x, p1.y, p2.x, p2.y, b.x, b.y);
+  return { t: hit.t, d2: hit.dist * hit.dist };
+}
+function nearestSegmentT(anchors, wx, wy, closed) {
+  let bestD2 = Infinity;
+  let best = null;
+  for (let s = 0; s < anchors.length; s++) {
+    const segCount = anchors[s].length - (closed?.[s] ? 0 : 1);
+    for (let i = 0; i < segCount; i++) {
+      const ends = segmentEnds(anchors, closed, s, i);
+      if (!ends) continue;
+      const hit = nearestOnSegment(ends.a, ends.b, wx, wy);
+      if (hit.d2 < bestD2) {
+        bestD2 = hit.d2;
+        best = { sub: s, segIdx: i, t: hit.t };
+      }
+    }
+  }
+  return best;
+}
+
+// src/glMat3.ts
+function create(a, b, c, d, tx, ty) {
+  return new Float64Array([a, b, 0, c, d, 0, tx, ty, 1]);
+}
+function identity2() {
+  return create(1, 0, 0, 1, 0, 0);
+}
+function multiply2(out, m) {
+  const a = out[0], b = out[1];
+  const c = out[3], d = out[4];
+  const tx = out[6], ty = out[7];
+  const ma = m[0], mb = m[1];
+  const mc = m[3], md = m[4];
+  const mtx = m[6], mty = m[7];
+  return create(
+    a * ma + c * mb,
+    // new a
+    b * ma + d * mb,
+    // new b
+    a * mc + c * md,
+    // new c
+    b * mc + d * md,
+    // new d
+    a * mtx + c * mty + tx,
+    // new tx
+    b * mtx + d * mty + ty
+    // new ty
+  );
+}
+function translated(m, tx, ty) {
+  const t = create(1, 0, 0, 1, tx, ty);
+  return multiply2(m, t);
+}
+function scaled(m, sx, sy) {
+  const s = create(sx, 0, 0, sy, 0, 0);
+  return multiply2(m, s);
+}
+function toAffine(m) {
+  return [m[0], m[1], m[3], m[4], m[6], m[7]];
+}
+function fromAffine(a) {
+  return create(a[0], a[1], a[2], a[3], a[4], a[5]);
+}
+function invert2(m) {
+  const inv = invert(toAffine(m));
+  return inv && fromAffine(inv);
+}
+function toUniform(m) {
+  return Float32Array.from(m);
+}
+function apply(m, x, y) {
+  const a = m[0], b = m[1];
+  const c = m[3], d = m[4];
+  const tx = m[6], ty = m[7];
+  return [a * x + c * y + tx, b * x + d * y + ty];
+}
+function screenToClip(width, height) {
+  return create(
+    2 / width,
+    // a
+    0,
+    // b
+    0,
+    // c
+    -2 / height,
+    // d
+    -1,
+    // tx
+    1
+    // ty
+  );
+}
+function meanScaleOf(m) {
+  return Math.sqrt(Math.abs(m[0] * m[4] - m[1] * m[3]));
+}
+function minScaleOf(m) {
+  const sum = m[0] * m[0] + m[1] * m[1] + m[3] * m[3] + m[4] * m[4];
+  const det = m[0] * m[4] - m[1] * m[3];
+  return Math.sqrt(Math.max(0, (sum - Math.sqrt(Math.max(0, sum * sum - 4 * det * det))) / 2));
+}
+var mat3 = {
+  identity: identity2,
+  toAffine,
+  fromAffine,
+  multiply: multiply2,
+  translated,
+  scaled,
+  invert: invert2,
+  toUniform,
+  apply,
+  screenToClip,
+  meanScaleOf,
+  minScaleOf
+};
+
+// src/viewToMat3.ts
+function viewToMat3(view) {
+  const sx = view.scale.x;
+  const sy = view.scale.y;
+  const tx = -view.x * sx + 0;
+  const ty = -view.y * sy + 0;
+  return new Float64Array([
+    sx,
+    0,
+    0,
+    0,
+    sy,
+    0,
+    tx,
+    ty,
+    1
+  ]);
 }
 
 // src/place.ts
@@ -1801,6 +2161,425 @@ function resolveEasing(spec) {
   throw new Error("resolveEasing: unrecognized easing spec");
 }
 
-export { EASINGS, PathBuilder, SPRING_PRESETS, ZOOM_FLOOR, applyToPoint, boundsOfPath, boxToBox, clampRectWithin, composePath, cubicBezierEasing, decomposePath, 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, ellipsePath, identity, invert, linePath, linear, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, normalizeZoom, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls2 as portControls, portCurvePoints2 as portCurvePoints, rectPath, regularPolygonPath, resolveEasing, reversePath, rotate, rotateAboutPoint, scale, scalePathToBounds, schneiderFit, splitSubpaths, starPath, strokeHitTest, transformCoords, transformPath, translate, translatePath, unionBoundsPath };
+// src/meanScale.ts
+function meanScale(s) {
+  return Math.sqrt(Math.abs(s.x * s.y));
+}
+
+// src/pxExtent.ts
+function pxExtent(px, scale2, rotation = 0) {
+  if (!rotation) {
+    return {
+      x: px / Math.abs(scale2.x),
+      y: px / Math.abs(scale2.y)
+    };
+  }
+  const c = Math.cos(rotation), s = Math.sin(rotation);
+  return {
+    x: px * Math.hypot(c / scale2.x, s / scale2.y),
+    y: px * Math.hypot(s / scale2.x, c / scale2.y)
+  };
+}
+function scaleDelta(dx, dy, scale2) {
+  return { x: dx * scale2.x, y: dy * scale2.y };
+}
+function withinPxBox(dx, dy, px, scale2) {
+  const s = scaleDelta(dx, dy, scale2);
+  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;
+}
+function withinPxRadius(dx, dy, px, scale2) {
+  const s = scaleDelta(dx, dy, scale2);
+  return s.x * s.x + s.y * s.y <= px * px;
+}
+function standoff(anchor, normal, px, scale2) {
+  const k = Math.sign(scale2.x * scale2.y) || 1;
+  let nx = normal.x * scale2.y * k;
+  let ny = normal.y * scale2.x * k;
+  const l = Math.hypot(nx, ny) || 1;
+  nx /= l;
+  ny /= l;
+  return { x: anchor.x + nx * px / scale2.x, y: anchor.y + ny * px / scale2.y, nx, ny };
+}
+function screenAngleOf(rotation, scale2) {
+  return Math.atan2(Math.sin(rotation) * scale2.y, Math.cos(rotation) * scale2.x);
+}
+
+// src/poseRotation.ts
+function poseRotationOf(pose) {
+  const p = pose;
+  if (p.rotation && p.x != null && p.y != null && p.width != null && p.height != null) {
+    return { cx: p.x + p.width / 2, cy: p.y + p.height / 2, rotation: p.rotation };
+  }
+  return null;
+}
+function rotatePathAround(path, cx, cy, rotation) {
+  if (path.kind === "rect") {
+    return rotateRectCorners(path.x, path.y, path.width, path.height, cx, cy, rotation);
+  }
+  return rotatePolygon(path, cx, cy, rotation);
+}
+function rotatePolygon(path, cx, cy, rotation) {
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const { commands, coords } = path;
+  const next = new Float32Array(coords.length);
+  forEachSegment(commands, coords, (cmd, ci) => {
+    for (let k = 0, len = pathCommandCoordCount(cmd); k < len; k += 2) {
+      const dx = coords[ci + k] - cx;
+      const dy = coords[ci + k + 1] - cy;
+      next[ci + k] = cx + dx * cos - dy * sin;
+      next[ci + k + 1] = cy + dx * sin + dy * cos;
+    }
+  });
+  return { ...path, coords: next };
+}
+function rotateRectCorners(x, y, w, h, cx, cy, rotation) {
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const rotate2 = (px, py) => {
+    const dx = px - cx;
+    const dy = py - cy;
+    return [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];
+  };
+  const [x0, y0] = rotate2(x, y);
+  const [x1, y1] = rotate2(x + w, y);
+  const [x2, y2] = rotate2(x + w, y + h);
+  const [x3, y3] = rotate2(x, y + h);
+  const commands = new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]);
+  const coords = new Float32Array([x0, y0, x1, y1, x2, y2, x3, y3]);
+  return { kind: "polygon", commands, coords, fillRule: "nonzero" };
+}
+
+// src/poseFrame.ts
+function poseLinearOf(pose) {
+  const t = pose?.transform;
+  if (!Array.isArray(t) || t.length !== 4) return null;
+  if (t[0] === 1 && t[1] === 0 && t[2] === 0 && t[3] === 1) return null;
+  return t;
+}
+function poseFrameOf(pose) {
+  const p = pose;
+  if (!p || p.x == null || p.y == null || p.width == null || p.height == null) return null;
+  const linear2 = poseLinearOf(p);
+  if (!p.rotation && !linear2) return null;
+  const cx = p.x + p.width / 2;
+  const cy = p.y + p.height / 2;
+  if (!linear2) return rotateAboutPoint(cx, cy, p.rotation);
+  const [a, b, c, d] = linear2;
+  const about = [a, b, c, d, cx - (a * cx + c * cy), cy - (b * cx + d * cy)];
+  return p.rotation ? multiply(rotateAboutPoint(cx, cy, p.rotation), about) : about;
+}
+function poseFrameInverseOf(pose) {
+  if (!poseLinearOf(pose)) {
+    const r = poseRotationOf(pose);
+    return r && rotateAboutPoint(r.cx, r.cy, -r.rotation);
+  }
+  const frame = poseFrameOf(pose);
+  return frame && invert(frame);
+}
+function pathThroughPoseFrame(path, pose) {
+  if (poseLinearOf(pose)) {
+    const frame = poseFrameOf(pose);
+    return frame ? transformPath(path, frame) : path;
+  }
+  const r = poseRotationOf(pose);
+  return r ? rotatePathAround(path, r.cx, r.cy, r.rotation) : path;
+}
+
+// src/paths/anchorEdits.ts
+function anchorCount(set) {
+  let n = 0;
+  for (const sub3 of set.anchors) n += sub3.length;
+  return n;
+}
+function locateAnchor(set, flatIndex) {
+  if (flatIndex < 0) return null;
+  let remaining = flatIndex;
+  for (let sub3 = 0; sub3 < set.anchors.length; sub3++) {
+    const len = set.anchors[sub3].length;
+    if (remaining < len) return { sub: sub3, idx: remaining };
+    remaining -= len;
+  }
+  return null;
+}
+function flatAnchorIndex(set, sub3, idx) {
+  if (sub3 < 0 || sub3 >= set.anchors.length) return -1;
+  if (idx < 0 || idx >= set.anchors[sub3].length) return -1;
+  let base = 0;
+  for (let s = 0; s < sub3; s++) base += set.anchors[s].length;
+  return base + idx;
+}
+function anchorAt(set, flatIndex) {
+  const loc = locateAnchor(set, flatIndex);
+  if (!loc) return null;
+  return set.anchors[loc.sub][loc.idx] ?? null;
+}
+function editAnchorSet(path, edit) {
+  const set = pathToAnchors(path);
+  const changed = edit(set);
+  if (changed === false) return null;
+  return anchorsToPath(set.anchors, set.closed, path);
+}
+function translateAnchorBy(set, flatIndex, dx, dy) {
+  const a = anchorAt(set, flatIndex);
+  if (!a) return false;
+  a.x += dx;
+  a.y += dy;
+  if (a.inHandle) {
+    a.inHandle.x += dx;
+    a.inHandle.y += dy;
+  }
+  if (a.outHandle) {
+    a.outHandle.x += dx;
+    a.outHandle.y += dy;
+  }
+  return true;
+}
+function moveHandleTo(set, flatIndex, side, toX, toY, breakSmoothness) {
+  const a = anchorAt(set, flatIndex);
+  if (!a) return false;
+  const wasSmooth = isAnchorSmooth(a);
+  const target = { x: toX, y: toY };
+  if (side === "out") a.outHandle = target;
+  else a.inHandle = target;
+  const oppositeSide = side === "out" ? "in" : "out";
+  const opposite = oppositeSide === "in" ? a.inHandle : a.outHandle;
+  if (!breakSmoothness && wasSmooth && opposite) {
+    const mirrored = { x: 2 * a.x - target.x, y: 2 * a.y - target.y };
+    if (oppositeSide === "in") a.inHandle = mirrored;
+    else a.outHandle = mirrored;
+  }
+  return true;
+}
+function insertAnchorOnSegment(set, args) {
+  const ends = segmentEnds(set.anchors, set.closed, args.sub, args.segIdx);
+  if (!ends) return -1;
+  const { a, b } = ends;
+  const at = args.segIdx + 1;
+  if (isStraightSegment(a, b)) {
+    set.anchors[args.sub].splice(at, 0, {
+      x: a.x + (b.x - a.x) * args.t,
+      y: a.y + (b.y - a.y) * args.t
+    });
+    return flatAnchorIndex(set, args.sub, at);
+  }
+  const p0 = a, p1 = a.outHandle ?? a, p2 = b.inHandle ?? b, p3 = b;
+  const { left, right } = splitCubicAtT(p0, p1, p2, p3, args.t);
+  a.outHandle = { x: left[1].x, y: left[1].y };
+  b.inHandle = { x: right[2].x, y: right[2].y };
+  set.anchors[args.sub].splice(at, 0, {
+    x: left[3].x,
+    y: left[3].y,
+    inHandle: { x: left[2].x, y: left[2].y },
+    outHandle: { x: right[1].x, y: right[1].y }
+  });
+  return flatAnchorIndex(set, args.sub, at);
+}
+function segmentAt(set, x, y, opts) {
+  const scale2 = opts.scale ?? { x: 1, y: 1 };
+  const onScreen = (p) => ({ x: p.x * scale2.x, y: p.y * scale2.y });
+  const screenAnchors = set.anchors.map((sub3) => sub3.map((a) => ({
+    ...onScreen(a),
+    ...a.inHandle ? { inHandle: onScreen(a.inHandle) } : {},
+    ...a.outHandle ? { outHandle: onScreen(a.outHandle) } : {}
+  })));
+  const hit = nearestSegmentT(screenAnchors, x * scale2.x, y * scale2.y, set.closed);
+  if (!hit) return null;
+  const ends = segmentEnds(set.anchors, set.closed, hit.sub, hit.segIdx);
+  const point = pointOnSegment(ends.a, ends.b, hit.t);
+  const tol = opts.tolerancePx;
+  if (!withinPxRadius(point.x - x, point.y - y, tol, scale2)) return null;
+  if (withinPxRadius(point.x - ends.a.x, point.y - ends.a.y, tol, scale2)) return null;
+  if (withinPxRadius(point.x - ends.b.x, point.y - ends.b.y, tol, scale2)) return null;
+  return { sub: hit.sub, segIdx: hit.segIdx, t: hit.t, x: point.x, y: point.y };
+}
+function pointOnSegment(a, b, t) {
+  if (isStraightSegment(a, b)) return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+  return cubicPointAt(a, a.outHandle ?? a, b.inHandle ?? b, b, t);
+}
+function deleteAnchorsAt(set, flatIndexes) {
+  const bySub = /* @__PURE__ */ new Map();
+  for (const flat of new Set(flatIndexes)) {
+    const loc = locateAnchor(set, flat);
+    if (!loc) continue;
+    const list = bySub.get(loc.sub);
+    if (list) list.push(loc.idx);
+    else bySub.set(loc.sub, [loc.idx]);
+  }
+  if (bySub.size === 0) return false;
+  let survivors = 0;
+  for (let s = 0; s < set.anchors.length; s++) {
+    const doomed = bySub.get(s)?.length ?? 0;
+    if (set.anchors[s].length - doomed >= 2) survivors++;
+  }
+  if (survivors === 0) return false;
+  for (const [s, indices] of bySub) {
+    const sub3 = set.anchors[s];
+    if (!sub3) continue;
+    indices.sort((a, b) => b - a);
+    for (const i of indices) {
+      const wraps = set.closed[s] && sub3.length > 2;
+      const prev = wraps ? sub3[(i - 1 + sub3.length) % sub3.length] : sub3[i - 1];
+      const next = wraps ? sub3[(i + 1) % sub3.length] : sub3[i + 1];
+      if (prev && next) {
+        const { c1, c2 } = fitCubicThroughDeletion(prev, next);
+        prev.outHandle = c1;
+        next.inHandle = c2;
+      }
+      sub3.splice(i, 1);
+    }
+  }
+  for (let s = set.anchors.length - 1; s >= 0; s--) {
+    if (set.anchors[s].length < 2) {
+      set.anchors.splice(s, 1);
+      set.closed.splice(s, 1);
+    }
+  }
+  return true;
+}
+function openSubpathAt(set, flatIndex) {
+  const loc = locateAnchor(set, flatIndex);
+  if (!loc) return false;
+  if (!set.closed[loc.sub]) return false;
+  const sub3 = set.anchors[loc.sub];
+  if (!sub3) return false;
+  const { inHandle, ...start } = sub3[loc.idx];
+  const end = { x: start.x, y: start.y, ...inHandle ? { inHandle } : {} };
+  set.anchors[loc.sub] = [start, ...sub3.slice(loc.idx + 1), ...sub3.slice(0, loc.idx), end];
+  set.closed[loc.sub] = false;
+  return true;
+}
+function anchorsInRect(set, rect) {
+  const x2 = rect.x + rect.width;
+  const y2 = rect.y + rect.height;
+  const hits = [];
+  let flat = 0;
+  for (const sub3 of set.anchors) {
+    for (const a of sub3) {
+      if (a.x >= rect.x && a.x <= x2 && a.y >= rect.y && a.y <= y2) hits.push(flat);
+      flat++;
+    }
+  }
+  return hits;
+}
+
+// src/paths/nearestAnchor.ts
+function nearestPathAnchor(paths, point, px, scale2, accept) {
+  let best = null;
+  let bestD2 = px * px;
+  for (const { id, path } of paths) {
+    const { anchors, closed } = pathToAnchors(path);
+    for (let sub3 = 0; sub3 < anchors.length; sub3++) {
+      const list = anchors[sub3];
+      for (let idx = 0; idx < list.length; idx++) {
+        const a = list[idx];
+        const s = scaleDelta(a.x - point.x, a.y - point.y, scale2);
+        const d2 = s.x * s.x + s.y * s.y;
+        if (d2 > bestD2 || best !== null && d2 === bestD2) continue;
+        const end = closed[sub3] ? null : idx === list.length - 1 ? "last" : idx === 0 ? "first" : null;
+        const hit = { id, sub: sub3, idx, x: a.x, y: a.y, end };
+        if (accept && !accept(hit)) continue;
+        best = hit;
+        bestD2 = d2;
+      }
+    }
+  }
+  return best;
+}
+function reverseAnchors(anchors) {
+  return anchors.map((a) => {
+    const { inHandle, outHandle, ...rest } = a;
+    const r = { ...rest };
+    if (outHandle) r.inHandle = { ...outHandle };
+    if (inHandle) r.outHandle = { ...inHandle };
+    return r;
+  }).reverse();
+}
+
+// src/paths/pathInWorld.ts
+function pathInPoseFrame(path, pose) {
+  if (path.kind === "rect") {
+    if (path.x === pose.x && path.y === pose.y && path.width === pose.width && path.height === pose.height) return path;
+    return { kind: "rect", x: pose.x, y: pose.y, width: pose.width, height: pose.height };
+  }
+  const b = boundsOfPath(path);
+  if (b.x === pose.x && b.y === pose.y && b.width === pose.width && b.height === pose.height) {
+    return path;
+  }
+  const m = boxToBox(b.x, b.y, b.width, b.height, pose.x, pose.y, pose.width, pose.height);
+  return transformPath(path, m);
+}
+function pathInWorld(path, pose) {
+  const local = pathInPoseFrame(path, pose);
+  const frame = poseFrameOf(pose);
+  if (!frame) return local;
+  return transformPath(local, frame);
+}
+function worldEditToStorage(pose, worldPath) {
+  const back = poseFrameInverseOf(pose);
+  const frame = back && poseFrameOf(pose);
+  const unrotated = back ? transformPath(worldPath, back) : worldPath;
+  const b = boundsOfPath(unrotated);
+  const aligned = translatePath(unrotated, -b.x, -b.y);
+  let x = b.x, y = b.y;
+  if (frame) {
+    const [cx, cy] = applyToPoint(frame, b.x + b.width / 2, b.y + b.height / 2);
+    x = cx - b.width / 2;
+    y = cy - b.height / 2;
+  }
+  return {
+    pose: { ...pose, x, y, width: b.width, height: b.height },
+    path: aligned
+  };
+}
+
+// src/typedArrayJson.ts
+var TYPED_ARRAY_CONSTRUCTORS = {
+  i8: Int8Array,
+  u8: Uint8Array,
+  u8c: Uint8ClampedArray,
+  i16: Int16Array,
+  u16: Uint16Array,
+  i32: Int32Array,
+  u32: Uint32Array,
+  f32: Float32Array,
+  f64: Float64Array
+};
+var TAGS = new Map(
+  Object.keys(TYPED_ARRAY_CONSTRUCTORS).map((tag) => [TYPED_ARRAY_CONSTRUCTORS[tag].name, tag])
+);
+var classOf = (value) => Object.prototype.toString.call(value).slice(8, -1);
+function tagTypedArray(value) {
+  if (!ArrayBuffer.isView(value)) return void 0;
+  const tag = TAGS.get(classOf(value));
+  return tag && { __ta: tag, data: Array.from(value) };
+}
+function untagTypedArray(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const { __ta: tag, data } = value;
+  if (typeof tag !== "string" || !Object.hasOwn(TYPED_ARRAY_CONSTRUCTORS, tag) || !Array.isArray(data)) return void 0;
+  return TYPED_ARRAY_CONSTRUCTORS[tag].from(data);
+}
+var isPlain = (value) => classOf(value) === "Object";
+function mapDeep(value, leaf) {
+  const swapped = leaf(value);
+  if (swapped !== void 0) return swapped;
+  if (Array.isArray(value)) return value.map((v) => mapDeep(v, leaf));
+  if (!isPlain(value)) return value;
+  const out = {};
+  for (const key of Object.keys(value)) out[key] = mapDeep(value[key], leaf);
+  return out;
+}
+function tagTypedArrays(value) {
+  return mapDeep(value, tagTypedArray);
+}
+function reviveTypedArrays(value) {
+  return mapDeep(value, untagTypedArray);
+}
+function typedArrayReplacer(_key, value) {
+  return tagTypedArray(value) ?? value;
+}
+
+export { EASINGS, PathBuilder, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, anchorAt, anchorCount, anchorsInRect, anchorsToPath, applyToPoint, boundsOfPath, boxToBox, circlePath, clampRectWithin, composePath, countPathAnchors, cubicBezierEasing, decomposePath, deleteAnchorsAt, 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, ellipsePath, flatAnchorIndex, hasOpenSubpath, identity, insertAnchorOnSegment, invert, isAnchorSmooth, isStraightSegment, linePath, linear, locateAnchor, mat3, meanScale, moveHandleTo, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestPathAnchor, nearestSegmentT, normalizeZoom, openSubpathAt, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, pathThroughPoseFrame, pathToAnchors, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, pxExtent, rectMarkerPath, rectPath, regularPolygonPath, resolveEasing, reverseAnchors, reversePath, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, scale, scaleDelta, scalePathToBounds, schneiderFit, screenAngleOf, segmentAt, segmentEnds, splitByClosure, splitSubpaths, squarePath, standoff, starPath, strokeHitTest, tagTypedArray, tagTypedArrays, transformCoords, transformPath, translate, translateAnchorBy, translatePath, typedArrayReplacer, unionBoundsPath, untagTypedArray, viewToMat3, withinPxBox, withinPxRadius, worldEditToStorage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map