@sckyzo/cosmos-charts 0.2.0 → 0.3.0

package/dist/WorldMap.cjs

@@ -0,0 +1,2088 @@
+"use client";
+'use strict';
+
+var chunkT3K6Q34U_cjs = require('./chunk-T3K6Q34U.cjs');
+var chunkLT3UC65O_cjs = require('./chunk-LT3UC65O.cjs');
+var react = require('react');
+var topojsonClient = require('topojson-client');
+var jsxRuntime = require('react/jsx-runtime');
+
+// ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/fsum.js
+var Adder = class {
+  constructor() {
+    this._partials = new Float64Array(32);
+    this._n = 0;
+  }
+  add(x) {
+    const p = this._partials;
+    let i = 0;
+    for (let j = 0; j < this._n && j < 32; j++) {
+      const y = p[j], hi = x + y, lo = Math.abs(x) < Math.abs(y) ? x - (hi - y) : y - (hi - x);
+      if (lo) p[i++] = lo;
+      x = hi;
+    }
+    p[i] = x;
+    this._n = i + 1;
+    return this;
+  }
+  valueOf() {
+    const p = this._partials;
+    let n = this._n, x, y, lo, hi = 0;
+    if (n > 0) {
+      hi = p[--n];
+      while (n > 0) {
+        x = hi;
+        y = p[--n];
+        hi = x + y;
+        lo = y - (hi - x);
+        if (lo) break;
+      }
+      if (n > 0 && (lo < 0 && p[n - 1] < 0 || lo > 0 && p[n - 1] > 0)) {
+        y = lo * 2;
+        x = hi + y;
+        if (y == x - hi) hi = x;
+      }
+    }
+    return hi;
+  }
+};
+
+// ../../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));
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/math.js
+var epsilon = 1e-6;
+var pi = Math.PI;
+var halfPi = pi / 2;
+var quarterPi = pi / 4;
+var tau = pi * 2;
+var degrees = 180 / pi;
+var radians = pi / 180;
+var abs = Math.abs;
+var atan = Math.atan;
+var atan2 = Math.atan2;
+var cos = Math.cos;
+var sin = Math.sin;
+var sign = Math.sign || function(x) {
+  return x > 0 ? 1 : x < 0 ? -1 : 0;
+};
+var sqrt = Math.sqrt;
+function acos(x) {
+  return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);
+}
+function asin(x) {
+  return x > 1 ? halfPi : x < -1 ? -halfPi : Math.asin(x);
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/noop.js
+function noop() {
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/stream.js
+function streamGeometry(geometry, stream) {
+  if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {
+    streamGeometryType[geometry.type](geometry, stream);
+  }
+}
+var streamObjectType = {
+  Feature: function(object, stream) {
+    streamGeometry(object.geometry, stream);
+  },
+  FeatureCollection: function(object, stream) {
+    var features = object.features, i = -1, n = features.length;
+    while (++i < n) streamGeometry(features[i].geometry, stream);
+  }
+};
+var streamGeometryType = {
+  Sphere: function(object, stream) {
+    stream.sphere();
+  },
+  Point: function(object, stream) {
+    object = object.coordinates;
+    stream.point(object[0], object[1], object[2]);
+  },
+  MultiPoint: function(object, stream) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
+    while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]);
+  },
+  LineString: function(object, stream) {
+    streamLine(object.coordinates, stream, 0);
+  },
+  MultiLineString: function(object, stream) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
+    while (++i < n) streamLine(coordinates[i], stream, 0);
+  },
+  Polygon: function(object, stream) {
+    streamPolygon(object.coordinates, stream);
+  },
+  MultiPolygon: function(object, stream) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
+    while (++i < n) streamPolygon(coordinates[i], stream);
+  },
+  GeometryCollection: function(object, stream) {
+    var geometries = object.geometries, i = -1, n = geometries.length;
+    while (++i < n) streamGeometry(geometries[i], stream);
+  }
+};
+function streamLine(coordinates, stream, closed) {
+  var i = -1, n = coordinates.length - closed, coordinate;
+  stream.lineStart();
+  while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);
+  stream.lineEnd();
+}
+function streamPolygon(coordinates, stream) {
+  var i = -1, n = coordinates.length;
+  stream.polygonStart();
+  while (++i < n) streamLine(coordinates[i], stream, 1);
+  stream.polygonEnd();
+}
+function stream_default(object, stream) {
+  if (object && streamObjectType.hasOwnProperty(object.type)) {
+    streamObjectType[object.type](object, stream);
+  } else {
+    streamGeometry(object, stream);
+  }
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/cartesian.js
+function spherical(cartesian2) {
+  return [atan2(cartesian2[1], cartesian2[0]), asin(cartesian2[2])];
+}
+function cartesian(spherical2) {
+  var lambda = spherical2[0], phi = spherical2[1], cosPhi = cos(phi);
+  return [cosPhi * cos(lambda), cosPhi * sin(lambda), sin(phi)];
+}
+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 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(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+  d[0] /= l, d[1] /= l, d[2] /= l;
+}
+
+// ../../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;
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/rotation.js
+function rotationIdentity(lambda, phi) {
+  if (abs(lambda) > pi) 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) 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(deltaPhi), sinDeltaPhi = sin(deltaPhi), cosDeltaGamma = cos(deltaGamma), sinDeltaGamma = sin(deltaGamma);
+  function rotation(lambda, phi) {
+    var cosPhi = cos(phi), x = cos(lambda) * cosPhi, y = sin(lambda) * cosPhi, z = sin(phi), k = z * cosDeltaPhi + x * sinDeltaPhi;
+    return [
+      atan2(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi),
+      asin(k * cosDeltaGamma + y * sinDeltaGamma)
+    ];
+  }
+  rotation.invert = function(lambda, phi) {
+    var cosPhi = cos(phi), x = cos(lambda) * cosPhi, y = sin(lambda) * cosPhi, z = sin(phi), k = z * cosDeltaGamma - y * sinDeltaGamma;
+    return [
+      atan2(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi),
+      asin(k * cosDeltaPhi - x * sinDeltaPhi)
+    ];
+  };
+  return rotation;
+}
+
+// ../../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(radius), sinRadius = sin(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([cosRadius, -sinRadius * cos(t), -sinRadius * sin(t)]);
+    stream.point(point[0], point[1]);
+  }
+}
+function circleRadius(cosRadius, point) {
+  point = cartesian(point), point[0] -= cosRadius;
+  cartesianNormalizeInPlace(point);
+  var radius = acos(-point[1]);
+  return ((-point[2] < 0 ? -radius : radius) + tau - epsilon) % tau;
+}
+
+// ../../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;
+    }
+  };
+}
+
+// ../../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]) < epsilon && abs(a[1] - b[1]) < epsilon;
+}
+
+// ../../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, compareIntersection2, startInside, interpolate, stream) {
+  var subject = [], clip = [], i, n;
+  segments.forEach(function(segment) {
+    if ((n2 = segment.length - 1) <= 0) return;
+    var n2, p0 = segment[0], p1 = segment[n2], x;
+    if (pointEqual_default(p0, p1)) {
+      if (!p0[2] && !p1[2]) {
+        stream.lineStart();
+        for (i = 0; i < n2; ++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(compareIntersection2);
+  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;
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/polygonContains.js
+function longitude(point) {
+  return abs(point[0]) <= pi ? point[0] : sign(point[0]) * ((abs(point[0]) + pi) % tau - pi);
+}
+function polygonContains_default(polygon, point) {
+  var lambda = longitude(point), phi = point[1], sinPhi = sin(phi), normal = [sin(lambda), -cos(lambda), 0], angle = 0, winding = 0;
+  var sum = new Adder();
+  if (sinPhi === 1) phi = halfPi + epsilon;
+  else if (sinPhi === -1) phi = -halfPi - 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(phi0), cosPhi0 = cos(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(phi1), cosPhi1 = cos(phi1), delta = lambda1 - lambda0, sign2 = delta >= 0 ? 1 : -1, absDelta = sign2 * delta, antimeridian = absDelta > pi, k = sinPhi0 * sinPhi1;
+      sum.add(atan2(k * sign2 * sin(absDelta), cosPhi0 * cosPhi1 + k * cos(absDelta)));
+      angle += antimeridian ? delta + sign2 * tau : delta;
+      if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {
+        var arc = cartesianCross(cartesian(point0), cartesian(point1));
+        cartesianNormalizeInPlace(arc);
+        var intersection = cartesianCross(normal, arc);
+        cartesianNormalizeInPlace(intersection);
+        var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin(intersection[2]);
+        if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {
+          winding += antimeridian ^ delta >= 0 ? 1 : -1;
+        }
+      }
+    }
+  }
+  return (angle < -epsilon || angle < epsilon && sum < -1e-12) ^ winding & 1;
+}
+
+// ../../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, point2;
+      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((point2 = segment[i])[0], point2[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 - epsilon : halfPi - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfPi - epsilon : halfPi - b[1]);
+}
+
+// ../../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, -halfPi]
+);
+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 : -pi, delta = abs(lambda1 - lambda0);
+      if (abs(delta - pi) < epsilon) {
+        stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi : -halfPi);
+        stream.point(sign0, phi0);
+        stream.lineEnd();
+        stream.lineStart();
+        stream.point(sign1, phi0);
+        stream.point(lambda1, phi0);
+        clean = 0;
+      } else if (sign0 !== sign1 && delta >= pi) {
+        if (abs(lambda0 - sign0) < epsilon) lambda0 -= sign0 * epsilon;
+        if (abs(lambda1 - sign1) < epsilon) 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(lambda0 - lambda1);
+  return abs(sinLambda0Lambda1) > epsilon ? atan((sin(phi0) * (cosPhi1 = cos(phi1)) * sin(lambda1) - sin(phi1) * (cosPhi0 = cos(phi0)) * sin(lambda0)) / (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) : (phi0 + phi1) / 2;
+}
+function clipAntimeridianInterpolate(from, to, direction, stream) {
+  var phi;
+  if (from == null) {
+    phi = direction * halfPi;
+    stream.point(-pi, phi);
+    stream.point(0, phi);
+    stream.point(pi, phi);
+    stream.point(pi, 0);
+    stream.point(pi, -phi);
+    stream.point(0, -phi);
+    stream.point(-pi, -phi);
+    stream.point(-pi, 0);
+    stream.point(-pi, phi);
+  } else if (abs(from[0] - to[0]) > epsilon) {
+    var lambda = from[0] < to[0] ? pi : -pi;
+    phi = direction * lambda / 2;
+    stream.point(-lambda, phi);
+    stream.point(0, phi);
+    stream.point(lambda, phi);
+  } else {
+    stream.point(to[0], to[1]);
+  }
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/clip/circle.js
+function circle_default(radius) {
+  var cr = cos(radius), delta = 2 * radians, 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(lambda) * cos(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 : -pi), 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;
+      },
+      // Rejoin first and last segments if there were intersections and the first
+      // and last points were visible.
+      clean: function() {
+        return clean | (v00 && v0) << 1;
+      }
+    };
+  }
+  function intersect(a, b, two) {
+    var pa = cartesian(a), pb = cartesian(b);
+    var n1 = [1, 0, 0], n2 = cartesianCross(pa, pb), n2n2 = cartesianDot(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(n1, n2), A = cartesianScale(n1, c1), B = cartesianScale(n2, c2);
+    cartesianAddInPlace(A, B);
+    var u = n1xn2, w = cartesianDot(A, u), uu = cartesianDot(u, u), t2 = w * w - uu * (cartesianDot(A, A) - 1);
+    if (t2 < 0) return;
+    var t = sqrt(t2), q = cartesianScale(u, (-w - t) / uu);
+    cartesianAddInPlace(q, A);
+    q = spherical(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 delta2 = lambda1 - lambda0, polar = abs(delta2 - pi) < epsilon, meridian = polar || delta2 < epsilon;
+    if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z;
+    if (meridian ? polar ? phi0 + phi1 > 0 ^ q[1] < (abs(q[0] - lambda0) < epsilon ? phi0 : phi1) : phi0 <= q[1] && q[1] <= phi1 : delta2 > pi ^ (lambda0 <= q[0] && q[0] <= lambda1)) {
+      var q1 = cartesianScale(u, (-w + t) / uu);
+      cartesianAddInPlace(q1, A);
+      return [q, spherical(q1)];
+    }
+  }
+  function code(lambda, phi) {
+    var r = smallRadius ? radius : pi - radius, code2 = 0;
+    if (lambda < -r) code2 |= 1;
+    else if (lambda > r) code2 |= 2;
+    if (phi < -r) code2 |= 4;
+    else if (phi > r) code2 |= 8;
+    return code2;
+  }
+  return clip_default(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-pi, radius - pi]);
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/clip/line.js
+function line_default(a, b, x05, y05, x12, y12) {
+  var ax = a[0], ay = a[1], bx = b[0], by = b[1], t0 = 0, t1 = 1, dx = bx - ax, dy = by - ay, r;
+  r = x05 - 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 = x12 - 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 = y05 - 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 = y12 - 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;
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/clip/rectangle.js
+var clipMax = 1e9;
+var clipMin = -clipMax;
+function clipRectangle(x05, y05, x12, y12) {
+  function visible(x, y) {
+    return x05 <= x && x <= x12 && y05 <= y && y <= y12;
+  }
+  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 ? x05 : x12, a > 1 ? y12 : y05);
+      while ((a = (a + direction + 4) % 4) !== a1);
+    } else {
+      stream.point(to[0], to[1]);
+    }
+  }
+  function corner(p, direction) {
+    return abs(p[0] - x05) < epsilon ? direction > 0 ? 0 : 3 : abs(p[0] - x12) < epsilon ? direction > 0 ? 2 : 1 : abs(p[1] - y05) < epsilon ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2;
+  }
+  function compareIntersection2(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 ring2 = polygon[i], j = 1, m = ring2.length, point2 = ring2[0], a0, a1, b0 = point2[0], b1 = point2[1]; j < m; ++j) {
+          a0 = b0, a1 = b1, point2 = ring2[j], b0 = point2[0], b1 = point2[1];
+          if (a1 <= y12) {
+            if (b1 > y12 && (b0 - a0) * (y12 - a1) > (b1 - a1) * (x05 - a0)) ++winding;
+          } else {
+            if (b1 <= y12 && (b0 - a0) * (y12 - a1) < (b1 - a1) * (x05 - a0)) --winding;
+          }
+        }
+      }
+      return winding;
+    }
+    function polygonStart() {
+      activeStream = bufferStream, segments = [], polygon = [], clean = true;
+    }
+    function polygonEnd() {
+      var startInside = polygonInside(), cleanInside = clean && startInside, visible2 = (segments = merge(segments)).length;
+      if (cleanInside || visible2) {
+        stream.polygonStart();
+        if (cleanInside) {
+          stream.lineStart();
+          interpolate(null, null, 1, stream);
+          stream.lineEnd();
+        }
+        if (visible2) {
+          rejoin_default(segments, compareIntersection2, 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, x05, y05, x12, y12)) {
+            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;
+  };
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/identity.js
+var identity_default = (x) => x;
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/path/area.js
+var areaSum = new Adder();
+var areaRingSum = new Adder();
+var x00;
+var y00;
+var x0;
+var y0;
+var areaStream = {
+  point: noop,
+  lineStart: noop,
+  lineEnd: noop,
+  polygonStart: function() {
+    areaStream.lineStart = areaRingStart;
+    areaStream.lineEnd = areaRingEnd;
+  },
+  polygonEnd: function() {
+    areaStream.lineStart = areaStream.lineEnd = areaStream.point = noop;
+    areaSum.add(abs(areaRingSum));
+    areaRingSum = new Adder();
+  },
+  result: function() {
+    var area = areaSum / 2;
+    areaSum = new Adder();
+    return area;
+  }
+};
+function areaRingStart() {
+  areaStream.point = areaPointFirst;
+}
+function areaPointFirst(x, y) {
+  areaStream.point = areaPoint;
+  x00 = x0 = x, y00 = y0 = y;
+}
+function areaPoint(x, y) {
+  areaRingSum.add(y0 * x - x0 * y);
+  x0 = x, y0 = y;
+}
+function areaRingEnd() {
+  areaPoint(x00, y00);
+}
+var area_default = areaStream;
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/path/bounds.js
+var x02 = Infinity;
+var y02 = x02;
+var x1 = -x02;
+var y1 = x1;
+var boundsStream = {
+  point: boundsPoint,
+  lineStart: noop,
+  lineEnd: noop,
+  polygonStart: noop,
+  polygonEnd: noop,
+  result: function() {
+    var bounds = [[x02, y02], [x1, y1]];
+    x1 = y1 = -(y02 = x02 = Infinity);
+    return bounds;
+  }
+};
+function boundsPoint(x, y) {
+  if (x < x02) x02 = x;
+  if (x > x1) x1 = x;
+  if (y < y02) y02 = y;
+  if (y > y1) y1 = y;
+}
+var bounds_default = boundsStream;
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/path/centroid.js
+var X0 = 0;
+var Y0 = 0;
+var Z0 = 0;
+var X1 = 0;
+var Y1 = 0;
+var Z1 = 0;
+var X2 = 0;
+var Y2 = 0;
+var Z2 = 0;
+var x002;
+var y002;
+var x03;
+var y03;
+var centroidStream = {
+  point: centroidPoint,
+  lineStart: centroidLineStart,
+  lineEnd: centroidLineEnd,
+  polygonStart: function() {
+    centroidStream.lineStart = centroidRingStart;
+    centroidStream.lineEnd = centroidRingEnd;
+  },
+  polygonEnd: function() {
+    centroidStream.point = centroidPoint;
+    centroidStream.lineStart = centroidLineStart;
+    centroidStream.lineEnd = centroidLineEnd;
+  },
+  result: function() {
+    var centroid = Z2 ? [X2 / Z2, Y2 / Z2] : Z1 ? [X1 / Z1, Y1 / Z1] : Z0 ? [X0 / Z0, Y0 / Z0] : [NaN, NaN];
+    X0 = Y0 = Z0 = X1 = Y1 = Z1 = X2 = Y2 = Z2 = 0;
+    return centroid;
+  }
+};
+function centroidPoint(x, y) {
+  X0 += x;
+  Y0 += y;
+  ++Z0;
+}
+function centroidLineStart() {
+  centroidStream.point = centroidPointFirstLine;
+}
+function centroidPointFirstLine(x, y) {
+  centroidStream.point = centroidPointLine;
+  centroidPoint(x03 = x, y03 = y);
+}
+function centroidPointLine(x, y) {
+  var dx = x - x03, dy = y - y03, z = sqrt(dx * dx + dy * dy);
+  X1 += z * (x03 + x) / 2;
+  Y1 += z * (y03 + y) / 2;
+  Z1 += z;
+  centroidPoint(x03 = x, y03 = y);
+}
+function centroidLineEnd() {
+  centroidStream.point = centroidPoint;
+}
+function centroidRingStart() {
+  centroidStream.point = centroidPointFirstRing;
+}
+function centroidRingEnd() {
+  centroidPointRing(x002, y002);
+}
+function centroidPointFirstRing(x, y) {
+  centroidStream.point = centroidPointRing;
+  centroidPoint(x002 = x03 = x, y002 = y03 = y);
+}
+function centroidPointRing(x, y) {
+  var dx = x - x03, dy = y - y03, z = sqrt(dx * dx + dy * dy);
+  X1 += z * (x03 + x) / 2;
+  Y1 += z * (y03 + y) / 2;
+  Z1 += z;
+  z = y03 * x - x03 * y;
+  X2 += z * (x03 + x);
+  Y2 += z * (y03 + y);
+  Z2 += z * 3;
+  centroidPoint(x03 = x, y03 = y);
+}
+var centroid_default = centroidStream;
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/path/context.js
+function PathContext(context) {
+  this._context = context;
+}
+PathContext.prototype = {
+  _radius: 4.5,
+  pointRadius: function(_) {
+    return this._radius = _, this;
+  },
+  polygonStart: function() {
+    this._line = 0;
+  },
+  polygonEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._point = 0;
+  },
+  lineEnd: function() {
+    if (this._line === 0) this._context.closePath();
+    this._point = NaN;
+  },
+  point: function(x, y) {
+    switch (this._point) {
+      case 0: {
+        this._context.moveTo(x, y);
+        this._point = 1;
+        break;
+      }
+      case 1: {
+        this._context.lineTo(x, y);
+        break;
+      }
+      default: {
+        this._context.moveTo(x + this._radius, y);
+        this._context.arc(x, y, this._radius, 0, tau);
+        break;
+      }
+    }
+  },
+  result: noop
+};
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/path/measure.js
+var lengthSum = new Adder();
+var lengthRing;
+var x003;
+var y003;
+var x04;
+var y04;
+var lengthStream = {
+  point: noop,
+  lineStart: function() {
+    lengthStream.point = lengthPointFirst;
+  },
+  lineEnd: function() {
+    if (lengthRing) lengthPoint(x003, y003);
+    lengthStream.point = noop;
+  },
+  polygonStart: function() {
+    lengthRing = true;
+  },
+  polygonEnd: function() {
+    lengthRing = null;
+  },
+  result: function() {
+    var length = +lengthSum;
+    lengthSum = new Adder();
+    return length;
+  }
+};
+function lengthPointFirst(x, y) {
+  lengthStream.point = lengthPoint;
+  x003 = x04 = x, y003 = y04 = y;
+}
+function lengthPoint(x, y) {
+  x04 -= x, y04 -= y;
+  lengthSum.add(sqrt(x04 * x04 + y04 * y04));
+  x04 = x, y04 = y;
+}
+var measure_default = lengthStream;
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/path/string.js
+var cacheDigits;
+var cacheAppend;
+var cacheRadius;
+var cacheCircle;
+var PathString = class {
+  constructor(digits) {
+    this._append = digits == null ? append : appendRound(digits);
+    this._radius = 4.5;
+    this._ = "";
+  }
+  pointRadius(_) {
+    this._radius = +_;
+    return this;
+  }
+  polygonStart() {
+    this._line = 0;
+  }
+  polygonEnd() {
+    this._line = NaN;
+  }
+  lineStart() {
+    this._point = 0;
+  }
+  lineEnd() {
+    if (this._line === 0) this._ += "Z";
+    this._point = NaN;
+  }
+  point(x, y) {
+    switch (this._point) {
+      case 0: {
+        this._append`M${x},${y}`;
+        this._point = 1;
+        break;
+      }
+      case 1: {
+        this._append`L${x},${y}`;
+        break;
+      }
+      default: {
+        this._append`M${x},${y}`;
+        if (this._radius !== cacheRadius || this._append !== cacheAppend) {
+          const r = this._radius;
+          const s = this._;
+          this._ = "";
+          this._append`m0,${r}a${r},${r} 0 1,1 0,${ -2 * r}a${r},${r} 0 1,1 0,${2 * r}z`;
+          cacheRadius = r;
+          cacheAppend = this._append;
+          cacheCircle = this._;
+          this._ = s;
+        }
+        this._ += cacheCircle;
+        break;
+      }
+    }
+  }
+  result() {
+    const result = this._;
+    this._ = "";
+    return result.length ? result : null;
+  }
+};
+function append(strings) {
+  let i = 1;
+  this._ += strings[0];
+  for (const j = strings.length; i < j; ++i) {
+    this._ += arguments[i] + strings[i];
+  }
+}
+function appendRound(digits) {
+  const d = Math.floor(digits);
+  if (!(d >= 0)) throw new RangeError(`invalid digits: ${digits}`);
+  if (d > 15) return append;
+  if (d !== cacheDigits) {
+    const k = 10 ** d;
+    cacheDigits = d;
+    cacheAppend = function append2(strings) {
+      let i = 1;
+      this._ += strings[0];
+      for (const j = strings.length; i < j; ++i) {
+        this._ += Math.round(arguments[i] * k) / k + strings[i];
+      }
+    };
+  }
+  return cacheAppend;
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/path/index.js
+function path_default(projection2, context) {
+  let digits = 3, pointRadius = 4.5, projectionStream, contextStream;
+  function path(object) {
+    if (object) {
+      if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
+      stream_default(object, projectionStream(contextStream));
+    }
+    return contextStream.result();
+  }
+  path.area = function(object) {
+    stream_default(object, projectionStream(area_default));
+    return area_default.result();
+  };
+  path.measure = function(object) {
+    stream_default(object, projectionStream(measure_default));
+    return measure_default.result();
+  };
+  path.bounds = function(object) {
+    stream_default(object, projectionStream(bounds_default));
+    return bounds_default.result();
+  };
+  path.centroid = function(object) {
+    stream_default(object, projectionStream(centroid_default));
+    return centroid_default.result();
+  };
+  path.projection = function(_) {
+    if (!arguments.length) return projection2;
+    projectionStream = _ == null ? (projection2 = null, identity_default) : (projection2 = _).stream;
+    return path;
+  };
+  path.context = function(_) {
+    if (!arguments.length) return context;
+    contextStream = _ == null ? (context = null, new PathString(digits)) : new PathContext(context = _);
+    if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
+    return path;
+  };
+  path.pointRadius = function(_) {
+    if (!arguments.length) return pointRadius;
+    pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
+    return path;
+  };
+  path.digits = function(_) {
+    if (!arguments.length) return digits;
+    if (_ == null) digits = null;
+    else {
+      const d = Math.floor(_);
+      if (!(d >= 0)) throw new RangeError(`invalid digits: ${_}`);
+      digits = d;
+    }
+    if (context === null) contextStream = new PathString(digits);
+    return path;
+  };
+  return path.projection(projection2).digits(digits).context(context);
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/transform.js
+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();
+  }
+};
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/projection/fit.js
+function fit(projection2, fitBounds, object) {
+  var clip = projection2.clipExtent && projection2.clipExtent();
+  projection2.scale(150).translate([0, 0]);
+  if (clip != null) projection2.clipExtent(null);
+  stream_default(object, projection2.stream(bounds_default));
+  fitBounds(bounds_default.result());
+  if (clip != null) projection2.clipExtent(clip);
+  return projection2;
+}
+function fitExtent(projection2, extent, object) {
+  return fit(projection2, 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;
+    projection2.scale(150 * k).translate([x, y]);
+  }, object);
+}
+function fitSize(projection2, size, object) {
+  return fitExtent(projection2, [[0, 0], size], object);
+}
+function fitWidth(projection2, width, object) {
+  return fit(projection2, 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];
+    projection2.scale(150 * k).translate([x, y]);
+  }, object);
+}
+function fitHeight(projection2, height, object) {
+  return fit(projection2, 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;
+    projection2.scale(150 * k).translate([x, y]);
+  }, object);
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/projection/resample.js
+var maxDepth = 16;
+var cosMinDistance = cos(30 * radians);
+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(x05, y05, lambda0, a0, b0, c0, x12, y12, lambda1, a1, b1, c1, depth, stream) {
+    var dx = x12 - x05, dy = y12 - y05, d2 = dx * dx + dy * dy;
+    if (d2 > 4 * delta2 && depth--) {
+      var a = a0 + a1, b = b0 + b1, c = c0 + c1, m = sqrt(a * a + b * b + c * c), phi2 = asin(c /= m), lambda2 = abs(abs(c) - 1) < epsilon || abs(lambda0 - lambda1) < epsilon ? (lambda0 + lambda1) / 2 : atan2(b, a), p = project(lambda2, phi2), x2 = p[0], y2 = p[1], dx2 = x2 - x05, dy2 = y2 - y05, dz = dy * dx2 - dx * dy2;
+      if (dz * dz / d2 > delta2 || abs((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) {
+        resampleLineTo(x05, y05, 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, x12, y12, lambda1, a1, b1, c1, depth, stream);
+      }
+    }
+  }
+  return function(stream) {
+    var lambda00, x004, y004, a00, b00, c00, lambda0, x05, y05, 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() {
+      x05 = NaN;
+      resampleStream.point = linePoint;
+      stream.lineStart();
+    }
+    function linePoint(lambda, phi) {
+      var c = cartesian([lambda, phi]), p = project(lambda, phi);
+      resampleLineTo(x05, y05, lambda0, a0, b0, c0, x05 = p[0], y05 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
+      stream.point(x05, y05);
+    }
+    function lineEnd() {
+      resampleStream.point = point;
+      stream.lineEnd();
+    }
+    function ringStart() {
+      lineStart();
+      resampleStream.point = ringPoint;
+      resampleStream.lineEnd = ringEnd;
+    }
+    function ringPoint(lambda, phi) {
+      linePoint(lambda00 = lambda, phi), x004 = x05, y004 = y05, a00 = a0, b00 = b0, c00 = c0;
+      resampleStream.point = linePoint;
+    }
+    function ringEnd() {
+      resampleLineTo(x05, y05, lambda0, a0, b0, c0, x004, y004, lambda00, a00, b00, c00, maxDepth, stream);
+      resampleStream.lineEnd = lineEnd;
+      lineEnd();
+    }
+    return resampleStream;
+  };
+}
+
+// ../../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, y * radians);
+  }
+});
+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(alpha), sinAlpha = sin(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, x05 = null, y05, x12, y12, postclip = identity_default, delta2 = 0.5, projectResample, projectTransform, projectRotateTransform, cache, cacheStream;
+  function projection2(point) {
+    return projectRotateTransform(point[0] * radians, point[1] * radians);
+  }
+  function invert(point) {
+    point = projectRotateTransform.invert(point[0], point[1]);
+    return point && [point[0] * degrees, point[1] * degrees];
+  }
+  projection2.stream = function(stream) {
+    return cache && cacheStream === stream ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream)))));
+  };
+  projection2.preclip = function(_) {
+    return arguments.length ? (preclip = _, theta = void 0, reset()) : preclip;
+  };
+  projection2.postclip = function(_) {
+    return arguments.length ? (postclip = _, x05 = y05 = x12 = y12 = null, reset()) : postclip;
+  };
+  projection2.clipAngle = function(_) {
+    return arguments.length ? (preclip = +_ ? circle_default(theta = _ * radians) : (theta = null, antimeridian_default), reset()) : theta * degrees;
+  };
+  projection2.clipExtent = function(_) {
+    return arguments.length ? (postclip = _ == null ? (x05 = y05 = x12 = y12 = null, identity_default) : clipRectangle(x05 = +_[0][0], y05 = +_[0][1], x12 = +_[1][0], y12 = +_[1][1]), reset()) : x05 == null ? null : [[x05, y05], [x12, y12]];
+  };
+  projection2.scale = function(_) {
+    return arguments.length ? (k = +_, recenter()) : k;
+  };
+  projection2.translate = function(_) {
+    return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y];
+  };
+  projection2.center = function(_) {
+    return arguments.length ? (lambda = _[0] % 360 * radians, phi = _[1] % 360 * radians, recenter()) : [lambda * degrees, phi * degrees];
+  };
+  projection2.rotate = function(_) {
+    return arguments.length ? (deltaLambda = _[0] % 360 * radians, deltaPhi = _[1] % 360 * radians, deltaGamma = _.length > 2 ? _[2] % 360 * radians : 0, recenter()) : [deltaLambda * degrees, deltaPhi * degrees, deltaGamma * degrees];
+  };
+  projection2.angle = function(_) {
+    return arguments.length ? (alpha = _ % 360 * radians, recenter()) : alpha * degrees;
+  };
+  projection2.reflectX = function(_) {
+    return arguments.length ? (sx = _ ? -1 : 1, recenter()) : sx < 0;
+  };
+  projection2.reflectY = function(_) {
+    return arguments.length ? (sy = _ ? -1 : 1, recenter()) : sy < 0;
+  };
+  projection2.precision = function(_) {
+    return arguments.length ? (projectResample = resample_default(projectTransform, delta2 = _ * _), reset()) : sqrt(delta2);
+  };
+  projection2.fitExtent = function(extent, object) {
+    return fitExtent(projection2, extent, object);
+  };
+  projection2.fitSize = function(size, object) {
+    return fitSize(projection2, size, object);
+  };
+  projection2.fitWidth = function(width, object) {
+    return fitWidth(projection2, width, object);
+  };
+  projection2.fitHeight = function(height, object) {
+    return fitHeight(projection2, 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 projection2;
+  }
+  return function() {
+    project = projectAt.apply(this, arguments);
+    projection2.invert = project.invert && invert;
+    return recenter();
+  };
+}
+
+// ../../node_modules/.pnpm/d3-geo@3.1.1/node_modules/d3-geo/src/projection/naturalEarth1.js
+function naturalEarth1Raw(lambda, phi) {
+  var phi2 = phi * phi, phi4 = phi2 * phi2;
+  return [
+    lambda * (0.8707 - 0.131979 * phi2 + phi4 * (-0.013791 + phi4 * (3971e-6 * phi2 - 1529e-6 * phi4))),
+    phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 5916e-6 * phi4)))
+  ];
+}
+naturalEarth1Raw.invert = function(x, y) {
+  var phi = y, i = 25, delta;
+  do {
+    var phi2 = phi * phi, phi4 = phi2 * phi2;
+    phi -= delta = (phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 5916e-6 * phi4))) - y) / (1.007226 + phi2 * (0.015085 * 3 + phi4 * (-0.044475 * 7 + 0.028874 * 9 * phi2 - 5916e-6 * 11 * phi4)));
+  } while (abs(delta) > epsilon && --i > 0);
+  return [
+    x / (0.8707 + (phi2 = phi * phi) * (-0.131979 + phi2 * (-0.013791 + phi2 * phi2 * phi2 * (3971e-6 - 1529e-6 * phi2)))),
+    phi
+  ];
+};
+function naturalEarth1_default() {
+  return projection(naturalEarth1Raw).scale(175.295);
+}
+
+// src/world-map-codes.ts
+var NUMERIC_TO_ALPHA2 = {
+  "004": "AF",
+  "008": "AL",
+  "010": "AQ",
+  "012": "DZ",
+  "016": "AS",
+  "020": "AD",
+  "024": "AO",
+  "028": "AG",
+  "031": "AZ",
+  "032": "AR",
+  "036": "AU",
+  "040": "AT",
+  "044": "BS",
+  "048": "BH",
+  "050": "BD",
+  "051": "AM",
+  "052": "BB",
+  "056": "BE",
+  "060": "BM",
+  "064": "BT",
+  "068": "BO",
+  "070": "BA",
+  "072": "BW",
+  "074": "BV",
+  "076": "BR",
+  "084": "BZ",
+  "086": "IO",
+  "090": "SB",
+  "092": "VG",
+  "096": "BN",
+  "100": "BG",
+  "104": "MM",
+  "108": "BI",
+  "112": "BY",
+  "116": "KH",
+  "120": "CM",
+  "124": "CA",
+  "132": "CV",
+  "136": "KY",
+  "140": "CF",
+  "144": "LK",
+  "148": "TD",
+  "152": "CL",
+  "156": "CN",
+  "158": "TW",
+  "162": "CX",
+  "166": "CC",
+  "170": "CO",
+  "174": "KM",
+  "175": "YT",
+  "178": "CG",
+  "180": "CD",
+  "184": "CK",
+  "188": "CR",
+  "191": "HR",
+  "192": "CU",
+  "196": "CY",
+  "203": "CZ",
+  "204": "BJ",
+  "208": "DK",
+  "212": "DM",
+  "214": "DO",
+  "218": "EC",
+  "222": "SV",
+  "226": "GQ",
+  "231": "ET",
+  "232": "ER",
+  "233": "EE",
+  "234": "FO",
+  "238": "FK",
+  "239": "GS",
+  "242": "FJ",
+  "246": "FI",
+  "248": "AX",
+  "250": "FR",
+  "254": "GF",
+  "258": "PF",
+  "260": "TF",
+  "262": "DJ",
+  "266": "GA",
+  "268": "GE",
+  "270": "GM",
+  "275": "PS",
+  "276": "DE",
+  "288": "GH",
+  "292": "GI",
+  "296": "KI",
+  "300": "GR",
+  "304": "GL",
+  "308": "GD",
+  "312": "GP",
+  "316": "GU",
+  "320": "GT",
+  "324": "GN",
+  "328": "GY",
+  "332": "HT",
+  "334": "HM",
+  "336": "VA",
+  "340": "HN",
+  "344": "HK",
+  "348": "HU",
+  "352": "IS",
+  "356": "IN",
+  "360": "ID",
+  "364": "IR",
+  "368": "IQ",
+  "372": "IE",
+  "376": "IL",
+  "380": "IT",
+  "384": "CI",
+  "388": "JM",
+  "392": "JP",
+  "398": "KZ",
+  "400": "JO",
+  "404": "KE",
+  "408": "KP",
+  "410": "KR",
+  "414": "KW",
+  "417": "KG",
+  "418": "LA",
+  "422": "LB",
+  "426": "LS",
+  "428": "LV",
+  "430": "LR",
+  "434": "LY",
+  "438": "LI",
+  "440": "LT",
+  "442": "LU",
+  "446": "MO",
+  "450": "MG",
+  "454": "MW",
+  "458": "MY",
+  "462": "MV",
+  "466": "ML",
+  "470": "MT",
+  "474": "MQ",
+  "478": "MR",
+  "480": "MU",
+  "484": "MX",
+  "492": "MC",
+  "496": "MN",
+  "498": "MD",
+  "499": "ME",
+  "500": "MS",
+  "504": "MA",
+  "508": "MZ",
+  "512": "OM",
+  "516": "NA",
+  "520": "NR",
+  "524": "NP",
+  "528": "NL",
+  "531": "CW",
+  "533": "AW",
+  "534": "SX",
+  "535": "BQ",
+  "540": "NC",
+  "548": "VU",
+  "554": "NZ",
+  "558": "NI",
+  "562": "NE",
+  "566": "NG",
+  "570": "NU",
+  "574": "NF",
+  "578": "NO",
+  "580": "MP",
+  "581": "UM",
+  "583": "FM",
+  "584": "MH",
+  "585": "PW",
+  "586": "PK",
+  "591": "PA",
+  "598": "PG",
+  "600": "PY",
+  "604": "PE",
+  "608": "PH",
+  "612": "PN",
+  "616": "PL",
+  "620": "PT",
+  "624": "GW",
+  "626": "TL",
+  "630": "PR",
+  "634": "QA",
+  "638": "RE",
+  "642": "RO",
+  "643": "RU",
+  "646": "RW",
+  "652": "BL",
+  "654": "SH",
+  "659": "KN",
+  "660": "AI",
+  "662": "LC",
+  "663": "MF",
+  "666": "PM",
+  "670": "VC",
+  "674": "SM",
+  "678": "ST",
+  "682": "SA",
+  "686": "SN",
+  "688": "RS",
+  "690": "SC",
+  "694": "SL",
+  "702": "SG",
+  "703": "SK",
+  "704": "VN",
+  "705": "SI",
+  "706": "SO",
+  "710": "ZA",
+  "716": "ZW",
+  "724": "ES",
+  "728": "SS",
+  "729": "SD",
+  "732": "EH",
+  "740": "SR",
+  "744": "SJ",
+  "748": "SZ",
+  "752": "SE",
+  "756": "CH",
+  "760": "SY",
+  "762": "TJ",
+  "764": "TH",
+  "768": "TG",
+  "772": "TK",
+  "776": "TO",
+  "780": "TT",
+  "784": "AE",
+  "788": "TN",
+  "792": "TR",
+  "795": "TM",
+  "796": "TC",
+  "798": "TV",
+  "800": "UG",
+  "804": "UA",
+  "807": "MK",
+  "818": "EG",
+  "826": "GB",
+  "831": "GG",
+  "832": "JE",
+  "833": "IM",
+  "834": "TZ",
+  "840": "US",
+  "850": "VI",
+  "854": "BF",
+  "858": "UY",
+  "860": "UZ",
+  "862": "VE",
+  "876": "WF",
+  "882": "WS",
+  "887": "YE",
+  "894": "ZM"
+};
+
+// src/world-map.ts
+var STEPS = 5;
+var clamp = (value, min, max) => Math.min(Math.max(value, min ?? -Infinity), max ?? Infinity);
+var scaleOf = (values, min, max) => {
+  const [low, high] = min !== void 0 && max !== void 0 && min > max ? [max, min] : [min, max];
+  const sorted = values.filter(Number.isFinite).map((value) => clamp(value, low, high)).sort((a, b) => a - b);
+  if (sorted.length === 0) return void 0;
+  const thresholds = [1, 2, 3, 4].map((q) => sorted[Math.floor(sorted.length * q / STEPS)]);
+  return { thresholds, bounds: [low ?? sorted[0], ...thresholds], min: low, max: high };
+};
+var stepOf = (value, scale) => {
+  const clamped = clamp(value, scale.min, scale.max);
+  return scale.thresholds.filter((threshold) => clamped >= threshold).length;
+};
+var ranked = (countries) => countries.filter((country) => country.value !== void 0).sort((a, b) => b.value - a.value || a.name.localeCompare(b.name));
+var walk = (order, current, delta) => {
+  const index = order.findIndex((country) => country.code === current);
+  if (index < 0) return order[0];
+  return order[Math.min(Math.max(index + delta, 0), order.length - 1)];
+};
+var VIEW_WIDTH = 960;
+var MARGIN = 2;
+var ANTARCTICA = "010";
+var TIP_GAP = 6;
+var POINTER_GAP = 14;
+var HIDDEN = {
+  position: "absolute",
+  width: 1,
+  height: 1,
+  margin: -1,
+  padding: 0,
+  overflow: "hidden",
+  clipPath: "inset(50%)",
+  whiteSpace: "nowrap",
+  border: 0
+};
+var shapesOf = (geography) => {
+  const countries = geography.objects.countries;
+  if (!countries) {
+    throw new Error("WorldMap: `geography` has no `countries` object");
+  }
+  const collection = topojsonClient.feature(geography, countries);
+  const features = (collection.type === "FeatureCollection" ? collection.features : [collection]).filter((item) => String(item.id).padStart(3, "0") !== ANTARCTICA);
+  const world = { type: "FeatureCollection", features };
+  const projection2 = naturalEarth1_default().fitWidth(VIEW_WIDTH - 2 * MARGIN, world);
+  const [x, y] = projection2.translate();
+  projection2.translate([x + MARGIN, y + MARGIN]);
+  const path = path_default(projection2);
+  const [, [, bottom]] = path.bounds(world);
+  const shapes = features.flatMap((item) => {
+    const d = path(item);
+    if (!d) return [];
+    const name = item.properties?.name;
+    return [
+      {
+        code: item.id === void 0 ? void 0 : NUMERIC_TO_ALPHA2[String(item.id).padStart(3, "0")],
+        name: typeof name === "string" ? name : "",
+        d
+      }
+    ];
+  });
+  return { shapes, viewHeight: Math.ceil(bottom) + MARGIN };
+};
+var WorldMap = ({
+  data,
+  geography,
+  formatValue = String,
+  label,
+  min,
+  max,
+  showLegend = true,
+  onSelect,
+  ariaLabel,
+  height,
+  width
+}) => {
+  const frame = react.useRef(null);
+  const { shapes, viewHeight } = react.useMemo(() => shapesOf(geography), [geography]);
+  const [hover, setHover] = react.useState();
+  const [focus, setFocus] = react.useState();
+  const [lastKey, setLastKey] = react.useState();
+  const valued = shapes.map((shape) => {
+    const value = shape.code === void 0 ? void 0 : data[shape.code];
+    return { ...shape, value: Number.isFinite(value) ? value : void 0 };
+  });
+  const order = ranked(
+    valued.filter((country) => country.code !== void 0)
+  );
+  const scale = scaleOf(
+    order.map((country) => country.value),
+    min,
+    max
+  );
+  const countries = valued.map((country) => ({
+    ...country,
+    step: scale && country.value !== void 0 ? stepOf(country.value, scale) : void 0
+  }));
+  const byCode = new Map(
+    countries.flatMap((country) => country.code ? [[country.code, country]] : [])
+  );
+  const interactive = order.length > 0;
+  const stepColor = (step) => step === void 0 ? chunkLT3UC65O_cjs.TRACK : chunkLT3UC65O_cjs.SEQUENTIAL[step];
+  const name = ariaLabel ?? (interactive ? `World map, ${label ?? "value"} by country, from ${formatValue(order[order.length - 1].value)} to ${formatValue(order[0].value)}` : "World map");
+  const tip = hover ?? focus;
+  const tipCountry = tip && byCode.get(tip.code);
+  const anchor = (code, x, top, bottom, gap) => {
+    const host = frame.current.getBoundingClientRect();
+    const middle = x - host.left;
+    const align = middle < host.width / 3 ? "start" : middle > 2 * host.width / 3 ? "end" : "center";
+    return {
+      code,
+      x: middle,
+      top: top - host.top - gap,
+      bottom: bottom - host.top + gap,
+      align,
+      // Not enough room above for the card: it goes under.
+      below: top - host.top < 90
+    };
+  };
+  const tipAtPointer = (code, event) => anchor(code, event.clientX, event.clientY, event.clientY, POINTER_GAP - TIP_GAP);
+  const tipAtCountry = (code) => {
+    const element = frame.current?.querySelector(`[data-code="${code}"]`);
+    if (!element) return void 0;
+    const box = element.getBoundingClientRect();
+    const middle = box.top + box.height / 2;
+    return anchor(code, box.left + box.width / 2, middle, middle, 0);
+  };
+  const goTo = (country) => {
+    if (!country) return;
+    setLastKey(country.code);
+    setFocus(tipAtCountry(country.code));
+  };
+  const keyDown = (event) => {
+    const current = focus?.code ?? lastKey;
+    const targets = {
+      ArrowRight: () => walk(order, current, 1),
+      ArrowDown: () => walk(order, current, 1),
+      ArrowLeft: () => walk(order, current, -1),
+      ArrowUp: () => walk(order, current, -1),
+      Home: () => order[0],
+      End: () => order[order.length - 1]
+    };
+    if (targets[event.key]) {
+      event.preventDefault();
+      goTo(targets[event.key]());
+    } else if (onSelect && (event.key === "Enter" || event.key === " ") && focus) {
+      event.preventDefault();
+      onSelect(focus.code);
+    }
+  };
+  const focusIn = (event) => {
+    if (event.target === event.currentTarget && event.currentTarget.matches(":focus-visible")) {
+      goTo(order.find((country) => country.code === lastKey) ?? order[0]);
+    }
+  };
+  const focusOut = (event) => {
+    if (!event.currentTarget.contains(event.relatedTarget)) setFocus(void 0);
+  };
+  const tipStyle = tip && {
+    position: "absolute",
+    left: tip.x,
+    top: tip.below ? tip.bottom : tip.top,
+    transform: `translate(${{ start: "0", center: "-50%", end: "-100%" }[tip.align]}, ${tip.below ? "0" : "-100%"})`,
+    zIndex: 10,
+    pointerEvents: "none"
+  };
+  const active = tipCountry?.value === void 0 ? void 0 : tipCountry;
+  const legend = showLegend && scale && /* @__PURE__ */ jsxRuntime.jsx(Legend, { scale, format: formatValue });
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-world-map": "",
+      style: {
+        position: "relative",
+        display: "flex",
+        flexDirection: "column",
+        gap: "0.75rem",
+        width: width ?? "100%",
+        height,
+        maxWidth: "100%",
+        minWidth: 0
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            ref: frame,
+            role: interactive ? "application" : void 0,
+            "aria-label": interactive ? name : void 0,
+            tabIndex: interactive ? 0 : void 0,
+            onKeyDown: interactive ? keyDown : void 0,
+            onFocus: interactive ? focusIn : void 0,
+            onBlur: interactive ? focusOut : void 0,
+            style: {
+              position: "relative",
+              flex: height === void 0 ? void 0 : "1 1 0",
+              minHeight: 0,
+              // The country outline and the tooltip show where the keyboard is.
+              outline: "none"
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(
+                "svg",
+                {
+                  role: "img",
+                  "aria-label": name,
+                  viewBox: `0 0 ${VIEW_WIDTH} ${viewHeight}`,
+                  style: {
+                    display: "block",
+                    width: "100%",
+                    height: height === void 0 ? "auto" : "100%"
+                  },
+                  children: [
+                    countries.map((country, i) => {
+                      const code = country.code;
+                      const has = code !== void 0 && country.value !== void 0;
+                      return /* @__PURE__ */ jsxRuntime.jsx(
+                        "path",
+                        {
+                          d: country.d,
+                          "data-code": has ? code : void 0,
+                          "data-step": country.step,
+                          fill: stepColor(country.step),
+                          stroke: chunkLT3UC65O_cjs.PANEL,
+                          strokeWidth: 0.5,
+                          strokeLinejoin: "round",
+                          style: has && onSelect ? { cursor: "pointer" } : void 0,
+                          onMouseEnter: has ? (event) => setHover(tipAtPointer(code, event)) : void 0,
+                          onMouseMove: has ? (event) => setHover(tipAtPointer(code, event)) : void 0,
+                          onMouseLeave: has ? () => setHover(void 0) : void 0,
+                          onClick: has && onSelect ? () => onSelect(code) : void 0
+                        },
+                        i
+                      );
+                    }),
+                    active && // The same outline for the pointer and the keyboard, in the text color:
+                    // an accent one would vanish on the darkest steps. Drawn last to sit
+                    // above the neighbors' borders.
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      "path",
+                      {
+                        d: active.d,
+                        "data-world-active": "",
+                        fill: "none",
+                        stroke: chunkLT3UC65O_cjs.TEXT,
+                        strokeWidth: 1.6,
+                        strokeLinejoin: "round",
+                        pointerEvents: "none"
+                      }
+                    )
+                  ]
+                }
+              ),
+              tip && tipCountry && tipCountry.value !== void 0 && tipStyle && /* @__PURE__ */ jsxRuntime.jsx("div", { "data-world-tooltip": "", "aria-hidden": true, style: tipStyle, children: /* @__PURE__ */ jsxRuntime.jsx(
+                chunkT3K6Q34U_cjs.TooltipCard,
+                {
+                  title: tipCountry.name,
+                  rows: [
+                    {
+                      name: label ?? "Value",
+                      value: formatValue(tipCountry.value),
+                      color: stepColor(tipCountry.step)
+                    }
+                  ]
+                }
+              ) }),
+              interactive && /* @__PURE__ */ jsxRuntime.jsx("span", { "data-world-status": "", role: "status", "aria-live": "polite", style: HIDDEN, children: focus && tipCountry && tipCountry.value !== void 0 ? `${tipCountry.name}, ${label ?? "Value"}: ${formatValue(tipCountry.value)}` : "" })
+            ]
+          }
+        ),
+        interactive && /* @__PURE__ */ jsxRuntime.jsx("div", { style: HIDDEN, children: /* @__PURE__ */ jsxRuntime.jsxs("table", { "data-world-table": "", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("caption", { children: name }),
+          /* @__PURE__ */ jsxRuntime.jsx("thead", { children: /* @__PURE__ */ jsxRuntime.jsxs("tr", { children: [
+            /* @__PURE__ */ jsxRuntime.jsx("th", { scope: "col", children: "Country" }),
+            /* @__PURE__ */ jsxRuntime.jsx("th", { scope: "col", children: label ?? "Value" })
+          ] }) }),
+          /* @__PURE__ */ jsxRuntime.jsx("tbody", { children: order.map((country) => /* @__PURE__ */ jsxRuntime.jsxs("tr", { children: [
+            /* @__PURE__ */ jsxRuntime.jsx("th", { scope: "row", children: country.name }),
+            /* @__PURE__ */ jsxRuntime.jsx("td", { children: formatValue(country.value) })
+          ] }, country.code)) })
+        ] }) }),
+        legend
+      ]
+    }
+  );
+};
+var Legend = ({ scale, format }) => /* @__PURE__ */ jsxRuntime.jsxs(
+  "ul",
+  {
+    "data-world-legend": "",
+    style: {
+      display: "flex",
+      flexWrap: "wrap",
+      alignItems: "flex-end",
+      columnGap: 2,
+      rowGap: "0.5rem",
+      margin: 0,
+      padding: 0,
+      listStyle: "none",
+      fontSize: "var(--text-2xs, 0.6875rem)",
+      color: chunkLT3UC65O_cjs.MUTED
+    },
+    children: [
+      chunkLT3UC65O_cjs.SEQUENTIAL.map((color, i) => /* @__PURE__ */ jsxRuntime.jsxs("li", { style: { display: "flex", flexDirection: "column", gap: 4, minWidth: "2.75rem" }, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "span",
+          {
+            "aria-hidden": true,
+            "data-world-swatch": "",
+            style: { height: 10, borderRadius: 2, background: color }
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { style: { fontVariantNumeric: "tabular-nums", whiteSpace: "nowrap" }, children: [
+          format(scale.bounds[i]),
+          "+"
+        ] })
+      ] }, i)),
+      /* @__PURE__ */ jsxRuntime.jsxs("li", { style: { display: "flex", flexDirection: "column", gap: 4, marginLeft: "0.75rem" }, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "span",
+          {
+            "aria-hidden": true,
+            "data-world-swatch": "",
+            style: {
+              width: "1.75rem",
+              height: 10,
+              borderRadius: 2,
+              background: chunkLT3UC65O_cjs.TRACK,
+              border: `1px solid ${chunkLT3UC65O_cjs.BORDER}`,
+              boxSizing: "border-box"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { style: { whiteSpace: "nowrap" }, children: "No data" })
+      ] })
+    ]
+  }
+);
+
+exports.WorldMap = WorldMap;
+//# sourceMappingURL=WorldMap.cjs.map
+//# sourceMappingURL=WorldMap.cjs.map