@marimo-team/islands 0.23.17-dev54 → 0.23.17-dev56

package/dist/vennDiagram-T6HMQDX7-CTyzMewS.js

@@ -0,0 +1,1913 @@
+import "./purify.es-DR5PNXwx.js";
+import { a as cleanAndMerge } from "./chunk-NSK5VX7P-BmmoJBbx.js";
+import { t as select_default } from "./src-BwVZVGyf.js";
+import { n as __name } from "./chunk-Y2CYZVJY-DX3DSigL.js";
+import { $ as darken_default, H as setAccDescription, K as setDiagramTitle, U as setAccTitle, a as clear, b as getConfig, c as configureSvgSize, et as lighten_default, f as defaultConfig_default, nt as is_dark_default, tt as adjust_channel_default, v as getAccDescription, w as getDiagramTitle, y as getAccTitle } from "./chunk-I66GZJ75-9xAsFrdW.js";
+import { t as selectSvgElement } from "./chunk-3NCLNEKW-BPlp8K7N.js";
+import "./dist-HaLHv0k5.js";
+import { t as at } from "./rough.esm-lGyFQ0B-.js";
+var transparentize_default = (e, g) => adjust_channel_default(e, "a", -g), SMALL$1 = 1e-10;
+function intersectionArea(e, g) {
+  let _ = getIntersectionPoints(e), v = _.filter((g2) => containedInCircles(g2, e)), y = 0, b = 0, x = [];
+  if (v.length > 1) {
+    let g2 = getCenter(v);
+    for (let e2 = 0; e2 < v.length; ++e2) {
+      let _3 = v[e2];
+      _3.angle = Math.atan2(_3.x - g2.x, _3.y - g2.y);
+    }
+    v.sort((e2, g3) => g3.angle - e2.angle);
+    let _2 = v[v.length - 1];
+    for (let g3 = 0; g3 < v.length; ++g3) {
+      let S = v[g3];
+      b += (_2.x + S.x) * (S.y - _2.y);
+      let C = {
+        x: (S.x + _2.x) / 2,
+        y: (S.y + _2.y) / 2
+      }, w = null;
+      for (let g4 = 0; g4 < S.parentIndex.length; ++g4) if (_2.parentIndex.includes(S.parentIndex[g4])) {
+        let v2 = e[S.parentIndex[g4]], y2 = Math.atan2(S.x - v2.x, S.y - v2.y), b2 = Math.atan2(_2.x - v2.x, _2.y - v2.y), x2 = b2 - y2;
+        x2 < 0 && (x2 += 2 * Math.PI);
+        let T = b2 - x2 / 2, E = distance(C, {
+          x: v2.x + v2.radius * Math.sin(T),
+          y: v2.y + v2.radius * Math.cos(T)
+        });
+        E > v2.radius * 2 && (E = v2.radius * 2), (w == null || w.width > E) && (w = {
+          circle: v2,
+          width: E,
+          p1: S,
+          p2: _2,
+          large: E > v2.radius,
+          sweep: true
+        });
+      }
+      w != null && (x.push(w), y += circleArea(w.circle.radius, w.width), _2 = S);
+    }
+  } else {
+    let g2 = e[0];
+    for (let _3 = 1; _3 < e.length; ++_3) e[_3].radius < g2.radius && (g2 = e[_3]);
+    let _2 = false;
+    for (let v2 = 0; v2 < e.length; ++v2) if (distance(e[v2], g2) > Math.abs(g2.radius - e[v2].radius)) {
+      _2 = true;
+      break;
+    }
+    _2 ? y = b = 0 : (y = g2.radius * g2.radius * Math.PI, x.push({
+      circle: g2,
+      p1: {
+        x: g2.x,
+        y: g2.y + g2.radius
+      },
+      p2: {
+        x: g2.x - SMALL$1,
+        y: g2.y + g2.radius
+      },
+      width: g2.radius * 2,
+      large: true,
+      sweep: true
+    }));
+  }
+  return b /= 2, g && (g.area = y + b, g.arcArea = y, g.polygonArea = b, g.arcs = x, g.innerPoints = v, g.intersectionPoints = _), y + b;
+}
+function containedInCircles(e, g) {
+  return g.every((g2) => distance(e, g2) < g2.radius + SMALL$1);
+}
+function getIntersectionPoints(e) {
+  let g = [];
+  for (let _ = 0; _ < e.length; ++_) for (let v = _ + 1; v < e.length; ++v) {
+    let y = circleCircleIntersection(e[_], e[v]);
+    for (let e2 of y) e2.parentIndex = [_, v], g.push(e2);
+  }
+  return g;
+}
+function circleArea(e, g) {
+  return e * e * Math.acos(1 - g / e) - (e - g) * Math.sqrt(g * (2 * e - g));
+}
+function distance(e, g) {
+  return Math.sqrt((e.x - g.x) * (e.x - g.x) + (e.y - g.y) * (e.y - g.y));
+}
+function circleOverlap(e, g, _) {
+  if (_ >= e + g) return 0;
+  if (_ <= Math.abs(e - g)) return Math.PI * Math.min(e, g) * Math.min(e, g);
+  let v = e - (_ * _ - g * g + e * e) / (2 * _), y = g - (_ * _ - e * e + g * g) / (2 * _);
+  return circleArea(e, v) + circleArea(g, y);
+}
+function circleCircleIntersection(e, g) {
+  let _ = distance(e, g), v = e.radius, y = g.radius;
+  if (_ >= v + y || _ <= Math.abs(v - y)) return [];
+  let b = (v * v - y * y + _ * _) / (2 * _), x = Math.sqrt(v * v - b * b), S = e.x + b * (g.x - e.x) / _, C = e.y + b * (g.y - e.y) / _, w = -(g.y - e.y) * (x / _), T = -(g.x - e.x) * (x / _);
+  return [{
+    x: S + w,
+    y: C - T
+  }, {
+    x: S - w,
+    y: C + T
+  }];
+}
+function getCenter(e) {
+  let g = {
+    x: 0,
+    y: 0
+  };
+  for (let _ of e) g.x += _.x, g.y += _.y;
+  return g.x /= e.length, g.y /= e.length, g;
+}
+function bisect(e, g, _, v) {
+  v || (v = {});
+  let y = v.maxIterations || 100, b = v.tolerance || 1e-10, x = e(g), S = e(_), C = _ - g;
+  if (x * S > 0) throw "Initial bisect points must have opposite signs";
+  if (x === 0) return g;
+  if (S === 0) return _;
+  for (let _2 = 0; _2 < y; ++_2) {
+    C /= 2;
+    let _3 = g + C, v2 = e(_3);
+    if (v2 * x >= 0 && (g = _3), Math.abs(C) < b || v2 === 0) return _3;
+  }
+  return g + C;
+}
+function zeros(e) {
+  let g = Array(e);
+  for (let _ = 0; _ < e; ++_) g[_] = 0;
+  return g;
+}
+function zerosM(e, g) {
+  return zeros(e).map(() => zeros(g));
+}
+function dot(e, g) {
+  let _ = 0;
+  for (let v = 0; v < e.length; ++v) _ += e[v] * g[v];
+  return _;
+}
+function norm2(e) {
+  return Math.sqrt(dot(e, e));
+}
+function scale(e, g, _) {
+  for (let v = 0; v < g.length; ++v) e[v] = g[v] * _;
+}
+function weightedSum(e, g, _, v, y) {
+  for (let b = 0; b < e.length; ++b) e[b] = g * _[b] + v * y[b];
+}
+function nelderMead(e, g, _) {
+  _ || (_ = {});
+  let v = _.maxIterations || g.length * 200, y = _.nonZeroDelta || 1.05, b = _.zeroDelta || 1e-3, x = _.minErrorDelta || 1e-6, S = _.minErrorDelta || 1e-5, C = _.rho === void 0 ? 1 : _.rho, w = _.chi === void 0 ? 2 : _.chi, T = _.psi === void 0 ? -0.5 : _.psi, E = _.sigma === void 0 ? 0.5 : _.sigma, D, O = g.length, k = Array(O + 1);
+  k[0] = g, k[0].fx = e(g), k[0].id = 0;
+  for (let _2 = 0; _2 < O; ++_2) {
+    let v2 = g.slice();
+    v2[_2] = v2[_2] ? v2[_2] * y : b, k[_2 + 1] = v2, k[_2 + 1].fx = e(v2), k[_2 + 1].id = _2 + 1;
+  }
+  function A(e2) {
+    for (let g2 = 0; g2 < e2.length; g2++) k[O][g2] = e2[g2];
+    k[O].fx = e2.fx;
+  }
+  let j = (e2, g2) => e2.fx - g2.fx, M = g.slice(), N = g.slice(), P = g.slice(), F = g.slice();
+  for (let g2 = 0; g2 < v; ++g2) {
+    if (k.sort(j), _.history) {
+      let e2 = k.map((e3) => {
+        let g4 = e3.slice();
+        return g4.fx = e3.fx, g4.id = e3.id, g4;
+      });
+      e2.sort((e3, g4) => e3.id - g4.id), _.history.push({
+        x: k[0].slice(),
+        fx: k[0].fx,
+        simplex: e2
+      });
+    }
+    D = 0;
+    for (let e2 = 0; e2 < O; ++e2) D = Math.max(D, Math.abs(k[0][e2] - k[1][e2]));
+    if (Math.abs(k[0].fx - k[O].fx) < x && D < S) break;
+    for (let e2 = 0; e2 < O; ++e2) {
+      M[e2] = 0;
+      for (let g4 = 0; g4 < O; ++g4) M[e2] += k[g4][e2];
+      M[e2] /= O;
+    }
+    let g3 = k[O];
+    if (weightedSum(N, 1 + C, M, -C, g3), N.fx = e(N), N.fx < k[0].fx) weightedSum(F, 1 + w, M, -w, g3), F.fx = e(F), F.fx < N.fx ? A(F) : A(N);
+    else if (N.fx >= k[O - 1].fx) {
+      let _2 = false;
+      if (N.fx > g3.fx ? (weightedSum(P, 1 + T, M, -T, g3), P.fx = e(P), P.fx < g3.fx ? A(P) : _2 = true) : (weightedSum(P, 1 - T * C, M, T * C, g3), P.fx = e(P), P.fx < N.fx ? A(P) : _2 = true), _2) {
+        if (E >= 1) break;
+        for (let g4 = 1; g4 < k.length; ++g4) weightedSum(k[g4], 1 - E, k[0], E, k[g4]), k[g4].fx = e(k[g4]);
+      }
+    } else A(N);
+  }
+  return k.sort(j), {
+    fx: k[0].fx,
+    x: k[0]
+  };
+}
+function wolfeLineSearch(e, g, _, v, y, b, x) {
+  let S = _.fx, C = dot(_.fxprime, g), w = S, T = S, E = C, D = 0;
+  y || (y = 1), b || (b = 1e-6), x || (x = 0.1);
+  function O(T2, D2, O2) {
+    for (let k = 0; k < 16; ++k) if (y = (T2 + D2) / 2, weightedSum(v.x, 1, _.x, y, g), w = v.fx = e(v.x, v.fxprime), E = dot(v.fxprime, g), w > S + b * y * C || w >= O2) D2 = y;
+    else {
+      if (Math.abs(E) <= -x * C) return y;
+      E * (D2 - T2) >= 0 && (D2 = T2), T2 = y, O2 = w;
+    }
+    return 0;
+  }
+  for (let k = 0; k < 10; ++k) {
+    if (weightedSum(v.x, 1, _.x, y, g), w = v.fx = e(v.x, v.fxprime), E = dot(v.fxprime, g), w > S + b * y * C || k && w >= T) return O(D, y, T);
+    if (Math.abs(E) <= -x * C) return y;
+    if (E >= 0) return O(y, D, w);
+    T = w, D = y, y *= 2;
+  }
+  return y;
+}
+function conjugateGradient(e, g, _) {
+  let v = {
+    x: g.slice(),
+    fx: 0,
+    fxprime: g.slice()
+  }, y = {
+    x: g.slice(),
+    fx: 0,
+    fxprime: g.slice()
+  }, b = g.slice(), x, S, C = 1, w;
+  _ || (_ = {}), w = _.maxIterations || g.length * 20, v.fx = e(v.x, v.fxprime), x = v.fxprime.slice(), scale(x, v.fxprime, -1);
+  for (let g2 = 0; g2 < w; ++g2) {
+    if (C = wolfeLineSearch(e, x, v, y, C), _.history && _.history.push({
+      x: v.x.slice(),
+      fx: v.fx,
+      fxprime: v.fxprime.slice(),
+      alpha: C
+    }), !C) scale(x, v.fxprime, -1);
+    else {
+      weightedSum(b, 1, y.fxprime, -1, v.fxprime);
+      let e2 = dot(v.fxprime, v.fxprime), g3 = Math.max(0, dot(b, y.fxprime) / e2);
+      weightedSum(x, g3, x, -1, y.fxprime), S = v, v = y, y = S;
+    }
+    if (norm2(v.fxprime) <= 1e-5) break;
+  }
+  return _.history && _.history.push({
+    x: v.x.slice(),
+    fx: v.fx,
+    fxprime: v.fxprime.slice(),
+    alpha: C
+  }), v;
+}
+function venn(e, g = {}) {
+  g.maxIterations = g.maxIterations || 500;
+  let _ = g.initialLayout || bestInitialLayout, v = g.lossFunction || lossFunction, y = addMissingAreas(e, g), b = _(y, g), x = Object.keys(b), S = [];
+  for (let e2 of x) S.push(b[e2].x), S.push(b[e2].y);
+  let C = nelderMead((e2) => {
+    let g2 = {};
+    for (let _2 = 0; _2 < x.length; ++_2) {
+      let v2 = x[_2];
+      g2[v2] = {
+        x: e2[2 * _2],
+        y: e2[2 * _2 + 1],
+        radius: b[v2].radius
+      };
+    }
+    return v(g2, y);
+  }, S, g).x;
+  for (let e2 = 0; e2 < x.length; ++e2) {
+    let g2 = x[e2];
+    b[g2].x = C[2 * e2], b[g2].y = C[2 * e2 + 1];
+  }
+  return b;
+}
+var SMALL = 1e-10;
+function distanceFromIntersectArea(e, g, _) {
+  return Math.min(e, g) * Math.min(e, g) * Math.PI <= _ + SMALL ? Math.abs(e - g) : bisect((v) => circleOverlap(e, g, v) - _, 0, e + g);
+}
+function addMissingAreas(e, g = {}) {
+  let _ = g.distinct, v = e.map((e2) => Object.assign({}, e2));
+  function y(e2) {
+    return e2.join(";");
+  }
+  if (_) {
+    let e2 = /* @__PURE__ */ new Map();
+    for (let g2 of v) for (let _2 = 0; _2 < g2.sets.length; _2++) {
+      let v2 = String(g2.sets[_2]);
+      e2.set(v2, g2.size + (e2.get(v2) || 0));
+      for (let y2 = _2 + 1; y2 < g2.sets.length; y2++) {
+        let _3 = String(g2.sets[y2]), b2 = `${v2};${_3}`, x2 = `${_3};${v2}`;
+        e2.set(b2, g2.size + (e2.get(b2) || 0)), e2.set(x2, g2.size + (e2.get(x2) || 0));
+      }
+    }
+    for (let g2 of v) g2.sets.length < 3 && (g2.size = e2.get(y(g2.sets)));
+  }
+  let b = [], x = /* @__PURE__ */ new Set();
+  for (let e2 of v) if (e2.sets.length === 1) b.push(e2.sets[0]);
+  else if (e2.sets.length === 2) {
+    let g2 = e2.sets[0], _2 = e2.sets[1];
+    x.add(y(e2.sets)), x.add(y([_2, g2]));
+  }
+  b.sort((e2, g2) => e2 === g2 ? 0 : e2 < g2 ? -1 : 1);
+  for (let e2 = 0; e2 < b.length; ++e2) {
+    let g2 = b[e2];
+    for (let _2 = e2 + 1; _2 < b.length; ++_2) {
+      let e3 = b[_2];
+      x.has(y([g2, e3])) || v.push({
+        sets: [g2, e3],
+        size: 0
+      });
+    }
+  }
+  return v;
+}
+function getDistanceMatrices(e, g, _) {
+  let v = zerosM(g.length, g.length), y = zerosM(g.length, g.length);
+  return e.filter((e2) => e2.sets.length === 2).forEach((e2) => {
+    let b = _[e2.sets[0]], x = _[e2.sets[1]], S = distanceFromIntersectArea(Math.sqrt(g[b].size / Math.PI), Math.sqrt(g[x].size / Math.PI), e2.size);
+    v[b][x] = v[x][b] = S;
+    let C = 0;
+    e2.size + 1e-10 >= Math.min(g[b].size, g[x].size) ? C = 1 : e2.size <= 1e-10 && (C = -1), y[b][x] = y[x][b] = C;
+  }), {
+    distances: v,
+    constraints: y
+  };
+}
+function constrainedMDSGradient(e, g, _, v) {
+  for (let e2 = 0; e2 < g.length; ++e2) g[e2] = 0;
+  let y = 0;
+  for (let b = 0; b < _.length; ++b) {
+    let x = e[2 * b], S = e[2 * b + 1];
+    for (let C = b + 1; C < _.length; ++C) {
+      let w = e[2 * C], T = e[2 * C + 1], E = _[b][C], D = v[b][C], O = (w - x) * (w - x) + (T - S) * (T - S), k = Math.sqrt(O), A = O - E * E;
+      D > 0 && k <= E || D < 0 && k >= E || (y += 2 * A * A, g[2 * b] += 4 * A * (x - w), g[2 * b + 1] += 4 * A * (S - T), g[2 * C] += 4 * A * (w - x), g[2 * C + 1] += 4 * A * (T - S));
+    }
+  }
+  return y;
+}
+function bestInitialLayout(e, g = {}) {
+  let _ = greedyLayout(e, g), v = g.lossFunction || lossFunction;
+  if (e.length >= 8) {
+    let y = constrainedMDSLayout(e, g), b = v(y, e), x = v(_, e);
+    b + 1e-8 < x && (_ = y);
+  }
+  return _;
+}
+function constrainedMDSLayout(e, g = {}) {
+  let _ = g.restarts || 10, v = [], y = {};
+  for (let g2 of e) g2.sets.length === 1 && (y[g2.sets[0]] = v.length, v.push(g2));
+  let { distances: b, constraints: x } = getDistanceMatrices(e, v, y), S = norm2(b.map(norm2)) / b.length;
+  b = b.map((e2) => e2.map((e3) => e3 / S));
+  let C = (e2, g2) => constrainedMDSGradient(e2, g2, b, x), w = null;
+  for (let e2 = 0; e2 < _; ++e2) {
+    let e3 = conjugateGradient(C, zeros(b.length * 2).map(Math.random), g);
+    (!w || e3.fx < w.fx) && (w = e3);
+  }
+  let T = w.x, E = {};
+  for (let e2 = 0; e2 < v.length; ++e2) {
+    let g2 = v[e2];
+    E[g2.sets[0]] = {
+      x: T[2 * e2] * S,
+      y: T[2 * e2 + 1] * S,
+      radius: Math.sqrt(g2.size / Math.PI)
+    };
+  }
+  if (g.history) for (let e2 of g.history) scale(e2.x, S);
+  return E;
+}
+function greedyLayout(e, g) {
+  let _ = g && g.lossFunction ? g.lossFunction : lossFunction, v = {}, y = {};
+  for (let g2 of e) if (g2.sets.length === 1) {
+    let e2 = g2.sets[0];
+    v[e2] = {
+      x: 1e10,
+      y: 1e10,
+      rowid: v.length,
+      size: g2.size,
+      radius: Math.sqrt(g2.size / Math.PI)
+    }, y[e2] = [];
+  }
+  e = e.filter((e2) => e2.sets.length === 2);
+  for (let g2 of e) {
+    let e2 = g2.weight == null ? 1 : g2.weight, _2 = g2.sets[0], b2 = g2.sets[1];
+    g2.size + SMALL >= Math.min(v[_2].size, v[b2].size) && (e2 = 0), y[_2].push({
+      set: b2,
+      size: g2.size,
+      weight: e2
+    }), y[b2].push({
+      set: _2,
+      size: g2.size,
+      weight: e2
+    });
+  }
+  let b = [];
+  Object.keys(y).forEach((e2) => {
+    let g2 = 0;
+    for (let _2 = 0; _2 < y[e2].length; ++_2) g2 += y[e2][_2].size * y[e2][_2].weight;
+    b.push({
+      set: e2,
+      size: g2
+    });
+  });
+  function x(e2, g2) {
+    return g2.size - e2.size;
+  }
+  b.sort(x);
+  let S = {};
+  function C(e2) {
+    return e2.set in S;
+  }
+  function w(e2, g2) {
+    v[g2].x = e2.x, v[g2].y = e2.y, S[g2] = true;
+  }
+  w({
+    x: 0,
+    y: 0
+  }, b[0].set);
+  for (let g2 = 1; g2 < b.length; ++g2) {
+    let S2 = b[g2].set, E = y[S2].filter(C), D = v[S2];
+    if (E.sort(x), E.length === 0) throw "ERROR: missing pairwise overlap information";
+    let O = [];
+    for (var T = 0; T < E.length; ++T) {
+      let e2 = v[E[T].set], g3 = distanceFromIntersectArea(D.radius, e2.radius, E[T].size);
+      O.push({
+        x: e2.x + g3,
+        y: e2.y
+      }), O.push({
+        x: e2.x - g3,
+        y: e2.y
+      }), O.push({
+        y: e2.y + g3,
+        x: e2.x
+      }), O.push({
+        y: e2.y - g3,
+        x: e2.x
+      });
+      for (let _2 = T + 1; _2 < E.length; ++_2) {
+        let y2 = v[E[_2].set], b2 = distanceFromIntersectArea(D.radius, y2.radius, E[_2].size), x2 = circleCircleIntersection({
+          x: e2.x,
+          y: e2.y,
+          radius: g3
+        }, {
+          x: y2.x,
+          y: y2.y,
+          radius: b2
+        });
+        O.push(...x2);
+      }
+    }
+    let k = 1e50, A = O[0];
+    for (let g3 of O) {
+      v[S2].x = g3.x, v[S2].y = g3.y;
+      let y2 = _(v, e);
+      y2 < k && (k = y2, A = g3);
+    }
+    w(A, S2);
+  }
+  return v;
+}
+function lossFunction(e, g) {
+  let _ = 0;
+  for (let v of g) {
+    if (v.sets.length === 1) continue;
+    let g2;
+    if (v.sets.length === 2) {
+      let _2 = e[v.sets[0]], y2 = e[v.sets[1]];
+      g2 = circleOverlap(_2.radius, y2.radius, distance(_2, y2));
+    } else g2 = intersectionArea(v.sets.map((g3) => e[g3]));
+    let y = v.weight == null ? 1 : v.weight;
+    _ += y * (g2 - v.size) * (g2 - v.size);
+  }
+  return _;
+}
+function logRatioLossFunction(e, g) {
+  let _ = 0;
+  for (let v of g) {
+    if (v.sets.length === 1) continue;
+    let g2;
+    if (v.sets.length === 2) {
+      let _2 = e[v.sets[0]], y2 = e[v.sets[1]];
+      g2 = circleOverlap(_2.radius, y2.radius, distance(_2, y2));
+    } else g2 = intersectionArea(v.sets.map((g3) => e[g3]));
+    let y = v.weight == null ? 1 : v.weight, b = Math.log((g2 + 1) / (v.size + 1));
+    _ += y * b * b;
+  }
+  return _;
+}
+function orientateCircles(e, g, _) {
+  if (_ == null ? e.sort((e2, g2) => g2.radius - e2.radius) : e.sort(_), e.length > 0) {
+    let g2 = e[0].x, _2 = e[0].y;
+    for (let v2 of e) v2.x -= g2, v2.y -= _2;
+  }
+  if (e.length === 2 && distance(e[0], e[1]) < Math.abs(e[1].radius - e[0].radius) && (e[1].x = e[0].x + e[0].radius - e[1].radius - 1e-10, e[1].y = e[0].y), e.length > 1) {
+    let _2 = Math.atan2(e[1].x, e[1].y) - g, v2 = Math.cos(_2), y = Math.sin(_2);
+    for (let g2 of e) {
+      let e2 = g2.x, _3 = g2.y;
+      g2.x = v2 * e2 - y * _3, g2.y = y * e2 + v2 * _3;
+    }
+  }
+  if (e.length > 2) {
+    let _2 = Math.atan2(e[2].x, e[2].y) - g;
+    for (; _2 < 0; ) _2 += 2 * Math.PI;
+    for (; _2 > 2 * Math.PI; ) _2 -= 2 * Math.PI;
+    if (_2 > Math.PI) {
+      let g2 = e[1].y / (1e-10 + e[1].x);
+      for (let _3 of e) {
+        var v = (_3.x + g2 * _3.y) / (1 + g2 * g2);
+        _3.x = 2 * v - _3.x, _3.y = 2 * v * g2 - _3.y;
+      }
+    }
+  }
+}
+function disjointCluster(e) {
+  e.forEach((e2) => {
+    e2.parent = e2;
+  });
+  function g(e2) {
+    return e2.parent !== e2 && (e2.parent = g(e2.parent)), e2.parent;
+  }
+  function _(e2, _2) {
+    let v2 = g(e2);
+    v2.parent = g(_2);
+  }
+  for (let g2 = 0; g2 < e.length; ++g2) for (let v2 = g2 + 1; v2 < e.length; ++v2) {
+    let y = e[g2].radius + e[v2].radius;
+    distance(e[g2], e[v2]) + 1e-10 < y && _(e[v2], e[g2]);
+  }
+  let v = /* @__PURE__ */ new Map();
+  for (let _2 = 0; _2 < e.length; ++_2) {
+    let y = g(e[_2]).parent.setid;
+    v.has(y) || v.set(y, []), v.get(y).push(e[_2]);
+  }
+  return e.forEach((e2) => {
+    delete e2.parent;
+  }), Array.from(v.values());
+}
+function getBoundingBox(e) {
+  let g = (g2) => ({
+    max: e.reduce((e2, _) => Math.max(e2, _[g2] + _.radius), -Infinity),
+    min: e.reduce((e2, _) => Math.min(e2, _[g2] - _.radius), Infinity)
+  });
+  return {
+    xRange: g("x"),
+    yRange: g("y")
+  };
+}
+function normalizeSolution(e, g, _) {
+  g ?? (g = Math.PI / 2);
+  let v = fromObjectNotation(e).map((e2) => Object.assign({}, e2)), y = disjointCluster(v);
+  for (let e2 of y) {
+    orientateCircles(e2, g, _);
+    let v2 = getBoundingBox(e2);
+    e2.size = (v2.xRange.max - v2.xRange.min) * (v2.yRange.max - v2.yRange.min), e2.bounds = v2;
+  }
+  y.sort((e2, g2) => g2.size - e2.size), v = y[0];
+  let b = v.bounds, x = (b.xRange.max - b.xRange.min) / 50;
+  function S(e2, g2, _2) {
+    if (!e2) return;
+    let y2 = e2.bounds, S2, C2;
+    if (g2) S2 = b.xRange.max - y2.xRange.min + x;
+    else {
+      S2 = b.xRange.max - y2.xRange.max;
+      let e3 = (y2.xRange.max - y2.xRange.min) / 2 - (b.xRange.max - b.xRange.min) / 2;
+      e3 < 0 && (S2 += e3);
+    }
+    if (_2) C2 = b.yRange.max - y2.yRange.min + x;
+    else {
+      C2 = b.yRange.max - y2.yRange.max;
+      let e3 = (y2.yRange.max - y2.yRange.min) / 2 - (b.yRange.max - b.yRange.min) / 2;
+      e3 < 0 && (C2 += e3);
+    }
+    for (let g3 of e2) g3.x += S2, g3.y += C2, v.push(g3);
+  }
+  let C = 1;
+  for (; C < y.length; ) S(y[C], true, false), S(y[C + 1], false, true), S(y[C + 2], true, true), C += 3, b = getBoundingBox(v);
+  return toObjectNotation(v);
+}
+function scaleSolution(e, g, _, v, y) {
+  let b = fromObjectNotation(e);
+  g -= 2 * v, _ -= 2 * v;
+  let { xRange: x, yRange: S } = getBoundingBox(b);
+  if (x.max === x.min || S.max === S.min) return console.log("not scaling solution: zero size detected"), e;
+  let C, w;
+  if (y) {
+    let e2 = Math.sqrt(y / Math.PI) * 2;
+    C = g / e2, w = _ / e2;
+  } else C = g / (x.max - x.min), w = _ / (S.max - S.min);
+  let T = Math.min(w, C), E = (g - (x.max - x.min) * T) / 2, D = (_ - (S.max - S.min) * T) / 2;
+  return toObjectNotation(b.map((e2) => ({
+    radius: T * e2.radius,
+    x: v + E + (e2.x - x.min) * T,
+    y: v + D + (e2.y - S.min) * T,
+    setid: e2.setid
+  })));
+}
+function toObjectNotation(e) {
+  let g = {};
+  for (let _ of e) g[_.setid] = _;
+  return g;
+}
+function fromObjectNotation(e) {
+  return Object.keys(e).map((g) => Object.assign(e[g], { setid: g }));
+}
+function VennDiagram(e = {}) {
+  let g = false, _ = 600, v = 350, y = 15, b = 1e3, x = Math.PI / 2, S = true, C = null, w = true, T = true, E = null, D = null, O = false, k = null, A = e && e.symmetricalTextCentre ? e.symmetricalTextCentre : false, j = {}, M = e && e.colourScheme ? e.colourScheme : e && e.colorScheme ? e.colorScheme : [
+    "#1f77b4",
+    "#ff7f0e",
+    "#2ca02c",
+    "#d62728",
+    "#9467bd",
+    "#8c564b",
+    "#e377c2",
+    "#7f7f7f",
+    "#bcbd22",
+    "#17becf"
+  ], N = 0, P = function(e2) {
+    if (e2 in j) return j[e2];
+    var g2 = j[e2] = M[N];
+    return N += 1, N >= M.length && (N = 0), g2;
+  }, F = venn, I = lossFunction;
+  function L(j2) {
+    let M2 = j2.datum(), N2 = /* @__PURE__ */ new Set();
+    M2.forEach((e2) => {
+      e2.size == 0 && e2.sets.length == 1 && N2.add(e2.sets[0]);
+    }), M2 = M2.filter((e2) => !e2.sets.some((e3) => N2.has(e3)));
+    let L2 = {}, R = {};
+    if (M2.length > 0) {
+      let e2 = F(M2, {
+        lossFunction: I,
+        distinct: O
+      });
+      S && (e2 = normalizeSolution(e2, x, D)), L2 = scaleSolution(e2, _, v, y, C), R = computeTextCentres(L2, M2, A);
+    }
+    let z = {};
+    M2.forEach((e2) => {
+      e2.label && (z[e2.sets] = e2.label);
+    });
+    function B(e2) {
+      if (e2.sets in z) return z[e2.sets];
+      if (e2.sets.length == 1) return "" + e2.sets[0];
+    }
+    j2.selectAll("svg").data([L2]).enter().append("svg");
+    let V = j2.select("svg");
+    g ? V.attr("viewBox", `0 0 ${_} ${v}`) : V.attr("width", _).attr("height", v);
+    let H = {}, U = false;
+    V.selectAll(".venn-area path").each(function(e2) {
+      let g2 = this.getAttribute("d");
+      e2.sets.length == 1 && g2 && !O && (U = true, H[e2.sets[0]] = circleFromPath(g2));
+    });
+    function W(e2) {
+      return (g2) => intersectionAreaPath(e2.sets.map((e3) => {
+        let y2 = H[e3], b2 = L2[e3];
+        return y2 || (y2 = {
+          x: _ / 2,
+          y: v / 2,
+          radius: 1
+        }), b2 || (b2 = {
+          x: _ / 2,
+          y: v / 2,
+          radius: 1
+        }), {
+          x: y2.x * (1 - g2) + b2.x * g2,
+          y: y2.y * (1 - g2) + b2.y * g2,
+          radius: y2.radius * (1 - g2) + b2.radius * g2
+        };
+      }), k);
+    }
+    let G = V.selectAll(".venn-area").data(M2, (e2) => e2.sets), K = G.enter().append("g").attr("class", (e2) => `venn-area venn-${e2.sets.length == 1 ? "circle" : "intersection"}${e2.colour || e2.color ? " venn-coloured" : ""}`).attr("data-venn-sets", (e2) => e2.sets.join("_")), q = K.append("path"), J = K.append("text").attr("class", "label").text((e2) => B(e2)).attr("text-anchor", "middle").attr("dy", ".35em").attr("x", _ / 2).attr("y", v / 2);
+    T && (q.style("fill-opacity", "0").filter((e2) => e2.sets.length == 1).style("fill", (e2) => e2.colour ? e2.colour : e2.color ? e2.color : P(e2.sets)).style("fill-opacity", ".25"), J.style("fill", (g2) => g2.colour || g2.color ? "#FFF" : e.textFill ? e.textFill : g2.sets.length == 1 ? P(g2.sets) : "#444"));
+    function Y(e2) {
+      return typeof e2.transition == "function" ? e2.transition("venn").duration(b) : e2;
+    }
+    let X = j2;
+    U && typeof X.transition == "function" ? (X = Y(j2), X.selectAll("path").attrTween("d", W)) : X.selectAll("path").attr("d", (e2) => intersectionAreaPath(e2.sets.map((e3) => L2[e3])), k);
+    let Z = X.selectAll("text").filter((e2) => e2.sets in R).text((e2) => B(e2)).attr("x", (e2) => Math.floor(R[e2.sets].x)).attr("y", (e2) => Math.floor(R[e2.sets].y));
+    w && (U ? "on" in Z ? Z.on("end", wrapText(L2, B)) : Z.each("end", wrapText(L2, B)) : Z.each(wrapText(L2, B)));
+    let Q = Y(G.exit()).remove();
+    typeof G.transition == "function" && Q.selectAll("path").attrTween("d", W);
+    let $ = Q.selectAll("text").attr("x", _ / 2).attr("y", v / 2);
+    return E !== null && (J.style("font-size", "0px"), Z.style("font-size", E), $.style("font-size", "0px")), {
+      circles: L2,
+      textCentres: R,
+      nodes: G,
+      enter: K,
+      update: X,
+      exit: Q
+    };
+  }
+  return L.wrap = function(e2) {
+    return arguments.length ? (w = e2, L) : w;
+  }, L.useViewBox = function() {
+    return g = true, L;
+  }, L.width = function(e2) {
+    return arguments.length ? (_ = e2, L) : _;
+  }, L.height = function(e2) {
+    return arguments.length ? (v = e2, L) : v;
+  }, L.padding = function(e2) {
+    return arguments.length ? (y = e2, L) : y;
+  }, L.distinct = function(e2) {
+    return arguments.length ? (O = e2, L) : O;
+  }, L.colours = function(e2) {
+    return arguments.length ? (P = e2, L) : P;
+  }, L.colors = function(e2) {
+    return arguments.length ? (P = e2, L) : P;
+  }, L.fontSize = function(e2) {
+    return arguments.length ? (E = e2, L) : E;
+  }, L.round = function(e2) {
+    return arguments.length ? (k = e2, L) : k;
+  }, L.duration = function(e2) {
+    return arguments.length ? (b = e2, L) : b;
+  }, L.layoutFunction = function(e2) {
+    return arguments.length ? (F = e2, L) : F;
+  }, L.normalize = function(e2) {
+    return arguments.length ? (S = e2, L) : S;
+  }, L.scaleToFit = function(e2) {
+    return arguments.length ? (C = e2, L) : C;
+  }, L.styled = function(e2) {
+    return arguments.length ? (T = e2, L) : T;
+  }, L.orientation = function(e2) {
+    return arguments.length ? (x = e2, L) : x;
+  }, L.orientationOrder = function(e2) {
+    return arguments.length ? (D = e2, L) : D;
+  }, L.lossFunction = function(e2) {
+    return arguments.length ? (I = e2 === "default" ? lossFunction : e2 === "logRatio" ? logRatioLossFunction : e2, L) : I;
+  }, L;
+}
+function wrapText(e, g) {
+  return function(_) {
+    let v = this, y = e[_.sets[0]].radius || 50, b = g(_) || "", x = b.split(/\s+/).reverse(), S = (b.length + x.length) / 3, C = x.pop(), w = [C], T = 0, E = 1.1;
+    v.textContent = null;
+    let D = [];
+    function O(e2) {
+      let g2 = v.ownerDocument.createElementNS(v.namespaceURI, "tspan");
+      return g2.textContent = e2, D.push(g2), v.append(g2), g2;
+    }
+    let k = O(C);
+    for (; C = x.pop(), C; ) {
+      w.push(C);
+      let e2 = w.join(" ");
+      k.textContent = e2, e2.length > S && k.getComputedTextLength() > y && (w.pop(), k.textContent = w.join(" "), w = [C], k = O(C), T++);
+    }
+    let A = 0.35 - T * E / 2, j = v.getAttribute("x"), M = v.getAttribute("y");
+    D.forEach((e2, g2) => {
+      e2.setAttribute("x", j), e2.setAttribute("y", M), e2.setAttribute("dy", `${A + g2 * E}em`);
+    });
+  };
+}
+function circleMargin(e, g, _) {
+  let v = g[0].radius - distance(g[0], e);
+  for (let _2 = 1; _2 < g.length; ++_2) {
+    let y = g[_2].radius - distance(g[_2], e);
+    y <= v && (v = y);
+  }
+  for (let g2 = 0; g2 < _.length; ++g2) {
+    let y = distance(_[g2], e) - _[g2].radius;
+    y <= v && (v = y);
+  }
+  return v;
+}
+function computeTextCentre(e, g, _) {
+  let v = [];
+  for (let g2 of e) v.push({
+    x: g2.x,
+    y: g2.y
+  }), v.push({
+    x: g2.x + g2.radius / 2,
+    y: g2.y
+  }), v.push({
+    x: g2.x - g2.radius / 2,
+    y: g2.y
+  }), v.push({
+    x: g2.x,
+    y: g2.y + g2.radius / 2
+  }), v.push({
+    x: g2.x,
+    y: g2.y - g2.radius / 2
+  });
+  let y = v[0], b = circleMargin(v[0], e, g);
+  for (let _2 = 1; _2 < v.length; ++_2) {
+    let x2 = circleMargin(v[_2], e, g);
+    x2 >= b && (y = v[_2], b = x2);
+  }
+  let x = nelderMead((_2) => -1 * circleMargin({
+    x: _2[0],
+    y: _2[1]
+  }, e, g), [y.x, y.y], {
+    maxIterations: 500,
+    minErrorDelta: 1e-10
+  }).x, S = {
+    x: _ ? 0 : x[0],
+    y: x[1]
+  }, C = true;
+  for (let g2 of e) if (distance(S, g2) > g2.radius) {
+    C = false;
+    break;
+  }
+  for (let e2 of g) if (distance(S, e2) < e2.radius) {
+    C = false;
+    break;
+  }
+  if (C) return S;
+  if (e.length == 1) return {
+    x: e[0].x,
+    y: e[0].y
+  };
+  let w = {};
+  return intersectionArea(e, w), w.arcs.length === 0 ? {
+    x: 0,
+    y: -1e3,
+    disjoint: true
+  } : w.arcs.length == 1 ? {
+    x: w.arcs[0].circle.x,
+    y: w.arcs[0].circle.y
+  } : g.length ? computeTextCentre(e, []) : getCenter(w.arcs.map((e2) => e2.p1));
+}
+function getOverlappingCircles(e) {
+  let g = {}, _ = Object.keys(e);
+  for (let e2 of _) g[e2] = [];
+  for (let v = 0; v < _.length; v++) {
+    let y = _[v], b = e[y];
+    for (let x = v + 1; x < _.length; ++x) {
+      let v2 = _[x], S = e[v2], C = distance(b, S);
+      C + S.radius <= b.radius + 1e-10 ? g[v2].push(y) : C + b.radius <= S.radius + 1e-10 && g[y].push(v2);
+    }
+  }
+  return g;
+}
+function computeTextCentres(e, g, _) {
+  let v = {}, y = getOverlappingCircles(e);
+  for (let b = 0; b < g.length; ++b) {
+    let x = g[b].sets, S = {}, C = {};
+    for (let e2 = 0; e2 < x.length; ++e2) {
+      S[x[e2]] = true;
+      let g2 = y[x[e2]];
+      for (let e3 = 0; e3 < g2.length; ++e3) C[g2[e3]] = true;
+    }
+    let w = [], T = [];
+    for (let g2 in e) g2 in S ? w.push(e[g2]) : g2 in C || T.push(e[g2]);
+    let E = computeTextCentre(w, T, _);
+    v[x] = E, E.disjoint && g[b].size > 0 && console.log("WARNING: area " + x + " not represented on screen");
+  }
+  return v;
+}
+function circlePath(e, g, _) {
+  let v = [];
+  return v.push("\nM", e, g), v.push("\nm", -_, 0), v.push("\na", _, _, 0, 1, 0, _ * 2, 0), v.push("\na", _, _, 0, 1, 0, -_ * 2, 0), v.join(" ");
+}
+function circleFromPath(e) {
+  let g = e.split(" ");
+  return {
+    x: Number.parseFloat(g[1]),
+    y: Number.parseFloat(g[2]),
+    radius: -Number.parseFloat(g[4])
+  };
+}
+function intersectionAreaArcs(e) {
+  if (e.length === 0) return [];
+  let g = {};
+  return intersectionArea(e, g), g.arcs;
+}
+function arcsToPath(e, g) {
+  if (e.length === 0) return "M 0 0";
+  let _ = 10 ** (g || 0), v = g == null ? (e2) => e2 : (e2) => Math.round(e2 * _) / _;
+  if (e.length == 1) {
+    let g2 = e[0].circle;
+    return circlePath(v(g2.x), v(g2.y), v(g2.radius));
+  }
+  let y = [
+    "\nM",
+    v(e[0].p2.x),
+    v(e[0].p2.y)
+  ];
+  for (let g2 of e) {
+    let e2 = v(g2.circle.radius);
+    y.push("\nA", e2, e2, 0, g2.large ? 1 : 0, g2.sweep ? 1 : 0, v(g2.p1.x), v(g2.p1.y));
+  }
+  return y.join(" ");
+}
+function intersectionAreaPath(e, g) {
+  return arcsToPath(intersectionAreaArcs(e), g);
+}
+function layout(e, g = {}) {
+  let { lossFunction: _, layoutFunction: v = venn, normalize: y = true, orientation: b = Math.PI / 2, orientationOrder: x, width: S = 600, height: C = 350, padding: w = 15, scaleToFit: T = false, symmetricalTextCentre: E = false, distinct: D, round: O = 2 } = g, k = v(e, {
+    lossFunction: _ === "default" || !_ ? lossFunction : _ === "logRatio" ? logRatioLossFunction : _,
+    distinct: D
+  });
+  y && (k = normalizeSolution(k, b, x));
+  let A = scaleSolution(k, S, C, w, T), j = computeTextCentres(A, e, E), M = new Map(Object.keys(A).map((e2) => [e2, {
+    set: e2,
+    x: A[e2].x,
+    y: A[e2].y,
+    radius: A[e2].radius
+  }])), N = e.map((e2) => {
+    let g2 = e2.sets.map((e3) => M.get(e3)), _2 = intersectionAreaArcs(g2);
+    return {
+      circles: g2,
+      arcs: _2,
+      path: arcsToPath(_2, O),
+      area: e2,
+      has: new Set(e2.sets)
+    };
+  });
+  function P(e2) {
+    let g2 = "";
+    for (let _2 of N) _2.has.size > e2.length && e2.every((e3) => _2.has.has(e3)) && (g2 += " " + _2.path);
+    return g2;
+  }
+  return N.map(({ circles: e2, arcs: g2, path: _2, area: v2 }) => ({
+    data: v2,
+    text: j[v2.sets],
+    circles: e2,
+    arcs: g2,
+    path: _2,
+    distinctPath: _2 + P(v2.sets)
+  }));
+}
+var parser = (function() {
+  var e = /* @__PURE__ */ __name(function(e2, g2, _, v2) {
+    for (_ || (_ = {}), v2 = e2.length; v2--; _[e2[v2]] = g2) ;
+    return _;
+  }, "o"), g = [5, 8], v = [
+    7,
+    8,
+    11,
+    12,
+    17,
+    19,
+    22,
+    24
+  ], y = [1, 17], b = [1, 18], x = [
+    7,
+    8,
+    11,
+    12,
+    14,
+    15,
+    16,
+    17,
+    19,
+    20,
+    21,
+    22,
+    24,
+    27
+  ], S = [1, 31], C = [1, 39], w = [
+    7,
+    8,
+    11,
+    12,
+    17,
+    19,
+    22,
+    24,
+    27
+  ], T = [1, 57], E = [1, 56], D = [1, 58], O = [1, 59], k = [1, 60], A = [
+    7,
+    8,
+    11,
+    12,
+    16,
+    17,
+    19,
+    20,
+    22,
+    24,
+    27,
+    31,
+    32,
+    33
+  ], j = {
+    trace: /* @__PURE__ */ __name(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__ */ __name(function(e2, g2, _, v2, y2, b2, x2) {
+      var S2 = b2.length - 1;
+      switch (y2) {
+        case 1:
+          return b2[S2 - 1];
+        case 2:
+        case 3:
+        case 4:
+          this.$ = [];
+          break;
+        case 5:
+          b2[S2 - 1].push(b2[S2]), this.$ = b2[S2 - 1];
+          break;
+        case 6:
+          this.$ = [];
+          break;
+        case 7:
+        case 22:
+        case 32:
+        case 36:
+        case 37:
+        case 38:
+        case 39:
+        case 40:
+          this.$ = b2[S2];
+          break;
+        case 8:
+          v2.setDiagramTitle(b2[S2].substr(6)), this.$ = b2[S2].substr(6);
+          break;
+        case 9:
+          v2.addSubsetData([b2[S2]], void 0, void 0), v2.setIndentMode && v2.setIndentMode(true);
+          break;
+        case 10:
+          v2.addSubsetData([b2[S2 - 1]], b2[S2], void 0), v2.setIndentMode && v2.setIndentMode(true);
+          break;
+        case 11:
+          v2.addSubsetData([b2[S2 - 2]], void 0, parseFloat(b2[S2])), v2.setIndentMode && v2.setIndentMode(true);
+          break;
+        case 12:
+          v2.addSubsetData([b2[S2 - 3]], b2[S2 - 2], parseFloat(b2[S2])), v2.setIndentMode && v2.setIndentMode(true);
+          break;
+        case 13:
+          if (b2[S2].length < 2) throw Error("union requires multiple identifiers");
+          v2.validateUnionIdentifiers && v2.validateUnionIdentifiers(b2[S2]), v2.addSubsetData(b2[S2], void 0, void 0), v2.setIndentMode && v2.setIndentMode(true);
+          break;
+        case 14:
+          if (b2[S2 - 1].length < 2) throw Error("union requires multiple identifiers");
+          v2.validateUnionIdentifiers && v2.validateUnionIdentifiers(b2[S2 - 1]), v2.addSubsetData(b2[S2 - 1], b2[S2], void 0), v2.setIndentMode && v2.setIndentMode(true);
+          break;
+        case 15:
+          if (b2[S2 - 2].length < 2) throw Error("union requires multiple identifiers");
+          v2.validateUnionIdentifiers && v2.validateUnionIdentifiers(b2[S2 - 2]), v2.addSubsetData(b2[S2 - 2], void 0, parseFloat(b2[S2])), v2.setIndentMode && v2.setIndentMode(true);
+          break;
+        case 16:
+          if (b2[S2 - 3].length < 2) throw Error("union requires multiple identifiers");
+          v2.validateUnionIdentifiers && v2.validateUnionIdentifiers(b2[S2 - 3]), v2.addSubsetData(b2[S2 - 3], b2[S2 - 2], parseFloat(b2[S2])), v2.setIndentMode && v2.setIndentMode(true);
+          break;
+        case 17:
+        case 18:
+        case 19:
+          v2.addTextData(b2[S2 - 1], b2[S2], void 0);
+          break;
+        case 20:
+        case 21:
+          v2.addTextData(b2[S2 - 2], b2[S2 - 1], b2[S2]);
+          break;
+        case 23:
+          v2.addStyleData(b2[S2 - 1], b2[S2]);
+          break;
+        case 24:
+        case 25:
+        case 26:
+          var C2 = v2.getCurrentSets();
+          if (!C2) throw Error("text requires set");
+          v2.addTextData(C2, b2[S2], void 0);
+          break;
+        case 27:
+        case 28:
+          var C2 = v2.getCurrentSets();
+          if (!C2) throw Error("text requires set");
+          v2.addTextData(C2, b2[S2 - 1], b2[S2]);
+          break;
+        case 29:
+        case 41:
+          this.$ = [b2[S2]];
+          break;
+        case 30:
+        case 42:
+          this.$ = [...b2[S2 - 2], b2[S2]];
+          break;
+        case 31:
+          this.$ = [b2[S2 - 2], b2[S2]];
+          break;
+        case 33:
+          this.$ = b2[S2].join(" ");
+          break;
+        case 34:
+          this.$ = [b2[S2]];
+          break;
+        case 35:
+          b2[S2 - 1].push(b2[S2]), this.$ = b2[S2 - 1];
+          break;
+        case 43:
+        case 44:
+          this.$ = b2[S2];
+          break;
+      }
+    }, "anonymous"),
+    table: [
+      e(g, [2, 2], {
+        3: 1,
+        4: 2
+      }),
+      { 1: [3] },
+      {
+        5: [1, 3],
+        8: [1, 4]
+      },
+      e(v, [2, 4], { 6: 5 }),
+      e(g, [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] },
+      e(v, [2, 5]),
+      e(v, [2, 6]),
+      e(v, [2, 7]),
+      e(v, [2, 8]),
+      {
+        13: 16,
+        20: y,
+        21: b
+      },
+      {
+        13: 20,
+        18: 19,
+        20: y,
+        21: b
+      },
+      {
+        13: 20,
+        18: 21,
+        20: y,
+        21: b
+      },
+      {
+        16: [1, 25],
+        20: [1, 23],
+        21: [1, 24],
+        23: 22
+      },
+      {
+        13: 20,
+        18: 26,
+        20: y,
+        21: b
+      },
+      e(v, [2, 9], {
+        14: [1, 27],
+        15: [1, 28]
+      }),
+      e(x, [2, 43]),
+      e(x, [2, 44]),
+      e(v, [2, 13], {
+        14: [1, 29],
+        15: [1, 30],
+        27: S
+      }),
+      e(x, [2, 41]),
+      {
+        16: [1, 34],
+        20: [1, 32],
+        21: [1, 33],
+        27: S
+      },
+      e(v, [2, 22]),
+      e(v, [2, 24], { 14: [1, 35] }),
+      e(v, [2, 25], { 14: [1, 36] }),
+      e(v, [2, 26]),
+      {
+        20: C,
+        25: 37,
+        26: 38,
+        27: S
+      },
+      e(v, [2, 10], { 15: [1, 40] }),
+      { 16: [1, 41] },
+      e(v, [2, 14], { 15: [1, 42] }),
+      { 16: [1, 43] },
+      {
+        13: 44,
+        20: y,
+        21: b
+      },
+      e(v, [2, 17], { 14: [1, 45] }),
+      e(v, [2, 18], { 14: [1, 46] }),
+      e(v, [2, 19]),
+      e(v, [2, 27]),
+      e(v, [2, 28]),
+      e(v, [2, 23], { 27: [1, 47] }),
+      e(w, [2, 29]),
+      { 15: [1, 48] },
+      { 16: [1, 49] },
+      e(v, [2, 11]),
+      { 16: [1, 50] },
+      e(v, [2, 15]),
+      e(x, [2, 42]),
+      e(v, [2, 20]),
+      e(v, [2, 21]),
+      {
+        20: C,
+        26: 51
+      },
+      {
+        16: T,
+        20: E,
+        21: [1, 53],
+        28: 52,
+        29: 54,
+        30: 55,
+        31: D,
+        32: O,
+        33: k
+      },
+      e(v, [2, 12]),
+      e(v, [2, 16]),
+      e(w, [2, 30]),
+      e(w, [2, 31]),
+      e(w, [2, 32]),
+      e(w, [2, 33], {
+        30: 61,
+        16: T,
+        20: E,
+        31: D,
+        32: O,
+        33: k
+      }),
+      e(A, [2, 34]),
+      e(A, [2, 36]),
+      e(A, [2, 37]),
+      e(A, [2, 38]),
+      e(A, [2, 39]),
+      e(A, [2, 40]),
+      e(A, [2, 35])
+    ],
+    defaultActions: { 6: [2, 1] },
+    parseError: /* @__PURE__ */ __name(function(e2, g2) {
+      if (g2.recoverable) this.trace(e2);
+      else {
+        var _ = Error(e2);
+        throw _.hash = g2, _;
+      }
+    }, "parseError"),
+    parse: /* @__PURE__ */ __name(function(e2) {
+      var g2 = this, v2 = [0], y2 = [], b2 = [null], x2 = [], S2 = this.table, C2 = "", w2 = 0, T2 = 0, E2 = 0, D2 = 2, O2 = 1, k2 = x2.slice.call(arguments, 1), A2 = Object.create(this.lexer), j2 = { yy: {} };
+      for (var M2 in this.yy) Object.prototype.hasOwnProperty.call(this.yy, M2) && (j2.yy[M2] = this.yy[M2]);
+      A2.setInput(e2, j2.yy), j2.yy.lexer = A2, j2.yy.parser = this, A2.yylloc === void 0 && (A2.yylloc = {});
+      var N = A2.yylloc;
+      x2.push(N);
+      var P = A2.options && A2.options.ranges;
+      typeof j2.yy.parseError == "function" ? this.parseError = j2.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function F(e3) {
+        v2.length -= 2 * e3, b2.length -= e3, x2.length -= e3;
+      }
+      __name(F, "popStack");
+      function I() {
+        var e3 = y2.pop() || A2.lex() || O2;
+        return typeof e3 != "number" && (e3 instanceof Array && (y2 = e3, e3 = y2.pop()), e3 = g2.symbols_[e3] || e3), e3;
+      }
+      __name(I, "lex");
+      for (var L, R, z, B, V, H = {}, U, W, G, K; ; ) {
+        if (z = v2[v2.length - 1], this.defaultActions[z] ? B = this.defaultActions[z] : (L ?? (L = I()), B = S2[z] && S2[z][L]), B === void 0 || !B.length || !B[0]) {
+          var q = "";
+          for (U in K = [], S2[z]) this.terminals_[U] && U > D2 && K.push("'" + this.terminals_[U] + "'");
+          q = A2.showPosition ? "Parse error on line " + (w2 + 1) + ":\n" + A2.showPosition() + "\nExpecting " + K.join(", ") + ", got '" + (this.terminals_[L] || L) + "'" : "Parse error on line " + (w2 + 1) + ": Unexpected " + (L == O2 ? "end of input" : "'" + (this.terminals_[L] || L) + "'"), this.parseError(q, {
+            text: A2.match,
+            token: this.terminals_[L] || L,
+            line: A2.yylineno,
+            loc: N,
+            expected: K
+          });
+        }
+        if (B[0] instanceof Array && B.length > 1) throw Error("Parse Error: multiple actions possible at state: " + z + ", token: " + L);
+        switch (B[0]) {
+          case 1:
+            v2.push(L), b2.push(A2.yytext), x2.push(A2.yylloc), v2.push(B[1]), L = null, R ? (L = R, R = null) : (T2 = A2.yyleng, C2 = A2.yytext, w2 = A2.yylineno, N = A2.yylloc, E2 > 0 && E2--);
+            break;
+          case 2:
+            if (W = this.productions_[B[1]][1], H.$ = b2[b2.length - W], H._$ = {
+              first_line: x2[x2.length - (W || 1)].first_line,
+              last_line: x2[x2.length - 1].last_line,
+              first_column: x2[x2.length - (W || 1)].first_column,
+              last_column: x2[x2.length - 1].last_column
+            }, P && (H._$.range = [x2[x2.length - (W || 1)].range[0], x2[x2.length - 1].range[1]]), V = this.performAction.apply(H, [
+              C2,
+              T2,
+              w2,
+              j2.yy,
+              B[1],
+              b2,
+              x2
+            ].concat(k2)), V !== void 0) return V;
+            W && (v2 = v2.slice(0, -1 * W * 2), b2 = b2.slice(0, -1 * W), x2 = x2.slice(0, -1 * W)), v2.push(this.productions_[B[1]][0]), b2.push(H.$), x2.push(H._$), G = S2[v2[v2.length - 2]][v2[v2.length - 1]], v2.push(G);
+            break;
+          case 3:
+            return true;
+        }
+      }
+      return true;
+    }, "parse")
+  };
+  j.lexer = /* @__PURE__ */ (function() {
+    return {
+      EOF: 1,
+      parseError: /* @__PURE__ */ __name(function(e2, g2) {
+        if (this.yy.parser) this.yy.parser.parseError(e2, g2);
+        else throw Error(e2);
+      }, "parseError"),
+      setInput: /* @__PURE__ */ __name(function(e2, g2) {
+        return this.yy = g2 || this.yy || {}, this._input = e2, this._more = this._backtrack = this.done = false, 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"),
+      input: /* @__PURE__ */ __name(function() {
+        var e2 = this._input[0];
+        return this.yytext += e2, this.yyleng++, this.offset++, this.match += e2, this.matched += e2, e2.match(/(?:\r\n?|\n).*/g) ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), e2;
+      }, "input"),
+      unput: /* @__PURE__ */ __name(function(e2) {
+        var g2 = e2.length, _ = e2.split(/(?:\r\n?|\n)/g);
+        this._input = e2 + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - g2), this.offset -= g2;
+        var v2 = 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), _.length - 1 && (this.yylineno -= _.length - 1);
+        var y2 = 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: _ ? (_.length === v2.length ? this.yylloc.first_column : 0) + v2[v2.length - _.length].length - _[0].length : this.yylloc.first_column - g2
+        }, this.options.ranges && (this.yylloc.range = [y2[0], y2[0] + this.yyleng - g2]), this.yyleng = this.yytext.length, this;
+      }, "unput"),
+      more: /* @__PURE__ */ __name(function() {
+        return this._more = true, this;
+      }, "more"),
+      reject: /* @__PURE__ */ __name(function() {
+        if (this.options.backtrack_lexer) this._backtrack = true;
+        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).\n" + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+        return this;
+      }, "reject"),
+      less: /* @__PURE__ */ __name(function(e2) {
+        this.unput(this.match.slice(e2));
+      }, "less"),
+      pastInput: /* @__PURE__ */ __name(function() {
+        var e2 = this.matched.substr(0, this.matched.length - this.match.length);
+        return (e2.length > 20 ? "..." : "") + e2.substr(-20).replace(/\n/g, "");
+      }, "pastInput"),
+      upcomingInput: /* @__PURE__ */ __name(function() {
+        var e2 = this.match;
+        return e2.length < 20 && (e2 += this._input.substr(0, 20 - e2.length)), (e2.substr(0, 20) + (e2.length > 20 ? "..." : "")).replace(/\n/g, "");
+      }, "upcomingInput"),
+      showPosition: /* @__PURE__ */ __name(function() {
+        var e2 = this.pastInput(), g2 = Array(e2.length + 1).join("-");
+        return e2 + this.upcomingInput() + "\n" + g2 + "^";
+      }, "showPosition"),
+      test_match: /* @__PURE__ */ __name(function(e2, g2) {
+        var _, v2, y2;
+        if (this.options.backtrack_lexer && (y2 = {
+          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 && (y2.yylloc.range = this.yylloc.range.slice(0))), v2 = e2[0].match(/(?:\r\n?|\n).*/g), v2 && (this.yylineno += v2.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: v2 ? v2[v2.length - 1].length - v2[v2.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + e2[0].length
+        }, this.yytext += e2[0], this.match += e2[0], this.matches = e2, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [this.offset, this.offset += this.yyleng]), this._more = false, this._backtrack = false, this._input = this._input.slice(e2[0].length), this.matched += e2[0], _ = this.performAction.call(this, this.yy, this, g2, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = false), _) return _;
+        if (this._backtrack) {
+          for (var b2 in y2) this[b2] = y2[b2];
+          return false;
+        }
+        return false;
+      }, "test_match"),
+      next: /* @__PURE__ */ __name(function() {
+        if (this.done) return this.EOF;
+        this._input || (this.done = true);
+        var e2, g2, _, v2;
+        this._more || (this.yytext = "", this.match = "");
+        for (var y2 = this._currentRules(), b2 = 0; b2 < y2.length; b2++) if (_ = this._input.match(this.rules[y2[b2]]), _ && (!g2 || _[0].length > g2[0].length)) {
+          if (g2 = _, v2 = b2, this.options.backtrack_lexer) {
+            if (e2 = this.test_match(_, y2[b2]), e2 !== false) return e2;
+            if (this._backtrack) {
+              g2 = false;
+              continue;
+            } else return false;
+          } else if (!this.options.flex) break;
+        }
+        return g2 ? (e2 = this.test_match(g2, y2[v2]), e2 === false ? false : e2) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+      }, "next"),
+      lex: /* @__PURE__ */ __name(function() {
+        return this.next() || this.lex();
+      }, "lex"),
+      begin: /* @__PURE__ */ __name(function(e2) {
+        this.conditionStack.push(e2);
+      }, "begin"),
+      popState: /* @__PURE__ */ __name(function() {
+        return this.conditionStack.length - 1 > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+      }, "popState"),
+      _currentRules: /* @__PURE__ */ __name(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"),
+      topState: /* @__PURE__ */ __name(function(e2) {
+        return e2 = this.conditionStack.length - 1 - Math.abs(e2 || 0), e2 >= 0 ? this.conditionStack[e2] : "INITIAL";
+      }, "topState"),
+      pushState: /* @__PURE__ */ __name(function(e2) {
+        this.begin(e2);
+      }, "pushState"),
+      stateStackSize: /* @__PURE__ */ __name(function() {
+        return this.conditionStack.length;
+      }, "stateStackSize"),
+      options: { "case-insensitive": true },
+      performAction: /* @__PURE__ */ __name(function(e2, g2, _, v2) {
+        switch (_) {
+          case 0:
+            break;
+          case 1:
+            break;
+          case 2:
+            break;
+          case 3:
+            if (e2.getIndentMode && e2.getIndentMode()) return e2.consumeIndentText = true, this.begin("INITIAL"), 22;
+            break;
+          case 4:
+            break;
+          case 5:
+            e2.setIndentMode && e2.setIndentMode(false), this.begin("INITIAL"), this.unput(g2.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 (e2.consumeIndentText) e2.consumeIndentText = false;
+            else return 19;
+            break;
+          case 15:
+            return 24;
+          case 16:
+            return g2.yytext = g2.yytext.slice(2, -2), 14;
+          case 17:
+            return g2.yytext = g2.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: true
+        },
+        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: true
+        }
+      }
+    };
+  })();
+  function M() {
+    this.yy = {};
+  }
+  return __name(M, "Parser"), M.prototype = j, j.Parser = M, new M();
+})();
+parser.parser = parser;
+var venn_default = parser, subsets = [], textNodes = [], styleEntries = [], knownSets = /* @__PURE__ */ new Set(), currentSets, indentMode = false, addSubsetData = /* @__PURE__ */ __name((e, g, _) => {
+  let v = normalizeIdentifierList(e).sort(), y = _ ?? 10 / e.length ** 2;
+  currentSets = v, v.length === 1 && knownSets.add(v[0]), subsets.push({
+    sets: v,
+    size: y,
+    label: g ? normalizeText(g) : void 0
+  });
+}, "addSubsetData"), getSubsetData = /* @__PURE__ */ __name(() => subsets, "getSubsetData"), normalizeText = /* @__PURE__ */ __name((e) => {
+  let g = e.trim();
+  return g.length >= 2 && g.startsWith('"') && g.endsWith('"') ? g.slice(1, -1) : g;
+}, "normalizeText"), normalizeStyleValue = /* @__PURE__ */ __name((e) => e && normalizeText(e), "normalizeStyleValue"), addTextData = /* @__PURE__ */ __name((e, g, _) => {
+  let v = normalizeText(g);
+  textNodes.push({
+    sets: normalizeIdentifierList(e).sort(),
+    id: v,
+    label: _ ? normalizeText(_) : void 0
+  });
+}, "addTextData"), addStyleData = /* @__PURE__ */ __name((e, g) => {
+  let _ = normalizeIdentifierList(e).sort(), v = {};
+  for (let [e2, _2] of g) v[e2] = normalizeStyleValue(_2) ?? _2;
+  styleEntries.push({
+    targets: _,
+    styles: v
+  });
+}, "addStyleData"), getStyleData = /* @__PURE__ */ __name(() => styleEntries, "getStyleData"), normalizeIdentifierList = /* @__PURE__ */ __name((e) => e.map((e2) => normalizeText(e2)), "normalizeIdentifierList"), validateUnionIdentifiers = /* @__PURE__ */ __name((e) => {
+  let g = normalizeIdentifierList(e).filter((e2) => !knownSets.has(e2));
+  if (g.length > 0) throw Error(`unknown set identifier: ${g.join(", ")}`);
+}, "validateUnionIdentifiers"), getTextData = /* @__PURE__ */ __name(() => textNodes, "getTextData"), getCurrentSets = /* @__PURE__ */ __name(() => currentSets, "getCurrentSets"), getIndentMode = /* @__PURE__ */ __name(() => indentMode, "getIndentMode"), setIndentMode = /* @__PURE__ */ __name((e) => {
+  indentMode = e;
+}, "setIndentMode"), DEFAULT_VENN_CONFIG = defaultConfig_default.venn;
+function getConfig2() {
+  return cleanAndMerge(DEFAULT_VENN_CONFIG, getConfig().venn);
+}
+__name(getConfig2, "getConfig");
+var db = {
+  getConfig: getConfig2,
+  clear: /* @__PURE__ */ __name(() => {
+    clear(), subsets.length = 0, textNodes.length = 0, styleEntries.length = 0, knownSets.clear(), currentSets = void 0, indentMode = false;
+  }, "customClear"),
+  setAccTitle,
+  getAccTitle,
+  setDiagramTitle,
+  getDiagramTitle,
+  getAccDescription,
+  setAccDescription,
+  addSubsetData,
+  getSubsetData,
+  addTextData,
+  addStyleData,
+  validateUnionIdentifiers,
+  getTextData,
+  getStyleData,
+  getCurrentSets,
+  getIndentMode,
+  setIndentMode
+}, styles_default = /* @__PURE__ */ __name((e) => `
+  .venn-title {
+    font-size: 32px;
+    fill: ${e.vennTitleTextColor};
+    font-family: ${e.fontFamily};
+  }
+
+  .venn-circle text {
+    font-size: 48px;
+    font-family: ${e.fontFamily};
+  }
+
+  .venn-intersection text {
+    font-size: 48px;
+    fill: ${e.vennSetTextColor};
+    font-family: ${e.fontFamily};
+  }
+
+  .venn-text-node {
+    font-family: ${e.fontFamily};
+    color: ${e.vennSetTextColor};
+  }
+`, "getStyles");
+function buildStyleByKey(e) {
+  let g = /* @__PURE__ */ new Map();
+  for (let _ of e) {
+    let e2 = _.targets.join("|"), v = g.get(e2);
+    v ? Object.assign(v, _.styles) : g.set(e2, { ..._.styles });
+  }
+  return g;
+}
+__name(buildStyleByKey, "buildStyleByKey");
+var draw = /* @__PURE__ */ __name((e, _, y, b) => {
+  var _a, _b, _c;
+  let x = b.db, S = (_a = x.getConfig) == null ? void 0 : _a.call(x), { themeVariables: E, look: O, handDrawnSeed: k } = getConfig(), A = O === "handDrawn", j = [
+    E.venn1,
+    E.venn2,
+    E.venn3,
+    E.venn4,
+    E.venn5,
+    E.venn6,
+    E.venn7,
+    E.venn8
+  ].filter(Boolean), F = (_b = x.getDiagramTitle) == null ? void 0 : _b.call(x), I = x.getSubsetData(), L = x.getTextData(), R = buildStyleByKey(x.getStyleData()), z = ensurePairwiseSubsets(I), B = (S == null ? void 0 : S.width) ?? 800, V = (S == null ? void 0 : S.height) ?? 450, H = B / 1600, U = F ? 48 * H : 0, W = E.primaryTextColor ?? E.textColor, G = selectSvgElement(_);
+  G.attr("viewBox", `0 0 ${B} ${V}`), F && G.append("text").text(F).attr("class", "venn-title").attr("font-size", `${32 * H}px`).attr("text-anchor", "middle").attr("dominant-baseline", "middle").attr("x", "50%").attr("y", 32 * H).style("fill", E.vennTitleTextColor || E.titleColor);
+  let K = select_default(document.createElement("div")), q = VennDiagram().width(B).height(V - U);
+  K.datum(z).call(q);
+  let J = A ? at.svg(K.select("svg").node()) : void 0, Y = layout(z, {
+    width: B,
+    height: V - U,
+    padding: (S == null ? void 0 : S.padding) ?? 15
+  }), X = /* @__PURE__ */ new Map();
+  for (let e2 of Y) {
+    let g = stableSetsKey([...e2.data.sets].sort());
+    X.set(g, e2);
+  }
+  L.length > 0 && renderTextNodes(S, X, K, L, H, R);
+  let Z = is_dark_default(E.background || "#f4f4f4");
+  K.selectAll(".venn-circle").each(function(e2, _2) {
+    var _a2;
+    let y2 = select_default(this), b2 = stableSetsKey([...e2.sets].sort()), x2 = R.get(b2), S2 = (x2 == null ? void 0 : x2.fill) || j[_2 % j.length] || E.primaryColor;
+    y2.classed(`venn-set-${_2 % 8}`, true);
+    let C = (x2 == null ? void 0 : x2["fill-opacity"]) ?? 0.1, w = (x2 == null ? void 0 : x2.stroke) || S2, D = (x2 == null ? void 0 : x2["stroke-width"]) || `${5 * H}`;
+    if (A && J) {
+      let e3 = X.get(b2);
+      if (e3 && e3.circles.length > 0) {
+        let g = e3.circles[0], v = J.circle(g.x, g.y, g.radius * 2, {
+          roughness: 0.7,
+          seed: k,
+          fill: transparentize_default(S2, 0.7),
+          fillStyle: "hachure",
+          fillWeight: 2,
+          hachureGap: 8,
+          hachureAngle: -41 + _2 * 60,
+          stroke: w,
+          strokeWidth: parseFloat(String(D))
+        });
+        y2.select("path").remove(), (_a2 = y2.node()) == null ? void 0 : _a2.insertBefore(v, y2.select("text").node());
+      }
+    } else y2.select("path").style("fill", S2).style("fill-opacity", C).style("stroke", w).style("stroke-width", D).style("stroke-opacity", 0.95);
+    let O2 = (x2 == null ? void 0 : x2.color) || (Z ? lighten_default(S2, 30) : darken_default(S2, 30));
+    y2.select("text").style("font-size", `${48 * H}px`).style("fill", O2);
+  }), A && J ? K.selectAll(".venn-intersection").each(function(e2) {
+    var _a2;
+    let _2 = select_default(this), v = stableSetsKey([...e2.sets].sort()), y2 = R.get(v), b2 = y2 == null ? void 0 : y2.fill;
+    if (b2) {
+      let e3 = _2.select("path"), g = e3.attr("d");
+      if (g) {
+        let _3 = J.path(g, {
+          roughness: 0.7,
+          seed: k,
+          fill: transparentize_default(b2, 0.3),
+          fillStyle: "cross-hatch",
+          fillWeight: 2,
+          hachureGap: 6,
+          hachureAngle: 60,
+          stroke: "none"
+        }), v2 = e3.node();
+        (_a2 = v2 == null ? void 0 : v2.parentNode) == null ? void 0 : _a2.insertBefore(_3, v2), e3.remove();
+      }
+    } else _2.select("path").style("fill-opacity", 0);
+    _2.select("text").style("font-size", `${48 * H}px`).style("fill", (y2 == null ? void 0 : y2.color) ?? E.vennSetTextColor ?? W);
+  }) : (K.selectAll(".venn-intersection text").style("font-size", `${48 * H}px`).style("fill", (e2) => {
+    var _a2;
+    let g = stableSetsKey([...e2.sets].sort());
+    return ((_a2 = R.get(g)) == null ? void 0 : _a2.color) ?? E.vennSetTextColor ?? W;
+  }), K.selectAll(".venn-intersection path").style("fill-opacity", (e2) => {
+    var _a2;
+    let g = stableSetsKey([...e2.sets].sort());
+    return ((_a2 = R.get(g)) == null ? void 0 : _a2.fill) ? 1 : 0;
+  }).style("fill", (e2) => {
+    var _a2;
+    let g = stableSetsKey([...e2.sets].sort());
+    return ((_a2 = R.get(g)) == null ? void 0 : _a2.fill) ?? "transparent";
+  }));
+  let Q = G.append("g").attr("transform", `translate(0, ${U})`), $ = K.select("svg").node();
+  if ($ && "childNodes" in $) for (let e2 of [...$.childNodes]) (_c = Q.node()) == null ? void 0 : _c.appendChild(e2);
+  configureSvgSize(G, V, B, (S == null ? void 0 : S.useMaxWidth) ?? true);
+}, "draw");
+function stableSetsKey(e) {
+  return e.join("|");
+}
+__name(stableSetsKey, "stableSetsKey");
+function renderTextNodes(e, g, _, v, y, b) {
+  var _a;
+  let x = (e == null ? void 0 : e.useDebugLayout) ?? false, S = _.select("svg").append("g").attr("class", "venn-text-nodes"), C = /* @__PURE__ */ new Map();
+  for (let e2 of v) {
+    let g2 = stableSetsKey(e2.sets), _2 = C.get(g2);
+    _2 ? _2.push(e2) : C.set(g2, [e2]);
+  }
+  for (let [e2, _2] of C.entries()) {
+    let v2 = g.get(e2);
+    if (!(v2 == null ? void 0 : v2.text)) continue;
+    let C2 = v2.text.x, w = v2.text.y, T = Math.min(...v2.circles.map((e3) => e3.radius)), E = Math.min(...v2.circles.map((e3) => e3.radius - Math.hypot(C2 - e3.x, w - e3.y))), D = Number.isFinite(E) ? Math.max(0, E) : 0;
+    D === 0 && Number.isFinite(T) && (D = T * 0.6);
+    let O = S.append("g").attr("class", "venn-text-area").attr("font-size", `${40 * y}px`);
+    x && O.append("circle").attr("class", "venn-text-debug-circle").attr("cx", C2).attr("cy", w).attr("r", D).attr("fill", "none").attr("stroke", "purple").attr("stroke-width", 1.5 * y).attr("stroke-dasharray", `${6 * y} ${4 * y}`);
+    let k = Math.max(80 * y, D * 2 * 0.95), A = Math.max(60 * y, D * 2 * 0.95), j = (v2.data.label && v2.data.label.length > 0 ? Math.min(32 * y, D * 0.25) : 0) + (_2.length <= 2 ? 30 * y : 0), M = C2 - k / 2, N = w - A / 2 + j, P = Math.max(1, Math.ceil(Math.sqrt(_2.length))), F = Math.max(1, Math.ceil(_2.length / P)), I = k / P, L = A / F;
+    for (let [e3, g2] of _2.entries()) {
+      let _3 = e3 % P, v3 = Math.floor(e3 / P), S2 = M + I * (_3 + 0.5), C3 = N + L * (v3 + 0.5);
+      x && O.append("rect").attr("class", "venn-text-debug-cell").attr("x", M + I * _3).attr("y", N + L * v3).attr("width", I).attr("height", L).attr("fill", "none").attr("stroke", "teal").attr("stroke-width", 1 * y).attr("stroke-dasharray", `${4 * y} ${3 * y}`);
+      let w2 = I * 0.9, T2 = L * 0.9, E2 = O.append("foreignObject").attr("class", "venn-text-node-fo").attr("width", w2).attr("height", T2).attr("x", S2 - w2 / 2).attr("y", C3 - T2 / 2).attr("overflow", "visible"), D2 = (_a = b.get(g2.id)) == null ? void 0 : _a.color, k2 = E2.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(g2.label ?? g2.id);
+      D2 && k2.style("color", D2);
+    }
+  }
+}
+__name(renderTextNodes, "renderTextNodes");
+function ensurePairwiseSubsets(e) {
+  let g = new Set(e.map((e2) => [...e2.sets].sort().join("|"))), _ = new Map(e.filter((e2) => e2.sets.length === 1 && e2.size !== void 0).map((e2) => [e2.sets[0], e2.size])), v = [];
+  for (let y of e) {
+    if (y.sets.length < 3) continue;
+    let e2 = [...y.sets].sort();
+    for (let y2 = 0; y2 < e2.length - 1; y2++) for (let b = y2 + 1; b < e2.length; b++) {
+      let x = [e2[y2], e2[b]], S = x.join("|");
+      if (!g.has(S)) {
+        g.add(S);
+        let e3 = _.get(x[0]), y3 = _.get(x[1]), b2 = e3 !== void 0 && y3 !== void 0 ? Math.min(e3, y3) / 4 : 2.5;
+        v.push({
+          sets: x,
+          size: b2,
+          label: ""
+        });
+      }
+    }
+  }
+  return v.length > 0 ? [...e, ...v] : e;
+}
+__name(ensurePairwiseSubsets, "ensurePairwiseSubsets");
+var diagram = {
+  parser: venn_default,
+  db,
+  renderer: { draw },
+  styles: styles_default
+};
+export {
+  diagram
+};