@weasel-js/geom 1.10.1 → 1.11.1

package/dist/chunk-EAKE3N7W.js

@@ -0,0 +1,804 @@
+import { sign, len2, dot } from './chunk-755Y4YZS.js';
+import { PathBuilder, cubicPointAt, forEachSegment, PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M, hasCorners, withoutCorners, cornerAt, cubicEvalAt, splitCubicAt } from './chunk-B53BERKG.js';
+
+// src/flatten.ts
+var DEFAULT_FLATTEN_TOLERANCE = 0.5;
+var MIN_FLATTEN_TOLERANCE = 1e-6;
+var MAX_FLATTEN_DEPTH = 16;
+function usableTolerance(tolerance) {
+  return tolerance > 0 ? tolerance : MIN_FLATTEN_TOLERANCE;
+}
+function finite6(a, b, c, d, e, f) {
+  return Number.isFinite(a) && Number.isFinite(b) && Number.isFinite(c) && Number.isFinite(d) && Number.isFinite(e) && Number.isFinite(f);
+}
+function finite8(a, b, c, d, e, f, g, h) {
+  return finite6(a, b, c, d, e, f) && Number.isFinite(g) && Number.isFinite(h);
+}
+function distPointToSegment(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const len22 = dx * dx + dy * dy;
+  const along = len22 === 0 ? 0 : ((px - ax) * dx + (py - ay) * dy) / len22;
+  if (along <= 0) return Math.hypot(px - ax, py - ay);
+  if (along >= 1) return Math.hypot(px - bx, py - by);
+  return Math.abs((px - ax) * dy - (py - ay) * dx) / Math.sqrt(len22);
+}
+function turnsWithin(x0, y0, x1, y1, x2, y2, x3, y3, maxTurn) {
+  let turn = legTurn(x1 - x0, y1 - y0, x2 - x1, y2 - y1);
+  if (turn > maxTurn) return false;
+  turn += legTurn(x2 - x1, y2 - y1, x3 - x2, y3 - y2);
+  if (x2 === x1 && y2 === y1) turn += legTurn(x1 - x0, y1 - y0, x3 - x2, y3 - y2);
+  return turn <= maxTurn;
+}
+function legTurn(ax, ay, bx, by) {
+  const lens = Math.sqrt((ax * ax + ay * ay) * (bx * bx + by * by));
+  if (lens === 0) return 0;
+  return Math.acos(Math.max(-1, Math.min(1, (ax * bx + ay * by) / lens)));
+}
+function flattenCubic(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out) {
+  if (!finite8(x0, y0, x1, y1, x2, y2, x3, y3)) {
+    out.push(x3, y3);
+    return;
+  }
+  flattenCubicRec(x0, y0, x1, y1, x2, y2, x3, y3, usableTolerance(tolerance), out, 0);
+}
+function flattenCubicRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, depth) {
+  const d1 = distPointToSegment(x1, y1, x0, y0, x3, y3);
+  const d2 = distPointToSegment(x2, y2, x0, y0, x3, y3);
+  if (Math.max(d1, d2) <= tolerance || depth >= MAX_FLATTEN_DEPTH) {
+    out.push(x3, y3);
+    return;
+  }
+  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
+  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
+  const x23 = (x2 + x3) * 0.5, y23 = (y2 + y3) * 0.5;
+  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
+  const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;
+  const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;
+  flattenCubicRec(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out, depth + 1);
+  flattenCubicRec(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out, depth + 1);
+}
+function flattenQuadratic(x0, y0, x1, y1, x2, y2, tolerance, out) {
+  if (!finite6(x0, y0, x1, y1, x2, y2)) {
+    out.push(x2, y2);
+    return;
+  }
+  flattenQuadraticRec(x0, y0, x1, y1, x2, y2, usableTolerance(tolerance), out, 0);
+}
+function flattenQuadraticRec(x0, y0, x1, y1, x2, y2, tolerance, out, depth) {
+  const d = distPointToSegment(x1, y1, x0, y0, x2, y2);
+  if (d <= tolerance || depth >= MAX_FLATTEN_DEPTH) {
+    out.push(x2, y2);
+    return;
+  }
+  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
+  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
+  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
+  flattenQuadraticRec(x0, y0, x01, y01, x012, y012, tolerance, out, depth + 1);
+  flattenQuadraticRec(x012, y012, x12, y12, x2, y2, tolerance, out, depth + 1);
+}
+function flattenCubicWithArcLen(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut, maxTurn = Infinity) {
+  if (!finite8(x0, y0, x1, y1, x2, y2, x3, y3)) {
+    out.push(x3, y3);
+    arcOut.push(0);
+    return 0;
+  }
+  return flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, usableTolerance(tolerance), maxTurn, out, arcOut, 0, 0);
+}
+function flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, maxTurn, out, arcOut, accum, depth) {
+  const d1 = distPointToSegment(x1, y1, x0, y0, x3, y3);
+  const d2 = distPointToSegment(x2, y2, x0, y0, x3, y3);
+  const flat = Math.max(d1, d2) <= tolerance && (maxTurn === Infinity || turnsWithin(x0, y0, x1, y1, x2, y2, x3, y3, maxTurn));
+  if (flat || depth >= MAX_FLATTEN_DEPTH) {
+    const lastX = out.length >= 2 ? out[out.length - 2] : x0;
+    const lastY = out.length >= 2 ? out[out.length - 1] : y0;
+    const seg = Math.hypot(x3 - lastX, y3 - lastY);
+    accum += seg;
+    out.push(x3, y3);
+    arcOut.push(accum);
+    return accum;
+  }
+  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
+  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
+  const x23 = (x2 + x3) * 0.5, y23 = (y2 + y3) * 0.5;
+  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
+  const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;
+  const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;
+  accum = flattenCubicArcRec(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, maxTurn, out, arcOut, accum, depth + 1);
+  accum = flattenCubicArcRec(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, maxTurn, out, arcOut, accum, depth + 1);
+  return accum;
+}
+function flattenQuadraticWithArcLen(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut, maxTurn = Infinity) {
+  if (!finite6(x0, y0, x1, y1, x2, y2)) {
+    out.push(x2, y2);
+    arcOut.push(0);
+    return 0;
+  }
+  return flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, usableTolerance(tolerance), maxTurn, out, arcOut, 0, 0);
+}
+function flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, tolerance, maxTurn, out, arcOut, accum, depth) {
+  const d = distPointToSegment(x1, y1, x0, y0, x2, y2);
+  const flat = d <= tolerance && (maxTurn === Infinity || turnsWithin(x0, y0, x1, y1, x2, y2, x2, y2, maxTurn));
+  if (flat || depth >= MAX_FLATTEN_DEPTH) {
+    const lastX = out.length >= 2 ? out[out.length - 2] : x0;
+    const lastY = out.length >= 2 ? out[out.length - 1] : y0;
+    const seg = Math.hypot(x2 - lastX, y2 - lastY);
+    accum += seg;
+    out.push(x2, y2);
+    arcOut.push(accum);
+    return accum;
+  }
+  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
+  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
+  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
+  accum = flattenQuadraticArcRec(x0, y0, x01, y01, x012, y012, tolerance, maxTurn, out, arcOut, accum, depth + 1);
+  accum = flattenQuadraticArcRec(x012, y012, x12, y12, x2, y2, tolerance, maxTurn, out, arcOut, accum, depth + 1);
+  return accum;
+}
+
+// src/polyline.ts
+function pointInPolygon(coords, px, py, start = 0, end = coords.length >> 1) {
+  if (end - start < 3) return false;
+  let inside = false;
+  for (let i = start, j = end - 1; i < end; j = i++) {
+    const xi = coords[i * 2], yi = coords[i * 2 + 1];
+    const xj = coords[j * 2], yj = coords[j * 2 + 1];
+    const crosses = yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi;
+    if (crosses) inside = !inside;
+  }
+  return inside;
+}
+function segmentsCross(ax, ay, bx, by, cx, cy, dx, dy) {
+  const d1 = sign((dx - cx) * (ay - cy) - (dy - cy) * (ax - cx));
+  const d2 = sign((dx - cx) * (by - cy) - (dy - cy) * (bx - cx));
+  const d3 = sign((bx - ax) * (cy - ay) - (by - ay) * (cx - ax));
+  const d4 = sign((bx - ax) * (dy - ay) - (by - ay) * (dx - ax));
+  return d1 !== d2 && d3 !== d4;
+}
+function pointSegmentDist2(px, py, ax, ay, bx, by) {
+  const vx = bx - ax, vy = by - ay;
+  const wx = px - ax, wy = py - ay;
+  const vv = len2(vx, vy);
+  let t = vv === 0 ? 0 : dot(wx, wy, vx, vy) / vv;
+  t = t < 0 ? 0 : t > 1 ? 1 : t;
+  const dx = px - (ax + t * vx), dy = py - (ay + t * vy);
+  return len2(dx, dy);
+}
+
+// src/openFill.ts
+var fallback = "close";
+function setDefaultOpenFill(rule) {
+  fallback = rule;
+}
+function defaultOpenFill() {
+  return fallback;
+}
+function fillsOpenSubpaths(path) {
+  return (path.openFill ?? fallback) === "close";
+}
+
+// src/paths/schneiderFit.ts
+function schneiderFit(samples, errorTolerance) {
+  if (samples.length === 0) {
+    return {
+      kind: "polygon",
+      commands: new Uint8Array(),
+      coords: new Float32Array(),
+      fillRule: "nonzero"
+    };
+  }
+  const b = new PathBuilder();
+  b.moveTo(samples[0].x, samples[0].y);
+  if (samples.length === 1) {
+    return b.build();
+  }
+  if (samples.length === 2) {
+    emitStraightCubic(b, samples[0], samples[1]);
+    return b.build();
+  }
+  fitRecursive(samples, errorTolerance, b);
+  return b.build();
+}
+function fitRecursive(samples, errorTolerance, b) {
+  if (samples.length === 2) {
+    const fit2 = fitOneCubic(samples);
+    b.curveTo(fit2.cp1.x, fit2.cp1.y, fit2.cp2.x, fit2.cp2.y, fit2.end.x, fit2.end.y);
+    return;
+  }
+  const fit = fitOneCubic(samples);
+  const { worstIndex, worstError } = measureError(samples, fit);
+  if (worstError <= errorTolerance * errorTolerance) {
+    b.curveTo(fit.cp1.x, fit.cp1.y, fit.cp2.x, fit.cp2.y, fit.end.x, fit.end.y);
+    return;
+  }
+  const left = samples.slice(0, worstIndex + 1);
+  const right = samples.slice(worstIndex);
+  fitRecursive(left, errorTolerance, b);
+  fitRecursive(right, errorTolerance, b);
+}
+function measureError(samples, fit) {
+  let worstIndex = 1;
+  let worstError = 0;
+  const a = samples[0];
+  for (let i = 1; i < samples.length - 1; i++) {
+    const q = cubicPointAt(a, fit.cp1, fit.cp2, fit.end, fit.ts[i]);
+    const dx = samples[i].x - q.x;
+    const dy = samples[i].y - q.y;
+    const sq = dx * dx + dy * dy;
+    if (sq > worstError) {
+      worstError = sq;
+      worstIndex = i;
+    }
+  }
+  return { worstIndex, worstError };
+}
+function fitOneCubic(samples) {
+  const n = samples.length;
+  return fitWithTangents(
+    samples,
+    unit(sub(samples[1], samples[0])),
+    unit(sub(samples[n - 2], samples[n - 1])),
+    4
+  );
+}
+function fitCubicWithTangents(samples, tStart, tEnd, opts = {}) {
+  const { cp1, cp2 } = fitWithTangents(samples, tStart, tEnd, opts.passes ?? 4, opts.params);
+  return { cp1, cp2 };
+}
+function fitWithTangents(samples, tStart, tEnd, passes, params) {
+  const n = samples.length;
+  const a = samples[0];
+  const e = samples[n - 1];
+  const ts = params ? [...params] : chordLengthParam(samples);
+  if (ts === null) return { cp1: { ...a }, cp2: { ...e }, end: e, ts: samples.map(() => 0) };
+  let fit = solveLS(samples, ts, a, e, tStart, tEnd);
+  for (let pass = 0; pass < passes; pass++) {
+    reparameterize(samples, ts, a, e, fit);
+    fit = solveLS(samples, ts, a, e, tStart, tEnd);
+  }
+  return fit;
+}
+function chordLengthParam(samples) {
+  const n = samples.length;
+  const ts = new Array(n);
+  ts[0] = 0;
+  let total = 0;
+  for (let i = 1; i < n; i++) {
+    total += dist(samples[i - 1], samples[i]);
+    ts[i] = total;
+  }
+  if (total === 0) return null;
+  for (let i = 0; i < n; i++) ts[i] /= total;
+  return ts;
+}
+function solveLS(samples, ts, a, e, tStart, tEnd) {
+  const n = samples.length;
+  let c11 = 0, c12 = 0, c22 = 0, x1 = 0, x2 = 0;
+  for (let i = 0; i < n; i++) {
+    const t = ts[i];
+    const u = 1 - t;
+    const b0 = u * u * u;
+    const b1 = 3 * u * u * t;
+    const b2 = 3 * u * t * t;
+    const b3 = t * t * t;
+    const A1x = b1 * tStart.x;
+    const A1y = b1 * tStart.y;
+    const A2x = b2 * tEnd.x;
+    const A2y = b2 * tEnd.y;
+    c11 += A1x * A1x + A1y * A1y;
+    c12 += A1x * A2x + A1y * A2y;
+    c22 += A2x * A2x + A2y * A2y;
+    const targetX = samples[i].x - (b0 + b1) * a.x - (b2 + b3) * e.x;
+    const targetY = samples[i].y - (b0 + b1) * a.y - (b2 + b3) * e.y;
+    x1 += A1x * targetX + A1y * targetY;
+    x2 += A2x * targetX + A2y * targetY;
+  }
+  const det = c11 * c22 - c12 * c12;
+  let alpha1;
+  let alpha2;
+  if (Math.abs(det) < 1e-12) {
+    const chord = dist(a, e);
+    alpha1 = alpha2 = chord / 3;
+  } else {
+    alpha1 = (c22 * x1 - c12 * x2) / det;
+    alpha2 = (c11 * x2 - c12 * x1) / det;
+    if (alpha1 < 1e-6 || alpha2 < 1e-6) {
+      const chord = dist(a, e);
+      alpha1 = alpha2 = chord / 3;
+    }
+  }
+  return {
+    cp1: { x: a.x + tStart.x * alpha1, y: a.y + tStart.y * alpha1 },
+    cp2: { x: e.x + tEnd.x * alpha2, y: e.y + tEnd.y * alpha2 },
+    end: e,
+    ts
+  };
+}
+function reparameterize(samples, ts, a, e, fit) {
+  for (let i = 1; i < samples.length - 1; i++) {
+    ts[i] = newtonRefineT(samples[i], ts[i], samples[0], fit.cp1, fit.cp2, samples[samples.length - 1]);
+  }
+}
+function newtonRefineT(p, t, p0, p1, p2, p3) {
+  const u = 1 - t;
+  const { x: qx, y: qy } = cubicPointAt(p0, p1, p2, p3, t);
+  const qpx = 3 * u * u * (p1.x - p0.x) + 6 * u * t * (p2.x - p1.x) + 3 * t * t * (p3.x - p2.x);
+  const qpy = 3 * u * u * (p1.y - p0.y) + 6 * u * t * (p2.y - p1.y) + 3 * t * t * (p3.y - p2.y);
+  const qppx = 6 * u * (p2.x - 2 * p1.x + p0.x) + 6 * t * (p3.x - 2 * p2.x + p1.x);
+  const qppy = 6 * u * (p2.y - 2 * p1.y + p0.y) + 6 * t * (p3.y - 2 * p2.y + p1.y);
+  const dx = qx - p.x;
+  const dy = qy - p.y;
+  const numerator = dx * qpx + dy * qpy;
+  const denominator = qpx * qpx + qpy * qpy + dx * qppx + dy * qppy;
+  if (Math.abs(denominator) < 1e-12) return t;
+  const next = t - numerator / denominator;
+  if (next < 0) return 0;
+  if (next > 1) return 1;
+  return next;
+}
+function sub(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y };
+}
+function dist(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function unit(v) {
+  const m = Math.hypot(v.x, v.y);
+  if (m === 0) return { x: 0, y: 0 };
+  return { x: v.x / m, y: v.y / m };
+}
+function emitStraightCubic(b, a, c) {
+  const cp1x = a.x + (c.x - a.x) / 3;
+  const cp1y = a.y + (c.y - a.y) / 3;
+  const cp2x = a.x + 2 * (c.x - a.x) / 3;
+  const cp2y = a.y + 2 * (c.y - a.y) / 3;
+  b.curveTo(cp1x, cp1y, cp2x, cp2y, c.x, c.y);
+}
+
+// src/paths/cornerShape.ts
+var CORNER_KEYWORDS = ["square", "squircle", "round", "bevel", "scoop", "notch"];
+var K_OF = {
+  square: Infinity,
+  squircle: 2,
+  round: 1,
+  bevel: 0,
+  scoop: -1,
+  notch: -Infinity
+};
+function cornerShapeK(shape) {
+  return typeof shape === "number" ? shape : K_OF[shape];
+}
+function cornerKeywordOf(k) {
+  return CORNER_KEYWORDS.find((w) => K_OF[w] === k) ?? null;
+}
+function isCornerShape(v) {
+  return typeof v === "number" && Number.isFinite(v) || CORNER_KEYWORDS.includes(v);
+}
+function nextCornerShape(shape) {
+  if (typeof shape !== "number") {
+    return CORNER_KEYWORDS[(CORNER_KEYWORDS.indexOf(shape) + 1) % CORNER_KEYWORDS.length];
+  }
+  return CORNER_KEYWORDS.find((w) => K_OF[w] < shape) ?? CORNER_KEYWORDS[0];
+}
+var CORNER_FIT_TOLERANCE = 1e-3;
+var KAPPA = 4 / 3 * Math.tan(Math.PI / 8);
+function exponentOf(k) {
+  const n = 2 ** Math.abs(k);
+  return 1 - 0.5 ** (1 / n) < CORNER_FIT_TOLERANCE / 4 ? Infinity : n;
+}
+function unitPoint(n, theta) {
+  const p = 2 / n;
+  return { x: Math.cos(theta) ** p, y: Math.sin(theta) ** p };
+}
+function unitTangent(n, theta) {
+  const q = 2 - 2 / n;
+  const x = Math.sin(theta) ** q, y = -(Math.cos(theta) ** q);
+  const l = Math.hypot(x, y);
+  return { x: x / l, y: y / l };
+}
+var sub2 = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
+function cubicAt(p0, [c1, c2, p3], t) {
+  const u = 1 - t;
+  const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
+  return { x: a * p0.x + b * c1.x + c * c2.x + d * p3.x, y: a * p0.y + b * c1.y + c * c2.y + d * p3.y };
+}
+function distanceToCubic(q, p0, piece) {
+  const d = (t) => {
+    const c = cubicAt(p0, piece, t);
+    return Math.hypot(c.x - q.x, c.y - q.y);
+  };
+  let best = 0;
+  for (let i = 1; i <= 32; i++) if (d(i / 32) < d(best / 32)) best = i;
+  let lo = Math.max(0, (best - 1) / 32), hi = Math.min(1, (best + 1) / 32);
+  for (let i = 0; i < 30; i++) {
+    const a = lo + (hi - lo) / 3, b = hi - (hi - lo) / 3;
+    if (d(a) < d(b)) hi = b;
+    else lo = a;
+  }
+  return d((lo + hi) / 2);
+}
+function fitError(n, a, b, p0, piece) {
+  let worst = 0;
+  for (let i = 1; i < 16; i++) worst = Math.max(worst, distanceToCubic(unitPoint(n, a + (b - a) * (i / 16)), p0, piece));
+  return worst;
+}
+function fitUnit(n, a, b, tol, depth, out) {
+  const p0 = unitPoint(n, a), p3 = unitPoint(n, b);
+  const samples = [];
+  const params = [];
+  for (let i = 0; i <= 12; i++) {
+    samples.push(unitPoint(n, a + (b - a) * (i / 12)));
+    params.push(i / 12);
+  }
+  const tEnd = unitTangent(n, b);
+  const { cp1, cp2 } = fitCubicWithTangents(samples, unitTangent(n, a), { x: -tEnd.x, y: -tEnd.y }, { params });
+  const piece = [cp1, cp2, p3];
+  if (depth >= 10 || fitError(n, a, b, p0, piece) <= tol) {
+    out.push(piece);
+    return;
+  }
+  const mid = (a + b) / 2;
+  fitUnit(n, a, mid, tol, depth + 1, out);
+  fitUnit(n, mid, b, tol, depth + 1, out);
+}
+var unitCache = /* @__PURE__ */ new Map();
+function unitCubics(n, tol) {
+  if (n === 2) return [[{ x: KAPPA, y: 1 }, { x: 1, y: KAPPA }, { x: 1, y: 0 }]];
+  const key = `${n}:${tol}`;
+  let hit = unitCache.get(key);
+  if (!hit) {
+    hit = [];
+    fitUnit(n, Math.PI / 2, 0, tol, 0, hit);
+    if (unitCache.size > 256) unitCache.clear();
+    unitCache.set(key, hit);
+  }
+  return hit;
+}
+function mapperFor(frame, center) {
+  const ex = sub2(frame.end, center), sy = sub2(frame.start, center);
+  return (p) => ({ x: center.x + p.x * ex.x + p.y * sy.x, y: center.y + p.x * ex.y + p.y * sy.y });
+}
+function cornerCenter(frame) {
+  return { x: frame.start.x + frame.end.x - frame.outer.x, y: frame.start.y + frame.end.y - frame.outer.y };
+}
+function cornerShapePieces(k, frame, tolerance = CORNER_FIT_TOLERANCE) {
+  if (k === 0) return [{ kind: "line", to: frame.end }];
+  const n = exponentOf(k);
+  if (n === Infinity) {
+    const via = k > 0 ? frame.outer : cornerCenter(frame);
+    return [{ kind: "line", to: via }, { kind: "line", to: frame.end }];
+  }
+  const map = mapperFor(frame, k > 0 ? cornerCenter(frame) : frame.outer);
+  return unitCubics(n, tolerance).map(([c1, c2, to]) => ({ kind: "cubic", c1: map(c1), c2: map(c2), to: map(to) }));
+}
+function cornerShapePoint(k, frame, s) {
+  const n = 2 ** Math.abs(k);
+  const map = mapperFor(frame, k > 0 ? cornerCenter(frame) : frame.outer);
+  return map(unitPoint(n, Math.PI / 2 * (1 - s)));
+}
+
+// src/paths/cornerSegments.ts
+var lineSeg = (a, b) => ({ line: true, p0: a, c1: a, c2: b, p3: b });
+function decodeContours(path) {
+  const { commands, coords } = path;
+  const out = [];
+  let cur = null;
+  let flat = 0;
+  let drawn = 0;
+  let bad = false;
+  const last = () => cur.anchors[cur.anchors.length - 1];
+  const push = (p, seg) => {
+    cur.segs.push(seg);
+    cur.anchors.push(p);
+    cur.sources.push(drawn++);
+    flat++;
+  };
+  forEachSegment(commands, coords, (cmd, ci, _px, _py, _i, opens) => {
+    if (opens) {
+      bad = true;
+      return false;
+    }
+    const at = (k) => ({ x: coords[ci + k], y: coords[ci + k + 1] });
+    switch (cmd) {
+      case PATH_M:
+        if (cur) out.push(cur);
+        cur = { anchors: [at(0)], segs: [], closed: false, first: flat++, sources: [drawn++] };
+        break;
+      case PATH_L:
+        push(at(0), lineSeg(last(), at(0)));
+        break;
+      case PATH_C:
+        push(at(4), { line: false, p0: last(), c1: at(0), c2: at(2), p3: at(4) });
+        break;
+      case PATH_Q: {
+        const p0 = last(), q = at(0), p3 = at(2);
+        const c1 = { x: p0.x + 2 / 3 * (q.x - p0.x), y: p0.y + 2 / 3 * (q.y - p0.y) };
+        const c2 = { x: p3.x + 2 / 3 * (q.x - p3.x), y: p3.y + 2 / 3 * (q.y - p3.y) };
+        push(p3, { line: false, p0, c1, c2, p3 });
+        break;
+      }
+      case PATH_Z:
+        if (cur) closeContour(cur, () => flat--);
+        if (cur) out.push(cur);
+        cur = null;
+        break;
+    }
+    return void 0;
+  });
+  if (bad) return null;
+  if (cur) out.push(cur);
+  return out;
+}
+function closeContour(c, unfold) {
+  c.closed = true;
+  const n = c.anchors.length;
+  const a0 = c.anchors[0];
+  const end = c.anchors[n - 1];
+  if (n > 1 && !c.segs[n - 2].line && end.x === a0.x && end.y === a0.y) {
+    c.anchors.pop();
+    c.sources.pop();
+    unfold();
+    return;
+  }
+  c.segs.push(lineSeg(end, a0));
+}
+var LUT_STEPS = 32;
+function segLength(seg) {
+  if (seg.line) return Math.hypot(seg.p3.x - seg.p0.x, seg.p3.y - seg.p0.y);
+  return lut(seg)[LUT_STEPS];
+}
+var lutCache = /* @__PURE__ */ new WeakMap();
+function lut(seg) {
+  let table = lutCache.get(seg);
+  if (table) return table;
+  table = new Float64Array(LUT_STEPS + 1);
+  let prev = seg.p0;
+  for (let i = 1; i <= LUT_STEPS; i++) {
+    const p = pointAt(seg, i / LUT_STEPS);
+    table[i] = table[i - 1] + Math.hypot(p.x - prev.x, p.y - prev.y);
+    prev = p;
+  }
+  lutCache.set(seg, table);
+  return table;
+}
+function paramAtLength(seg, s) {
+  const total = segLength(seg);
+  if (total <= 0) return 0;
+  if (seg.line) return Math.min(1, Math.max(0, s / total));
+  const table = lut(seg);
+  if (s <= 0) return 0;
+  if (s >= total) return 1;
+  let i = 1;
+  while (table[i] < s) i++;
+  const span = table[i] - table[i - 1];
+  const f = span > 0 ? (s - table[i - 1]) / span : 0;
+  return (i - 1 + f) / LUT_STEPS;
+}
+function pointAt(seg, t) {
+  if (seg.line) {
+    return { x: seg.p0.x + (seg.p3.x - seg.p0.x) * t, y: seg.p0.y + (seg.p3.y - seg.p0.y) * t };
+  }
+  const { p0, c1, c2, p3 } = seg;
+  const [x, y] = cubicEvalAt(p0.x, p0.y, c1.x, c1.y, c2.x, c2.y, p3.x, p3.y, t);
+  return { x, y };
+}
+function unit2(x, y) {
+  const l = Math.hypot(x, y);
+  return l > 1e-12 ? { x: x / l, y: y / l } : null;
+}
+function tangentAt(seg, t) {
+  const { p0, c1, c2, p3 } = seg;
+  if (seg.line) return unit2(p3.x - p0.x, p3.y - p0.y);
+  const u = 1 - t;
+  const dx = 3 * (u * u * (c1.x - p0.x) + 2 * u * t * (c2.x - c1.x) + t * t * (p3.x - c2.x));
+  const dy = 3 * (u * u * (c1.y - p0.y) + 2 * u * t * (c2.y - c1.y) + t * t * (p3.y - c2.y));
+  const d = unit2(dx, dy);
+  if (d) return d;
+  if (t < 0.5) return unit2(c2.x - p0.x, c2.y - p0.y) ?? unit2(p3.x - p0.x, p3.y - p0.y);
+  return unit2(p3.x - c1.x, p3.y - c1.y) ?? unit2(p3.x - p0.x, p3.y - p0.y);
+}
+function subCubic(seg, t0, t1) {
+  const { p0, c1, c2, p3 } = seg;
+  let c = [p0.x, p0.y, c1.x, c1.y, c2.x, c2.y, p3.x, p3.y];
+  if (t0 > 0) c = [...splitCubicAt(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], t0)[1]];
+  const t = t0 < 1 ? (t1 - t0) / (1 - t0) : 1;
+  if (t < 1) c = [...splitCubicAt(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], t)[0]];
+  return [{ x: c[2], y: c[3] }, { x: c[4], y: c[5] }, { x: c[6], y: c[7] }];
+}
+
+// src/paths/corners.ts
+var MIN_TURN = 1e-3;
+function contourCuts(path, c) {
+  const n = c.anchors.length;
+  const lengths = c.segs.map(segLength);
+  const cuts = c.anchors.map((a, i) => {
+    const inSeg = i > 0 ? c.segs[i - 1] : c.closed ? c.segs[n - 1] : null;
+    const outSeg = i < c.segs.length ? c.segs[i] : null;
+    if (!inSeg || !outSeg || inSeg === outSeg) return null;
+    const tIn = tangentAt(inSeg, 1);
+    const tOut = tangentAt(outSeg, 0);
+    if (!tIn || !tOut) return null;
+    const turn = Math.acos(Math.max(-1, Math.min(1, tIn.x * tOut.x + tIn.y * tOut.y)));
+    if (turn < MIN_TURN || turn > Math.PI - MIN_TURN) return null;
+    const bx = tOut.x - tIn.x, by = tOut.y - tIn.y;
+    const bl = Math.hypot(bx, by);
+    const halfAngle = (Math.PI - turn) / 2;
+    const spec = cornerAt(path, c.first + i);
+    const want = spec ? spec.radius : 0;
+    return {
+      frame: { index: c.first + i, x: a.x, y: a.y, bisector: { x: bx / bl, y: by / bl }, halfAngle },
+      spec,
+      want,
+      trim: want
+    };
+  });
+  const scale = cuts.map(() => 1);
+  c.segs.forEach((_seg, k) => {
+    const a = k, b = (k + 1) % n;
+    const sum = (cuts[a]?.want ?? 0) + (cuts[b]?.want ?? 0);
+    if (sum <= lengths[k]) return;
+    const f = lengths[k] / sum;
+    scale[a] = Math.min(scale[a], f);
+    scale[b] = Math.min(scale[b], f);
+  });
+  cuts.forEach((cut, i) => {
+    if (cut) cut.trim = cut.want * scale[i];
+  });
+  return cuts;
+}
+function cornerFrames(path) {
+  const contours = decodeContours(path);
+  if (!contours) return [];
+  const out = [];
+  for (const c of contours) {
+    const cuts = contourCuts(path, c);
+    const n = c.anchors.length;
+    cuts.forEach((cut, i) => {
+      if (!cut) return;
+      const prev = (i - 1 + n) % n;
+      const next = (i + 1) % n;
+      const inLen = segLength(c.segs[prev]);
+      const outLen = segLength(c.segs[i]);
+      const room = (len, j) => len - Math.min(len, cuts[j]?.want ?? 0);
+      out.push({
+        ...cut.frame,
+        trim: cut.trim,
+        maxTrim: Math.max(0, Math.min(room(inLen, prev), room(outLen, next)))
+      });
+    });
+  }
+  return out;
+}
+function cornerFrameAt(path, index) {
+  return cornerFrames(path).find((f) => f.index === index) ?? null;
+}
+var expanded = /* @__PURE__ */ new WeakMap();
+function resolveCornersWithSources(path) {
+  if (path.corners === void 0) return { path, anchorSources: null };
+  const hit = expanded.get(path);
+  if (hit) return hit;
+  const out = hasCorners(path) ? expand(path) : { path: withoutCorners(path), anchorSources: null };
+  expanded.set(path, out);
+  return out;
+}
+function resolveCorners(path) {
+  if (path.kind !== "polygon") return path;
+  return resolveCornersWithSources(path).path;
+}
+function remapPerAnchor(values, sources, stride) {
+  const out = new Array(sources.length * stride);
+  for (let i = 0; i < sources.length; i++) {
+    for (let k = 0; k < stride; k++) out[i * stride + k] = values[sources[i] * stride + k];
+  }
+  return out;
+}
+var Emitter = class {
+  b = new PathBuilder();
+  sources = [];
+  src = 0;
+  moveTo(x, y) {
+    this.b.moveTo(x, y);
+    this.sources.push(this.src);
+  }
+  lineTo(x, y) {
+    this.b.lineTo(x, y);
+    this.sources.push(this.src);
+  }
+  curveTo(a, b, c, d, x, y) {
+    this.b.curveTo(a, b, c, d, x, y);
+    this.sources.push(this.src);
+  }
+  close() {
+    this.b.close();
+  }
+};
+function expand(path) {
+  const contours = decodeContours(path);
+  if (!contours) return { path: withoutCorners(path), anchorSources: null };
+  const e = new Emitter();
+  for (const c of contours) emitContour(e, c, contourCuts(path, c));
+  const { commands, coords } = e.b.build();
+  return {
+    path: { ...withoutCorners(path), commands, coords },
+    anchorSources: Uint32Array.from(e.sources)
+  };
+}
+function segSpan(c, cuts, k) {
+  const seg = c.segs[k];
+  const len = segLength(seg);
+  const t0 = paramAtLength(seg, cuts[k]?.trim ?? 0);
+  const t1 = paramAtLength(seg, len - (cuts[(k + 1) % c.anchors.length]?.trim ?? 0));
+  return [t0, Math.max(t0, t1)];
+}
+function cutAfter(c, cuts, spans, k) {
+  const j = (k + 1) % c.anchors.length;
+  const cut = cuts[j];
+  const next = c.segs[j];
+  if (!cut?.spec || cut.trim <= 0 || !next) return null;
+  const seg = c.segs[k];
+  const start = pointAt(seg, spans[k][1]);
+  const end = pointAt(next, spans[j][0]);
+  const frame = shapeFrame({ x: cut.frame.x, y: cut.frame.y }, start, tangentAt(seg, spans[k][1]), end, tangentAt(next, spans[j][0]));
+  return { cut, start, end, pieces: cornerShapePieces(cornerShapeK(cut.spec.shape), frame) };
+}
+function cornerCuts(path) {
+  if (!hasCorners(path)) return [];
+  const out = [];
+  for (const c of decodeContours(path) ?? []) {
+    const cuts = contourCuts(path, c);
+    const spans = c.segs.map((_s, k) => segSpan(c, cuts, k));
+    c.segs.forEach((_seg, k) => {
+      const at = cutAfter(c, cuts, spans, k);
+      if (!at) return;
+      const { frame } = at.cut;
+      out.push({ index: frame.index, anchor: { x: frame.x, y: frame.y }, spec: at.cut.spec, start: at.start, end: at.end, pieces: at.pieces });
+    });
+  }
+  return out;
+}
+function emitContour(b, c, cuts) {
+  const n = c.anchors.length;
+  const spans = c.segs.map((_s, k) => segSpan(c, cuts, k));
+  const start = c.closed && c.segs.length > 0 ? pointAt(c.segs[0], spans[0][0]) : c.anchors[0];
+  b.src = c.sources[0];
+  b.moveTo(start.x, start.y);
+  c.segs.forEach((seg, k) => {
+    const [t0, t1] = spans[k];
+    b.src = c.sources[(k + 1) % n];
+    const closing = c.closed && k === n - 1 && !(cuts[0]?.spec && cuts[0].trim > 0);
+    if (t1 > t0 && !(closing && seg.line)) {
+      if (seg.line) {
+        const p = pointAt(seg, t1);
+        b.lineTo(p.x, p.y);
+      } else {
+        const [c1, c2, p3] = subCubic(seg, t0, t1);
+        b.curveTo(c1.x, c1.y, c2.x, c2.y, p3.x, p3.y);
+      }
+    }
+    const at = cutAfter(c, cuts, spans, k);
+    if (!at) return;
+    const pieces = [...at.pieces];
+    if ((k + 1) % n === 0 && pieces.at(-1)?.kind === "line") pieces.pop();
+    for (const piece of pieces) {
+      if (piece.kind === "line") b.lineTo(piece.to.x, piece.to.y);
+      else b.curveTo(piece.c1.x, piece.c1.y, piece.c2.x, piece.c2.y, piece.to.x, piece.to.y);
+    }
+  });
+  if (c.closed) b.close();
+}
+function shapeFrame(v, p1, t1, p2, t2) {
+  const outer = t1 && t2 ? tangentMeet(p1, t1, p2, t2) : null;
+  const chord = Math.hypot(p2.x - p1.x, p2.y - p1.y);
+  const far = !outer || Math.hypot(outer.x - v.x, outer.y - v.y) > 4 * chord;
+  return { start: p1, end: p2, outer: far ? v : outer };
+}
+function tangentMeet(a, ta, b, tb) {
+  const den = ta.x * tb.y - ta.y * tb.x;
+  if (Math.abs(den) < 1e-9) return null;
+  const s = ((b.x - a.x) * tb.y - (b.y - a.y) * tb.x) / den;
+  return { x: a.x + ta.x * s, y: a.y + ta.y * s };
+}
+
+export { CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, DEFAULT_FLATTEN_TOLERANCE, cornerCenter, cornerCuts, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerShapePoint, decodeContours, defaultOpenFill, fillsOpenSubpaths, fitCubicWithTangents, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, isCornerShape, nextCornerShape, pointInPolygon, pointSegmentDist2, remapPerAnchor, resolveCorners, resolveCornersWithSources, schneiderFit, segmentsCross, setDefaultOpenFill };
+//# sourceMappingURL=chunk-EAKE3N7W.js.map
+//# sourceMappingURL=chunk-EAKE3N7W.js.map