pantograph2d 0.6.0 → 0.8.0

package/dist/pantograph.js

@@ -1,206 +1,211 @@
-import { o as ht, D } from "./draw-a830827a.js";
-import { d as fn } from "./draw-a830827a.js";
-import { F as p, L as P, D as h, f as C, r as gt, z as pt, s as dt, a as wt, c as Pt, i as mt, S as y, l as Mt, d as m, b as vt, p as St, n as K, e as $, g as It, h as Lt, j as kt, k as At, m as Q, o as w, A as M, q as j, t as v, u as $t, v as bt, E as O, R as Et } from "./Diagram-d848c815.js";
-import { w as un } from "./Diagram-d848c815.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 tt(t, n, e = 1e-9) {
+function tt(t, e, n = 1e-9) {
   let s = [];
-  const r = [], i = new Array(n.segments.length).fill(0).map(() => []);
-  n.segments.forEach((c, f) => {
+  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 } = C(
+      const { intersections: u, overlaps: m } = B(
         c,
         a,
-        e
+        n
       );
-      s.push(...u), i[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
       ]);
-      s.push(...g), i[f].push(...g);
+      s.push(...h), i[f].push(...h);
     });
-  }), s = gt(s, e);
-  const o = pt([n.segments, i]).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(
-    dt(
+    ht(
       o,
       s,
       r
     )
   );
 }
