pantograph2d 0.7.0 → 0.8.0

package/dist/pantograph.js

@@ -1,616 +1,581 @@
-import { o as Pt, D } from "./draw-825692f1.js";
-import { d as dn } from "./draw-825692f1.js";
-import { F as p, L as P, D as h, f as O, r as wt, z as mt, s as Mt, a as It, c as St, i as vt, S as C, l as $t, d as m, b as At, p as Lt, n as K, e as E, g as kt, h as Et, j as bt, k as yt, m as j, o as M, A as v, q as tt, t as I, u as Ct, v as Ft, E as nt, R as Dt, Q as et, C as it, w as xt, B as Rt } from "./Diagram-8c3c5e1b.js";
-import { x as wn } from "./Diagram-8c3c5e1b.js";
-function S(t) {
-  if (t instanceof p)
+var lt = Object.defineProperty;
+var ut = (t, e, n) => e in t ? lt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var p = (t, e, n) => (ut(t, typeof e != "symbol" ? e + "" : e, n), n);
+import { o as gt, D } from "./draw-c7b2705c.js";
+import { d as Pe } from "./draw-c7b2705c.js";
+import { F as d, L as P, D as g, f as B, s as ht, a as pt, c as dt, i as mt, S as C, l as Pt, p as wt, b as Mt, d as X, e as It } from "./Diagram-2450b2e6.js";
+import { g as Me } from "./Diagram-2450b2e6.js";
+import { r as St, z as bt, l as Lt, d as w, n as Y, s as E, a as vt, b as At, p as kt, c as j, L as S, A as b, e as M, t as Et, f as yt, B as Ft, E as Ct, Q as xt, C as Dt } from "./QuadraticBezier-e116a2d6.js";
+import { s as Rt, a as Ot, b as Bt, c as $t, d as Gt, w as z } from "./wrapSVG-0ec8a111.js";
+function I(t) {
+  if (t instanceof d)
     return [t];
   if (t instanceof P)
-    return [new p(t)];
-  if (t instanceof h)
+    return [new d(t)];
+  if (t instanceof g)
     return t.figures;
   throw new Error("Unknown shape");
 }
-function st(t, n, e = 1e-9) {
-  let i = [];
-  const r = [], s = new Array(n.segments.length).fill(0).map(() => []);
-  n.segments.forEach((c, f) => {
+function tt(t, e, n = 1e-9) {
+  let s = [];
+  const r = [], i = new Array(e.segments.length).fill(0).map(() => []);
+  e.segments.forEach((c, f) => {
     t.segments.forEach((a) => {
-      const { intersections: u, overlaps: d } = O(
+      const { intersections: u, overlaps: m } = B(
         c,
         a,
-        e
+        n
       );
-      i.push(...u), s[f].push(...u), r.push(...d);
-      const g = d.flatMap((l) => [
+      s.push(...u), i[f].push(...u), r.push(...m);
+      const h = m.flatMap((l) => [
         l.firstPoint,
         l.lastPoint
       ]);
-      i.push(...g), s[f].push(...g);
+      s.push(...h), i[f].push(...h);
     });
-  }), i = wt(i, e);
-  const o = mt([n.segments, s]).flatMap(([c, f]) => f.length ? c.splitAt(f) : [c]);
+  }), s = St(s, n);
+  const o = bt([e.segments, i]).flatMap(([c, f]) => f.length ? c.splitAt(f) : [c]);
   return Array.from(
-    Mt(
+    ht(
       o,
-      i,
+      s,
       r
     )
   );
 }
-function B(t, n, e = !1) {
-  return st(n, t).filter((r) => {
-    const s = r.segments[0].midPoint;
-    return n.onStroke(s) ? !e : !n.contains(s);
+function $(t, e, n = !1) {
+  return tt(e, t).filter((r) => {
+    const i = r.segments[0].midPoint;
+    return e.onStroke(i) ? !n : !e.contains(i);
   });
 }
-function G(t, n, e = !1) {
-  return st(n, t).filter((r) => {
-    const s = r.segments[0].midPoint;
-    return n.onStroke(s) ? !e : n.contains(s);
+function G(t, e, n = !1) {
+  return tt(e, t).filter((r) => {
+    const i = r.segments[0].midPoint;
+    return e.onStroke(i) ? !n : e.contains(i);
   });
 }
-function z(t, n, e = !1) {
-  const i = B(
+function V(t, e, n = !1) {
+  const s = $(
     t,
-    n.contour,
-    e
-  ), r = n.holes.flatMap(
-    (s) => G(t, s, e)
+    e.contour,
+    n
+  ), r = e.holes.flatMap(
+    (i) => G(t, i, n)
   );
-  return [...i, ...r];
+  return [...s, ...r];
 }
-function _(t, n, e = !1) {
-  let i = G(
+function _(t, e, n = !1) {
+  let s = G(
     t,
-    n.contour,
-    e
+    e.contour,
+    n
   );
-  return n.holes.forEach((r) => {
-    i = i.flatMap(
-      (s) => B(s, r, e)
+  return e.holes.forEach((r) => {
+    s = s.flatMap(
+      (i) => $(i, r, n)
     );
-  }), i;
+  }), s;
 }
-function Ot(t, n) {
-  return new h(
-    It(S(t), S(n))
+function Tt(t, e) {
+  return new g(
+    pt(I(t), I(e))
   );
 }
-function b(t) {
+function y(t) {
   return t.reduce(
-    (n, e) => Ot(n, e),
-    new h()
+    (e, n) => Tt(e, n),
+    new g()
   );
 }
-function rt(t, n) {
-  return new h(
-    St(S(t), S(n))
+function et(t, e) {
+  return new g(
+    dt(I(t), I(e))
   );
 }
-function sn(t, n) {
-  return new h(
-    vt(S(t), S(n))
+function oe(t, e) {
+  return new g(
+    mt(I(t), I(e))
   );
 }
-function rn(t, n, e = !0) {
-  if (n instanceof P)
-    return B(t, n, e);
-  if (n instanceof p)
-    return z(t, n, e);
-  let i = [new C([...t.segments])];
-  return n.figures.forEach((r) => {
-    i = i.flatMap((s) => z(s, r, e));
-  }), i;
-}
-function on(t, n, e = !1) {
-  if (n instanceof P)
-    return G(t, n, e);
-  if (n instanceof p)
-    return _(t, n, e);
-  let i = [new C([...t.segments])];
-  return n.figures.forEach((r) => {
-    i = i.flatMap((s) => _(s, r, e));
-  }), i;
-}
-function q(t) {
+function ae(t, e, n = !0) {
+  if (e instanceof P)
+    return $(t, e, n);
+  if (e instanceof d)
+    return V(t, e, n);
+  let s = [new C([...t.segments])];
+  return e.figures.forEach((r) => {
+    s = s.flatMap((i) => V(i, r, n));
+  }), s;
+}
+function ce(t, e, n = !1) {
+  if (e instanceof P)
+    return G(t, e, n);
+  if (e instanceof d)
+    return _(t, e, n);
+  let s = [new C([...t.segments])];
+  return e.figures.forEach((r) => {
+    s = s.flatMap((i) => _(i, r, n));
+  }), s;
+}
+function N(t) {
   return t < 0 ? "before" : t > 1 ? "after" : "between";
 }
-const N = (t, n, e) => {
-  if (e === "before")
-    return t.distanceFrom(n.firstPoint);
-  if (e === "after")
-    return t.distanceFrom(n.lastPoint);
+const q = (t, e, n) => {
+  if (n === "before")
+    return t.distanceFrom(e.firstPoint);
+  if (n === "after")
+    return t.distanceFrom(e.lastPoint);
   throw new Error("Invalid position");
 };
-function Bt(t, n) {
-  const e = $t(t, n);
-  if (e === "parallel")
+function Ut(t, e) {
+  const n = Lt(t, e);
+  if (n === "parallel")
     return Math.min(
-      t.distanceFrom(n.firstPoint),
-      t.distanceFrom(n.lastPoint)
+      t.distanceFrom(e.firstPoint),
+      t.distanceFrom(e.lastPoint)
     );
-  const { intersectionParam1: i, intersectionParam2: r } = e, s = q(i), o = q(r);
-  if (s === "between" && o === "between")
+  const { intersectionParam1: s, intersectionParam2: r } = n, i = N(s), o = N(r);
+  if (i === "between" && o === "between")
     return 0;
-  if (s === "between" && o !== "between")
-    return N(t, n, o);
-  if (o === "between" && s !== "between")
-    return N(n, t, s);
-  if (s === "before" && o === "before")
-    return m(t.firstPoint, n.firstPoint);
-  if (s === "after" && o === "after")
-    return m(t.lastPoint, n.lastPoint);
-  if (s === "before" && o === "after")
-    return m(t.firstPoint, n.lastPoint);
-  if (s === "after" && o === "before")
-    return m(t.lastPoint, n.firstPoint);
+  if (i === "between" && o !== "between")
+    return q(t, e, o);
+  if (o === "between" && i !== "between")
+    return q(e, t, i);
+  if (i === "before" && o === "before")
+    return w(t.firstPoint, e.firstPoint);
+  if (i === "after" && o === "after")
+    return w(t.lastPoint, e.lastPoint);
+  if (i === "before" && o === "after")
+    return w(t.firstPoint, e.lastPoint);
+  if (i === "after" && o === "before")
+    return w(t.lastPoint, e.firstPoint);
   throw new Error("Invalid position");
 }
-function Q(t, n) {
-  if (At(t, n).length > 0)
+function J(t, e) {
+  if (Pt(t, e).length > 0)
     return 0;
-  const e = Lt(t, n.center);
-  if (t.isOnSegment(e)) {
-    const i = m(e, n.center);
-    if (Math.abs(i - n.radius) < t.precision && n.isOnSegment(e))
+  const n = wt(t, e.center);
+  if (t.isOnSegment(n)) {
+    const s = w(n, e.center);
+    if (Math.abs(s - e.radius) < t.precision && e.isOnSegment(n))
       return 0;
-    if (i - n.radius > t.precision) {
-      const r = K(
-        E(e, n.center)
-      ), s = kt(
-        n.center,
-        Et(r, n.radius)
+    if (s - e.radius > t.precision) {
+      const r = Y(
+        E(n, e.center)
+      ), i = vt(
+        e.center,
+        At(r, e.radius)
       );
-      if (n.isOnSegment(s))
-        return m(s, e);
+      if (e.isOnSegment(i))
+        return w(i, n);
     }
   }
   return Math.min(
-    n.distanceFrom(t.firstPoint),
-    n.distanceFrom(t.lastPoint),
-    t.distanceFrom(n.firstPoint),
-    t.distanceFrom(n.lastPoint)
+    e.distanceFrom(t.firstPoint),
+    e.distanceFrom(t.lastPoint),
+    t.distanceFrom(e.firstPoint),
+    t.distanceFrom(e.lastPoint)
   );
 }
-const Gt = (t, n) => {
-  const e = t.angleToParam(n.firstAngle);
-  if (t.isValidParameter(e))
+const zt = (t, e) => {
+  const n = t.angleToParam(e.firstAngle);
+  if (t.isValidParameter(n))
     return !0;
-  const i = t.angleToParam(n.lastAngle);
-  return !!t.isValidParameter(i);
+  const s = t.angleToParam(e.lastAngle);
+  return !!t.isValidParameter(s);
 };
-function Tt(t, n) {
-  if (bt(t, n, !0).length > 0)
+function Vt(t, e) {
+  if (Mt(t, e, !0).length > 0)
     return 0;
-  const e = m(t.center, n.center);
-  if (e < t.precision && Gt(t, n))
-    return Math.abs(t.radius - n.radius);
-  const i = K(E(n.center, t.center)), r = e - Math.abs(t.radius - n.radius) < t.precision;
-  let s = yt(i);
-  r && n.radius > t.radius && (s += Math.PI);
-  const o = r ? s : s + Math.PI, c = t.angleToParam(s), f = n.angleToParam(o);
-  return t.isValidParameter(c) && n.isValidParameter(f) ? m(t.paramPoint(c), n.paramPoint(f)) : Math.min(
-    t.distanceFrom(n.firstPoint),
-    t.distanceFrom(n.lastPoint),
-    n.distanceFrom(t.firstPoint),
-    n.distanceFrom(t.lastPoint)
+  const n = w(t.center, e.center);
+  if (n < t.precision && zt(t, e))
+    return Math.abs(t.radius - e.radius);
+  const s = Y(E(e.center, t.center)), r = n - Math.abs(t.radius - e.radius) < t.precision;
+  let i = kt(s);
+  r && e.radius > t.radius && (i += Math.PI);
+  const o = r ? i : i + Math.PI, c = t.angleToParam(i), f = e.angleToParam(o);
+  return t.isValidParameter(c) && e.isValidParameter(f) ? w(t.paramPoint(c), e.paramPoint(f)) : Math.min(
+    t.distanceFrom(e.firstPoint),
+    t.distanceFrom(e.lastPoint),
+    e.distanceFrom(t.firstPoint),
+    e.distanceFrom(t.lastPoint)
   );
 }
-function Ut(t, n, e) {
-  let i = 0, r = t.length - 1;
-  for (; i <= r; ) {
-    const s = Math.floor((i + r) / 2), o = e(t[s], n);
+function _t(t, e, n) {
+  let s = 0, r = t.length - 1;
+  for (; s <= r; ) {
+    const i = Math.floor((s + r) / 2), o = n(t[i], e);
     if (o < 0)
-      i = s + 1;
+      s = i + 1;
     else if (o > 0)
-      r = s - 1;
+      r = i - 1;
     else
-      return s;
+      return i;
   }
-  return -(i + 1);
+  return -(s + 1);
 }
-function Vt(t, n, e) {
-  const i = Ut(t, n, e);
-  i < 0 ? t.splice(-(i + 1), 0, n) : t.splice(i, 0, n);
+function Nt(t, e, n) {
+  const s = _t(t, e, n);
+  s < 0 ? t.splice(-(s + 1), 0, e) : t.splice(s, 0, e);
 }
-class zt {
+class qt {
   constructor() {
+    p(this, "buckets");
     this.buckets = [];
   }
-  addInterval(n) {
-    const e = this.buckets[n.rectangle.diagonalBucketIndex];
-    e === void 0 ? this.buckets[n.rectangle.diagonalBucketIndex] = [n] : Vt(e, n, (i, r) => i.value - r.value);
+  addInterval(e) {
+    const n = this.buckets[e.rectangle.diagonalBucketIndex];
+    n === void 0 ? this.buckets[e.rectangle.diagonalBucketIndex] = [e] : Nt(n, e, (s, r) => s.value - r.value);
   }
-  removeInterval(n) {
-    const e = this.buckets[n.rectangle.diagonalBucketIndex];
-    if (e === void 0)
+  removeInterval(e) {
+    const n = this.buckets[e.rectangle.diagonalBucketIndex];
+    if (n === void 0)
       throw new Error("Interval not found");
-    e.shift();
+    n.shift();
   }
   getBottomRightHullIntervals() {
-    const n = [];
-    for (let e = this.buckets.length - 1; e >= 0; e--) {
-      const i = this.buckets[e];
-      if (!i === void 0)
+    const e = [];
+    for (let n = this.buckets.length - 1; n >= 0; n--) {
+      const s = this.buckets[n];
+      if (!s === void 0)
         continue;
-      const r = i[0];
+      const r = s[0];
       if (r !== void 0) {
-        if (!n.length) {
-          n.push(r);
+        if (!e.length) {
+          e.push(r);
           continue;
         }
-        for (; n.length && n[n.length - 1].value >= r.value; )
-          n.pop();
-        for (; n.length >= 2; ) {
-          const s = n[n.length - 1], o = n[n.length - 2], c = (r.value - o.value) / ((r.rectangle.diagonal - o.rectangle.diagonal) * 2);
-          if (o.value + (s.rectangle.diagonal - o.rectangle.diagonal) / 2 * c < s.value)
-            n.pop();
+        for (; e.length && e[e.length - 1].value >= r.value; )
+          e.pop();
+        for (; e.length >= 2; ) {
+          const i = e[e.length - 1], o = e[e.length - 2], c = (r.value - o.value) / ((r.rectangle.diagonal - o.rectangle.diagonal) * 2);
+          if (o.value + (i.rectangle.diagonal - o.rectangle.diagonal) / 2 * c < i.value)
+            e.pop();
           else
             break;
         }
-        n.push(r);
+        e.push(r);
       }
     }
-    return n;
+    return e;
   }
 }
-class _t {
-  constructor(n, e) {
-    this.x = n, this.y = e, this.xLength = Math.pow(3, -n), this.yLength = Math.pow(3, -e), this.diagonal = Math.sqrt(
+class Jt {
+  constructor(e, n) {
+    p(this, "diagonal");
+    p(this, "diagonalBucketIndex");
+    p(this, "xLength");
+    p(this, "yLength");
+    p(this, "index");
+    this.x = e, this.y = n, this.xLength = Math.pow(3, -e), this.yLength = Math.pow(3, -n), this.diagonal = Math.sqrt(
       this.xLength * this.xLength + this.yLength * this.yLength
-    ), this.diagonalBucketIndex = n + e, this.index = `${n},${e}`;
+    ), this.diagonalBucketIndex = e + n, this.index = `${e},${n}`;
   }
 }
-class qt {
-  constructor(n, e = 1e-8, i = 1e3, r = 1e-6) {
-    this.fcn = n, this.endTolerance = e, this.maxIterations = i, this.epsilon = r, this.fcn = n, this.epsilon = r, this.endTolerance = e, this.maxIterations = i, this.rectangles = /* @__PURE__ */ new Map(), this.buckets = new zt();
-    const s = [0.5, 0.5], o = this.rect(0, 0), c = this.fcn(s);
-    this.buckets.addInterval(new k(s, c, o)), this.fMin = c, this.argMin = s, this.tol = o.diagonal;
+class Qt {
+  constructor(e, n = 1e-8, s = 1e3, r = 1e-6) {
+    p(this, "rectangles");
+    p(this, "buckets");
+    p(this, "fMin");
+    p(this, "argMin");
+    p(this, "tol");
+    this.fcn = e, this.endTolerance = n, this.maxIterations = s, this.epsilon = r, this.fcn = e, this.epsilon = r, this.endTolerance = n, this.maxIterations = s, this.rectangles = /* @__PURE__ */ new Map(), this.buckets = new qt();
+    const i = [0.5, 0.5], o = this.rect(0, 0), c = this.fcn(i);
+    this.buckets.addInterval(new k(i, c, o)), this.fMin = c, this.argMin = i, this.tol = o.diagonal;
   }
-  registerInterval(n) {
-    this.buckets.addInterval(n), n.value <= this.fMin && (this.fMin = n.value, this.argMin = n.center, this.tol = n.rectangle.diagonal);
+  registerInterval(e) {
+    this.buckets.addInterval(e), e.value <= this.fMin && (this.fMin = e.value, this.argMin = e.center, this.tol = e.rectangle.diagonal);
   }
-  rect(n, e) {
-    const i = `${n},${e}`;
-    return this.rectangles.has(i) || this.rectangles.set(i, new _t(n, e)), this.rectangles.get(i);
+  rect(e, n) {
+    const s = `${e},${n}`;
+    return this.rectangles.has(s) || this.rectangles.set(s, new Jt(e, n)), this.rectangles.get(s);
   }
-  splitInterval(n) {
-    let e, i, r;
-    const [s, o] = n.center;
-    return n.rectangle.x <= n.rectangle.y ? (e = this.rect(n.rectangle.x + 1, n.rectangle.y), i = [s - e.xLength, o], r = [s + e.xLength, o]) : (e = this.rect(n.rectangle.x, n.rectangle.y + 1), i = [s, o - e.yLength], r = [s, o + e.yLength]), [
-      new k(i, this.fcn(i), e),
-      new k(n.center, n.value, e),
-      new k(r, this.fcn(r), e)
+  splitInterval(e) {
+    let n, s, r;
+    const [i, o] = e.center;
+    return e.rectangle.x <= e.rectangle.y ? (n = this.rect(e.rectangle.x + 1, e.rectangle.y), s = [i - n.xLength, o], r = [i + n.xLength, o]) : (n = this.rect(e.rectangle.x, e.rectangle.y + 1), s = [i, o - n.yLength], r = [i, o + n.yLength]), [
+      new k(s, this.fcn(s), n),
+      new k(e.center, e.value, n),
+      new k(r, this.fcn(r), n)
     ];
   }
   single_iteration() {
-    const n = this.buckets.getBottomRightHullIntervals();
-    for (; n.length >= 2; ) {
-      const e = n[0], i = n[1], r = (i.value - e.value) / ((i.rectangle.diagonal - e.rectangle.diagonal) / 2), s = e.value - r * i.value / 2;
-      if ((this.fMin - s) / Math.abs(this.fMin) < this.epsilon)
-        n.shift();
+    const e = this.buckets.getBottomRightHullIntervals();
+    for (; e.length >= 2; ) {
+      const n = e[0], s = e[1], r = (s.value - n.value) / ((s.rectangle.diagonal - n.rectangle.diagonal) / 2), i = n.value - r * s.value / 2;
+      if ((this.fMin - i) / Math.abs(this.fMin) < this.epsilon)
+        e.shift();
       else
         break;
     }
-    n.forEach((e) => {
-      this.buckets.removeInterval(e);
+    e.forEach((n) => {
+      this.buckets.removeInterval(n);
     });
-    for (const e of n) {
-      const [i, r, s] = this.splitInterval(e);
-      this.registerInterval(i), this.registerInterval(r), this.registerInterval(s);
+    for (const n of e) {
+      const [s, r, i] = this.splitInterval(n);
+      this.registerInterval(s), this.registerInterval(r), this.registerInterval(i);
     }
   }
   run() {
-    let n = 0;
-    for (; this.tol > this.endTolerance / 2 && (this.single_iteration(), n++, !(n > this.maxIterations)); )
+    let e = 0;
+    for (; this.tol > this.endTolerance / 2 && (this.single_iteration(), e++, !(e > this.maxIterations)); )
       ;
     return {
       fMin: this.fMin,
       argMin: this.argMin,
       tol: this.tol,
-      iterations: n
+      iterations: e
     };
   }
 }
 class k {
-  constructor(n, e, i) {
-    this.center = n, this.value = e, this.rectangle = i;
+  constructor(e, n, s) {
+    this.center = e, this.value = n, this.rectangle = s;
   }
 }
-function Nt(t, n = 1e-8, e = 1e3, i = 1e-6) {
-  return new qt(
+function Zt(t, e = 1e-8, n = 1e3, s = 1e-6) {
+  return new Qt(
     t,
-    n,
     e,
-    i
+    n,
+    s
   ).run();
 }
-function Qt(t, n, e = 1e-9) {
-  const i = Nt((r) => {
-    const s = t.paramPoint(r[0]), o = n.paramPoint(r[1]);
-    return j(s, o);
-  }, e);
-  return Math.sqrt(i.fMin);
+function Ht(t, e, n = 1e-9) {
+  const s = Zt((r) => {
+    const i = t.paramPoint(r[0]), o = e.paramPoint(r[1]);
+    return j(i, o);
+  }, n);
+  return Math.sqrt(s.fMin);
 }
-function Zt(t, n) {
-  return t instanceof M && n instanceof M ? Bt(t, n) : t instanceof M && n instanceof v ? Q(t, n) : t instanceof v && n instanceof M ? Q(n, t) : t instanceof v && n instanceof v ? Tt(t, n) : Qt(t, n);
+function Wt(t, e) {
+  return t instanceof S && e instanceof S ? Ut(t, e) : t instanceof S && e instanceof b ? J(t, e) : t instanceof b && e instanceof S ? J(e, t) : t instanceof b && e instanceof b ? Vt(t, e) : Ht(t, e);
 }
 const T = 1e-8;
-function x(t, n, e = !0) {
-  const i = t.map((a) => ({
-    offset: Pt(a, n),
+function R(t, e, n = !0) {
+  const s = t.map((a) => ({
+    offset: gt(a, e),
     original: a
   })), r = [];
-  let s = e ? null : i.at(-1), o = e ? i.at(-1) : null;
+  let i = n ? null : s.at(-1), o = n ? s.at(-1) : null;
   if (r.length === 1)
     return r;
   const c = (a) => {
-    s ? a.offset instanceof D ? I(a.offset.firstPoint, a.offset.lastPoint) || r.push(
-      new M(a.offset.firstPoint, a.offset.lastPoint)
-    ) : r.push(a.offset) : s = a;
+    i ? a.offset instanceof D ? M(a.offset.firstPoint, a.offset.lastPoint) || r.push(
+      new S(a.offset.firstPoint, a.offset.lastPoint)
+    ) : r.push(a.offset) : i = a;
   }, f = function* () {
-    for (const a of i.slice(0, -1))
+    for (const a of s.slice(0, -1))
       yield a;
-    if (!s)
+    if (!i)
       throw new Error("Bug in the offset algorithm");
-    yield s;
+    yield i;
   };
   for (const a of f()) {
     if (!o) {
       o = a;
       continue;
     }
-    const u = o.offset.lastPoint, d = a.offset.firstPoint;
-    if (I(u, d)) {
+    const u = o.offset.lastPoint, m = a.offset.firstPoint;
+    if (M(u, m)) {
       c(o), o = a;
       continue;
     }
-    let g = [];
+    let h = [];
     if (!(o.offset instanceof D) && !(a.offset instanceof D)) {
-      const { intersections: $, overlaps: F } = O(
+      const { intersections: L, overlaps: x } = B(
         o.offset,
         a.offset,
         T / 100
       );
-      g = [
-        ...$,
-        ...F.flatMap((A) => [A.firstPoint, A.lastPoint])
+      h = [
+        ...L,
+        ...x.flatMap((v) => [v.firstPoint, v.lastPoint])
       ];
     }
-    if (g.length > 0) {
-      let $ = g[0];
-      if (g.length > 1) {
-        const pt = o == null ? void 0 : o.original.lastPoint, V = g.map(
-          (dt) => j(dt, pt)
+    if (h.length > 0) {
+      let L = h[0];
+      if (h.length > 1) {
+        const ct = o == null ? void 0 : o.original.lastPoint, U = h.map(
+          (ft) => j(ft, ct)
         );
-        $ = g[V.indexOf(Math.min(...V))];
+        L = h[U.indexOf(Math.min(...U))];
       }
-      const F = o.offset.splitAt([
-        $
-      ])[0], A = a.offset.splitAt([$]).at(-1);
-      if (!A)
+      const x = o.offset.splitAt([
+        L
+      ])[0], v = a.offset.splitAt([L]).at(-1);
+      if (!v)
         throw new Error("Bug in the splitting algo in offset");
       c({
-        offset: F,
+        offset: x,
         original: o.original
-      }), o = { offset: A, original: a.original };
+      }), o = { offset: v, original: a.original };
       continue;
     }
-    const l = o.original.lastPoint, L = Ft(
-      E(d, l),
+    const l = o.original.lastPoint, A = yt(
+      E(m, l),
       E(u, l)
-    ) > 0, gt = new v(u, d, l, L);
-    c(o), r.push(gt), o = a;
+    ) > 0, at = new b(u, m, l, A);
+    c(o), r.push(at), o = a;
   }
   return o && c(o), r;
 }
-function ot(t) {
-  const n = /* @__PURE__ */ new Map(), e = (i, r) => {
-    const s = n.get(i) || [];
-    n.set(i, [...s, ...r]);
+function nt(t) {
+  const e = /* @__PURE__ */ new Map(), n = (s, r) => {
+    const i = e.get(s) || [];
+    e.set(s, [...i, ...r]);
   };
-  return t.forEach((i, r) => {
-    t.slice(r + 1).forEach((s, o) => {
-      const { intersections: c, overlaps: f } = O(i, s, T), a = [
+  return t.forEach((s, r) => {
+    t.slice(r + 1).forEach((i, o) => {
+      const { intersections: c, overlaps: f } = B(s, i, T), a = [
         ...c,
         ...f.flatMap((u) => [u.firstPoint, u.lastPoint])
       ].filter((u) => {
-        const d = I(u, i.firstPoint) || I(u, i.lastPoint), g = I(u, s.firstPoint) || I(u, s.lastPoint);
-        return !(d && g);
+        const m = M(u, s.firstPoint) || M(u, s.lastPoint), h = M(u, i.firstPoint) || M(u, i.lastPoint);
+        return !(m && h);
       });
-      a.length && (e(r, a), e(o + r + 1, a));
+      a.length && (n(r, a), n(o + r + 1, a));
     });
-  }), n;
-}
-function at(t, n) {
-  return n.flatMap((e, i) => {
-    if (!t.has(i))
-      return e;
-    const r = t.get(i);
-    return r ? e.splitAt(r) : e;
+  }), e;
+}
+function st(t, e) {
+  return e.flatMap((n, s) => {
+    if (!t.has(s))
+      return n;
+    const r = t.get(s);
+    return r ? n.splitAt(r) : n;
   });
 }
-function ct(t, n, e) {
-  return t.filter((i) => !n.segments.some((s) => Zt(s, i) < Math.abs(e) - T));
+function it(t, e, n) {
+  return t.filter((s) => !e.segments.some((i) => Wt(i, s) < Math.abs(n) - T));
 }
-function y(t, n) {
-  const e = t.clockwise ? n : -n, i = x(t.segments, e);
-  if (i.length < 2)
-    return new h();
-  const r = ot(i);
+function F(t, e) {
+  const n = t.clockwise ? e : -e, s = R(t.segments, n);
+  if (s.length < 2)
+    return new g();
+  const r = nt(s);
   if (!r.size) {
-    const a = new P(i);
-    return new h([new p(a)]);
+    const a = new P(s);
+    return new g([new d(a)]);
   }
-  const s = at(
+  const i = st(
     r,
-    i
-  ), o = ct(s, t, n);
+    s
+  ), o = it(i, t, e);
   if (!o.length)
-    return new h();
-  const f = tt(o).filter((a) => a.length > 1).filter((a) => I(a[0].firstPoint, a.at(-1).lastPoint)).map((a) => new P(a));
-  return f.length ? new h(f.map((a) => new p(a))) : new h();
+    return new g();
+  const f = X(o).filter((a) => a.length > 1).filter((a) => M(a[0].firstPoint, a.at(-1).lastPoint)).map((a) => new P(a));
+  return f.length ? new g(f.map((a) => new d(a))) : new g();
 }
-function Jt(t, n, e = "round") {
-  const i = n / 2, r = x(t.segments, i, !1), s = x(t.segments, -i, !1).map(
+function Kt(t, e, n = "round") {
+  const s = e / 2, r = R(t.segments, s, !1), i = R(t.segments, -s, !1).map(
     (l) => l.reverse()
   );
-  s.reverse();
-  const o = (l, L) => e === "round" ? Ct(
+  i.reverse();
+  const o = (l, A) => n === "round" ? Et(
     l.lastPoint,
-    L.firstPoint,
+    A.firstPoint,
     l.tangentAtLastPoint
-  ) : new M(l.lastPoint, L.firstPoint), c = [
+  ) : new S(l.lastPoint, A.firstPoint), c = [
     ...r,
     o(
       r[r.length - 1],
-      s[0]
+      i[0]
     ),
-    ...s,
+    ...i,
     o(
-      s[s.length - 1],
+      i[i.length - 1],
       r[0]
     )
-  ], f = ot(c);
+  ], f = nt(c);
   if (!f.size) {
     const l = new P(c);
-    return new h([new p(l)]);
+    return new g([new d(l)]);
   }
-  const a = at(
+  const a = st(
     f,
     c
-  ), u = ct(a, t, i);
+  ), u = it(a, t, s);
   if (!u.length)
-    return new h();
-  const g = tt(u).filter((l) => l.length > 1).filter((l) => I(l[0].firstPoint, l.at(-1).lastPoint)).map((l) => new P(l));
-  return g.length ? new h(g.map((l) => new p(l))) : new h();
-}
-function Ht(t, n) {
-  const e = t.map((i) => {
-    const r = b(
-      i.holes.map((s) => y(s, n))
+    return new g();
+  const h = X(u).filter((l) => l.length > 1).filter((l) => M(l[0].firstPoint, l.at(-1).lastPoint)).map((l) => new P(l));
+  return h.length ? new g(h.map((l) => new d(l))) : new g();
+}
+function Xt(t, e) {
+  const n = t.map((s) => {
+    const r = y(
+      s.holes.map((i) => F(i, e))
     );
-    return rt(y(i.contour, n), r);
+    return et(F(s.contour, e), r);
   });
-  return b(e);
+  return y(n);
 }
-function Wt(t, n) {
-  const e = Math.abs(n / 2), i = t.map(
-    (r) => b(
-      r.allLoops.map((s) => rt(y(s, e), y(s, -e)))
+function Yt(t, e) {
+  const n = Math.abs(e / 2), s = t.map(
+    (r) => y(
+      r.allLoops.map((i) => et(F(i, n), F(i, -n)))
     )
   );
-  return b(i);
-}
-function an(t, n) {
-  return Ht(S(t), n);
-}
-function cn(t, n, { endCap: e = "round" } = {}) {
-  return t instanceof C ? Jt(t, n, e) : Wt(S(t), n);
-}
-function w([t, n]) {
-  return `${t} ${n}`;
-}
-function U(t) {
-  if (t instanceof M)
-    return `L ${w(t.lastPoint)}`;
-  if (t instanceof v)
-    return `A ${t.radius} ${t.radius} 0 ${t.angularLength > Math.PI ? "1" : "0"} ${t.clockwise ? "0" : "1"} ${w(t.lastPoint)}`;
-  if (t instanceof nt)
-    return `A ${t.majorRadius} ${t.minorRadius} ${t.tiltAngle * Dt} ${t.deltaAngle > Math.PI ? "1" : "0"} ${t.clockwise ? "0" : "1"} ${w(t.lastPoint)}`;
-  if (t instanceof et)
-    return `Q ${[
-      w(t.controlPoint),
-      w(t.lastPoint)
-    ].join(" ")}`;
-  if (t instanceof it)
-    return `C ${[
-      w(t.firstControlPoint),
-      w(t.lastControlPoint),
-      w(t.lastPoint)
-    ].join(" ")}`;
-  throw new Error("Unknown segment type");
+  return y(s);
 }
-function ft(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(U).join(" ");
-  return `${n} ${e} Z`;
-}
-function lt(t) {
-  return `<path d="${t.allLoops.map(ft).join(" ")}" />`;
-}
-function Xt(t) {
-  return `<g>
-  ${t.figures.map(lt).join(`
-`)}
-</g>`;
-}
-function Yt(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(U).join(" ");
-  return `${n} ${e}`;
-}
-function Kt(t, n = 1) {
-  const e = t.xMin - n, i = t.yMin - n;
-  return `${e} ${i} ${t.width + 2 * n} ${t.height + 2 * n}`;
-}
-function Z(t, n, e = 1, i) {
-  const r = Kt(n, e), s = i ? `width="${n.width + 2 * e}${i}" height="${n.height + 2 * e}${i}"` : "";
-  return `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${r}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke" ${s}>
-    ${t}
-</svg>`;
-}
-function J(t) {
-  if (t instanceof h)
-    return Xt(t);
-  if (t instanceof p)
-    return lt(t);
+function fe(t, e) {
+  return Xt(I(t), e);
+}
+function le(t, e, { endCap: n = "round" } = {}) {
+  return t instanceof C ? Kt(t, e, n) : Yt(I(t), e);
+}
+function Q(t) {
+  if (t instanceof g)
+    return Rt(t);
+  if (t instanceof d)
+    return Ot(t);
   if (t instanceof P)
-    return `<path d="${ft(t)}" />`;
+    return `<path d="${Bt(t)}" />`;
   if (t instanceof C)
-    return `<path d="${Yt(t)}" />`;
-  if (xt(t))
-    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${U(
+    return `<path d="${$t(t)}" />`;
+  if (It(t))
+    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${Gt(
       t
     )}" />`;
   throw new Error("Unknown shape type");
 }
-const H = (t) => "shape" in t ? t.shape : t, W = (t, n) => {
+const Z = (t) => "shape" in t ? t.shape : t, H = (t, e) => {
   if (!("shape" in t))
-    return n;
-  const { color: e } = t;
-  return e ? `<g stroke="${e}">${n}</g>` : n;
-}, X = (t) => new Rt(t.xMin, -t.yMax, t.xMax, -t.yMin);
-function fn(t, {
-  margin: n = 1,
-  unit: e = null,
-  viewBox: i
+    return e;
+  const { color: n } = t;
+  return n ? `<g stroke="${n}">${e}</g>` : e;
+}, W = (t) => new Ft(t.xMin, -t.yMax, t.xMax, -t.yMin);
+function ue(t, {
+  margin: e = 1,
+  unit: n = null,
+  viewBox: s
 } = {}) {
   if (Array.isArray(t)) {
-    const s = t.map((f) => H(f).mirror()), o = s.map((f, a) => W(t[a], J(f))).join(`
-`), c = s.slice(1).reduce((f, a) => f.merge(a.boundingBox), s[0].boundingBox);
-    return Z(o, i ? X(i) : c, n, e);
+    const i = t.map((f) => Z(f).mirror()), o = i.map((f, a) => H(t[a], Q(f))).join(`
+`), c = i.slice(1).reduce((f, a) => f.merge(a.boundingBox), i[0].boundingBox);
+    return z(o, s ? W(s) : c, e, n);
   }
-  const r = H(t).mirror();
-  return Z(
-    W(t, J(r)),
-    i ? X(i) : r.boundingBox,
-    n,
-    e
+  const r = Z(t).mirror();
+  return z(
+    H(t, Q(r)),
+    s ? W(s) : r.boundingBox,
+    e,
+    n
   );
 }
-const ut = (t) => {
+const rt = (t) => {
   if (t.type === "LINE")
-    return new M(t.firstPoint, t.lastPoint);
+    return new S(t.firstPoint, t.lastPoint);
   if (t.type === "ARC")
-    return new v(
+    return new b(
       t.firstPoint,
       t.lastPoint,
       t.center,
       t.clockwise
     );
   if (t.type === "ELLIPSE_ARC")
-    return new nt(
+    return new Ct(
       t.firstPoint,
       t.lastPoint,
       t.center,
@@ -621,66 +586,66 @@ const ut = (t) => {
       { angleUnits: "rad" }
     );
   if (t.type === "QUADRATIC_BEZIER")
-    return new et(
+    return new xt(
       t.firstPoint,
       t.lastPoint,
       t.controlPoint
     );
   if (t.type === "CUBIC_BEZIER")
-    return new it(
+    return new Dt(
       t.firstPoint,
       t.lastPoint,
       t.firstControlPoint,
       t.lastControlPoint
     );
   throw new Error("Unknown segment type");
-}, R = (t) => {
-  const n = t.segments.map(ut);
-  return new P(n);
-}, ht = (t) => {
-  const n = R(t.contour), e = t.holes.map(R);
-  return new p(n, e);
+}, O = (t) => {
+  const e = t.segments.map(rt);
+  return new P(e);
+}, ot = (t) => {
+  const e = O(t.contour), n = t.holes.map(O);
+  return new d(e, n);
 }, jt = (t) => {
-  const n = t.figures.map(ht);
-  return new h(n);
+  const e = t.figures.map(ot);
+  return new g(e);
 };
-function ln(t) {
+function ge(t) {
   if (t.type === "DIAGRAM")
     return jt(t);
   if (t.type === "FIGURE")
-    return ht(t);
+    return ot(t);
   if (t.type === "LOOP")
-    return R(t);
+    return O(t);
   if (t.type === "LINE" || t.type === "ARC" || t.type === "ELLIPSE_ARC" || t.type === "CUBIC_BEZIER")
-    return ut(t);
+    return rt(t);
   throw new Error("Unknown shape type");
 }
-const Y = Math.PI / 180, tn = 180 / Math.PI;
-function un(t, n) {
-  const e = Math.cos(n * Y) * t, i = Math.sin(n * Y) * t;
-  return [e, i];
+const K = Math.PI / 180, te = 180 / Math.PI;
+function he(t, e) {
+  const n = Math.cos(e * K) * t, s = Math.sin(e * K) * t;
+  return [n, s];
 }
-function hn([t, n]) {
-  const e = Math.sqrt(t * t + n * n), i = Math.atan2(n, t) * tn;
-  return [e, i];
+function pe([t, e]) {
+  const n = Math.sqrt(t * t + e * e), s = Math.atan2(e, t) * te;
+  return [n, s];
 }
 export {
-  Y as DEG2RAD,
-  tn as RAD2DEG,
-  hn as cartesianToPolar,
-  on as confineStrand,
-  rt as cut,
-  dn as draw,
-  rn as eraseStrand,
-  wn as exportJSON,
-  fn as exportSVG,
-  Ot as fuse,
-  b as fuseAll,
-  ln as importJSON,
-  sn as intersect,
-  an as offset,
-  cn as outlineStroke,
-  un as polarToCartesian,
-  J as svgBody
+  K as DEG2RAD,
+  te as RAD2DEG,
+  pe as cartesianToPolar,
+  ce as confineStrand,
+  et as cut,
+  Pe as draw,
+  ae as eraseStrand,
+  Me as exportJSON,
+  ue as exportSVG,
+  Tt as fuse,
+  y as fuseAll,
+  ge as importJSON,
+  oe as intersect,
+  fe as offset,
+  le as outlineStroke,
+  he as polarToCartesian,
+  Q as svgBody
 };
 //# sourceMappingURL=pantograph.js.map