@loopstack/loopstack-studio 0.25.1 → 0.25.2

package/dist/node_modules/@upsetjs/venn.js/build/venn.esm.js

@@ -1,595 +1,594 @@
-//#region ../../node_modules/@upsetjs/venn.js/build/venn.esm.js
-var e = 1e-10;
-function t(t, o) {
-	let s = r(t), l = s.filter((e) => n(e, t)), u = 0, d = 0, f = [];
-	if (l.length > 1) {
-		let e = c(l);
-		for (let t = 0; t < l.length; ++t) {
-			let n = l[t];
-			n.angle = Math.atan2(n.x - e.x, n.y - e.y);
+var SMALL$1 = 1e-10;
+function intersectionArea(d, g) {
+	let _ = getIntersectionPoints(d), y = _.filter((e) => containedInCircles(e, d)), b = 0, x = 0, S = [];
+	if (y.length > 1) {
+		let e = getCenter(y);
+		for (let d = 0; d < y.length; ++d) {
+			let f = y[d];
+			f.angle = Math.atan2(f.x - e.x, f.y - e.y);
 		}
-		l.sort((e, t) => t.angle - e.angle);
-		let n = l[l.length - 1];
-		for (let e = 0; e < l.length; ++e) {
-			let r = l[e];
-			d += (n.x + r.x) * (r.y - n.y);
-			let o = {
-				x: (r.x + n.x) / 2,
-				y: (r.y + n.y) / 2
-			}, s = null;
-			for (let e = 0; e < r.parentIndex.length; ++e) if (n.parentIndex.includes(r.parentIndex[e])) {
-				let i = t[r.parentIndex[e]], c = Math.atan2(r.x - i.x, r.y - i.y), l = Math.atan2(n.x - i.x, n.y - i.y), u = l - c;
-				u < 0 && (u += 2 * Math.PI);
-				let d = l - u / 2, f = a(o, {
-					x: i.x + i.radius * Math.sin(d),
-					y: i.y + i.radius * Math.cos(d)
+		y.sort((e, d) => d.angle - e.angle);
+		let f = y[y.length - 1];
+		for (let e = 0; e < y.length; ++e) {
+			let p = y[e];
+			x += (f.x + p.x) * (p.y - f.y);
+			let g = {
+				x: (p.x + f.x) / 2,
+				y: (p.y + f.y) / 2
+			}, _ = null;
+			for (let e = 0; e < p.parentIndex.length; ++e) if (f.parentIndex.includes(p.parentIndex[e])) {
+				let m = d[p.parentIndex[e]], v = Math.atan2(p.x - m.x, p.y - m.y), y = Math.atan2(f.x - m.x, f.y - m.y), b = y - v;
+				b < 0 && (b += 2 * Math.PI);
+				let x = y - b / 2, S = distance(g, {
+					x: m.x + m.radius * Math.sin(x),
+					y: m.y + m.radius * Math.cos(x)
 				});
-				f > i.radius * 2 && (f = i.radius * 2), (s == null || s.width > f) && (s = {
-					circle: i,
-					width: f,
-					p1: r,
-					p2: n,
-					large: f > i.radius,
+				S > m.radius * 2 && (S = m.radius * 2), (_ == null || _.width > S) && (_ = {
+					circle: m,
+					width: S,
+					p1: p,
+					p2: f,
+					large: S > m.radius,
 					sweep: !0
 				});
 			}
-			s != null && (f.push(s), u += i(s.circle.radius, s.width), n = r);
+			_ != null && (S.push(_), b += circleArea(_.circle.radius, _.width), f = p);
 		}
 	} else {
-		let n = t[0];
-		for (let e = 1; e < t.length; ++e) t[e].radius < n.radius && (n = t[e]);
-		let r = !1;
-		for (let e = 0; e < t.length; ++e) if (a(t[e], n) > Math.abs(n.radius - t[e].radius)) {
-			r = !0;
+		let f = d[0];
+		for (let e = 1; e < d.length; ++e) d[e].radius < f.radius && (f = d[e]);
+		let p = !1;
+		for (let e = 0; e < d.length; ++e) if (distance(d[e], f) > Math.abs(f.radius - d[e].radius)) {
+			p = !0;
 			break;
 		}
-		r ? u = d = 0 : (u = n.radius * n.radius * Math.PI, f.push({
-			circle: n,
+		p ? b = x = 0 : (b = f.radius * f.radius * Math.PI, S.push({
+			circle: f,
 			p1: {
-				x: n.x,
-				y: n.y + n.radius
+				x: f.x,
+				y: f.y + f.radius
 			},
 			p2: {
-				x: n.x - e,
-				y: n.y + n.radius
+				x: f.x - SMALL$1,
+				y: f.y + f.radius
 			},
-			width: n.radius * 2,
+			width: f.radius * 2,
 			large: !0,
 			sweep: !0
 		}));
 	}
-	return d /= 2, o && (o.area = u + d, o.arcArea = u, o.polygonArea = d, o.arcs = f, o.innerPoints = l, o.intersectionPoints = s), u + d;
+	return x /= 2, g && (g.area = b + x, g.arcArea = b, g.polygonArea = x, g.arcs = S, g.innerPoints = y, g.intersectionPoints = _), b + x;
 }
-function n(t, n) {
-	return n.every((n) => a(t, n) < n.radius + e);
+function containedInCircles(d, f) {
+	return f.every((f) => distance(d, f) < f.radius + SMALL$1);
 }
-function r(e) {
-	let t = [];
-	for (let n = 0; n < e.length; ++n) for (let r = n + 1; r < e.length; ++r) {
-		let i = s(e[n], e[r]);
-		for (let e of i) e.parentIndex = [n, r], t.push(e);
+function getIntersectionPoints(e) {
+	let d = [];
+	for (let f = 0; f < e.length; ++f) for (let p = f + 1; p < e.length; ++p) {
+		let m = circleCircleIntersection(e[f], e[p]);
+		for (let e of m) e.parentIndex = [f, p], d.push(e);
 	}
-	return t;
+	return d;
 }
-function i(e, t) {
-	return e * e * Math.acos(1 - t / e) - (e - t) * Math.sqrt(t * (2 * e - t));
+function circleArea(e, d) {
+	return e * e * Math.acos(1 - d / e) - (e - d) * Math.sqrt(d * (2 * e - d));
 }
-function a(e, t) {
-	return Math.sqrt((e.x - t.x) * (e.x - t.x) + (e.y - t.y) * (e.y - t.y));
+function distance(e, d) {
+	return Math.sqrt((e.x - d.x) * (e.x - d.x) + (e.y - d.y) * (e.y - d.y));
 }
-function o(e, t, n) {
-	if (n >= e + t) return 0;
-	if (n <= Math.abs(e - t)) return Math.PI * Math.min(e, t) * Math.min(e, t);
-	let r = e - (n * n - t * t + e * e) / (2 * n), a = t - (n * n - e * e + t * t) / (2 * n);
-	return i(e, r) + i(t, a);
+function circleOverlap(e, d, f) {
+	if (f >= e + d) return 0;
+	if (f <= Math.abs(e - d)) return Math.PI * Math.min(e, d) * Math.min(e, d);
+	let p = e - (f * f - d * d + e * e) / (2 * f), h = d - (f * f - e * e + d * d) / (2 * f);
+	return circleArea(e, p) + circleArea(d, h);
 }
-function s(e, t) {
-	let n = a(e, t), r = e.radius, i = t.radius;
-	if (n >= r + i || n <= Math.abs(r - i)) return [];
-	let o = (r * r - i * i + n * n) / (2 * n), s = Math.sqrt(r * r - o * o), c = e.x + o * (t.x - e.x) / n, l = e.y + o * (t.y - e.y) / n, u = -(t.y - e.y) * (s / n), d = -(t.x - e.x) * (s / n);
+function circleCircleIntersection(e, d) {
+	let f = distance(e, d), p = e.radius, m = d.radius;
+	if (f >= p + m || f <= Math.abs(p - m)) return [];
+	let g = (p * p - m * m + f * f) / (2 * f), _ = Math.sqrt(p * p - g * g), v = e.x + g * (d.x - e.x) / f, y = e.y + g * (d.y - e.y) / f, b = -(d.y - e.y) * (_ / f), x = -(d.x - e.x) * (_ / f);
 	return [{
-		x: c + u,
-		y: l - d
+		x: v + b,
+		y: y - x
 	}, {
-		x: c - u,
-		y: l + d
+		x: v - b,
+		y: y + x
 	}];
 }
-function c(e) {
-	let t = {
+function getCenter(e) {
+	let d = {
 		x: 0,
 		y: 0
 	};
-	for (let n of e) t.x += n.x, t.y += n.y;
-	return t.x /= e.length, t.y /= e.length, t;
-}
-function l(e, t, n, r) {
-	r ||= {};
-	let i = r.maxIterations || 100, a = r.tolerance || 1e-10, o = e(t), s = e(n), c = n - t;
-	if (o * s > 0) throw "Initial bisect points must have opposite signs";
-	if (o === 0) return t;
-	if (s === 0) return n;
-	for (let n = 0; n < i; ++n) {
-		c /= 2;
-		let n = t + c, r = e(n);
-		if (r * o >= 0 && (t = n), Math.abs(c) < a || r === 0) return n;
-	}
-	return t + c;
-}
-function u(e) {
-	let t = Array(e);
-	for (let n = 0; n < e; ++n) t[n] = 0;
-	return t;
-}
-function d(e, t) {
-	return u(e).map(() => u(t));
-}
-function f(e, t) {
-	let n = 0;
-	for (let r = 0; r < e.length; ++r) n += e[r] * t[r];
-	return n;
-}
-function p(e) {
-	return Math.sqrt(f(e, e));
-}
-function m(e, t, n) {
-	for (let r = 0; r < t.length; ++r) e[r] = t[r] * n;
-}
-function h(e, t, n, r, i) {
-	for (let a = 0; a < e.length; ++a) e[a] = t * n[a] + r * i[a];
-}
-function g(e, t, n) {
-	n ||= {};
-	let r = n.maxIterations || t.length * 200, i = n.nonZeroDelta || 1.05, a = n.zeroDelta || .001, o = n.minErrorDelta || 1e-6, s = n.minErrorDelta || 1e-5, c = n.rho === void 0 ? 1 : n.rho, l = n.chi === void 0 ? 2 : n.chi, u = n.psi === void 0 ? -.5 : n.psi, d = n.sigma === void 0 ? .5 : n.sigma, f, p = t.length, m = Array(p + 1);
-	m[0] = t, m[0].fx = e(t), m[0].id = 0;
-	for (let n = 0; n < p; ++n) {
-		let r = t.slice();
-		r[n] = r[n] ? r[n] * i : a, m[n + 1] = r, m[n + 1].fx = e(r), m[n + 1].id = n + 1;
-	}
-	function g(e) {
-		for (let t = 0; t < e.length; t++) m[p][t] = e[t];
-		m[p].fx = e.fx;
-	}
-	let _ = (e, t) => e.fx - t.fx, v = t.slice(), y = t.slice(), b = t.slice(), x = t.slice();
-	for (let t = 0; t < r; ++t) {
-		if (m.sort(_), n.history) {
-			let e = m.map((e) => {
-				let t = e.slice();
-				return t.fx = e.fx, t.id = e.id, t;
+	for (let f of e) d.x += f.x, d.y += f.y;
+	return d.x /= e.length, d.y /= e.length, d;
+}
+function bisect(e, d, f, p) {
+	p ||= {};
+	let m = p.maxIterations || 100, h = p.tolerance || 1e-10, g = e(d), _ = e(f), v = f - d;
+	if (g * _ > 0) throw "Initial bisect points must have opposite signs";
+	if (g === 0) return d;
+	if (_ === 0) return f;
+	for (let f = 0; f < m; ++f) {
+		v /= 2;
+		let f = d + v, p = e(f);
+		if (p * g >= 0 && (d = f), Math.abs(v) < h || p === 0) return f;
+	}
+	return d + v;
+}
+function zeros(e) {
+	let d = Array(e);
+	for (let f = 0; f < e; ++f) d[f] = 0;
+	return d;
+}
+function zerosM(e, d) {
+	return zeros(e).map(() => zeros(d));
+}
+function dot(e, d) {
+	let f = 0;
+	for (let p = 0; p < e.length; ++p) f += e[p] * d[p];
+	return f;
+}
+function norm2(e) {
+	return Math.sqrt(dot(e, e));
+}
+function scale(e, d, f) {
+	for (let p = 0; p < d.length; ++p) e[p] = d[p] * f;
+}
+function weightedSum(e, d, f, p, m) {
+	for (let h = 0; h < e.length; ++h) e[h] = d * f[h] + p * m[h];
+}
+function nelderMead(e, d, f) {
+	f ||= {};
+	let p = f.maxIterations || d.length * 200, m = f.nonZeroDelta || 1.05, h = f.zeroDelta || .001, g = f.minErrorDelta || 1e-6, _ = f.minErrorDelta || 1e-5, v = f.rho === void 0 ? 1 : f.rho, y = f.chi === void 0 ? 2 : f.chi, b = f.psi === void 0 ? -.5 : f.psi, x = f.sigma === void 0 ? .5 : f.sigma, S, C = d.length, w = Array(C + 1);
+	w[0] = d, w[0].fx = e(d), w[0].id = 0;
+	for (let f = 0; f < C; ++f) {
+		let p = d.slice();
+		p[f] = p[f] ? p[f] * m : h, w[f + 1] = p, w[f + 1].fx = e(p), w[f + 1].id = f + 1;
+	}
+	function E(e) {
+		for (let d = 0; d < e.length; d++) w[C][d] = e[d];
+		w[C].fx = e.fx;
+	}
+	let D = (e, d) => e.fx - d.fx, O = d.slice(), k = d.slice(), A = d.slice(), j = d.slice();
+	for (let d = 0; d < p; ++d) {
+		if (w.sort(D), f.history) {
+			let e = w.map((e) => {
+				let d = e.slice();
+				return d.fx = e.fx, d.id = e.id, d;
 			});
-			e.sort((e, t) => e.id - t.id), n.history.push({
-				x: m[0].slice(),
-				fx: m[0].fx,
+			e.sort((e, d) => e.id - d.id), f.history.push({
+				x: w[0].slice(),
+				fx: w[0].fx,
 				simplex: e
 			});
 		}
-		f = 0;
-		for (let e = 0; e < p; ++e) f = Math.max(f, Math.abs(m[0][e] - m[1][e]));
-		if (Math.abs(m[0].fx - m[p].fx) < o && f < s) break;
-		for (let e = 0; e < p; ++e) {
-			v[e] = 0;
-			for (let t = 0; t < p; ++t) v[e] += m[t][e];
-			v[e] /= p;
+		S = 0;
+		for (let e = 0; e < C; ++e) S = Math.max(S, Math.abs(w[0][e] - w[1][e]));
+		if (Math.abs(w[0].fx - w[C].fx) < g && S < _) break;
+		for (let e = 0; e < C; ++e) {
+			O[e] = 0;
+			for (let d = 0; d < C; ++d) O[e] += w[d][e];
+			O[e] /= C;
 		}
-		let t = m[p];
-		if (h(y, 1 + c, v, -c, t), y.fx = e(y), y.fx < m[0].fx) h(x, 1 + l, v, -l, t), x.fx = e(x), x.fx < y.fx ? g(x) : g(y);
-		else if (y.fx >= m[p - 1].fx) {
-			let n = !1;
-			if (y.fx > t.fx ? (h(b, 1 + u, v, -u, t), b.fx = e(b), b.fx < t.fx ? g(b) : n = !0) : (h(b, 1 - u * c, v, u * c, t), b.fx = e(b), b.fx < y.fx ? g(b) : n = !0), n) {
-				if (d >= 1) break;
-				for (let t = 1; t < m.length; ++t) h(m[t], 1 - d, m[0], d, m[t]), m[t].fx = e(m[t]);
+		let d = w[C];
+		if (weightedSum(k, 1 + v, O, -v, d), k.fx = e(k), k.fx < w[0].fx) weightedSum(j, 1 + y, O, -y, d), j.fx = e(j), j.fx < k.fx ? E(j) : E(k);
+		else if (k.fx >= w[C - 1].fx) {
+			let f = !1;
+			if (k.fx > d.fx ? (weightedSum(A, 1 + b, O, -b, d), A.fx = e(A), A.fx < d.fx ? E(A) : f = !0) : (weightedSum(A, 1 - b * v, O, b * v, d), A.fx = e(A), A.fx < k.fx ? E(A) : f = !0), f) {
+				if (x >= 1) break;
+				for (let d = 1; d < w.length; ++d) weightedSum(w[d], 1 - x, w[0], x, w[d]), w[d].fx = e(w[d]);
 			}
-		} else g(y);
+		} else E(k);
 	}
-	return m.sort(_), {
-		fx: m[0].fx,
-		x: m[0]
+	return w.sort(D), {
+		fx: w[0].fx,
+		x: w[0]
 	};
 }
-function _(e, t, n, r, i, a, o) {
-	let s = n.fx, c = f(n.fxprime, t), l = s, u = s, d = c, p = 0;
-	i ||= 1, a ||= 1e-6, o ||= .1;
-	function m(u, p, m) {
-		for (let g = 0; g < 16; ++g) if (i = (u + p) / 2, h(r.x, 1, n.x, i, t), l = r.fx = e(r.x, r.fxprime), d = f(r.fxprime, t), l > s + a * i * c || l >= m) p = i;
+function wolfeLineSearch(e, d, f, p, m, h, g) {
+	let _ = f.fx, v = dot(f.fxprime, d), y = _, b = _, x = v, C = 0;
+	m ||= 1, h ||= 1e-6, g ||= .1;
+	function w(b, C, w) {
+		for (let E = 0; E < 16; ++E) if (m = (b + C) / 2, weightedSum(p.x, 1, f.x, m, d), y = p.fx = e(p.x, p.fxprime), x = dot(p.fxprime, d), y > _ + h * m * v || y >= w) C = m;
 		else {
-			if (Math.abs(d) <= -o * c) return i;
-			d * (p - u) >= 0 && (p = u), u = i, m = l;
+			if (Math.abs(x) <= -g * v) return m;
+			x * (C - b) >= 0 && (C = b), b = m, w = y;
 		}
 		return 0;
 	}
-	for (let g = 0; g < 10; ++g) {
-		if (h(r.x, 1, n.x, i, t), l = r.fx = e(r.x, r.fxprime), d = f(r.fxprime, t), l > s + a * i * c || g && l >= u) return m(p, i, u);
-		if (Math.abs(d) <= -o * c) return i;
-		if (d >= 0) return m(i, p, l);
-		u = l, p = i, i *= 2;
+	for (let E = 0; E < 10; ++E) {
+		if (weightedSum(p.x, 1, f.x, m, d), y = p.fx = e(p.x, p.fxprime), x = dot(p.fxprime, d), y > _ + h * m * v || E && y >= b) return w(C, m, b);
+		if (Math.abs(x) <= -g * v) return m;
+		if (x >= 0) return w(m, C, y);
+		b = y, C = m, m *= 2;
 	}
-	return i;
+	return m;
 }
-function v(e, t, n) {
-	let r = {
-		x: t.slice(),
+function conjugateGradient(e, d, f) {
+	let p = {
+		x: d.slice(),
 		fx: 0,
-		fxprime: t.slice()
-	}, i = {
-		x: t.slice(),
+		fxprime: d.slice()
+	}, m = {
+		x: d.slice(),
 		fx: 0,
-		fxprime: t.slice()
-	}, a = t.slice(), o, s, c = 1, l;
-	n ||= {}, l = n.maxIterations || t.length * 20, r.fx = e(r.x, r.fxprime), o = r.fxprime.slice(), m(o, r.fxprime, -1);
-	for (let t = 0; t < l; ++t) {
-		if (c = _(e, o, r, i, c), n.history && n.history.push({
-			x: r.x.slice(),
-			fx: r.fx,
-			fxprime: r.fxprime.slice(),
-			alpha: c
-		}), !c) m(o, r.fxprime, -1);
+		fxprime: d.slice()
+	}, h = d.slice(), g, _, v = 1, y;
+	f ||= {}, y = f.maxIterations || d.length * 20, p.fx = e(p.x, p.fxprime), g = p.fxprime.slice(), scale(g, p.fxprime, -1);
+	for (let d = 0; d < y; ++d) {
+		if (v = wolfeLineSearch(e, g, p, m, v), f.history && f.history.push({
+			x: p.x.slice(),
+			fx: p.fx,
+			fxprime: p.fxprime.slice(),
+			alpha: v
+		}), !v) scale(g, p.fxprime, -1);
 		else {
-			h(a, 1, i.fxprime, -1, r.fxprime);
-			let e = f(r.fxprime, r.fxprime), t = Math.max(0, f(a, i.fxprime) / e);
-			h(o, t, o, -1, i.fxprime), s = r, r = i, i = s;
+			weightedSum(h, 1, m.fxprime, -1, p.fxprime);
+			let e = dot(p.fxprime, p.fxprime), d = Math.max(0, dot(h, m.fxprime) / e);
+			weightedSum(g, d, g, -1, m.fxprime), _ = p, p = m, m = _;
 		}
-		if (p(r.fxprime) <= 1e-5) break;
-	}
-	return n.history && n.history.push({
-		x: r.x.slice(),
-		fx: r.fx,
-		fxprime: r.fxprime.slice(),
-		alpha: c
-	}), r;
-}
-function y(e, t = {}) {
-	t.maxIterations = t.maxIterations || 500;
-	let n = t.initialLayout || T, r = t.lossFunction || O, i = S(e, t), a = n(i, t), o = Object.keys(a), s = [];
-	for (let e of o) s.push(a[e].x), s.push(a[e].y);
-	let c = g((e) => {
-		let t = {};
-		for (let n = 0; n < o.length; ++n) {
-			let r = o[n];
-			t[r] = {
-				x: e[2 * n],
-				y: e[2 * n + 1],
-				radius: a[r].radius
+		if (norm2(p.fxprime) <= 1e-5) break;
+	}
+	return f.history && f.history.push({
+		x: p.x.slice(),
+		fx: p.fx,
+		fxprime: p.fxprime.slice(),
+		alpha: v
+	}), p;
+}
+function venn(e, d = {}) {
+	d.maxIterations = d.maxIterations || 500;
+	let f = d.initialLayout || bestInitialLayout, p = d.lossFunction || lossFunction, m = addMissingAreas(e, d), h = f(m, d), g = Object.keys(h), _ = [];
+	for (let e of g) _.push(h[e].x), _.push(h[e].y);
+	let v = nelderMead((e) => {
+		let d = {};
+		for (let f = 0; f < g.length; ++f) {
+			let p = g[f];
+			d[p] = {
+				x: e[2 * f],
+				y: e[2 * f + 1],
+				radius: h[p].radius
 			};
 		}
-		return r(t, i);
-	}, s, t).x;
-	for (let e = 0; e < o.length; ++e) {
-		let t = o[e];
-		a[t].x = c[2 * e], a[t].y = c[2 * e + 1];
+		return p(d, m);
+	}, _, d).x;
+	for (let e = 0; e < g.length; ++e) {
+		let d = g[e];
+		h[d].x = v[2 * e], h[d].y = v[2 * e + 1];
 	}
-	return a;
+	return h;
 }
-var b = 1e-10;
-function x(e, t, n) {
-	return Math.min(e, t) * Math.min(e, t) * Math.PI <= n + b ? Math.abs(e - t) : l((r) => o(e, t, r) - n, 0, e + t);
+var SMALL = 1e-10;
+function distanceFromIntersectArea(e, d, f) {
+	return Math.min(e, d) * Math.min(e, d) * Math.PI <= f + SMALL ? Math.abs(e - d) : bisect((p) => circleOverlap(e, d, p) - f, 0, e + d);
 }
-function S(e, t = {}) {
-	let n = t.distinct, r = e.map((e) => Object.assign({}, e));
-	function i(e) {
+function addMissingAreas(e, d = {}) {
+	let f = d.distinct, p = e.map((e) => Object.assign({}, e));
+	function m(e) {
 		return e.join(";");
 	}
-	if (n) {
+	if (f) {
 		let e = /* @__PURE__ */ new Map();
-		for (let t of r) for (let n = 0; n < t.sets.length; n++) {
-			let r = String(t.sets[n]);
-			e.set(r, t.size + (e.get(r) || 0));
-			for (let i = n + 1; i < t.sets.length; i++) {
-				let n = String(t.sets[i]), a = `${r};${n}`, o = `${n};${r}`;
-				e.set(a, t.size + (e.get(a) || 0)), e.set(o, t.size + (e.get(o) || 0));
+		for (let d of p) for (let f = 0; f < d.sets.length; f++) {
+			let p = String(d.sets[f]);
+			e.set(p, d.size + (e.get(p) || 0));
+			for (let m = f + 1; m < d.sets.length; m++) {
+				let f = String(d.sets[m]), h = `${p};${f}`, g = `${f};${p}`;
+				e.set(h, d.size + (e.get(h) || 0)), e.set(g, d.size + (e.get(g) || 0));
 			}
 		}
-		for (let t of r) t.sets.length < 3 && (t.size = e.get(i(t.sets)));
+		for (let d of p) d.sets.length < 3 && (d.size = e.get(m(d.sets)));
 	}
-	let a = [], o = /* @__PURE__ */ new Set();
-	for (let e of r) if (e.sets.length === 1) a.push(e.sets[0]);
+	let h = [], g = /* @__PURE__ */ new Set();
+	for (let e of p) if (e.sets.length === 1) h.push(e.sets[0]);
 	else if (e.sets.length === 2) {
-		let t = e.sets[0], n = e.sets[1];
-		o.add(i(e.sets)), o.add(i([n, t]));
-	}
-	a.sort((e, t) => e === t ? 0 : e < t ? -1 : 1);
-	for (let e = 0; e < a.length; ++e) {
-		let t = a[e];
-		for (let n = e + 1; n < a.length; ++n) {
-			let e = a[n];
-			o.has(i([t, e])) || r.push({
-				sets: [t, e],
+		let d = e.sets[0], f = e.sets[1];
+		g.add(m(e.sets)), g.add(m([f, d]));
+	}
+	h.sort((e, d) => e === d ? 0 : e < d ? -1 : 1);
+	for (let e = 0; e < h.length; ++e) {
+		let d = h[e];
+		for (let f = e + 1; f < h.length; ++f) {
+			let e = h[f];
+			g.has(m([d, e])) || p.push({
+				sets: [d, e],
 				size: 0
 			});
 		}
 	}
-	return r;
+	return p;
 }
-function C(e, t, n) {
-	let r = d(t.length, t.length), i = d(t.length, t.length);
+function getDistanceMatrices(e, d, f) {
+	let p = zerosM(d.length, d.length), m = zerosM(d.length, d.length);
 	return e.filter((e) => e.sets.length === 2).forEach((e) => {
-		let a = n[e.sets[0]], o = n[e.sets[1]], s = x(Math.sqrt(t[a].size / Math.PI), Math.sqrt(t[o].size / Math.PI), e.size);
-		r[a][o] = r[o][a] = s;
-		let c = 0;
-		e.size + 1e-10 >= Math.min(t[a].size, t[o].size) ? c = 1 : e.size <= 1e-10 && (c = -1), i[a][o] = i[o][a] = c;
+		let h = f[e.sets[0]], g = f[e.sets[1]], _ = distanceFromIntersectArea(Math.sqrt(d[h].size / Math.PI), Math.sqrt(d[g].size / Math.PI), e.size);
+		p[h][g] = p[g][h] = _;
+		let v = 0;
+		e.size + 1e-10 >= Math.min(d[h].size, d[g].size) ? v = 1 : e.size <= 1e-10 && (v = -1), m[h][g] = m[g][h] = v;
 	}), {
-		distances: r,
-		constraints: i
+		distances: p,
+		constraints: m
 	};
 }
-function w(e, t, n, r) {
-	for (let e = 0; e < t.length; ++e) t[e] = 0;
-	let i = 0;
-	for (let a = 0; a < n.length; ++a) {
-		let o = e[2 * a], s = e[2 * a + 1];
-		for (let c = a + 1; c < n.length; ++c) {
-			let l = e[2 * c], u = e[2 * c + 1], d = n[a][c], f = r[a][c], p = (l - o) * (l - o) + (u - s) * (u - s), m = Math.sqrt(p), h = p - d * d;
-			f > 0 && m <= d || f < 0 && m >= d || (i += 2 * h * h, t[2 * a] += 4 * h * (o - l), t[2 * a + 1] += 4 * h * (s - u), t[2 * c] += 4 * h * (l - o), t[2 * c + 1] += 4 * h * (u - s));
+function constrainedMDSGradient(e, d, f, p) {
+	for (let e = 0; e < d.length; ++e) d[e] = 0;
+	let m = 0;
+	for (let h = 0; h < f.length; ++h) {
+		let g = e[2 * h], _ = e[2 * h + 1];
+		for (let v = h + 1; v < f.length; ++v) {
+			let y = e[2 * v], b = e[2 * v + 1], x = f[h][v], S = p[h][v], C = (y - g) * (y - g) + (b - _) * (b - _), w = Math.sqrt(C), T = C - x * x;
+			S > 0 && w <= x || S < 0 && w >= x || (m += 2 * T * T, d[2 * h] += 4 * T * (g - y), d[2 * h + 1] += 4 * T * (_ - b), d[2 * v] += 4 * T * (y - g), d[2 * v + 1] += 4 * T * (b - _));
 		}
 	}
-	return i;
+	return m;
 }
-function T(e, t = {}) {
-	let n = D(e, t), r = t.lossFunction || O;
+function bestInitialLayout(e, d = {}) {
+	let f = greedyLayout(e, d), p = d.lossFunction || lossFunction;
 	if (e.length >= 8) {
-		let i = E(e, t), a = r(i, e), o = r(n, e);
-		a + 1e-8 < o && (n = i);
-	}
-	return n;
-}
-function E(e, t = {}) {
-	let n = t.restarts || 10, r = [], i = {};
-	for (let t of e) t.sets.length === 1 && (i[t.sets[0]] = r.length, r.push(t));
-	let { distances: a, constraints: o } = C(e, r, i), s = p(a.map(p)) / a.length;
-	a = a.map((e) => e.map((e) => e / s));
-	let c = (e, t) => w(e, t, a, o), l = null;
-	for (let e = 0; e < n; ++e) {
-		let e = v(c, u(a.length * 2).map(Math.random), t);
-		(!l || e.fx < l.fx) && (l = e);
-	}
-	let d = l.x, f = {};
-	for (let e = 0; e < r.length; ++e) {
-		let t = r[e];
-		f[t.sets[0]] = {
-			x: d[2 * e] * s,
-			y: d[2 * e + 1] * s,
-			radius: Math.sqrt(t.size / Math.PI)
-		};
+		let m = constrainedMDSLayout(e, d), h = p(m, e), g = p(f, e);
+		h + 1e-8 < g && (f = m);
 	}
-	if (t.history) for (let e of t.history) m(e.x, s);
 	return f;
 }
-function D(e, t) {
-	let n = t && t.lossFunction ? t.lossFunction : O, r = {}, i = {};
-	for (let t of e) if (t.sets.length === 1) {
-		let e = t.sets[0];
-		r[e] = {
+function constrainedMDSLayout(e, d = {}) {
+	let f = d.restarts || 10, p = [], m = {};
+	for (let d of e) d.sets.length === 1 && (m[d.sets[0]] = p.length, p.push(d));
+	let { distances: h, constraints: g } = getDistanceMatrices(e, p, m), _ = norm2(h.map(norm2)) / h.length;
+	h = h.map((e) => e.map((e) => e / _));
+	let v = (e, d) => constrainedMDSGradient(e, d, h, g), y = null;
+	for (let e = 0; e < f; ++e) {
+		let e = conjugateGradient(v, zeros(h.length * 2).map(Math.random), d);
+		(!y || e.fx < y.fx) && (y = e);
+	}
+	let x = y.x, S = {};
+	for (let e = 0; e < p.length; ++e) {
+		let d = p[e];
+		S[d.sets[0]] = {
+			x: x[2 * e] * _,
+			y: x[2 * e + 1] * _,
+			radius: Math.sqrt(d.size / Math.PI)
+		};
+	}
+	if (d.history) for (let e of d.history) scale(e.x, _);
+	return S;
+}
+function greedyLayout(e, d) {
+	let f = d && d.lossFunction ? d.lossFunction : lossFunction, p = {}, m = {};
+	for (let d of e) if (d.sets.length === 1) {
+		let e = d.sets[0];
+		p[e] = {
 			x: 1e10,
 			y: 1e10,
-			rowid: r.length,
-			size: t.size,
-			radius: Math.sqrt(t.size / Math.PI)
-		}, i[e] = [];
+			rowid: p.length,
+			size: d.size,
+			radius: Math.sqrt(d.size / Math.PI)
+		}, m[e] = [];
 	}
 	e = e.filter((e) => e.sets.length === 2);
-	for (let t of e) {
-		let e = t.weight == null ? 1 : t.weight, n = t.sets[0], a = t.sets[1];
-		t.size + b >= Math.min(r[n].size, r[a].size) && (e = 0), i[n].push({
-			set: a,
-			size: t.size,
+	for (let d of e) {
+		let e = d.weight == null ? 1 : d.weight, f = d.sets[0], h = d.sets[1];
+		d.size + SMALL >= Math.min(p[f].size, p[h].size) && (e = 0), m[f].push({
+			set: h,
+			size: d.size,
 			weight: e
-		}), i[a].push({
-			set: n,
-			size: t.size,
+		}), m[h].push({
+			set: f,
+			size: d.size,
 			weight: e
 		});
 	}
-	let a = [];
-	Object.keys(i).forEach((e) => {
-		let t = 0;
-		for (let n = 0; n < i[e].length; ++n) t += i[e][n].size * i[e][n].weight;
-		a.push({
+	let h = [];
+	Object.keys(m).forEach((e) => {
+		let d = 0;
+		for (let f = 0; f < m[e].length; ++f) d += m[e][f].size * m[e][f].weight;
+		h.push({
 			set: e,
-			size: t
+			size: d
 		});
 	});
-	function o(e, t) {
-		return t.size - e.size;
+	function g(e, d) {
+		return d.size - e.size;
 	}
-	a.sort(o);
-	let c = {};
-	function l(e) {
-		return e.set in c;
+	h.sort(g);
+	let v = {};
+	function y(e) {
+		return e.set in v;
 	}
-	function u(e, t) {
-		r[t].x = e.x, r[t].y = e.y, c[t] = !0;
+	function b(e, d) {
+		p[d].x = e.x, p[d].y = e.y, v[d] = !0;
 	}
-	u({
+	b({
 		x: 0,
 		y: 0
-	}, a[0].set);
-	for (let t = 1; t < a.length; ++t) {
-		let c = a[t].set, f = i[c].filter(l), p = r[c];
-		if (f.sort(o), f.length === 0) throw "ERROR: missing pairwise overlap information";
-		let m = [];
-		for (var d = 0; d < f.length; ++d) {
-			let e = r[f[d].set], t = x(p.radius, e.radius, f[d].size);
-			m.push({
-				x: e.x + t,
+	}, h[0].set);
+	for (let d = 1; d < h.length; ++d) {
+		let v = h[d].set, S = m[v].filter(y), C = p[v];
+		if (S.sort(g), S.length === 0) throw "ERROR: missing pairwise overlap information";
+		let w = [];
+		for (var x = 0; x < S.length; ++x) {
+			let e = p[S[x].set], d = distanceFromIntersectArea(C.radius, e.radius, S[x].size);
+			w.push({
+				x: e.x + d,
 				y: e.y
-			}), m.push({
-				x: e.x - t,
+			}), w.push({
+				x: e.x - d,
 				y: e.y
-			}), m.push({
-				y: e.y + t,
+			}), w.push({
+				y: e.y + d,
 				x: e.x
-			}), m.push({
-				y: e.y - t,
+			}), w.push({
+				y: e.y - d,
 				x: e.x
 			});
-			for (let n = d + 1; n < f.length; ++n) {
-				let i = r[f[n].set], a = x(p.radius, i.radius, f[n].size), o = s({
+			for (let f = x + 1; f < S.length; ++f) {
+				let m = p[S[f].set], h = distanceFromIntersectArea(C.radius, m.radius, S[f].size), g = circleCircleIntersection({
 					x: e.x,
 					y: e.y,
-					radius: t
+					radius: d
 				}, {
-					x: i.x,
-					y: i.y,
-					radius: a
+					x: m.x,
+					y: m.y,
+					radius: h
 				});
-				m.push(...o);
+				w.push(...g);
 			}
 		}
-		let h = 1e50, g = m[0];
-		for (let t of m) {
-			r[c].x = t.x, r[c].y = t.y;
-			let i = n(r, e);
-			i < h && (h = i, g = t);
+		let T = 1e50, E = w[0];
+		for (let d of w) {
+			p[v].x = d.x, p[v].y = d.y;
+			let m = f(p, e);
+			m < T && (T = m, E = d);
 		}
-		u(g, c);
-	}
-	return r;
-}
-function O(e, n) {
-	let r = 0;
-	for (let i of n) {
-		if (i.sets.length === 1) continue;
-		let n;
-		if (i.sets.length === 2) {
-			let t = e[i.sets[0]], r = e[i.sets[1]];
-			n = o(t.radius, r.radius, a(t, r));
-		} else n = t(i.sets.map((t) => e[t]));
-		let s = i.weight == null ? 1 : i.weight;
-		r += s * (n - i.size) * (n - i.size);
-	}
-	return r;
-}
-function k(e, n) {
-	let r = 0;
-	for (let i of n) {
-		if (i.sets.length === 1) continue;
-		let n;
-		if (i.sets.length === 2) {
-			let t = e[i.sets[0]], r = e[i.sets[1]];
-			n = o(t.radius, r.radius, a(t, r));
-		} else n = t(i.sets.map((t) => e[t]));
-		let s = i.weight == null ? 1 : i.weight, c = Math.log((n + 1) / (i.size + 1));
-		r += s * c * c;
-	}
-	return r;
-}
-function A(e, t, n) {
-	if (n == null ? e.sort((e, t) => t.radius - e.radius) : e.sort(n), e.length > 0) {
-		let t = e[0].x, n = e[0].y;
-		for (let r of e) r.x -= t, r.y -= n;
-	}
-	if (e.length === 2 && a(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 n = Math.atan2(e[1].x, e[1].y) - t, r = Math.cos(n), i = Math.sin(n);
-		for (let t of e) {
-			let e = t.x, n = t.y;
-			t.x = r * e - i * n, t.y = i * e + r * n;
+		b(E, v);
+	}
+	return p;
+}
+function lossFunction(e, f) {
+	let p = 0;
+	for (let m of f) {
+		if (m.sets.length === 1) continue;
+		let f;
+		if (m.sets.length === 2) {
+			let d = e[m.sets[0]], p = e[m.sets[1]];
+			f = circleOverlap(d.radius, p.radius, distance(d, p));
+		} else f = intersectionArea(m.sets.map((d) => e[d]));
+		let _ = m.weight == null ? 1 : m.weight;
+		p += _ * (f - m.size) * (f - m.size);
+	}
+	return p;
+}
+function logRatioLossFunction(e, f) {
+	let p = 0;
+	for (let m of f) {
+		if (m.sets.length === 1) continue;
+		let f;
+		if (m.sets.length === 2) {
+			let d = e[m.sets[0]], p = e[m.sets[1]];
+			f = circleOverlap(d.radius, p.radius, distance(d, p));
+		} else f = intersectionArea(m.sets.map((d) => e[d]));
+		let _ = m.weight == null ? 1 : m.weight, v = Math.log((f + 1) / (m.size + 1));
+		p += _ * v * v;
+	}
+	return p;
+}
+function orientateCircles(e, d, f) {
+	if (f == null ? e.sort((e, d) => d.radius - e.radius) : e.sort(f), e.length > 0) {
+		let d = e[0].x, f = e[0].y;
+		for (let p of e) p.x -= d, p.y -= f;
+	}
+	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 f = Math.atan2(e[1].x, e[1].y) - d, p = Math.cos(f), m = Math.sin(f);
+		for (let d of e) {
+			let e = d.x, f = d.y;
+			d.x = p * e - m * f, d.y = m * e + p * f;
 		}
 	}
 	if (e.length > 2) {
-		let n = Math.atan2(e[2].x, e[2].y) - t;
-		for (; n < 0;) n += 2 * Math.PI;
-		for (; n > 2 * Math.PI;) n -= 2 * Math.PI;
-		if (n > Math.PI) {
-			let t = e[1].y / (1e-10 + e[1].x);
-			for (let n of e) {
-				var r = (n.x + t * n.y) / (1 + t * t);
-				n.x = 2 * r - n.x, n.y = 2 * r * t - n.y;
+		let f = Math.atan2(e[2].x, e[2].y) - d;
+		for (; f < 0;) f += 2 * Math.PI;
+		for (; f > 2 * Math.PI;) f -= 2 * Math.PI;
+		if (f > Math.PI) {
+			let d = e[1].y / (1e-10 + e[1].x);
+			for (let f of e) {
+				var p = (f.x + d * f.y) / (1 + d * d);
+				f.x = 2 * p - f.x, f.y = 2 * p * d - f.y;
 			}
 		}
 	}
 }
-function j(e) {
+function disjointCluster(e) {
 	e.forEach((e) => {
 		e.parent = e;
 	});
-	function t(e) {
-		return e.parent !== e && (e.parent = t(e.parent)), e.parent;
+	function d(e) {
+		return e.parent !== e && (e.parent = d(e.parent)), e.parent;
 	}
-	function n(e, n) {
-		let r = t(e);
-		r.parent = t(n);
+	function f(e, f) {
+		let p = d(e);
+		p.parent = d(f);
 	}
-	for (let t = 0; t < e.length; ++t) for (let r = t + 1; r < e.length; ++r) {
-		let i = e[t].radius + e[r].radius;
-		a(e[t], e[r]) + 1e-10 < i && n(e[r], e[t]);
+	for (let d = 0; d < e.length; ++d) for (let p = d + 1; p < e.length; ++p) {
+		let m = e[d].radius + e[p].radius;
+		distance(e[d], e[p]) + 1e-10 < m && f(e[p], e[d]);
 	}
-	let r = /* @__PURE__ */ new Map();
-	for (let n = 0; n < e.length; ++n) {
-		let i = t(e[n]).parent.setid;
-		r.has(i) || r.set(i, []), r.get(i).push(e[n]);
+	let p = /* @__PURE__ */ new Map();
+	for (let f = 0; f < e.length; ++f) {
+		let m = d(e[f]).parent.setid;
+		p.has(m) || p.set(m, []), p.get(m).push(e[f]);
 	}
 	return e.forEach((e) => {
 		delete e.parent;
-	}), Array.from(r.values());
+	}), Array.from(p.values());
 }
-function M(e) {
-	let t = (t) => ({
-		max: e.reduce((e, n) => Math.max(e, n[t] + n.radius), -Infinity),
-		min: e.reduce((e, n) => Math.min(e, n[t] - n.radius), Infinity)
+function getBoundingBox(e) {
+	let d = (d) => ({
+		max: e.reduce((e, f) => Math.max(e, f[d] + f.radius), -Infinity),
+		min: e.reduce((e, f) => Math.min(e, f[d] - f.radius), Infinity)
 	});
 	return {
-		xRange: t("x"),
-		yRange: t("y")
+		xRange: d("x"),
+		yRange: d("y")
 	};
 }
-function N(e, t, n) {
-	t ??= Math.PI / 2;
-	let r = I(e).map((e) => Object.assign({}, e)), i = j(r);
-	for (let e of i) {
-		A(e, t, n);
-		let r = M(e);
-		e.size = (r.xRange.max - r.xRange.min) * (r.yRange.max - r.yRange.min), e.bounds = r;
-	}
-	i.sort((e, t) => t.size - e.size), r = i[0];
-	let a = r.bounds, o = (a.xRange.max - a.xRange.min) / 50;
-	function s(e, t, n) {
+function normalizeSolution(e, d, f) {
+	d ??= Math.PI / 2;
+	let p = fromObjectNotation(e).map((e) => Object.assign({}, e)), m = disjointCluster(p);
+	for (let e of m) {
+		orientateCircles(e, d, f);
+		let p = getBoundingBox(e);
+		e.size = (p.xRange.max - p.xRange.min) * (p.yRange.max - p.yRange.min), e.bounds = p;
+	}
+	m.sort((e, d) => d.size - e.size), p = m[0];
+	let h = p.bounds, g = (h.xRange.max - h.xRange.min) / 50;
+	function _(e, d, f) {
 		if (!e) return;
-		let i = e.bounds, s, c;
-		if (t) s = a.xRange.max - i.xRange.min + o;
+		let m = e.bounds, _, v;
+		if (d) _ = h.xRange.max - m.xRange.min + g;
 		else {
-			s = a.xRange.max - i.xRange.max;
-			let e = (i.xRange.max - i.xRange.min) / 2 - (a.xRange.max - a.xRange.min) / 2;
-			e < 0 && (s += e);
+			_ = h.xRange.max - m.xRange.max;
+			let e = (m.xRange.max - m.xRange.min) / 2 - (h.xRange.max - h.xRange.min) / 2;
+			e < 0 && (_ += e);
 		}
-		if (n) c = a.yRange.max - i.yRange.min + o;
+		if (f) v = h.yRange.max - m.yRange.min + g;
 		else {
-			c = a.yRange.max - i.yRange.max;
-			let e = (i.yRange.max - i.yRange.min) / 2 - (a.yRange.max - a.yRange.min) / 2;
-			e < 0 && (c += e);
+			v = h.yRange.max - m.yRange.max;
+			let e = (m.yRange.max - m.yRange.min) / 2 - (h.yRange.max - h.yRange.min) / 2;
+			e < 0 && (v += e);
 		}
-		for (let t of e) t.x += s, t.y += c, r.push(t);
-	}
-	let c = 1;
-	for (; c < i.length;) s(i[c], !0, !1), s(i[c + 1], !1, !0), s(i[c + 2], !0, !0), c += 3, a = M(r);
-	return F(r);
-}
-function P(e, t, n, r, i) {
-	let a = I(e);
-	t -= 2 * r, n -= 2 * r;
-	let { xRange: o, yRange: s } = M(a);
-	if (o.max === o.min || s.max === s.min) return console.log("not scaling solution: zero size detected"), e;
-	let c, l;
-	if (i) {
-		let e = Math.sqrt(i / Math.PI) * 2;
-		c = t / e, l = n / e;
-	} else c = t / (o.max - o.min), l = n / (s.max - s.min);
-	let u = Math.min(l, c), d = (t - (o.max - o.min) * u) / 2, f = (n - (s.max - s.min) * u) / 2;
-	return F(a.map((e) => ({
-		radius: u * e.radius,
-		x: r + d + (e.x - o.min) * u,
-		y: r + f + (e.y - s.min) * u,
+		for (let d of e) d.x += _, d.y += v, p.push(d);
+	}
+	let v = 1;
+	for (; v < m.length;) _(m[v], !0, !1), _(m[v + 1], !1, !0), _(m[v + 2], !0, !0), v += 3, h = getBoundingBox(p);
+	return toObjectNotation(p);
+}
+function scaleSolution(e, d, f, p, m) {
+	let h = fromObjectNotation(e);
+	d -= 2 * p, f -= 2 * p;
+	let { xRange: g, yRange: _ } = getBoundingBox(h);
+	if (g.max === g.min || _.max === _.min) return console.log("not scaling solution: zero size detected"), e;
+	let v, y;
+	if (m) {
+		let e = Math.sqrt(m / Math.PI) * 2;
+		v = d / e, y = f / e;
+	} else v = d / (g.max - g.min), y = f / (_.max - _.min);
+	let b = Math.min(y, v), x = (d - (g.max - g.min) * b) / 2, S = (f - (_.max - _.min) * b) / 2;
+	return toObjectNotation(h.map((e) => ({
+		radius: b * e.radius,
+		x: p + x + (e.x - g.min) * b,
+		y: p + S + (e.y - _.min) * b,
 		setid: e.setid
 	})));
 }
-function F(e) {
-	let t = {};
-	for (let n of e) t[n.setid] = n;
-	return t;
+function toObjectNotation(e) {
+	let d = {};
+	for (let f of e) d[f.setid] = f;
+	return d;
 }
-function I(e) {
-	return Object.keys(e).map((t) => Object.assign(e[t], { setid: t }));
+function fromObjectNotation(e) {
+	return Object.keys(e).map((d) => Object.assign(e[d], { setid: d }));
 }
-function L(e = {}) {
-	let t = !1, n = 600, r = 350, i = 15, a = 1e3, o = Math.PI / 2, s = !0, c = null, l = !0, u = !0, d = null, f = null, p = !1, m = null, h = e && e.symmetricalTextCentre ? e.symmetricalTextCentre : !1, g = {}, _ = e && e.colourScheme ? e.colourScheme : e && e.colorScheme ? e.colorScheme : [
+function VennDiagram(e = {}) {
+	let d = !1, f = 600, p = 350, m = 15, h = 1e3, g = Math.PI / 2, _ = !0, v = null, y = !0, b = !0, x = null, S = null, C = !1, w = null, T = e && e.symmetricalTextCentre ? e.symmetricalTextCentre : !1, E = {}, D = e && e.colourScheme ? e.colourScheme : e && e.colorScheme ? e.colorScheme : [
 		"#1f77b4",
 		"#ff7f0e",
 		"#2ca02c",
@@ -600,306 +599,305 @@ function L(e = {}) {
 		"#7f7f7f",
 		"#bcbd22",
 		"#17becf"
-	], v = 0, b = function(e) {
-		if (e in g) return g[e];
-		var t = g[e] = _[v];
-		return v += 1, v >= _.length && (v = 0), t;
-	}, x = y, S = O;
-	function C(g) {
-		let _ = g.datum(), v = /* @__PURE__ */ new Set();
-		_.forEach((e) => {
-			e.size == 0 && e.sets.length == 1 && v.add(e.sets[0]);
-		}), _ = _.filter((e) => !e.sets.some((e) => v.has(e)));
-		let y = {}, C = {};
-		if (_.length > 0) {
-			let e = x(_, {
-				lossFunction: S,
-				distinct: p
+	], O = 0, A = function(e) {
+		if (e in E) return E[e];
+		var d = E[e] = D[O];
+		return O += 1, O >= D.length && (O = 0), d;
+	}, j = venn, M = lossFunction;
+	function N(E) {
+		let D = E.datum(), O = /* @__PURE__ */ new Set();
+		D.forEach((e) => {
+			e.size == 0 && e.sets.length == 1 && O.add(e.sets[0]);
+		}), D = D.filter((e) => !e.sets.some((e) => O.has(e)));
+		let k = {}, N = {};
+		if (D.length > 0) {
+			let e = j(D, {
+				lossFunction: M,
+				distinct: C
 			});
-			s && (e = N(e, o, f)), y = P(e, n, r, i, c), C = H(y, _, h);
+			_ && (e = normalizeSolution(e, g, S)), k = scaleSolution(e, f, p, m, v), N = computeTextCentres(k, D, T);
 		}
-		let w = {};
-		_.forEach((e) => {
-			e.label && (w[e.sets] = e.label);
+		let P = {};
+		D.forEach((e) => {
+			e.label && (P[e.sets] = e.label);
 		});
-		function T(e) {
-			if (e.sets in w) return w[e.sets];
+		function F(e) {
+			if (e.sets in P) return P[e.sets];
 			if (e.sets.length == 1) return "" + e.sets[0];
 		}
-		g.selectAll("svg").data([y]).enter().append("svg");
-		let E = g.select("svg");
-		t ? E.attr("viewBox", `0 0 ${n} ${r}`) : E.attr("width", n).attr("height", r);
-		let D = {}, O = !1;
-		E.selectAll(".venn-area path").each(function(e) {
-			let t = this.getAttribute("d");
-			e.sets.length == 1 && t && !p && (O = !0, D[e.sets[0]] = W(t));
+		E.selectAll("svg").data([k]).enter().append("svg");
+		let I = E.select("svg");
+		d ? I.attr("viewBox", `0 0 ${f} ${p}`) : I.attr("width", f).attr("height", p);
+		let L = {}, R = !1;
+		I.selectAll(".venn-area path").each(function(e) {
+			let d = this.getAttribute("d");
+			e.sets.length == 1 && d && !C && (R = !0, L[e.sets[0]] = circleFromPath(d));
 		});
-		function k(e) {
-			return (t) => q(e.sets.map((e) => {
-				let i = D[e], a = y[e];
-				return i ||= {
-					x: n / 2,
-					y: r / 2,
+		function z(e) {
+			return (d) => intersectionAreaPath(e.sets.map((e) => {
+				let m = L[e], h = k[e];
+				return m ||= {
+					x: f / 2,
+					y: p / 2,
 					radius: 1
-				}, a ||= {
-					x: n / 2,
-					y: r / 2,
+				}, h ||= {
+					x: f / 2,
+					y: p / 2,
 					radius: 1
 				}, {
-					x: i.x * (1 - t) + a.x * t,
-					y: i.y * (1 - t) + a.y * t,
-					radius: i.radius * (1 - t) + a.radius * t
+					x: m.x * (1 - d) + h.x * d,
+					y: m.y * (1 - d) + h.y * d,
+					radius: m.radius * (1 - d) + h.radius * d
 				};
-			}), m);
+			}), w);
 		}
-		let A = E.selectAll(".venn-area").data(_, (e) => e.sets), j = A.enter().append("g").attr("class", (e) => `venn-area venn-${e.sets.length == 1 ? "circle" : "intersection"}${e.colour || e.color ? " venn-coloured" : ""}`).attr("data-venn-sets", (e) => e.sets.join("_")), M = j.append("path"), F = j.append("text").attr("class", "label").text((e) => T(e)).attr("text-anchor", "middle").attr("dy", ".35em").attr("x", n / 2).attr("y", r / 2);
-		u && (M.style("fill-opacity", "0").filter((e) => e.sets.length == 1).style("fill", (e) => e.colour ? e.colour : e.color ? e.color : b(e.sets)).style("fill-opacity", ".25"), F.style("fill", (t) => t.colour || t.color ? "#FFF" : e.textFill ? e.textFill : t.sets.length == 1 ? b(t.sets) : "#444"));
-		function I(e) {
-			return typeof e.transition == "function" ? e.transition("venn").duration(a) : e;
+		let B = I.selectAll(".venn-area").data(D, (e) => e.sets), V = B.enter().append("g").attr("class", (e) => `venn-area venn-${e.sets.length == 1 ? "circle" : "intersection"}${e.colour || e.color ? " venn-coloured" : ""}`).attr("data-venn-sets", (e) => e.sets.join("_")), H = V.append("path"), U = V.append("text").attr("class", "label").text((e) => F(e)).attr("text-anchor", "middle").attr("dy", ".35em").attr("x", f / 2).attr("y", p / 2);
+		b && (H.style("fill-opacity", "0").filter((e) => e.sets.length == 1).style("fill", (e) => e.colour ? e.colour : e.color ? e.color : A(e.sets)).style("fill-opacity", ".25"), U.style("fill", (d) => d.colour || d.color ? "#FFF" : e.textFill ? e.textFill : d.sets.length == 1 ? A(d.sets) : "#444"));
+		function W(e) {
+			return typeof e.transition == "function" ? e.transition("venn").duration(h) : e;
 		}
-		let L = g;
-		O && typeof L.transition == "function" ? (L = I(g), L.selectAll("path").attrTween("d", k)) : L.selectAll("path").attr("d", (e) => q(e.sets.map((e) => y[e])), m);
-		let z = L.selectAll("text").filter((e) => e.sets in C).text((e) => T(e)).attr("x", (e) => Math.floor(C[e.sets].x)).attr("y", (e) => Math.floor(C[e.sets].y));
-		l && (O ? "on" in z ? z.on("end", R(y, T)) : z.each("end", R(y, T)) : z.each(R(y, T)));
-		let B = I(A.exit()).remove();
-		typeof A.transition == "function" && B.selectAll("path").attrTween("d", k);
-		let V = B.selectAll("text").attr("x", n / 2).attr("y", r / 2);
-		return d !== null && (F.style("font-size", "0px"), z.style("font-size", d), V.style("font-size", "0px")), {
-			circles: y,
-			textCentres: C,
-			nodes: A,
-			enter: j,
-			update: L,
-			exit: B
+		let G = E;
+		R && typeof G.transition == "function" ? (G = W(E), G.selectAll("path").attrTween("d", z)) : G.selectAll("path").attr("d", (e) => intersectionAreaPath(e.sets.map((e) => k[e])), w);
+		let K = G.selectAll("text").filter((e) => e.sets in N).text((e) => F(e)).attr("x", (e) => Math.floor(N[e.sets].x)).attr("y", (e) => Math.floor(N[e.sets].y));
+		y && (R ? "on" in K ? K.on("end", wrapText(k, F)) : K.each("end", wrapText(k, F)) : K.each(wrapText(k, F)));
+		let q = W(B.exit()).remove();
+		typeof B.transition == "function" && q.selectAll("path").attrTween("d", z);
+		let J = q.selectAll("text").attr("x", f / 2).attr("y", p / 2);
+		return x !== null && (U.style("font-size", "0px"), K.style("font-size", x), J.style("font-size", "0px")), {
+			circles: k,
+			textCentres: N,
+			nodes: B,
+			enter: V,
+			update: G,
+			exit: q
 		};
 	}
-	return C.wrap = function(e) {
-		return arguments.length ? (l = e, C) : l;
-	}, C.useViewBox = function() {
-		return t = !0, C;
-	}, C.width = function(e) {
-		return arguments.length ? (n = e, C) : n;
-	}, C.height = function(e) {
-		return arguments.length ? (r = e, C) : r;
-	}, C.padding = function(e) {
-		return arguments.length ? (i = e, C) : i;
-	}, C.distinct = function(e) {
-		return arguments.length ? (p = e, C) : p;
-	}, C.colours = function(e) {
-		return arguments.length ? (b = e, C) : b;
-	}, C.colors = function(e) {
-		return arguments.length ? (b = e, C) : b;
-	}, C.fontSize = function(e) {
-		return arguments.length ? (d = e, C) : d;
-	}, C.round = function(e) {
-		return arguments.length ? (m = e, C) : m;
-	}, C.duration = function(e) {
-		return arguments.length ? (a = e, C) : a;
-	}, C.layoutFunction = function(e) {
-		return arguments.length ? (x = e, C) : x;
-	}, C.normalize = function(e) {
-		return arguments.length ? (s = e, C) : s;
-	}, C.scaleToFit = function(e) {
-		return arguments.length ? (c = e, C) : c;
-	}, C.styled = function(e) {
-		return arguments.length ? (u = e, C) : u;
-	}, C.orientation = function(e) {
-		return arguments.length ? (o = e, C) : o;
-	}, C.orientationOrder = function(e) {
-		return arguments.length ? (f = e, C) : f;
-	}, C.lossFunction = function(e) {
-		return arguments.length ? (S = e === "default" ? O : e === "logRatio" ? k : e, C) : S;
-	}, C;
-}
-function R(e, t) {
-	return function(n) {
-		let r = this, i = e[n.sets[0]].radius || 50, a = t(n) || "", o = a.split(/\s+/).reverse(), s = (a.length + o.length) / 3, c = o.pop(), l = [c], u = 0, d = 1.1;
-		r.textContent = null;
-		let f = [];
-		function p(e) {
-			let t = r.ownerDocument.createElementNS(r.namespaceURI, "tspan");
-			return t.textContent = e, f.push(t), r.append(t), t;
+	return N.wrap = function(e) {
+		return arguments.length ? (y = e, N) : y;
+	}, N.useViewBox = function() {
+		return d = !0, N;
+	}, N.width = function(e) {
+		return arguments.length ? (f = e, N) : f;
+	}, N.height = function(e) {
+		return arguments.length ? (p = e, N) : p;
+	}, N.padding = function(e) {
+		return arguments.length ? (m = e, N) : m;
+	}, N.distinct = function(e) {
+		return arguments.length ? (C = e, N) : C;
+	}, N.colours = function(e) {
+		return arguments.length ? (A = e, N) : A;
+	}, N.colors = function(e) {
+		return arguments.length ? (A = e, N) : A;
+	}, N.fontSize = function(e) {
+		return arguments.length ? (x = e, N) : x;
+	}, N.round = function(e) {
+		return arguments.length ? (w = e, N) : w;
+	}, N.duration = function(e) {
+		return arguments.length ? (h = e, N) : h;
+	}, N.layoutFunction = function(e) {
+		return arguments.length ? (j = e, N) : j;
+	}, N.normalize = function(e) {
+		return arguments.length ? (_ = e, N) : _;
+	}, N.scaleToFit = function(e) {
+		return arguments.length ? (v = e, N) : v;
+	}, N.styled = function(e) {
+		return arguments.length ? (b = e, N) : b;
+	}, N.orientation = function(e) {
+		return arguments.length ? (g = e, N) : g;
+	}, N.orientationOrder = function(e) {
+		return arguments.length ? (S = e, N) : S;
+	}, N.lossFunction = function(e) {
+		return arguments.length ? (M = e === "default" ? lossFunction : e === "logRatio" ? logRatioLossFunction : e, N) : M;
+	}, N;
+}
+function wrapText(e, d) {
+	return function(f) {
+		let p = this, m = e[f.sets[0]].radius || 50, h = d(f) || "", g = h.split(/\s+/).reverse(), _ = (h.length + g.length) / 3, v = g.pop(), y = [v], b = 0, x = 1.1;
+		p.textContent = null;
+		let S = [];
+		function C(e) {
+			let d = p.ownerDocument.createElementNS(p.namespaceURI, "tspan");
+			return d.textContent = e, S.push(d), p.append(d), d;
 		}
-		let m = p(c);
-		for (; c = o.pop(), c;) {
-			l.push(c);
-			let e = l.join(" ");
-			m.textContent = e, e.length > s && m.getComputedTextLength() > i && (l.pop(), m.textContent = l.join(" "), l = [c], m = p(c), u++);
+		let w = C(v);
+		for (; v = g.pop(), v;) {
+			y.push(v);
+			let e = y.join(" ");
+			w.textContent = e, e.length > _ && w.getComputedTextLength() > m && (y.pop(), w.textContent = y.join(" "), y = [v], w = C(v), b++);
 		}
-		let h = .35 - u * d / 2, g = r.getAttribute("x"), _ = r.getAttribute("y");
-		f.forEach((e, t) => {
-			e.setAttribute("x", g), e.setAttribute("y", _), e.setAttribute("dy", `${h + t * d}em`);
+		let T = .35 - b * x / 2, E = p.getAttribute("x"), D = p.getAttribute("y");
+		S.forEach((e, d) => {
+			e.setAttribute("x", E), e.setAttribute("y", D), e.setAttribute("dy", `${T + d * x}em`);
 		});
 	};
 }
-function z(e, t, n) {
-	let r = t[0].radius - a(t[0], e);
-	for (let n = 1; n < t.length; ++n) {
-		let i = t[n].radius - a(t[n], e);
-		i <= r && (r = i);
-	}
-	for (let t = 0; t < n.length; ++t) {
-		let i = a(n[t], e) - n[t].radius;
-		i <= r && (r = i);
-	}
-	return r;
-}
-function B(e, n, r) {
-	let i = [];
-	for (let t of e) i.push({
-		x: t.x,
-		y: t.y
-	}), i.push({
-		x: t.x + t.radius / 2,
-		y: t.y
-	}), i.push({
-		x: t.x - t.radius / 2,
-		y: t.y
-	}), i.push({
-		x: t.x,
-		y: t.y + t.radius / 2
-	}), i.push({
-		x: t.x,
-		y: t.y - t.radius / 2
+function circleMargin(e, d, f) {
+	let p = d[0].radius - distance(d[0], e);
+	for (let f = 1; f < d.length; ++f) {
+		let m = d[f].radius - distance(d[f], e);
+		m <= p && (p = m);
+	}
+	for (let d = 0; d < f.length; ++d) {
+		let m = distance(f[d], e) - f[d].radius;
+		m <= p && (p = m);
+	}
+	return p;
+}
+function computeTextCentre(e, f, p) {
+	let m = [];
+	for (let d of e) m.push({
+		x: d.x,
+		y: d.y
+	}), m.push({
+		x: d.x + d.radius / 2,
+		y: d.y
+	}), m.push({
+		x: d.x - d.radius / 2,
+		y: d.y
+	}), m.push({
+		x: d.x,
+		y: d.y + d.radius / 2
+	}), m.push({
+		x: d.x,
+		y: d.y - d.radius / 2
 	});
-	let o = i[0], s = z(i[0], e, n);
-	for (let t = 1; t < i.length; ++t) {
-		let r = z(i[t], e, n);
-		r >= s && (o = i[t], s = r);
-	}
-	let l = g((t) => -1 * z({
-		x: t[0],
-		y: t[1]
-	}, e, n), [o.x, o.y], {
+	let g = m[0], _ = circleMargin(m[0], e, f);
+	for (let d = 1; d < m.length; ++d) {
+		let p = circleMargin(m[d], e, f);
+		p >= _ && (g = m[d], _ = p);
+	}
+	let y = nelderMead((d) => -1 * circleMargin({
+		x: d[0],
+		y: d[1]
+	}, e, f), [g.x, g.y], {
 		maxIterations: 500,
 		minErrorDelta: 1e-10
-	}).x, u = {
-		x: r ? 0 : l[0],
-		y: l[1]
-	}, d = !0;
-	for (let t of e) if (a(u, t) > t.radius) {
-		d = !1;
+	}).x, b = {
+		x: p ? 0 : y[0],
+		y: y[1]
+	}, x = !0;
+	for (let d of e) if (distance(b, d) > d.radius) {
+		x = !1;
 		break;
 	}
-	for (let e of n) if (a(u, e) < e.radius) {
-		d = !1;
+	for (let e of f) if (distance(b, e) < e.radius) {
+		x = !1;
 		break;
 	}
-	if (d) return u;
+	if (x) return b;
 	if (e.length == 1) return {
 		x: e[0].x,
 		y: e[0].y
 	};
-	let f = {};
-	return t(e, f), f.arcs.length === 0 ? {
+	let S = {};
+	return intersectionArea(e, S), S.arcs.length === 0 ? {
 		x: 0,
 		y: -1e3,
 		disjoint: !0
-	} : f.arcs.length == 1 ? {
-		x: f.arcs[0].circle.x,
-		y: f.arcs[0].circle.y
-	} : n.length ? B(e, []) : c(f.arcs.map((e) => e.p1));
-}
-function V(e) {
-	let t = {}, n = Object.keys(e);
-	for (let e of n) t[e] = [];
-	for (let r = 0; r < n.length; r++) {
-		let i = n[r], o = e[i];
-		for (let s = r + 1; s < n.length; ++s) {
-			let r = n[s], c = e[r], l = a(o, c);
-			l + c.radius <= o.radius + 1e-10 ? t[r].push(i) : l + o.radius <= c.radius + 1e-10 && t[i].push(r);
+	} : S.arcs.length == 1 ? {
+		x: S.arcs[0].circle.x,
+		y: S.arcs[0].circle.y
+	} : f.length ? computeTextCentre(e, []) : getCenter(S.arcs.map((e) => e.p1));
+}
+function getOverlappingCircles(e) {
+	let d = {}, f = Object.keys(e);
+	for (let e of f) d[e] = [];
+	for (let p = 0; p < f.length; p++) {
+		let m = f[p], g = e[m];
+		for (let _ = p + 1; _ < f.length; ++_) {
+			let p = f[_], v = e[p], y = distance(g, v);
+			y + v.radius <= g.radius + 1e-10 ? d[p].push(m) : y + g.radius <= v.radius + 1e-10 && d[m].push(p);
 		}
 	}
-	return t;
+	return d;
 }
-function H(e, t, n) {
-	let r = {}, i = V(e);
-	for (let a = 0; a < t.length; ++a) {
-		let o = t[a].sets, s = {}, c = {};
-		for (let e = 0; e < o.length; ++e) {
-			s[o[e]] = !0;
-			let t = i[o[e]];
-			for (let e = 0; e < t.length; ++e) c[t[e]] = !0;
+function computeTextCentres(e, d, f) {
+	let p = {}, m = getOverlappingCircles(e);
+	for (let h = 0; h < d.length; ++h) {
+		let g = d[h].sets, _ = {}, v = {};
+		for (let e = 0; e < g.length; ++e) {
+			_[g[e]] = !0;
+			let d = m[g[e]];
+			for (let e = 0; e < d.length; ++e) v[d[e]] = !0;
 		}
-		let l = [], u = [];
-		for (let t in e) t in s ? l.push(e[t]) : t in c || u.push(e[t]);
-		let d = B(l, u, n);
-		r[o] = d, d.disjoint && t[a].size > 0 && console.log("WARNING: area " + o + " not represented on screen");
+		let y = [], b = [];
+		for (let d in e) d in _ ? y.push(e[d]) : d in v || b.push(e[d]);
+		let x = computeTextCentre(y, b, f);
+		p[g] = x, x.disjoint && d[h].size > 0 && console.log("WARNING: area " + g + " not represented on screen");
 	}
-	return r;
+	return p;
 }
-function U(e, t, n) {
-	let r = [];
-	return r.push("\nM", e, t), r.push("\nm", -n, 0), r.push("\na", n, n, 0, 1, 0, n * 2, 0), r.push("\na", n, n, 0, 1, 0, -n * 2, 0), r.join(" ");
+function circlePath(e, d, f) {
+	let p = [];
+	return p.push("\nM", e, d), p.push("\nm", -f, 0), p.push("\na", f, f, 0, 1, 0, f * 2, 0), p.push("\na", f, f, 0, 1, 0, -f * 2, 0), p.join(" ");
 }
-function W(e) {
-	let t = e.split(" ");
+function circleFromPath(e) {
+	let d = e.split(" ");
 	return {
-		x: Number.parseFloat(t[1]),
-		y: Number.parseFloat(t[2]),
-		radius: -Number.parseFloat(t[4])
+		x: Number.parseFloat(d[1]),
+		y: Number.parseFloat(d[2]),
+		radius: -Number.parseFloat(d[4])
 	};
 }
-function G(e) {
+function intersectionAreaArcs(e) {
 	if (e.length === 0) return [];
-	let n = {};
-	return t(e, n), n.arcs;
+	let f = {};
+	return intersectionArea(e, f), f.arcs;
 }
-function K(e, t) {
+function arcsToPath(e, d) {
 	if (e.length === 0) return "M 0 0";
-	let n = 10 ** (t || 0), r = t == null ? (e) => e : (e) => Math.round(e * n) / n;
+	let f = 10 ** (d || 0), p = d == null ? (e) => e : (e) => Math.round(e * f) / f;
 	if (e.length == 1) {
-		let t = e[0].circle;
-		return U(r(t.x), r(t.y), r(t.radius));
+		let d = e[0].circle;
+		return circlePath(p(d.x), p(d.y), p(d.radius));
 	}
-	let i = [
+	let m = [
 		"\nM",
-		r(e[0].p2.x),
-		r(e[0].p2.y)
+		p(e[0].p2.x),
+		p(e[0].p2.y)
 	];
-	for (let t of e) {
-		let e = r(t.circle.radius);
-		i.push("\nA", e, e, 0, +!!t.large, +!!t.sweep, r(t.p1.x), r(t.p1.y));
+	for (let d of e) {
+		let e = p(d.circle.radius);
+		m.push("\nA", e, e, 0, d.large ? 1 : 0, d.sweep ? 1 : 0, p(d.p1.x), p(d.p1.y));
 	}
-	return i.join(" ");
+	return m.join(" ");
 }
-function q(e, t) {
-	return K(G(e), t);
+function intersectionAreaPath(e, d) {
+	return arcsToPath(intersectionAreaArcs(e), d);
 }
-function J(e, t = {}) {
-	let { lossFunction: n, layoutFunction: r = y, normalize: i = !0, orientation: a = Math.PI / 2, orientationOrder: o, width: s = 600, height: c = 350, padding: l = 15, scaleToFit: u = !1, symmetricalTextCentre: d = !1, distinct: f, round: p = 2 } = t, m = r(e, {
-		lossFunction: n === "default" || !n ? O : n === "logRatio" ? k : n,
-		distinct: f
+function layout(e, d = {}) {
+	let { lossFunction: f, layoutFunction: p = venn, normalize: m = !0, orientation: h = Math.PI / 2, orientationOrder: g, width: _ = 600, height: v = 350, padding: y = 15, scaleToFit: b = !1, symmetricalTextCentre: x = !1, distinct: S, round: C = 2 } = d, w = p(e, {
+		lossFunction: f === "default" || !f ? lossFunction : f === "logRatio" ? logRatioLossFunction : f,
+		distinct: S
 	});
-	i && (m = N(m, a, o));
-	let h = P(m, s, c, l, u), g = H(h, e, d), _ = new Map(Object.keys(h).map((e) => [e, {
+	m && (w = normalizeSolution(w, h, g));
+	let T = scaleSolution(w, _, v, y, b), E = computeTextCentres(T, e, x), D = new Map(Object.keys(T).map((e) => [e, {
 		set: e,
-		x: h[e].x,
-		y: h[e].y,
-		radius: h[e].radius
-	}])), v = e.map((e) => {
-		let t = e.sets.map((e) => _.get(e)), n = G(t);
+		x: T[e].x,
+		y: T[e].y,
+		radius: T[e].radius
+	}])), O = e.map((e) => {
+		let d = e.sets.map((e) => D.get(e)), f = intersectionAreaArcs(d);
 		return {
-			circles: t,
-			arcs: n,
-			path: K(n, p),
+			circles: d,
+			arcs: f,
+			path: arcsToPath(f, C),
 			area: e,
 			has: new Set(e.sets)
 		};
 	});
-	function b(e) {
-		let t = "";
-		for (let n of v) n.has.size > e.length && e.every((e) => n.has.has(e)) && (t += " " + n.path);
-		return t;
-	}
-	return v.map(({ circles: e, arcs: t, path: n, area: r }) => ({
-		data: r,
-		text: g[r.sets],
+	function A(e) {
+		let d = "";
+		for (let f of O) f.has.size > e.length && e.every((e) => f.has.has(e)) && (d += " " + f.path);
+		return d;
+	}
+	return O.map(({ circles: e, arcs: d, path: f, area: p }) => ({
+		data: p,
+		text: E[p.sets],
 		circles: e,
-		arcs: t,
-		path: n,
-		distinctPath: n + b(r.sets)
+		arcs: d,
+		path: f,
+		distinctPath: f + A(p.sets)
 	}));
 }
-//#endregion
-export { L as VennDiagram, J as layout };
+export { VennDiagram, layout };