react-threat-map 0.1.0

package/dist/index.js

@@ -0,0 +1,1321 @@
+import { lookupRegionCode, UNKNOWN_REGION, RegionIndex } from './chunk-43FECBAY.js';
+export { UNKNOWN_REGION, getRegionById, listRegions, lookupRegionCode } from './chunk-43FECBAY.js';
+import './chunk-PM2OVFS5.js';
+import { useRef, useMemo, useCallback, useState, useEffect } from 'react';
+import { geoOrthographic, geoMercator, geoEquirectangular, geoNaturalEarth1, geoPath, geoGraticule10, geoInterpolate } from 'd3-geo';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/config.ts
+var defaultTheme = Object.freeze({
+  ocean: "#080c18",
+  land: "#18213a",
+  border: "#2b3858",
+  borderWidth: 0.5,
+  stateBorder: "#212c4a",
+  stateBorderWidth: 0.4,
+  severityColors: Object.freeze({
+    low: "#22d3ee",
+    medium: "#fbbf24",
+    high: "#fb7185",
+    critical: "#ef4444"
+  }),
+  headColor: "#ffffff",
+  originColor: "#64748b",
+  impactColor: "#ffffff"
+});
+var defaultLineStyle = Object.freeze({
+  curvature: 0.22,
+  width: 1.2,
+  trackOpacity: 0.28,
+  trailOpacity: 0.95,
+  trailLength: 0.18,
+  glow: 0.5,
+  headRadius: 2,
+  showOrigin: true,
+  showImpact: true,
+  segments: 48
+});
+var defaultAnimation = Object.freeze({
+  enabled: true,
+  speed: 0.5,
+  easing: "easeInOutQuad",
+  stagger: 1,
+  loop: true,
+  fadeIn: 400,
+  fadeOut: 600,
+  respectReducedMotion: true
+});
+var defaultRegions = Object.freeze({
+  showCountries: true,
+  showStates: false,
+  showGraticule: false,
+  graticuleColor: "rgba(255,255,255,0.05)",
+  showSphere: true
+});
+
+// src/geo/resolve.ts
+function isLatLng(location) {
+  return typeof location === "object" && location !== null && "lat" in location && "lng" in location;
+}
+function isValidCoordinate(point) {
+  return Number.isFinite(point.lat) && Number.isFinite(point.lng) && point.lat >= -90 && point.lat <= 90 && point.lng >= -180 && point.lng <= 180;
+}
+function resolveLocation(location, index, preferStates = true) {
+  if (typeof location === "string") {
+    const entry = lookupRegionCode(location);
+    if (!entry) {
+      return {
+        ok: false,
+        reason: `Unknown region code "${location}". Expected an ISO 3166-1 alpha-2/alpha-3 country code (e.g. "FR", "FRA") or an ISO 3166-2 US state code (e.g. "US-CA").`
+      };
+    }
+    return { ok: true, value: { point: entry.anchor, region: toRegion(entry) } };
+  }
+  if (!isLatLng(location)) {
+    return {
+      ok: false,
+      reason: `Invalid location ${JSON.stringify(location)}. Expected a region code string or a {lat, lng} object.`
+    };
+  }
+  const point = { lat: location.lat, lng: location.lng };
+  if (!isValidCoordinate(point)) {
+    return {
+      ok: false,
+      reason: `Invalid coordinates {lat: ${location.lat}, lng: ${location.lng}}. Latitude must be within [-90, 90] and longitude within [-180, 180].`
+    };
+  }
+  if (location.region) {
+    const entry = lookupRegionCode(location.region);
+    if (entry) return { ok: true, value: { point, region: toRegion(entry) } };
+  }
+  const region = index ? index.resolve(point, preferStates) : UNKNOWN_REGION;
+  return { ok: true, value: { point, region } };
+}
+function toRegion(entry) {
+  return { id: entry.id, name: entry.name, kind: entry.kind, countryCode: entry.countryCode };
+}
+
+// src/utils/merge.ts
+function mergeDefined(defaults, overrides) {
+  if (!overrides) return { ...defaults };
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const value = overrides[key];
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/aggregation/keys.ts
+var SEVERITY_ORDER = ["low", "medium", "high", "critical"];
+var SEVERITY_RANK = new Map(SEVERITY_ORDER.map((s, i) => [s, i]));
+function severityRank(severity) {
+  return SEVERITY_RANK.get(severity) ?? 1;
+}
+function maxSeverity(severities) {
+  let best = severities[0] ?? "medium";
+  let bestRank = severityRank(best);
+  for (let i = 1; i < severities.length; i++) {
+    const current = severities[i];
+    const rank = severityRank(current);
+    if (rank > bestRank) {
+      best = current;
+      bestRank = rank;
+    }
+  }
+  return best;
+}
+function regionKey(region, granularity) {
+  if (region.kind === "unknown") return region.id;
+  if (granularity === "country") {
+    return region.countryCode;
+  }
+  return region.id;
+}
+
+// src/aggregation/scale.ts
+var MAX_INTENSITY = 6;
+var defaultIntensityScale = (count) => {
+  if (!Number.isFinite(count) || count <= 1) return 1;
+  const intensity = 1 + Math.log2(count) * 0.5;
+  return Math.min(intensity, MAX_INTENSITY);
+};
+function clampIntensity(value) {
+  if (Number.isNaN(value)) return 1;
+  return Math.max(0, Math.min(value, MAX_INTENSITY));
+}
+
+// src/aggregation/aggregate.ts
+var defaultAggregation = Object.freeze({
+  enabled: true,
+  granularity: "auto",
+  groupBy: "origin-destination",
+  minCount: 2,
+  scale: defaultIntensityScale,
+  severity: maxSeverity
+});
+function aggregateAttacks(attacks, options = {}) {
+  const { index = null, onError } = options;
+  const config = resolveConfig(options.config);
+  const prepared = prepareAll(attacks, index, config.granularity, onError);
+  if (!config.enabled) {
+    return sortThreats(prepared.map((p, i) => toSoloThreat(p, i)));
+  }
+  const { groups, ungrouped } = groupAll(prepared, config);
+  const threats = [];
+  for (const p of ungrouped) {
+    threats.push(toSoloThreat(p, threats.length));
+  }
+  for (const group of groups) {
+    if (group.members.length < config.minCount) {
+      for (const p of group.members) threats.push(toSoloThreat(p, threats.length));
+    } else {
+      threats.push(collapse(group, config));
+    }
+  }
+  const sorted = sortThreats(threats);
+  return config.maxGroups != null && config.maxGroups >= 0 ? sorted.slice(0, config.maxGroups) : sorted;
+}
+function resolveConfig(config) {
+  const base = defaultAggregation;
+  if (config === false) {
+    return { ...base, enabled: false };
+  }
+  return mergeDefined(base, config);
+}
+function prepareAll(attacks, index, granularity, onError) {
+  const preferStates = granularity !== "country";
+  const out = [];
+  for (const attack of attacks) {
+    const from = resolveLocation(attack.from, index, preferStates);
+    if (!from.ok) {
+      onError?.(`Could not resolve attack origin: ${from.reason}`, attack);
+      continue;
+    }
+    const to = resolveLocation(attack.to, index, preferStates);
+    if (!to.ok) {
+      onError?.(`Could not resolve attack destination: ${to.reason}`, attack);
+      continue;
+    }
+    const rawWeight = attack.weight ?? 1;
+    out.push({
+      attack,
+      from: from.value.point,
+      to: to.value.point,
+      fromRegion: from.value.region,
+      toRegion: to.value.region,
+      // A non-finite or negative weight would poison totalWeight and, through
+      // it, the intensity scale and the maxGroups ordering.
+      weight: Number.isFinite(rawWeight) && rawWeight > 0 ? rawWeight : 1,
+      severity: attack.severity ?? "medium"
+    });
+  }
+  return out;
+}
+function groupAll(prepared, config) {
+  const groups = /* @__PURE__ */ new Map();
+  const ungrouped = [];
+  for (const p of prepared) {
+    const key = deriveKey(p, config);
+    if (key === null) {
+      ungrouped.push(p);
+      continue;
+    }
+    let group = groups.get(key);
+    if (!group) {
+      group = { key, members: [], totalWeight: 0 };
+      groups.set(key, group);
+    }
+    group.members.push(p);
+    group.totalWeight += p.weight;
+  }
+  return { groups: [...groups.values()], ungrouped };
+}
+function deriveKey(p, config) {
+  if (config.key) {
+    return config.key(p.attack, p.fromRegion, p.toRegion);
+  }
+  const origin = regionKey(p.fromRegion, config.granularity);
+  if (config.groupBy === "origin") return origin;
+  const destination = regionKey(p.toRegion, config.granularity);
+  return `${origin}>${destination}`;
+}
+function collapse(group, config) {
+  const members = group.members;
+  const first = members[0];
+  const representative = config.groupBy === "origin" ? dominantDestination(members) : first;
+  const count = members.length;
+  const severity = config.severity(members.map((m) => m.severity));
+  const intensity = clampIntensity(config.scale(count, group.totalWeight));
+  return {
+    id: group.key,
+    // Origin is the shared property of the group, so any member's coordinate
+    // would do — but averaging them puts the line's tail at the centre of where
+    // the attacks actually came from, which reads better than snapping to one
+    // arbitrary member or to the region's anchor.
+    from: meanPoint(members.map((m) => m.from)),
+    to: representative.to,
+    fromRegion: first.fromRegion,
+    toRegion: representative.toRegion,
+    count,
+    totalWeight: group.totalWeight,
+    severity,
+    intensity,
+    attacks: members.map((m) => m.attack)
+  };
+}
+function dominantDestination(members) {
+  const weightByRegion = /* @__PURE__ */ new Map();
+  for (const m of members) {
+    weightByRegion.set(m.toRegion.id, (weightByRegion.get(m.toRegion.id) ?? 0) + m.weight);
+  }
+  let bestId = "";
+  let bestWeight = -1;
+  for (const [id, weight] of weightByRegion) {
+    if (weight > bestWeight || weight === bestWeight && id < bestId) {
+      bestWeight = weight;
+      bestId = id;
+    }
+  }
+  return members.find((m) => m.toRegion.id === bestId);
+}
+function meanPoint(points) {
+  if (points.length === 1) return points[0];
+  let latSum = 0;
+  let x = 0;
+  let y = 0;
+  for (const p of points) {
+    latSum += p.lat;
+    const rad = p.lng * Math.PI / 180;
+    x += Math.cos(rad);
+    y += Math.sin(rad);
+  }
+  const lat = latSum / points.length;
+  if (Math.abs(x) < 1e-12 && Math.abs(y) < 1e-12) {
+    return { lat, lng: points[0].lng };
+  }
+  return { lat, lng: Math.atan2(y, x) * 180 / Math.PI };
+}
+function toSoloThreat(p, ordinal) {
+  return {
+    id: attackId(p.attack, ordinal),
+    from: p.from,
+    to: p.to,
+    fromRegion: p.fromRegion,
+    toRegion: p.toRegion,
+    count: 1,
+    totalWeight: p.weight,
+    severity: p.severity,
+    intensity: 1,
+    attacks: [p.attack]
+  };
+}
+function attackId(attack, ordinal) {
+  if (attack.id) return attack.id;
+  const from = typeof attack.from === "string" ? attack.from : `${attack.from.lat},${attack.from.lng}`;
+  const to = typeof attack.to === "string" ? attack.to : `${attack.to.lat},${attack.to.lng}`;
+  return `${from}>${to}@${attack.timestamp ?? ordinal}`;
+}
+function sortThreats(threats) {
+  return threats.sort((a, b) => b.totalWeight - a.totalWeight || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+var factories = Object.freeze({
+  naturalEarth1: () => geoNaturalEarth1(),
+  equirectangular: () => geoEquirectangular(),
+  mercator: () => geoMercator(),
+  orthographic: () => geoOrthographic()
+});
+var aspectRatios = Object.freeze({
+  naturalEarth1: 0.5,
+  equirectangular: 0.5,
+  // Mercator is infinite at the poles, so it is clipped to ~±85° — which is
+  // very nearly square.
+  mercator: 0.72,
+  orthographic: 1
+});
+function ratioFor(spec) {
+  return typeof spec === "string" ? aspectRatios[spec] ?? 0.5 : 0.5;
+}
+function defaultHeightFor(spec, width) {
+  return Math.round(width * ratioFor(spec));
+}
+function aspectRatioFor(spec) {
+  return 1 / ratioFor(spec);
+}
+var SPHERE = { type: "Sphere" };
+function createProjection(spec, width, height) {
+  const projection = typeof spec === "string" ? (factories[spec] ?? factories.naturalEarth1)() : spec;
+  if (typeof projection.fitExtent !== "function") return projection;
+  const w = Math.max(1, width);
+  const h = Math.max(1, height);
+  try {
+    return projection.fitExtent(
+      [
+        [0, 0],
+        [w, h]
+      ],
+      SPHERE
+    );
+  } catch {
+    return projection;
+  }
+}
+function useElementSize(ref, enabled = true) {
+  const [size, setSize] = useState(null);
+  useEffect(() => {
+    if (!enabled) return;
+    const element = ref.current;
+    if (!element) return;
+    if (typeof ResizeObserver === "undefined") {
+      const rect = element.getBoundingClientRect();
+      setSize({ width: rect.width, height: rect.height });
+      return;
+    }
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+      const { width, height } = entry.contentRect;
+      setSize(
+        (previous) => previous && previous.width === width && previous.height === height ? previous : { width, height }
+      );
+    });
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, [ref, enabled]);
+  return size;
+}
+var EMPTY = Object.freeze({ geo: null, index: null, loading: true });
+function useGeoData(source, wantStates, onError) {
+  const [state, setState] = useState(EMPTY);
+  useEffect(() => {
+    let cancelled = false;
+    const apply = (geo) => {
+      if (cancelled) return;
+      setState({ geo, index: new RegionIndex(geo), loading: false });
+    };
+    const fail = (cause) => {
+      if (cancelled) return;
+      setState({ geo: null, index: null, loading: false });
+      onError?.({
+        kind: "geo-load",
+        message: "Failed to load map geometry. The map will render without boundaries.",
+        cause
+      });
+    };
+    if (source && typeof source !== "function") {
+      apply(source);
+      return;
+    }
+    setState((previous) => previous.loading ? previous : { ...previous, loading: true });
+    const load = source ?? (() => import('./geo.js').then((m) => m.loadGeoData({ states: wantStates })));
+    Promise.resolve().then(load).then(apply).catch(fail);
+    return () => {
+      cancelled = true;
+    };
+  }, [source, wantStates]);
+  return state;
+}
+var MAX_PIXEL_RATIO = 2;
+function currentRatio() {
+  if (typeof window === "undefined") return 1;
+  return Math.min(window.devicePixelRatio || 1, MAX_PIXEL_RATIO);
+}
+function usePixelRatio() {
+  const [ratio, setRatio] = useState(currentRatio);
+  useEffect(() => {
+    if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+    let query;
+    const update = () => {
+      setRatio(currentRatio());
+      listen();
+    };
+    const listen = () => {
+      query = window.matchMedia(`(resolution: ${window.devicePixelRatio}dppx)`);
+      query.addEventListener("change", update, { once: true });
+    };
+    listen();
+    return () => query?.removeEventListener("change", update);
+  }, []);
+  return ratio;
+}
+var QUERY = "(prefers-reduced-motion: reduce)";
+function useReducedMotion() {
+  const [reduced, setReduced] = useState(false);
+  useEffect(() => {
+    if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+    const query = window.matchMedia(QUERY);
+    setReduced(query.matches);
+    const update = (event) => setReduced(event.matches);
+    query.addEventListener("change", update);
+    return () => query.removeEventListener("change", update);
+  }, []);
+  return reduced;
+}
+function drawBaseMap(options) {
+  const { ctx, width, height, projection, geo, theme, regions } = options;
+  ctx.clearRect(0, 0, width, height);
+  const path = geoPath(projection, ctx);
+  drawOcean(ctx, width, height, theme, regions, path);
+  if (regions.showGraticule) {
+    ctx.beginPath();
+    path(geoGraticule10());
+    ctx.strokeStyle = regions.graticuleColor;
+    ctx.lineWidth = 0.5;
+    ctx.stroke();
+  }
+  if (!geo) return;
+  if (regions.showCountries) {
+    drawFeatures(options, path, geo.countries.features, theme.border, theme.borderWidth);
+  }
+  if (regions.showStates && geo.states) {
+    drawFeatures(options, path, geo.states.features, theme.stateBorder, theme.stateBorderWidth);
+  }
+}
+function drawOcean(ctx, width, height, theme, regions, path) {
+  if (regions.showSphere) {
+    ctx.beginPath();
+    path({ type: "Sphere" });
+    ctx.fillStyle = theme.ocean;
+    ctx.fill();
+    return;
+  }
+  ctx.fillStyle = theme.ocean;
+  ctx.fillRect(0, 0, width, height);
+}
+function drawFeatures(options, path, features, borderColor, borderWidth) {
+  const { ctx, theme, renderRegion, weights, onError } = options;
+  let hookFailed = false;
+  const batched = [];
+  for (const featureItem of features) {
+    if (renderRegion && !hookFailed) {
+      try {
+        const handled = renderRegion(ctx, {
+          feature: featureItem,
+          id: featureItem.id,
+          kind: featureItem.properties.kind,
+          path: (f) => path(f),
+          theme,
+          weight: weights?.get(featureItem.id) ?? 0
+        });
+        if (handled === true) continue;
+      } catch (error) {
+        hookFailed = true;
+        onError?.("renderRegion threw; falling back to the built-in renderer.", error);
+      }
+    }
+    batched.push(featureItem);
+  }
+  if (batched.length === 0) return;
+  ctx.beginPath();
+  for (const featureItem of batched) {
+    path(featureItem);
+  }
+  ctx.fillStyle = theme.land;
+  ctx.fill();
+  if (borderWidth > 0) {
+    ctx.strokeStyle = borderColor;
+    ctx.lineWidth = borderWidth;
+    ctx.lineJoin = "round";
+    ctx.stroke();
+  }
+}
+function BaseMapCanvas(props) {
+  const canvasRef = useRef(null);
+  const { width, height, pixelRatio, projection, geo, theme, regions, renderRegion, weights, onError } = props;
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas || !projection || width <= 0 || height <= 0) return;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      onError?.("Could not acquire a 2D canvas context; the base map will not render.", void 0);
+      return;
+    }
+    ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+    drawBaseMap({ ctx, width, height, projection, geo, theme, regions, renderRegion, weights, onError });
+  }, [width, height, pixelRatio, projection, geo, theme, regions, renderRegion, weights, onError]);
+  return /* @__PURE__ */ jsx(
+    "canvas",
+    {
+      ref: canvasRef,
+      width: Math.max(1, Math.round(width * pixelRatio)),
+      height: Math.max(1, Math.round(height * pixelRatio)),
+      style: { position: "absolute", inset: 0, width: "100%", height: "100%" },
+      "aria-hidden": "true"
+    }
+  );
+}
+function buildArc(from, to, projection, curvature, segments, maxLift = Infinity) {
+  const steps = Math.max(2, Math.floor(segments));
+  const count = steps + 1;
+  const a = [from.lng, from.lat];
+  const b = [to.lng, to.lat];
+  const startPx = projection(a);
+  const endPx = projection(b);
+  if (!startPx || !endPx || !isFinitePoint(startPx) || !isFinitePoint(endPx)) return null;
+  const dx = endPx[0] - startPx[0];
+  const dy = endPx[1] - startPx[1];
+  const chord = Math.hypot(dx, dy);
+  const nx = chord > 0 ? -dy / chord : 0;
+  const ny = chord > 0 ? dx / chord : 0;
+  const rawLift = chord * curvature;
+  const lift = Math.sign(rawLift) * Math.min(Math.abs(rawLift), maxLift);
+  const interpolate = geoInterpolate(a, b);
+  const points = new Float32Array(count * 2);
+  let breakAt = -1;
+  let prevX = 0;
+  let written = 0;
+  for (let i = 0; i < count; i++) {
+    const t = i / steps;
+    const projected = projection(interpolate(t));
+    if (!projected || !isFinitePoint(projected)) {
+      const x2 = startPx[0] + dx * t;
+      const y2 = startPx[1] + dy * t;
+      points[i * 2] = x2;
+      points[i * 2 + 1] = y2;
+      prevX = x2;
+      written++;
+      continue;
+    }
+    const offset = Math.sin(Math.PI * t) * lift;
+    const x = projected[0] + nx * offset;
+    const y = projected[1] + ny * offset;
+    if (written > 0 && breakAt === -1 && Math.abs(x - prevX) > ANTIMERIDIAN_JUMP) {
+      breakAt = i;
+    }
+    points[i * 2] = x;
+    points[i * 2 + 1] = y;
+    prevX = x;
+    written++;
+  }
+  const { distances, length } = measure(points, count, breakAt);
+  return { points, breakAt, distances, length };
+}
+var ANTIMERIDIAN_JUMP = 180;
+function isFinitePoint(p) {
+  return Number.isFinite(p[0]) && Number.isFinite(p[1]);
+}
+function measure(points, count, breakAt) {
+  const distances = new Float32Array(count);
+  let total = 0;
+  for (let i = 1; i < count; i++) {
+    if (i !== breakAt) {
+      const dx = points[i * 2] - points[(i - 1) * 2];
+      const dy = points[i * 2 + 1] - points[(i - 1) * 2 + 1];
+      total += Math.hypot(dx, dy);
+    }
+    distances[i] = total;
+  }
+  return { distances, length: total };
+}
+function pointAt(geometry, t, out) {
+  const { points, distances, length } = geometry;
+  const count = distances.length;
+  const clamped = Math.max(0, Math.min(1, t));
+  const target = clamped * length;
+  if (length === 0) {
+    out[0] = points[0];
+    out[1] = points[1];
+    return;
+  }
+  const i = upperBound(distances, target);
+  if (i <= 0) {
+    out[0] = points[0];
+    out[1] = points[1];
+    return;
+  }
+  if (i >= count) {
+    out[0] = points[(count - 1) * 2];
+    out[1] = points[(count - 1) * 2 + 1];
+    return;
+  }
+  const d0 = distances[i - 1];
+  const d1 = distances[i];
+  const span = d1 - d0;
+  const f = span > 0 ? (target - d0) / span : 0;
+  const x0 = points[(i - 1) * 2];
+  const y0 = points[(i - 1) * 2 + 1];
+  const x1 = points[i * 2];
+  const y1 = points[i * 2 + 1];
+  out[0] = x0 + (x1 - x0) * f;
+  out[1] = y0 + (y1 - y0) * f;
+}
+function upperBound(distances, target) {
+  let low = 0;
+  let high = distances.length - 1;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if (distances[mid] < target) low = mid + 1;
+    else high = mid;
+  }
+  return low;
+}
+
+// src/render/drawThreats.ts
+var buckets = /* @__PURE__ */ new Map();
+var IMPACT_WINDOW = 0.12;
+var IMPACT_STEPS = 6;
+var IMPACT_RADIUS = 9;
+var scratch = new Float32Array(2);
+var ALPHA_STEPS = 16;
+function drawThreats(options) {
+  const { ctx, width, height, threats, theme, line, renderThreat, onError } = options;
+  ctx.clearRect(0, 0, width, height);
+  ctx.lineCap = "round";
+  ctx.lineJoin = "round";
+  buckets.clear();
+  const decorations = { origins: /* @__PURE__ */ new Map(), impacts: /* @__PURE__ */ new Map() };
+  let hookFailed = false;
+  for (const renderable of threats) {
+    if (renderable.alpha <= 0) continue;
+    if (renderThreat && !hookFailed) {
+      const handled = runHook(options, renderable, () => {
+        hookFailed = true;
+      });
+      if (handled) continue;
+    }
+    accumulate(renderable, theme, line);
+    accumulateDecorations(renderable, line, decorations);
+  }
+  paint(ctx, line, theme);
+  paintDecorations(ctx, theme, decorations);
+  if (hookFailed) {
+    onError?.("renderThreat threw; falling back to the built-in renderer.", void 0);
+  }
+}
+function runHook(options, renderable, markFailed) {
+  const { ctx, theme, line, pixelRatio, elapsed, renderThreat } = options;
+  ctx.save();
+  try {
+    const handled = renderThreat(ctx, {
+      threat: renderable.threat,
+      points: renderable.geometry.points,
+      progress: renderable.progress,
+      alpha: renderable.alpha,
+      theme,
+      line,
+      pixelRatio,
+      elapsed
+    });
+    return handled === true;
+  } catch {
+    markFailed();
+    return false;
+  } finally {
+    ctx.restore();
+  }
+}
+function colorFor(threat, theme) {
+  return theme.severityColors[threat.severity] ?? theme.severityColors.medium ?? "#fbbf24";
+}
+function accumulate(renderable, theme, line) {
+  const { threat, geometry, progress, alpha } = renderable;
+  const color = colorFor(threat, theme);
+  const rawWidth = line.width * threat.intensity;
+  const width = Math.max(0.25, Math.round(rawWidth * 2) / 2);
+  const alphaStep = Math.max(1, Math.round(alpha * ALPHA_STEPS));
+  const key = `${color}|${width}|${alphaStep}`;
+  let bucket = buckets.get(key);
+  if (!bucket) {
+    bucket = {
+      color,
+      width,
+      alpha: alphaStep / ALPHA_STEPS,
+      track: new Path2D(),
+      trail: new Path2D(),
+      heads: new Path2D(),
+      hasTrack: false,
+      hasTrail: false,
+      hasHeads: false
+    };
+    buckets.set(key, bucket);
+  }
+  appendPolyline(bucket.track, geometry, 0, 1);
+  bucket.hasTrack = true;
+  if (line.trailLength > 0 && progress > 0) {
+    const start = Math.max(0, progress - line.trailLength);
+    appendPolyline(bucket.trail, geometry, start, progress);
+    bucket.hasTrail = true;
+  }
+  if (line.headRadius > 0) {
+    pointAt(geometry, progress, scratch);
+    const radius = line.headRadius * Math.max(1, Math.sqrt(threat.intensity));
+    bucket.heads.moveTo(scratch[0] + radius, scratch[1]);
+    bucket.heads.arc(scratch[0], scratch[1], radius, 0, Math.PI * 2);
+    bucket.hasHeads = true;
+  }
+}
+function accumulateDecorations(renderable, line, decorations) {
+  const { geometry, progress, threat, alpha } = renderable;
+  const { points } = geometry;
+  const alphaStep = Math.max(1, Math.round(alpha * ALPHA_STEPS));
+  if (line.showOrigin) {
+    const radius2 = Math.max(1, 1.5 * Math.sqrt(threat.intensity));
+    const x2 = points[0];
+    const y2 = points[1];
+    let origins = decorations.origins.get(alphaStep);
+    if (!origins) {
+      origins = new Path2D();
+      decorations.origins.set(alphaStep, origins);
+    }
+    origins.moveTo(x2 + radius2, y2);
+    origins.arc(x2, y2, radius2, 0, Math.PI * 2);
+  }
+  if (!line.showImpact || progress < 1 - IMPACT_WINDOW) return;
+  const phase = (progress - (1 - IMPACT_WINDOW)) / IMPACT_WINDOW;
+  const phaseStep = Math.min(IMPACT_STEPS - 1, Math.floor(phase * IMPACT_STEPS));
+  const last = points.length - 2;
+  const x = points[last];
+  const y = points[last + 1];
+  const radius = Math.max(0.5, phase * IMPACT_RADIUS * Math.sqrt(threat.intensity));
+  const key = `${phaseStep}:${alphaStep}`;
+  let path = decorations.impacts.get(key);
+  if (!path) {
+    path = new Path2D();
+    decorations.impacts.set(key, path);
+  }
+  path.moveTo(x + radius, y);
+  path.arc(x, y, radius, 0, Math.PI * 2);
+}
+function paintDecorations(ctx, theme, decorations) {
+  if (decorations.origins.size > 0) {
+    ctx.fillStyle = theme.originColor;
+    for (const [alphaStep, path] of decorations.origins) {
+      ctx.globalAlpha = 0.9 * (alphaStep / ALPHA_STEPS);
+      ctx.fill(path);
+    }
+  }
+  if (decorations.impacts.size > 0) {
+    const previousComposite = ctx.globalCompositeOperation;
+    ctx.globalCompositeOperation = "lighter";
+    ctx.strokeStyle = theme.impactColor;
+    ctx.lineWidth = 1;
+    for (const [key, path] of decorations.impacts) {
+      const [phaseStep, alphaStep] = key.split(":");
+      const phase = (Number(phaseStep) + 0.5) / IMPACT_STEPS;
+      const fade = Number(alphaStep) / ALPHA_STEPS;
+      ctx.globalAlpha = (1 - phase) * 0.7 * fade;
+      ctx.stroke(path);
+    }
+    ctx.globalCompositeOperation = previousComposite;
+  }
+  ctx.globalAlpha = 1;
+}
+function appendPolyline(path, geometry, from, to) {
+  const { points, distances, length, breakAt } = geometry;
+  const count = distances.length;
+  if (count < 2 || length <= 0) return;
+  const startDistance = from * length;
+  const endDistance = to * length;
+  let started = false;
+  for (let i = 0; i < count; i++) {
+    const distance = distances[i];
+    if (distance < startDistance) {
+      continue;
+    }
+    if (distance > endDistance) break;
+    const x = points[i * 2];
+    const y = points[i * 2 + 1];
+    if (!started) {
+      pointAt(geometry, from, scratch);
+      path.moveTo(scratch[0], scratch[1]);
+      started = true;
+    }
+    if (i === breakAt) {
+      path.moveTo(x, y);
+      continue;
+    }
+    path.lineTo(x, y);
+  }
+  if (!started) {
+    pointAt(geometry, from, scratch);
+    path.moveTo(scratch[0], scratch[1]);
+  }
+  pointAt(geometry, to, scratch);
+  path.lineTo(scratch[0], scratch[1]);
+}
+function paint(ctx, line, theme) {
+  const previousComposite = ctx.globalCompositeOperation;
+  ctx.globalCompositeOperation = "lighter";
+  for (const bucket of buckets.values()) {
+    const alpha = bucket.alpha;
+    if (bucket.hasTrack && line.trackOpacity > 0) {
+      ctx.globalAlpha = line.trackOpacity * alpha;
+      ctx.strokeStyle = bucket.color;
+      ctx.lineWidth = bucket.width;
+      ctx.stroke(bucket.track);
+    }
+    if (bucket.hasTrail) {
+      if (line.glow > 0) {
+        ctx.globalAlpha = line.trailOpacity * alpha * 0.22 * line.glow;
+        ctx.strokeStyle = bucket.color;
+        ctx.lineWidth = bucket.width * 4;
+        ctx.stroke(bucket.trail);
+      }
+      ctx.globalAlpha = line.trailOpacity * alpha;
+      ctx.strokeStyle = bucket.color;
+      ctx.lineWidth = bucket.width;
+      ctx.stroke(bucket.trail);
+    }
+    if (bucket.hasHeads) {
+      ctx.globalAlpha = alpha;
+      ctx.fillStyle = theme.headColor ?? bucket.color;
+      ctx.fill(bucket.heads);
+    }
+  }
+  ctx.globalAlpha = 1;
+  ctx.globalCompositeOperation = previousComposite;
+}
+
+// src/render/easing.ts
+var easings = Object.freeze({
+  linear: (t) => t,
+  easeInQuad: (t) => t * t,
+  easeOutQuad: (t) => t * (2 - t),
+  easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+  easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1
+});
+function resolveEasing(easing) {
+  if (typeof easing === "function") {
+    return (t) => {
+      const eased = easing(t);
+      return Number.isFinite(eased) ? Math.max(0, Math.min(1, eased)) : t;
+    };
+  }
+  return easings[easing] ?? easings.linear;
+}
+
+// src/render/hitTest.ts
+var HIT_TOLERANCE = 5;
+function distanceSquaredToSegment(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const lengthSquared = dx * dx + dy * dy;
+  if (lengthSquared === 0) {
+    const cx2 = px - ax;
+    const cy2 = py - ay;
+    return cx2 * cx2 + cy2 * cy2;
+  }
+  let t = ((px - ax) * dx + (py - ay) * dy) / lengthSquared;
+  t = t < 0 ? 0 : t > 1 ? 1 : t;
+  const cx = px - (ax + t * dx);
+  const cy = py - (ay + t * dy);
+  return cx * cx + cy * cy;
+}
+function distanceToArcSquared(geometry, x, y, tolerance) {
+  const { points, breakAt, distances } = geometry;
+  const count = distances.length;
+  if (count < 2) return Infinity;
+  let best = Infinity;
+  for (let i = 1; i < count; i++) {
+    if (i === breakAt) continue;
+    const ax = points[(i - 1) * 2];
+    const ay = points[(i - 1) * 2 + 1];
+    const bx = points[i * 2];
+    const by = points[i * 2 + 1];
+    if (ax < x - tolerance && bx < x - tolerance || ax > x + tolerance && bx > x + tolerance || ay < y - tolerance && by < y - tolerance || ay > y + tolerance && by > y + tolerance) {
+      continue;
+    }
+    const d = distanceSquaredToSegment(x, y, ax, ay, bx, by);
+    if (d < best) best = d;
+  }
+  return best;
+}
+function hitTest(candidates2, x, y, baseWidth) {
+  let best = null;
+  let bestDistance = Infinity;
+  for (const candidate of candidates2) {
+    const tolerance = HIT_TOLERANCE + baseWidth * candidate.intensity / 2;
+    const distance = distanceToArcSquared(candidate.geometry, x, y, tolerance);
+    if (distance <= tolerance * tolerance && distance < bestDistance) {
+      bestDistance = distance;
+      best = candidate.value;
+    }
+  }
+  return best;
+}
+
+// src/hooks/useThreatAnimation.ts
+function phaseFor(id) {
+  let hash = 2166136261;
+  for (let i = 0; i < id.length; i++) {
+    hash ^= id.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) % 1e4 / 1e4;
+}
+function useThreatAnimation(options) {
+  const entries = useRef(/* @__PURE__ */ new Map());
+  const latest = useRef(options);
+  latest.current = options;
+  const startedAt = useRef(0);
+  const frame = useRef(0);
+  const { threats, projection, line, width, height } = options;
+  useEffect(() => {
+    const map = entries.current;
+    const now = performance.now();
+    const seen = /* @__PURE__ */ new Set();
+    for (const threat of threats) {
+      seen.add(threat.id);
+      const existing = map.get(threat.id);
+      if (existing) {
+        existing.threat = threat;
+        existing.diedAt = null;
+      } else {
+        map.set(threat.id, {
+          threat,
+          geometry: null,
+          phase: phaseFor(threat.id),
+          bornAt: now,
+          diedAt: null
+        });
+      }
+    }
+    for (const [id, entry] of map) {
+      if (!seen.has(id) && entry.diedAt === null) entry.diedAt = now;
+    }
+  }, [threats]);
+  useEffect(() => {
+    if (!projection) return;
+    const maxLift = height > 0 ? height / 3 : Infinity;
+    for (const entry of entries.current.values()) {
+      entry.geometry = buildArc(
+        entry.threat.from,
+        entry.threat.to,
+        projection,
+        line.curvature,
+        line.segments,
+        maxLift
+      );
+    }
+  }, [projection, line.curvature, line.segments, threats, width, height]);
+  useEffect(() => {
+    const canvas = options.canvas.current;
+    if (!canvas || width <= 0 || height <= 0) return;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      options.onError?.("Could not acquire a 2D canvas context; the threat layer will not render.", void 0);
+      return;
+    }
+    if (startedAt.current === 0) startedAt.current = performance.now();
+    const renderFrame = (now) => {
+      const current = latest.current;
+      const elapsed = now - startedAt.current;
+      const renderables = collect(entries.current, current, elapsed, now);
+      ctx.setTransform(current.pixelRatio, 0, 0, current.pixelRatio, 0, 0);
+      drawThreats({
+        ctx,
+        width: current.width,
+        height: current.height,
+        threats: renderables,
+        theme: current.theme,
+        line: current.line,
+        pixelRatio: current.pixelRatio,
+        elapsed,
+        renderThreat: current.renderThreat,
+        onError: current.onError
+      });
+      if (current.animation.enabled) {
+        frame.current = requestAnimationFrame(renderFrame);
+      }
+    };
+    frame.current = requestAnimationFrame(renderFrame);
+    return () => cancelAnimationFrame(frame.current);
+  }, [
+    options.canvas,
+    width,
+    height,
+    options.pixelRatio,
+    options.animation,
+    options.theme,
+    options.line,
+    options.renderThreat,
+    threats,
+    projection
+  ]);
+  const pickAt = useCallback(
+    (x, y) => {
+      const current = latest.current;
+      return hitTest(candidates(entries.current), x, y, current.line.width);
+    },
+    []
+  );
+  return { pickAt };
+}
+function* candidates(map) {
+  for (const entry of map.values()) {
+    if (!entry.geometry || entry.diedAt !== null) continue;
+    yield { value: entry.threat, geometry: entry.geometry, intensity: entry.threat.intensity };
+  }
+}
+function collect(map, options, elapsed, now) {
+  const { animation } = options;
+  const easing = resolveEasing(animation.easing);
+  const out = [];
+  let expired = null;
+  for (const [id, entry] of map) {
+    if (!entry.geometry) continue;
+    const alpha = alphaFor(entry, animation, now);
+    if (alpha <= 0 && entry.diedAt !== null) {
+      (expired ?? (expired = [])).push(id);
+      continue;
+    }
+    out.push({
+      threat: entry.threat,
+      geometry: entry.geometry,
+      progress: easing(progressFor(entry, animation, elapsed)),
+      alpha
+    });
+  }
+  if (expired) {
+    for (const id of expired) map.delete(id);
+  }
+  return out;
+}
+function progressFor(entry, animation, elapsed) {
+  if (!animation.enabled) return 1;
+  const stagger = Math.max(0, Math.min(1, animation.stagger));
+  const cycles = elapsed / 1e3 * animation.speed + entry.phase * stagger;
+  if (animation.loop) return cycles % 1;
+  return Math.min(1, cycles);
+}
+function alphaFor(entry, animation, now) {
+  if (entry.diedAt !== null) {
+    if (animation.fadeOut <= 0) return 0;
+    return Math.max(0, 1 - (now - entry.diedAt) / animation.fadeOut);
+  }
+  if (animation.fadeIn <= 0) return 1;
+  return Math.min(1, (now - entry.bornAt) / animation.fadeIn);
+}
+function ThreatCanvas(props) {
+  const canvasRef = useRef(null);
+  const hovered = useRef(null);
+  const {
+    width,
+    height,
+    pixelRatio,
+    projection,
+    threats,
+    theme,
+    line,
+    animation,
+    renderThreat,
+    onThreatClick,
+    onThreatHover,
+    onError
+  } = props;
+  const { pickAt } = useThreatAnimation({
+    canvas: canvasRef,
+    threats,
+    projection,
+    width,
+    height,
+    pixelRatio,
+    theme,
+    line,
+    animation,
+    renderThreat,
+    onError
+  });
+  const interactive = Boolean(onThreatClick ?? onThreatHover);
+  const pick = useCallback(
+    (event) => {
+      const canvas = canvasRef.current;
+      if (!canvas) return null;
+      const rect = canvas.getBoundingClientRect();
+      return pickAt(event.clientX - rect.left, event.clientY - rect.top);
+    },
+    [pickAt]
+  );
+  const handleMove = useCallback(
+    (event) => {
+      if (!onThreatHover) return;
+      const threat = pick(event);
+      const id = threat?.id ?? null;
+      if (id === hovered.current) return;
+      hovered.current = id;
+      onThreatHover(threat, event.nativeEvent);
+    },
+    [onThreatHover, pick]
+  );
+  const handleLeave = useCallback(
+    (event) => {
+      if (!onThreatHover || hovered.current === null) return;
+      hovered.current = null;
+      onThreatHover(null, event.nativeEvent);
+    },
+    [onThreatHover]
+  );
+  const handleClick = useCallback(
+    (event) => {
+      if (!onThreatClick) return;
+      const threat = pick(event);
+      if (threat) onThreatClick(threat, event.nativeEvent);
+    },
+    [onThreatClick, pick]
+  );
+  return /* @__PURE__ */ jsx(
+    "canvas",
+    {
+      ref: canvasRef,
+      width: Math.max(1, Math.round(width * pixelRatio)),
+      height: Math.max(1, Math.round(height * pixelRatio)),
+      style: {
+        position: "absolute",
+        inset: 0,
+        width: "100%",
+        height: "100%",
+        // Without handlers the canvas must not eat pointer events aimed at
+        // whatever the consumer layered underneath.
+        pointerEvents: interactive ? "auto" : "none"
+      },
+      onMouseMove: interactive ? handleMove : void 0,
+      onMouseLeave: interactive ? handleLeave : void 0,
+      onClick: interactive ? handleClick : void 0,
+      "aria-hidden": "true"
+    }
+  );
+}
+function ThreatMap(props) {
+  const {
+    attacks,
+    width: widthProp,
+    height: heightProp,
+    projection: projectionProp = "naturalEarth1",
+    geo: geoProp,
+    renderThreat,
+    renderRegion,
+    onThreatClick,
+    onThreatHover,
+    onError,
+    className,
+    style,
+    ariaLabel = "Cyberattack threat map"
+  } = props;
+  const containerRef = useRef(null);
+  const theme = useMemo(() => {
+    const merged = mergeDefined(defaultTheme, props.theme);
+    return props.theme?.severityColors ? { ...merged, severityColors: { ...defaultTheme.severityColors, ...props.theme.severityColors } } : merged;
+  }, [props.theme]);
+  const line = useMemo(() => mergeDefined(defaultLineStyle, props.line), [props.line]);
+  const regions = useMemo(() => mergeDefined(defaultRegions, props.regions), [props.regions]);
+  const reducedMotion = useReducedMotion();
+  const animation = useMemo(() => {
+    const merged = mergeDefined(defaultAnimation, props.animation);
+    return merged.respectReducedMotion && reducedMotion ? { ...merged, enabled: false } : merged;
+  }, [props.animation, reducedMotion]);
+  const measured = useElementSize(containerRef, widthProp === void 0 || heightProp === void 0);
+  const pixelRatio = usePixelRatio();
+  const width = widthProp ?? measured?.width ?? 0;
+  const height = heightProp ?? (measured && measured.height > 0 ? measured.height : width > 0 ? defaultHeightFor(projectionProp, width) : 0);
+  const projection = useMemo(
+    () => width > 0 && height > 0 ? createProjection(projectionProp, width, height) : null,
+    [projectionProp, width, height]
+  );
+  const handleError = useCallback(
+    (error) => {
+      if (onError) {
+        onError(error);
+        return;
+      }
+      if (process.env.NODE_ENV !== "production") {
+        console.warn(`[react-threat-map] ${error.message}`, error.cause ?? "");
+      }
+    },
+    [onError]
+  );
+  const needsStates = regions.showStates || wantsStateResolution(props, attacks);
+  const { geo, index } = useGeoData(geoProp, needsStates, handleError);
+  const aggregationConfig = props.aggregation;
+  const threats = useMemo(
+    () => aggregateAttacks(attacks, {
+      config: aggregationConfig,
+      index,
+      onError: (message, attack) => handleError({ kind: "resolve", message, attack })
+    }),
+    [attacks, aggregationConfig, index, handleError]
+  );
+  const weights = useMemo(() => {
+    if (!renderRegion) return void 0;
+    const map = /* @__PURE__ */ new Map();
+    for (const threat of threats) {
+      map.set(threat.fromRegion.id, (map.get(threat.fromRegion.id) ?? 0) + threat.totalWeight);
+    }
+    return map;
+  }, [threats, renderRegion]);
+  const handleRenderError = useCallback(
+    (message, cause) => handleError({ kind: "render", message, cause }),
+    [handleError]
+  );
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      style: {
+        position: "relative",
+        ...widthProp !== void 0 ? { width: widthProp } : { width: "100%" },
+        // With no explicit height, give the box an aspect ratio rather than a
+        // pixel height. The canvases are absolutely positioned and so contribute
+        // no height of their own; without this the wrapper collapses to zero,
+        // which gates off the canvases, which keeps it collapsed. `aspect-ratio`
+        // is inert the moment anything else determines the height — a CSS class,
+        // a flex parent, or the consumer's own `style` below — so it sets a
+        // floor without taking the decision away from them.
+        ...heightProp !== void 0 ? { height: heightProp } : { aspectRatio: aspectRatioFor(projectionProp) },
+        ...style
+      },
+      role: "img",
+      "aria-label": ariaLabel,
+      children: width > 0 && height > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(
+          BaseMapCanvas,
+          {
+            width,
+            height,
+            pixelRatio,
+            projection,
+            geo,
+            theme,
+            regions,
+            renderRegion,
+            weights,
+            onError: handleRenderError
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          ThreatCanvas,
+          {
+            width,
+            height,
+            pixelRatio,
+            projection,
+            threats,
+            theme,
+            line,
+            animation,
+            renderThreat,
+            onThreatClick,
+            onThreatHover,
+            onError: handleRenderError
+          }
+        )
+      ] }) : null
+    }
+  );
+}
+function wantsStateResolution(props, attacks) {
+  const aggregation = props.aggregation;
+  if (aggregation === false || aggregation?.enabled === false) return false;
+  if (aggregation?.granularity === "country") return false;
+  for (const attack of attacks) {
+    if (isBareCoordinate(attack.from) || isBareCoordinate(attack.to)) return true;
+  }
+  return false;
+}
+function isBareCoordinate(location) {
+  return typeof location !== "string" && !("region" in location && location.region);
+}
+
+export { MAX_INTENSITY, SEVERITY_ORDER, ThreatMap, aggregateAttacks, defaultAggregation, defaultAnimation, defaultIntensityScale, defaultLineStyle, defaultRegions, defaultTheme, maxSeverity, regionKey, resolveLocation, severityRank };