pantograph2d 0.2.0 → 0.3.1

package/dist/pantograph.js

@@ -1,286 +1,608 @@
-import { s as v, L as c, t as x, p as D, a as M, b as k, d as b, c as F, e as I, T as R, D as a, F as h, f as g, g as p, h as m, i as G, j as B, k as C, A as l } from "./exportJSON-b3e1c256.js";
-import { l as rt } from "./exportJSON-b3e1c256.js";
-function U(n) {
-  if (!n.length)
-    throw new Error("No segments to close");
-  const t = n[0], r = n.at(-1);
-  return v(t.firstPoint, r.lastPoint) ? n : [
-    ...n,
-    new c(r.lastPoint, t.firstPoint)
+import { L as p, A as P, a as L, s as C, p as D, t as Q, c as j, f as ct, b as ft, d as A, e as ut, g as S, h as $, T as lt, D as g, F as T, i as M, j as _, k as V, l as ht, m as gt, n as pt, o as mt, q as Pt, r as wt, u as tt, v as dt, w as At, x as nt, y as St, z as vt, S as Lt } from "./exportJSON-26bb92ef.js";
+import { B as Zt } from "./exportJSON-26bb92ef.js";
+class F {
+  constructor(n, e) {
+    this.firstPoint = n, this.lastPoint = e;
+  }
+}
+function k(t, n) {
+  if (t instanceof p)
+    return Ct(t, n);
+  if (t instanceof P)
+    return Tt(t, n);
+  throw new Error("Not implemented");
+}
+function Ct(t, n) {
+  const { firstPoint: e, lastPoint: r } = t, s = t.normalVector;
+  return new p(
+    L(e, C(s, n)),
+    L(r, C(s, n))
+  );
+}
+function Tt(t, n) {
+  const e = L(
+    t.firstPoint,
+    C(D(t.tangentAtFirstPoint), n)
+  ), r = L(
+    t.lastPoint,
+    C(D(t.tangentAtLastPoint), n)
+  ), s = n * (t.clockwise ? 1 : -1);
+  return t.radius + s < t.precision ? new F(e, r) : new P(e, r, t.center, t.clockwise);
+}
+function et(t, n, e) {
+  const r = j(
+    t.tangentAtLastPoint,
+    n.tangentAtFirstPoint
+  );
+  if (Math.abs(r) < 1e-10)
+    return null;
+  const s = r > 0 ? 1 : -1, i = Math.abs(e) * s, o = k(t, i), u = k(n, i);
+  if (o instanceof F || u instanceof F)
+    return null;
+  let c;
+  try {
+    c = ct(o, u, 1e-9).at(-1);
+  } catch {
+    return null;
+  }
+  if (!c)
+    return null;
+  const m = c, a = (v, b) => {
+    const w = b.tangentAt(m), d = ft(w), h = L(m, C(d, i));
+    return v.splitAt(h);
+  }, [f] = a(t, o), [, l] = a(n, u);
+  return { first: f, second: l, center: m };
+}
+function B(t, n, e) {
+  const r = et(t, n, e);
+  if (!r)
+    return console.warn(
+      "Cannot fillet between segments",
+      t.repr,
+      n.repr
+    ), [t, n];
+  const { first: s, second: i } = r;
+  return [
+    s,
+    Q(s.lastPoint, i.firstPoint, s.tangentAtLastPoint),
+    i
   ];
 }
-function w(n) {
-  return new a([new h(new g(n))]);
+function G(t, n, e) {
+  const r = et(t, n, e);
+  if (!r)
+    return console.warn(
+      "Cannot chamfer between segments",
+      t.repr,
+      n.repr
+    ), [t, n];
+  const { first: s, second: i } = r;
+  return [s, new p(s.lastPoint, i.firstPoint), i];
+}
+function N(t) {
+  return new g([new T(new M(t))]);
 }
-class N {
-  constructor(t = [0, 0]) {
-    this.pointer = t, this.firstPoint = t, this.pendingSegments = [];
+class Et {
+  constructor(n = [0, 0]) {
+    this.pointer = n, this.firstPoint = n, this.pendingSegments = [], this._nextCorner = null;
   }
-  movePointerTo(t) {
+  movePointerTo(n) {
     if (this.pendingSegments.length)
       throw new Error(
         "You can only move the pointer if there is no segment defined"
       );
-    return this.pointer = t, this.firstPoint = t, this;
+    return this.pointer = n, this.firstPoint = n, this;
   }
-  saveSegment(t) {
-    if (v(t.firstPoint, t.lastPoint))
-      throw new Error(`Segment has no length, ${t.repr}`);
-    return this.pendingSegments.push(t), this;
+  saveSegment(n) {
+    if (A(n.firstPoint, n.lastPoint))
+      throw new Error(`Segment has no length, ${n.repr}`);
+    if (!this._nextCorner)
+      return this.pendingSegments.push(n), this;
+    const e = this.pendingSegments.pop();
+    if (!e)
+      throw new Error("bug in the custom corner algorithm");
+    const r = this._nextCorner.mode === "chamfer" ? G : B;
+    return this.pendingSegments.push(
+      ...r(e, n, this._nextCorner.radius)
+    ), this._nextCorner = null, this;
   }
-  lineTo(t) {
-    const r = new c(this.pointer, t);
-    return this.pointer = t, this.saveSegment(r);
+  lineTo(n) {
+    const e = new p(this.pointer, n);
+    return this.pointer = n, this.saveSegment(e);
   }
-  line(t, r) {
-    return this.lineTo([this.pointer[0] + t, this.pointer[1] + r]);
+  line(n, e) {
+    return this.lineTo([this.pointer[0] + n, this.pointer[1] + e]);
   }
-  vLine(t) {
-    return this.line(0, t);
+  vLine(n) {
+    return this.line(0, n);
   }
-  hLine(t) {
-    return this.line(t, 0);
+  hLine(n) {
+    return this.line(n, 0);
   }
-  vLineTo(t) {
-    return this.lineTo([this.pointer[0], t]);
+  vLineTo(n) {
+    return this.lineTo([this.pointer[0], n]);
   }
-  hLineTo(t) {
-    return this.lineTo([t, this.pointer[1]]);
+  hLineTo(n) {
+    return this.lineTo([n, this.pointer[1]]);
   }
-  polarLineTo([t, r]) {
-    const e = r * m, i = p(t, e);
-    return this.lineTo(i);
+  polarLineTo([n, e]) {
+    const r = e * V, s = _(n, r);
+    return this.lineTo(s);
   }
-  polarLine(t, r) {
-    const e = r * m, [i, o] = p(t, e);
-    return this.line(i, o);
+  polarLine(n, e) {
+    const r = e * V, [s, i] = _(n, r);
+    return this.line(s, i);
   }
-  tangentLine(t) {
-    const r = this.pendingSegments.at(-1);
-    if (!r)
+  tangentLine(n) {
+    const e = this.pendingSegments.at(-1);
+    if (!e)
       throw new Error("You need a previous segment to sketch a tangent line");
-    const [e, i] = r.tangentAtLastPoint;
-    return this.line(e * t, i * t);
+    const [r, s] = e.tangentAtLastPoint;
+    return this.line(r * n, s * n);
   }
-  threePointsArcTo(t, r) {
-    return this.saveSegment(x(this.pointer, r, t)), this.pointer = t, this;
+  threePointsArcTo(n, e) {
+    return this.saveSegment(ut(this.pointer, e, n)), this.pointer = n, this;
   }
-  threePointsArc(t, r, e, i) {
-    const [o, s] = this.pointer;
+  threePointsArc(n, e, r, s) {
+    const [i, o] = this.pointer;
     return this.threePointsArcTo(
-      [o + t, s + r],
-      [o + e, s + i]
+      [i + n, o + e],
+      [i + r, o + s]
     );
   }
-  sagittaArcTo(t, r) {
-    if (!r)
-      return this.lineTo(t);
-    const e = new c(this.pointer, t), i = D(e.tangentAtFirstPoint), o = M(e.midPoint, k(i, r));
-    return this.threePointsArcTo(t, o);
+  sagittaArcTo(n, e) {
+    if (!e)
+      return this.lineTo(n);
+    const r = new p(this.pointer, n), s = D(r.tangentAtFirstPoint), i = L(r.midPoint, C(s, e));
+    return this.threePointsArcTo(n, i);
   }
-  sagittaArc(t, r, e) {
+  sagittaArc(n, e, r) {
     return this.sagittaArcTo(
-      [t + this.pointer[0], r + this.pointer[1]],
-      e
+      [n + this.pointer[0], e + this.pointer[1]],
+      r
     );
   }
-  vSagittaArc(t, r) {
-    return this.sagittaArc(0, t, r);
+  vSagittaArc(n, e) {
+    return this.sagittaArc(0, n, e);
   }
-  hSagittaArc(t, r) {
-    return this.sagittaArc(t, 0, r);
+  hSagittaArc(n, e) {
+    return this.sagittaArc(n, 0, e);
   }
-  bulgeArcTo(t, r) {
-    if (!r)
-      return this.lineTo(t);
-    const e = b(this.pointer, t) / 2, i = -r * e;
-    return this.sagittaArcTo(t, i);
+  bulgeArcTo(n, e) {
+    if (!e)
+      return this.lineTo(n);
+    const r = S(this.pointer, n) / 2, s = -e * r;
+    return this.sagittaArcTo(n, s);
   }
-  bulgeArc(t, r, e) {
+  bulgeArc(n, e, r) {
     return this.bulgeArcTo(
-      [t + this.pointer[0], r + this.pointer[1]],
-      e
+      [n + this.pointer[0], e + this.pointer[1]],
+      r
     );
   }
-  vBulgeArc(t, r) {
-    return this.bulgeArc(0, t, r);
+  vBulgeArc(n, e) {
+    return this.bulgeArc(0, n, e);
   }
-  hBulgeArc(t, r) {
-    return this.bulgeArc(t, 0, r);
+  hBulgeArc(n, e) {
+    return this.bulgeArc(n, 0, e);
   }
-  tangentArcTo(t) {
-    const r = this.pendingSegments.at(-1);
-    if (!r)
+  tangentArcTo(n) {
+    const e = this.pendingSegments.at(-1);
+    if (!e)
       throw new Error("You need a previous curve to sketch a tangent arc");
     return this.saveSegment(
-      F(this.pointer, t, r.tangentAtLastPoint)
-    ), this.pointer = t, this;
+      Q(this.pointer, n, e.tangentAtLastPoint)
+    ), this.pointer = n, this;
   }
-  tangentArc(t, r) {
-    const [e, i] = this.pointer;
-    return this.tangentArcTo([t + e, r + i]);
+  tangentArc(n, e) {
+    const [r, s] = this.pointer;
+    return this.tangentArcTo([n + r, e + s]);
+  }
+  customCorner(n, e = "fillet") {
+    if (!this.pendingSegments.length)
+      throw new Error("You need a segment defined to fillet the angle");
+    return this._nextCorner = { mode: e, radius: n }, this;
+  }
+  _customCornerLastWithFirst(n, e = "fillet") {
+    if (!n)
+      return;
+    const r = this.pendingSegments.pop(), s = this.pendingSegments.shift();
+    if (!r || !s)
+      throw new Error("Not enough curves to close and fillet");
+    const i = e === "chamfer" ? G : B;
+    this.pendingSegments.push(...i(r, s, n));
   }
   close() {
-    const t = U(this.pendingSegments);
-    return w(t);
+    if (!this.pendingSegments.length)
+      throw new Error("No segments to close");
+    const n = this.pendingSegments[0], e = this.pendingSegments.at(-1);
+    return A(n.firstPoint, e.lastPoint) || this.lineTo(n.firstPoint), this._nextCorner !== null && (this._customCornerLastWithFirst(
+      this._nextCorner.radius,
+      this._nextCorner.mode
+    ), this._nextCorner = null), N(this.pendingSegments);
   }
   closeWithMirror() {
     if (!this.pendingSegments.length)
       throw new Error("No segments to close");
-    const t = this.pendingSegments[0], r = this.pendingSegments.at(-1), e = I(
-      r.lastPoint,
-      t.firstPoint
-    ), i = new R().mirrorLine(
-      e,
-      t.firstPoint
-    ), o = this.pendingSegments.map(
-      (s) => s.transform(i).reverse()
+    const n = this.pendingSegments[0], e = this.pendingSegments.at(-1), r = $(
+      e.lastPoint,
+      n.firstPoint
+    ), s = new lt().mirrorLine(
+      r,
+      n.firstPoint
+    ), i = this.pendingSegments.map(
+      (o) => o.transform(s).reverse()
     );
-    return o.reverse(), w([
+    return i.reverse(), N([
       ...this.pendingSegments,
-      ...o
+      ...i
     ]);
   }
 }
-function X(n = [0, 0]) {
-  return new N(n);
+function Gt(t = [0, 0]) {
+  return new Et(t);
 }
-function u(n) {
-  if (n instanceof h)
-    return [n];
-  if (n instanceof g)
-    return [new h(n)];
-  if (n instanceof a)
-    return n.figures;
+function E(t) {
+  if (t instanceof T)
+    return [t];
+  if (t instanceof M)
+    return [new T(t)];
+  if (t instanceof g)
+    return t.figures;
   throw new Error("Unknown shape");
 }
-function V(n, t) {
-  return new a(
-    G(u(n), u(t))
+function Ft(t, n) {
+  return new g(
+    ht(E(t), E(n))
   );
 }
-function Z(n) {
-  return n.reduce(
-    (t, r) => V(t, r),
-    new a()
+function U(t) {
+  return t.reduce(
+    (n, e) => Ft(n, e),
+    new g()
   );
 }
-function z(n, t) {
-  return new a(
-    B(u(n), u(t))
+function Mt(t, n) {
+  return new g(
+    gt(E(t), E(n))
+  );
+}
+function Nt(t, n) {
+  return new g(
+    pt(E(t), E(n))
+  );
+}
+function Y(t) {
+  return t < 0 ? "before" : t > 1 ? "after" : "between";
+}
+const q = (t, n, e) => {
+  if (e === "before")
+    return t.distanceFrom(n.firstPoint);
+  if (e === "after")
+    return t.distanceFrom(n.lastPoint);
+  throw new Error("Invalid position");
+};
+function bt(t, n) {
+  const e = mt(t, n);
+  if (e === "parallel")
+    return Math.min(
+      t.distanceFrom(n.firstPoint),
+      t.distanceFrom(n.lastPoint)
+    );
+  const { intersectionParam1: r, intersectionParam2: s } = e, i = Y(r), o = Y(s);
+  if (i === "between" && o === "between")
+    return 0;
+  if (i === "between" && o !== "between")
+    return q(t, n, o);
+  if (o === "between" && i !== "between")
+    return q(n, t, i);
+  if (i === "before" && o === "before")
+    return S(t.firstPoint, n.firstPoint);
+  if (i === "after" && o === "after")
+    return S(t.lastPoint, n.lastPoint);
+  if (i === "before" && o === "after")
+    return S(t.firstPoint, n.lastPoint);
+  if (i === "after" && o === "before")
+    return S(t.lastPoint, n.firstPoint);
+  throw new Error("Invalid position");
+}
+function z(t, n) {
+  if (Pt(t, n).length > 0)
+    return 0;
+  const e = wt(t, n.center);
+  if (t.isOnSegment(e)) {
+    const r = S(e, n.center);
+    if (Math.abs(r - n.radius) < t.precision && n.isOnSegment(e))
+      return 0;
+    if (r - n.radius > t.precision) {
+      const s = tt(
+        $(e, n.center)
+      ), i = L(
+        n.center,
+        C(s, n.radius)
+      );
+      if (n.isOnSegment(i))
+        return S(i, e);
+    }
+  }
+  return Math.min(
+    n.distanceFrom(t.firstPoint),
+    n.distanceFrom(t.lastPoint),
+    t.distanceFrom(n.firstPoint),
+    t.distanceFrom(n.lastPoint)
   );
 }
-function H(n, t) {
-  return new a(
-    C(u(n), u(t))
+const $t = (t, n) => {
+  const e = t.angleToParam(n.firstAngle);
+  if (t.isValidParameter(e))
+    return !0;
+  const r = t.angleToParam(n.lastAngle);
+  return !!t.isValidParameter(r);
+};
+function yt(t, n) {
+  if (dt(t, n, !0).length > 0)
+    return 0;
+  const e = S(t.center, n.center);
+  if (e < t.precision && $t(t, n))
+    return Math.abs(t.radius - n.radius);
+  const r = tt($(n.center, t.center)), s = e - Math.abs(t.radius - n.radius) < t.precision;
+  let i = At(r);
+  s && n.radius > t.radius && (i += Math.PI);
+  const o = s ? i : i + Math.PI, u = t.angleToParam(i), c = n.angleToParam(o);
+  return t.isValidParameter(u) && n.isValidParameter(c) ? S(t.paramPoint(u), n.paramPoint(c)) : Math.min(
+    t.distanceFrom(n.firstPoint),
+    t.distanceFrom(n.lastPoint),
+    n.distanceFrom(t.firstPoint),
+    n.distanceFrom(t.lastPoint)
   );
 }
-function S(n) {
-  if (n instanceof c)
-    return `L ${n.lastPoint.join(" ")}`;
-  if (n instanceof l)
-    return `A ${n.radius} ${n.radius} 0 ${n.angularLength > Math.PI ? "1" : "0"} ${n.clockwise ? "0" : "1"} ${n.lastPoint.join(" ")}`;
+function xt(t, n) {
+  if (t instanceof p && n instanceof p)
+    return bt(t, n);
+  if (t instanceof p && n instanceof P)
+    return z(t, n);
+  if (t instanceof P && n instanceof p)
+    return z(n, t);
+  if (t instanceof P && n instanceof P)
+    return yt(t, n);
+  throw new Error("Not implemented");
+}
+const I = 1e-8;
+function Dt(t, n) {
+  const e = t.map((c) => ({
+    offset: k(c, n),
+    original: c
+  })), r = [];
+  let s = null, i = e.at(-1);
+  if (!i)
+    return [];
+  if (r.length === 1)
+    return r;
+  const o = (c) => {
+    s ? c.offset instanceof F ? A(c.offset.firstPoint, c.offset.lastPoint) || r.push(
+      new p(c.offset.firstPoint, c.offset.lastPoint)
+    ) : r.push(c.offset) : s = c;
+  }, u = function* () {
+    for (const c of e.slice(0, -1))
+      yield c;
+    if (!s)
+      throw new Error("Bug in the offset algorithm");
+    yield s;
+  };
+  for (const c of u()) {
+    const m = i.offset.lastPoint, a = c.offset.firstPoint;
+    if (A(m, a)) {
+      o(i), i = c;
+      continue;
+    }
+    let f = [];
+    if (!(i.offset instanceof F) && !(c.offset instanceof F)) {
+      const { intersections: w, overlaps: d } = nt(
+        i.offset,
+        c.offset,
+        I / 100
+      );
+      f = [
+        ...w,
+        ...d.flatMap((h) => [h.firstPoint, h.lastPoint])
+      ];
+    }
+    if (f.length > 0) {
+      let w = f[0];
+      if (f.length > 1) {
+        const x = i == null ? void 0 : i.original.lastPoint, y = f.map(
+          (at) => vt(at, x)
+        );
+        w = f[y.indexOf(Math.min(...y))];
+      }
+      const d = i.offset.splitAt([
+        w
+      ])[0], h = c.offset.splitAt([w]).at(-1);
+      if (!h)
+        throw new Error("Bug in the splitting algo in offset");
+      o({
+        offset: d,
+        original: i.original
+      }), i = { offset: h, original: c.original };
+      continue;
+    }
+    const l = i.original.lastPoint, v = j(
+      $(a, l),
+      $(m, l)
+    ) > 0, b = new P(m, a, l, v);
+    o(i), r.push(b), i = c;
+  }
+  return o(i), r;
+}
+function W(t, n) {
+  const e = t.clockwise ? n : -n, r = Dt(t.segments, e);
+  if (r.length < 2)
+    return new g();
+  const s = /* @__PURE__ */ new Map(), i = (a, f) => {
+    const l = s.get(a) || [];
+    s.set(a, [...l, ...f]);
+  };
+  if (r.forEach((a, f) => {
+    r.slice(f + 1).forEach((l, v) => {
+      const { intersections: b, overlaps: w } = nt(a, l, I), d = [
+        ...b,
+        ...w.flatMap((h) => [h.firstPoint, h.lastPoint])
+      ].filter((h) => {
+        const x = A(h, a.firstPoint) || A(h, a.lastPoint), y = A(h, l.firstPoint) || A(h, l.lastPoint);
+        return !(x && y);
+      });
+      d.length && (i(f, d), i(v + f + 1, d));
+    });
+  }), !s.size) {
+    const a = new M(r);
+    return new g([new T(a)]);
+  }
+  const u = r.flatMap((a, f) => {
+    if (!s.has(f))
+      return a;
+    const l = s.get(f) || [];
+    return a.splitAt(l);
+  }).filter((a) => !t.segments.some((l) => xt(l, a) < Math.abs(n) - I));
+  if (!u.length)
+    return new g();
+  const m = St(u).filter((a) => a.length > 1).filter((a) => A(a[0].firstPoint, a.at(-1).lastPoint)).map((a) => new M(a));
+  return m.length ? new g(m.map((a) => new T(a))) : new g();
+}
+function kt(t, n) {
+  const e = t.map((r) => {
+    const s = U(
+      r.holes.map((i) => W(i, n))
+    );
+    return Mt(W(r.contour, n), s);
+  });
+  return U(e);
+}
+function Ut(t, n) {
+  return kt(E(t), n);
+}
+function R(t) {
+  if (t instanceof p)
+    return `L ${t.lastPoint.join(" ")}`;
+  if (t instanceof P)
+    return `A ${t.radius} ${t.radius} 0 ${t.angularLength > Math.PI ? "1" : "0"} ${t.clockwise ? "0" : "1"} ${t.lastPoint.join(" ")}`;
   throw new Error("Unknown segment type");
 }
-function T(n) {
-  const t = `M ${n.firstPoint.join(" ")}`, r = n.segments.map(S).join(" ");
-  return `${t} ${r} Z`;
+function rt(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(R).join(" ");
+  return `${n} ${e} Z`;
 }
-function L(n) {
-  return `<path d="${n.allLoops.map(T).join(" ")}" />`;
+function it(t) {
+  return `<path d="${t.allLoops.map(rt).join(" ")}" />`;
 }
-function O(n) {
+function It(t) {
   return `<g>
-  ${n.figures.map(L).join(`
+  ${t.figures.map(it).join(`
 `)}
 </g>`;
 }
-function Y(n, t = 1) {
-  const r = n.xMin - t, e = n.yMin - t;
-  return `${r} ${e} ${n.width + 2 * t} ${n.height + 2 * t}`;
+function Ot(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(R).join(" ");
+  return `${n} ${e}`;
 }
-function A(n, t, r = 1) {
+function Rt(t, n = 1) {
+  const e = t.xMin - n, r = t.yMin - n;
+  return `${e} ${r} ${t.width + 2 * n} ${t.height + 2 * n}`;
+}
+function J(t, n, e = 1) {
   return `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${Y(t, r)}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke">
-    ${n}
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${Rt(n, e)}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke">
+    ${t}
 </svg>`;
 }
-function d(n) {
-  if (n instanceof a)
-    return O(n);
-  if (n instanceof h)
-    return L(n);
-  if (n instanceof g)
-    return `<path d="${T(n)}" />`;
-  if (n instanceof l || n instanceof c)
-    return `<path d="${`M ${n.firstPoint.join(" ")}`} ${S(
-      n
+function X(t) {
+  if (t instanceof g)
+    return It(t);
+  if (t instanceof T)
+    return it(t);
+  if (t instanceof M)
+    return `<path d="${rt(t)}" />`;
+  if (t instanceof Lt)
+    return `<path d="${Ot(t)}" />`;
+  if (t instanceof P || t instanceof p)
+    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${R(
+      t
     )}" />`;
   throw new Error("Unknown shape type");
 }
-function K(n, t = 1) {
-  if (Array.isArray(n)) {
-    const e = n.map((s) => s.mirror()), i = e.map((s) => d(s)).join(`
-`), o = e.slice(1).reduce((s, E) => s.merge(E.boundingBox), e[0].boundingBox);
-    return A(i, o);
-  }
-  const r = n.mirror();
-  return A(d(r), r.boundingBox, t);
-}
-const $ = (n) => {
-  if (n.type === "LINE")
-    return new c(n.firstPoint, n.lastPoint);
-  if (n.type === "ARC")
-    return new l(
-      n.firstPoint,
-      n.lastPoint,
-      n.center,
-      n.clockwise
+const Z = (t) => "shape" in t ? t.shape : t, H = (t, n) => {
+  if (!("shape" in t))
+    return n;
+  const { color: e } = t;
+  return e ? `<g stroke="${e}">${n}</g>` : n;
+};
+function Yt(t, n = 1) {
+  if (Array.isArray(t)) {
+    const r = t.map((o) => Z(o).mirror()), s = r.map((o, u) => H(t[u], X(o))).join(`
+`), i = r.slice(1).reduce((o, u) => o.merge(u.boundingBox), r[0].boundingBox);
+    return J(s, i);
+  }
+  const e = Z(t).mirror();
+  return J(
+    H(t, X(e)),
+    e.boundingBox,
+    n
+  );
+}
+const st = (t) => {
+  if (t.type === "LINE")
+    return new p(t.firstPoint, t.lastPoint);
+  if (t.type === "ARC")
+    return new P(
+      t.firstPoint,
+      t.lastPoint,
+      t.center,
+      t.clockwise
     );
   throw new Error("Unknown segment type");
-}, f = (n) => {
-  const t = n.segments.map($);
-  return new g(t);
-}, y = (n) => {
-  const t = f(n.contour), r = n.holes.map(f);
-  return new h(t, r);
-}, J = (n) => {
-  const t = n.figures.map(y);
-  return new a(t);
+}, O = (t) => {
+  const n = t.segments.map(st);
+  return new M(n);
+}, ot = (t) => {
+  const n = O(t.contour), e = t.holes.map(O);
+  return new T(n, e);
+}, _t = (t) => {
+  const n = t.figures.map(ot);
+  return new g(n);
 };
-function Q(n) {
-  if (n.type === "DIAGRAM")
-    return J(n);
-  if (n.type === "FIGURE")
-    return y(n);
-  if (n.type === "LOOP")
-    return f(n);
-  if (n.type === "LINE" || n.type === "ARC")
-    return $(n);
+function qt(t) {
+  if (t.type === "DIAGRAM")
+    return _t(t);
+  if (t.type === "FIGURE")
+    return ot(t);
+  if (t.type === "LOOP")
+    return O(t);
+  if (t.type === "LINE" || t.type === "ARC")
+    return st(t);
   throw new Error("Unknown shape type");
 }
-const P = Math.PI / 180, q = 180 / Math.PI;
-function _(n, t) {
-  const r = Math.cos(t * P) * n, e = Math.sin(t * P) * n;
-  return [r, e];
+const K = Math.PI / 180, Vt = 180 / Math.PI;
+function zt(t, n) {
+  const e = Math.cos(n * K) * t, r = Math.sin(n * K) * t;
+  return [e, r];
 }
-function j([n, t]) {
-  const r = Math.sqrt(n * n + t * t), e = Math.atan2(t, n) * q;
-  return [r, e];
+function Wt([t, n]) {
+  const e = Math.sqrt(t * t + n * n), r = Math.atan2(n, t) * Vt;
+  return [e, r];
 }
 export {
-  P as DEG2RAD,
-  q as RAD2DEG,
-  j as cartesianToPolar,
-  z as cut,
-  X as draw,
-  rt as exportJSON,
-  K as exportSVG,
-  V as fuse,
-  Z as fuseAll,
-  Q as importJSON,
-  H as intersect,
-  _ as polarToCartesian,
-  d as svgBody
+  K as DEG2RAD,
+  Vt as RAD2DEG,
+  Wt as cartesianToPolar,
+  Mt as cut,
+  Gt as draw,
+  Zt as exportJSON,
+  Yt as exportSVG,
+  Ft as fuse,
+  U as fuseAll,
+  qt as importJSON,
+  Nt as intersect,
+  Ut as offset,
+  zt as polarToCartesian,
+  X as svgBody
 };
 //# sourceMappingURL=pantograph.js.map