watch-tail 0.4.0 → 0.6.0

package/build/server/chunks/chunks/Voronoi.js-DevTsXQE.js

@@ -0,0 +1,2052 @@
+import { at as spread_props, ak as ensure_array_like, ac as derived, as as props_id, am as bind_props } from './server.js-CAEBuMIH.js';
+import { a as getChartContext, b as cls, e as accessor } from './common.js-BWQB8Die.js';
+import { g as getLayerContext, u as getFacetPanel, b as getGeoContext } from './key.svelte.js-CWIvXc6L.js';
+import { C as ClipPath_svg, a as ClipPath_canvas, l as linearClosed_default, e as extent } from './ClipPath.canvas.js-CFTBDWVU.js';
+import { s as stream_default, h as hypot, a as atan2$1, d as degrees$1, b as asin$1, A as Adder, n as noop, p as path_default, r as radians$1, t as tau, c as sqrt$1, i as identity_default, e as sin$1, f as cos$1, g as abs, j as boundsStream, k as epsilon, q as quarterPi, l as pi$1, m as sign$1, o as halfPi$1, u as atan, v as acos } from './path.js-BizMrlzb.js';
+import { m as max$1 } from './max.js-CuS0BpRI.js';
+import { a as Path_svg, G as Group_svg, b as Path_canvas, d as Group_canvas, c as createId, p as path } from './Path.canvas.js-DNAtnEBt.js';
+import { p as pointRadial_default } from './pointRadial.js-Deeu1LXx.js';
+import { D as Delaunay, a as area_default$1, c as centroid_default$1 } from './centroid.js-BnGN3LH0.js';
+import './uneval.js-DaakSYFQ.js';
+import './motion.svelte.js-DCHSFMu-.js';
+
+//#region node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/merge.js
+function* flatten(arrays) {
+	for (const array of arrays) yield* array;
+}
+function merge(arrays) {
+	return Array.from(flatten(arrays));
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/area.js
+var areaRingSum = new Adder();
+var areaSum = new Adder();
+var lambda00$1;
+var phi00$1;
+var lambda0$1;
+var cosPhi0$1;
+var sinPhi0$1;
+var areaStream = {
+	point: noop,
+	lineStart: noop,
+	lineEnd: noop,
+	polygonStart: function() {
+		areaRingSum = new Adder();
+		areaStream.lineStart = areaRingStart;
+		areaStream.lineEnd = areaRingEnd;
+	},
+	polygonEnd: function() {
+		var areaRing = +areaRingSum;
+		areaSum.add(areaRing < 0 ? tau + areaRing : areaRing);
+		this.lineStart = this.lineEnd = this.point = noop;
+	},
+	sphere: function() {
+		areaSum.add(tau);
+	}
+};
+function areaRingStart() {
+	areaStream.point = areaPointFirst;
+}
+function areaRingEnd() {
+	areaPoint(lambda00$1, phi00$1);
+}
+function areaPointFirst(lambda, phi) {
+	areaStream.point = areaPoint;
+	lambda00$1 = lambda, phi00$1 = phi;
+	lambda *= radians$1, phi *= radians$1;
+	lambda0$1 = lambda, cosPhi0$1 = cos$1(phi = phi / 2 + quarterPi), sinPhi0$1 = sin$1(phi);
+}
+function areaPoint(lambda, phi) {
+	lambda *= radians$1, phi *= radians$1;
+	phi = phi / 2 + quarterPi;
+	var dLambda = lambda - lambda0$1, sdLambda = dLambda >= 0 ? 1 : -1, adLambda = sdLambda * dLambda, cosPhi = cos$1(phi), sinPhi = sin$1(phi), k = sinPhi0$1 * sinPhi, u = cosPhi0$1 * cosPhi + k * cos$1(adLambda), v = k * sdLambda * sin$1(adLambda);
+	areaRingSum.add(atan2$1(v, u));
+	lambda0$1 = lambda, cosPhi0$1 = cosPhi, sinPhi0$1 = sinPhi;
+}
+function area_default(object) {
+	areaSum = new Adder();
+	stream_default(object, areaStream);
+	return areaSum * 2;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/cartesian.js
+function spherical$1(cartesian) {
+	return [atan2$1(cartesian[1], cartesian[0]), asin$1(cartesian[2])];
+}
+function cartesian$1(spherical) {
+	var lambda = spherical[0], phi = spherical[1], cosPhi = cos$1(phi);
+	return [
+		cosPhi * cos$1(lambda),
+		cosPhi * sin$1(lambda),
+		sin$1(phi)
+	];
+}
+function cartesianDot$1(a, b) {
+	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cartesianCross$1(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+function cartesianAddInPlace(a, b) {
+	a[0] += b[0], a[1] += b[1], a[2] += b[2];
+}
+function cartesianScale(vector, k) {
+	return [
+		vector[0] * k,
+		vector[1] * k,
+		vector[2] * k
+	];
+}
+function cartesianNormalizeInPlace(d) {
+	var l = sqrt$1(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+	d[0] /= l, d[1] /= l, d[2] /= l;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/centroid.js
+var W0;
+var W1;
+var X0;
+var Y0;
+var Z0;
+var X1;
+var Y1;
+var Z1;
+var X2;
+var Y2;
+var Z2;
+var lambda00;
+var phi00;
+var x0;
+var y0;
+var z0;
+var centroidStream = {
+	sphere: noop,
+	point: centroidPoint,
+	lineStart: centroidLineStart,
+	lineEnd: centroidLineEnd,
+	polygonStart: function() {
+		centroidStream.lineStart = centroidRingStart;
+		centroidStream.lineEnd = centroidRingEnd;
+	},
+	polygonEnd: function() {
+		centroidStream.lineStart = centroidLineStart;
+		centroidStream.lineEnd = centroidLineEnd;
+	}
+};
+function centroidPoint(lambda, phi) {
+	lambda *= radians$1, phi *= radians$1;
+	var cosPhi = cos$1(phi);
+	centroidPointCartesian(cosPhi * cos$1(lambda), cosPhi * sin$1(lambda), sin$1(phi));
+}
+function centroidPointCartesian(x, y, z) {
+	++W0;
+	X0 += (x - X0) / W0;
+	Y0 += (y - Y0) / W0;
+	Z0 += (z - Z0) / W0;
+}
+function centroidLineStart() {
+	centroidStream.point = centroidLinePointFirst;
+}
+function centroidLinePointFirst(lambda, phi) {
+	lambda *= radians$1, phi *= radians$1;
+	var cosPhi = cos$1(phi);
+	x0 = cosPhi * cos$1(lambda);
+	y0 = cosPhi * sin$1(lambda);
+	z0 = sin$1(phi);
+	centroidStream.point = centroidLinePoint;
+	centroidPointCartesian(x0, y0, z0);
+}
+function centroidLinePoint(lambda, phi) {
+	lambda *= radians$1, phi *= radians$1;
+	var cosPhi = cos$1(phi), x = cosPhi * cos$1(lambda), y = cosPhi * sin$1(lambda), z = sin$1(phi), w = atan2$1(sqrt$1((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
+	W1 += w;
+	X1 += w * (x0 + (x0 = x));
+	Y1 += w * (y0 + (y0 = y));
+	Z1 += w * (z0 + (z0 = z));
+	centroidPointCartesian(x0, y0, z0);
+}
+function centroidLineEnd() {
+	centroidStream.point = centroidPoint;
+}
+function centroidRingStart() {
+	centroidStream.point = centroidRingPointFirst;
+}
+function centroidRingEnd() {
+	centroidRingPoint(lambda00, phi00);
+	centroidStream.point = centroidPoint;
+}
+function centroidRingPointFirst(lambda, phi) {
+	lambda00 = lambda, phi00 = phi;
+	lambda *= radians$1, phi *= radians$1;
+	centroidStream.point = centroidRingPoint;
+	var cosPhi = cos$1(phi);
+	x0 = cosPhi * cos$1(lambda);
+	y0 = cosPhi * sin$1(lambda);
+	z0 = sin$1(phi);
+	centroidPointCartesian(x0, y0, z0);
+}
+function centroidRingPoint(lambda, phi) {
+	lambda *= radians$1, phi *= radians$1;
+	var cosPhi = cos$1(phi), x = cosPhi * cos$1(lambda), y = cosPhi * sin$1(lambda), z = sin$1(phi), cx = y0 * z - z0 * y, cy = z0 * x - x0 * z, cz = x0 * y - y0 * x, m = hypot(cx, cy, cz), w = asin$1(m), v = m && -w / m;
+	X2.add(v * cx);
+	Y2.add(v * cy);
+	Z2.add(v * cz);
+	W1 += w;
+	X1 += w * (x0 + (x0 = x));
+	Y1 += w * (y0 + (y0 = y));
+	Z1 += w * (z0 + (z0 = z));
+	centroidPointCartesian(x0, y0, z0);
+}
+function centroid_default(object) {
+	W0 = W1 = X0 = Y0 = Z0 = X1 = Y1 = Z1 = 0;
+	X2 = new Adder();
+	Y2 = new Adder();
+	Z2 = new Adder();
+	stream_default(object, centroidStream);
+	var x = +X2, y = +Y2, z = +Z2, m = hypot(x, y, z);
+	if (m < 1e-12) {
+		x = X1, y = Y1, z = Z1;
+		if (W1 < 1e-6) x = X0, y = Y0, z = Z0;
+		m = hypot(x, y, z);
+		if (m < 1e-12) return [NaN, NaN];
+	}
+	return [atan2$1(y, x) * degrees$1, asin$1(z / m) * degrees$1];
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/compose.js
+function compose_default(a, b) {
+	function compose(x, y) {
+		return x = a(x, y), b(x[0], x[1]);
+	}
+	if (a.invert && b.invert) compose.invert = function(x, y) {
+		return x = b.invert(x, y), x && a.invert(x[0], x[1]);
+	};
+	return compose;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/rotation.js
+function rotationIdentity(lambda, phi) {
+	if (abs(lambda) > pi$1) lambda -= Math.round(lambda / tau) * tau;
+	return [lambda, phi];
+}
+rotationIdentity.invert = rotationIdentity;
+function rotateRadians(deltaLambda, deltaPhi, deltaGamma) {
+	return (deltaLambda %= tau) ? deltaPhi || deltaGamma ? compose_default(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma)) : rotationLambda(deltaLambda) : deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma) : rotationIdentity;
+}
+function forwardRotationLambda(deltaLambda) {
+	return function(lambda, phi) {
+		lambda += deltaLambda;
+		if (abs(lambda) > pi$1) lambda -= Math.round(lambda / tau) * tau;
+		return [lambda, phi];
+	};
+}
+function rotationLambda(deltaLambda) {
+	var rotation = forwardRotationLambda(deltaLambda);
+	rotation.invert = forwardRotationLambda(-deltaLambda);
+	return rotation;
+}
+function rotationPhiGamma(deltaPhi, deltaGamma) {
+	var cosDeltaPhi = cos$1(deltaPhi), sinDeltaPhi = sin$1(deltaPhi), cosDeltaGamma = cos$1(deltaGamma), sinDeltaGamma = sin$1(deltaGamma);
+	function rotation(lambda, phi) {
+		var cosPhi = cos$1(phi), x = cos$1(lambda) * cosPhi, y = sin$1(lambda) * cosPhi, z = sin$1(phi), k = z * cosDeltaPhi + x * sinDeltaPhi;
+		return [atan2$1(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi), asin$1(k * cosDeltaGamma + y * sinDeltaGamma)];
+	}
+	rotation.invert = function(lambda, phi) {
+		var cosPhi = cos$1(phi), x = cos$1(lambda) * cosPhi, y = sin$1(lambda) * cosPhi, z = sin$1(phi), k = z * cosDeltaGamma - y * sinDeltaGamma;
+		return [atan2$1(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi), asin$1(k * cosDeltaPhi - x * sinDeltaPhi)];
+	};
+	return rotation;
+}
+function rotation_default(rotate) {
+	rotate = rotateRadians(rotate[0] * radians$1, rotate[1] * radians$1, rotate.length > 2 ? rotate[2] * radians$1 : 0);
+	function forward(coordinates) {
+		coordinates = rotate(coordinates[0] * radians$1, coordinates[1] * radians$1);
+		return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates;
+	}
+	forward.invert = function(coordinates) {
+		coordinates = rotate.invert(coordinates[0] * radians$1, coordinates[1] * radians$1);
+		return coordinates[0] *= degrees$1, coordinates[1] *= degrees$1, coordinates;
+	};
+	return forward;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/circle.js
+function circleStream(stream, radius, delta, direction, t0, t1) {
+	if (!delta) return;
+	var cosRadius = cos$1(radius), sinRadius = sin$1(radius), step = direction * delta;
+	if (t0 == null) {
+		t0 = radius + direction * tau;
+		t1 = radius - step / 2;
+	} else {
+		t0 = circleRadius(cosRadius, t0);
+		t1 = circleRadius(cosRadius, t1);
+		if (direction > 0 ? t0 < t1 : t0 > t1) t0 += direction * tau;
+	}
+	for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) {
+		point = spherical$1([
+			cosRadius,
+			-sinRadius * cos$1(t),
+			-sinRadius * sin$1(t)
+		]);
+		stream.point(point[0], point[1]);
+	}
+}
+function circleRadius(cosRadius, point) {
+	point = cartesian$1(point), point[0] -= cosRadius;
+	cartesianNormalizeInPlace(point);
+	var radius = acos(-point[1]);
+	return ((-point[2] < 0 ? -radius : radius) + tau - epsilon) % tau;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/clip/buffer.js
+function buffer_default() {
+	var lines = [], line;
+	return {
+		point: function(x, y, m) {
+			line.push([
+				x,
+				y,
+				m
+			]);
+		},
+		lineStart: function() {
+			lines.push(line = []);
+		},
+		lineEnd: noop,
+		rejoin: function() {
+			if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
+		},
+		result: function() {
+			var result = lines;
+			lines = [];
+			line = null;
+			return result;
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/pointEqual.js
+function pointEqual_default(a, b) {
+	return abs(a[0] - b[0]) < 1e-6 && abs(a[1] - b[1]) < 1e-6;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/clip/rejoin.js
+function Intersection(point, points, other, entry) {
+	this.x = point;
+	this.z = points;
+	this.o = other;
+	this.e = entry;
+	this.v = false;
+	this.n = this.p = null;
+}
+function rejoin_default(segments, compareIntersection, startInside, interpolate, stream) {
+	var subject = [], clip = [], i, n;
+	segments.forEach(function(segment) {
+		if ((n = segment.length - 1) <= 0) return;
+		var n, p0 = segment[0], p1 = segment[n], x;
+		if (pointEqual_default(p0, p1)) {
+			if (!p0[2] && !p1[2]) {
+				stream.lineStart();
+				for (i = 0; i < n; ++i) stream.point((p0 = segment[i])[0], p0[1]);
+				stream.lineEnd();
+				return;
+			}
+			p1[0] += 2 * epsilon;
+		}
+		subject.push(x = new Intersection(p0, segment, null, true));
+		clip.push(x.o = new Intersection(p0, null, x, false));
+		subject.push(x = new Intersection(p1, segment, null, false));
+		clip.push(x.o = new Intersection(p1, null, x, true));
+	});
+	if (!subject.length) return;
+	clip.sort(compareIntersection);
+	link(subject);
+	link(clip);
+	for (i = 0, n = clip.length; i < n; ++i) clip[i].e = startInside = !startInside;
+	var start = subject[0], points, point;
+	while (1) {
+		var current = start, isSubject = true;
+		while (current.v) if ((current = current.n) === start) return;
+		points = current.z;
+		stream.lineStart();
+		do {
+			current.v = current.o.v = true;
+			if (current.e) {
+				if (isSubject) for (i = 0, n = points.length; i < n; ++i) stream.point((point = points[i])[0], point[1]);
+				else interpolate(current.x, current.n.x, 1, stream);
+				current = current.n;
+			} else {
+				if (isSubject) {
+					points = current.p.z;
+					for (i = points.length - 1; i >= 0; --i) stream.point((point = points[i])[0], point[1]);
+				} else interpolate(current.x, current.p.x, -1, stream);
+				current = current.p;
+			}
+			current = current.o;
+			points = current.z;
+			isSubject = !isSubject;
+		} while (!current.v);
+		stream.lineEnd();
+	}
+}
+function link(array) {
+	if (!(n = array.length)) return;
+	var n, i = 0, a = array[0], b;
+	while (++i < n) {
+		a.n = b = array[i];
+		b.p = a;
+		a = b;
+	}
+	a.n = b = array[0];
+	b.p = a;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/polygonContains.js
+function longitude(point) {
+	return abs(point[0]) <= pi$1 ? point[0] : sign$1(point[0]) * ((abs(point[0]) + pi$1) % tau - pi$1);
+}
+function polygonContains_default(polygon, point) {
+	var lambda = longitude(point), phi = point[1], sinPhi = sin$1(phi), normal = [
+		sin$1(lambda),
+		-cos$1(lambda),
+		0
+	], angle = 0, winding = 0;
+	var sum = new Adder();
+	if (sinPhi === 1) phi = halfPi$1 + epsilon;
+	else if (sinPhi === -1) phi = -halfPi$1 - epsilon;
+	for (var i = 0, n = polygon.length; i < n; ++i) {
+		if (!(m = (ring = polygon[i]).length)) continue;
+		var ring, m, point0 = ring[m - 1], lambda0 = longitude(point0), phi0 = point0[1] / 2 + quarterPi, sinPhi0 = sin$1(phi0), cosPhi0 = cos$1(phi0);
+		for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) {
+			var point1 = ring[j], lambda1 = longitude(point1), phi1 = point1[1] / 2 + quarterPi, sinPhi1 = sin$1(phi1), cosPhi1 = cos$1(phi1), delta = lambda1 - lambda0, sign = delta >= 0 ? 1 : -1, absDelta = sign * delta, antimeridian = absDelta > pi$1, k = sinPhi0 * sinPhi1;
+			sum.add(atan2$1(k * sign * sin$1(absDelta), cosPhi0 * cosPhi1 + k * cos$1(absDelta)));
+			angle += antimeridian ? delta + sign * tau : delta;
+			if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {
+				var arc = cartesianCross$1(cartesian$1(point0), cartesian$1(point1));
+				cartesianNormalizeInPlace(arc);
+				var intersection = cartesianCross$1(normal, arc);
+				cartesianNormalizeInPlace(intersection);
+				var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin$1(intersection[2]);
+				if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) winding += antimeridian ^ delta >= 0 ? 1 : -1;
+			}
+		}
+	}
+	return (angle < -1e-6 || angle < 1e-6 && sum < -1e-12) ^ winding & 1;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/clip/index.js
+function clip_default(pointVisible, clipLine, interpolate, start) {
+	return function(sink) {
+		var line = clipLine(sink), ringBuffer = buffer_default(), ringSink = clipLine(ringBuffer), polygonStarted = false, polygon, segments, ring;
+		var clip = {
+			point,
+			lineStart,
+			lineEnd,
+			polygonStart: function() {
+				clip.point = pointRing;
+				clip.lineStart = ringStart;
+				clip.lineEnd = ringEnd;
+				segments = [];
+				polygon = [];
+			},
+			polygonEnd: function() {
+				clip.point = point;
+				clip.lineStart = lineStart;
+				clip.lineEnd = lineEnd;
+				segments = merge(segments);
+				var startInside = polygonContains_default(polygon, start);
+				if (segments.length) {
+					if (!polygonStarted) sink.polygonStart(), polygonStarted = true;
+					rejoin_default(segments, compareIntersection, startInside, interpolate, sink);
+				} else if (startInside) {
+					if (!polygonStarted) sink.polygonStart(), polygonStarted = true;
+					sink.lineStart();
+					interpolate(null, null, 1, sink);
+					sink.lineEnd();
+				}
+				if (polygonStarted) sink.polygonEnd(), polygonStarted = false;
+				segments = polygon = null;
+			},
+			sphere: function() {
+				sink.polygonStart();
+				sink.lineStart();
+				interpolate(null, null, 1, sink);
+				sink.lineEnd();
+				sink.polygonEnd();
+			}
+		};
+		function point(lambda, phi) {
+			if (pointVisible(lambda, phi)) sink.point(lambda, phi);
+		}
+		function pointLine(lambda, phi) {
+			line.point(lambda, phi);
+		}
+		function lineStart() {
+			clip.point = pointLine;
+			line.lineStart();
+		}
+		function lineEnd() {
+			clip.point = point;
+			line.lineEnd();
+		}
+		function pointRing(lambda, phi) {
+			ring.push([lambda, phi]);
+			ringSink.point(lambda, phi);
+		}
+		function ringStart() {
+			ringSink.lineStart();
+			ring = [];
+		}
+		function ringEnd() {
+			pointRing(ring[0][0], ring[0][1]);
+			ringSink.lineEnd();
+			var clean = ringSink.clean(), ringSegments = ringBuffer.result(), i, n = ringSegments.length, m, segment, point;
+			ring.pop();
+			polygon.push(ring);
+			ring = null;
+			if (!n) return;
+			if (clean & 1) {
+				segment = ringSegments[0];
+				if ((m = segment.length - 1) > 0) {
+					if (!polygonStarted) sink.polygonStart(), polygonStarted = true;
+					sink.lineStart();
+					for (i = 0; i < m; ++i) sink.point((point = segment[i])[0], point[1]);
+					sink.lineEnd();
+				}
+				return;
+			}
+			if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
+			segments.push(ringSegments.filter(validSegment));
+		}
+		return clip;
+	};
+}
+function validSegment(segment) {
+	return segment.length > 1;
+}
+function compareIntersection(a, b) {
+	return ((a = a.x)[0] < 0 ? a[1] - halfPi$1 - epsilon : halfPi$1 - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfPi$1 - epsilon : halfPi$1 - b[1]);
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/clip/antimeridian.js
+var antimeridian_default = clip_default(function() {
+	return true;
+}, clipAntimeridianLine, clipAntimeridianInterpolate, [-pi$1, -halfPi$1]);
+function clipAntimeridianLine(stream) {
+	var lambda0 = NaN, phi0 = NaN, sign0 = NaN, clean;
+	return {
+		lineStart: function() {
+			stream.lineStart();
+			clean = 1;
+		},
+		point: function(lambda1, phi1) {
+			var sign1 = lambda1 > 0 ? pi$1 : -pi$1, delta = abs(lambda1 - lambda0);
+			if (abs(delta - pi$1) < 1e-6) {
+				stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi$1 : -halfPi$1);
+				stream.point(sign0, phi0);
+				stream.lineEnd();
+				stream.lineStart();
+				stream.point(sign1, phi0);
+				stream.point(lambda1, phi0);
+				clean = 0;
+			} else if (sign0 !== sign1 && delta >= pi$1) {
+				if (abs(lambda0 - sign0) < 1e-6) lambda0 -= sign0 * epsilon;
+				if (abs(lambda1 - sign1) < 1e-6) lambda1 -= sign1 * epsilon;
+				phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1);
+				stream.point(sign0, phi0);
+				stream.lineEnd();
+				stream.lineStart();
+				stream.point(sign1, phi0);
+				clean = 0;
+			}
+			stream.point(lambda0 = lambda1, phi0 = phi1);
+			sign0 = sign1;
+		},
+		lineEnd: function() {
+			stream.lineEnd();
+			lambda0 = phi0 = NaN;
+		},
+		clean: function() {
+			return 2 - clean;
+		}
+	};
+}
+function clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) {
+	var cosPhi0, cosPhi1, sinLambda0Lambda1 = sin$1(lambda0 - lambda1);
+	return abs(sinLambda0Lambda1) > 1e-6 ? atan((sin$1(phi0) * (cosPhi1 = cos$1(phi1)) * sin$1(lambda1) - sin$1(phi1) * (cosPhi0 = cos$1(phi0)) * sin$1(lambda0)) / (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) : (phi0 + phi1) / 2;
+}
+function clipAntimeridianInterpolate(from, to, direction, stream) {
+	var phi;
+	if (from == null) {
+		phi = direction * halfPi$1;
+		stream.point(-pi$1, phi);
+		stream.point(0, phi);
+		stream.point(pi$1, phi);
+		stream.point(pi$1, 0);
+		stream.point(pi$1, -phi);
+		stream.point(0, -phi);
+		stream.point(-pi$1, -phi);
+		stream.point(-pi$1, 0);
+		stream.point(-pi$1, phi);
+	} else if (abs(from[0] - to[0]) > 1e-6) {
+		var lambda = from[0] < to[0] ? pi$1 : -pi$1;
+		phi = direction * lambda / 2;
+		stream.point(-lambda, phi);
+		stream.point(0, phi);
+		stream.point(lambda, phi);
+	} else stream.point(to[0], to[1]);
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/clip/circle.js
+function circle_default(radius) {
+	var cr = cos$1(radius), delta = 2 * radians$1, smallRadius = cr > 0, notHemisphere = abs(cr) > epsilon;
+	function interpolate(from, to, direction, stream) {
+		circleStream(stream, radius, delta, direction, from, to);
+	}
+	function visible(lambda, phi) {
+		return cos$1(lambda) * cos$1(phi) > cr;
+	}
+	function clipLine(stream) {
+		var point0, c0, v0, v00, clean;
+		return {
+			lineStart: function() {
+				v00 = v0 = false;
+				clean = 1;
+			},
+			point: function(lambda, phi) {
+				var point1 = [lambda, phi], point2, v = visible(lambda, phi), c = smallRadius ? v ? 0 : code(lambda, phi) : v ? code(lambda + (lambda < 0 ? pi$1 : -pi$1), phi) : 0;
+				if (!point0 && (v00 = v0 = v)) stream.lineStart();
+				if (v !== v0) {
+					point2 = intersect(point0, point1);
+					if (!point2 || pointEqual_default(point0, point2) || pointEqual_default(point1, point2)) point1[2] = 1;
+				}
+				if (v !== v0) {
+					clean = 0;
+					if (v) {
+						stream.lineStart();
+						point2 = intersect(point1, point0);
+						stream.point(point2[0], point2[1]);
+					} else {
+						point2 = intersect(point0, point1);
+						stream.point(point2[0], point2[1], 2);
+						stream.lineEnd();
+					}
+					point0 = point2;
+				} else if (notHemisphere && point0 && smallRadius ^ v) {
+					var t;
+					if (!(c & c0) && (t = intersect(point1, point0, true))) {
+						clean = 0;
+						if (smallRadius) {
+							stream.lineStart();
+							stream.point(t[0][0], t[0][1]);
+							stream.point(t[1][0], t[1][1]);
+							stream.lineEnd();
+						} else {
+							stream.point(t[1][0], t[1][1]);
+							stream.lineEnd();
+							stream.lineStart();
+							stream.point(t[0][0], t[0][1], 3);
+						}
+					}
+				}
+				if (v && (!point0 || !pointEqual_default(point0, point1))) stream.point(point1[0], point1[1]);
+				point0 = point1, v0 = v, c0 = c;
+			},
+			lineEnd: function() {
+				if (v0) stream.lineEnd();
+				point0 = null;
+			},
+			clean: function() {
+				return clean | (v00 && v0) << 1;
+			}
+		};
+	}
+	function intersect(a, b, two) {
+		var pa = cartesian$1(a), pb = cartesian$1(b);
+		var n1 = [
+			1,
+			0,
+			0
+		], n2 = cartesianCross$1(pa, pb), n2n2 = cartesianDot$1(n2, n2), n1n2 = n2[0], determinant = n2n2 - n1n2 * n1n2;
+		if (!determinant) return !two && a;
+		var c1 = cr * n2n2 / determinant, c2 = -cr * n1n2 / determinant, n1xn2 = cartesianCross$1(n1, n2), A = cartesianScale(n1, c1);
+		cartesianAddInPlace(A, cartesianScale(n2, c2));
+		var u = n1xn2, w = cartesianDot$1(A, u), uu = cartesianDot$1(u, u), t2 = w * w - uu * (cartesianDot$1(A, A) - 1);
+		if (t2 < 0) return;
+		var t = sqrt$1(t2), q = cartesianScale(u, (-w - t) / uu);
+		cartesianAddInPlace(q, A);
+		q = spherical$1(q);
+		if (!two) return q;
+		var lambda0 = a[0], lambda1 = b[0], phi0 = a[1], phi1 = b[1], z;
+		if (lambda1 < lambda0) z = lambda0, lambda0 = lambda1, lambda1 = z;
+		var delta = lambda1 - lambda0, polar = abs(delta - pi$1) < epsilon, meridian = polar || delta < 1e-6;
+		if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z;
+		if (meridian ? polar ? phi0 + phi1 > 0 ^ q[1] < (abs(q[0] - lambda0) < 1e-6 ? phi0 : phi1) : phi0 <= q[1] && q[1] <= phi1 : delta > pi$1 ^ (lambda0 <= q[0] && q[0] <= lambda1)) {
+			var q1 = cartesianScale(u, (-w + t) / uu);
+			cartesianAddInPlace(q1, A);
+			return [q, spherical$1(q1)];
+		}
+	}
+	function code(lambda, phi) {
+		var r = smallRadius ? radius : pi$1 - radius, code = 0;
+		if (lambda < -r) code |= 1;
+		else if (lambda > r) code |= 2;
+		if (phi < -r) code |= 4;
+		else if (phi > r) code |= 8;
+		return code;
+	}
+	return clip_default(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-pi$1, radius - pi$1]);
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/clip/line.js
+function line_default(a, b, x0, y0, x1, y1) {
+	var ax = a[0], ay = a[1], bx = b[0], by = b[1], t0 = 0, t1 = 1, dx = bx - ax, dy = by - ay, r = x0 - ax;
+	if (!dx && r > 0) return;
+	r /= dx;
+	if (dx < 0) {
+		if (r < t0) return;
+		if (r < t1) t1 = r;
+	} else if (dx > 0) {
+		if (r > t1) return;
+		if (r > t0) t0 = r;
+	}
+	r = x1 - ax;
+	if (!dx && r < 0) return;
+	r /= dx;
+	if (dx < 0) {
+		if (r > t1) return;
+		if (r > t0) t0 = r;
+	} else if (dx > 0) {
+		if (r < t0) return;
+		if (r < t1) t1 = r;
+	}
+	r = y0 - ay;
+	if (!dy && r > 0) return;
+	r /= dy;
+	if (dy < 0) {
+		if (r < t0) return;
+		if (r < t1) t1 = r;
+	} else if (dy > 0) {
+		if (r > t1) return;
+		if (r > t0) t0 = r;
+	}
+	r = y1 - ay;
+	if (!dy && r < 0) return;
+	r /= dy;
+	if (dy < 0) {
+		if (r > t1) return;
+		if (r > t0) t0 = r;
+	} else if (dy > 0) {
+		if (r < t0) return;
+		if (r < t1) t1 = r;
+	}
+	if (t0 > 0) a[0] = ax + t0 * dx, a[1] = ay + t0 * dy;
+	if (t1 < 1) b[0] = ax + t1 * dx, b[1] = ay + t1 * dy;
+	return true;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/clip/rectangle.js
+var clipMax = 1e9;
+var clipMin = -clipMax;
+function clipRectangle(x0, y0, x1, y1) {
+	function visible(x, y) {
+		return x0 <= x && x <= x1 && y0 <= y && y <= y1;
+	}
+	function interpolate(from, to, direction, stream) {
+		var a = 0, a1 = 0;
+		if (from == null || (a = corner(from, direction)) !== (a1 = corner(to, direction)) || comparePoint(from, to) < 0 ^ direction > 0) do
+			stream.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);
+		while ((a = (a + direction + 4) % 4) !== a1);
+		else stream.point(to[0], to[1]);
+	}
+	function corner(p, direction) {
+		return abs(p[0] - x0) < 1e-6 ? direction > 0 ? 0 : 3 : abs(p[0] - x1) < 1e-6 ? direction > 0 ? 2 : 1 : abs(p[1] - y0) < 1e-6 ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2;
+	}
+	function compareIntersection(a, b) {
+		return comparePoint(a.x, b.x);
+	}
+	function comparePoint(a, b) {
+		var ca = corner(a, 1), cb = corner(b, 1);
+		return ca !== cb ? ca - cb : ca === 0 ? b[1] - a[1] : ca === 1 ? a[0] - b[0] : ca === 2 ? a[1] - b[1] : b[0] - a[0];
+	}
+	return function(stream) {
+		var activeStream = stream, bufferStream = buffer_default(), segments, polygon, ring, x__, y__, v__, x_, y_, v_, first, clean;
+		var clipStream = {
+			point,
+			lineStart,
+			lineEnd,
+			polygonStart,
+			polygonEnd
+		};
+		function point(x, y) {
+			if (visible(x, y)) activeStream.point(x, y);
+		}
+		function polygonInside() {
+			var winding = 0;
+			for (var i = 0, n = polygon.length; i < n; ++i) for (var ring = polygon[i], j = 1, m = ring.length, point = ring[0], a0, a1, b0 = point[0], b1 = point[1]; j < m; ++j) {
+				a0 = b0, a1 = b1, point = ring[j], b0 = point[0], b1 = point[1];
+				if (a1 <= y1) {
+					if (b1 > y1 && (b0 - a0) * (y1 - a1) > (b1 - a1) * (x0 - a0)) ++winding;
+				} else if (b1 <= y1 && (b0 - a0) * (y1 - a1) < (b1 - a1) * (x0 - a0)) --winding;
+			}
+			return winding;
+		}
+		function polygonStart() {
+			activeStream = bufferStream, segments = [], polygon = [], clean = true;
+		}
+		function polygonEnd() {
+			var startInside = polygonInside(), cleanInside = clean && startInside, visible = (segments = merge(segments)).length;
+			if (cleanInside || visible) {
+				stream.polygonStart();
+				if (cleanInside) {
+					stream.lineStart();
+					interpolate(null, null, 1, stream);
+					stream.lineEnd();
+				}
+				if (visible) rejoin_default(segments, compareIntersection, startInside, interpolate, stream);
+				stream.polygonEnd();
+			}
+			activeStream = stream, segments = polygon = ring = null;
+		}
+		function lineStart() {
+			clipStream.point = linePoint;
+			if (polygon) polygon.push(ring = []);
+			first = true;
+			v_ = false;
+			x_ = y_ = NaN;
+		}
+		function lineEnd() {
+			if (segments) {
+				linePoint(x__, y__);
+				if (v__ && v_) bufferStream.rejoin();
+				segments.push(bufferStream.result());
+			}
+			clipStream.point = point;
+			if (v_) activeStream.lineEnd();
+		}
+		function linePoint(x, y) {
+			var v = visible(x, y);
+			if (polygon) ring.push([x, y]);
+			if (first) {
+				x__ = x, y__ = y, v__ = v;
+				first = false;
+				if (v) {
+					activeStream.lineStart();
+					activeStream.point(x, y);
+				}
+			} else if (v && v_) activeStream.point(x, y);
+			else {
+				var a = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))], b = [x = Math.max(clipMin, Math.min(clipMax, x)), y = Math.max(clipMin, Math.min(clipMax, y))];
+				if (line_default(a, b, x0, y0, x1, y1)) {
+					if (!v_) {
+						activeStream.lineStart();
+						activeStream.point(a[0], a[1]);
+					}
+					activeStream.point(b[0], b[1]);
+					if (!v) activeStream.lineEnd();
+					clean = false;
+				} else if (v) {
+					activeStream.lineStart();
+					activeStream.point(x, y);
+					clean = false;
+				}
+			}
+			x_ = x, y_ = y, v_ = v;
+		}
+		return clipStream;
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/length.js
+var lengthSum;
+var lambda0;
+var sinPhi0;
+var cosPhi0;
+var lengthStream = {
+	sphere: noop,
+	point: noop,
+	lineStart: lengthLineStart,
+	lineEnd: noop,
+	polygonStart: noop,
+	polygonEnd: noop
+};
+function lengthLineStart() {
+	lengthStream.point = lengthPointFirst;
+	lengthStream.lineEnd = lengthLineEnd;
+}
+function lengthLineEnd() {
+	lengthStream.point = lengthStream.lineEnd = noop;
+}
+function lengthPointFirst(lambda, phi) {
+	lambda *= radians$1, phi *= radians$1;
+	lambda0 = lambda, sinPhi0 = sin$1(phi), cosPhi0 = cos$1(phi);
+	lengthStream.point = lengthPoint;
+}
+function lengthPoint(lambda, phi) {
+	lambda *= radians$1, phi *= radians$1;
+	var sinPhi = sin$1(phi), cosPhi = cos$1(phi), delta = abs(lambda - lambda0), cosDelta = cos$1(delta), x = cosPhi * sin$1(delta), y = cosPhi0 * sinPhi - sinPhi0 * cosPhi * cosDelta, z = sinPhi0 * sinPhi + cosPhi0 * cosPhi * cosDelta;
+	lengthSum.add(atan2$1(sqrt$1(x * x + y * y), z));
+	lambda0 = lambda, sinPhi0 = sinPhi, cosPhi0 = cosPhi;
+}
+function length_default(object) {
+	lengthSum = new Adder();
+	stream_default(object, lengthStream);
+	return +lengthSum;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/distance.js
+var coordinates = [null, null];
+var object = {
+	type: "LineString",
+	coordinates
+};
+function distance_default(a, b) {
+	coordinates[0] = a;
+	coordinates[1] = b;
+	return length_default(object);
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/transform.js
+function transform_default(methods) {
+	return { stream: transformer(methods) };
+}
+function transformer(methods) {
+	return function(stream) {
+		var s = new TransformStream();
+		for (var key in methods) s[key] = methods[key];
+		s.stream = stream;
+		return s;
+	};
+}
+function TransformStream() {}
+TransformStream.prototype = {
+	constructor: TransformStream,
+	point: function(x, y) {
+		this.stream.point(x, y);
+	},
+	sphere: function() {
+		this.stream.sphere();
+	},
+	lineStart: function() {
+		this.stream.lineStart();
+	},
+	lineEnd: function() {
+		this.stream.lineEnd();
+	},
+	polygonStart: function() {
+		this.stream.polygonStart();
+	},
+	polygonEnd: function() {
+		this.stream.polygonEnd();
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/projection/fit.js
+function fit(projection, fitBounds, object) {
+	var clip = projection.clipExtent && projection.clipExtent();
+	projection.scale(150).translate([0, 0]);
+	if (clip != null) projection.clipExtent(null);
+	stream_default(object, projection.stream(boundsStream));
+	fitBounds(boundsStream.result());
+	if (clip != null) projection.clipExtent(clip);
+	return projection;
+}
+function fitExtent(projection, extent, object) {
+	return fit(projection, function(b) {
+		var w = extent[1][0] - extent[0][0], h = extent[1][1] - extent[0][1], k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])), x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2, y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2;
+		projection.scale(150 * k).translate([x, y]);
+	}, object);
+}
+function fitSize(projection, size, object) {
+	return fitExtent(projection, [[0, 0], size], object);
+}
+function fitWidth(projection, width, object) {
+	return fit(projection, function(b) {
+		var w = +width, k = w / (b[1][0] - b[0][0]), x = (w - k * (b[1][0] + b[0][0])) / 2, y = -k * b[0][1];
+		projection.scale(150 * k).translate([x, y]);
+	}, object);
+}
+function fitHeight(projection, height, object) {
+	return fit(projection, function(b) {
+		var h = +height, k = h / (b[1][1] - b[0][1]), x = -k * b[0][0], y = (h - k * (b[1][1] + b[0][1])) / 2;
+		projection.scale(150 * k).translate([x, y]);
+	}, object);
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/projection/resample.js
+var maxDepth = 16;
+var cosMinDistance = cos$1(30 * radians$1);
+function resample_default(project, delta2) {
+	return +delta2 ? resample(project, delta2) : resampleNone(project);
+}
+function resampleNone(project) {
+	return transformer({ point: function(x, y) {
+		x = project(x, y);
+		this.stream.point(x[0], x[1]);
+	} });
+}
+function resample(project, delta2) {
+	function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) {
+		var dx = x1 - x0, dy = y1 - y0, d2 = dx * dx + dy * dy;
+		if (d2 > 4 * delta2 && depth--) {
+			var a = a0 + a1, b = b0 + b1, c = c0 + c1, m = sqrt$1(a * a + b * b + c * c), phi2 = asin$1(c /= m), lambda2 = abs(abs(c) - 1) < 1e-6 || abs(lambda0 - lambda1) < 1e-6 ? (lambda0 + lambda1) / 2 : atan2$1(b, a), p = project(lambda2, phi2), x2 = p[0], y2 = p[1], dx2 = x2 - x0, dy2 = y2 - y0, dz = dy * dx2 - dx * dy2;
+			if (dz * dz / d2 > delta2 || abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) {
+				resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream);
+				stream.point(x2, y2);
+				resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream);
+			}
+		}
+	}
+	return function(stream) {
+		var lambda00, x00, y00, a00, b00, c00, lambda0, x0, y0, a0, b0, c0;
+		var resampleStream = {
+			point,
+			lineStart,
+			lineEnd,
+			polygonStart: function() {
+				stream.polygonStart();
+				resampleStream.lineStart = ringStart;
+			},
+			polygonEnd: function() {
+				stream.polygonEnd();
+				resampleStream.lineStart = lineStart;
+			}
+		};
+		function point(x, y) {
+			x = project(x, y);
+			stream.point(x[0], x[1]);
+		}
+		function lineStart() {
+			x0 = NaN;
+			resampleStream.point = linePoint;
+			stream.lineStart();
+		}
+		function linePoint(lambda, phi) {
+			var c = cartesian$1([lambda, phi]), p = project(lambda, phi);
+			resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
+			stream.point(x0, y0);
+		}
+		function lineEnd() {
+			resampleStream.point = point;
+			stream.lineEnd();
+		}
+		function ringStart() {
+			lineStart();
+			resampleStream.point = ringPoint;
+			resampleStream.lineEnd = ringEnd;
+		}
+		function ringPoint(lambda, phi) {
+			linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;
+			resampleStream.point = linePoint;
+		}
+		function ringEnd() {
+			resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream);
+			resampleStream.lineEnd = lineEnd;
+			lineEnd();
+		}
+		return resampleStream;
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/projection/index.js
+var transformRadians = transformer({ point: function(x, y) {
+	this.stream.point(x * radians$1, y * radians$1);
+} });
+function transformRotate(rotate) {
+	return transformer({ point: function(x, y) {
+		var r = rotate(x, y);
+		return this.stream.point(r[0], r[1]);
+	} });
+}
+function scaleTranslate(k, dx, dy, sx, sy) {
+	function transform(x, y) {
+		x *= sx;
+		y *= sy;
+		return [dx + k * x, dy - k * y];
+	}
+	transform.invert = function(x, y) {
+		return [(x - dx) / k * sx, (dy - y) / k * sy];
+	};
+	return transform;
+}
+function scaleTranslateRotate(k, dx, dy, sx, sy, alpha) {
+	if (!alpha) return scaleTranslate(k, dx, dy, sx, sy);
+	var cosAlpha = cos$1(alpha), sinAlpha = sin$1(alpha), a = cosAlpha * k, b = sinAlpha * k, ai = cosAlpha / k, bi = sinAlpha / k, ci = (sinAlpha * dy - cosAlpha * dx) / k, fi = (sinAlpha * dx + cosAlpha * dy) / k;
+	function transform(x, y) {
+		x *= sx;
+		y *= sy;
+		return [a * x - b * y + dx, dy - b * x - a * y];
+	}
+	transform.invert = function(x, y) {
+		return [sx * (ai * x - bi * y + ci), sy * (fi - bi * x - ai * y)];
+	};
+	return transform;
+}
+function projection(project) {
+	return projectionMutator(function() {
+		return project;
+	})();
+}
+function projectionMutator(projectAt) {
+	var project, k = 150, x = 480, y = 250, lambda = 0, phi = 0, deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, rotate, alpha = 0, sx = 1, sy = 1, theta = null, preclip = antimeridian_default, x0 = null, y0, x1, y1, postclip = identity_default, delta2 = .5, projectResample, projectTransform, projectRotateTransform, cache, cacheStream;
+	function projection(point) {
+		return projectRotateTransform(point[0] * radians$1, point[1] * radians$1);
+	}
+	function invert(point) {
+		point = projectRotateTransform.invert(point[0], point[1]);
+		return point && [point[0] * degrees$1, point[1] * degrees$1];
+	}
+	projection.stream = function(stream) {
+		return cache && cacheStream === stream ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream)))));
+	};
+	projection.preclip = function(_) {
+		return arguments.length ? (preclip = _, theta = void 0, reset()) : preclip;
+	};
+	projection.postclip = function(_) {
+		return arguments.length ? (postclip = _, x0 = y0 = x1 = y1 = null, reset()) : postclip;
+	};
+	projection.clipAngle = function(_) {
+		return arguments.length ? (preclip = +_ ? circle_default(theta = _ * radians$1) : (theta = null, antimeridian_default), reset()) : theta * degrees$1;
+	};
+	projection.clipExtent = function(_) {
+		return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, identity_default) : clipRectangle(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];
+	};
+	projection.scale = function(_) {
+		return arguments.length ? (k = +_, recenter()) : k;
+	};
+	projection.translate = function(_) {
+		return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y];
+	};
+	projection.center = function(_) {
+		return arguments.length ? (lambda = _[0] % 360 * radians$1, phi = _[1] % 360 * radians$1, recenter()) : [lambda * degrees$1, phi * degrees$1];
+	};
+	projection.rotate = function(_) {
+		return arguments.length ? (deltaLambda = _[0] % 360 * radians$1, deltaPhi = _[1] % 360 * radians$1, deltaGamma = _.length > 2 ? _[2] % 360 * radians$1 : 0, recenter()) : [
+			deltaLambda * degrees$1,
+			deltaPhi * degrees$1,
+			deltaGamma * degrees$1
+		];
+	};
+	projection.angle = function(_) {
+		return arguments.length ? (alpha = _ % 360 * radians$1, recenter()) : alpha * degrees$1;
+	};
+	projection.reflectX = function(_) {
+		return arguments.length ? (sx = _ ? -1 : 1, recenter()) : sx < 0;
+	};
+	projection.reflectY = function(_) {
+		return arguments.length ? (sy = _ ? -1 : 1, recenter()) : sy < 0;
+	};
+	projection.precision = function(_) {
+		return arguments.length ? (projectResample = resample_default(projectTransform, delta2 = _ * _), reset()) : sqrt$1(delta2);
+	};
+	projection.fitExtent = function(extent, object) {
+		return fitExtent(projection, extent, object);
+	};
+	projection.fitSize = function(size, object) {
+		return fitSize(projection, size, object);
+	};
+	projection.fitWidth = function(width, object) {
+		return fitWidth(projection, width, object);
+	};
+	projection.fitHeight = function(height, object) {
+		return fitHeight(projection, height, object);
+	};
+	function recenter() {
+		var center = scaleTranslateRotate(k, 0, 0, sx, sy, alpha).apply(null, project(lambda, phi)), transform = scaleTranslateRotate(k, x - center[0], y - center[1], sx, sy, alpha);
+		rotate = rotateRadians(deltaLambda, deltaPhi, deltaGamma);
+		projectTransform = compose_default(project, transform);
+		projectRotateTransform = compose_default(rotate, projectTransform);
+		projectResample = resample_default(projectTransform, delta2);
+		return reset();
+	}
+	function reset() {
+		cache = cacheStream = null;
+		return projection;
+	}
+	return function() {
+		project = projectAt.apply(this, arguments);
+		projection.invert = project.invert && invert;
+		return recenter();
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/projection/azimuthal.js
+function azimuthalInvert(angle) {
+	return function(x, y) {
+		var z = sqrt$1(x * x + y * y), c = angle(z), sc = sin$1(c), cc = cos$1(c);
+		return [atan2$1(x * sc, z * cc), asin$1(z && y * sc / z)];
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/projection/stereographic.js
+function stereographicRaw(x, y) {
+	var cy = cos$1(y), k = 1 + cos$1(x) * cy;
+	return [cy * sin$1(x) / k, sin$1(y) / k];
+}
+stereographicRaw.invert = azimuthalInvert(function(z) {
+	return 2 * atan(z);
+});
+function stereographic_default() {
+	return projection(stereographicRaw).scale(250).clipAngle(142);
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo-voronoi@2.1.0/node_modules/d3-geo-voronoi/src/math.js
+var pi = Math.PI;
+var halfPi = pi / 2;
+var degrees = 180 / pi;
+var radians = pi / 180;
+var atan2 = Math.atan2;
+var cos = Math.cos;
+var max = Math.max;
+var min = Math.min;
+var sin = Math.sin;
+var sign = Math.sign || function(x) {
+	return x > 0 ? 1 : x < 0 ? -1 : 0;
+};
+var sqrt = Math.sqrt;
+function asin(x) {
+	return x > 1 ? halfPi : x < -1 ? -halfPi : Math.asin(x);
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo-voronoi@2.1.0/node_modules/d3-geo-voronoi/src/cartesian.js
+function cartesianDot(a, b) {
+	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cartesianCross(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+function cartesianAdd(a, b) {
+	return [
+		a[0] + b[0],
+		a[1] + b[1],
+		a[2] + b[2]
+	];
+}
+function cartesianNormalize(d) {
+	var l = sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+	return [
+		d[0] / l,
+		d[1] / l,
+		d[2] / l
+	];
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo-voronoi@2.1.0/node_modules/d3-geo-voronoi/src/delaunay.js
+function spherical(cartesian) {
+	return [atan2(cartesian[1], cartesian[0]) * degrees, asin(max(-1, min(1, cartesian[2]))) * degrees];
+}
+function cartesian(coordinates) {
+	const lambda = coordinates[0] * radians, phi = coordinates[1] * radians, cosphi = cos(phi);
+	return [
+		cosphi * cos(lambda),
+		cosphi * sin(lambda),
+		sin(phi)
+	];
+}
+function excess(triangle) {
+	triangle = triangle.map((p) => cartesian(p));
+	return cartesianDot(triangle[0], cartesianCross(triangle[2], triangle[1]));
+}
+function geoDelaunay(points) {
+	const delaunay = geo_delaunay_from(points), triangles = geo_triangles(delaunay), edges = geo_edges(triangles, points), neighbors = geo_neighbors(triangles, points.length), find = geo_find(neighbors, points), { polygons, centers } = geo_polygons(geo_circumcenters(triangles, points), triangles, points);
+	return {
+		delaunay,
+		edges,
+		triangles,
+		centers,
+		neighbors,
+		polygons,
+		mesh: geo_mesh(polygons),
+		hull: geo_hull(triangles, points),
+		urquhart: geo_urquhart(edges, triangles),
+		find
+	};
+}
+function geo_find(neighbors, points) {
+	function distance2(a, b) {
+		let x = a[0] - b[0], y = a[1] - b[1], z = a[2] - b[2];
+		return x * x + y * y + z * z;
+	}
+	return function find(x, y, next) {
+		if (next === void 0) next = 0;
+		let cell, dist, found = next;
+		const xyz = cartesian([x, y]);
+		do {
+			cell = next;
+			next = null;
+			dist = distance2(xyz, cartesian(points[cell]));
+			neighbors[cell].forEach((i) => {
+				let ndist = distance2(xyz, cartesian(points[i]));
+				if (ndist < dist) {
+					dist = ndist;
+					next = i;
+					found = i;
+					return;
+				}
+			});
+		} while (next !== null);
+		return found;
+	};
+}
+function geo_delaunay_from(points) {
+	if (points.length < 2) return {};
+	let pivot = 0;
+	while (isNaN(points[pivot][0] + points[pivot][1]) && pivot++ < points.length);
+	const r = rotation_default(points[pivot]), projection = stereographic_default().translate([0, 0]).scale(1).rotate(r.invert([180, 0]));
+	points = points.map(projection);
+	const zeros = [];
+	let max2 = 1;
+	for (let i = 0, n = points.length; i < n; i++) {
+		let m = points[i][0] ** 2 + points[i][1] ** 2;
+		if (!isFinite(m) || m > 1e32) zeros.push(i);
+		else if (m > max2) max2 = m;
+	}
+	const FAR = 1e6 * sqrt(max2);
+	zeros.forEach((i) => points[i] = [FAR, 0]);
+	points.push([0, FAR]);
+	points.push([-FAR, 0]);
+	points.push([0, -FAR]);
+	const delaunay = Delaunay.from(points);
+	delaunay.projection = projection;
+	const { triangles, halfedges, inedges } = delaunay;
+	for (let i = 0, l = halfedges.length; i < l; i++) if (halfedges[i] < 0) {
+		const j = i % 3 == 2 ? i - 2 : i + 1;
+		const k = i % 3 == 0 ? i + 2 : i - 1;
+		const a = halfedges[j];
+		const b = halfedges[k];
+		halfedges[a] = b;
+		halfedges[b] = a;
+		halfedges[j] = halfedges[k] = -1;
+		triangles[i] = triangles[j] = triangles[k] = pivot;
+		inedges[triangles[a]] = a % 3 == 0 ? a + 2 : a - 1;
+		inedges[triangles[b]] = b % 3 == 0 ? b + 2 : b - 1;
+		i += 2 - i % 3;
+	} else if (triangles[i] > points.length - 3 - 1) triangles[i] = pivot;
+	return delaunay;
+}
+function geo_edges(triangles, points) {
+	const _index = /* @__PURE__ */ new Set();
+	if (points.length === 2) return [[0, 1]];
+	triangles.forEach((tri) => {
+		if (tri[0] === tri[1]) return;
+		if (excess(tri.map((i) => points[i])) < 0) return;
+		for (let i = 0, j; i < 3; i++) {
+			j = (i + 1) % 3;
+			_index.add(extent([tri[i], tri[j]]).join("-"));
+		}
+	});
+	return Array.from(_index, (d) => d.split("-").map(Number));
+}
+function geo_triangles(delaunay) {
+	const { triangles } = delaunay;
+	if (!triangles) return [];
+	const geo_triangles = [];
+	for (let i = 0, n = triangles.length / 3; i < n; i++) {
+		const a = triangles[3 * i], b = triangles[3 * i + 1], c = triangles[3 * i + 2];
+		if (a !== b && b !== c) geo_triangles.push([
+			a,
+			c,
+			b
+		]);
+	}
+	return geo_triangles;
+}
+function geo_circumcenters(triangles, points) {
+	return triangles.map((tri) => {
+		const c = tri.map((i) => points[i]).map(cartesian);
+		return spherical(cartesianNormalize(cartesianAdd(cartesianAdd(cartesianCross(c[1], c[0]), cartesianCross(c[2], c[1])), cartesianCross(c[0], c[2]))));
+	});
+}
+function geo_neighbors(triangles, npoints) {
+	const neighbors = [];
+	triangles.forEach((tri) => {
+		for (let j = 0; j < 3; j++) {
+			const a = tri[j], b = tri[(j + 1) % 3];
+			neighbors[a] = neighbors[a] || [];
+			neighbors[a].push(b);
+		}
+	});
+	if (triangles.length === 0) {
+		if (npoints === 2) neighbors[0] = [1], neighbors[1] = [0];
+		else if (npoints === 1) neighbors[0] = [];
+	}
+	return neighbors;
+}
+function geo_polygons(circumcenters, triangles, points) {
+	const polygons = [];
+	const centers = circumcenters.slice();
+	if (triangles.length === 0) {
+		if (points.length < 2) return {
+			polygons,
+			centers
+		};
+		if (points.length === 2) {
+			const a = cartesian(points[0]), b = cartesian(points[1]), m = cartesianNormalize(cartesianAdd(a, b)), c = cartesianCross(m, cartesianNormalize(cartesianCross(a, b)));
+			const poly = [
+				m,
+				cartesianCross(m, c),
+				cartesianCross(cartesianCross(m, c), c),
+				cartesianCross(cartesianCross(cartesianCross(m, c), c), c)
+			].map(spherical).map(supplement);
+			return polygons.push(poly), polygons.push(poly.slice().reverse()), {
+				polygons,
+				centers
+			};
+		}
+	}
+	triangles.forEach((tri, t) => {
+		for (let j = 0; j < 3; j++) {
+			const a = tri[j], b = tri[(j + 1) % 3], c = tri[(j + 2) % 3];
+			polygons[a] = polygons[a] || [];
+			polygons[a].push([
+				b,
+				c,
+				t,
+				[
+					a,
+					b,
+					c
+				]
+			]);
+		}
+	});
+	const reordered = polygons.map((poly) => {
+		const p = [poly[0][2]];
+		let k = poly[0][1];
+		for (let i = 1; i < poly.length; i++) for (let j = 0; j < poly.length; j++) if (poly[j][0] == k) {
+			k = poly[j][1];
+			p.push(poly[j][2]);
+			break;
+		}
+		if (p.length > 2) return p;
+		else if (p.length == 2) {
+			const R0 = o_midpoint(points[poly[0][3][0]], points[poly[0][3][1]], centers[p[0]]), R1 = o_midpoint(points[poly[0][3][2]], points[poly[0][3][0]], centers[p[0]]);
+			const i0 = supplement(R0), i1 = supplement(R1);
+			return [
+				p[0],
+				i1,
+				p[1],
+				i0
+			];
+		}
+	});
+	function supplement(point) {
+		let f = -1;
+		centers.slice(triangles.length, Infinity).forEach((p, i) => {
+			if (p[0] === point[0] && p[1] === point[1]) f = i + triangles.length;
+		});
+		if (f < 0) f = centers.length, centers.push(point);
+		return f;
+	}
+	return {
+		polygons: reordered,
+		centers
+	};
+}
+function o_midpoint(a, b, c) {
+	a = cartesian(a);
+	b = cartesian(b);
+	c = cartesian(c);
+	const s = sign(cartesianDot(cartesianCross(b, a), c));
+	return spherical(cartesianNormalize(cartesianAdd(a, b)).map((d) => s * d));
+}
+function geo_mesh(polygons) {
+	const mesh = [];
+	polygons.forEach((poly) => {
+		if (!poly) return;
+		let p = poly[poly.length - 1];
+		for (let q of poly) {
+			if (q > p) mesh.push([p, q]);
+			p = q;
+		}
+	});
+	return mesh;
+}
+function geo_urquhart(edges, triangles) {
+	return function(distances) {
+		const _lengths = /* @__PURE__ */ new Map(), _urquhart = /* @__PURE__ */ new Map();
+		edges.forEach((edge, i) => {
+			const u = edge.join("-");
+			_lengths.set(u, distances[i]);
+			_urquhart.set(u, true);
+		});
+		triangles.forEach((tri) => {
+			let l = 0, remove = -1;
+			for (let j = 0; j < 3; j++) {
+				let u = extent([tri[j], tri[(j + 1) % 3]]).join("-");
+				if (_lengths.get(u) > l) {
+					l = _lengths.get(u);
+					remove = u;
+				}
+			}
+			_urquhart.set(remove, false);
+		});
+		return edges.map((edge) => _urquhart.get(edge.join("-")));
+	};
+}
+function geo_hull(triangles, points) {
+	const _hull = /* @__PURE__ */ new Set(), hull = [];
+	triangles.map((tri) => {
+		if (excess(tri.map((i) => points[i > points.length ? 0 : i])) > 1e-12) return;
+		for (let i = 0; i < 3; i++) {
+			let e = [tri[i], tri[(i + 1) % 3]], code = `${e[0]}-${e[1]}`;
+			if (_hull.has(code)) _hull.delete(code);
+			else _hull.add(`${e[1]}-${e[0]}`);
+		}
+	});
+	const _index = /* @__PURE__ */ new Map();
+	let start;
+	_hull.forEach((e) => {
+		e = e.split("-").map(Number);
+		_index.set(e[0], e[1]);
+		start = e[0];
+	});
+	if (start === void 0) return hull;
+	let next = start;
+	do {
+		hull.push(next);
+		let n = _index.get(next);
+		_index.set(next, -1);
+		next = n;
+	} while (next > -1 && next !== start);
+	return hull;
+}
+//#endregion
+//#region node_modules/.pnpm/d3-geo-voronoi@2.1.0/node_modules/d3-geo-voronoi/src/voronoi.js
+function geoVoronoi(data) {
+	const v = function(data) {
+		v.delaunay = null;
+		v._data = data;
+		if (typeof v._data === "object" && v._data.type === "FeatureCollection") v._data = v._data.features;
+		if (typeof v._data === "object") {
+			const temp = v._data.map((d) => [
+				v._vx(d),
+				v._vy(d),
+				d
+			]).filter((d) => isFinite(d[0] + d[1]));
+			v.points = temp.map((d) => [d[0], d[1]]);
+			v.valid = temp.map((d) => d[2]);
+			v.delaunay = geoDelaunay(v.points);
+		}
+		return v;
+	};
+	v._vx = function(d) {
+		if (typeof d == "object" && "type" in d) return centroid_default(d)[0];
+		if (0 in d) return d[0];
+	};
+	v._vy = function(d) {
+		if (typeof d == "object" && "type" in d) return centroid_default(d)[1];
+		if (1 in d) return d[1];
+	};
+	v.x = function(f) {
+		if (!f) return v._vx;
+		v._vx = f;
+		return v;
+	};
+	v.y = function(f) {
+		if (!f) return v._vy;
+		v._vy = f;
+		return v;
+	};
+	v.polygons = function(data) {
+		if (data !== void 0) v(data);
+		if (!v.delaunay) return false;
+		const coll = {
+			type: "FeatureCollection",
+			features: []
+		};
+		if (v.valid.length === 0) return coll;
+		v.delaunay.polygons.forEach((poly, i) => coll.features.push({
+			type: "Feature",
+			geometry: !poly ? null : {
+				type: "Polygon",
+				coordinates: [[...poly, poly[0]].map((i) => v.delaunay.centers[i])]
+			},
+			properties: {
+				site: v.valid[i],
+				sitecoordinates: v.points[i],
+				neighbours: v.delaunay.neighbors[i]
+			}
+		}));
+		if (v.valid.length === 1) coll.features.push({
+			type: "Feature",
+			geometry: { type: "Sphere" },
+			properties: {
+				site: v.valid[0],
+				sitecoordinates: v.points[0],
+				neighbours: []
+			}
+		});
+		return coll;
+	};
+	v.triangles = function(data) {
+		if (data !== void 0) v(data);
+		if (!v.delaunay) return false;
+		return {
+			type: "FeatureCollection",
+			features: v.delaunay.triangles.map((tri, index) => {
+				tri = tri.map((i) => v.points[i]);
+				tri.center = v.delaunay.centers[index];
+				return tri;
+			}).filter((tri) => excess(tri) > 0).map((tri) => ({
+				type: "Feature",
+				properties: { circumcenter: tri.center },
+				geometry: {
+					type: "Polygon",
+					coordinates: [[...tri, tri[0]]]
+				}
+			}))
+		};
+	};
+	v.links = function(data) {
+		if (data !== void 0) v(data);
+		if (!v.delaunay) return false;
+		const _distances = v.delaunay.edges.map((e) => distance_default(v.points[e[0]], v.points[e[1]])), _urquart = v.delaunay.urquhart(_distances);
+		return {
+			type: "FeatureCollection",
+			features: v.delaunay.edges.map((e, i) => ({
+				type: "Feature",
+				properties: {
+					source: v.valid[e[0]],
+					target: v.valid[e[1]],
+					length: _distances[i],
+					urquhart: !!_urquart[i]
+				},
+				geometry: {
+					type: "LineString",
+					coordinates: [v.points[e[0]], v.points[e[1]]]
+				}
+			}))
+		};
+	};
+	v.mesh = function(data) {
+		if (data !== void 0) v(data);
+		if (!v.delaunay) return false;
+		return {
+			type: "MultiLineString",
+			coordinates: v.delaunay.edges.map((e) => [v.points[e[0]], v.points[e[1]]])
+		};
+	};
+	v.cellMesh = function(data) {
+		if (data !== void 0) v(data);
+		if (!v.delaunay) return false;
+		const { centers, polygons } = v.delaunay;
+		const coordinates = [];
+		for (const p of polygons) {
+			if (!p) continue;
+			for (let n = p.length, p0 = p[n - 1], p1 = p[0], i = 0; i < n; p0 = p1, p1 = p[++i]) if (p1 > p0) coordinates.push([centers[p0], centers[p1]]);
+		}
+		return {
+			type: "MultiLineString",
+			coordinates
+		};
+	};
+	v._found = void 0;
+	v.find = function(x, y, radius) {
+		v._found = v.delaunay.find(x, y, v._found);
+		if (!radius || distance_default([x, y], v.points[v._found]) < radius) return v._found;
+	};
+	v.hull = function(data) {
+		if (data !== void 0) v(data);
+		const hull = v.delaunay.hull, points = v.points;
+		return hull.length === 0 ? null : {
+			type: "Polygon",
+			coordinates: [[...hull.map((i) => points[i]), points[hull[0]]]]
+		};
+	};
+	return data ? v(data) : v;
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/utils/geo.js
+/**
+* Render a geoPath() using curve factory
+* @see {@link https://observablehq.com/@d3/context-to-curve}
+*/
+function geoCurvePath(projection, curve, context) {
+	const pathContext = path() ;
+	const geoPath = path_default(projection, curveContext(curve(pathContext)));
+	const fn = (object) => {
+		geoPath(object);
+		return context === void 0 ? pathContext + "" : void 0;
+	};
+	Object.setPrototypeOf(fn, geoPath);
+	return fn;
+}
+/**
+* Translate Curve to GeoContext interface
+*/
+function curveContext(curve) {
+	return {
+		beginPath() {},
+		moveTo(x, y) {
+			curve.lineStart();
+			curve.point(x, y);
+		},
+		arc(x, y, radius, startAngle, endAngle, anticlockwise) {},
+		lineTo(x, y) {
+			curve.point(x, y);
+		},
+		closePath() {
+			curve.lineEnd();
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/geo/GeoPath/GeoPath.base.svelte
+function GeoPath_base($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { Path, geoTransform, geojson, tooltip, curve = linearClosed_default, onclick, onpointerenter, onpointermove, onpointerleave, class: className, ref: refProp = void 0, children, $$slots, $$events, ...restProps } = $$props;
+		const ctx = getChartContext();
+		const geo = getGeoContext();
+		const projection = derived(() => geoTransform && geo.projection ? transform_default(geoTransform(geo.projection)) : geo.projection);
+		const geoPath = derived(() => {
+			if (!projection()) return;
+			if (curve === linearClosed_default) return path_default(projection());
+			return geoCurvePath(projection(), curve);
+		});
+		const pathData = derived(() => geojson ? geoPath()?.(geojson) ?? "" : "");
+		function _onClick(e) {
+			onclick?.(e, geoPath());
+		}
+		function _onPointerEnter(e) {
+			onpointerenter?.(e);
+			if (tooltip) ctx?.tooltip.show(e, geojson);
+		}
+		function _onPointerMove(e) {
+			onpointermove?.(e);
+			if (tooltip) ctx.tooltip.show(e, geojson);
+		}
+		function _onPointerLeave(e) {
+			onpointerleave?.(e);
+			if (tooltip) ctx.tooltip.hide();
+		}
+		if (children) {
+			$$renderer.push("<!--[0-->");
+			children($$renderer, { geoPath: geoPath() });
+			$$renderer.push(`<!---->`);
+		} else {
+			$$renderer.push("<!--[-1-->");
+			if (Path) {
+				$$renderer.push("<!--[-->");
+				Path($$renderer, spread_props([
+					{ pathData: pathData() },
+					restProps,
+					onclick && { onclick: _onClick },
+					(tooltip || onpointerenter) && { onpointerenter: _onPointerEnter },
+					(tooltip || onpointermove) && { onpointermove: _onPointerMove },
+					(tooltip || onpointerleave) && { onpointerleave: _onPointerLeave },
+					{
+						class: cls("lc-geo-path", className),
+						pathRef: refProp
+					}
+				]));
+				$$renderer.push("<!--]-->");
+			} else {
+				$$renderer.push("<!--[!-->");
+				$$renderer.push("<!--]-->");
+			}
+		}
+		$$renderer.push(`<!--]-->`);
+		bind_props($$props, { ref: refProp });
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/geo/GeoPath/GeoPath.svg.svelte
+function GeoPath_svg($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	GeoPath_base($$renderer, spread_props([{ Path: Path_svg }, props]));
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/geo/GeoPath/GeoPath.canvas.svelte
+function GeoPath_canvas($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	GeoPath_base($$renderer, spread_props([{ Path: Path_canvas }, props]));
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/geo/GeoPath/GeoPath.svelte
+function GeoPath($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const layerCtx = getLayerContext();
+		let { $$slots, $$events, ...props } = $$props;
+		if (layerCtx === "svg") {
+			$$renderer.push("<!--[0-->");
+			GeoPath_svg($$renderer, spread_props([props]));
+		} else if (layerCtx === "canvas") {
+			$$renderer.push("<!--[1-->");
+			GeoPath_canvas($$renderer, spread_props([props]));
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/Voronoi/Voronoi.base.svelte
+function Voronoi_base($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		let { Group, Path, CircleClipPath, data, x: xProp, y: yProp, r, classes = {}, onclick, onpointerenter, onpointerdown, onpointermove, class: className, children, $$slots, $$events, ...restProps } = $$props;
+		const ctx = getChartContext();
+		const facetPanel = getFacetPanel();
+		const geo = getGeoContext();
+		const xAccessorOverride = derived(() => xProp != null ? accessor(xProp) : void 0);
+		const yAccessorOverride = derived(() => yProp != null ? accessor(yProp) : void 0);
+		const points = derived(() => (data ?? facetPanel?.().data ?? ctx.flatData).map((d) => {
+			const xValue = xAccessorOverride() ? geo.projection ? xAccessorOverride()(d) : ctx.xScale(xAccessorOverride()(d)) : geo.projection ? ctx.x(d) : ctx.xGet(d);
+			const yValue = yAccessorOverride() ? geo.projection ? yAccessorOverride()(d) : ctx.yScale(yAccessorOverride()(d)) : geo.projection ? ctx.y(d) : ctx.yGet(d);
+			const x = Array.isArray(xValue) ? max$1(xValue) : xValue;
+			const y = Array.isArray(yValue) ? max$1(yValue) : yValue;
+			let point;
+			if (ctx.radial) {
+				const radialPoint = pointRadial_default(x, y);
+				point = [radialPoint[0] + ctx.width / 2, radialPoint[1] + ctx.height / 2];
+			} else point = [x, y];
+			point.data = d;
+			return point;
+		}));
+		const boundWidth = derived(() => Math.max(ctx.width, 0));
+		const boundHeight = derived(() => Math.max(ctx.height, 0));
+		const disableClip = derived(() => r === 0 || r == null || r === Infinity);
+		const voronoi = derived(() => geo.projection ? null : Delaunay.from(points()).voronoi([
+			0,
+			0,
+			boundWidth(),
+			boundHeight()
+		]));
+		const geoPolygons = derived(() => geo.projection ? geoVoronoi().polygons(points()) : null);
+		const cells = derived(() => {
+			if (!children) return [];
+			if (geo.projection && geoPolygons()) return geoPolygons().features.map((feature, index) => {
+				const projectedPoint = geo.projection?.(feature.properties.sitecoordinates) ?? null;
+				const ring = (feature.geometry?.coordinates?.[0] ?? []).map((coord) => geo.projection?.(coord)).filter((p) => p != null);
+				const polygon = ring.length ? ring : null;
+				const projectedCentroid = geo.projection?.(centroid_default(feature)) ?? null;
+				return {
+					data: feature.properties.site?.data,
+					index,
+					point: projectedPoint ?? [NaN, NaN],
+					polygon,
+					centroid: projectedCentroid && Number.isFinite(projectedCentroid[0]) ? projectedCentroid : null,
+					area: area_default(feature)
+				};
+			});
+			if (voronoi()) return points().map((point, index) => {
+				const polygon = voronoi().cellPolygon(index);
+				return {
+					data: point.data,
+					index,
+					point: [point[0], point[1]],
+					polygon,
+					centroid: polygon ? centroid_default$1(polygon) : null,
+					area: polygon ? Math.abs(area_default$1(polygon)) : 0
+				};
+			});
+			return [];
+		});
+		if (Group) {
+			$$renderer.push("<!--[-->");
+			Group($$renderer, spread_props([restProps, {
+				class: cls("lc-voronoi-g", classes.root, className),
+				children: ($$renderer) => {
+					if (geo.projection) {
+						$$renderer.push("<!--[0-->");
+						if (geoPolygons()) {
+							$$renderer.push(`<!--[0--><!--[-->`);
+							const each_array = ensure_array_like(geoPolygons().features);
+							for (let $$index = 0, $$length = each_array.length; $$index < $$length; $$index++) {
+								let feature = each_array[$$index];
+								const point = r ? geo.projection?.(feature.properties.sitecoordinates) : null;
+								if (CircleClipPath) {
+									$$renderer.push("<!--[-->");
+									CircleClipPath($$renderer, {
+										cx: point?.[0],
+										cy: point?.[1],
+										r: r ?? 0,
+										disabled: point == null || disableClip(),
+										children: ($$renderer) => {
+											GeoPath($$renderer, {
+												geojson: feature,
+												class: ["lc-voronoi-geo-path", classes.path],
+												onclick: (e) => onclick?.(e, {
+													data: feature.properties.site.data,
+													feature
+												}),
+												onpointerenter: (e) => onpointerenter?.(e, {
+													data: feature.properties.site.data,
+													feature
+												}),
+												onpointermove: (e) => onpointermove?.(e, {
+													data: feature.properties.site.data,
+													feature
+												}),
+												onpointerdown: (e) => onpointerdown?.(e, {
+													data: feature.properties.site.data,
+													feature
+												}),
+												ontouchmove: (e) => {
+													e.preventDefault();
+												}
+											});
+										},
+										$$slots: { default: true }
+									});
+									$$renderer.push("<!--]-->");
+								} else {
+									$$renderer.push("<!--[!-->");
+									$$renderer.push("<!--]-->");
+								}
+							}
+							$$renderer.push(`<!--]-->`);
+						} else $$renderer.push("<!--[-1-->");
+						$$renderer.push(`<!--]-->`);
+					} else if (voronoi()) {
+						$$renderer.push(`<!--[1--><!--[-->`);
+						const each_array_1 = ensure_array_like(points());
+						for (let i = 0, $$length = each_array_1.length; i < $$length; i++) {
+							let point = each_array_1[i];
+							const pathData = voronoi().renderCell(i);
+							if (pathData) {
+								$$renderer.push("<!--[0-->");
+								if (CircleClipPath) {
+									$$renderer.push("<!--[-->");
+									CircleClipPath($$renderer, {
+										cx: point[0],
+										cy: point[1],
+										r: r ?? 0,
+										disabled: disableClip(),
+										children: ($$renderer) => {
+											if (Path) {
+												$$renderer.push("<!--[-->");
+												Path($$renderer, {
+													pathData,
+													class: ["lc-voronoi-path", classes.path],
+													onclick: (e) => onclick?.(e, {
+														data: point.data,
+														point
+													}),
+													onpointerenter: (e) => onpointerenter?.(e, {
+														data: point.data,
+														point
+													}),
+													onpointermove: (e) => onpointermove?.(e, {
+														data: point.data,
+														point
+													}),
+													onpointerdown: (e) => onpointerdown?.(e, {
+														data: point.data,
+														point
+													}),
+													ontouchmove: (e) => {
+														e.preventDefault();
+													}
+												});
+												$$renderer.push("<!--]-->");
+											} else {
+												$$renderer.push("<!--[!-->");
+												$$renderer.push("<!--]-->");
+											}
+										},
+										$$slots: { default: true }
+									});
+									$$renderer.push("<!--]-->");
+								} else {
+									$$renderer.push("<!--[!-->");
+									$$renderer.push("<!--]-->");
+								}
+							} else $$renderer.push("<!--[-1-->");
+							$$renderer.push(`<!--]-->`);
+						}
+						$$renderer.push(`<!--]-->`);
+					} else $$renderer.push("<!--[-1-->");
+					$$renderer.push(`<!--]--> `);
+					children?.($$renderer, { cells: cells() });
+					$$renderer.push(`<!---->`);
+				},
+				$$slots: { default: true }
+			}]));
+			$$renderer.push("<!--]-->");
+		} else {
+			$$renderer.push("<!--[!-->");
+			$$renderer.push("<!--]-->");
+		}
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/CircleClipPath/CircleClipPath.base.svelte
+function CircleClipPath_base($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const uid = props_id($$renderer);
+		let { ClipPath, id = createId("clipPath-", uid), cx = 0, cy = 0, r, disabled = false, invert = false, children } = $$props;
+		const path = derived(() => `M${cx - r},${cy} a${r},${r} 0 1,0 ${2 * r},0 a${r},${r} 0 1,0 ${ -2 * r},0 Z`);
+		if (ClipPath) {
+			$$renderer.push("<!--[-->");
+			ClipPath($$renderer, {
+				id,
+				disabled,
+				invert,
+				children,
+				path: path()
+			});
+			$$renderer.push("<!--]-->");
+		} else {
+			$$renderer.push("<!--[!-->");
+			$$renderer.push("<!--]-->");
+		}
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/CircleClipPath/CircleClipPath.svg.svelte
+function CircleClipPath_svg($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	CircleClipPath_base($$renderer, spread_props([{ ClipPath: ClipPath_svg }, props]));
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/Voronoi/Voronoi.svg.svelte
+function Voronoi_svg($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	Voronoi_base($$renderer, spread_props([{
+		Group: Group_svg,
+		Path: Path_svg,
+		CircleClipPath: CircleClipPath_svg
+	}, props]));
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/CircleClipPath/CircleClipPath.canvas.svelte
+function CircleClipPath_canvas($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	CircleClipPath_base($$renderer, spread_props([{ ClipPath: ClipPath_canvas }, props]));
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/Voronoi/Voronoi.canvas.svelte
+function Voronoi_canvas($$renderer, $$props) {
+	let { $$slots, $$events, ...props } = $$props;
+	Voronoi_base($$renderer, spread_props([{
+		Group: Group_canvas,
+		Path: Path_canvas,
+		CircleClipPath: CircleClipPath_canvas
+	}, props]));
+}
+//#endregion
+//#region node_modules/.pnpm/layerchart@2.5.0_@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0__9bc60734f10d29b7556189549fab5703/node_modules/layerchart/dist/components/Voronoi/Voronoi.svelte
+function Voronoi($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		const layerCtx = getLayerContext();
+		let { $$slots, $$events, ...props } = $$props;
+		if (layerCtx === "svg") {
+			$$renderer.push("<!--[0-->");
+			Voronoi_svg($$renderer, spread_props([props]));
+		} else if (layerCtx === "canvas") {
+			$$renderer.push("<!--[1-->");
+			Voronoi_canvas($$renderer, spread_props([props]));
+		} else $$renderer.push("<!--[-1-->");
+		$$renderer.push(`<!--]-->`);
+	});
+}
+
+export { Voronoi as default };
+//# sourceMappingURL=Voronoi.js-DevTsXQE.js.map