@omg-dev/app 0.1.308

package/dist-lib/vennDiagram-L72KCM5P-C4lh5m77.js

@@ -0,0 +1,1585 @@
+import { b4 as Wt, s as Kt, g as Ht, p as Yt, o as Xt, a as Zt, b as Jt, _ as S, z as St, F as Qt, d as rt, al as $t, aa as te, ab as ee, ac as ne, e as se, q as ie, B as re, D as oe } from "./index-JkCQXUYs.js";
+const kt = (t, n) => Wt(t, "a", -n), _t = 1e-10;
+function st(t, n) {
+  const s = le(t), e = s.filter((l) => ae(l, t));
+  let i = 0, r = 0;
+  const o = [];
+  if (e.length > 1) {
+    const l = Et(e);
+    for (let u = 0; u < e.length; ++u) {
+      const a = e[u];
+      a.angle = Math.atan2(a.x - l.x, a.y - l.y);
+    }
+    e.sort((u, a) => a.angle - u.angle);
+    let h = e[e.length - 1];
+    for (let u = 0; u < e.length; ++u) {
+      const a = e[u];
+      r += (h.x + a.x) * (a.y - h.y);
+      const p = { x: (a.x + h.x) / 2, y: (a.y + h.y) / 2 };
+      let d = null;
+      for (let m = 0; m < a.parentIndex.length; ++m)
+        if (h.parentIndex.includes(a.parentIndex[m])) {
+          const y = t[a.parentIndex[m]], M = Math.atan2(a.x - y.x, a.y - y.y), E = Math.atan2(h.x - y.x, h.y - y.y);
+          let T = E - M;
+          T < 0 && (T += 2 * Math.PI);
+          const w = E - T / 2;
+          let g = K(p, {
+            x: y.x + y.radius * Math.sin(w),
+            y: y.y + y.radius * Math.cos(w)
+          });
+          g > y.radius * 2 && (g = y.radius * 2), (d == null || d.width > g) && (d = { circle: y, width: g, p1: a, p2: h, large: g > y.radius, sweep: !0 });
+        }
+      d != null && (o.push(d), i += lt(d.circle.radius, d.width), h = a);
+    }
+  } else {
+    let l = t[0];
+    for (let u = 1; u < t.length; ++u)
+      t[u].radius < l.radius && (l = t[u]);
+    let h = !1;
+    for (let u = 0; u < t.length; ++u)
+      if (K(t[u], l) > Math.abs(l.radius - t[u].radius)) {
+        h = !0;
+        break;
+      }
+    h ? i = r = 0 : (i = l.radius * l.radius * Math.PI, o.push({
+      circle: l,
+      p1: { x: l.x, y: l.y + l.radius },
+      p2: { x: l.x - _t, y: l.y + l.radius },
+      width: l.radius * 2,
+      large: !0,
+      sweep: !0
+    }));
+  }
+  return r /= 2, n && (n.area = i + r, n.arcArea = i, n.polygonArea = r, n.arcs = o, n.innerPoints = e, n.intersectionPoints = s), i + r;
+}
+function ae(t, n) {
+  return n.every((s) => K(t, s) < s.radius + _t);
+}
+function le(t) {
+  const n = [];
+  for (let s = 0; s < t.length; ++s)
+    for (let e = s + 1; e < t.length; ++e) {
+      const i = Tt(t[s], t[e]);
+      for (const r of i)
+        r.parentIndex = [s, e], n.push(r);
+    }
+  return n;
+}
+function lt(t, n) {
+  return t * t * Math.acos(1 - n / t) - (t - n) * Math.sqrt(n * (2 * t - n));
+}
+function K(t, n) {
+  return Math.sqrt((t.x - n.x) * (t.x - n.x) + (t.y - n.y) * (t.y - n.y));
+}
+function xt(t, n, s) {
+  if (s >= t + n)
+    return 0;
+  if (s <= Math.abs(t - n))
+    return Math.PI * Math.min(t, n) * Math.min(t, n);
+  const e = t - (s * s - n * n + t * t) / (2 * s), i = n - (s * s - t * t + n * n) / (2 * s);
+  return lt(t, e) + lt(n, i);
+}
+function Tt(t, n) {
+  const s = K(t, n), e = t.radius, i = n.radius;
+  if (s >= e + i || s <= Math.abs(e - i))
+    return [];
+  const r = (e * e - i * i + s * s) / (2 * s), o = Math.sqrt(e * e - r * r), l = t.x + r * (n.x - t.x) / s, h = t.y + r * (n.y - t.y) / s, u = -(n.y - t.y) * (o / s), a = -(n.x - t.x) * (o / s);
+  return [
+    { x: l + u, y: h - a },
+    { x: l - u, y: h + a }
+  ];
+}
+function Et(t) {
+  const n = { x: 0, y: 0 };
+  for (const s of t)
+    n.x += s.x, n.y += s.y;
+  return n.x /= t.length, n.y /= t.length, n;
+}
+function ce(t, n, s, e) {
+  e = e || {};
+  const i = e.maxIterations || 100, r = e.tolerance || 1e-10, o = t(n), l = t(s);
+  let h = s - n;
+  if (o * l > 0)
+    throw "Initial bisect points must have opposite signs";
+  if (o === 0) return n;
+  if (l === 0) return s;
+  for (let u = 0; u < i; ++u) {
+    h /= 2;
+    const a = n + h, p = t(a);
+    if (p * o >= 0 && (n = a), Math.abs(h) < r || p === 0)
+      return a;
+  }
+  return n + h;
+}
+function ct(t) {
+  const n = new Array(t);
+  for (let s = 0; s < t; ++s)
+    n[s] = 0;
+  return n;
+}
+function Mt(t, n) {
+  return ct(t).map(() => ct(n));
+}
+function tt(t, n) {
+  let s = 0;
+  for (let e = 0; e < t.length; ++e)
+    s += t[e] * n[e];
+  return s;
+}
+function ut(t) {
+  return Math.sqrt(tt(t, t));
+}
+function ht(t, n, s) {
+  for (let e = 0; e < n.length; ++e)
+    t[e] = n[e] * s;
+}
+function Q(t, n, s, e, i) {
+  for (let r = 0; r < t.length; ++r)
+    t[r] = n * s[r] + e * i[r];
+}
+function zt(t, n, s) {
+  s = s || {};
+  const e = s.maxIterations || n.length * 200, i = s.nonZeroDelta || 1.05, r = s.zeroDelta || 1e-3, o = s.minErrorDelta || 1e-6, l = s.minErrorDelta || 1e-5, h = s.rho !== void 0 ? s.rho : 1, u = s.chi !== void 0 ? s.chi : 2, a = s.psi !== void 0 ? s.psi : -0.5, p = s.sigma !== void 0 ? s.sigma : 0.5;
+  let d;
+  const m = n.length, y = new Array(m + 1);
+  y[0] = n, y[0].fx = t(n), y[0].id = 0;
+  for (let v = 0; v < m; ++v) {
+    const c = n.slice();
+    c[v] = c[v] ? c[v] * i : r, y[v + 1] = c, y[v + 1].fx = t(c), y[v + 1].id = v + 1;
+  }
+  function M(v) {
+    for (let c = 0; c < v.length; c++)
+      y[m][c] = v[c];
+    y[m].fx = v.fx;
+  }
+  const E = (v, c) => v.fx - c.fx, T = n.slice(), w = n.slice(), g = n.slice(), b = n.slice();
+  for (let v = 0; v < e; ++v) {
+    if (y.sort(E), s.history) {
+      const x = y.map((f) => {
+        const O = f.slice();
+        return O.fx = f.fx, O.id = f.id, O;
+      });
+      x.sort((f, O) => f.id - O.id), s.history.push({
+        x: y[0].slice(),
+        fx: y[0].fx,
+        simplex: x
+      });
+    }
+    d = 0;
+    for (let x = 0; x < m; ++x)
+      d = Math.max(d, Math.abs(y[0][x] - y[1][x]));
+    if (Math.abs(y[0].fx - y[m].fx) < o && d < l)
+      break;
+    for (let x = 0; x < m; ++x) {
+      T[x] = 0;
+      for (let f = 0; f < m; ++f)
+        T[x] += y[f][x];
+      T[x] /= m;
+    }
+    const c = y[m];
+    if (Q(w, 1 + h, T, -h, c), w.fx = t(w), w.fx < y[0].fx)
+      Q(b, 1 + u, T, -u, c), b.fx = t(b), b.fx < w.fx ? M(b) : M(w);
+    else if (w.fx >= y[m - 1].fx) {
+      let x = !1;
+      if (w.fx > c.fx ? (Q(g, 1 + a, T, -a, c), g.fx = t(g), g.fx < c.fx ? M(g) : x = !0) : (Q(g, 1 - a * h, T, a * h, c), g.fx = t(g), g.fx < w.fx ? M(g) : x = !0), x) {
+        if (p >= 1) break;
+        for (let f = 1; f < y.length; ++f)
+          Q(y[f], 1 - p, y[0], p, y[f]), y[f].fx = t(y[f]);
+      }
+    } else
+      M(w);
+  }
+  return y.sort(E), { fx: y[0].fx, x: y[0] };
+}
+function ue(t, n, s, e, i, r, o) {
+  const l = s.fx, h = tt(s.fxprime, n);
+  let u = l, a = l, p = h, d = 0;
+  i = i || 1, r = r || 1e-6, o = o || 0.1;
+  function m(y, M, E) {
+    for (let T = 0; T < 16; ++T)
+      if (i = (y + M) / 2, Q(e.x, 1, s.x, i, n), u = e.fx = t(e.x, e.fxprime), p = tt(e.fxprime, n), u > l + r * i * h || u >= E)
+        M = i;
+      else {
+        if (Math.abs(p) <= -o * h)
+          return i;
+        p * (M - y) >= 0 && (M = y), y = i, E = u;
+      }
+    return 0;
+  }
+  for (let y = 0; y < 10; ++y) {
+    if (Q(e.x, 1, s.x, i, n), u = e.fx = t(e.x, e.fxprime), p = tt(e.fxprime, n), u > l + r * i * h || y && u >= a)
+      return m(d, i, a);
+    if (Math.abs(p) <= -o * h)
+      return i;
+    if (p >= 0)
+      return m(i, d, u);
+    a = u, d = i, i *= 2;
+  }
+  return i;
+}
+function he(t, n, s) {
+  let e = { x: n.slice(), fx: 0, fxprime: n.slice() }, i = { x: n.slice(), fx: 0, fxprime: n.slice() };
+  const r = n.slice();
+  let o, l, h = 1, u;
+  s = s || {}, u = s.maxIterations || n.length * 20, e.fx = t(e.x, e.fxprime), o = e.fxprime.slice(), ht(o, e.fxprime, -1);
+  for (let a = 0; a < u; ++a) {
+    if (h = ue(t, o, e, i, h), s.history && s.history.push({
+      x: e.x.slice(),
+      fx: e.fx,
+      fxprime: e.fxprime.slice(),
+      alpha: h
+    }), !h)
+      ht(o, e.fxprime, -1);
+    else {
+      Q(r, 1, i.fxprime, -1, e.fxprime);
+      const p = tt(e.fxprime, e.fxprime), d = Math.max(0, tt(r, i.fxprime) / p);
+      Q(o, d, o, -1, i.fxprime), l = e, e = i, i = l;
+    }
+    if (ut(e.fxprime) <= 1e-5)
+      break;
+  }
+  return s.history && s.history.push({
+    x: e.x.slice(),
+    fx: e.fx,
+    fxprime: e.fxprime.slice(),
+    alpha: h
+  }), e;
+}
+function At(t, n = {}) {
+  n.maxIterations = n.maxIterations || 500;
+  const s = n.initialLayout || xe, e = n.lossFunction || et, i = fe(t, n), r = s(i, n), o = Object.keys(r), l = [];
+  for (const a of o)
+    l.push(r[a].x), l.push(r[a].y);
+  const u = zt(
+    (a) => {
+      const p = {};
+      for (let d = 0; d < o.length; ++d) {
+        const m = o[d];
+        p[m] = {
+          x: a[2 * d],
+          y: a[2 * d + 1],
+          radius: r[m].radius
+          // size : circles[setid].size
+        };
+      }
+      return e(p, i);
+    },
+    l,
+    n
+  ).x;
+  for (let a = 0; a < o.length; ++a) {
+    const p = o[a];
+    r[p].x = u[2 * a], r[p].y = u[2 * a + 1];
+  }
+  return r;
+}
+const Rt = 1e-10;
+function ft(t, n, s) {
+  return Math.min(t, n) * Math.min(t, n) * Math.PI <= s + Rt ? Math.abs(t - n) : ce((e) => xt(t, n, e) - s, 0, t + n);
+}
+function fe(t, n = {}) {
+  const s = n.distinct, e = t.map((l) => Object.assign({}, l));
+  function i(l) {
+    return l.join(";");
+  }
+  if (s) {
+    const l = /* @__PURE__ */ new Map();
+    for (const h of e)
+      for (let u = 0; u < h.sets.length; u++) {
+        const a = String(h.sets[u]);
+        l.set(a, h.size + (l.get(a) || 0));
+        for (let p = u + 1; p < h.sets.length; p++) {
+          const d = String(h.sets[p]), m = `${a};${d}`, y = `${d};${a}`;
+          l.set(m, h.size + (l.get(m) || 0)), l.set(y, h.size + (l.get(y) || 0));
+        }
+      }
+    for (const h of e)
+      h.sets.length < 3 && (h.size = l.get(i(h.sets)));
+  }
+  const r = [], o = /* @__PURE__ */ new Set();
+  for (const l of e)
+    if (l.sets.length === 1)
+      r.push(l.sets[0]);
+    else if (l.sets.length === 2) {
+      const h = l.sets[0], u = l.sets[1];
+      o.add(i(l.sets)), o.add(i([u, h]));
+    }
+  r.sort((l, h) => l === h ? 0 : l < h ? -1 : 1);
+  for (let l = 0; l < r.length; ++l) {
+    const h = r[l];
+    for (let u = l + 1; u < r.length; ++u) {
+      const a = r[u];
+      o.has(i([h, a])) || e.push({ sets: [h, a], size: 0 });
+    }
+  }
+  return e;
+}
+function de(t, n, s) {
+  const e = Mt(n.length, n.length), i = Mt(n.length, n.length);
+  return t.filter((r) => r.sets.length === 2).forEach((r) => {
+    const o = s[r.sets[0]], l = s[r.sets[1]], h = Math.sqrt(n[o].size / Math.PI), u = Math.sqrt(n[l].size / Math.PI), a = ft(h, u, r.size);
+    e[o][l] = e[l][o] = a;
+    let p = 0;
+    r.size + 1e-10 >= Math.min(n[o].size, n[l].size) ? p = 1 : r.size <= 1e-10 && (p = -1), i[o][l] = i[l][o] = p;
+  }), { distances: e, constraints: i };
+}
+function ge(t, n, s, e) {
+  for (let r = 0; r < n.length; ++r)
+    n[r] = 0;
+  let i = 0;
+  for (let r = 0; r < s.length; ++r) {
+    const o = t[2 * r], l = t[2 * r + 1];
+    for (let h = r + 1; h < s.length; ++h) {
+      const u = t[2 * h], a = t[2 * h + 1], p = s[r][h], d = e[r][h], m = (u - o) * (u - o) + (a - l) * (a - l), y = Math.sqrt(m), M = m - p * p;
+      d > 0 && y <= p || d < 0 && y >= p || (i += 2 * M * M, n[2 * r] += 4 * M * (o - u), n[2 * r + 1] += 4 * M * (l - a), n[2 * h] += 4 * M * (u - o), n[2 * h + 1] += 4 * M * (a - l));
+    }
+  }
+  return i;
+}
+function xe(t, n = {}) {
+  let s = pe(t, n);
+  const e = n.lossFunction || et;
+  if (t.length >= 8) {
+    const i = ye(t, n), r = e(i, t), o = e(s, t);
+    r + 1e-8 < o && (s = i);
+  }
+  return s;
+}
+function ye(t, n = {}) {
+  const s = n.restarts || 10, e = [], i = {};
+  for (const d of t)
+    d.sets.length === 1 && (i[d.sets[0]] = e.length, e.push(d));
+  let { distances: r, constraints: o } = de(t, e, i);
+  const l = ut(r.map(ut)) / r.length;
+  r = r.map((d) => d.map((m) => m / l));
+  const h = (d, m) => ge(d, m, r, o);
+  let u = null;
+  for (let d = 0; d < s; ++d) {
+    const m = ct(r.length * 2).map(Math.random), y = he(h, m, n);
+    (!u || y.fx < u.fx) && (u = y);
+  }
+  const a = u.x, p = {};
+  for (let d = 0; d < e.length; ++d) {
+    const m = e[d];
+    p[m.sets[0]] = {
+      x: a[2 * d] * l,
+      y: a[2 * d + 1] * l,
+      radius: Math.sqrt(m.size / Math.PI)
+    };
+  }
+  if (n.history)
+    for (const d of n.history)
+      ht(d.x, l);
+  return p;
+}
+function pe(t, n) {
+  const s = n && n.lossFunction ? n.lossFunction : et, e = {}, i = {};
+  for (const p of t)
+    if (p.sets.length === 1) {
+      const d = p.sets[0];
+      e[d] = {
+        x: 1e10,
+        y: 1e10,
+        rowid: e.length,
+        size: p.size,
+        radius: Math.sqrt(p.size / Math.PI)
+      }, i[d] = [];
+    }
+  t = t.filter((p) => p.sets.length === 2);
+  for (const p of t) {
+    let d = p.weight != null ? p.weight : 1;
+    const m = p.sets[0], y = p.sets[1];
+    p.size + Rt >= Math.min(e[m].size, e[y].size) && (d = 0), i[m].push({ set: y, size: p.size, weight: d }), i[y].push({ set: m, size: p.size, weight: d });
+  }
+  const r = [];
+  Object.keys(i).forEach((p) => {
+    let d = 0;
+    for (let m = 0; m < i[p].length; ++m)
+      d += i[p][m].size * i[p][m].weight;
+    r.push({ set: p, size: d });
+  });
+  function o(p, d) {
+    return d.size - p.size;
+  }
+  r.sort(o);
+  const l = {};
+  function h(p) {
+    return p.set in l;
+  }
+  function u(p, d) {
+    e[d].x = p.x, e[d].y = p.y, l[d] = !0;
+  }
+  u({ x: 0, y: 0 }, r[0].set);
+  for (let p = 1; p < r.length; ++p) {
+    const d = r[p].set, m = i[d].filter(h), y = e[d];
+    if (m.sort(o), m.length === 0)
+      throw "ERROR: missing pairwise overlap information";
+    const M = [];
+    for (var a = 0; a < m.length; ++a) {
+      const w = e[m[a].set], g = ft(y.radius, w.radius, m[a].size);
+      M.push({ x: w.x + g, y: w.y }), M.push({ x: w.x - g, y: w.y }), M.push({ y: w.y + g, x: w.x }), M.push({ y: w.y - g, x: w.x });
+      for (let b = a + 1; b < m.length; ++b) {
+        const v = e[m[b].set], c = ft(y.radius, v.radius, m[b].size), x = Tt(
+          { x: w.x, y: w.y, radius: g },
+          { x: v.x, y: v.y, radius: c }
+        );
+        M.push(...x);
+      }
+    }
+    let E = 1e50, T = M[0];
+    for (const w of M) {
+      e[d].x = w.x, e[d].y = w.y;
+      const g = s(e, t);
+      g < E && (E = g, T = w);
+    }
+    u(T, d);
+  }
+  return e;
+}
+function et(t, n) {
+  let s = 0;
+  for (const e of n) {
+    if (e.sets.length === 1)
+      continue;
+    let i;
+    if (e.sets.length === 2) {
+      const o = t[e.sets[0]], l = t[e.sets[1]];
+      i = xt(o.radius, l.radius, K(o, l));
+    } else
+      i = st(e.sets.map((o) => t[o]));
+    const r = e.weight != null ? e.weight : 1;
+    s += r * (i - e.size) * (i - e.size);
+  }
+  return s;
+}
+function Dt(t, n) {
+  let s = 0;
+  for (const e of n) {
+    if (e.sets.length === 1)
+      continue;
+    let i;
+    if (e.sets.length === 2) {
+      const l = t[e.sets[0]], h = t[e.sets[1]];
+      i = xt(l.radius, h.radius, K(l, h));
+    } else
+      i = st(e.sets.map((l) => t[l]));
+    const r = e.weight != null ? e.weight : 1, o = Math.log((i + 1) / (e.size + 1));
+    s += r * o * o;
+  }
+  return s;
+}
+function me(t, n, s) {
+  if (s == null ? t.sort((i, r) => r.radius - i.radius) : t.sort(s), t.length > 0) {
+    const i = t[0].x, r = t[0].y;
+    for (const o of t)
+      o.x -= i, o.y -= r;
+  }
+  if (t.length === 2 && K(t[0], t[1]) < Math.abs(t[1].radius - t[0].radius) && (t[1].x = t[0].x + t[0].radius - t[1].radius - 1e-10, t[1].y = t[0].y), t.length > 1) {
+    const i = Math.atan2(t[1].x, t[1].y) - n, r = Math.cos(i), o = Math.sin(i);
+    for (const l of t) {
+      const h = l.x, u = l.y;
+      l.x = r * h - o * u, l.y = o * h + r * u;
+    }
+  }
+  if (t.length > 2) {
+    let i = Math.atan2(t[2].x, t[2].y) - n;
+    for (; i < 0; )
+      i += 2 * Math.PI;
+    for (; i > 2 * Math.PI; )
+      i -= 2 * Math.PI;
+    if (i > Math.PI) {
+      const r = t[1].y / (1e-10 + t[1].x);
+      for (const o of t) {
+        var e = (o.x + r * o.y) / (1 + r * r);
+        o.x = 2 * e - o.x, o.y = 2 * e * r - o.y;
+      }
+    }
+  }
+}
+function be(t) {
+  t.forEach((i) => {
+    i.parent = i;
+  });
+  function n(i) {
+    return i.parent !== i && (i.parent = n(i.parent)), i.parent;
+  }
+  function s(i, r) {
+    const o = n(i), l = n(r);
+    o.parent = l;
+  }
+  for (let i = 0; i < t.length; ++i)
+    for (let r = i + 1; r < t.length; ++r) {
+      const o = t[i].radius + t[r].radius;
+      K(t[i], t[r]) + 1e-10 < o && s(t[r], t[i]);
+    }
+  const e = /* @__PURE__ */ new Map();
+  for (let i = 0; i < t.length; ++i) {
+    const r = n(t[i]).parent.setid;
+    e.has(r) || e.set(r, []), e.get(r).push(t[i]);
+  }
+  return t.forEach((i) => {
+    delete i.parent;
+  }), Array.from(e.values());
+}
+function dt(t) {
+  const n = (s) => {
+    const e = t.reduce((r, o) => Math.max(r, o[s] + o.radius), Number.NEGATIVE_INFINITY), i = t.reduce((r, o) => Math.min(r, o[s] - o.radius), Number.POSITIVE_INFINITY);
+    return { max: e, min: i };
+  };
+  return { xRange: n("x"), yRange: n("y") };
+}
+function Ct(t, n, s) {
+  n == null && (n = Math.PI / 2);
+  let e = Ft(t).map((u) => Object.assign({}, u));
+  const i = be(e);
+  for (const u of i) {
+    me(u, n, s);
+    const a = dt(u);
+    u.size = (a.xRange.max - a.xRange.min) * (a.yRange.max - a.yRange.min), u.bounds = a;
+  }
+  i.sort((u, a) => a.size - u.size), e = i[0];
+  let r = e.bounds;
+  const o = (r.xRange.max - r.xRange.min) / 50;
+  function l(u, a, p) {
+    if (!u)
+      return;
+    const d = u.bounds;
+    let m, y;
+    if (a)
+      m = r.xRange.max - d.xRange.min + o;
+    else {
+      m = r.xRange.max - d.xRange.max;
+      const M = (d.xRange.max - d.xRange.min) / 2 - (r.xRange.max - r.xRange.min) / 2;
+      M < 0 && (m += M);
+    }
+    if (p)
+      y = r.yRange.max - d.yRange.min + o;
+    else {
+      y = r.yRange.max - d.yRange.max;
+      const M = (d.yRange.max - d.yRange.min) / 2 - (r.yRange.max - r.yRange.min) / 2;
+      M < 0 && (y += M);
+    }
+    for (const M of u)
+      M.x += m, M.y += y, e.push(M);
+  }
+  let h = 1;
+  for (; h < i.length; )
+    l(i[h], !0, !1), l(i[h + 1], !1, !0), l(i[h + 2], !0, !0), h += 3, r = dt(e);
+  return Ot(e);
+}
+function Nt(t, n, s, e, i) {
+  const r = Ft(t);
+  n -= 2 * e, s -= 2 * e;
+  const { xRange: o, yRange: l } = dt(r);
+  if (o.max === o.min || l.max === l.min)
+    return console.log("not scaling solution: zero size detected"), t;
+  let h, u;
+  if (i) {
+    const m = Math.sqrt(i / Math.PI) * 2;
+    h = n / m, u = s / m;
+  } else
+    h = n / (o.max - o.min), u = s / (l.max - l.min);
+  const a = Math.min(u, h), p = (n - (o.max - o.min) * a) / 2, d = (s - (l.max - l.min) * a) / 2;
+  return Ot(
+    r.map((m) => ({
+      radius: a * m.radius,
+      x: e + p + (m.x - o.min) * a,
+      y: e + d + (m.y - l.min) * a,
+      setid: m.setid
+    }))
+  );
+}
+function Ot(t) {
+  const n = {};
+  for (const s of t)
+    n[s.setid] = s;
+  return n;
+}
+function Ft(t) {
+  return Object.keys(t).map((s) => Object.assign(t[s], { setid: s }));
+}
+function ve(t = {}) {
+  let n = !1, s = 600, e = 350, i = 15, r = 1e3, o = Math.PI / 2, l = !0, h = null, u = !0, a = !0, p = null, d = null, m = !1, y = null, M = t && t.symmetricalTextCentre ? t.symmetricalTextCentre : !1, E = {}, T = t && t.colourScheme ? t.colourScheme : t && t.colorScheme ? t.colorScheme : [
+    "#1f77b4",
+    "#ff7f0e",
+    "#2ca02c",
+    "#d62728",
+    "#9467bd",
+    "#8c564b",
+    "#e377c2",
+    "#7f7f7f",
+    "#bcbd22",
+    "#17becf"
+  ], w = 0, g = function(x) {
+    if (x in E)
+      return E[x];
+    var f = E[x] = T[w];
+    return w += 1, w >= T.length && (w = 0), f;
+  }, b = At, v = et;
+  function c(x) {
+    let f = x.datum();
+    const O = /* @__PURE__ */ new Set();
+    f.forEach((I) => {
+      I.size == 0 && I.sets.length == 1 && O.add(I.sets[0]);
+    }), f = f.filter((I) => !I.sets.some((C) => O.has(C)));
+    let k = {}, R = {};
+    if (f.length > 0) {
+      let I = b(f, { lossFunction: v, distinct: m });
+      l && (I = Ct(I, o, d)), k = Nt(I, s, e, i, h), R = Lt(k, f, M);
+    }
+    const Z = {};
+    f.forEach((I) => {
+      I.label && (Z[I.sets] = I.label);
+    });
+    function U(I) {
+      if (I.sets in Z)
+        return Z[I.sets];
+      if (I.sets.length == 1)
+        return "" + I.sets[0];
+    }
+    x.selectAll("svg").data([k]).enter().append("svg");
+    const B = x.select("svg");
+    n ? B.attr("viewBox", `0 0 ${s} ${e}`) : B.attr("width", s).attr("height", e);
+    const V = {};
+    let z = !1;
+    B.selectAll(".venn-area path").each(function(I) {
+      const C = this.getAttribute("d");
+      I.sets.length == 1 && C && !m && (z = !0, V[I.sets[0]] = Me(C));
+    });
+    function q(I) {
+      return (C) => {
+        const G = I.sets.map((J) => {
+          let W = V[J], X = k[J];
+          return W || (W = { x: s / 2, y: e / 2, radius: 1 }), X || (X = { x: s / 2, y: e / 2, radius: 1 }), {
+            x: W.x * (1 - C) + X.x * C,
+            y: W.y * (1 - C) + X.y * C,
+            radius: W.radius * (1 - C) + X.radius * C
+          };
+        });
+        return wt(G, y);
+      };
+    }
+    const A = B.selectAll(".venn-area").data(f, (I) => I.sets), F = A.enter().append("g").attr(
+      "class",
+      (I) => `venn-area venn-${I.sets.length == 1 ? "circle" : "intersection"}${I.colour || I.color ? " venn-coloured" : ""}`
+    ).attr("data-venn-sets", (I) => I.sets.join("_")), j = F.append("path"), L = F.append("text").attr("class", "label").text((I) => U(I)).attr("text-anchor", "middle").attr("dy", ".35em").attr("x", s / 2).attr("y", e / 2);
+    a && (j.style("fill-opacity", "0").filter((I) => I.sets.length == 1).style("fill", (I) => I.colour ? I.colour : I.color ? I.color : g(I.sets)).style("fill-opacity", ".25"), L.style("fill", (I) => I.colour || I.color ? "#FFF" : t.textFill ? t.textFill : I.sets.length == 1 ? g(I.sets) : "#444"));
+    function P(I) {
+      return typeof I.transition == "function" ? I.transition("venn").duration(r) : I;
+    }
+    let _ = x;
+    z && typeof _.transition == "function" ? (_ = P(x), _.selectAll("path").attrTween("d", q)) : _.selectAll("path").attr("d", (I) => wt(I.sets.map((C) => k[C])), y);
+    const D = _.selectAll("text").filter((I) => I.sets in R).text((I) => U(I)).attr("x", (I) => Math.floor(R[I.sets].x)).attr("y", (I) => Math.floor(R[I.sets].y));
+    u && (z ? "on" in D ? D.on("end", ot(k, U)) : D.each("end", ot(k, U)) : D.each(ot(k, U)));
+    const N = P(A.exit()).remove();
+    typeof A.transition == "function" && N.selectAll("path").attrTween("d", q);
+    const Y = N.selectAll("text").attr("x", s / 2).attr("y", e / 2);
+    return p !== null && (L.style("font-size", "0px"), D.style("font-size", p), Y.style("font-size", "0px")), { circles: k, textCentres: R, nodes: A, enter: F, update: _, exit: N };
+  }
+  return c.wrap = function(x) {
+    return arguments.length ? (u = x, c) : u;
+  }, c.useViewBox = function() {
+    return n = !0, c;
+  }, c.width = function(x) {
+    return arguments.length ? (s = x, c) : s;
+  }, c.height = function(x) {
+    return arguments.length ? (e = x, c) : e;
+  }, c.padding = function(x) {
+    return arguments.length ? (i = x, c) : i;
+  }, c.distinct = function(x) {
+    return arguments.length ? (m = x, c) : m;
+  }, c.colours = function(x) {
+    return arguments.length ? (g = x, c) : g;
+  }, c.colors = function(x) {
+    return arguments.length ? (g = x, c) : g;
+  }, c.fontSize = function(x) {
+    return arguments.length ? (p = x, c) : p;
+  }, c.round = function(x) {
+    return arguments.length ? (y = x, c) : y;
+  }, c.duration = function(x) {
+    return arguments.length ? (r = x, c) : r;
+  }, c.layoutFunction = function(x) {
+    return arguments.length ? (b = x, c) : b;
+  }, c.normalize = function(x) {
+    return arguments.length ? (l = x, c) : l;
+  }, c.scaleToFit = function(x) {
+    return arguments.length ? (h = x, c) : h;
+  }, c.styled = function(x) {
+    return arguments.length ? (a = x, c) : a;
+  }, c.orientation = function(x) {
+    return arguments.length ? (o = x, c) : o;
+  }, c.orientationOrder = function(x) {
+    return arguments.length ? (d = x, c) : d;
+  }, c.lossFunction = function(x) {
+    return arguments.length ? (v = x === "default" ? et : x === "logRatio" ? Dt : x, c) : v;
+  }, c;
+}
+function ot(t, n) {
+  return function(s) {
+    const e = this, i = t[s.sets[0]].radius || 50, r = n(s) || "", o = r.split(/\s+/).reverse(), h = (r.length + o.length) / 3;
+    let u = o.pop(), a = [u], p = 0;
+    const d = 1.1;
+    e.textContent = null;
+    const m = [];
+    function y(g) {
+      const b = e.ownerDocument.createElementNS(e.namespaceURI, "tspan");
+      return b.textContent = g, m.push(b), e.append(b), b;
+    }
+    let M = y(u);
+    for (; u = o.pop(), !!u; ) {
+      a.push(u);
+      const g = a.join(" ");
+      M.textContent = g, g.length > h && M.getComputedTextLength() > i && (a.pop(), M.textContent = a.join(" "), a = [u], M = y(u), p++);
+    }
+    const E = 0.35 - p * d / 2, T = e.getAttribute("x"), w = e.getAttribute("y");
+    m.forEach((g, b) => {
+      g.setAttribute("x", T), g.setAttribute("y", w), g.setAttribute("dy", `${E + b * d}em`);
+    });
+  };
+}
+function at(t, n, s) {
+  let e = n[0].radius - K(n[0], t);
+  for (let i = 1; i < n.length; ++i) {
+    const r = n[i].radius - K(n[i], t);
+    r <= e && (e = r);
+  }
+  for (let i = 0; i < s.length; ++i) {
+    const r = K(s[i], t) - s[i].radius;
+    r <= e && (e = r);
+  }
+  return e;
+}
+function jt(t, n, s) {
+  const e = [];
+  for (const a of t)
+    e.push({ x: a.x, y: a.y }), e.push({ x: a.x + a.radius / 2, y: a.y }), e.push({ x: a.x - a.radius / 2, y: a.y }), e.push({ x: a.x, y: a.y + a.radius / 2 }), e.push({ x: a.x, y: a.y - a.radius / 2 });
+  let i = e[0], r = at(e[0], t, n);
+  for (let a = 1; a < e.length; ++a) {
+    const p = at(e[a], t, n);
+    p >= r && (i = e[a], r = p);
+  }
+  const o = zt(
+    (a) => -1 * at({ x: a[0], y: a[1] }, t, n),
+    [i.x, i.y],
+    { maxIterations: 500, minErrorDelta: 1e-10 }
+  ).x, l = { x: s ? 0 : o[0], y: o[1] };
+  let h = !0;
+  for (const a of t)
+    if (K(l, a) > a.radius) {
+      h = !1;
+      break;
+    }
+  for (const a of n)
+    if (K(l, a) < a.radius) {
+      h = !1;
+      break;
+    }
+  if (h)
+    return l;
+  if (t.length == 1)
+    return { x: t[0].x, y: t[0].y };
+  const u = {};
+  return st(t, u), u.arcs.length === 0 ? { x: 0, y: -1e3, disjoint: !0 } : u.arcs.length == 1 ? { x: u.arcs[0].circle.x, y: u.arcs[0].circle.y } : n.length ? jt(t, []) : Et(u.arcs.map((a) => a.p1));
+}
+function Ie(t) {
+  const n = {}, s = Object.keys(t);
+  for (const e of s)
+    n[e] = [];
+  for (let e = 0; e < s.length; e++) {
+    const i = s[e], r = t[i];
+    for (let o = e + 1; o < s.length; ++o) {
+      const l = s[o], h = t[l], u = K(r, h);
+      u + h.radius <= r.radius + 1e-10 ? n[l].push(i) : u + r.radius <= h.radius + 1e-10 && n[i].push(l);
+    }
+  }
+  return n;
+}
+function Lt(t, n, s) {
+  const e = {}, i = Ie(t);
+  for (let r = 0; r < n.length; ++r) {
+    const o = n[r].sets, l = {}, h = {};
+    for (let d = 0; d < o.length; ++d) {
+      l[o[d]] = !0;
+      const m = i[o[d]];
+      for (let y = 0; y < m.length; ++y)
+        h[m[y]] = !0;
+    }
+    const u = [], a = [];
+    for (let d in t)
+      d in l ? u.push(t[d]) : d in h || a.push(t[d]);
+    const p = jt(u, a, s);
+    e[o] = p, p.disjoint && n[r].size > 0 && console.log("WARNING: area " + o + " not represented on screen");
+  }
+  return e;
+}
+function ke(t, n, s) {
+  const e = [];
+  return e.push(`
+M`, t, n), e.push(`
+m`, -s, 0), e.push(`
+a`, s, s, 0, 1, 0, s * 2, 0), e.push(`
+a`, s, s, 0, 1, 0, -s * 2, 0), e.join(" ");
+}
+function Me(t) {
+  const n = t.split(" ");
+  return { x: Number.parseFloat(n[1]), y: Number.parseFloat(n[2]), radius: -Number.parseFloat(n[4]) };
+}
+function Pt(t) {
+  if (t.length === 0)
+    return [];
+  const n = {};
+  return st(t, n), n.arcs;
+}
+function Bt(t, n) {
+  if (t.length === 0)
+    return "M 0 0";
+  const s = Math.pow(10, n || 0), e = n != null ? (r) => Math.round(r * s) / s : (r) => r;
+  if (t.length == 1) {
+    const r = t[0].circle;
+    return ke(e(r.x), e(r.y), e(r.radius));
+  }
+  const i = [`
+M`, e(t[0].p2.x), e(t[0].p2.y)];
+  for (const r of t) {
+    const o = e(r.circle.radius);
+    i.push(`
+A`, o, o, 0, r.large ? 1 : 0, r.sweep ? 1 : 0, e(r.p1.x), e(r.p1.y));
+  }
+  return i.join(" ");
+}
+function wt(t, n) {
+  return Bt(Pt(t), n);
+}
+function we(t, n = {}) {
+  const {
+    lossFunction: s,
+    layoutFunction: e = At,
+    normalize: i = !0,
+    orientation: r = Math.PI / 2,
+    orientationOrder: o,
+    width: l = 600,
+    height: h = 350,
+    padding: u = 15,
+    scaleToFit: a = !1,
+    symmetricalTextCentre: p = !1,
+    distinct: d,
+    round: m = 2
+  } = n;
+  let y = e(t, {
+    lossFunction: s === "default" || !s ? et : s === "logRatio" ? Dt : s,
+    distinct: d
+  });
+  i && (y = Ct(y, r, o));
+  const M = Nt(y, l, h, u, a), E = Lt(M, t, p), T = new Map(
+    Object.keys(M).map((b) => [
+      b,
+      {
+        set: b,
+        x: M[b].x,
+        y: M[b].y,
+        radius: M[b].radius
+      }
+    ])
+  ), w = t.map((b) => {
+    const v = b.sets.map((f) => T.get(f)), c = Pt(v), x = Bt(c, m);
+    return { circles: v, arcs: c, path: x, area: b, has: new Set(b.sets) };
+  });
+  function g(b) {
+    let v = "";
+    for (const c of w)
+      c.has.size > b.length && b.every((x) => c.has.has(x)) && (v += " " + c.path);
+    return v;
+  }
+  return w.map(({ circles: b, arcs: v, path: c, area: x }) => ({
+    data: x,
+    text: E[x.sets],
+    circles: b,
+    arcs: v,
+    path: c,
+    distinctPath: c + g(x.sets)
+  }));
+}
+var gt = (function() {
+  var t = /* @__PURE__ */ S(function(w, g, b, v) {
+    for (b = b || {}, v = w.length; v--; b[w[v]] = g) ;
+    return b;
+  }, "o"), n = [5, 8], s = [7, 8, 11, 12, 17, 19, 22, 24], e = [1, 17], i = [1, 18], r = [7, 8, 11, 12, 14, 15, 16, 17, 19, 20, 21, 22, 24, 27], o = [1, 31], l = [1, 39], h = [7, 8, 11, 12, 17, 19, 22, 24, 27], u = [1, 57], a = [1, 56], p = [1, 58], d = [1, 59], m = [1, 60], y = [7, 8, 11, 12, 16, 17, 19, 20, 22, 24, 27, 31, 32, 33], M = {
+    trace: /* @__PURE__ */ S(function() {
+    }, "trace"),
+    yy: {},
+    symbols_: { error: 2, start: 3, optNewlines: 4, VENN: 5, document: 6, EOF: 7, NEWLINE: 8, line: 9, statement: 10, TITLE: 11, SET: 12, identifier: 13, BRACKET_LABEL: 14, COLON: 15, NUMERIC: 16, UNION: 17, identifierList: 18, TEXT: 19, IDENTIFIER: 20, STRING: 21, INDENT_TEXT: 22, indentedTextTail: 23, STYLE: 24, stylesOpt: 25, styleField: 26, COMMA: 27, styleValue: 28, valueTokens: 29, valueToken: 30, HEXCOLOR: 31, RGBCOLOR: 32, RGBACOLOR: 33, $accept: 0, $end: 1 },
+    terminals_: { 2: "error", 5: "VENN", 7: "EOF", 8: "NEWLINE", 11: "TITLE", 12: "SET", 14: "BRACKET_LABEL", 15: "COLON", 16: "NUMERIC", 17: "UNION", 19: "TEXT", 20: "IDENTIFIER", 21: "STRING", 22: "INDENT_TEXT", 24: "STYLE", 27: "COMMA", 31: "HEXCOLOR", 32: "RGBCOLOR", 33: "RGBACOLOR" },
+    productions_: [0, [3, 4], [4, 0], [4, 2], [6, 0], [6, 2], [9, 1], [9, 1], [10, 1], [10, 2], [10, 3], [10, 4], [10, 5], [10, 2], [10, 3], [10, 4], [10, 5], [10, 3], [10, 3], [10, 3], [10, 4], [10, 4], [10, 2], [10, 3], [23, 1], [23, 1], [23, 1], [23, 2], [23, 2], [25, 1], [25, 3], [26, 3], [28, 1], [28, 1], [29, 1], [29, 2], [30, 1], [30, 1], [30, 1], [30, 1], [30, 1], [18, 1], [18, 3], [13, 1], [13, 1]],
+    performAction: /* @__PURE__ */ S(function(g, b, v, c, x, f, O) {
+      var k = f.length - 1;
+      switch (x) {
+        case 1:
+          return f[k - 1];
+        case 2:
+        case 3:
+        case 4:
+          this.$ = [];
+          break;
+        case 5:
+          f[k - 1].push(f[k]), this.$ = f[k - 1];
+          break;
+        case 6:
+          this.$ = [];
+          break;
+        case 7:
+        case 22:
+        case 32:
+        case 36:
+        case 37:
+        case 38:
+        case 39:
+        case 40:
+          this.$ = f[k];
+          break;
+        case 8:
+          c.setDiagramTitle(f[k].substr(6)), this.$ = f[k].substr(6);
+          break;
+        case 9:
+          c.addSubsetData([f[k]], void 0, void 0), c.setIndentMode && c.setIndentMode(!0);
+          break;
+        case 10:
+          c.addSubsetData([f[k - 1]], f[k], void 0), c.setIndentMode && c.setIndentMode(!0);
+          break;
+        case 11:
+          c.addSubsetData([f[k - 2]], void 0, parseFloat(f[k])), c.setIndentMode && c.setIndentMode(!0);
+          break;
+        case 12:
+          c.addSubsetData([f[k - 3]], f[k - 2], parseFloat(f[k])), c.setIndentMode && c.setIndentMode(!0);
+          break;
+        case 13:
+          if (f[k].length < 2)
+            throw new Error("union requires multiple identifiers");
+          c.validateUnionIdentifiers && c.validateUnionIdentifiers(f[k]), c.addSubsetData(f[k], void 0, void 0), c.setIndentMode && c.setIndentMode(!0);
+          break;
+        case 14:
+          if (f[k - 1].length < 2)
+            throw new Error("union requires multiple identifiers");
+          c.validateUnionIdentifiers && c.validateUnionIdentifiers(f[k - 1]), c.addSubsetData(f[k - 1], f[k], void 0), c.setIndentMode && c.setIndentMode(!0);
+          break;
+        case 15:
+          if (f[k - 2].length < 2)
+            throw new Error("union requires multiple identifiers");
+          c.validateUnionIdentifiers && c.validateUnionIdentifiers(f[k - 2]), c.addSubsetData(f[k - 2], void 0, parseFloat(f[k])), c.setIndentMode && c.setIndentMode(!0);
+          break;
+        case 16:
+          if (f[k - 3].length < 2)
+            throw new Error("union requires multiple identifiers");
+          c.validateUnionIdentifiers && c.validateUnionIdentifiers(f[k - 3]), c.addSubsetData(f[k - 3], f[k - 2], parseFloat(f[k])), c.setIndentMode && c.setIndentMode(!0);
+          break;
+        case 17:
+        case 18:
+        case 19:
+          c.addTextData(f[k - 1], f[k], void 0);
+          break;
+        case 20:
+        case 21:
+          c.addTextData(f[k - 2], f[k - 1], f[k]);
+          break;
+        case 23:
+          c.addStyleData(f[k - 1], f[k]);
+          break;
+        case 24:
+        case 25:
+        case 26:
+          var R = c.getCurrentSets();
+          if (!R) throw new Error("text requires set");
+          c.addTextData(R, f[k], void 0);
+          break;
+        case 27:
+        case 28:
+          var R = c.getCurrentSets();
+          if (!R) throw new Error("text requires set");
+          c.addTextData(R, f[k - 1], f[k]);
+          break;
+        case 29:
+        case 41:
+          this.$ = [f[k]];
+          break;
+        case 30:
+        case 42:
+          this.$ = [...f[k - 2], f[k]];
+          break;
+        case 31:
+          this.$ = [f[k - 2], f[k]];
+          break;
+        case 33:
+          this.$ = f[k].join(" ");
+          break;
+        case 34:
+          this.$ = [f[k]];
+          break;
+        case 35:
+          f[k - 1].push(f[k]), this.$ = f[k - 1];
+          break;
+        case 43:
+        case 44:
+          this.$ = f[k];
+          break;
+      }
+    }, "anonymous"),
+    table: [t(n, [2, 2], { 3: 1, 4: 2 }), { 1: [3] }, { 5: [1, 3], 8: [1, 4] }, t(s, [2, 4], { 6: 5 }), t(n, [2, 3]), { 7: [1, 6], 8: [1, 8], 9: 7, 10: 9, 11: [1, 10], 12: [1, 11], 17: [1, 12], 19: [1, 13], 22: [1, 14], 24: [1, 15] }, { 1: [2, 1] }, t(s, [2, 5]), t(s, [2, 6]), t(s, [2, 7]), t(s, [2, 8]), { 13: 16, 20: e, 21: i }, { 13: 20, 18: 19, 20: e, 21: i }, { 13: 20, 18: 21, 20: e, 21: i }, { 16: [1, 25], 20: [1, 23], 21: [1, 24], 23: 22 }, { 13: 20, 18: 26, 20: e, 21: i }, t(s, [2, 9], { 14: [1, 27], 15: [1, 28] }), t(r, [2, 43]), t(r, [2, 44]), t(s, [2, 13], { 14: [1, 29], 15: [1, 30], 27: o }), t(r, [2, 41]), { 16: [1, 34], 20: [1, 32], 21: [1, 33], 27: o }, t(s, [2, 22]), t(s, [2, 24], { 14: [1, 35] }), t(s, [2, 25], { 14: [1, 36] }), t(s, [2, 26]), { 20: l, 25: 37, 26: 38, 27: o }, t(s, [2, 10], { 15: [1, 40] }), { 16: [1, 41] }, t(s, [2, 14], { 15: [1, 42] }), { 16: [1, 43] }, { 13: 44, 20: e, 21: i }, t(s, [2, 17], { 14: [1, 45] }), t(s, [2, 18], { 14: [1, 46] }), t(s, [2, 19]), t(s, [2, 27]), t(s, [2, 28]), t(s, [2, 23], { 27: [1, 47] }), t(h, [2, 29]), { 15: [1, 48] }, { 16: [1, 49] }, t(s, [2, 11]), { 16: [1, 50] }, t(s, [2, 15]), t(r, [2, 42]), t(s, [2, 20]), t(s, [2, 21]), { 20: l, 26: 51 }, { 16: u, 20: a, 21: [1, 53], 28: 52, 29: 54, 30: 55, 31: p, 32: d, 33: m }, t(s, [2, 12]), t(s, [2, 16]), t(h, [2, 30]), t(h, [2, 31]), t(h, [2, 32]), t(h, [2, 33], { 30: 61, 16: u, 20: a, 31: p, 32: d, 33: m }), t(y, [2, 34]), t(y, [2, 36]), t(y, [2, 37]), t(y, [2, 38]), t(y, [2, 39]), t(y, [2, 40]), t(y, [2, 35])],
+    defaultActions: { 6: [2, 1] },
+    parseError: /* @__PURE__ */ S(function(g, b) {
+      if (b.recoverable)
+        this.trace(g);
+      else {
+        var v = new Error(g);
+        throw v.hash = b, v;
+      }
+    }, "parseError"),
+    parse: /* @__PURE__ */ S(function(g) {
+      var b = this, v = [0], c = [], x = [null], f = [], O = this.table, k = "", R = 0, Z = 0, U = 2, B = 1, V = f.slice.call(arguments, 1), z = Object.create(this.lexer), q = { yy: {} };
+      for (var A in this.yy)
+        Object.prototype.hasOwnProperty.call(this.yy, A) && (q.yy[A] = this.yy[A]);
+      z.setInput(g, q.yy), q.yy.lexer = z, q.yy.parser = this, typeof z.yylloc > "u" && (z.yylloc = {});
+      var F = z.yylloc;
+      f.push(F);
+      var j = z.options && z.options.ranges;
+      typeof q.yy.parseError == "function" ? this.parseError = q.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function L(H) {
+        v.length = v.length - 2 * H, x.length = x.length - H, f.length = f.length - H;
+      }
+      S(L, "popStack");
+      function P() {
+        var H;
+        return H = c.pop() || z.lex() || B, typeof H != "number" && (H instanceof Array && (c = H, H = c.pop()), H = b.symbols_[H] || H), H;
+      }
+      S(P, "lex");
+      for (var _, D, N, Y, I = {}, C, G, J, W; ; ) {
+        if (D = v[v.length - 1], this.defaultActions[D] ? N = this.defaultActions[D] : ((_ === null || typeof _ > "u") && (_ = P()), N = O[D] && O[D][_]), typeof N > "u" || !N.length || !N[0]) {
+          var X = "";
+          W = [];
+          for (C in O[D])
+            this.terminals_[C] && C > U && W.push("'" + this.terminals_[C] + "'");
+          z.showPosition ? X = "Parse error on line " + (R + 1) + `:
+` + z.showPosition() + `
+Expecting ` + W.join(", ") + ", got '" + (this.terminals_[_] || _) + "'" : X = "Parse error on line " + (R + 1) + ": Unexpected " + (_ == B ? "end of input" : "'" + (this.terminals_[_] || _) + "'"), this.parseError(X, {
+            text: z.match,
+            token: this.terminals_[_] || _,
+            line: z.yylineno,
+            loc: F,
+            expected: W
+          });
+        }
+        if (N[0] instanceof Array && N.length > 1)
+          throw new Error("Parse Error: multiple actions possible at state: " + D + ", token: " + _);
+        switch (N[0]) {
+          case 1:
+            v.push(_), x.push(z.yytext), f.push(z.yylloc), v.push(N[1]), _ = null, Z = z.yyleng, k = z.yytext, R = z.yylineno, F = z.yylloc;
+            break;
+          case 2:
+            if (G = this.productions_[N[1]][1], I.$ = x[x.length - G], I._$ = {
+              first_line: f[f.length - (G || 1)].first_line,
+              last_line: f[f.length - 1].last_line,
+              first_column: f[f.length - (G || 1)].first_column,
+              last_column: f[f.length - 1].last_column
+            }, j && (I._$.range = [
+              f[f.length - (G || 1)].range[0],
+              f[f.length - 1].range[1]
+            ]), Y = this.performAction.apply(I, [
+              k,
+              Z,
+              R,
+              q.yy,
+              N[1],
+              x,
+              f
+            ].concat(V)), typeof Y < "u")
+              return Y;
+            G && (v = v.slice(0, -1 * G * 2), x = x.slice(0, -1 * G), f = f.slice(0, -1 * G)), v.push(this.productions_[N[1]][0]), x.push(I.$), f.push(I._$), J = O[v[v.length - 2]][v[v.length - 1]], v.push(J);
+            break;
+          case 3:
+            return !0;
+        }
+      }
+      return !0;
+    }, "parse")
+  }, E = /* @__PURE__ */ (function() {
+    var w = {
+      EOF: 1,
+      parseError: /* @__PURE__ */ S(function(b, v) {
+        if (this.yy.parser)
+          this.yy.parser.parseError(b, v);
+        else
+          throw new Error(b);
+      }, "parseError"),
+      // resets the lexer, sets new input
+      setInput: /* @__PURE__ */ S(function(g, b) {
+        return this.yy = b || this.yy || {}, this._input = g, this._more = this._backtrack = this.done = !1, this.yylineno = this.yyleng = 0, this.yytext = this.matched = this.match = "", this.conditionStack = ["INITIAL"], this.yylloc = {
+          first_line: 1,
+          first_column: 0,
+          last_line: 1,
+          last_column: 0
+        }, this.options.ranges && (this.yylloc.range = [0, 0]), this.offset = 0, this;
+      }, "setInput"),
+      // consumes and returns one char from the input
+      input: /* @__PURE__ */ S(function() {
+        var g = this._input[0];
+        this.yytext += g, this.yyleng++, this.offset++, this.match += g, this.matched += g;
+        var b = g.match(/(?:\r\n?|\n).*/g);
+        return b ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), g;
+      }, "input"),
+      // unshifts one char (or a string) into the input
+      unput: /* @__PURE__ */ S(function(g) {
+        var b = g.length, v = g.split(/(?:\r\n?|\n)/g);
+        this._input = g + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - b), this.offset -= b;
+        var c = this.match.split(/(?:\r\n?|\n)/g);
+        this.match = this.match.substr(0, this.match.length - 1), this.matched = this.matched.substr(0, this.matched.length - 1), v.length - 1 && (this.yylineno -= v.length - 1);
+        var x = this.yylloc.range;
+        return this.yylloc = {
+          first_line: this.yylloc.first_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.first_column,
+          last_column: v ? (v.length === c.length ? this.yylloc.first_column : 0) + c[c.length - v.length].length - v[0].length : this.yylloc.first_column - b
+        }, this.options.ranges && (this.yylloc.range = [x[0], x[0] + this.yyleng - b]), this.yyleng = this.yytext.length, this;
+      }, "unput"),
+      // When called from action, caches matched text and appends it on next action
+      more: /* @__PURE__ */ S(function() {
+        return this._more = !0, this;
+      }, "more"),
+      // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
+      reject: /* @__PURE__ */ S(function() {
+        if (this.options.backtrack_lexer)
+          this._backtrack = !0;
+        else
+          return this.parseError("Lexical error on line " + (this.yylineno + 1) + `. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+` + this.showPosition(), {
+            text: "",
+            token: null,
+            line: this.yylineno
+          });
+        return this;
+      }, "reject"),
+      // retain first n characters of the match
+      less: /* @__PURE__ */ S(function(g) {
+        this.unput(this.match.slice(g));
+      }, "less"),
+      // displays already matched input, i.e. for error messages
+      pastInput: /* @__PURE__ */ S(function() {
+        var g = this.matched.substr(0, this.matched.length - this.match.length);
+        return (g.length > 20 ? "..." : "") + g.substr(-20).replace(/\n/g, "");
+      }, "pastInput"),
+      // displays upcoming input, i.e. for error messages
+      upcomingInput: /* @__PURE__ */ S(function() {
+        var g = this.match;
+        return g.length < 20 && (g += this._input.substr(0, 20 - g.length)), (g.substr(0, 20) + (g.length > 20 ? "..." : "")).replace(/\n/g, "");
+      }, "upcomingInput"),
+      // displays the character position where the lexing error occurred, i.e. for error messages
+      showPosition: /* @__PURE__ */ S(function() {
+        var g = this.pastInput(), b = new Array(g.length + 1).join("-");
+        return g + this.upcomingInput() + `
+` + b + "^";
+      }, "showPosition"),
+      // test the lexed token: return FALSE when not a match, otherwise return token
+      test_match: /* @__PURE__ */ S(function(g, b) {
+        var v, c, x;
+        if (this.options.backtrack_lexer && (x = {
+          yylineno: this.yylineno,
+          yylloc: {
+            first_line: this.yylloc.first_line,
+            last_line: this.last_line,
+            first_column: this.yylloc.first_column,
+            last_column: this.yylloc.last_column
+          },
+          yytext: this.yytext,
+          match: this.match,
+          matches: this.matches,
+          matched: this.matched,
+          yyleng: this.yyleng,
+          offset: this.offset,
+          _more: this._more,
+          _input: this._input,
+          yy: this.yy,
+          conditionStack: this.conditionStack.slice(0),
+          done: this.done
+        }, this.options.ranges && (x.yylloc.range = this.yylloc.range.slice(0))), c = g[0].match(/(?:\r\n?|\n).*/g), c && (this.yylineno += c.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: c ? c[c.length - 1].length - c[c.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + g[0].length
+        }, this.yytext += g[0], this.match += g[0], this.matches = g, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [this.offset, this.offset += this.yyleng]), this._more = !1, this._backtrack = !1, this._input = this._input.slice(g[0].length), this.matched += g[0], v = this.performAction.call(this, this.yy, this, b, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), v)
+          return v;
+        if (this._backtrack) {
+          for (var f in x)
+            this[f] = x[f];
+          return !1;
+        }
+        return !1;
+      }, "test_match"),
+      // return next match in input
+      next: /* @__PURE__ */ S(function() {
+        if (this.done)
+          return this.EOF;
+        this._input || (this.done = !0);
+        var g, b, v, c;
+        this._more || (this.yytext = "", this.match = "");
+        for (var x = this._currentRules(), f = 0; f < x.length; f++)
+          if (v = this._input.match(this.rules[x[f]]), v && (!b || v[0].length > b[0].length)) {
+            if (b = v, c = f, this.options.backtrack_lexer) {
+              if (g = this.test_match(v, x[f]), g !== !1)
+                return g;
+              if (this._backtrack) {
+                b = !1;
+                continue;
+              } else
+                return !1;
+            } else if (!this.options.flex)
+              break;
+          }
+        return b ? (g = this.test_match(b, x[c]), g !== !1 ? g : !1) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + `. Unrecognized text.
+` + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+      }, "next"),
+      // return next match that has a token
+      lex: /* @__PURE__ */ S(function() {
+        var b = this.next();
+        return b || this.lex();
+      }, "lex"),
+      // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+      begin: /* @__PURE__ */ S(function(b) {
+        this.conditionStack.push(b);
+      }, "begin"),
+      // pop the previously active lexer condition state off the condition stack
+      popState: /* @__PURE__ */ S(function() {
+        var b = this.conditionStack.length - 1;
+        return b > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+      }, "popState"),
+      // produce the lexer rule set which is active for the currently active lexer condition state
+      _currentRules: /* @__PURE__ */ S(function() {
+        return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1] ? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules : this.conditions.INITIAL.rules;
+      }, "_currentRules"),
+      // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+      topState: /* @__PURE__ */ S(function(b) {
+        return b = this.conditionStack.length - 1 - Math.abs(b || 0), b >= 0 ? this.conditionStack[b] : "INITIAL";
+      }, "topState"),
+      // alias for begin(condition)
+      pushState: /* @__PURE__ */ S(function(b) {
+        this.begin(b);
+      }, "pushState"),
+      // return the number of states currently on the stack
+      stateStackSize: /* @__PURE__ */ S(function() {
+        return this.conditionStack.length;
+      }, "stateStackSize"),
+      options: { "case-insensitive": !0 },
+      performAction: /* @__PURE__ */ S(function(b, v, c, x) {
+        switch (c) {
+          case 0:
+            break;
+          case 1:
+            break;
+          case 2:
+            break;
+          case 3:
+            if (b.getIndentMode && b.getIndentMode())
+              return b.consumeIndentText = !0, this.begin("INITIAL"), 22;
+            break;
+          case 4:
+            break;
+          case 5:
+            b.setIndentMode && b.setIndentMode(!1), this.begin("INITIAL"), this.unput(v.yytext);
+            break;
+          case 6:
+            return this.begin("bol"), 8;
+          case 7:
+            break;
+          case 8:
+            break;
+          case 9:
+            return 7;
+          case 10:
+            return 11;
+          case 11:
+            return 5;
+          case 12:
+            return 12;
+          case 13:
+            return 17;
+          case 14:
+            if (b.consumeIndentText)
+              b.consumeIndentText = !1;
+            else
+              return 19;
+            break;
+          case 15:
+            return 24;
+          case 16:
+            return v.yytext = v.yytext.slice(2, -2), 14;
+          case 17:
+            return v.yytext = v.yytext.slice(1, -1).trim(), 14;
+          case 18:
+            return 16;
+          case 19:
+            return 31;
+          case 20:
+            return 33;
+          case 21:
+            return 32;
+          case 22:
+            return 20;
+          case 23:
+            return 21;
+          case 24:
+            return 27;
+          case 25:
+            return 15;
+        }
+      }, "anonymous"),
+      rules: [/^(?:%%(?!\{)[^\n]*)/i, /^(?:[^\}]%%[^\n]*)/i, /^(?:[ \t]+(?=[\n\r]))/i, /^(?:[ \t]+(?=text\b))/i, /^(?:[ \t]+)/i, /^(?:[^ \t\n\r])/i, /^(?:[\n\r]+)/i, /^(?:%%[^\n]*)/i, /^(?:[ \t]+)/i, /^(?:$)/i, /^(?:title\s[^#\n;]+)/i, /^(?:venn-beta\b)/i, /^(?:set\b)/i, /^(?:union\b)/i, /^(?:text\b)/i, /^(?:style\b)/i, /^(?:\["[^\"]*"\])/i, /^(?:\[[^\]\"]+\])/i, /^(?:[+-]?(\d+(\.\d+)?|\.\d+))/i, /^(?:#[0-9a-fA-F]{3,8})/i, /^(?:rgba\(\s*[0-9.]+\s*[,]\s*[0-9.]+\s*[,]\s*[0-9.]+\s*[,]\s*[0-9.]+\s*\))/i, /^(?:rgb\(\s*[0-9.]+\s*[,]\s*[0-9.]+\s*[,]\s*[0-9.]+\s*\))/i, /^(?:[A-Za-z_][A-Za-z0-9\-_]*)/i, /^(?:"[^\"]*")/i, /^(?:,)/i, /^(?::)/i],
+      conditions: { bol: { rules: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], inclusive: !0 }, INITIAL: { rules: [0, 1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], inclusive: !0 } }
+    };
+    return w;
+  })();
+  M.lexer = E;
+  function T() {
+    this.yy = {};
+  }
+  return S(T, "Parser"), T.prototype = M, M.Parser = T, new T();
+})();
+gt.parser = gt;
+var Se = gt, yt = [], pt = [], mt = [], bt = /* @__PURE__ */ new Set(), vt, It = !1, _e = /* @__PURE__ */ S((t, n, s) => {
+  const e = it(t).sort(), i = s ?? 10 / Math.pow(t.length, 2);
+  vt = e, e.length === 1 && bt.add(e[0]), yt.push({
+    sets: e,
+    size: i,
+    label: n ? nt(n) : void 0
+  });
+}, "addSubsetData"), Te = /* @__PURE__ */ S(() => yt, "getSubsetData"), nt = /* @__PURE__ */ S((t) => {
+  const n = t.trim();
+  return n.length >= 2 && n.startsWith('"') && n.endsWith('"') ? n.slice(1, -1) : n;
+}, "normalizeText"), Ee = /* @__PURE__ */ S((t) => t && nt(t), "normalizeStyleValue"), ze = /* @__PURE__ */ S((t, n, s) => {
+  const e = nt(n);
+  pt.push({
+    sets: it(t).sort(),
+    id: e,
+    label: s ? nt(s) : void 0
+  });
+}, "addTextData"), Ae = /* @__PURE__ */ S((t, n) => {
+  const s = it(t).sort(), e = {};
+  for (const [i, r] of n)
+    e[i] = Ee(r) ?? r;
+  mt.push({ targets: s, styles: e });
+}, "addStyleData"), Re = /* @__PURE__ */ S(() => mt, "getStyleData"), it = /* @__PURE__ */ S((t) => t.map((n) => nt(n)), "normalizeIdentifierList"), De = /* @__PURE__ */ S((t) => {
+  const s = it(t).filter((e) => !bt.has(e));
+  if (s.length > 0)
+    throw new Error(`unknown set identifier: ${s.join(", ")}`);
+}, "validateUnionIdentifiers"), Ce = /* @__PURE__ */ S(() => pt, "getTextData"), Ne = /* @__PURE__ */ S(() => vt, "getCurrentSets"), Oe = /* @__PURE__ */ S(() => It, "getIndentMode"), Fe = /* @__PURE__ */ S((t) => {
+  It = t;
+}, "setIndentMode"), je = oe.venn;
+function Vt() {
+  return re(je, St().venn);
+}
+S(Vt, "getConfig");
+var Le = /* @__PURE__ */ S(() => {
+  ie(), yt.length = 0, pt.length = 0, mt.length = 0, bt.clear(), vt = void 0, It = !1;
+}, "customClear"), Pe = {
+  getConfig: Vt,
+  clear: Le,
+  setAccTitle: Jt,
+  getAccTitle: Zt,
+  setDiagramTitle: Xt,
+  getDiagramTitle: Yt,
+  getAccDescription: Ht,
+  setAccDescription: Kt,
+  addSubsetData: _e,
+  getSubsetData: Te,
+  addTextData: ze,
+  addStyleData: Ae,
+  validateUnionIdentifiers: De,
+  getTextData: Ce,
+  getStyleData: Re,
+  getCurrentSets: Ne,
+  getIndentMode: Oe,
+  setIndentMode: Fe
+}, Be = /* @__PURE__ */ S((t) => `
+  .venn-title {
+    font-size: 32px;
+    fill: ${t.vennTitleTextColor};
+    font-family: ${t.fontFamily};
+  }
+
+  .venn-circle text {
+    font-size: 48px;
+    font-family: ${t.fontFamily};
+  }
+
+  .venn-intersection text {
+    font-size: 48px;
+    fill: ${t.vennSetTextColor};
+    font-family: ${t.fontFamily};
+  }
+
+  .venn-text-node {
+    font-family: ${t.fontFamily};
+    color: ${t.vennSetTextColor};
+  }
+`, "getStyles"), Ve = Be;
+function qt(t) {
+  const n = /* @__PURE__ */ new Map();
+  for (const s of t) {
+    const e = s.targets.join("|"), i = n.get(e);
+    i ? Object.assign(i, s.styles) : n.set(e, { ...s.styles });
+  }
+  return n;
+}
+S(qt, "buildStyleByKey");
+var qe = /* @__PURE__ */ S((t, n, s, e) => {
+  var V, z, q;
+  const i = e.db, r = (V = i.getConfig) == null ? void 0 : V.call(i), { themeVariables: o, look: l, handDrawnSeed: h } = St(), u = l === "handDrawn", a = [
+    o.venn1,
+    o.venn2,
+    o.venn3,
+    o.venn4,
+    o.venn5,
+    o.venn6,
+    o.venn7,
+    o.venn8
+  ].filter(Boolean), p = (z = i.getDiagramTitle) == null ? void 0 : z.call(i), d = i.getSubsetData(), m = i.getTextData(), y = qt(i.getStyleData()), M = Gt(d), E = (r == null ? void 0 : r.width) ?? 800, T = (r == null ? void 0 : r.height) ?? 450, g = E / 1600, b = p ? 48 * g : 0, v = o.primaryTextColor ?? o.textColor, c = Qt(n);
+  c.attr("viewBox", `0 0 ${E} ${T}`), p && c.append("text").text(p).attr("class", "venn-title").attr("font-size", `${32 * g}px`).attr("text-anchor", "middle").attr("dominant-baseline", "middle").attr("x", "50%").attr("y", 32 * g).style("fill", o.vennTitleTextColor || o.titleColor);
+  const x = rt(document.createElement("div")), f = ve().width(E).height(T - b);
+  x.datum(M).call(f);
+  const O = u ? $t.svg(x.select("svg").node()) : void 0, k = we(M, {
+    width: E,
+    height: T - b,
+    padding: (r == null ? void 0 : r.padding) ?? 15
+  }), R = /* @__PURE__ */ new Map();
+  for (const A of k) {
+    const F = $([...A.data.sets].sort());
+    R.set(F, A);
+  }
+  m.length > 0 && Ut(r, R, x, m, g, y);
+  const Z = te(o.background || "#f4f4f4");
+  x.selectAll(".venn-circle").each(function(A, F) {
+    var G;
+    const j = rt(this), P = $([...A.sets].sort()), _ = y.get(P), D = (_ == null ? void 0 : _.fill) || a[F % a.length] || o.primaryColor;
+    j.classed(`venn-set-${F % 8}`, !0);
+    const N = (_ == null ? void 0 : _["fill-opacity"]) ?? 0.1, Y = (_ == null ? void 0 : _.stroke) || D, I = (_ == null ? void 0 : _["stroke-width"]) || `${5 * g}`;
+    if (u && O) {
+      const J = R.get(P);
+      if (J && J.circles.length > 0) {
+        const W = J.circles[0], X = O.circle(W.x, W.y, W.radius * 2, {
+          roughness: 0.7,
+          seed: h,
+          fill: kt(D, 0.7),
+          fillStyle: "hachure",
+          fillWeight: 2,
+          hachureGap: 8,
+          hachureAngle: -41 + F * 60,
+          stroke: Y,
+          strokeWidth: parseFloat(String(I))
+        });
+        j.select("path").remove(), (G = j.node()) == null || G.insertBefore(X, j.select("text").node());
+      }
+    } else
+      j.select("path").style("fill", D).style("fill-opacity", N).style("stroke", Y).style("stroke-width", I).style("stroke-opacity", 0.95);
+    const C = (_ == null ? void 0 : _.color) || (Z ? ee(D, 30) : ne(D, 30));
+    j.select("text").style("font-size", `${48 * g}px`).style("fill", C);
+  }), u && O ? x.selectAll(".venn-intersection").each(function(A) {
+    var D;
+    const F = rt(this), L = $([...A.sets].sort()), P = y.get(L), _ = P == null ? void 0 : P.fill;
+    if (_) {
+      const N = F.select("path"), Y = N.attr("d");
+      if (Y) {
+        const I = O.path(Y, {
+          roughness: 0.7,
+          seed: h,
+          fill: kt(_, 0.3),
+          fillStyle: "cross-hatch",
+          fillWeight: 2,
+          hachureGap: 6,
+          hachureAngle: 60,
+          stroke: "none"
+        }), C = N.node();
+        (D = C == null ? void 0 : C.parentNode) == null || D.insertBefore(I, C), N.remove();
+      }
+    } else
+      F.select("path").style("fill-opacity", 0);
+    F.select("text").style("font-size", `${48 * g}px`).style("fill", (P == null ? void 0 : P.color) ?? o.vennSetTextColor ?? v);
+  }) : (x.selectAll(".venn-intersection text").style("font-size", `${48 * g}px`).style("fill", (A) => {
+    var L;
+    const j = $([...A.sets].sort());
+    return ((L = y.get(j)) == null ? void 0 : L.color) ?? o.vennSetTextColor ?? v;
+  }), x.selectAll(".venn-intersection path").style("fill-opacity", (A) => {
+    var L;
+    const j = $([...A.sets].sort());
+    return (L = y.get(j)) != null && L.fill ? 1 : 0;
+  }).style("fill", (A) => {
+    var L;
+    const j = $([...A.sets].sort());
+    return ((L = y.get(j)) == null ? void 0 : L.fill) ?? "transparent";
+  }));
+  const U = c.append("g").attr("transform", `translate(0, ${b})`), B = x.select("svg").node();
+  if (B && "childNodes" in B)
+    for (const A of [...B.childNodes])
+      (q = U.node()) == null || q.appendChild(A);
+  se(c, T, E, (r == null ? void 0 : r.useMaxWidth) ?? !0);
+}, "draw");
+function $(t) {
+  return t.join("|");
+}
+S($, "stableSetsKey");
+function Ut(t, n, s, e, i, r) {
+  var a;
+  const o = (t == null ? void 0 : t.useDebugLayout) ?? !1, h = s.select("svg").append("g").attr("class", "venn-text-nodes"), u = /* @__PURE__ */ new Map();
+  for (const p of e) {
+    const d = $(p.sets), m = u.get(d);
+    m ? m.push(p) : u.set(d, [p]);
+  }
+  for (const [p, d] of u.entries()) {
+    const m = n.get(p);
+    if (!(m != null && m.text))
+      continue;
+    const y = m.text.x, M = m.text.y, E = Math.min(...m.circles.map((V) => V.radius)), T = Math.min(
+      ...m.circles.map((V) => V.radius - Math.hypot(y - V.x, M - V.y))
+    );
+    let w = Number.isFinite(T) ? Math.max(0, T) : 0;
+    w === 0 && Number.isFinite(E) && (w = E * 0.6);
+    const g = h.append("g").attr("class", "venn-text-area").attr("font-size", `${40 * i}px`);
+    o && g.append("circle").attr("class", "venn-text-debug-circle").attr("cx", y).attr("cy", M).attr("r", w).attr("fill", "none").attr("stroke", "purple").attr("stroke-width", 1.5 * i).attr("stroke-dasharray", `${6 * i} ${4 * i}`);
+    const b = Math.max(80 * i, w * 2 * 0.95), v = Math.max(60 * i, w * 2 * 0.95), f = (m.data.label && m.data.label.length > 0 ? Math.min(32 * i, w * 0.25) : 0) + (d.length <= 2 ? 30 * i : 0), O = y - b / 2, k = M - v / 2 + f, R = Math.max(1, Math.ceil(Math.sqrt(d.length))), Z = Math.max(1, Math.ceil(d.length / R)), U = b / R, B = v / Z;
+    for (const [V, z] of d.entries()) {
+      const q = V % R, A = Math.floor(V / R), F = O + U * (q + 0.5), j = k + B * (A + 0.5);
+      o && g.append("rect").attr("class", "venn-text-debug-cell").attr("x", O + U * q).attr("y", k + B * A).attr("width", U).attr("height", B).attr("fill", "none").attr("stroke", "teal").attr("stroke-width", 1 * i).attr("stroke-dasharray", `${4 * i} ${3 * i}`);
+      const L = U * 0.9, P = B * 0.9, _ = g.append("foreignObject").attr("class", "venn-text-node-fo").attr("width", L).attr("height", P).attr("x", F - L / 2).attr("y", j - P / 2).attr("overflow", "visible"), D = (a = r.get(z.id)) == null ? void 0 : a.color, N = _.append("xhtml:span").attr("class", "venn-text-node").style("display", "flex").style("width", "100%").style("height", "100%").style("white-space", "normal").style("align-items", "center").style("justify-content", "center").style("text-align", "center").style("overflow-wrap", "normal").style("word-break", "normal").text(z.label ?? z.id);
+      D && N.style("color", D);
+    }
+  }
+}
+S(Ut, "renderTextNodes");
+function Gt(t) {
+  const n = new Set(t.map((i) => [...i.sets].sort().join("|"))), s = new Map(
+    t.filter((i) => i.sets.length === 1 && i.size !== void 0).map((i) => [i.sets[0], i.size])
+  ), e = [];
+  for (const i of t) {
+    if (i.sets.length < 3)
+      continue;
+    const r = [...i.sets].sort();
+    for (let o = 0; o < r.length - 1; o++)
+      for (let l = o + 1; l < r.length; l++) {
+        const h = [r[o], r[l]], u = h.join("|");
+        if (!n.has(u)) {
+          n.add(u);
+          const a = s.get(h[0]), p = s.get(h[1]), d = a !== void 0 && p !== void 0 ? Math.min(a, p) / 4 : 2.5;
+          e.push({ sets: h, size: d, label: "" });
+        }
+      }
+  }
+  return e.length > 0 ? [...t, ...e] : t;
+}
+S(Gt, "ensurePairwiseSubsets");
+var Ue = { draw: qe }, We = {
+  parser: Se,
+  db: Pe,
+  renderer: Ue,
+  styles: Ve
+};
+export {
+  We as diagram
+};