@loopstack/loopstack-studio 0.25.0 → 0.25.2

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

@@ -0,0 +1,903 @@
+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);
+		}
+		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)
+				});
+				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
+				});
+			}
+			_ != null && (S.push(_), b += circleArea(_.circle.radius, _.width), f = p);
+		}
+	} else {
+		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;
+		}
+		p ? b = x = 0 : (b = f.radius * f.radius * Math.PI, S.push({
+			circle: f,
+			p1: {
+				x: f.x,
+				y: f.y + f.radius
+			},
+			p2: {
+				x: f.x - SMALL$1,
+				y: f.y + f.radius
+			},
+			width: f.radius * 2,
+			large: !0,
+			sweep: !0
+		}));
+	}
+	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 containedInCircles(d, f) {
+	return f.every((f) => distance(d, f) < f.radius + SMALL$1);
+}
+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 d;
+}
+function circleArea(e, d) {
+	return e * e * Math.acos(1 - d / e) - (e - d) * Math.sqrt(d * (2 * e - d));
+}
+function distance(e, d) {
+	return Math.sqrt((e.x - d.x) * (e.x - d.x) + (e.y - d.y) * (e.y - d.y));
+}
+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 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: v + b,
+		y: y - x
+	}, {
+		x: v - b,
+		y: y + x
+	}];
+}
+function getCenter(e) {
+	let d = {
+		x: 0,
+		y: 0
+	};
+	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, d) => e.id - d.id), f.history.push({
+				x: w[0].slice(),
+				fx: w[0].fx,
+				simplex: e
+			});
+		}
+		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 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 E(k);
+	}
+	return w.sort(D), {
+		fx: w[0].fx,
+		x: w[0]
+	};
+}
+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(x) <= -g * v) return m;
+			x * (C - b) >= 0 && (C = b), b = m, w = y;
+		}
+		return 0;
+	}
+	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 m;
+}
+function conjugateGradient(e, d, f) {
+	let p = {
+		x: d.slice(),
+		fx: 0,
+		fxprime: d.slice()
+	}, m = {
+		x: d.slice(),
+		fx: 0,
+		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 {
+			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 (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 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 h;
+}
+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 addMissingAreas(e, d = {}) {
+	let f = d.distinct, p = e.map((e) => Object.assign({}, e));
+	function m(e) {
+		return e.join(";");
+	}
+	if (f) {
+		let e = /* @__PURE__ */ new Map();
+		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 d of p) d.sets.length < 3 && (d.size = e.get(m(d.sets)));
+	}
+	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 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 p;
+}
+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 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: p,
+		constraints: m
+	};
+}
+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 m;
+}
+function bestInitialLayout(e, d = {}) {
+	let f = greedyLayout(e, d), p = d.lossFunction || lossFunction;
+	if (e.length >= 8) {
+		let m = constrainedMDSLayout(e, d), h = p(m, e), g = p(f, e);
+		h + 1e-8 < g && (f = m);
+	}
+	return f;
+}
+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: p.length,
+			size: d.size,
+			radius: Math.sqrt(d.size / Math.PI)
+		}, m[e] = [];
+	}
+	e = e.filter((e) => e.sets.length === 2);
+	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
+		}), m[h].push({
+			set: f,
+			size: d.size,
+			weight: e
+		});
+	}
+	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: d
+		});
+	});
+	function g(e, d) {
+		return d.size - e.size;
+	}
+	h.sort(g);
+	let v = {};
+	function y(e) {
+		return e.set in v;
+	}
+	function b(e, d) {
+		p[d].x = e.x, p[d].y = e.y, v[d] = !0;
+	}
+	b({
+		x: 0,
+		y: 0
+	}, 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
+			}), w.push({
+				x: e.x - d,
+				y: e.y
+			}), w.push({
+				y: e.y + d,
+				x: e.x
+			}), w.push({
+				y: e.y - d,
+				x: e.x
+			});
+			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: d
+				}, {
+					x: m.x,
+					y: m.y,
+					radius: h
+				});
+				w.push(...g);
+			}
+		}
+		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);
+		}
+		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 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 disjointCluster(e) {
+	e.forEach((e) => {
+		e.parent = e;
+	});
+	function d(e) {
+		return e.parent !== e && (e.parent = d(e.parent)), e.parent;
+	}
+	function f(e, f) {
+		let p = d(e);
+		p.parent = d(f);
+	}
+	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 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(p.values());
+}
+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: d("x"),
+		yRange: d("y")
+	};
+}
+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 m = e.bounds, _, v;
+		if (d) _ = h.xRange.max - m.xRange.min + g;
+		else {
+			_ = 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 (f) v = h.yRange.max - m.yRange.min + g;
+		else {
+			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 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 toObjectNotation(e) {
+	let d = {};
+	for (let f of e) d[f.setid] = f;
+	return d;
+}
+function fromObjectNotation(e) {
+	return Object.keys(e).map((d) => Object.assign(e[d], { setid: d }));
+}
+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",
+		"#d62728",
+		"#9467bd",
+		"#8c564b",
+		"#e377c2",
+		"#7f7f7f",
+		"#bcbd22",
+		"#17becf"
+	], 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
+			});
+			_ && (e = normalizeSolution(e, g, S)), k = scaleSolution(e, f, p, m, v), N = computeTextCentres(k, D, T);
+		}
+		let P = {};
+		D.forEach((e) => {
+			e.label && (P[e.sets] = e.label);
+		});
+		function F(e) {
+			if (e.sets in P) return P[e.sets];
+			if (e.sets.length == 1) return "" + e.sets[0];
+		}
+		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 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
+				}, h ||= {
+					x: f / 2,
+					y: p / 2,
+					radius: 1
+				}, {
+					x: m.x * (1 - d) + h.x * d,
+					y: m.y * (1 - d) + h.y * d,
+					radius: m.radius * (1 - d) + h.radius * d
+				};
+			}), w);
+		}
+		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 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 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 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 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 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 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, 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 f) if (distance(b, e) < e.radius) {
+		x = !1;
+		break;
+	}
+	if (x) return b;
+	if (e.length == 1) return {
+		x: e[0].x,
+		y: e[0].y
+	};
+	let S = {};
+	return intersectionArea(e, S), S.arcs.length === 0 ? {
+		x: 0,
+		y: -1e3,
+		disjoint: !0
+	} : 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 d;
+}
+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 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 p;
+}
+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 circleFromPath(e) {
+	let d = e.split(" ");
+	return {
+		x: Number.parseFloat(d[1]),
+		y: Number.parseFloat(d[2]),
+		radius: -Number.parseFloat(d[4])
+	};
+}
+function intersectionAreaArcs(e) {
+	if (e.length === 0) return [];
+	let f = {};
+	return intersectionArea(e, f), f.arcs;
+}
+function arcsToPath(e, d) {
+	if (e.length === 0) return "M 0 0";
+	let f = 10 ** (d || 0), p = d == null ? (e) => e : (e) => Math.round(e * f) / f;
+	if (e.length == 1) {
+		let d = e[0].circle;
+		return circlePath(p(d.x), p(d.y), p(d.radius));
+	}
+	let m = [
+		"\nM",
+		p(e[0].p2.x),
+		p(e[0].p2.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 m.join(" ");
+}
+function intersectionAreaPath(e, d) {
+	return arcsToPath(intersectionAreaArcs(e), d);
+}
+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
+	});
+	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: 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: d,
+			arcs: f,
+			path: arcsToPath(f, C),
+			area: e,
+			has: new Set(e.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: d,
+		path: f,
+		distinctPath: f + A(p.sets)
+	}));
+}
+export { VennDiagram, layout };