pantograph2d 0.3.0 → 0.4.0

package/dist/pantograph.js

@@ -1,825 +1,451 @@
-import { L as A, A as y, a as F, s as v, p as $, t as nt, c as et, f as ut, b as pt, d as _, e as dt, g as S, h as L, T as gt, D as P, F as b, i as I, j as Y, k as R, l as mt, m as wt, n as Pt, o as At, q as xt, r as yt, u as it, v as _t, w as St, x as st, y as Ft } from "./exportJSON-c42ca4ac.js";
-import { z as tn } from "./exportJSON-c42ca4ac.js";
-class T {
-  constructor(t, e) {
-    this.firstPoint = t, this.lastPoint = e;
-  }
+import { o as nt, D } from "./draw-44dd36a9.js";
+import { d as Jt } from "./draw-44dd36a9.js";
+import { F as h, L as $, D as P, f as C, r as et, z as st, s as rt, a as ot, c as it, i as ft, l as at, d as g, b as ct, p as ut, n as Z, e as E, g as lt, h as pt, j as Pt, k as mt, m as d, A as w, o as L, q as gt, t as dt, u as wt, S as ht } from "./Diagram-1c56996e.js";
+import { v as Xt } from "./Diagram-1c56996e.js";
+function F(t) {
+  if (t instanceof h)
+    return [t];
+  if (t instanceof $)
+    return [new h(t)];
+  if (t instanceof P)
+    return t.figures;
+  throw new Error("Unknown shape");
 }
-function D(n, t) {
-  if (n instanceof A)
-    return vt(n, t);
-  if (n instanceof y)
-    return bt(n, t);
-  throw new Error("Not implemented");
+function H(t, n, e = 1e-9) {
+  let r = [];
+  const o = [], s = new Array(n.segments.length).fill(0).map(() => []);
+  n.segments.forEach((u, i) => {
+    t.segments.forEach((m) => {
+      const { intersections: f, overlaps: c } = C(
+        u,
+        m,
+        e
+      );
+      r.push(...f), s[i].push(...f), o.push(...c);
+      const l = c.flatMap((S) => [
+        S.firstPoint,
+        S.lastPoint
+      ]);
+      r.push(...l), s[i].push(...l);
+    });
+  }), r = et(r, e);
+  const a = st([n.segments, s]).flatMap(([u, i]) => i.length ? u.splitAt(i) : [u]);
+  return Array.from(
+    rt(
+      a,
+      r,
+      o
+    )
+  );
 }
-function vt(n, t) {
-  const { firstPoint: e, lastPoint: i } = n, r = n.normalVector;
-  return new A(
-    F(e, v(r, t)),
-    F(i, v(r, t))
+function O(t, n, e = !1) {
+  return H(n, t).filter((o) => {
+    const s = o.segments[0].midPoint;
+    return n.onStroke(s) ? !e : !n.contains(s);
+  });
+}
+function x(t, n, e = !1) {
+  return H(n, t).filter((o) => {
+    const s = o.segments[0].midPoint;
+    return n.onStroke(s) ? !e : n.contains(s);
+  });
+}
+function V(t, n, e = !1) {
+  const r = O(
+    t,
+    n.contour,
+    e
+  ), o = n.holes.flatMap(
+    (s) => x(t, s, e)
   );
+  return [...r, ...o];
 }
-function bt(n, t) {
-  const e = F(
-    n.firstPoint,
-    v($(n.tangentAtFirstPoint), t)
-  ), i = F(
-    n.lastPoint,
-    v($(n.tangentAtLastPoint), t)
-  ), r = t * (n.clockwise ? 1 : -1);
-  return n.radius + r < n.precision ? new T(e, i) : new y(e, i, n.center, n.clockwise);
-}
-function rt(n, t, e) {
-  const i = et(
-    n.tangentAtLastPoint,
-    t.tangentAtFirstPoint
+function T(t, n, e = !1) {
+  let r = x(
+    t,
+    n.contour,
+    e
   );
-  if (Math.abs(i) < 1e-10)
-    return null;
-  const r = i > 0 ? 1 : -1, s = Math.abs(e) * r, o = D(n, s), a = D(t, s);
-  if (o instanceof T || a instanceof T)
-    return null;
-  let h;
-  try {
-    h = ut(o, a, 1e-9).at(-1);
-  } catch {
-    return null;
-  }
-  if (!h)
-    return null;
-  const l = h, c = (p, g) => {
-    const m = g.tangentAt(l), x = pt(m), d = F(l, v(x, s));
-    return p.splitAt(d);
-  }, [f] = c(n, o), [, u] = c(t, a);
-  return { first: f, second: u, center: l };
-}
-function V(n, t, e) {
-  const i = rt(n, t, e);
-  if (!i)
-    return console.warn(
-      "Cannot fillet between segments",
-      n.repr,
-      t.repr
-    ), [n, t];
-  const { first: r, second: s } = i;
-  return [
-    r,
-    nt(r.lastPoint, s.firstPoint, r.tangentAtLastPoint),
-    s
-  ];
-}
-function N(n, t, e) {
-  const i = rt(n, t, e);
-  if (!i)
-    return console.warn(
-      "Cannot chamfer between segments",
-      n.repr,
-      t.repr
-    ), [n, t];
-  const { first: r, second: s } = i;
-  return [r, new A(r.lastPoint, s.firstPoint), s];
-}
-function X(n) {
-  return new P([new b(new I(n))]);
-}
-class Et {
-  constructor(t = [0, 0]) {
-    this.pointer = t, this.firstPoint = t, this.pendingSegments = [], this._nextCorner = null;
-  }
-  movePointerTo(t) {
-    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;
-  }
-  saveSegment(t) {
-    if (_(t.firstPoint, t.lastPoint))
-      throw new Error(`Segment has no length, ${t.repr}`);
-    if (!this._nextCorner)
-      return this.pendingSegments.push(t), this;
-    const e = this.pendingSegments.pop();
-    if (!e)
-      throw new Error("bug in the custom corner algorithm");
-    const i = this._nextCorner.mode === "chamfer" ? N : V;
-    return this.pendingSegments.push(
-      ...i(e, t, this._nextCorner.radius)
-    ), this._nextCorner = null, this;
-  }
-  lineTo(t) {
-    const e = new A(this.pointer, t);
-    return this.pointer = t, this.saveSegment(e);
-  }
-  line(t, e) {
-    return this.lineTo([this.pointer[0] + t, this.pointer[1] + e]);
-  }
-  vLine(t) {
-    return this.line(0, t);
-  }
-  hLine(t) {
-    return this.line(t, 0);
-  }
-  vLineTo(t) {
-    return this.lineTo([this.pointer[0], t]);
-  }
-  hLineTo(t) {
-    return this.lineTo([t, this.pointer[1]]);
-  }
-  polarLineTo([t, e]) {
-    const i = e * R, r = Y(t, i);
-    return this.lineTo(r);
-  }
-  polarLine(t, e) {
-    const i = e * R, [r, s] = Y(t, i);
-    return this.line(r, s);
-  }
-  tangentLine(t) {
-    const e = this.pendingSegments.at(-1);
-    if (!e)
-      throw new Error("You need a previous segment to sketch a tangent line");
-    const [i, r] = e.tangentAtLastPoint;
-    return this.line(i * t, r * t);
-  }
-  threePointsArcTo(t, e) {
-    return this.saveSegment(dt(this.pointer, e, t)), this.pointer = t, this;
-  }
-  threePointsArc(t, e, i, r) {
-    const [s, o] = this.pointer;
-    return this.threePointsArcTo(
-      [s + t, o + e],
-      [s + i, o + r]
-    );
-  }
-  sagittaArcTo(t, e) {
-    if (!e)
-      return this.lineTo(t);
-    const i = new A(this.pointer, t), r = $(i.tangentAtFirstPoint), s = F(i.midPoint, v(r, e));
-    return this.threePointsArcTo(t, s);
-  }
-  sagittaArc(t, e, i) {
-    return this.sagittaArcTo(
-      [t + this.pointer[0], e + this.pointer[1]],
-      i
-    );
-  }
-  vSagittaArc(t, e) {
-    return this.sagittaArc(0, t, e);
-  }
-  hSagittaArc(t, e) {
-    return this.sagittaArc(t, 0, e);
-  }
-  bulgeArcTo(t, e) {
-    if (!e)
-      return this.lineTo(t);
-    const i = S(this.pointer, t) / 2, r = -e * i;
-    return this.sagittaArcTo(t, r);
-  }
-  bulgeArc(t, e, i) {
-    return this.bulgeArcTo(
-      [t + this.pointer[0], e + this.pointer[1]],
-      i
-    );
-  }
-  vBulgeArc(t, e) {
-    return this.bulgeArc(0, t, e);
-  }
-  hBulgeArc(t, e) {
-    return this.bulgeArc(t, 0, e);
-  }
-  tangentArcTo(t) {
-    const e = this.pendingSegments.at(-1);
-    if (!e)
-      throw new Error("You need a previous curve to sketch a tangent arc");
-    return this.saveSegment(
-      nt(this.pointer, t, e.tangentAtLastPoint)
-    ), this.pointer = t, this;
-  }
-  tangentArc(t, e) {
-    const [i, r] = this.pointer;
-    return this.tangentArcTo([t + i, e + r]);
-  }
-  customCorner(t, e = "fillet") {
-    if (!this.pendingSegments.length)
-      throw new Error("You need a segment defined to fillet the angle");
-    return this._nextCorner = { mode: e, radius: t }, this;
-  }
-  _customCornerLastWithFirst(t, e = "fillet") {
-    if (!t)
-      return;
-    const i = this.pendingSegments.pop(), r = this.pendingSegments.shift();
-    if (!i || !r)
-      throw new Error("Not enough curves to close and fillet");
-    const s = e === "chamfer" ? N : V;
-    this.pendingSegments.push(...s(i, r, t));
-  }
-  close() {
-    if (!this.pendingSegments.length)
-      throw new Error("No segments to close");
-    const t = this.pendingSegments[0], e = this.pendingSegments.at(-1);
-    return _(t.firstPoint, e.lastPoint) || this.lineTo(t.firstPoint), this._nextCorner !== null && (this._customCornerLastWithFirst(
-      this._nextCorner.radius,
-      this._nextCorner.mode
-    ), this._nextCorner = null), X(this.pendingSegments);
-  }
-  closeWithMirror() {
-    if (!this.pendingSegments.length)
-      throw new Error("No segments to close");
-    const t = this.pendingSegments[0], e = this.pendingSegments.at(-1), i = L(
-      e.lastPoint,
-      t.firstPoint
-    ), r = new gt().mirrorLine(
-      i,
-      t.firstPoint
-    ), s = this.pendingSegments.map(
-      (o) => o.transform(r).reverse()
+  return n.holes.forEach((o) => {
+    r = r.flatMap(
+      (s) => O(s, o, e)
     );
-    return s.reverse(), X([
-      ...this.pendingSegments,
-      ...s
-    ]);
-  }
-}
-function qt(n = [0, 0]) {
-  return new Et(n);
-}
-function E(n) {
-  if (n instanceof b)
-    return [n];
-  if (n instanceof I)
-    return [new b(n)];
-  if (n instanceof P)
-    return n.figures;
-  throw new Error("Unknown shape");
+  }), r;
 }
-function Mt(n, t) {
+function St(t, n) {
   return new P(
-    mt(E(n), E(t))
+    ot(F(t), F(n))
   );
 }
-function G(n) {
-  return n.reduce(
-    (t, e) => Mt(t, e),
+function R(t) {
+  return t.reduce(
+    (n, e) => St(n, e),
     new P()
   );
 }
-function Tt(n, t) {
+function Mt(t, n) {
   return new P(
-    wt(E(n), E(t))
+    it(F(t), F(n))
   );
 }
-function zt(n, t) {
+function xt(t, n) {
   return new P(
-    Pt(E(n), E(t))
+    ft(F(t), F(n))
   );
 }
-function q(n) {
-  return n < 0 ? "before" : n > 1 ? "after" : "between";
-}
-const z = (n, t, e) => {
+function Gt(t, n, e = !0) {
+  if (n instanceof $)
+    return O(t, n, e);
+  if (n instanceof h)
+    return V(t, n, e);
+  let r = [t];
+  return n.figures.forEach((o) => {
+    r = r.flatMap((s) => V(s, o, e));
+  }), r;
+}
+function Vt(t, n, e = !1) {
+  if (n instanceof $)
+    return x(t, n, e);
+  if (n instanceof h)
+    return T(t, n, e);
+  let r = [t];
+  return n.figures.forEach((o) => {
+    r = r.flatMap((s) => T(s, o, e));
+  }), r;
+}
+function U(t) {
+  return t < 0 ? "before" : t > 1 ? "after" : "between";
+}
+const N = (t, n, e) => {
   if (e === "before")
-    return n.distanceFrom(t.firstPoint);
+    return t.distanceFrom(n.firstPoint);
   if (e === "after")
-    return n.distanceFrom(t.lastPoint);
+    return t.distanceFrom(n.lastPoint);
   throw new Error("Invalid position");
 };
-function It(n, t) {
-  const e = At(n, t);
+function At(t, n) {
+  const e = at(t, n);
   if (e === "parallel")
     return Math.min(
-      n.distanceFrom(t.firstPoint),
-      n.distanceFrom(t.lastPoint)
+      t.distanceFrom(n.firstPoint),
+      t.distanceFrom(n.lastPoint)
     );
-  const { intersectionParam1: i, intersectionParam2: r } = e, s = q(i), o = q(r);
-  if (s === "between" && o === "between")
+  const { intersectionParam1: r, intersectionParam2: o } = e, s = U(r), a = U(o);
+  if (s === "between" && a === "between")
     return 0;
-  if (s === "between" && o !== "between")
-    return z(n, t, o);
-  if (o === "between" && s !== "between")
-    return z(t, n, s);
-  if (s === "before" && o === "before")
-    return S(n.firstPoint, t.firstPoint);
-  if (s === "after" && o === "after")
-    return S(n.lastPoint, t.lastPoint);
-  if (s === "before" && o === "after")
-    return S(n.firstPoint, t.lastPoint);
-  if (s === "after" && o === "before")
-    return S(n.lastPoint, t.firstPoint);
+  if (s === "between" && a !== "between")
+    return N(t, n, a);
+  if (a === "between" && s !== "between")
+    return N(n, t, s);
+  if (s === "before" && a === "before")
+    return g(t.firstPoint, n.firstPoint);
+  if (s === "after" && a === "after")
+    return g(t.lastPoint, n.lastPoint);
+  if (s === "before" && a === "after")
+    return g(t.firstPoint, n.lastPoint);
+  if (s === "after" && a === "before")
+    return g(t.lastPoint, n.firstPoint);
   throw new Error("Invalid position");
 }
-function W(n, t) {
-  if (xt(n, t).length > 0)
+function z(t, n) {
+  if (ct(t, n).length > 0)
     return 0;
-  const e = yt(n, t.center);
-  if (n.isOnSegment(e)) {
-    const i = S(e, t.center);
-    if (Math.abs(i - t.radius) < n.precision && t.isOnSegment(e))
+  const e = ut(t, n.center);
+  if (t.isOnSegment(e)) {
+    const r = g(e, n.center);
+    if (Math.abs(r - n.radius) < t.precision && n.isOnSegment(e))
       return 0;
-    if (i - t.radius > n.precision) {
-      const r = it(
-        L(e, t.center)
-      ), s = F(
-        t.center,
-        v(r, t.radius)
+    if (r - n.radius > t.precision) {
+      const o = Z(
+        E(e, n.center)
+      ), s = lt(
+        n.center,
+        pt(o, n.radius)
       );
-      if (t.isOnSegment(s))
-        return S(s, e);
+      if (n.isOnSegment(s))
+        return g(s, e);
     }
   }
   return Math.min(
-    t.distanceFrom(n.firstPoint),
-    t.distanceFrom(n.lastPoint),
     n.distanceFrom(t.firstPoint),
-    n.distanceFrom(t.lastPoint)
+    n.distanceFrom(t.lastPoint),
+    t.distanceFrom(n.firstPoint),
+    t.distanceFrom(n.lastPoint)
   );
 }
-const Lt = (n, t) => {
-  const e = n.angleToParam(t.firstAngle);
-  if (n.isValidParameter(e))
+const Lt = (t, n) => {
+  const e = t.angleToParam(n.firstAngle);
+  if (t.isValidParameter(e))
     return !0;
-  const i = n.angleToParam(t.lastAngle);
-  return !!n.isValidParameter(i);
+  const r = t.angleToParam(n.lastAngle);
+  return !!t.isValidParameter(r);
 };
-function Ct(n, t) {
-  if (_t(n, t, !0).length > 0)
+function $t(t, n) {
+  if (Pt(t, n, !0).length > 0)
     return 0;
-  const e = S(n.center, t.center);
-  if (e < n.precision && Lt(n, t))
-    return Math.abs(n.radius - t.radius);
-  const i = it(L(t.center, n.center)), r = e - Math.abs(n.radius - t.radius) < n.precision;
-  let s = St(i);
-  r && t.radius > n.radius && (s += Math.PI);
-  const o = r ? s : s + Math.PI, a = n.angleToParam(s), h = t.angleToParam(o);
-  return n.isValidParameter(a) && t.isValidParameter(h) ? S(n.paramPoint(a), t.paramPoint(h)) : Math.min(
-    n.distanceFrom(t.firstPoint),
-    n.distanceFrom(t.lastPoint),
+  const e = g(t.center, n.center);
+  if (e < t.precision && Lt(t, n))
+    return Math.abs(t.radius - n.radius);
+  const r = Z(E(n.center, t.center)), o = e - Math.abs(t.radius - n.radius) < t.precision;
+  let s = mt(r);
+  o && n.radius > t.radius && (s += Math.PI);
+  const a = o ? s : s + Math.PI, u = t.angleToParam(s), i = n.angleToParam(a);
+  return t.isValidParameter(u) && n.isValidParameter(i) ? g(t.paramPoint(u), n.paramPoint(i)) : Math.min(
     t.distanceFrom(n.firstPoint),
-    t.distanceFrom(n.lastPoint)
+    t.distanceFrom(n.lastPoint),
+    n.distanceFrom(t.firstPoint),
+    n.distanceFrom(t.lastPoint)
   );
 }
-function $t(n, t) {
-  if (n instanceof A && t instanceof A)
-    return It(n, t);
-  if (n instanceof A && t instanceof y)
-    return W(n, t);
-  if (n instanceof y && t instanceof A)
-    return W(t, n);
-  if (n instanceof y && t instanceof y)
-    return Ct(n, t);
+function Ft(t, n) {
+  if (t instanceof d && n instanceof d)
+    return At(t, n);
+  if (t instanceof d && n instanceof w)
+    return z(t, n);
+  if (t instanceof w && n instanceof d)
+    return z(n, t);
+  if (t instanceof w && n instanceof w)
+    return $t(t, n);
   throw new Error("Not implemented");
 }
-class Dt {
-  constructor() {
-    this.ids = [], this.values = [], this.length = 0;
-  }
-  clear() {
-    this.length = 0;
-  }
-  push(t, e) {
-    let i = this.length++;
-    for (; i > 0; ) {
-      const r = i - 1 >> 1, s = this.values[r];
-      if (e >= s)
-        break;
-      this.ids[i] = this.ids[r], this.values[i] = s, i = r;
-    }
-    this.ids[i] = t, this.values[i] = e;
-  }
-  pop() {
-    if (this.length === 0)
-      return;
-    const t = this.ids[0];
-    if (this.length--, this.length > 0) {
-      const e = this.ids[0] = this.ids[this.length], i = this.values[0] = this.values[this.length], r = this.length >> 1;
-      let s = 0;
-      for (; s < r; ) {
-        let o = (s << 1) + 1;
-        const a = o + 1;
-        let h = this.ids[o], l = this.values[o];
-        const c = this.values[a];
-        if (a < this.length && c < l && (o = a, h = this.ids[a], l = c), l >= i)
-          break;
-        this.ids[s] = h, this.values[s] = l, s = o;
-      }
-      this.ids[s] = e, this.values[s] = i;
-    }
-    return t;
-  }
-  peek() {
-    if (this.length !== 0)
-      return this.ids[0];
-  }
-  peekValue() {
-    if (this.length !== 0)
-      return this.values[0];
-  }
-  shrink() {
-    this.ids.length = this.values.length = this.length;
-  }
-}
-const J = [
-  Int8Array,
-  Uint8Array,
-  Uint8ClampedArray,
-  Int16Array,
-  Uint16Array,
-  Int32Array,
-  Uint32Array,
-  Float32Array,
-  Float64Array
-], C = 3;
-class U {
-  static from(t) {
-    if (!t || t.byteLength === void 0 || t.buffer)
-      throw new Error("Data must be an instance of ArrayBuffer or SharedArrayBuffer.");
-    const [e, i] = new Uint8Array(t, 0, 2);
-    if (e !== 251)
-      throw new Error("Data does not appear to be in a Flatbush format.");
-    if (i >> 4 !== C)
-      throw new Error(`Got v${i >> 4} data when expected v${C}.`);
-    const [r] = new Uint16Array(t, 2, 1), [s] = new Uint32Array(t, 4, 1);
-    return new U(s, r, J[i & 15], void 0, t);
-  }
-  constructor(t, e = 16, i = Float64Array, r = ArrayBuffer, s) {
-    if (t === void 0)
-      throw new Error("Missing required argument: numItems.");
-    if (isNaN(t) || t <= 0)
-      throw new Error(`Unexpected numItems value: ${t}.`);
-    this.numItems = +t, this.nodeSize = Math.min(Math.max(+e, 2), 65535);
-    let o = t, a = o;
-    this._levelBounds = [o * 4];
-    do
-      o = Math.ceil(o / this.nodeSize), a += o, this._levelBounds.push(a * 4);
-    while (o !== 1);
-    this.ArrayType = i || Float64Array, this.IndexArrayType = a < 16384 ? Uint16Array : Uint32Array;
-    const h = J.indexOf(this.ArrayType), l = a * 4 * this.ArrayType.BYTES_PER_ELEMENT;
-    if (h < 0)
-      throw new Error(`Unexpected typed array class: ${i}.`);
-    s && s.byteLength !== void 0 && !s.buffer ? (this.data = s, this._boxes = new this.ArrayType(this.data, 8, a * 4), this._indices = new this.IndexArrayType(this.data, 8 + l, a), this._pos = a * 4, this.minX = this._boxes[this._pos - 4], this.minY = this._boxes[this._pos - 3], this.maxX = this._boxes[this._pos - 2], this.maxY = this._boxes[this._pos - 1]) : (this.data = new r(8 + l + a * this.IndexArrayType.BYTES_PER_ELEMENT), this._boxes = new this.ArrayType(this.data, 8, a * 4), this._indices = new this.IndexArrayType(this.data, 8 + l, a), this._pos = 0, this.minX = 1 / 0, this.minY = 1 / 0, this.maxX = -1 / 0, this.maxY = -1 / 0, new Uint8Array(this.data, 0, 2).set([251, (C << 4) + h]), new Uint16Array(this.data, 2, 1)[0] = e, new Uint32Array(this.data, 4, 1)[0] = t), this._queue = new Dt();
-  }
-  add(t, e, i, r) {
-    const s = this._pos >> 2, o = this._boxes;
-    return this._indices[s] = s, o[this._pos++] = t, o[this._pos++] = e, o[this._pos++] = i, o[this._pos++] = r, t < this.minX && (this.minX = t), e < this.minY && (this.minY = e), i > this.maxX && (this.maxX = i), r > this.maxY && (this.maxY = r), s;
-  }
-  finish() {
-    if (this._pos >> 2 !== this.numItems)
-      throw new Error(`Added ${this._pos >> 2} items when expected ${this.numItems}.`);
-    const t = this._boxes;
-    if (this.numItems <= this.nodeSize) {
-      t[this._pos++] = this.minX, t[this._pos++] = this.minY, t[this._pos++] = this.maxX, t[this._pos++] = this.maxY;
-      return;
-    }
-    const e = this.maxX - this.minX || 1, i = this.maxY - this.minY || 1, r = new Uint32Array(this.numItems), s = (1 << 16) - 1;
-    for (let o = 0, a = 0; o < this.numItems; o++) {
-      const h = t[a++], l = t[a++], c = t[a++], f = t[a++], u = Math.floor(s * ((h + c) / 2 - this.minX) / e), p = Math.floor(s * ((l + f) / 2 - this.minY) / i);
-      r[o] = Bt(u, p);
-    }
-    k(r, t, this._indices, 0, this.numItems - 1, this.nodeSize);
-    for (let o = 0, a = 0; o < this._levelBounds.length - 1; o++) {
-      const h = this._levelBounds[o];
-      for (; a < h; ) {
-        const l = a;
-        let c = t[a++], f = t[a++], u = t[a++], p = t[a++];
-        for (let g = 1; g < this.nodeSize && a < h; g++)
-          c = Math.min(c, t[a++]), f = Math.min(f, t[a++]), u = Math.max(u, t[a++]), p = Math.max(p, t[a++]);
-        this._indices[this._pos >> 2] = l, t[this._pos++] = c, t[this._pos++] = f, t[this._pos++] = u, t[this._pos++] = p;
-      }
-    }
-  }
-  search(t, e, i, r, s) {
-    if (this._pos !== this._boxes.length)
-      throw new Error("Data not yet indexed - call index.finish().");
-    let o = this._boxes.length - 4;
-    const a = [], h = [];
-    for (; o !== void 0; ) {
-      const l = Math.min(o + this.nodeSize * 4, Z(o, this._levelBounds));
-      for (let c = o; c < l; c += 4) {
-        if (i < this._boxes[c] || r < this._boxes[c + 1] || t > this._boxes[c + 2] || e > this._boxes[c + 3])
-          continue;
-        const f = this._indices[c >> 2] | 0;
-        o >= this.numItems * 4 ? a.push(f) : (s === void 0 || s(f)) && h.push(f);
-      }
-      o = a.pop();
-    }
-    return h;
-  }
-  neighbors(t, e, i = 1 / 0, r = 1 / 0, s) {
-    if (this._pos !== this._boxes.length)
-      throw new Error("Data not yet indexed - call index.finish().");
-    let o = this._boxes.length - 4;
-    const a = this._queue, h = [], l = r * r;
-    for (; o !== void 0; ) {
-      const c = Math.min(o + this.nodeSize * 4, Z(o, this._levelBounds));
-      for (let f = o; f < c; f += 4) {
-        const u = this._indices[f >> 2] | 0, p = Q(t, this._boxes[f], this._boxes[f + 2]), g = Q(e, this._boxes[f + 1], this._boxes[f + 3]), m = p * p + g * g;
-        o >= this.numItems * 4 ? a.push(u << 1, m) : (s === void 0 || s(u)) && a.push((u << 1) + 1, m);
-      }
-      for (; a.length && a.peek() & 1; )
-        if (a.peekValue() > l || (h.push(a.pop() >> 1), h.length === i))
-          return a.clear(), h;
-      o = a.pop() >> 1;
-    }
-    return a.clear(), h;
-  }
-}
-function Q(n, t, e) {
-  return n < t ? t - n : n <= e ? 0 : n - e;
-}
-function Z(n, t) {
-  let e = 0, i = t.length - 1;
-  for (; e < i; ) {
-    const r = e + i >> 1;
-    t[r] > n ? i = r : e = r + 1;
-  }
-  return t[e];
-}
-function k(n, t, e, i, r, s) {
-  if (Math.floor(i / s) >= Math.floor(r / s))
-    return;
-  const o = n[i + r >> 1];
-  let a = i - 1, h = r + 1;
-  for (; ; ) {
-    do
-      a++;
-    while (n[a] < o);
-    do
-      h--;
-    while (n[h] > o);
-    if (a >= h)
-      break;
-    kt(n, t, e, a, h);
-  }
-  k(n, t, e, i, h, s), k(n, t, e, h + 1, r, s);
-}
-function kt(n, t, e, i, r) {
-  const s = n[i];
-  n[i] = n[r], n[r] = s;
-  const o = 4 * i, a = 4 * r, h = t[o], l = t[o + 1], c = t[o + 2], f = t[o + 3];
-  t[o] = t[a], t[o + 1] = t[a + 1], t[o + 2] = t[a + 2], t[o + 3] = t[a + 3], t[a] = h, t[a + 1] = l, t[a + 2] = c, t[a + 3] = f;
-  const u = e[i];
-  e[i] = e[r], e[r] = u;
-}
-function Bt(n, t) {
-  let e = n ^ t, i = 65535 ^ e, r = 65535 ^ (n | t), s = n & (t ^ 65535), o = e | i >> 1, a = e >> 1 ^ e, h = r >> 1 ^ i & s >> 1 ^ r, l = e & r >> 1 ^ s >> 1 ^ s;
-  e = o, i = a, r = h, s = l, o = e & e >> 2 ^ i & i >> 2, a = e & i >> 2 ^ i & (e ^ i) >> 2, h ^= e & r >> 2 ^ i & s >> 2, l ^= i & r >> 2 ^ (e ^ i) & s >> 2, e = o, i = a, r = h, s = l, o = e & e >> 4 ^ i & i >> 4, a = e & i >> 4 ^ i & (e ^ i) >> 4, h ^= e & r >> 4 ^ i & s >> 4, l ^= i & r >> 4 ^ (e ^ i) & s >> 4, e = o, i = a, r = h, s = l, h ^= e & r >> 8 ^ i & s >> 8, l ^= i & r >> 8 ^ (e ^ i) & s >> 8, e = h ^ h >> 1, i = l ^ l >> 1;
-  let c = n ^ t, f = i | 65535 ^ (c | e);
-  return c = (c | c << 8) & 16711935, c = (c | c << 4) & 252645135, c = (c | c << 2) & 858993459, c = (c | c << 1) & 1431655765, f = (f | f << 8) & 16711935, f = (f | f << 4) & 252645135, f = (f | f << 2) & 858993459, f = (f | f << 1) & 1431655765, (f << 1 | c) >>> 0;
-}
-function Ot(n, t = 1e-7) {
-  const e = new U(n.length);
-  n.forEach((s) => {
-    const [o, a] = s.firstPoint;
-    e.add(o - t, a - t, o + t, a + t);
-  }), e.finish();
-  const i = [], r = /* @__PURE__ */ new Set();
-  return n.forEach((s, o) => {
-    if (r.has(o))
-      return;
-    const a = [s];
-    let h = o;
-    r.add(o);
-    let l = n.length;
-    for (; ; ) {
-      if (l-- < 0)
-        throw new Error("Infinite loop detected");
-      const c = a[a.length - 1].lastPoint, [f, u] = c, p = e.search(
-        f - t,
-        u - t,
-        f + t,
-        u + t
-      ), g = (w) => Math.abs((h - w) % n.length), m = p.filter((w) => !r.has(w)).map((w) => [
-        n[w],
-        w,
-        g(w)
-      ]).sort(([, , w], [, , M]) => g(w) - g(M));
-      if (m.length === 0) {
-        i.push(a);
-        break;
-      }
-      const [x, d] = m[0];
-      a.push(x), r.add(d), h = d;
-    }
-  }), i;
-}
-const B = 1e-8;
-function Ut(n, t) {
-  const e = n.map((h) => ({
-    offset: D(h, t),
-    original: h
-  })), i = [];
-  let r = null, s = e.at(-1);
+const I = 1e-8;
+function vt(t, n) {
+  const e = t.map((i) => ({
+    offset: nt(i, n),
+    original: i
+  })), r = [];
+  let o = null, s = e.at(-1);
   if (!s)
     return [];
-  if (i.length === 1)
-    return i;
-  const o = (h) => {
-    r ? h.offset instanceof T ? _(h.offset.firstPoint, h.offset.lastPoint) || i.push(
-      new A(h.offset.firstPoint, h.offset.lastPoint)
-    ) : i.push(h.offset) : r = h;
-  }, a = function* () {
-    for (const h of e.slice(0, -1))
-      yield h;
-    if (!r)
+  if (r.length === 1)
+    return r;
+  const a = (i) => {
+    o ? i.offset instanceof D ? L(i.offset.firstPoint, i.offset.lastPoint) || r.push(
+      new d(i.offset.firstPoint, i.offset.lastPoint)
+    ) : r.push(i.offset) : o = i;
+  }, u = function* () {
+    for (const i of e.slice(0, -1))
+      yield i;
+    if (!o)
       throw new Error("Bug in the offset algorithm");
-    yield r;
+    yield o;
   };
-  for (const h of a()) {
-    const l = s.offset.lastPoint, c = h.offset.firstPoint;
-    if (_(l, c)) {
-      o(s), s = h;
+  for (const i of u()) {
+    const m = s.offset.lastPoint, f = i.offset.firstPoint;
+    if (L(m, f)) {
+      a(s), s = i;
       continue;
     }
-    let f = [];
-    if (!(s.offset instanceof T) && !(h.offset instanceof T)) {
-      const { intersections: m, overlaps: x } = st(
+    let c = [];
+    if (!(s.offset instanceof D) && !(i.offset instanceof D)) {
+      const { intersections: M, overlaps: A } = C(
         s.offset,
-        h.offset,
-        B / 100
+        i.offset,
+        I / 100
       );
-      f = [
-        ...m,
-        ...x.flatMap((d) => [d.firstPoint, d.lastPoint])
+      c = [
+        ...M,
+        ...A.flatMap((p) => [p.firstPoint, p.lastPoint])
       ];
     }
-    if (f.length > 0) {
-      let m = f[0];
-      if (f.length > 1) {
-        const w = s == null ? void 0 : s.original.lastPoint, M = f.map(
-          (lt) => Ft(lt, w)
+    if (c.length > 0) {
+      let M = c[0];
+      if (c.length > 1) {
+        const b = s == null ? void 0 : s.original.lastPoint, v = c.map(
+          (tt) => dt(tt, b)
         );
-        m = f[M.indexOf(Math.min(...M))];
+        M = c[v.indexOf(Math.min(...v))];
       }
-      const x = s.offset.splitAt([
-        m
-      ])[0], d = h.offset.splitAt([m]).at(-1);
-      if (!d)
+      const A = s.offset.splitAt([
+        M
+      ])[0], p = i.offset.splitAt([M]).at(-1);
+      if (!p)
         throw new Error("Bug in the splitting algo in offset");
-      o({
-        offset: x,
+      a({
+        offset: A,
         original: s.original
-      }), s = { offset: d, original: h.original };
+      }), s = { offset: p, original: i.original };
       continue;
     }
-    const u = s.original.lastPoint, p = et(
-      L(c, u),
-      L(l, u)
-    ) > 0, g = new y(l, c, u, p);
-    o(s), i.push(g), s = h;
+    const l = s.original.lastPoint, S = wt(
+      E(f, l),
+      E(m, l)
+    ) > 0, y = new w(m, f, l, S);
+    a(s), r.push(y), s = i;
   }
-  return o(s), i;
+  return a(s), r;
 }
-function H(n, t) {
-  const e = n.clockwise ? t : -t, i = Ut(n.segments, e);
-  if (i.length < 2)
+function q(t, n) {
+  const e = t.clockwise ? n : -n, r = vt(t.segments, e);
+  if (r.length < 2)
     return new P();
-  const r = /* @__PURE__ */ new Map(), s = (c, f) => {
-    const u = r.get(c) || [];
-    r.set(c, [...u, ...f]);
+  const o = /* @__PURE__ */ new Map(), s = (f, c) => {
+    const l = o.get(f) || [];
+    o.set(f, [...l, ...c]);
   };
-  if (i.forEach((c, f) => {
-    i.slice(f + 1).forEach((u, p) => {
-      const { intersections: g, overlaps: m } = st(c, u, B), x = [
-        ...g,
-        ...m.flatMap((d) => [d.firstPoint, d.lastPoint])
-      ].filter((d) => {
-        const w = _(d, c.firstPoint) || _(d, c.lastPoint), M = _(d, u.firstPoint) || _(d, u.lastPoint);
-        return !(w && M);
+  if (r.forEach((f, c) => {
+    r.slice(c + 1).forEach((l, S) => {
+      const { intersections: y, overlaps: M } = C(f, l, I), A = [
+        ...y,
+        ...M.flatMap((p) => [p.firstPoint, p.lastPoint])
+      ].filter((p) => {
+        const b = L(p, f.firstPoint) || L(p, f.lastPoint), v = L(p, l.firstPoint) || L(p, l.lastPoint);
+        return !(b && v);
       });
-      x.length && (s(f, x), s(p + f + 1, x));
+      A.length && (s(c, A), s(S + c + 1, A));
     });
-  }), !r.size) {
-    const c = new I(i);
-    return new P([new b(c)]);
-  }
-  const a = i.flatMap((c, f) => {
-    if (!r.has(f))
-      return c;
-    const u = r.get(f) || [];
-    return c.splitAt(u);
-  }).filter((c) => !n.segments.some((u) => $t(u, c) < Math.abs(t) - B));
-  if (!a.length)
+  }), !o.size) {
+    const f = new $(r);
+    return new P([new h(f)]);
+  }
+  const u = r.flatMap((f, c) => {
+    if (!o.has(c))
+      return f;
+    const l = o.get(c) || [];
+    return f.splitAt(l);
+  }).filter((f) => !t.segments.some((l) => Ft(l, f) < Math.abs(n) - I));
+  if (!u.length)
     return new P();
-  const l = Ot(a).filter((c) => c.length > 1).filter((c) => _(c[0].firstPoint, c.at(-1).lastPoint)).map((c) => new I(c));
-  return l.length ? new P(l.map((c) => new b(c))) : new P();
+  const m = gt(u).filter((f) => f.length > 1).filter((f) => L(f[0].firstPoint, f.at(-1).lastPoint)).map((f) => new $(f));
+  return m.length ? new P(m.map((f) => new h(f))) : new P();
 }
-function Yt(n, t) {
-  const e = n.map((i) => {
-    const r = G(
-      i.holes.map((s) => H(s, t))
+function Et(t, n) {
+  const e = t.map((r) => {
+    const o = R(
+      r.holes.map((s) => q(s, n))
     );
-    return Tt(H(i.contour, t), r);
+    return Mt(q(r.contour, n), o);
   });
-  return G(e);
+  return R(e);
 }
-function Wt(n, t) {
-  return Yt(E(n), t);
+function Tt(t, n) {
+  return Et(F(t), n);
 }
-function ot(n) {
-  if (n instanceof A)
-    return `L ${n.lastPoint.join(" ")}`;
-  if (n instanceof y)
-    return `A ${n.radius} ${n.radius} 0 ${n.angularLength > Math.PI ? "1" : "0"} ${n.clockwise ? "0" : "1"} ${n.lastPoint.join(" ")}`;
+function G(t) {
+  if (t instanceof d)
+    return `L ${t.lastPoint.join(" ")}`;
+  if (t instanceof w)
+    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 at(n) {
-  const t = `M ${n.firstPoint.join(" ")}`, e = n.segments.map(ot).join(" ");
-  return `${t} ${e} Z`;
+function K(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(G).join(" ");
+  return `${n} ${e} Z`;
 }
-function ht(n) {
-  return `<path d="${n.allLoops.map(at).join(" ")}" />`;
+function Q(t) {
+  return `<path d="${t.allLoops.map(K).join(" ")}" />`;
 }
-function Rt(n) {
+function yt(t) {
   return `<g>
-  ${n.figures.map(ht).join(`
+  ${t.figures.map(Q).join(`
 `)}
 </g>`;
 }
-function Vt(n, t = 1) {
-  const e = n.xMin - t, i = n.yMin - t;
-  return `${e} ${i} ${n.width + 2 * t} ${n.height + 2 * t}`;
+function bt(t) {
+  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(G).join(" ");
+  return `${n} ${e}`;
+}
+function Dt(t, n = 1) {
+  const e = t.xMin - n, r = t.yMin - n;
+  return `${e} ${r} ${t.width + 2 * n} ${t.height + 2 * n}`;
 }
-function K(n, t, e = 1) {
+function B(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="${Vt(t, e)}" 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="${Dt(n, e)}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke">
+    ${t}
 </svg>`;
 }
-function j(n) {
-  if (n instanceof P)
-    return Rt(n);
-  if (n instanceof b)
-    return ht(n);
-  if (n instanceof I)
-    return `<path d="${at(n)}" />`;
-  if (n instanceof y || n instanceof A)
-    return `<path d="${`M ${n.firstPoint.join(" ")}`} ${ot(
-      n
+function J(t) {
+  if (t instanceof P)
+    return yt(t);
+  if (t instanceof h)
+    return Q(t);
+  if (t instanceof $)
+    return `<path d="${K(t)}" />`;
+  if (t instanceof ht)
+    return `<path d="${bt(t)}" />`;
+  if (t instanceof w || t instanceof d)
+    return `<path d="${`M ${t.firstPoint.join(" ")}`} ${G(
+      t
     )}" />`;
   throw new Error("Unknown shape type");
 }
-function Jt(n, t = 1) {
-  if (Array.isArray(n)) {
-    const i = n.map((o) => o.mirror()), r = i.map((o) => j(o)).join(`
-`), s = i.slice(1).reduce((o, a) => o.merge(a.boundingBox), i[0].boundingBox);
-    return K(r, s);
-  }
-  const e = n.mirror();
-  return K(j(e), e.boundingBox, t);
-}
-const ct = (n) => {
-  if (n.type === "LINE")
-    return new A(n.firstPoint, n.lastPoint);
-  if (n.type === "ARC")
-    return new y(
-      n.firstPoint,
-      n.lastPoint,
-      n.center,
-      n.clockwise
+const W = (t) => "shape" in t ? t.shape : t, X = (t, n) => {
+  if (!("shape" in t))
+    return n;
+  const { color: e } = t;
+  return e ? `<g stroke="${e}">${n}</g>` : n;
+};
+function Rt(t, n = 1) {
+  if (Array.isArray(t)) {
+    const r = t.map((a) => W(a).mirror()), o = r.map((a, u) => X(t[u], J(a))).join(`
+`), s = r.slice(1).reduce((a, u) => a.merge(u.boundingBox), r[0].boundingBox);
+    return B(o, s);
+  }
+  const e = W(t).mirror();
+  return B(
+    X(t, J(e)),
+    e.boundingBox,
+    n
+  );
+}
+const _ = (t) => {
+  if (t.type === "LINE")
+    return new d(t.firstPoint, t.lastPoint);
+  if (t.type === "ARC")
+    return new w(
+      t.firstPoint,
+      t.lastPoint,
+      t.center,
+      t.clockwise
     );
   throw new Error("Unknown segment type");
-}, O = (n) => {
-  const t = n.segments.map(ct);
-  return new I(t);
-}, ft = (n) => {
-  const t = O(n.contour), e = n.holes.map(O);
-  return new b(t, e);
-}, Nt = (n) => {
-  const t = n.figures.map(ft);
-  return new P(t);
+}, k = (t) => {
+  const n = t.segments.map(_);
+  return new $(n);
+}, j = (t) => {
+  const n = k(t.contour), e = t.holes.map(k);
+  return new h(n, e);
+}, It = (t) => {
+  const n = t.figures.map(j);
+  return new P(n);
 };
-function Qt(n) {
-  if (n.type === "DIAGRAM")
-    return Nt(n);
-  if (n.type === "FIGURE")
-    return ft(n);
-  if (n.type === "LOOP")
-    return O(n);
-  if (n.type === "LINE" || n.type === "ARC")
-    return ct(n);
+function Ut(t) {
+  if (t.type === "DIAGRAM")
+    return It(t);
+  if (t.type === "FIGURE")
+    return j(t);
+  if (t.type === "LOOP")
+    return k(t);
+  if (t.type === "LINE" || t.type === "ARC")
+    return _(t);
   throw new Error("Unknown shape type");
 }
-const tt = Math.PI / 180, Xt = 180 / Math.PI;
-function Zt(n, t) {
-  const e = Math.cos(t * tt) * n, i = Math.sin(t * tt) * n;
-  return [e, i];
+const Y = Math.PI / 180, kt = 180 / Math.PI;
+function Nt(t, n) {
+  const e = Math.cos(n * Y) * t, r = Math.sin(n * Y) * t;
+  return [e, r];
 }
-function Ht([n, t]) {
-  const e = Math.sqrt(n * n + t * t), i = Math.atan2(t, n) * Xt;
-  return [e, i];
+function zt([t, n]) {
+  const e = Math.sqrt(t * t + n * n), r = Math.atan2(n, t) * kt;
+  return [e, r];
 }
 export {
-  tt as DEG2RAD,
-  Xt as RAD2DEG,
-  Ht as cartesianToPolar,
-  Tt as cut,
-  qt as draw,
-  tn as exportJSON,
-  Jt as exportSVG,
-  Mt as fuse,
-  G as fuseAll,
-  Qt as importJSON,
-  zt as intersect,
-  Wt as offset,
-  Zt as polarToCartesian,
-  j as svgBody
+  Y as DEG2RAD,
+  kt as RAD2DEG,
+  zt as cartesianToPolar,
+  Vt as confineStrand,
+  Mt as cut,
+  Jt as draw,
+  Gt as eraseStrand,
+  Xt as exportJSON,
+  Rt as exportSVG,
+  St as fuse,
+  R as fuseAll,
+  Ut as importJSON,
+  xt as intersect,
+  Tt as offset,
+  Nt as polarToCartesian,
+  J as svgBody
 };
 //# sourceMappingURL=pantograph.js.map