-function G(t, n, e = !1) {
-  return tt(n, t).filter((r) => {
+function $(t, e, n = !1) {
+  return tt(e, t).filter((r) => {
     const i = r.segments[0].midPoint;
-    return n.onStroke(i) ? !e : !n.contains(i);
+    return e.onStroke(i) ? !n : !e.contains(i);
   });
 }
-function T(t, n, e = !1) {
-  return tt(n, t).filter((r) => {
+function G(t, e, n = !1) {
+  return tt(e, t).filter((r) => {
     const i = r.segments[0].midPoint;
-    return n.onStroke(i) ? !e : n.contains(i);
+    return e.onStroke(i) ? !n : e.contains(i);
   });
 }
-function z(t, n, e = !1) {
-  const s = G(
+function V(t, e, n = !1) {
+  const s = $(
     t,
-    n.contour,
-    e
-  ), r = n.holes.flatMap(
-    (i) => T(t, i, e)
+    e.contour,
+    n
+  ), r = e.holes.flatMap(
+    (i) => G(t, i, n)
   );
   return [...s, ...r];
 }
-function q(t, n, e = !1) {
-  let s = T(
+function _(t, e, n = !1) {
+  let s = G(
     t,
-    n.contour,
-    e
+    e.contour,
+    n
   );
-  return n.holes.forEach((r) => {
+  return e.holes.forEach((r) => {
     s = s.flatMap(
-      (i) => G(i, r, e)
+      (i) => $(i, r, n)
     );
   }), s;
 }
-function yt(t, n) {
-  return new h(
-    wt(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) => yt(n, e),
-    new h()
+    (e, n) => Tt(e, n),
+    new g()
   );
 }
-function nt(t, n) {
-  return new h(
-    Pt(S(t), S(n))
+function et(t, e) {
+  return new g(
+    dt(I(t), I(e))
   );
 }
-function Kt(t, n) {
-  return new h(
-    mt(S(t), S(n))
+function oe(t, e) {
+  return new g(
+    mt(I(t), I(e))
   );
 }
-function Qt(t, n, e = !0) {
-  if (n instanceof P)
-    return G(t, n, e);
-  if (n instanceof p)
-    return z(t, n, e);
-  let s = [new y([...t.segments])];
-  return n.figures.forEach((r) => {
-    s = s.flatMap((i) => z(i, r, e));
+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 jt(t, n, e = !1) {
-  if (n instanceof P)
-    return T(t, n, e);
-  if (n instanceof p)
-    return q(t, n, e);
-  let s = [new y([...t.segments])];
-  return n.figures.forEach((r) => {
-    s = s.flatMap((i) => q(i, r, e));
+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 _ = (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 Ft(t, n) {
-  const e = Mt(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: s, intersectionParam2: r } = e, i = N(s), o = N(r);
+  const { intersectionParam1: s, intersectionParam2: r } = n, i = N(s), o = N(r);
   if (i === "between" && o === "between")
     return 0;
   if (i === "between" && o !== "between")
-    return _(t, n, o);
+    return q(t, e, o);
   if (o === "between" && i !== "between")
-    return _(n, t, i);
+    return q(e, t, i);
   if (i === "before" && o === "before")
-    return m(t.firstPoint, n.firstPoint);
+    return w(t.firstPoint, e.firstPoint);
   if (i === "after" && o === "after")
-    return m(t.lastPoint, n.lastPoint);
+    return w(t.lastPoint, e.lastPoint);
   if (i === "before" && o === "after")
-    return m(t.firstPoint, n.lastPoint);
+    return w(t.firstPoint, e.lastPoint);
   if (i === "after" && o === "before")
-    return m(t.lastPoint, n.firstPoint);
+    return w(t.lastPoint, e.firstPoint);
   throw new Error("Invalid position");
 }
-function J(t, n) {
-  if (vt(t, n).length > 0)
+function J(t, e) {
+  if (Pt(t, e).length > 0)
     return 0;
-  const e = St(t, n.center);
-  if (t.isOnSegment(e)) {
-    const s = m(e, n.center);
-    if (Math.abs(s - 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 (s - n.radius > t.precision) {
-      const r = K(
-        $(e, n.center)
-      ), i = It(
-        n.center,
-        Lt(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(i))
-        return m(i, 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 Dt = (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 s = t.angleToParam(n.lastAngle);
+  const s = t.angleToParam(e.lastAngle);
   return !!t.isValidParameter(s);
 };
-function xt(t, n) {
-  if (kt(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 && Dt(t, n))
-    return Math.abs(t.radius - n.radius);
-  const s = K($(n.center, t.center)), r = e - Math.abs(t.radius - n.radius) < t.precision;
-  let i = At(s);
-  r && n.radius > t.radius && (i += Math.PI);
-  const o = r ? i : i + Math.PI, c = t.angleToParam(i), 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 Rt(t, n, e) {
+function _t(t, e, n) {
   let s = 0, r = t.length - 1;
   for (; s <= r; ) {
-    const i = Math.floor((s + r) / 2), o = e(t[i], n);
+    const i = Math.floor((s + r) / 2), o = n(t[i], e);
     if (o < 0)
       s = i + 1;
     else if (o > 0)
@@ -210,144 +215,155 @@ function Rt(t, n, e) {
   }
   return -(s + 1);
 }
-function Ct(t, n, e) {
-  const s = Rt(t, n, e);
-  s < 0 ? t.splice(-(s + 1), 0, n) : t.splice(s, 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 Ot {
+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] : Ct(e, n, (s, r) => s.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 s = this.buckets[e];
+    const e = [];
+    for (let n = this.buckets.length - 1; n >= 0; n--) {
+      const s = this.buckets[n];
       if (!s === void 0)
         continue;
       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 i = n[n.length - 1], o = n[n.length - 2], c = (r.value - o.value) / ((r.rectangle.diagonal - o.rectangle.diagonal) * 2);
+        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)
-            n.pop();
+            e.pop();
           else
             break;
         }
-        n.push(r);
+        e.push(r);
       }
     }
-    return n;
+    return e;
   }
 }
-class Gt {
-  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 Tt {
-  constructor(n, e = 1e-8, s = 1e3, r = 1e-6) {
-    this.fcn = n, this.endTolerance = e, this.maxIterations = s, this.epsilon = r, this.fcn = n, this.epsilon = r, this.endTolerance = e, this.maxIterations = s, this.rectangles = /* @__PURE__ */ new Map(), this.buckets = new Ot();
+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 A(i, c, o)), this.fMin = c, this.argMin = i, this.tol = o.diagonal;
+    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 s = `${n},${e}`;
-    return this.rectangles.has(s) || this.rectangles.set(s, new Gt(n, e)), this.rectangles.get(s);
+  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, s, r;
-    const [i, o] = n.center;
-    return n.rectangle.x <= n.rectangle.y ? (e = this.rect(n.rectangle.x + 1, n.rectangle.y), s = [i - e.xLength, o], r = [i + e.xLength, o]) : (e = this.rect(n.rectangle.x, n.rectangle.y + 1), s = [i, o - e.yLength], r = [i, o + e.yLength]), [
-      new A(s, this.fcn(s), e),
-      new A(n.center, n.value, e),
-      new A(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], s = n[1], r = (s.value - e.value) / ((s.rectangle.diagonal - e.rectangle.diagonal) / 2), i = e.value - r * s.value / 2;
+    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)
-        n.shift();
+        e.shift();
       else
         break;
     }
-    n.forEach((e) => {
-      this.buckets.removeInterval(e);
+    e.forEach((n) => {
+      this.buckets.removeInterval(n);
     });
-    for (const e of n) {
-      const [s, r, i] = this.splitInterval(e);
+    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 A {
-  constructor(n, e, s) {
-    this.center = n, this.value = e, this.rectangle = s;
+class k {
+  constructor(e, n, s) {
+    this.center = e, this.value = n, this.rectangle = s;
   }
 }
-function Vt(t, n = 1e-8, e = 1e3, s = 1e-6) {
-  return new Tt(
+function Zt(t, e = 1e-8, n = 1e3, s = 1e-6) {
+  return new Qt(
     t,
-    n,
     e,
+    n,
     s
   ).run();
 }
-function Ut(t, n, e = 1e-9) {
-  const s = Vt((r) => {
-    const i = t.paramPoint(r[0]), o = n.paramPoint(r[1]);
-    return Q(i, o);
-  }, e);
+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 Bt(t, n) {
-  return t instanceof w && n instanceof w ? Ft(t, n) : t instanceof w && n instanceof M ? J(t, n) : t instanceof M && n instanceof w ? J(n, t) : t instanceof M && n instanceof M ? xt(t, n) : Ut(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 V = 1e-8;
-function x(t, n, e = !0) {
+const T = 1e-8;
+function R(t, e, n = !0) {
   const s = t.map((a) => ({
-    offset: ht(a, n),
+    offset: gt(a, e),
     original: a
   })), r = [];
-  let i = e ? null : s.at(-1), o = e ? s.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) => {
-    i ? a.offset instanceof D ? v(a.offset.firstPoint, a.offset.lastPoint) || r.push(
-      new w(a.offset.firstPoint, a.offset.lastPoint)
+    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 s.slice(0, -1))
@@ -361,107 +377,107 @@ function x(t, n, e = !0) {
       o = a;
       continue;
     }
-    const u = o.offset.lastPoint, d = a.offset.firstPoint;
-    if (v(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: I, overlaps: F } = C(
+      const { intersections: L, overlaps: x } = B(
         o.offset,
         a.offset,
-        V / 100
+        T / 100
       );
-      g = [
-        ...I,
-        ...F.flatMap((L) => [L.firstPoint, L.lastPoint])
+      h = [
+        ...L,
+        ...x.flatMap((v) => [v.firstPoint, v.lastPoint])
       ];
     }
-    if (g.length > 0) {
-      let I = g[0];
-      if (g.length > 1) {
-        const lt = o == null ? void 0 : o.original.lastPoint, B = g.map(
-          (ut) => Q(ut, lt)
+    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)
         );
-        I = g[B.indexOf(Math.min(...B))];
+        L = h[U.indexOf(Math.min(...U))];
       }
-      const F = o.offset.splitAt([
-        I
-      ])[0], L = a.offset.splitAt([I]).at(-1);
-      if (!L)
+      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: L, original: a.original };
+      }), o = { offset: v, original: a.original };
       continue;
     }
-    const l = o.original.lastPoint, k = bt(
-      $(d, l),
-      $(u, l)
-    ) > 0, ft = new M(u, d, l, k);
-    c(o), r.push(ft), o = a;
+    const l = o.original.lastPoint, A = yt(
+      E(m, l),
+      E(u, l)
+    ) > 0, at = new b(u, m, l, A);
+    c(o), r.push(at), o = a;
   }
   return o && c(o), r;
 }
-function et(t) {
-  const n = /* @__PURE__ */ new Map(), e = (s, r) => {
-    const i = n.get(s) || [];
-    n.set(s, [...i, ...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((s, r) => {
     t.slice(r + 1).forEach((i, o) => {
-      const { intersections: c, overlaps: f } = C(s, i, V), a = [
+      const { intersections: c, overlaps: f } = B(s, i, T), a = [
         ...c,
         ...f.flatMap((u) => [u.firstPoint, u.lastPoint])
       ].filter((u) => {
-        const d = v(u, s.firstPoint) || v(u, s.lastPoint), g = v(u, i.firstPoint) || v(u, i.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;
+  }), e;
 }
-function st(t, n) {
-  return n.flatMap((e, s) => {
+function st(t, e) {
+  return e.flatMap((n, s) => {
     if (!t.has(s))
-      return e;
+      return n;
     const r = t.get(s);
-    return r ? e.splitAt(r) : e;
+    return r ? n.splitAt(r) : n;
   });
 }
-function it(t, n, e) {
-  return t.filter((s) => !n.segments.some((i) => Bt(i, s) < Math.abs(e) - V));
+function it(t, e, n) {
+  return t.filter((s) => !e.segments.some((i) => Wt(i, s) < Math.abs(n) - T));
 }
-function E(t, n) {
-  const e = t.clockwise ? n : -n, s = x(t.segments, e);
+function F(t, e) {
+  const n = t.clockwise ? e : -e, s = R(t.segments, n);
   if (s.length < 2)
-    return new h();
-  const r = et(s);
+    return new g();
+  const r = nt(s);
   if (!r.size) {
     const a = new P(s);
-    return new h([new p(a)]);
+    return new g([new d(a)]);
   }
   const i = st(
     r,
     s
-  ), o = it(i, t, n);
+  ), o = it(i, t, e);
   if (!o.length)
-    return new h();
-  const f = j(o).filter((a) => a.length > 1).filter((a) => v(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 zt(t, n, e = "round") {
-  const s = n / 2, r = x(t.segments, s, !1), i = x(t.segments, -s, !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()
   );
   i.reverse();
-  const o = (l, k) => e === "round" ? $t(
+  const o = (l, A) => n === "round" ? Et(
     l.lastPoint,
-    k.firstPoint,
+    A.firstPoint,
     l.tangentAtLastPoint
-  ) : new w(l.lastPoint, k.firstPoint), c = [
+  ) : new S(l.lastPoint, A.firstPoint), c = [
     ...r,
     o(
       r[r.length - 1],
@@ -472,130 +488,94 @@ function zt(t, n, e = "round") {
       i[i.length - 1],
       r[0]
     )
-  ], f = et(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 = st(
     f,
     c
   ), u = it(a, t, s);
   if (!u.length)
-    return new h();
-  const g = j(u).filter((l) => l.length > 1).filter((l) => v(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 qt(t, n) {
-  const e = t.map((s) => {
-    const r = b(
-      s.holes.map((i) => E(i, 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 nt(E(s.contour, n), r);
+    return et(F(s.contour, e), r);
   });
-  return b(e);
+  return y(n);
 }
-function Nt(t, n) {
-  const e = Math.abs(n / 2), s = t.map(
-    (r) => b(
-      r.allLoops.map((i) => nt(E(i, e), E(i, -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(s);
+  return y(s);
 }
-function tn(t, n) {
-  return qt(S(t), n);
+function fe(t, e) {
+  return Xt(I(t), e);
 }
-function nn(t, n, { endCap: e = "round" } = {}) {
-  return t instanceof y ? zt(t, n, e) : Nt(S(t), n);
-}
-function U(t) {
-  if (t instanceof w)
-    return `L ${t.lastPoint.join(" ")}`;
-  if (t instanceof M)
-    return `A ${t.radius} ${t.radius} 0 ${t.angularLength > Math.PI ? "1" : "0"} ${t.clockwise ? "0" : "1"} ${t.lastPoint.join(" ")}`;
-  if (t instanceof O)
-    return `A ${t.majorRadius} ${t.minorRadius} ${t.tiltAngle * Et} ${t.deltaAngle > Math.PI ? "1" : "0"} ${t.clockwise ? "0" : "1"} ${t.lastPoint.join(" ")}`;
-  throw new Error("Unknown segment type");
+function le(t, e, { endCap: n = "round" } = {}) {
+  return t instanceof C ? Kt(t, e, n) : Yt(I(t), e);
 }
-function rt(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(U).join(" ");
-  return `${n} ${e} Z`;
-}
-function ot(t) {
-  return `<path d="${t.allLoops.map(rt).join(" ")}" />`;
-}
-function _t(t) {
-  return `<g>
-  ${t.figures.map(ot).join(`
-`)}
-</g>`;
-}
-function Jt(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(U).join(" ");
-  return `${n} ${e}`;
-}
-function Ht(t, n = 1) {
-  const e = t.xMin - n, s = t.yMin - n;
-  return `${e} ${s} ${t.width + 2 * n} ${t.height + 2 * n}`;
-}
-function H(t, n, e = 1, s) {
-  const r = Ht(n, e), i = s ? `width="${n.width + 2 * e}${s}" height="${n.height + 2 * e}${s}"` : "";
-  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" ${i}>
-    ${t}
-</svg>`;
-}
-function W(t) {
-  if (t instanceof h)
-    return _t(t);
-  if (t instanceof p)
-    return ot(t);
+function Q(t) {
+  if (t instanceof g)
+    return Rt(t);
+  if (t instanceof d)
+    return Ot(t);
   if (t instanceof P)
-    return `<path d="${rt(t)}" />`;
-  if (t instanceof y)
-    return `<path d="${Jt(t)}" />`;
-  if (t instanceof M || t instanceof w || t instanceof O)
-    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${U(
+    return `<path d="${Bt(t)}" />`;
+  if (t instanceof C)
+    return `<path d="${$t(t)}" />`;
+  if (It(t))
+    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${Gt(
       t
     )}" />`;
   throw new Error("Unknown shape type");
 }
-const X = (t) => "shape" in t ? t.shape : t, Y = (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;
-};
-function en(t, {
-  margin: n = 1,
-  unit: e = null
+    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 r = t.map((c) => X(c).mirror()), i = r.map((c, f) => Y(t[f], W(c))).join(`
-`), o = r.slice(1).reduce((c, f) => c.merge(f.boundingBox), r[0].boundingBox);
-    return H(i, o, 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 s = X(t).mirror();
-  return H(
-    Y(t, W(s)),
-    s.boundingBox,
-    n,
-    e
+  const r = Z(t).mirror();
+  return z(
+    H(t, Q(r)),
+    s ? W(s) : r.boundingBox,
+    e,
+    n
   );
 }
-const at = (t) => {
+const rt = (t) => {
   if (t.type === "LINE")
-    return new w(t.firstPoint, t.lastPoint);
+    return new S(t.firstPoint, t.lastPoint);
   if (t.type === "ARC")
-    return new M(
+    return new b(
       t.firstPoint,
       t.lastPoint,
       t.center,
       t.clockwise
     );
   if (t.type === "ELLIPSE_ARC")
-    return new O(
+    return new Ct(
       t.firstPoint,
       t.lastPoint,
       t.center,
@@ -605,54 +585,67 @@ const at = (t) => {
       t.clockwise,
       { angleUnits: "rad" }
     );
+  if (t.type === "QUADRATIC_BEZIER")
+    return new xt(
+      t.firstPoint,
+      t.lastPoint,
+      t.controlPoint
+    );
+  if (t.type === "CUBIC_BEZIER")
+    return new Dt(
+      t.firstPoint,
+      t.lastPoint,
+      t.firstControlPoint,
+      t.lastControlPoint
+    );
   throw new Error("Unknown segment type");
-}, R = (t) => {
-  const n = t.segments.map(at);
-  return new P(n);
-}, ct = (t) => {
-  const n = R(t.contour), e = t.holes.map(R);
-  return new p(n, e);
-}, Wt = (t) => {
-  const n = t.figures.map(ct);
-  return new h(n);
+}, 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 e = t.figures.map(ot);
+  return new g(e);
 };
-function sn(t) {
+function ge(t) {
   if (t.type === "DIAGRAM")
-    return Wt(t);
+    return jt(t);
   if (t.type === "FIGURE")
-    return ct(t);
+    return ot(t);
   if (t.type === "LOOP")
-    return R(t);
-  if (t.type === "LINE" || t.type === "ARC" || t.type === "ELLIPSE_ARC")
-    return at(t);
+    return O(t);
+  if (t.type === "LINE" || t.type === "ARC" || t.type === "ELLIPSE_ARC" || t.type === "CUBIC_BEZIER")
+    return rt(t);
   throw new Error("Unknown shape type");
 }
-const Z = Math.PI / 180, Xt = 180 / Math.PI;
-function rn(t, n) {
-  const e = Math.cos(n * Z) * t, s = Math.sin(n * Z) * t;
-  return [e, s];
+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 on([t, n]) {
-  const e = Math.sqrt(t * t + n * n), s = Math.atan2(n, t) * Xt;
-  return [e, s];
+function pe([t, e]) {
+  const n = Math.sqrt(t * t + e * e), s = Math.atan2(e, t) * te;
+  return [n, s];
 }
 export {
-  Z as DEG2RAD,
-  Xt as RAD2DEG,
-  on as cartesianToPolar,
-  jt as confineStrand,
-  nt as cut,
-  fn as draw,
-  Qt as eraseStrand,
-  un as exportJSON,
-  en as exportSVG,
-  yt as fuse,
-  b as fuseAll,
-  sn as importJSON,
-  Kt as intersect,
-  tn as offset,
-  nn as outlineStroke,
-  rn as polarToCartesian,
-  W 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