@weasel-js/geom 1.10.1 → 1.11.1

package/dist/chunk-UI3FUWXM.js

@@ -0,0 +1,533 @@
+import { segmentEnds, isStraightSegment, anchorsToPath, pathToAnchors } from './chunk-Q66NA2FU.js';
+import { cubicPointAt } from './chunk-B53BERKG.js';
+
+// src/paths/curvature.ts
+function cubicDerivativeAt(p0, p1, p2, p3, t) {
+  const u = 1 - t;
+  return {
+    x: 3 * u * u * (p1.x - p0.x) + 6 * u * t * (p2.x - p1.x) + 3 * t * t * (p3.x - p2.x),
+    y: 3 * u * u * (p1.y - p0.y) + 6 * u * t * (p2.y - p1.y) + 3 * t * t * (p3.y - p2.y)
+  };
+}
+function cubicSecondDerivativeAt(p0, p1, p2, p3, t) {
+  const u = 1 - t;
+  return {
+    x: 6 * u * (p2.x - 2 * p1.x + p0.x) + 6 * t * (p3.x - 2 * p2.x + p1.x),
+    y: 6 * u * (p2.y - 2 * p1.y + p0.y) + 6 * t * (p3.y - 2 * p2.y + p1.y)
+  };
+}
+function cubicCurvatureAt(p0, p1, p2, p3, t) {
+  const d1 = cubicDerivativeAt(p0, p1, p2, p3, t);
+  const d2 = cubicSecondDerivativeAt(p0, p1, p2, p3, t);
+  const den = Math.pow(d1.x * d1.x + d1.y * d1.y, 1.5);
+  if (den < 1e-12) return 0;
+  return (d1.x * d2.y - d1.y * d2.x) / den;
+}
+var END_NUDGE = 1e-3;
+function sampleCount(opts) {
+  return Math.max(2, Math.round(opts.samplesPerSegment ?? 24));
+}
+function combTeeth(source, opts) {
+  const samples = sampleCount(opts);
+  const teeth = [];
+  for (let i = 0; i < samples; i++) teeth.push(toothAt(source, i / (samples - 1), opts.scale));
+  return teeth;
+}
+function cubicCurvatureSource(p0, p1, p2, p3) {
+  return {
+    pointAt: (t) => cubicPointAt(p0, p1, p2, p3, t),
+    tangentAt: (t) => cubicDerivativeAt(p0, p1, p2, p3, t),
+    curvatureAt: (t) => cubicCurvatureAt(p0, p1, p2, p3, t)
+  };
+}
+function curvatureComb(set, opts) {
+  const out = [];
+  for (let sub = 0; sub < set.anchors.length; sub++) {
+    const count = set.anchors[sub].length - (set.closed[sub] ? 0 : 1);
+    for (let segIdx = 0; segIdx < count; segIdx++) {
+      const ends = segmentEnds(set.anchors, set.closed, sub, segIdx);
+      if (!ends || isStraightSegment(ends.a, ends.b)) continue;
+      const { a, b } = ends;
+      const source = cubicCurvatureSource(a, a.outHandle ?? a, b.inHandle ?? b, b);
+      out.push({ sub, segIdx, teeth: combTeeth(source, opts) });
+    }
+  }
+  return out;
+}
+function toothAt(source, t, scale) {
+  const at = source.pointAt(t);
+  let d = source.tangentAt(t);
+  let k = source.curvatureAt(t);
+  if (Math.hypot(d.x, d.y) < 1e-9) {
+    const inner = t < 0.5 ? t + END_NUDGE : t - END_NUDGE;
+    d = source.tangentAt(inner);
+    k = source.curvatureAt(inner);
+  }
+  const len = Math.hypot(d.x, d.y);
+  if (len < 1e-12) return { x: at.x, y: at.y, tipX: at.x, tipY: at.y, curvature: 0 };
+  const nx = -d.y / len;
+  const ny = d.x / len;
+  return { x: at.x, y: at.y, tipX: at.x - nx * k * scale, tipY: at.y - ny * k * scale, curvature: k };
+}
+
+// src/paths/eulerSpiral.ts
+var STEPS = 48;
+var MAX_ANGLE = Math.PI * 0.95;
+var clampAngle = (a) => Math.max(-MAX_ANGLE, Math.min(MAX_ANGLE, a));
+function integrateEuler(k0, k1, upTo = 1, k2 = 0, k3 = 0) {
+  const n = Math.max(2, Math.ceil(STEPS * upTo / 2) * 2);
+  const h = upTo / n;
+  let x = 0;
+  let y = 0;
+  for (let i = 0; i <= n; i++) {
+    const u = i * h - 0.5;
+    const phi = k0 * u + u * u * (k1 / 2 + u * (k2 / 6 + u * k3 / 24));
+    const w = i === 0 || i === n ? 1 : i % 2 === 1 ? 4 : 2;
+    x += w * Math.cos(phi);
+    y += w * Math.sin(phi);
+  }
+  return { x: x * h / 3, y: y * h / 3 };
+}
+function startError(k0, k1, k2, k3, th0) {
+  const c = integrateEuler(k0, k1, 1, k2, k3);
+  return -k0 / 2 + k1 / 8 - k2 / 48 + k3 / 384 - Math.atan2(c.y, c.x) - th0;
+}
+function fitEulerSegment(th0, th1, k2 = 0, k3 = 0) {
+  const t0 = clampAngle(th0);
+  const t1 = clampAngle(th1);
+  const k0 = t1 - t0 - k2 / 24;
+  let k1 = 6 * (t0 + t1) - k3 / 40;
+  for (let iter = 0; iter < 12; iter++) {
+    const e = startError(k0, k1, k2, k3, t0);
+    if (Math.abs(e) < 1e-12) break;
+    const d = (startError(k0, k1 + 1e-6, k2, k3, t0) - e) / 1e-6;
+    if (!Number.isFinite(d) || Math.abs(d) < 1e-12) break;
+    k1 -= e / d;
+  }
+  const c = integrateEuler(k0, k1, 1, k2, k3);
+  return { k0, k1, k2, k3, ratio: Math.hypot(c.x, c.y), chordAngle: Math.atan2(c.y, c.x) };
+}
+function placeEulerSegment(fit, p0, p1) {
+  const chord = Math.hypot(p1.x - p0.x, p1.y - p0.y);
+  const length = fit.ratio > 1e-9 ? chord / fit.ratio : chord;
+  const rotation = Math.atan2(p1.y - p0.y, p1.x - p0.x) - fit.chordAngle;
+  return { ...fit, p0, p1, length, rotation };
+}
+function eulerPointAt(seg, s) {
+  const c = integrateEuler(seg.k0, seg.k1, s, seg.k2, seg.k3);
+  const cos = Math.cos(seg.rotation);
+  const sin = Math.sin(seg.rotation);
+  return {
+    x: seg.p0.x + seg.length * (c.x * cos - c.y * sin),
+    y: seg.p0.y + seg.length * (c.x * sin + c.y * cos)
+  };
+}
+function eulerAngleAt(seg, s) {
+  const u = s - 0.5;
+  return seg.rotation + seg.k0 * u + u * u * (seg.k1 / 2 + u * (seg.k2 / 6 + u * seg.k3 / 24));
+}
+var bendAt = (f, u) => f.k0 + u * (f.k1 + u * (f.k2 / 2 + u * f.k3 / 6));
+function eulerCurvatureAt(seg, s) {
+  if (seg.length < 1e-12) return 0;
+  return bendAt(seg, s - 0.5) / seg.length;
+}
+function eulerCurvatureDerivativesAt(seg, s) {
+  if (seg.length < 1e-12) return [0, 0];
+  const u = s - 0.5;
+  return [
+    (seg.k1 + u * (seg.k2 + u * seg.k3 / 2)) / seg.length ** 2,
+    (seg.k2 + u * seg.k3) / seg.length ** 3
+  ];
+}
+var SAMPLES = 16;
+function fitHandleLengths(p0, p1, u0, u1, samples, ts) {
+  let m00 = 0, m01 = 0, m11 = 0, r0 = 0, r1 = 0;
+  samples.forEach((q, i) => {
+    const t = ts[i];
+    const mt = 1 - t;
+    const b0 = mt * mt * mt + 3 * mt * mt * t;
+    const b3 = 3 * mt * t * t + t * t * t;
+    const ex = q.x - (b0 * p0.x + b3 * p1.x);
+    const ey = q.y - (b0 * p0.y + b3 * p1.y);
+    const f1 = 3 * mt * mt * t;
+    const f2 = 3 * mt * t * t;
+    const ax = f1 * u0.x, ay = f1 * u0.y;
+    const bx = -f2 * u1.x, by = -f2 * u1.y;
+    m00 += ax * ax + ay * ay;
+    m01 += ax * bx + ay * by;
+    m11 += bx * bx + by * by;
+    r0 += ax * ex + ay * ey;
+    r1 += bx * ex + by * ey;
+  });
+  const det = m00 * m11 - m01 * m01;
+  if (Math.abs(det) < 1e-12) return null;
+  const a = (r0 * m11 - r1 * m01) / det;
+  const b = (m00 * r1 - m01 * r0) / det;
+  return a > 0 && b > 0 && Number.isFinite(a) && Number.isFinite(b) ? [a, b] : null;
+}
+function nearerT(p, q, t) {
+  const mt = 1 - t;
+  const at = (c0, c1, c2, c3) => mt * mt * mt * c0 + 3 * mt * mt * t * c1 + 3 * mt * t * t * c2 + t * t * t * c3;
+  const d1 = (c0, c1, c2, c3) => 3 * (mt * mt * (c1 - c0) + 2 * mt * t * (c2 - c1) + t * t * (c3 - c2));
+  const d2 = (c0, c1, c2, c3) => 6 * (mt * (c2 - 2 * c1 + c0) + t * (c3 - 2 * c2 + c1));
+  const ex = at(p[0].x, p[1].x, p[2].x, p[3].x) - q.x;
+  const ey = at(p[0].y, p[1].y, p[2].y, p[3].y) - q.y;
+  const dx = d1(p[0].x, p[1].x, p[2].x, p[3].x);
+  const dy = d1(p[0].y, p[1].y, p[2].y, p[3].y);
+  const ddx = d2(p[0].x, p[1].x, p[2].x, p[3].x);
+  const ddy = d2(p[0].y, p[1].y, p[2].y, p[3].y);
+  const den = dx * dx + dy * dy + ex * ddx + ey * ddy;
+  if (Math.abs(den) < 1e-12) return t;
+  return Math.min(1, Math.max(0, t - (ex * dx + ey * dy) / den));
+}
+function eulerSegmentCubic(seg) {
+  const { p0, p1 } = seg;
+  const a0 = eulerAngleAt(seg, 0);
+  const a1 = eulerAngleAt(seg, 1);
+  const u0 = { x: Math.cos(a0), y: Math.sin(a0) };
+  const u1 = { x: Math.cos(a1), y: Math.sin(a1) };
+  const samples = [];
+  const ts = [];
+  for (let i = 1; i < SAMPLES; i++) {
+    samples.push(eulerPointAt(seg, i / SAMPLES));
+    ts.push(i / SAMPLES);
+  }
+  const chord = Math.hypot(p1.x - p0.x, p1.y - p0.y);
+  let lengths = [chord / 3, chord / 3];
+  const handles = ([a, b]) => ({
+    c1: { x: p0.x + a * u0.x, y: p0.y + a * u0.y },
+    c2: { x: p1.x - b * u1.x, y: p1.y - b * u1.y }
+  });
+  for (let round = 0; round < 4; round++) {
+    const fit = fitHandleLengths(p0, p1, u0, u1, samples, ts);
+    if (!fit) break;
+    lengths = fit;
+    const { c1, c2 } = handles(lengths);
+    const ctrl = [p0, c1, c2, p1];
+    samples.forEach((q, i) => {
+      ts[i] = nearerT(ctrl, q, ts[i]);
+    });
+  }
+  return handles(lengths);
+}
+function subEulerSegment(seg, s0, s1) {
+  const d = s1 - s0;
+  const m = (s0 + s1) / 2 - 0.5;
+  const k0 = bendAt(seg, m) * d;
+  const k1 = (seg.k1 + m * (seg.k2 + m * seg.k3 / 2)) * d ** 2;
+  const k2 = (seg.k2 + m * seg.k3) * d ** 3;
+  const k3 = seg.k3 * d ** 4;
+  const c = integrateEuler(k0, k1, 1, k2, k3);
+  const fit = { k0, k1, k2, k3, ratio: Math.hypot(c.x, c.y), chordAngle: Math.atan2(c.y, c.x) };
+  return placeEulerSegment(fit, eulerPointAt(seg, s0), eulerPointAt(seg, s1));
+}
+function eulerCubicError(seg, c1, c2) {
+  const ctrl = [seg.p0, c1, c2, seg.p1];
+  let worst = 0;
+  for (const s of [0.2, 0.4, 0.5, 0.6, 0.8]) {
+    const q = eulerPointAt(seg, s);
+    let t = s;
+    for (let i = 0; i < 4; i++) t = nearerT(ctrl, q, t);
+    const mt = 1 - t;
+    const x = mt * mt * mt * seg.p0.x + 3 * mt * mt * t * c1.x + 3 * mt * t * t * c2.x + t * t * t * seg.p1.x;
+    const y = mt * mt * mt * seg.p0.y + 3 * mt * mt * t * c1.y + 3 * mt * t * t * c2.y + t * t * t * seg.p1.y;
+    worst = Math.max(worst, Math.hypot(x - q.x, y - q.y));
+  }
+  return worst;
+}
+
+// src/paths/spiro.ts
+var SPIRO_KINDS = ["smooth", "g4", "corner", "left", "right"];
+var TAU = Math.PI * 2;
+var wrap = (a) => a - TAU * Math.round(a / TAU);
+var angleOf = (p, q) => Math.atan2(q.y - p.y, q.x - p.x);
+var distance = (p, q) => Math.hypot(q.x - p.x, q.y - p.y);
+function isSpiroKind(kind) {
+  return SPIRO_KINDS.includes(kind);
+}
+function buildSystem(points, closed) {
+  const n = points.length;
+  const count = closed ? n : n - 1;
+  const ends = [];
+  const straight = [];
+  const slot = [];
+  const cubic = [];
+  let unknowns = 0;
+  for (let i = 0; i < count; i++) {
+    const j = (i + 1) % n;
+    ends.push(j);
+    const line = points[i].kind === "right" || points[j].kind === "left" || distance(points[i], points[j]) < 1e-9;
+    straight.push(line);
+    slot.push(line ? -1 : unknowns);
+    const higher = !line && (points[i].kind === "g4" || points[j].kind === "g4");
+    cubic.push(higher);
+    if (!line) unknowns += higher ? 4 : 2;
+  }
+  return { points, ends, straight, slot, cubic, unknowns };
+}
+function sides(sys, closed, i) {
+  const n = sys.points.length;
+  const count = sys.ends.length;
+  const side = (seg) => {
+    if (seg < 0 || seg >= count) return { kind: "none" };
+    if (sys.straight[seg]) return { kind: "line", angle: angleOf(sys.points[seg], sys.points[sys.ends[seg]]) };
+    return { kind: "curve", seg };
+  };
+  const into = i > 0 ? i - 1 : closed ? n - 1 : -1;
+  const outOf = closed || i < n - 1 ? i : -1;
+  return [side(into), side(outOf)];
+}
+function fitSegment(sys, s, x) {
+  const p0 = sys.points[s];
+  const p1 = sys.points[sys.ends[s]];
+  const chord = angleOf(p0, p1);
+  const k = sys.slot[s];
+  const fit = sys.cubic[s] ? fitEulerSegment(wrap(x[k] - chord), wrap(x[k + 1] - chord), x[k + 2], x[k + 3]) : fitEulerSegment(wrap(x[k] - chord), wrap(x[k + 1] - chord));
+  const seg = placeEulerSegment(fit, p0, p1);
+  const startAngle = eulerAngleAt(seg, 0);
+  return { seg, chord: distance(p0, p1), startAngle, endAngle: eulerAngleAt(seg, 1), cubic: sys.cubic[s] };
+}
+var bend = (f, at) => eulerCurvatureAt(f.seg, at) * f.chord;
+var twist = (f, at) => eulerCurvatureDerivativesAt(f.seg, at)[1] * f.chord ** 3;
+function g4Join(fa, fb) {
+  const scale = (fa.chord + fb.chord) / 2;
+  const [a1, a2] = eulerCurvatureDerivativesAt(fa.seg, 1);
+  const [b1, b2] = eulerCurvatureDerivativesAt(fb.seg, 0);
+  return [
+    wrap(fa.endAngle - fb.startAngle),
+    (eulerCurvatureAt(fa.seg, 1) - eulerCurvatureAt(fb.seg, 0)) * scale,
+    (a1 - b1) * scale ** 2,
+    (a2 - b2) * scale ** 3
+  ];
+}
+function residuals(sys, closed, fits) {
+  const out = [];
+  const fitOf = (side) => fits[side.seg];
+  for (let i = 0; i < sys.points.length; i++) {
+    const [a, b] = sides(sys, closed, i);
+    const kind = sys.points[i].kind;
+    const ac = a.kind === "curve";
+    const bc = b.kind === "curve";
+    if (!ac && !bc) continue;
+    if (kind === "g4" && ac && bc) {
+      out.push(...g4Join(fitOf(a), fitOf(b)));
+      continue;
+    }
+    if (kind === "smooth" && ac && bc) {
+      const fa = fitOf(a), fb = fitOf(b);
+      out.push(...g4Join(fa, fb).slice(0, 2));
+      if (fa.cubic) out.push(twist(fa, 1));
+      if (fb.cubic) out.push(twist(fb, 0));
+      continue;
+    }
+    for (const [side, other, at] of [[a, b, 1], [b, a, 0]]) {
+      if (side.kind !== "curve") continue;
+      const f = fitOf(side);
+      const angle = at === 1 ? f.endAngle : f.startAngle;
+      const followsLine = other.kind === "line" && kind !== "corner";
+      out.push(followsLine ? wrap(angle - other.angle) : bend(f, at));
+      if (f.cubic) out.push(twist(f, at));
+    }
+  }
+  return out;
+}
+function initialGuess(sys, closed) {
+  const x = new Array(sys.unknowns).fill(0);
+  const n = sys.points.length;
+  const tangentAt = (i, seg) => {
+    const chord = angleOf(sys.points[seg], sys.points[sys.ends[seg]]);
+    const [a, b] = sides(sys, closed, i);
+    if (sys.points[i].kind === "corner" || a.kind === "none" || b.kind === "none") return chord;
+    if (a.kind === "line") return a.angle;
+    if (b.kind === "line") return b.angle;
+    const prev = sys.points[(i - 1 + n) % n];
+    const next = sys.points[(i + 1) % n];
+    const pin = angleOf(prev, sys.points[i]);
+    const pout = angleOf(sys.points[i], next);
+    return pin + wrap(pout - pin) / 2;
+  };
+  for (let s = 0; s < sys.ends.length; s++) {
+    const k = sys.slot[s];
+    if (k < 0) continue;
+    x[k] = tangentAt(s, s);
+    x[k + 1] = tangentAt(sys.ends[s], s);
+  }
+  return x;
+}
+function solveLinear(m, r) {
+  const n = r.length;
+  for (let c = 0; c < n; c++) {
+    let p = c;
+    for (let i = c + 1; i < n; i++) if (Math.abs(m[i][c]) > Math.abs(m[p][c])) p = i;
+    if (Math.abs(m[p][c]) < 1e-14) return null;
+    [m[c], m[p]] = [m[p], m[c]];
+    [r[c], r[p]] = [r[p], r[c]];
+    for (let i = c + 1; i < n; i++) {
+      const f = m[i][c] / m[c][c];
+      if (f === 0) continue;
+      for (let j = c; j < n; j++) m[i][j] -= f * m[c][j];
+      r[i] -= f * r[c];
+    }
+  }
+  const out = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    let v = r[i];
+    for (let j = i + 1; j < n; j++) v -= m[i][j] * out[j];
+    out[i] = v / m[i][i];
+  }
+  return out;
+}
+var norm = (v) => Math.sqrt(v.reduce((s, e) => s + e * e, 0));
+function solveSpiro(points, closed) {
+  if (points.length < 2) return [];
+  const sys = buildSystem(points, closed && points.length > 2);
+  const isClosed = closed && points.length > 2;
+  let x = initialGuess(sys, isClosed);
+  const fitAll = (v) => sys.ends.map((_, s) => sys.slot[s] < 0 ? null : fitSegment(sys, s, v));
+  let fits = fitAll(x);
+  let r = residuals(sys, isClosed, fits);
+  for (let iter = 0; iter < 40 && sys.unknowns > 0; iter++) {
+    const err = norm(r);
+    if (err < 1e-10) break;
+    const jac = r.map(() => new Array(sys.unknowns).fill(0));
+    for (let s = 0; s < sys.ends.length; s++) {
+      const k = sys.slot[s];
+      if (k < 0) continue;
+      for (let u = k; u < k + (sys.cubic[s] ? 4 : 2); u++) {
+        const h = 1e-6;
+        const xs = x.slice();
+        xs[u] += h;
+        const moved = fits.slice();
+        moved[s] = fitSegment(sys, s, xs);
+        const rs = residuals(sys, isClosed, moved);
+        for (let e = 0; e < r.length; e++) jac[e][u] = (rs[e] - r[e]) / h;
+      }
+    }
+    const step = solveLinear(jac, r.map((v) => -v));
+    if (!step) break;
+    let t = 1;
+    let accepted = false;
+    for (let tries = 0; tries < 12; tries++, t /= 2) {
+      const xt = x.map((v, i) => v + t * step[i]);
+      const ft = fitAll(xt);
+      const rt = residuals(sys, isClosed, ft);
+      if (norm(rt) < err) {
+        x = xt;
+        fits = ft;
+        r = rt;
+        accepted = true;
+        break;
+      }
+    }
+    if (!accepted) break;
+  }
+  return sys.ends.map((end, s) => ({
+    from: { x: points[s].x, y: points[s].y },
+    to: { x: points[end].x, y: points[end].y },
+    spiral: sys.slot[s] < 0 ? null : fits[s].seg
+  }));
+}
+
+// src/paths/spiroPath.ts
+var MAX_PIECES = 16;
+function cubicPieces(spiral, tol) {
+  let best = [];
+  for (let m = 1; m <= MAX_PIECES; m++) {
+    best = [];
+    let fits = true;
+    for (let j = 0; j < m; j++) {
+      const piece = m === 1 ? spiral : subEulerSegment(spiral, j / m, (j + 1) / m);
+      const { c1, c2 } = eulerSegmentCubic(piece);
+      best.push({ end: piece, c1, c2 });
+      if (eulerCubicError(piece, c1, c2) > tol * spiral.length) fits = false;
+    }
+    if (fits) break;
+  }
+  return best;
+}
+function contourAnchors(c, tol) {
+  const anchors = [];
+  const at = [];
+  const segments = solveSpiro(c.points, c.closed);
+  let arriving = null;
+  c.points.forEach((p, i) => {
+    at.push(anchors.length);
+    anchors.push({ x: p.x, y: p.y, ...arriving ? { inHandle: arriving } : {} });
+    arriving = null;
+    const spiral = segments[i]?.spiral;
+    if (!spiral) return;
+    const pieces = cubicPieces(spiral, tol);
+    pieces.forEach((piece, j) => {
+      anchors[anchors.length - 1].outHandle = { x: piece.c1.x, y: piece.c1.y };
+      const c2 = { x: piece.c2.x, y: piece.c2.y };
+      if (j < pieces.length - 1) anchors.push({ x: piece.end.p1.x, y: piece.end.p1.y, inHandle: c2 });
+      else arriving = c2;
+    });
+  });
+  if (arriving) anchors[0].inHandle = arriving;
+  return { anchors, at };
+}
+function spiroToPath(contours, options = {}) {
+  const tol = options.tolerance ?? 1e-4;
+  const subs = [];
+  const closed = [];
+  const at = [];
+  let base = 0;
+  for (const c of contours) {
+    if (c.points.length === 0) continue;
+    const written = contourAnchors(c, tol);
+    subs.push(written.anchors);
+    closed.push(c.closed && c.points.length > 2);
+    at.push(...written.at.map((i) => i + base));
+    base += written.anchors.length;
+  }
+  return { path: anchorsToPath(subs, closed, options.like), at };
+}
+function spiroContoursOf(path, kinds, at) {
+  if (kinds.length !== at.length || at.length === 0) return null;
+  const { anchors, closed } = pathToAnchors(path);
+  const contours = [];
+  let flat = 0;
+  let k = 0;
+  for (let s = 0; s < anchors.length; s++) {
+    const sub = anchors[s];
+    if (at[k] !== flat) return null;
+    const points = [];
+    while (k < at.length && at[k] < flat + sub.length) {
+      if (k > 0 && at[k] <= at[k - 1]) return null;
+      const a = sub[at[k] - flat];
+      points.push({ x: a.x, y: a.y, kind: kinds[k] });
+      k++;
+    }
+    contours.push({ points, closed: closed[s] });
+    flat += sub.length;
+  }
+  return k === at.length ? contours : null;
+}
+function spiroControlPath(contours) {
+  return anchorsToPath(
+    contours.map((c) => c.points.map((p) => ({ x: p.x, y: p.y }))),
+    contours.map((c) => c.closed)
+  );
+}
+var key = (x, y) => `${Math.round(x * 1e3)},${Math.round(y * 1e3)}`;
+function spiroContoursFromControl(control, before, fallback = "smooth") {
+  const { anchors, closed } = pathToAnchors(control);
+  const old = before.flatMap((c) => c.points);
+  const count = anchors.reduce((n, sub) => n + sub.length, 0);
+  const byPlace = /* @__PURE__ */ new Map();
+  for (const p of old) if (!byPlace.has(key(p.x, p.y))) byPlace.set(key(p.x, p.y), p.kind);
+  let i = 0;
+  return anchors.map((sub, s) => ({
+    closed: closed[s],
+    points: sub.map((a) => {
+      const kind = count === old.length ? old[i].kind : byPlace.get(key(a.x, a.y)) ?? fallback;
+      i++;
+      return { x: a.x, y: a.y, kind };
+    })
+  }));
+}
+
+export { SPIRO_KINDS, combTeeth, cubicCurvatureAt, cubicCurvatureSource, cubicDerivativeAt, curvatureComb, eulerAngleAt, eulerCurvatureAt, eulerCurvatureDerivativesAt, eulerPointAt, fitEulerSegment, isSpiroKind, placeEulerSegment, solveSpiro, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath };
+//# sourceMappingURL=chunk-UI3FUWXM.js.map
+//# sourceMappingURL=chunk-UI3FUWXM.js.map