choropleth-kit 0.0.0-stage → 0.2.0

package/dist/chunk-ZN6SLXL3.js

@@ -0,0 +1,1932 @@
+// src/core/geography.ts
+import { feature } from "topojson-client";
+var unwrapGeography = (value) => "default" in value ? value.default : value;
+var toFeatureCollection = ({
+  geography,
+  objectName
+}) => {
+  const kind = geography?.type;
+  if (kind === "FeatureCollection") {
+    return geography;
+  }
+  if (kind !== "Topology") {
+    throw new Error(
+      `[choropleth] toFeatureCollection: unrecognized format (type = ${JSON.stringify(kind)}). Expected a "Topology" (TopoJSON) or a "FeatureCollection" (GeoJSON).`
+    );
+  }
+  const topology = geography;
+  const availableNames = Object.keys(topology.objects);
+  const name = objectName ?? availableNames[0];
+  const object = name === void 0 ? void 0 : topology.objects[name];
+  if (name === void 0 || object === void 0) {
+    throw new Error(
+      `[choropleth] toFeatureCollection: object "${objectName ?? "(none)"}" does not exist in the topology. Available objects: ${availableNames.length > 0 ? availableNames.join(", ") : "(none)"}.`
+    );
+  }
+  const converted = feature(topology, object);
+  if (converted.type === "FeatureCollection") {
+    return converted;
+  }
+  return { type: "FeatureCollection", features: [converted] };
+};
+
+// src/core/bounds.ts
+import { geoBounds } from "d3-geo";
+import polylabel from "polylabel";
+var polygonsOf = (geometry) => {
+  if (geometry.type === "Polygon") return [geometry];
+  if (geometry.type === "MultiPolygon") {
+    return geometry.coordinates.map((coordinates) => ({ type: "Polygon", coordinates }));
+  }
+  return null;
+};
+var getFocusGeometry = ({
+  feature: feature2,
+  path,
+  near = 0.5
+}) => {
+  const { geometry } = feature2;
+  if (geometry === null) return null;
+  const polygons = polygonsOf(geometry);
+  if (polygons === null || polygons.length <= 1) return geometry;
+  const measured = polygons.map((polygon) => {
+    const [[x0, y0], [x1, y1]] = path.bounds(polygon);
+    return {
+      polygon,
+      area: path.area(polygon),
+      cx: (x0 + x1) / 2,
+      cy: (y0 + y1) / 2,
+      diagonal: Math.hypot(x1 - x0, y1 - y0)
+    };
+  });
+  const usable = measured.filter((m) => Number.isFinite(m.area) && Number.isFinite(m.cx));
+  const main = usable.reduce(
+    (best, m) => best === void 0 || m.area > best.area ? m : best,
+    void 0
+  );
+  if (main === void 0) return geometry;
+  const kept = usable.filter(
+    (m) => m === main || Math.hypot(m.cx - main.cx, m.cy - main.cy) <= near * main.diagonal
+  );
+  const [only] = kept;
+  return kept.length === 1 && only !== void 0 ? only.polygon : { type: "MultiPolygon", coordinates: kept.map((m) => m.polygon.coordinates) };
+};
+var ringArea = (ring) => {
+  let sum = 0;
+  ring.forEach(([x, y], i) => {
+    const [nx, ny] = ring[(i + 1) % ring.length] ?? [x, y];
+    sum += x * ny - nx * y;
+  });
+  return Math.abs(sum / 2);
+};
+var getAnchorPoint = ({
+  geometry,
+  project,
+  precision = 1
+}) => {
+  if (geometry === null) return null;
+  const polygons = polygonsOf(geometry)?.map((p) => p.coordinates);
+  if (polygons === void 0) return null;
+  const projected = polygons.map(
+    (rings) => rings.map(
+      (ring) => ring.flatMap(([lon, lat]) => {
+        const at = lon === void 0 || lat === void 0 ? null : project([lon, lat]);
+        return at === null ? [] : [at];
+      })
+    )
+  ).filter(([outer]) => outer !== void 0 && outer.length >= 3);
+  const biggest = projected.reduce((best, rings) => {
+    const outer = rings[0] ?? [];
+    return best === void 0 || ringArea(outer) > ringArea(best[0] ?? []) ? rings : best;
+  }, void 0);
+  if (biggest === void 0) return null;
+  const [x, y] = polylabel(
+    biggest.map((ring) => ring.map(([px2, py]) => [px2, py])),
+    precision
+  );
+  return Number.isFinite(x) && Number.isFinite(y) ? [x, y] : null;
+};
+var DEFAULT_PADDING = 24;
+var normalizePadding = (padding = DEFAULT_PADDING) => typeof padding === "number" ? { top: padding, right: padding, bottom: padding, left: padding } : padding;
+var boundsToTransform = ({
+  bounds,
+  size,
+  padding = DEFAULT_PADDING,
+  scaleExtent = [0, Infinity]
+}) => {
+  const [[x0, y0], [x1, y1]] = bounds;
+  const { top, right, bottom, left } = normalizePadding(padding);
+  const innerW = size.width - left - right;
+  const innerH = size.height - top - bottom;
+  const raw = Math.min(innerW / (x1 - x0), innerH / (y1 - y0));
+  const k = Math.min(scaleExtent[1], Math.max(scaleExtent[0], Number.isNaN(raw) ? 1 : raw));
+  return {
+    k,
+    x: left + innerW / 2 - k * ((x0 + x1) / 2),
+    y: top + innerH / 2 - k * ((y0 + y1) / 2)
+  };
+};
+var EDGE_SAMPLES = 9;
+var projectBounds = (bounds, project) => {
+  const [[west, south], [east, north]] = bounds;
+  if (east < west) {
+    const eastHalf = [
+      [west, south],
+      [180, north]
+    ];
+    const westHalf = [
+      [-180, south],
+      [east, north]
+    ];
+    return projectBounds(180 - west >= east + 180 ? eastHalf : westHalf, project);
+  }
+  const samples = [];
+  for (let i = 0; i < EDGE_SAMPLES; i += 1) {
+    const t = i / (EDGE_SAMPLES - 1);
+    const lon = west + (east - west) * t;
+    const lat = south + (north - south) * t;
+    samples.push([lon, south], [lon, north], [west, lat], [east, lat]);
+  }
+  const projected = samples.flatMap((at) => {
+    const p = project(at);
+    return p === null ? [] : [p];
+  });
+  if (projected.length === 0) return null;
+  const xs = projected.map(([x]) => x);
+  const ys = projected.map(([, y]) => y);
+  return [
+    [Math.min(...xs), Math.min(...ys)],
+    [Math.max(...xs), Math.max(...ys)]
+  ];
+};
+var getFocusExtent = ({
+  feature: feature2,
+  path,
+  project,
+  near
+}) => {
+  const geometry = getFocusGeometry({ feature: feature2, path, near });
+  if (geometry === null) return null;
+  const [[west, south], [east, north]] = geoBounds(geometry);
+  if (west > east)
+    return projectBounds(
+      [
+        [west, south],
+        [east, north]
+      ],
+      project
+    );
+  const [[x0, y0], [x1, y1]] = path.bounds(geometry);
+  return [x0, y0, x1, y1].every(Number.isFinite) ? [
+    [x0, y0],
+    [x1, y1]
+  ] : null;
+};
+
+// src/core/camera.ts
+import { interpolateZoom } from "d3-interpolate";
+var FIT_TRANSFORM = { k: 1, x: 0, y: 0 };
+var isFitTransform = (t, epsilon = 1e-3) => Math.abs(t.k - 1) < epsilon && Math.abs(t.x) < epsilon && Math.abs(t.y) < epsilon;
+var applyTransform = ({ k, x, y }, [px2, py]) => [
+  px2 * k + x,
+  py * k + y
+];
+var invertTransform = ({ k, x, y }, [sx, sy]) => [
+  (sx - x) / k,
+  (sy - y) / k
+];
+var constrainAxis = ({
+  t,
+  k,
+  c0,
+  c1,
+  v0,
+  v1,
+  overscroll = 0
+}) => {
+  const size = (c1 - c0) * k;
+  const view = v1 - v0;
+  if (size <= view) return v0 + (view - size) / 2 - c0 * k;
+  const slack = view * overscroll;
+  const min = v1 - c1 * k - slack;
+  const max = v0 - c0 * k + slack;
+  return Math.min(max, Math.max(min, t));
+};
+var constrainTransform = ({
+  transform,
+  content,
+  view,
+  overscroll
+}) => ({
+  k: transform.k,
+  x: constrainAxis({
+    t: transform.x,
+    k: transform.k,
+    c0: content[0][0],
+    c1: content[1][0],
+    v0: view[0][0],
+    v1: view[1][0],
+    overscroll
+  }),
+  y: constrainAxis({
+    t: transform.y,
+    k: transform.k,
+    c0: content[0][1],
+    c1: content[1][1],
+    v0: view[0][1],
+    v1: view[1][1],
+    overscroll
+  })
+});
+var preserveView = ({
+  transform,
+  oldSize,
+  newSize,
+  invertOld,
+  projectNew
+}) => {
+  const center = invertOld(invertTransform(transform, [oldSize.width / 2, oldSize.height / 2]));
+  const projected = center === null ? null : projectNew(center);
+  if (projected === null) return FIT_TRANSFORM;
+  return {
+    k: transform.k,
+    x: newSize.width / 2 - transform.k * projected[0],
+    y: newSize.height / 2 - transform.k * projected[1]
+  };
+};
+var MIN_FLIGHT_MS = 350;
+var MAX_FLIGHT_MS = 1200;
+var DEFAULT_FLIGHT_CURVATURE = 1.25;
+var transformToZoomView = ({ k, x, y }, { width, height }) => [(width / 2 - x) / k, (height / 2 - y) / k, width / k];
+var createZoomInterpolator = (rho) => interpolateZoom.rho(rho);
+var flightDuration = ({
+  from,
+  to,
+  size,
+  speed = 1,
+  curvature = DEFAULT_FLIGHT_CURVATURE
+}) => {
+  const natural = createZoomInterpolator(curvature)(
+    transformToZoomView(from, size),
+    transformToZoomView(to, size)
+  ).duration;
+  const scaled = natural * speed;
+  if (!Number.isFinite(scaled)) return MIN_FLIGHT_MS;
+  return Math.min(MAX_FLIGHT_MS, Math.max(MIN_FLIGHT_MS, scaled));
+};
+var INERTIA_TAU_MS = 325;
+var inertiaOffset = ({
+  velocity,
+  elapsed,
+  tau = INERTIA_TAU_MS
+}) => {
+  if (!(elapsed > 0) || !Number.isFinite(velocity)) return 0;
+  return velocity * tau * (1 - Math.exp(-elapsed / tau));
+};
+var INERTIA_MIN_VELOCITY = 0.3;
+var INERTIA_WINDOW_MS = 100;
+var releaseVelocity = ({
+  samples,
+  now,
+  windowMs = INERTIA_WINDOW_MS,
+  minVelocity = INERTIA_MIN_VELOCITY
+}) => {
+  const recent = samples.filter((s) => now - s.time <= windowMs);
+  if (recent.length < 2) return null;
+  const first = recent[0];
+  const last = recent[recent.length - 1];
+  if (first === void 0 || last === void 0) return null;
+  if (recent.some((s) => s.k !== last.k)) return null;
+  const dt = last.time - first.time;
+  if (!(dt > 0)) return null;
+  const vx = (last.x - first.x) / dt;
+  const vy = (last.y - first.y) / dt;
+  return Math.hypot(vx, vy) >= minVelocity ? [vx, vy] : null;
+};
+var bubbleScale = (k, scaling) => {
+  if (!(k > 0) || !Number.isFinite(k)) return 1;
+  switch (scaling) {
+    case "screen":
+      return 1 / k;
+    case "geo":
+      return 1;
+    case "sqrt":
+      return 1 / Math.sqrt(k);
+  }
+};
+var WORLD_BOUNDS = [
+  [-180, -90],
+  [180, 90]
+];
+var BOUNDS_SAMPLES = 5;
+var toViewState = ({
+  transform,
+  size,
+  invert,
+  level = { id: "root", depth: 0 }
+}) => {
+  const toCoordinates = (screen) => {
+    const at = invert(invertTransform(transform, screen));
+    return at !== null && Number.isFinite(at[0]) && Number.isFinite(at[1]) ? at : null;
+  };
+  const samples = [];
+  for (let i = 0; i < BOUNDS_SAMPLES; i += 1) {
+    for (let j = 0; j < BOUNDS_SAMPLES; j += 1) {
+      const at = toCoordinates([
+        size.width * i / (BOUNDS_SAMPLES - 1),
+        size.height * j / (BOUNDS_SAMPLES - 1)
+      ]);
+      if (at !== null) samples.push(at);
+    }
+  }
+  const lons = samples.map(([lon]) => lon);
+  const lats = samples.map(([, lat]) => lat);
+  const bounds = samples.length === 0 ? WORLD_BOUNDS : [
+    [Math.min(...lons), Math.min(...lats)],
+    [Math.max(...lons), Math.max(...lats)]
+  ];
+  const center = toCoordinates([size.width / 2, size.height / 2]) ?? [
+    (bounds[0][0] + bounds[1][0]) / 2,
+    (bounds[0][1] + bounds[1][1]) / 2
+  ];
+  return {
+    k: transform.k,
+    x: transform.x,
+    y: transform.y,
+    zoom: transform.k,
+    center,
+    bounds,
+    level
+  };
+};
+
+// src/core/theme.ts
+var defineTheme = (theme) => theme;
+var light = {
+  background: "transparent",
+  empty: { fill: "#d4d4d4" },
+  context: { fill: "#e5e5e5", border: "#ffffff" },
+  border: { color: "#ffffff", width: 0.5 },
+  hover: { stroke: "#000000", width: 1.5 },
+  selected: { stroke: "#0b5fff", width: 2 },
+  focus: { ring: "#0b5fff", width: 2 },
+  dim: { opacity: 0.45 },
+  bubble: { fill: "#2563eb", stroke: "#ffffff", opacity: 0.75 },
+  font: { color: "#111111" },
+  tooltip: {
+    background: "#ffffff",
+    color: "#111111",
+    border: "#cccccc",
+    radius: 4,
+    shadow: "none"
+  },
+  controls: { background: "#ffffff", color: "#111111", border: "#cccccc", radius: 6 }
+};
+var dark = {
+  background: "#0f172a",
+  empty: { fill: "#475569" },
+  context: { fill: "#1e293b", border: "#0f172a" },
+  border: { color: "#0f172a", width: 0.5 },
+  hover: { stroke: "#f8fafc", width: 1.5 },
+  selected: { stroke: "#60a5fa", width: 2 },
+  focus: { ring: "#93c5fd", width: 2 },
+  dim: { opacity: 0.4 },
+  bubble: { fill: "#60a5fa", stroke: "#0f172a", opacity: 0.8 },
+  font: { color: "#e2e8f0" },
+  tooltip: {
+    background: "#f8fafc",
+    color: "#0f172a",
+    border: "#cbd5e1",
+    radius: 4,
+    shadow: "0 4px 12px rgb(0 0 0 / 0.4)"
+  },
+  controls: { background: "#1e293b", color: "#e2e8f0", border: "#334155", radius: 6 }
+};
+var minimal = {
+  background: "transparent",
+  empty: { fill: "#eeeeee" },
+  context: { fill: "#f3f3f3", border: "#ffffff" },
+  border: { color: "#ffffff", width: 0.25 },
+  hover: { stroke: "#444444", width: 1 },
+  selected: { stroke: "#111111", width: 1.5 },
+  focus: { ring: "#111111", width: 2 },
+  dim: { opacity: 0.5 },
+  bubble: { fill: "#111111", stroke: "#ffffff", opacity: 0.6 },
+  font: { color: "#333333" },
+  tooltip: {
+    background: "#ffffff",
+    color: "#222222",
+    border: "transparent",
+    radius: 2,
+    shadow: "0 1px 4px rgb(0 0 0 / 0.18)"
+  },
+  controls: { background: "#ffffff", color: "#333333", border: "transparent", radius: 2 }
+};
+var contrast = {
+  background: "#ffffff",
+  empty: { fill: "#bdbdbd", pattern: "hatch" },
+  context: { fill: "#e0e0e0", border: "#000000" },
+  border: { color: "#000000", width: 1 },
+  hover: { stroke: "#000000", width: 3 },
+  selected: { stroke: "#0033cc", width: 4 },
+  focus: { ring: "#000000", width: 4 },
+  dim: { opacity: 0.35 },
+  bubble: { fill: "#003399", stroke: "#000000", opacity: 0.85 },
+  font: { color: "#000000", size: 14 },
+  tooltip: {
+    background: "#000000",
+    color: "#ffffff",
+    border: "#ffffff",
+    radius: 0,
+    shadow: "none"
+  },
+  controls: { background: "#ffffff", color: "#000000", border: "#000000", radius: 0 }
+};
+var THEMES = {
+  light,
+  dark,
+  minimal,
+  contrast
+};
+var isThemeName = (value) => typeof value === "string" && Object.hasOwn(THEMES, value);
+var resolveTheme = (theme) => isThemeName(theme) ? THEMES[theme] : theme;
+var extendTheme = (base, overrides) => {
+  const from = resolveTheme(base) ?? {};
+  const merged = { ...from };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === void 0) continue;
+    const previous = merged[key];
+    merged[key] = typeof value === "object" && value !== null && typeof previous === "object" ? { ...previous, ...value } : value;
+  }
+  return merged;
+};
+var px = (value) => `${value}px`;
+var themeToCssVars = (theme) => {
+  const vars = {};
+  if (theme === void 0) return vars;
+  const set = (name, value, unit) => {
+    if (value === void 0) return;
+    vars[`--cm-${name}`] = typeof value === "number" && unit !== void 0 ? unit(value) : `${value}`;
+  };
+  set("background", theme.background);
+  set("empty-fill", theme.empty?.fill);
+  set("context-fill", theme.context?.fill);
+  set("context-border-color", theme.context?.border);
+  set("border-color", theme.border?.color);
+  set("border-width", theme.border?.width, px);
+  set("hover-stroke", theme.hover?.stroke);
+  set("hover-stroke-width", theme.hover?.width, px);
+  set("selected-stroke", theme.selected?.stroke);
+  set("selected-stroke-width", theme.selected?.width, px);
+  set("focus-ring", theme.focus?.ring);
+  set("focus-ring-width", theme.focus?.width, px);
+  set("dim-opacity", theme.dim?.opacity);
+  set("bubble-fill", theme.bubble?.fill);
+  set("bubble-stroke", theme.bubble?.stroke);
+  set("bubble-opacity", theme.bubble?.opacity);
+  set("font-family", theme.font?.family);
+  set("font-size", theme.font?.size, px);
+  set("label-color", theme.font?.color);
+  set("tooltip-bg", theme.tooltip?.background);
+  set("tooltip-color", theme.tooltip?.color);
+  set("tooltip-border", theme.tooltip?.border);
+  set("tooltip-radius", theme.tooltip?.radius, px);
+  set("tooltip-shadow", theme.tooltip?.shadow);
+  set("control-bg", theme.controls?.background);
+  set("control-color", theme.controls?.color);
+  set("control-border", theme.controls?.border);
+  set("control-radius", theme.controls?.radius, px);
+  return vars;
+};
+
+// src/core/labels.ts
+var en = {
+  noData: "No data",
+  geographyError: "The map could not be loaded.",
+  zoomIn: "Zoom in",
+  zoomOut: "Zoom out",
+  resetView: "Reset view",
+  gestureHintWheel: "Use Ctrl + scroll to zoom",
+  gestureHintWheelMac: "Use \u2318 + scroll to zoom",
+  gestureHintTouch: "Use two fingers to move the map",
+  breadcrumb: "Breadcrumb",
+  breadcrumbRoot: "All",
+  drillUp: "Up one level",
+  drillHint: "Click to see regions",
+  tapAgainHint: "Tap again to enter"
+};
+var es = {
+  noData: "Sin dato",
+  geographyError: "No se pudo cargar el mapa.",
+  zoomIn: "Acercar",
+  zoomOut: "Alejar",
+  resetView: "Restablecer vista",
+  gestureHintWheel: "Usa Ctrl + rueda para hacer zoom",
+  gestureHintWheelMac: "Usa \u2318 + rueda para hacer zoom",
+  gestureHintTouch: "Usa dos dedos para mover el mapa",
+  breadcrumb: "Ruta de navegaci\xF3n",
+  breadcrumbRoot: "Todo",
+  drillUp: "Subir un nivel",
+  drillHint: "Clic para ver regiones",
+  tapAgainHint: "Toca de nuevo para entrar"
+};
+var resolveLabels = (labels) => ({
+  ...en,
+  ...labels
+});
+
+// src/core/join.ts
+var defaultGetFeatureId = (feature2) => feature2.id === void 0 ? void 0 : String(feature2.id);
+var joinData = ({
+  features,
+  data,
+  getId,
+  getFeatureId = defaultGetFeatureId
+}) => {
+  const featureIds = /* @__PURE__ */ new Set();
+  for (const feature2 of features) {
+    const id = getFeatureId(feature2);
+    if (id !== void 0) featureIds.add(id);
+  }
+  const dataById = /* @__PURE__ */ new Map();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const datum of data) {
+    const id = getId(datum);
+    if (dataById.has(id)) duplicates.add(id);
+    else dataById.set(id, datum);
+  }
+  const joined = /* @__PURE__ */ new Map();
+  const unmatchedData = [];
+  for (const [id, datum] of dataById) {
+    if (featureIds.has(id)) joined.set(id, datum);
+    else unmatchedData.push(id);
+  }
+  const featuresWithoutData = [...featureIds].filter((id) => !dataById.has(id));
+  return { joined, unmatchedData, featuresWithoutData, duplicateDataIds: [...duplicates] };
+};
+
+// src/core/classify.ts
+import { scaleQuantile, scaleQuantize } from "d3-scale";
+var DEFAULT_CLASSES = 5;
+var finiteValues = (values) => values.filter((v) => typeof v === "number" && Number.isFinite(v));
+var assertValidClasses = (classes) => {
+  if (!Number.isInteger(classes) || classes < 1) {
+    throw new Error(
+      `[choropleth] classify: "classes" must be an integer \u2265 1 (received: ${classes}).`
+    );
+  }
+};
+var computeThresholds = ({
+  values,
+  classification,
+  domain
+}) => {
+  switch (classification.method) {
+    case "linear":
+      return [];
+    case "threshold": {
+      const { thresholds } = classification;
+      const ascending = thresholds.every(
+        (t, i) => Number.isFinite(t) && (i === 0 || t > (thresholds[i - 1] ?? t))
+      );
+      if (!ascending) {
+        throw new Error(
+          `[choropleth] classify: "thresholds" must be a list of finite numbers in strictly ascending order (received: [${thresholds.join(", ")}]).`
+        );
+      }
+      return [...thresholds];
+    }
+    case "quantize": {
+      const classes = classification.classes ?? DEFAULT_CLASSES;
+      assertValidClasses(classes);
+      return scaleQuantize().domain([...domain]).range(Array.from({ length: classes }, (_, i) => i)).thresholds();
+    }
+    case "quantile": {
+      const classes = classification.classes ?? DEFAULT_CLASSES;
+      assertValidClasses(classes);
+      if (values.length === 0) return [];
+      return scaleQuantile().domain([...values]).range(Array.from({ length: classes }, (_, i) => i)).quantiles();
+    }
+  }
+};
+
+// src/core/scales.ts
+import { scaleDiverging, scaleSequential, scaleThreshold } from "d3-scale";
+
+// src/core/palettes.ts
+import {
+  interpolateBlues,
+  interpolateBrBG,
+  interpolateGreens,
+  interpolateGreys,
+  interpolateOranges,
+  interpolatePiYG,
+  interpolatePRGn,
+  interpolatePuOr,
+  interpolatePurples,
+  interpolateRdBu,
+  interpolateRdYlBu,
+  interpolateRdYlGn,
+  interpolateReds,
+  interpolateSpectral,
+  interpolateViridis,
+  schemeAccent,
+  schemeDark2,
+  schemePaired,
+  schemePastel1,
+  schemeSet2,
+  schemeSet3,
+  schemeTableau10
+} from "d3-scale-chromatic";
+var SEQUENTIAL_PALETTES = {
+  blues: interpolateBlues,
+  greens: interpolateGreens,
+  greys: interpolateGreys,
+  oranges: interpolateOranges,
+  purples: interpolatePurples,
+  reds: interpolateReds,
+  viridis: interpolateViridis
+};
+var DIVERGING_PALETTES = {
+  rdbu: interpolateRdBu,
+  brbg: interpolateBrBG,
+  piyg: interpolatePiYG,
+  prgn: interpolatePRGn,
+  puor: interpolatePuOr,
+  rdylbu: interpolateRdYlBu,
+  rdylgn: interpolateRdYlGn,
+  spectral: interpolateSpectral
+};
+var DEFAULT_SEQUENTIAL_PALETTE = "blues";
+var DEFAULT_DIVERGING_PALETTE = "rdbu";
+var SEQUENTIAL_START = 0.15;
+var sampleSequentialColors = ({
+  interpolate,
+  classes
+}) => Array.from(
+  { length: classes },
+  (_, i) => (
+    // With a single class there is no "from less to more": a mid tone is used, not the light extreme.
+    interpolate(
+      classes === 1 ? 0.6 : SEQUENTIAL_START + (1 - SEQUENTIAL_START) * i / (classes - 1)
+    )
+  )
+);
+var sampleDivergingColors = ({
+  interpolate,
+  classes
+}) => (
+  // Center of each band: with 5 classes t = 0.1, 0.3, 0.5, 0.7, 0.9. With an odd number the middle
+  // class falls exactly at t = 0.5, the palette's neutral color, which is the one that must
+  // represent the midpoint. That is why the diverging one does not use SEQUENTIAL_START: its light
+  // end is in the center, and that is intentional.
+  Array.from({ length: classes }, (_, i) => interpolate((i + 0.5) / classes))
+);
+var CATEGORICAL_PALETTES = {
+  tableau10: schemeTableau10,
+  set2: schemeSet2,
+  set3: schemeSet3,
+  accent: schemeAccent,
+  dark2: schemeDark2,
+  paired: schemePaired,
+  pastel1: schemePastel1
+};
+var DEFAULT_CATEGORICAL_PALETTE = "tableau10";
+
+// src/core/scales.ts
+var DEFAULT_EMPTY_FILL = "#d4d4d4";
+var extent = (values) => {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const v of values) {
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  return values.length === 0 ? [0, 1] : [min, max];
+};
+var createColorScale = (options) => {
+  const emptyFill = options.emptyFill ?? DEFAULT_EMPTY_FILL;
+  const values = finiteValues(options.values);
+  const midpoint = options.variant === "diverging" ? options.midpoint ?? 0 : 0;
+  const [min, max] = extent(values);
+  let domain = [min, max];
+  if (options.variant === "diverging") {
+    const spread = Math.max(Math.abs(min - midpoint), Math.abs(max - midpoint)) || 1;
+    domain = [midpoint - spread, midpoint + spread];
+  }
+  const classification = options.classification ?? (options.variant === "diverging" ? { method: "quantize", classes: DEFAULT_CLASSES } : { method: "quantile", classes: DEFAULT_CLASSES });
+  const thresholds = computeThresholds({ values, classification, domain });
+  const interpolate = options.variant === "diverging" ? DIVERGING_PALETTES[options.palette ?? DEFAULT_DIVERGING_PALETTE] : SEQUENTIAL_PALETTES[options.palette ?? DEFAULT_SEQUENTIAL_PALETTE];
+  const isUsable2 = (v) => typeof v === "number" && Number.isFinite(v);
+  if (classification.method === "linear") {
+    const continuous = options.variant === "diverging" ? scaleDiverging(interpolate).domain([domain[0], midpoint, domain[1]]).clamp(true) : scaleSequential(interpolate).domain(domain).clamp(true);
+    return {
+      getColor: (value) => isUsable2(value) ? continuous(value) : emptyFill,
+      kind: "continuous",
+      domain,
+      thresholds: [],
+      colors: [],
+      emptyFill
+    };
+  }
+  const classes = thresholds.length + 1;
+  const colors = options.variant === "diverging" ? sampleDivergingColors({ interpolate, classes }) : sampleSequentialColors({ interpolate, classes });
+  const classed = scaleThreshold().domain(thresholds).range(colors);
+  return {
+    getColor: (value) => isUsable2(value) ? classed(value) : emptyFill,
+    kind: "classed",
+    domain,
+    thresholds,
+    colors,
+    emptyFill
+  };
+};
+
+// src/core/projection.ts
+import {
+  geoAlbers,
+  geoPath,
+  geoEqualEarth,
+  geoMercator,
+  geoNaturalEarth1,
+  geoOrthographic
+} from "d3-geo";
+var PROJECTIONS = {
+  // Equal areas: each country takes up the area that belongs to it. Recommended for the world.
+  equalEarth: geoEqualEarth,
+  // Compromise projection, pleasant to the eye; distorts areas somewhat.
+  naturalEarth: geoNaturalEarth1,
+  // Inflates polar areas (Greenland ≈ Africa). Useful for street maps, not for world choropleths:
+  // the eye associates more painted area with more importance.
+  mercator: geoMercator,
+  // Conic for the US (with Alaska and Hawaii repositioned). Looks bad over the whole world.
+  albers: geoAlbers,
+  // Globe view: only one hemisphere is visible.
+  orthographic: geoOrthographic
+};
+var projectionFactory = (name = DEFAULT_PROJECTION) => PROJECTIONS[name];
+var DEFAULT_PROJECTION = "equalEarth";
+var createProjection = ({
+  name = DEFAULT_PROJECTION,
+  width,
+  height,
+  featureCollection,
+  rotate
+}) => {
+  if (!(Number.isFinite(width) && width > 0 && Number.isFinite(height) && height > 0)) {
+    throw new Error(
+      `[choropleth] createProjection: width and height must be finite numbers > 0 (received: ${width} \xD7 ${height}).`
+    );
+  }
+  const projection = PROJECTIONS[name]();
+  if (rotate !== void 0) projection.rotate([rotate[0], rotate[1]]);
+  if (featureCollection.features.length === 0) return projection;
+  return projection.fitSize([width, height], featureCollection);
+};
+var DEFAULT_ASPECT_RATIO = 960 / 500;
+var MIN_ASPECT_RATIO = 0.2;
+var MAX_ASPECT_RATIO = 5;
+var computeAspectRatio = ({
+  name = DEFAULT_PROJECTION,
+  featureCollection,
+  rotate
+}) => {
+  if (featureCollection.features.length === 0) return DEFAULT_ASPECT_RATIO;
+  const base = PROJECTIONS[name]();
+  if (rotate !== void 0) base.rotate([rotate[0], rotate[1]]);
+  const projection = base.fitWidth(1e3, featureCollection);
+  const [[x0, y0], [x1, y1]] = geoPath(projection).bounds(featureCollection);
+  const ratio = (x1 - x0) / (y1 - y0);
+  if (!Number.isFinite(ratio) || ratio <= 0) return DEFAULT_ASPECT_RATIO;
+  return Math.min(MAX_ASPECT_RATIO, Math.max(MIN_ASPECT_RATIO, ratio));
+};
+var relativeTransform = (from, to) => {
+  const k = to.scale() / from.scale();
+  const [fx, fy] = from.translate();
+  const [tx, ty] = to.translate();
+  return { k, x: tx - k * fx, y: ty - k * fy };
+};
+var rebaseProjection = ({
+  parent,
+  factory,
+  focus,
+  width,
+  height,
+  padding
+}) => {
+  if (!(Number.isFinite(width) && width > 0 && Number.isFinite(height) && height > 0)) {
+    throw new Error(
+      `[choropleth] rebaseProjection: width and height must be finite numbers > 0 (received: ${width} \xD7 ${height}).`
+    );
+  }
+  const child = copyShape(factory(), parent);
+  child.fitExtent(
+    [
+      [padding.left, padding.top],
+      [width - padding.right, height - padding.bottom]
+    ],
+    focus
+  );
+  if (!(child.scale() > 0) || !Number.isFinite(child.scale())) {
+    throw new Error(
+      "[choropleth] rebaseProjection: the focus geometry has no extent (empty or a single point), so it cannot be fitted."
+    );
+  }
+  return { projection: child, relative: relativeTransform(parent, child) };
+};
+var copyShape = (child, parent) => {
+  child.rotate(parent.rotate()).center(parent.center());
+  child.angle(parent.angle()).reflectX(parent.reflectX()).reflectY(parent.reflectY());
+  child.precision(parent.precision());
+  const clipAngle = parent.clipAngle();
+  if (clipAngle !== null) child.clipAngle(clipAngle);
+  const conic = parent;
+  const target = child;
+  if (conic.parallels !== void 0 && target.parallels !== void 0) {
+    target.parallels(conic.parallels());
+  }
+  return child;
+};
+
+// src/core/legend.ts
+var defaultFormatValue = (value) => Number.isInteger(value) ? String(value) : String(Number(value.toFixed(2)));
+var classIndex = (thresholds, value) => {
+  let lo = 0;
+  let hi = thresholds.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (thresholds[mid] <= value) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+};
+var buildLegend = (options) => {
+  const { scale, values, emptyLabel } = options;
+  const format = options.formatValue ?? defaultFormatValue;
+  if (scale.kind === "continuous") return [];
+  const counts = Array.from({ length: scale.colors.length }, () => 0);
+  let empty = 0;
+  for (const v of values) {
+    if (typeof v !== "number" || !Number.isFinite(v)) empty += 1;
+    else
+      counts[classIndex(scale.thresholds, v)] = (counts[classIndex(scale.thresholds, v)] ?? 0) + 1;
+  }
+  const items = scale.colors.map((color, i) => {
+    const from = i === 0 ? scale.domain[0] : scale.thresholds[i - 1];
+    const to = i === scale.colors.length - 1 ? scale.domain[1] : scale.thresholds[i];
+    return { color, from, to, label: `${format(from)} \u2013 ${format(to)}`, count: counts[i] ?? 0 };
+  });
+  if (emptyLabel !== void 0) {
+    items.push({ color: scale.emptyFill, label: emptyLabel, count: empty, empty: true });
+  }
+  return items;
+};
+
+// src/core/borders.ts
+import { feature as toFeature, mesh } from "topojson-client";
+var createBorders = ({
+  geography,
+  objectName,
+  filterFeatures
+}) => {
+  if (geography.type !== "Topology") return null;
+  const topology = geography;
+  const name = objectName ?? Object.keys(topology.objects)[0];
+  const object = name === void 0 ? void 0 : topology.objects[name];
+  if (object === void 0) return null;
+  if (filterFeatures === void 0) {
+    return mesh(topology, object, (a, b) => a !== b);
+  }
+  const kept = /* @__PURE__ */ new Map();
+  const keep = (geometry) => {
+    let result = kept.get(geometry);
+    if (result === void 0) {
+      result = filterFeatures(toFeature(topology, geometry));
+      kept.set(geometry, result);
+    }
+    return result;
+  };
+  return mesh(
+    topology,
+    object,
+    (a, b) => a !== b && keep(a) && keep(b)
+  );
+};
+
+// src/core/diagnostics.ts
+var MAX_LISTED = 8;
+var list = (ids) => {
+  const shown = ids.slice(0, MAX_LISTED).map((id) => JSON.stringify(id));
+  const rest = ids.length - shown.length;
+  return rest > 0 ? `${shown.join(", ")} and ${rest} more` : shown.join(", ");
+};
+var styleOf = (id) => {
+  if (/^\d+$/.test(id)) return "numeric";
+  if (/^[A-Za-z]{2}$/.test(id)) return "alpha-2";
+  if (/^[A-Za-z]{3}$/.test(id)) return "alpha-3";
+  return "other";
+};
+var commonStyle = (ids) => {
+  const first = ids[0];
+  if (first === void 0) return null;
+  const style = styleOf(first);
+  return style !== "other" && ids.every((id) => styleOf(id) === style) ? style : null;
+};
+var STYLE_NAMES = {
+  numeric: 'ISO 3166-1 numeric (e.g. "724")',
+  "alpha-2": 'ISO 3166-1 alpha-2 (e.g. "ES")',
+  "alpha-3": 'ISO 3166-1 alpha-3 (e.g. "ESP")',
+  other: "something else"
+};
+var hintFor = (unmatched, featuresWithoutData) => {
+  const features = new Set(featuresWithoutData);
+  const padded = unmatched.find((id) => /^\d{1,2}$/.test(id) && features.has(id.padStart(3, "0")));
+  if (padded !== void 0) {
+    return `Hint: ${JSON.stringify(padded)} does not match ${JSON.stringify(padded.padStart(3, "0"))}. Leading zeros matter (a spreadsheet may have dropped them).`;
+  }
+  const upper = new Set(featuresWithoutData.map((id) => id.toUpperCase()));
+  const lowered = unmatched.find((id) => id !== id.toUpperCase() && upper.has(id.toUpperCase()));
+  if (lowered !== void 0) {
+    return `Hint: ids are case-sensitive; ${JSON.stringify(lowered)} would match ${JSON.stringify(lowered.toUpperCase())}.`;
+  }
+  const dataStyle = commonStyle(unmatched);
+  const geometryStyle = commonStyle(featuresWithoutData);
+  if (dataStyle !== null && geometryStyle !== null && dataStyle !== geometryStyle) {
+    return `Hint: your data ids look like ${STYLE_NAMES[dataStyle]} but the geometry ids look like ${STYLE_NAMES[geometryStyle]}. Convert one of them, or use \`getFeatureId\` to read another property of the geometry.`;
+  }
+  return null;
+};
+var formatJoinDiagnostics = ({
+  unmatchedData,
+  featuresWithoutData,
+  duplicateDataIds,
+  dataCount
+}) => {
+  if (dataCount === 0) return null;
+  const lines = [];
+  if (unmatchedData.length > 0) {
+    lines.push(
+      `${unmatchedData.length} datum(s) have no matching geometry: ${list(unmatchedData)}.`
+    );
+    const hint = hintFor(unmatchedData, featuresWithoutData);
+    if (hint !== null) lines.push(hint);
+  }
+  if (duplicateDataIds.length > 0) {
+    lines.push(
+      `${duplicateDataIds.length} id(s) appear more than once in \`data\` (only the first row of each is used): ${list(duplicateDataIds)}.`
+    );
+  }
+  if (featuresWithoutData.length > 0) {
+    lines.push(`${featuresWithoutData.length} region(s) have no data and will use \`emptyFill\`.`);
+  }
+  return lines.length === 0 ? null : `[choropleth] ${lines.join("\n             ")}`;
+};
+
+// src/core/categories.ts
+var createCategoricalScale = ({
+  values,
+  categories,
+  palette = DEFAULT_CATEGORICAL_PALETTE,
+  emptyFill
+}) => {
+  const colors = CATEGORICAL_PALETTES[palette];
+  const specs = categories ?? [...new Set(values.filter((v) => typeof v === "string"))].sort((a, b) => a.localeCompare(b)).map((id) => ({ id }));
+  const resolved = specs.map((spec, index) => ({
+    id: spec.id,
+    label: spec.label ?? spec.id,
+    // `as string`: the modulo never gives undefined because `colors` has length ≥ 1.
+    color: spec.color ?? colors[index % colors.length]
+  }));
+  const byId = new Map(resolved.map((c) => [c.id, c]));
+  return {
+    getColor: (category) => category == null ? emptyFill : byId.get(category)?.color ?? emptyFill,
+    getLabel: (category) => category == null ? "" : byId.get(category)?.label ?? category,
+    categories: resolved,
+    emptyFill
+  };
+};
+var buildCategoricalLegend = ({
+  scale,
+  values,
+  emptyLabel
+}) => {
+  const counts = /* @__PURE__ */ new Map();
+  let empty = 0;
+  for (const v of values) {
+    if (v == null || !scale.categories.some((c) => c.id === v)) empty += 1;
+    else counts.set(v, (counts.get(v) ?? 0) + 1);
+  }
+  const items = scale.categories.map((c) => ({
+    color: c.color,
+    label: c.label,
+    count: counts.get(c.id) ?? 0
+  }));
+  if (emptyLabel !== void 0)
+    items.push({ color: scale.emptyFill, label: emptyLabel, count: empty, empty: true });
+  return items;
+};
+
+// src/core/bubbles.ts
+import { scaleSqrt } from "d3-scale";
+var DEFAULT_MAX_RADIUS = 24;
+var isPositive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+var createRadiusScale = ({
+  values,
+  maxRadius = DEFAULT_MAX_RADIUS
+}) => {
+  let max = 0;
+  for (const v of values) if (isPositive(v) && v > max) max = v;
+  const scale = scaleSqrt().domain([0, max || 1]).range([0, maxRadius]).clamp(true);
+  return { getRadius: (value) => max === 0 ? 0 : scale(value), max, maxRadius };
+};
+var buildSizeLegend = ({
+  scale,
+  formatValue = defaultFormatValue
+}) => {
+  if (scale.max === 0) return [];
+  return [0.25, 0.5, 1].map((fraction) => {
+    const value = scale.max * fraction;
+    return { value, radius: scale.getRadius(value), label: formatValue(value) };
+  });
+};
+
+// src/core/variants.ts
+var DEFAULT_BUBBLE_FILL = "#2563eb";
+var isUsable = (v) => typeof v === "number" && Number.isFinite(v);
+var resolveVariant = (options) => {
+  const { config, entries, emptyFill, formatValue, emptyLabel } = options;
+  const numeric = (get) => entries.map((e) => e.datum === void 0 ? null : get(e.datum));
+  const formatted = (values2) => values2.map((v) => isUsable(v) ? formatValue(v) : "");
+  if (config.variant === "categorical") {
+    const values2 = entries.map((e) => e.datum === void 0 ? null : config.getCategory(e.datum));
+    const scale2 = createCategoricalScale({
+      values: values2,
+      categories: config.categories,
+      palette: config.palette,
+      emptyFill
+    });
+    return {
+      fills: values2.map((v) => scale2.getColor(v)),
+      values: values2,
+      labels: values2.map((v) => scale2.getLabel(v)),
+      scale: null,
+      legend: buildCategoricalLegend({ scale: scale2, values: values2, emptyLabel }),
+      classes: values2.map((v) => {
+        const index = v == null ? -1 : scale2.categories.findIndex((c) => c.id === v);
+        return index < 0 ? null : index;
+      }),
+      bubbles: [],
+      sizeLegend: []
+    };
+  }
+  if (config.variant === "bubble") return resolveBubbles(options, config);
+  const values = numeric(config.getValue);
+  const scale = createColorScale({
+    values,
+    classification: config.classification,
+    emptyFill,
+    ...config.variant === "diverging" ? { variant: "diverging", palette: config.palette, midpoint: config.midpoint } : { variant: "sequential", palette: config.palette }
+  });
+  return {
+    fills: values.map((v) => scale.getColor(v)),
+    values,
+    labels: formatted(values),
+    scale,
+    legend: buildLegend({ scale, values, formatValue, emptyLabel }),
+    classes: values.map(
+      (v) => isUsable(v) && scale.kind !== "continuous" ? classIndex(scale.thresholds, v) : null
+    ),
+    bubbles: [],
+    sizeLegend: []
+  };
+};
+var resolveBubbles = (options, config) => {
+  const { entries, data, getId, centroids, project, emptyFill, formatValue, emptyLabel } = options;
+  const values = entries.map((e) => e.datum === void 0 ? null : config.getValue(e.datum));
+  const sources = [];
+  if (config.getCoordinates !== void 0) {
+    for (const datum of data) {
+      const coordinates = config.getCoordinates(datum);
+      const at = coordinates === null ? null : project(coordinates);
+      if (coordinates !== null && at !== null) {
+        sources.push({ id: getId(datum), datum, at, coordinates });
+      }
+    }
+  } else {
+    entries.forEach((entry, index) => {
+      const at = centroids[index];
+      if (entry.id !== void 0 && entry.datum !== void 0 && at != null) {
+        sources.push({ id: entry.id, datum: entry.datum, at, coordinates: null });
+      }
+    });
+  }
+  const sized = sources.map((source) => ({ ...source, value: config.getValue(source.datum) })).filter((s) => isUsable(s.value) && s.value > 0);
+  const radius = createRadiusScale({
+    values: sized.map((s) => s.value),
+    maxRadius: config.maxRadius ?? DEFAULT_MAX_RADIUS
+  });
+  const colorValues = sized.map(
+    (s) => config.getColorValue ? config.getColorValue(s.datum) : null
+  );
+  const colorScale = config.getColorValue === void 0 ? null : createColorScale({
+    variant: "diverging",
+    values: colorValues,
+    classification: config.classification,
+    palette: config.palette,
+    midpoint: config.midpoint,
+    emptyFill
+  });
+  const bubbles = sized.map((s, i) => ({
+    id: s.id,
+    x: s.at[0],
+    y: s.at[1],
+    r: radius.getRadius(s.value),
+    fill: colorScale === null ? config.color ?? DEFAULT_BUBBLE_FILL : colorScale.getColor(colorValues[i]),
+    value: s.value,
+    colorValue: colorValues[i] ?? null,
+    datum: s.datum,
+    coordinates: s.coordinates
+  })).sort((a, b) => b.r - a.r);
+  return {
+    fills: entries.map(() => emptyFill),
+    values,
+    labels: values.map((v) => isUsable(v) ? formatValue(v) : ""),
+    scale: colorScale,
+    legend: colorScale === null ? [] : buildLegend({ scale: colorScale, values: colorValues, formatValue, emptyLabel }),
+    // The bubbles carry the color, not the regions: there is no per-region class here.
+    classes: entries.map(() => null),
+    bubbles,
+    sizeLegend: buildSizeLegend({ scale: radius, formatValue })
+  };
+};
+
+// src/core/zoom.ts
+var DEFAULT_FOCUS_BOUNDS = {
+  ES: [
+    [-18.5, 27.5],
+    [4.5, 44]
+  ]
+};
+var DEFAULT_ZOOM_MIN = 1;
+var DEFAULT_ZOOM_MAX = 12;
+var resolveZoomOptions = (zoom, { clickIsBusy }) => {
+  if (zoom === false) return null;
+  const options = zoom === true || zoom === void 0 ? {} : zoom;
+  const { min = DEFAULT_ZOOM_MIN, max = DEFAULT_ZOOM_MAX } = options;
+  if (!(min > 0) || !Number.isFinite(max) || max < min) {
+    throw new Error(
+      `[choropleth] zoom: "min" must be > 0 and "max" must be finite and \u2265 "min" (received: min = ${min}, max = ${max}).`
+    );
+  }
+  const { doubleClick = "auto" } = options;
+  return {
+    min,
+    max,
+    wheel: options.wheel ?? "always",
+    pinch: options.pinch ?? true,
+    pan: options.pan ?? true,
+    doubleClick: doubleClick === "auto" ? !clickIsBusy : doubleClick,
+    constrain: options.constrain ?? "contain",
+    bubbleScaling: options.bubbleScaling ?? "sqrt",
+    inertia: options.inertia ?? true,
+    keyboard: options.keyboard ?? true,
+    padding: options.padding ?? 24,
+    initialView: options.initialView
+  };
+};
+var resolveControls = (zoom) => {
+  if (typeof zoom !== "object" || zoom.controls === void 0 || zoom.controls === false) {
+    return null;
+  }
+  const options = zoom.controls === true ? {} : zoom.controls;
+  return { position: options.position ?? "bottom-right", reset: options.reset ?? true };
+};
+var zoomKeyAction = (event) => {
+  if (event.ctrlKey === true || event.metaKey === true || event.altKey === true) return null;
+  switch (event.key) {
+    case "+":
+    case "=":
+      return "in";
+    case "-":
+    case "_":
+      return "out";
+    case "0":
+      return "reset";
+    default:
+      return null;
+  }
+};
+var createZoomFilter = ({ wheel, pinch, pan, doubleClick, onGestureHint }) => (event) => {
+  switch (event.type) {
+    case "wheel": {
+      if (wheel === "never") return false;
+      if (wheel === "always" || event.ctrlKey === true || event.metaKey === true) return true;
+      onGestureHint?.("wheel");
+      return false;
+    }
+    case "touchstart": {
+      const multi = (event.touches?.length ?? 0) >= 2;
+      if (multi) return pinch || pan;
+      if (wheel === "cooperative") {
+        onGestureHint?.("touch");
+        return false;
+      }
+      return pan;
+    }
+    case "dblclick":
+      return doubleClick;
+    case "mousedown":
+      return pan && !event.button;
+    // primary button only
+    default:
+      return !event.button;
+  }
+};
+var clamp = (value, [min, max]) => Math.min(max, Math.max(min, value));
+var resolveZoomTarget = ({
+  target,
+  size,
+  padding,
+  scaleExtent,
+  project,
+  getRegionExtent,
+  focusBounds
+}) => {
+  if (typeof target === "string") {
+    const override = focusBounds?.[target];
+    const extent2 = override ? projectBounds(override, project) : getRegionExtent(target);
+    return extent2 === null ? null : boundsToTransform({ bounds: extent2, size, padding, scaleExtent });
+  }
+  if ("bounds" in target) {
+    const extent2 = projectBounds(target.bounds, project);
+    return extent2 === null ? null : boundsToTransform({ bounds: extent2, size, padding, scaleExtent });
+  }
+  const at = project([target.center[0], target.center[1]]);
+  if (at === null || !Number.isFinite(target.zoom)) return null;
+  const k = clamp(target.zoom, scaleExtent);
+  return { k, x: size.width / 2 - k * at[0], y: size.height / 2 - k * at[1] };
+};
+
+// src/core/drill.ts
+var layerKey = (path, depth = path.length) => JSON.stringify(path.slice(0, depth));
+var samePath = (a, b) => a.length === b.length && a.every((id, i) => id === b[i]);
+var startsWith = (path, prefix) => prefix.length <= path.length && prefix.every((id, i) => id === path[i]);
+var classifyDrill = (from, to) => {
+  if (samePath(from, to)) return "equal";
+  if (startsWith(from, to)) return "up";
+  if (to.length === from.length + 1 && startsWith(to, from)) return "down";
+  if (to.length === from.length && startsWith(to.slice(0, -1), from.slice(0, -1))) return "lateral";
+  return "jump";
+};
+var settledLayers = (path) => Array.from({ length: path.length + 1 }, (_, depth) => ({
+  key: layerKey(path, depth),
+  depth,
+  role: depth === path.length ? "active" : "context"
+}));
+var createDrillState = (path = []) => ({
+  phase: "idle",
+  path,
+  settledPath: path,
+  direction: null,
+  layers: settledLayers(path),
+  flight: "done",
+  flightId: 0,
+  geometry: null,
+  geometryKey: null,
+  savedCameras: {},
+  returnCamera: null,
+  error: null
+});
+var savedCameraFor = (state, path) => state.savedCameras[layerKey(path)] ?? null;
+var layersFor = (current, to, newRole) => {
+  const existing = new Set(current.map((layer) => layer.key));
+  const wanted = settledLayers(to).map(
+    (layer) => !existing.has(layer.key) && layer.role === "active" ? { ...layer, role: newRole } : layer
+  );
+  const wantedKeys = new Set(wanted.map((layer) => layer.key));
+  const leaving = current.filter((layer) => !wantedKeys.has(layer.key)).map((layer) => ({ ...layer, role: "exiting" }));
+  return [...wanted, ...leaving].sort((a, b) => a.depth - b.depth);
+};
+var settleLayers = (layers) => layers.filter((layer) => layer.role !== "exiting").map((layer) => layer.role === "entering" ? { ...layer, role: "active" } : layer);
+var settle = (state) => state.phase === "revealing" || state.direction === "up" ? {
+  ...state,
+  phase: "idle",
+  direction: null,
+  settledPath: state.path,
+  layers: settleLayers(state.layers),
+  flight: "done",
+  geometry: null,
+  geometryKey: null,
+  returnCamera: null
+} : state;
+var cancelled = (state) => ({
+  ...state,
+  phase: "idle",
+  path: state.settledPath,
+  direction: null,
+  layers: settleLayers(state.layers),
+  flight: "done",
+  geometry: null,
+  geometryKey: null,
+  returnCamera: null
+});
+var flyBack = (state) => ({
+  ...cancelled(state),
+  phase: "flying",
+  direction: "up",
+  flight: "pending",
+  flightId: state.flightId + 1,
+  returnCamera: state.returnCamera
+});
+var pruneCameras = (cameras, path) => {
+  const keep = new Set(Array.from({ length: path.length + 1 }, (_, d) => layerKey(path, d)));
+  return Object.fromEntries(Object.entries(cameras).filter(([key]) => keep.has(key)));
+};
+var onDrill = (state, event) => {
+  const start = settle(state);
+  const { to } = event;
+  const from = start.settledPath;
+  const direction = event.direction === "jump" ? "jump" : classifyDrill(from, to);
+  const base = { ...start, error: null };
+  if (start.direction !== null && start.direction !== "up" && samePath(to, start.path))
+    return state;
+  const busy = start.direction !== null;
+  if (direction === "equal") {
+    return busy ? flyBack({ ...base, returnCamera: start.returnCamera }) : base;
+  }
+  if (direction === "up") {
+    return {
+      ...base,
+      phase: "flying",
+      path: to,
+      settledPath: to,
+      direction: "up",
+      layers: layersFor(start.layers, to, "active"),
+      flight: "pending",
+      flightId: start.flightId + 1,
+      geometry: null,
+      geometryKey: null,
+      savedCameras: pruneCameras(start.savedCameras, to),
+      returnCamera: null
+    };
+  }
+  const key = layerKey(to);
+  const cached = event.cached === true;
+  const geometry = cached ? "ready" : "pending";
+  if (direction === "jump") {
+    if (cached) {
+      return {
+        ...base,
+        phase: "idle",
+        path: to,
+        settledPath: to,
+        direction: null,
+        layers: settledLayers(to),
+        flight: "done",
+        flightId: start.flightId + 1,
+        geometry: null,
+        geometryKey: null,
+        savedCameras: pruneCameras(start.savedCameras, to),
+        returnCamera: null
+      };
+    }
+    return {
+      ...base,
+      phase: "loading",
+      path: to,
+      direction: "jump",
+      flight: "done",
+      flightId: start.flightId + 1,
+      geometry: "pending",
+      geometryKey: key,
+      returnCamera: null
+    };
+  }
+  const fresh = !busy;
+  return {
+    ...base,
+    phase: "flying",
+    path: to,
+    direction,
+    flight: "pending",
+    flightId: start.flightId + 1,
+    geometry,
+    geometryKey: key,
+    savedCameras: direction === "down" && fresh && event.camera !== void 0 ? { ...start.savedCameras, [layerKey(from)]: event.camera } : start.savedCameras,
+    returnCamera: fresh ? event.camera ?? null : start.returnCamera
+  };
+};
+var startReveal = (state) => ({
+  ...state,
+  phase: "revealing",
+  layers: layersFor(state.layers, state.path, "entering"),
+  flight: "done"
+});
+var finishJump = (state) => ({
+  ...state,
+  phase: "idle",
+  settledPath: state.path,
+  direction: null,
+  layers: settledLayers(state.path),
+  geometry: null,
+  geometryKey: null,
+  savedCameras: pruneCameras(state.savedCameras, state.path),
+  returnCamera: null
+});
+var drillReducer = (state, event) => {
+  switch (event.type) {
+    case "DRILL":
+      return onDrill(state, event);
+    case "FLIGHT_END": {
+      if (state.phase !== "flying" || event.id !== state.flightId) return state;
+      if (state.direction === "up") return settle(state);
+      if (!event.completed) return cancelled(state);
+      if (state.geometry === "error") return flyBack(state);
+      return state.geometry === "ready" ? startReveal(state) : { ...state, phase: "loading", flight: "done" };
+    }
+    case "GEOMETRY_READY": {
+      if (event.key !== state.geometryKey || state.geometry !== "pending") return state;
+      const ready = { ...state, geometry: "ready" };
+      if (state.phase !== "loading") return ready;
+      return state.direction === "jump" ? finishJump(ready) : startReveal(ready);
+    }
+    case "GEOMETRY_ERROR": {
+      if (event.key !== state.geometryKey || state.geometry !== "pending") return state;
+      const failed = { ...state, geometry: "error", error: event.key };
+      if (state.phase === "flying") return failed;
+      if (state.phase !== "loading") return state;
+      return state.direction === "jump" ? cancelled(failed) : flyBack(failed);
+    }
+    case "REVEAL_END":
+      return state.phase === "revealing" ? settle(state) : state;
+  }
+};
+
+// src/core/drill-levels.ts
+var contextOf = (path) => ({
+  path,
+  parentId: path.at(-1) ?? null,
+  depth: path.length
+});
+var validateLevels = (levels) => {
+  if (levels.length === 0) {
+    throw new Error(
+      "[choropleth] drill: at least one level is required (received an empty array)."
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const level of levels) {
+    if (seen.has(level.id)) {
+      throw new Error(
+        `[choropleth] drill: duplicate level id "${level.id}". Each level needs a unique id.`
+      );
+    }
+    seen.add(level.id);
+  }
+  if (levels[0]?.geography === "inherit") {
+    throw new Error(
+      `[choropleth] drill: the first level ("${levels[0].id}") cannot use geography: "inherit" because it has no parent. Pass its geometry.`
+    );
+  }
+};
+var clampPath = (path, levelCount) => {
+  const max = Math.max(0, levelCount - 1);
+  return path.length <= max ? { path, clamped: false } : { path: path.slice(0, max), clamped: true };
+};
+var buildBreadcrumbs = ({
+  path,
+  rootLabel,
+  getLabel
+}) => [
+  { depth: 0, id: null, label: rootLabel },
+  ...path.map((id, index) => ({
+    depth: index + 1,
+    id,
+    label: getLabel?.({ id, depth: index + 1 }) ?? id
+  }))
+];
+var geographyKeyFor = (levels, path) => {
+  for (let depth = Math.min(path.length, levels.length - 1); depth >= 0; depth--) {
+    const level = levels[depth];
+    if (level === void 0) continue;
+    const ctx = contextOf(path.slice(0, depth));
+    if (level.geographyKey !== void 0) return level.geographyKey(ctx);
+    if (level.geography === "inherit" && depth > 0) continue;
+    return typeof level.geography === "function" ? `${level.id}:${ctx.parentId}` : level.id;
+  }
+  return "";
+};
+var resolveDrillData = (data, ctx) => typeof data === "function" ? data(ctx) : data;
+var drillDirectionBetween = (from, to) => {
+  const direction = classifyDrill(from, to);
+  return direction === "equal" ? null : direction;
+};
+var DEFAULT_LEVEL_CACHE_SIZE = 8;
+var createLruCache = (capacity = DEFAULT_LEVEL_CACHE_SIZE) => {
+  if (!(Number.isInteger(capacity) && capacity >= 1)) {
+    throw new Error(
+      `[choropleth] createLruCache: capacity must be an integer \u2265 1 (received: ${capacity}).`
+    );
+  }
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => {
+      if (!entries.has(key)) return void 0;
+      const value = entries.get(key);
+      entries.delete(key);
+      entries.set(key, value);
+      return value;
+    },
+    has: (key) => entries.has(key),
+    set: (key, value) => {
+      entries.delete(key);
+      entries.set(key, value);
+      if (entries.size > capacity) {
+        const oldest = entries.keys().next().value;
+        if (oldest !== void 0) entries.delete(oldest);
+      }
+    },
+    delete: (key) => void entries.delete(key),
+    clear: () => entries.clear(),
+    get size() {
+      return entries.size;
+    }
+  };
+};
+
+// src/core/drill-intent.ts
+var DRILL_INTENT_MS = 150;
+var createIntentTimer = ({
+  onIntent,
+  delay = DRILL_INTENT_MS,
+  setTimer = (callback, ms) => setTimeout(callback, ms),
+  clearTimer = (handle) => clearTimeout(handle)
+}) => {
+  let current = null;
+  let handle;
+  let armed = false;
+  const cancel = () => {
+    if (armed) clearTimer(handle);
+    armed = false;
+  };
+  return {
+    hover: (key) => {
+      if (key === current) return;
+      cancel();
+      current = key;
+      if (key === null) return;
+      armed = true;
+      handle = setTimer(() => {
+        armed = false;
+        onIntent(key);
+      }, delay);
+    },
+    dispose: () => {
+      cancel();
+      current = null;
+    }
+  };
+};
+var checkDrillStep = ({
+  id,
+  depth,
+  levelId,
+  knownIds,
+  drillable
+}) => {
+  if (knownIds !== void 0 && !knownIds.has(id)) {
+    return { kind: "unknown-id", id, depth, levelId };
+  }
+  if (drillable === false) return { kind: "cannot-drill", id, depth, levelId };
+  return null;
+};
+var formatDrillRequestProblem = (problem, source) => {
+  const where = `level "${problem.levelId}" (depth ${problem.depth})`;
+  return problem.kind === "unknown-id" ? `[choropleth] ${source}: region ${JSON.stringify(problem.id)} does not exist in ${where}. Hint: ids come from \`getFeatureId\` / \`feature.id\`; navigation was ignored.` : `[choropleth] ${source}: region ${JSON.stringify(problem.id)} cannot be drilled into: \`canDrill\` is false for it in ${where}; navigation was ignored.`;
+};
+var formatTooDeepRequest = (path, levelCount, source) => `[choropleth] ${source}: cannot go to ${JSON.stringify(path)}: only ${levelCount} level(s) are defined (max depth ${Math.max(0, levelCount - 1)}); navigation was ignored.`;
+var formatNoIdsDiagnostic = ({
+  featureCount,
+  idCount,
+  levelId,
+  customGetFeatureId
+}) => {
+  if (featureCount === 0 || idCount > 0) return null;
+  const level = levelId === null ? "" : ` in level "${levelId}"`;
+  const hint = customGetFeatureId ? "`getFeatureId` returned `undefined` for every one; check the property it reads." : "none has a `feature.id`; pass `getFeatureId` to read another property.";
+  return `[choropleth] none of the ${featureCount} region(s)${level} has an id, so no data can match: ${hint}`;
+};
+var formatWrongLevelDataHint = ({
+  drillActive,
+  dataIsSelector,
+  dataCount,
+  unmatchedCount,
+  levelId
+}) => {
+  if (!drillActive || dataIsSelector || dataCount === 0 || unmatchedCount < dataCount) return null;
+  const level = levelId === null ? "this level" : `level "${levelId}"`;
+  return `Hint: with \`drill\`, a fixed \`data\` array is used for every level and none of its rows match ${level}. Pass \`data\` as a selector to give each level its own rows: \`data={(ctx) => rowsFor(ctx)}\`.`;
+};
+
+// src/core/drill-chain.ts
+import { geoBounds as geoBounds2, geoPath as geoPath2 } from "d3-geo";
+var boundsToObject = ([[west, south], [east, north]]) => ({
+  type: "MultiPoint",
+  coordinates: [
+    [west, south],
+    [(west + east) / 2, south],
+    [east, south],
+    [east, (south + north) / 2],
+    [east, north],
+    [(west + east) / 2, north],
+    [west, north],
+    [west, (south + north) / 2]
+  ]
+});
+var widerHalf = ([[west, south], [east, north]]) => {
+  if (west <= east)
+    return [
+      [west, south],
+      [east, north]
+    ];
+  return 180 - west >= east + 180 ? [
+    [west, south],
+    [180, north]
+  ] : [
+    [-180, south],
+    [east, north]
+  ];
+};
+var mainBody = (geometry) => {
+  if (geometry === null) return null;
+  const [[west, south], [east, north]] = geoBounds2(geometry);
+  return west > east ? boundsToObject(
+    widerHalf([
+      [west, south],
+      [east, north]
+    ])
+  ) : geometry;
+};
+var buildProjectionChain = ({
+  levels,
+  path,
+  name,
+  width,
+  height,
+  padding,
+  focusBounds,
+  rotate
+}) => {
+  const root = levels[0];
+  const collection = (features) => ({
+    type: "FeatureCollection",
+    features: [...features]
+  });
+  const projections = [
+    createProjection({
+      name,
+      width,
+      height,
+      featureCollection: collection(root?.features ?? []),
+      rotate
+    })
+  ];
+  const factory = projectionFactory(name);
+  const pad = normalizePadding(padding);
+  let missing = null;
+  for (let depth = 1; depth <= path.length; depth++) {
+    const parent = projections[depth - 1];
+    const id = path[depth - 1];
+    if (missing !== null) {
+      projections.push(parent);
+      continue;
+    }
+    const level = levels[depth - 1];
+    const feature2 = level?.features.find((f) => level.idOf(f) === id);
+    const bounds = focusBounds?.[id];
+    const focus = bounds != null ? boundsToObject(widerHalf(bounds)) : feature2 === void 0 ? null : mainBody(getFocusGeometry({ feature: feature2, path: geoPath2(parent) }));
+    if (focus === null) {
+      missing = id;
+      projections.push(parent);
+      continue;
+    }
+    try {
+      projections.push(
+        rebaseProjection({ parent, factory, focus, width, height, padding: pad }).projection
+      );
+    } catch {
+      missing = id;
+      projections.push(parent);
+    }
+  }
+  return { projections, missing };
+};
+
+// src/core/region.ts
+var ALPHA2 = /^[A-Za-z]{2}$/;
+var resolveRegion = (region, presets) => {
+  const entries = typeof region === "string" ? [region] : region;
+  if (entries.length === 0) {
+    throw new Error(
+      `[choropleth] region: the list is empty. Pass a preset (${presetNames(presets)}) or alpha-2 codes.`
+    );
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const preset = Object.hasOwn(presets, entry) ? presets[entry] : void 0;
+    if (preset !== void 0) {
+      for (const id of preset) ids.add(id);
+    } else if (ALPHA2.test(entry)) {
+      ids.add(entry.toUpperCase());
+    } else {
+      throw new Error(
+        `[choropleth] region: unknown "${entry}". Use an alpha-2 code ("ES") or one of the presets: ${presetNames(presets)}.`
+      );
+    }
+  }
+  return ids;
+};
+var presetNames = (presets) => Object.keys(presets).join(", ");
+var centerInBox = ([ring], [[west, south], [east, north]]) => {
+  if (ring === void 0 || ring.length === 0) return false;
+  let minLon = Infinity;
+  let maxLon = -Infinity;
+  let minLat = Infinity;
+  let maxLat = -Infinity;
+  for (const [lon2 = NaN, lat2 = NaN] of ring) {
+    minLon = Math.min(minLon, lon2);
+    maxLon = Math.max(maxLon, lon2);
+    minLat = Math.min(minLat, lat2);
+    maxLat = Math.max(maxLat, lat2);
+  }
+  const lon = (minLon + maxLon) / 2;
+  const lat = (minLat + maxLat) / 2;
+  return lon >= west && lon <= east && lat >= south && lat <= north;
+};
+var dropOverseas = (features, territories) => features.map((feature2) => {
+  const boxes = feature2.id === void 0 ? void 0 : territories[String(feature2.id)];
+  const { geometry } = feature2;
+  if (boxes === void 0 || boxes.length === 0 || geometry.type !== "MultiPolygon")
+    return feature2;
+  const kept = geometry.coordinates.filter(
+    (coordinates) => !boxes.some((box) => centerInBox(coordinates, box))
+  );
+  if (kept.length === geometry.coordinates.length || kept.length === 0) return feature2;
+  const trimmed = { type: "MultiPolygon", coordinates: kept };
+  return { ...feature2, geometry: trimmed };
+});
+var BINS = 360;
+var binOf = (lon) => Math.floor(((lon + 180) % 360 + 360) % 360);
+var markRing = (ring, occupied) => {
+  let previous;
+  for (const [lon] of ring) {
+    if (lon === void 0 || !Number.isFinite(lon)) continue;
+    const at = ((lon + 180) % 360 + 360) % 360;
+    if (previous !== void 0) {
+      const delta = (at - previous + 540) % 360 - 180;
+      const steps = Math.max(1, Math.ceil(Math.abs(delta)));
+      for (let i = 0; i <= steps; i++) {
+        occupied[binOf(previous + delta * i / steps - 180)] = 1;
+      }
+    }
+    occupied[binOf(lon)] = 1;
+    previous = at;
+  }
+};
+var markGeometry = (geometry, occupied) => {
+  if (geometry === null) return;
+  if (geometry.type === "Polygon") {
+    for (const ring of geometry.coordinates) markRing(ring, occupied);
+  } else if (geometry.type === "MultiPolygon") {
+    for (const polygon of geometry.coordinates) {
+      for (const ring of polygon) markRing(ring, occupied);
+    }
+  }
+};
+var regionRotation = (features, points = []) => {
+  const occupied = new Uint8Array(BINS);
+  for (const feature2 of features) markGeometry(feature2.geometry, occupied);
+  for (const [lon] of points) if (Number.isFinite(lon)) occupied[binOf(lon)] = 1;
+  let start = -1;
+  let length = 0;
+  let runStart = -1;
+  for (let i = 0; i < BINS * 2; i++) {
+    if (occupied[i % BINS] === 1) {
+      runStart = -1;
+      continue;
+    }
+    if (runStart === -1) runStart = i;
+    const runLength = Math.min(i - runStart + 1, BINS);
+    if (runLength > length) {
+      length = runLength;
+      start = runStart;
+    }
+  }
+  if (length === 0) return void 0;
+  if (start + length > BINS || start === 0) return void 0;
+  const lambda = -(start + length / 2);
+  return [((lambda + 180) % 360 + 360) % 360 - 180, 0];
+};
+
+export {
+  unwrapGeography,
+  toFeatureCollection,
+  getFocusGeometry,
+  getAnchorPoint,
+  DEFAULT_PADDING,
+  normalizePadding,
+  boundsToTransform,
+  projectBounds,
+  getFocusExtent,
+  FIT_TRANSFORM,
+  isFitTransform,
+  applyTransform,
+  invertTransform,
+  constrainAxis,
+  constrainTransform,
+  preserveView,
+  MIN_FLIGHT_MS,
+  MAX_FLIGHT_MS,
+  DEFAULT_FLIGHT_CURVATURE,
+  transformToZoomView,
+  createZoomInterpolator,
+  flightDuration,
+  INERTIA_TAU_MS,
+  inertiaOffset,
+  INERTIA_MIN_VELOCITY,
+  INERTIA_WINDOW_MS,
+  releaseVelocity,
+  bubbleScale,
+  toViewState,
+  defineTheme,
+  THEMES,
+  isThemeName,
+  resolveTheme,
+  extendTheme,
+  themeToCssVars,
+  en,
+  es,
+  resolveLabels,
+  joinData,
+  DEFAULT_CLASSES,
+  finiteValues,
+  computeThresholds,
+  SEQUENTIAL_PALETTES,
+  DIVERGING_PALETTES,
+  CATEGORICAL_PALETTES,
+  DEFAULT_EMPTY_FILL,
+  createColorScale,
+  projectionFactory,
+  DEFAULT_PROJECTION,
+  createProjection,
+  DEFAULT_ASPECT_RATIO,
+  computeAspectRatio,
+  relativeTransform,
+  rebaseProjection,
+  defaultFormatValue,
+  classIndex,
+  buildLegend,
+  createBorders,
+  formatJoinDiagnostics,
+  createCategoricalScale,
+  buildCategoricalLegend,
+  DEFAULT_MAX_RADIUS,
+  createRadiusScale,
+  buildSizeLegend,
+  DEFAULT_BUBBLE_FILL,
+  resolveVariant,
+  DEFAULT_FOCUS_BOUNDS,
+  DEFAULT_ZOOM_MIN,
+  DEFAULT_ZOOM_MAX,
+  resolveZoomOptions,
+  resolveControls,
+  zoomKeyAction,
+  createZoomFilter,
+  resolveZoomTarget,
+  layerKey,
+  classifyDrill,
+  createDrillState,
+  savedCameraFor,
+  drillReducer,
+  contextOf,
+  validateLevels,
+  clampPath,
+  buildBreadcrumbs,
+  geographyKeyFor,
+  resolveDrillData,
+  drillDirectionBetween,
+  DEFAULT_LEVEL_CACHE_SIZE,
+  createLruCache,
+  DRILL_INTENT_MS,
+  createIntentTimer,
+  checkDrillStep,
+  formatDrillRequestProblem,
+  formatTooDeepRequest,
+  formatNoIdsDiagnostic,
+  formatWrongLevelDataHint,
+  buildProjectionChain,
+  resolveRegion,
+  dropOverseas,
+  regionRotation
+};
+//# sourceMappingURL=chunk-ZN6SLXL3.js.map