@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-FITOLXSX.js

@@ -0,0 +1,714 @@
+import {
+  decodeFeatures,
+  featureBbox,
+  featureBboxPrimary,
+  featureIndex,
+  fold,
+  regionAt,
+  unionExtent
+} from "./chunk-I5IGB56C.js";
+import {
+  MAP_DX
+} from "./chunk-3SMGIJDD.js";
+import {
+  emit,
+  formatDgmoError,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/map/resolver.ts
+var WORLD_SPAN = 90;
+var MERCATOR_MAX_LAT = 80;
+var PAD_FRACTION = 0.05;
+var REGION_PAD_FRACTION = 0.12;
+var WORLD_LAT_SOUTH = -58;
+var WORLD_LAT_NORTH = 78;
+var POI_ZOOM_FLOOR_DEG = 7;
+var CONTAINER_OVERSHOOT_MAX = 8;
+var CONTAINER_OVERSHOOT_MIN = 3;
+var CONTAINER_OVERSHOOT_DECAY = 0.3;
+function containerOvershoot(span, usOriented) {
+  if (usOriented) return CONTAINER_OVERSHOOT_MAX;
+  return Math.max(
+    CONTAINER_OVERSHOOT_MIN,
+    Math.min(
+      CONTAINER_OVERSHOOT_MAX,
+      CONTAINER_OVERSHOOT_MAX - CONTAINER_OVERSHOOT_DECAY * span
+    )
+  );
+}
+var US_NATIONAL_LON_SPAN = 48;
+var CONUS_BBOX = [
+  [-125, 25],
+  [-66, 49]
+];
+var US_SUBNATIONAL_AREA_FRACTION = 0.4;
+function bboxArea(b) {
+  return (b[1][0] - b[0][0]) * (b[1][1] - b[0][1]);
+}
+function isSubNationalUsExtent(bbox) {
+  if (!bbox) return false;
+  return bboxArea(bbox) / bboxArea(CONUS_BBOX) < US_SUBNATIONAL_AREA_FRACTION;
+}
+var REGION_ALIASES = {
+  // Common everyday names → the Natural-Earth display name actually shipped.
+  "united states": "united states of america",
+  usa: "united states of america",
+  america: "united states of america",
+  uk: "united kingdom",
+  "western sahara": "w. sahara",
+  "democratic republic of the congo": "dem. rep. congo",
+  "dr congo": "dem. rep. congo",
+  drc: "dem. rep. congo",
+  "dominican republic": "dominican rep.",
+  "falkland islands": "falkland is.",
+  "ivory coast": "cote d'ivoire",
+  "central african republic": "central african rep.",
+  "equatorial guinea": "eq. guinea",
+  "solomon islands": "solomon is.",
+  "bosnia and herzegovina": "bosnia and herz.",
+  "south sudan": "s. sudan",
+  "north macedonia": "macedonia",
+  "czech republic": "czechia"
+};
+var US_STATE_POSTAL = /* @__PURE__ */ new Set([
+  "AL",
+  "AK",
+  "AZ",
+  "AR",
+  "CA",
+  "CO",
+  "CT",
+  "DE",
+  "FL",
+  "GA",
+  "HI",
+  "ID",
+  "IL",
+  "IN",
+  "IA",
+  "KS",
+  "KY",
+  "LA",
+  "ME",
+  "MD",
+  "MA",
+  "MI",
+  "MN",
+  "MS",
+  "MO",
+  "MT",
+  "NE",
+  "NV",
+  "NH",
+  "NJ",
+  "NM",
+  "NY",
+  "NC",
+  "ND",
+  "OH",
+  "OK",
+  "OR",
+  "PA",
+  "RI",
+  "SC",
+  "SD",
+  "TN",
+  "TX",
+  "UT",
+  "VT",
+  "VA",
+  "WA",
+  "WV",
+  "WI",
+  "WY",
+  "DC"
+]);
+function usStateFromBareScope(scope) {
+  if (!scope) return null;
+  const up = scope.toUpperCase();
+  return US_STATE_POSTAL.has(up) ? `US-${up}` : null;
+}
+function looksUS(lat, lon) {
+  if (lat < 15 || lat > 72) return false;
+  return lon >= -180 && lon <= -64 || lon >= 172;
+}
+function looksNorthAmericaNeighbor(lat, lon) {
+  return lat >= 14 && lat <= 72 && lon >= -141 && lon <= -52;
+}
+function isWholeSphere(bb) {
+  return bb[0][0] <= -179 && bb[1][0] >= 179 && bb[0][1] <= -89 && bb[1][1] >= 89;
+}
+function resolveMap(parsed, data) {
+  const diagnostics = [...parsed.diagnostics];
+  const shadowedAirports = /* @__PURE__ */ new Set();
+  const result = {
+    title: parsed.title,
+    ...parsed.directives.caption !== void 0 && {
+      caption: parsed.directives.caption
+    },
+    tagGroups: [...parsed.tagGroups],
+    // Shallow-copy so the resolved model never aliases the parser's mutable
+    // directives object (#11). NOTE: tag→region-fill COLOR binding is the
+    // renderer's job (step 4) — the resolver only carries `tags` + `tagGroups`
+    // through; it never resolves a tag value to a palette color (#10).
+    directives: { ...parsed.directives },
+    basemaps: { world: "detail", subdivisions: [] },
+    regions: [],
+    pois: [],
+    edges: [],
+    routes: [],
+    extent: [
+      [-180, -85],
+      [180, 85]
+    ],
+    projection: "equirectangular",
+    poiFrameContainers: [],
+    diagnostics,
+    error: parsed.error
+  };
+  const countryIndex = featureIndex(data.worldCoarse);
+  const usStateIndex = featureIndex(data.usStates);
+  const allNames = [
+    ...[...countryIndex.values()].map((v) => v.name),
+    ...[...usStateIndex.values()].map((v) => v.name)
+  ];
+  const localeRaw = parsed.directives.locale?.toUpperCase();
+  const localeCountry = localeRaw ? localeRaw.split("-")[0] : void 0;
+  const localeSubdivision = localeRaw && /^[A-Z]{2}-/.test(localeRaw) ? localeRaw : void 0;
+  const usScoped = localeCountry === "US" || parsed.regions.some((r) => {
+    const f = fold(r.name);
+    return usStateIndex.has(f) && !countryIndex.has(f);
+  }) || parsed.regions.some(
+    (r) => r.scope === "US" || r.scope?.startsWith("US-") || usStateFromBareScope(r.scope) !== null
+  ) || parsed.pois.some(
+    (p) => p.pos.kind === "name" && (p.pos.scope?.startsWith("US-") || usStateFromBareScope(p.pos.scope) !== null)
+  );
+  const regions = [];
+  const seenRegion = /* @__PURE__ */ new Map();
+  let usSubdivisionReferenced = false;
+  let hasAlaskaRef = false;
+  let hasHawaiiRef = false;
+  const referencedRegionIds = [];
+  for (const r of parsed.regions) {
+    const f = fold(r.name);
+    const inCountry = countryIndex.get(f) ?? (REGION_ALIASES[f] ? countryIndex.get(REGION_ALIASES[f]) : void 0);
+    const inState = usStateIndex.get(f);
+    let chosen = null;
+    const scope = r.scope;
+    if (scope) {
+      const wantsState = scope === "US" || scope.startsWith("US-");
+      if (wantsState && inState) {
+        if (scope.startsWith("US-") && inState.id !== scope) {
+          diagnostics.push(
+            emit(MAP_DX.SCOPE_MISS, r.lineNumber, {
+              name: r.name,
+              scope,
+              iso: inState.id
+            })
+          );
+          continue;
+        }
+        chosen = { ...inState, layer: "us-state" };
+      } else if (!wantsState && inCountry) {
+        chosen = { ...inCountry, layer: "country" };
+      } else {
+        diagnostics.push(
+          emit(MAP_DX.SCOPE_MISS, r.lineNumber, { name: r.name, scope })
+        );
+        continue;
+      }
+    } else if (inCountry && inState) {
+      if (usScoped) {
+        chosen = { ...inState, layer: "us-state" };
+      } else {
+        chosen = { ...inCountry, layer: "country" };
+        diagnostics.push(
+          emit(MAP_DX.REGION_AMBIGUOUS, r.lineNumber, {
+            name: r.name,
+            layer: chosen.layer,
+            chosenId: chosen.id,
+            stateId: inState.id,
+            countryId: inCountry.id
+          })
+        );
+      }
+    } else if (inState) {
+      chosen = { ...inState, layer: "us-state" };
+    } else if (inCountry) {
+      chosen = { ...inCountry, layer: "country" };
+    }
+    if (!chosen) {
+      const hint = suggest(r.name, allNames);
+      diagnostics.push(
+        emit(MAP_DX.UNKNOWN_SUBDIVISION, r.lineNumber, { name: r.name, hint })
+      );
+      continue;
+    }
+    if (chosen.layer === "us-state") {
+      usSubdivisionReferenced = true;
+      if (chosen.id === "US-AK") hasAlaskaRef = true;
+      if (chosen.id === "US-HI") hasHawaiiRef = true;
+      referencedRegionIds.push({ topo: "us", id: chosen.id });
+    }
+    const resolved = {
+      iso: chosen.id,
+      name: chosen.name,
+      layer: chosen.layer,
+      ...r.value !== void 0 && { value: r.value },
+      ...r.color !== void 0 && { color: r.color },
+      tags: r.tags,
+      meta: r.meta,
+      lineNumber: r.lineNumber
+    };
+    const prev = seenRegion.get(chosen.id);
+    if (prev !== void 0) {
+      diagnostics.push(
+        emit(MAP_DX.DUPLICATE_REGION, r.lineNumber, { name: chosen.name })
+      );
+      regions[prev] = resolved;
+    } else {
+      seenRegion.set(chosen.id, regions.length);
+      regions.push(resolved);
+    }
+  }
+  const registry = /* @__PURE__ */ new Map();
+  const pois = [];
+  const registerPoi = (id, poi, line) => {
+    const existing = registry.get(id);
+    if (existing) {
+      if (poi.implicit && !existing.implicit) return;
+      if (!poi.implicit && !existing.implicit) {
+        diagnostics.push(emit(MAP_DX.DUPLICATE_POI, line, { id }));
+      }
+      const idx = pois.indexOf(existing);
+      if (idx >= 0) pois[idx] = poi;
+    } else {
+      pois.push(poi);
+    }
+    registry.set(id, poi);
+  };
+  const lookupName = (name, scope, line, scopeHint, allowAmbiguous) => {
+    const f = fold(name);
+    let idxs = data.gazetteer.byName[f];
+    if (!idxs?.length) {
+      const aliasIdx = data.gazetteer.alt[f];
+      if (aliasIdx !== void 0) idxs = [aliasIdx];
+    }
+    if (!idxs?.length) {
+      const airIdx = data.airports?.airportIata?.[f];
+      if (airIdx !== void 0) {
+        const a = data.airports.airports[airIdx];
+        if (a) return { kind: "ok", lat: a[0], lon: a[1], iso: a[2] };
+      }
+      if (/^[A-Za-z]{3}$/.test(name)) {
+        const code = name.toUpperCase();
+        diagnostics.push(emit(MAP_DX.UNKNOWN_AIRPORT_CODE, line, { code }));
+        return { kind: "miss" };
+      }
+      const cityNames = data.gazetteer.cities.map((c2) => c2[4]);
+      const hint = suggest(name, cityNames);
+      diagnostics.push(emit(MAP_DX.UNKNOWN_PLACE, line, { name, hint }));
+      return { kind: "miss" };
+    }
+    let cands = idxs.map((i) => data.gazetteer.cities[i]);
+    const scopeUse = scope ?? scopeHint;
+    if (scopeUse) {
+      const bareState = usStateFromBareScope(scopeUse);
+      const subScope = /^[A-Za-z]{2}-/.test(scopeUse) ? scopeUse : bareState;
+      const filtered = cands.filter(
+        (c2) => subScope ? c2[5] === subScope : c2[2] === scopeUse
+      );
+      if (filtered.length) cands = filtered;
+      else if (scope) {
+        diagnostics.push(
+          emit(MAP_DX.SCOPE_MISS, line, { name, scope, place: true })
+        );
+        return { kind: "miss" };
+      }
+    }
+    if (cands.length > 1) {
+      if (!allowAmbiguous && !scopeUse) {
+        return { kind: "defer" };
+      }
+      cands = [...cands].sort((a, b) => b[3] - a[3]);
+      if (!scope) diagnostics.push(emit(MAP_DX.AMBIGUOUS_NAME, line, { name }));
+    }
+    const c = cands[0];
+    if (data.airports?.airportIata?.[f] !== void 0 && !shadowedAirports.has(f)) {
+      shadowedAirports.add(f);
+      const code = name.toUpperCase();
+      diagnostics.push(
+        emit(MAP_DX.AIRPORT_SHADOWED_BY_CITY, line, { name, code })
+      );
+    }
+    return { kind: "ok", lat: c[0], lon: c[1], iso: c[2] };
+  };
+  const poiIdFor = (pos, alias) => {
+    if (alias) return fold(alias);
+    if (pos.kind === "coords") return `@${pos.lat},${pos.lon}`;
+    return fold(pos.name);
+  };
+  const poiCountries = [];
+  let anyUsPoi = false;
+  let anyNonNaPoi = false;
+  const noteCountry = (iso) => {
+    if (iso) {
+      poiCountries.push(iso);
+      if (iso === "US") anyUsPoi = true;
+      if (iso !== "US" && iso !== "CA" && iso !== "MX") anyNonNaPoi = true;
+    }
+  };
+  const deferred = [];
+  for (const p of parsed.pois) {
+    if (p.pos.kind === "coords") {
+      if (looksUS(p.pos.lat, p.pos.lon)) anyUsPoi = true;
+      else if (!looksNorthAmericaNeighbor(p.pos.lat, p.pos.lon))
+        anyNonNaPoi = true;
+      addResolvedPoi(p.pos.lat, p.pos.lon, p);
+      continue;
+    }
+    const got = lookupName(
+      p.pos.name,
+      p.pos.scope,
+      p.lineNumber,
+      void 0,
+      false
+    );
+    if (got.kind === "ok") {
+      noteCountry(got.iso);
+      addResolvedPoi(got.lat, got.lon, p);
+    } else if (got.kind === "defer") {
+      deferred.push(p);
+    }
+  }
+  const inferredCountry = localeCountry ?? mostCommonCountry(regions, poiCountries) ?? void 0;
+  const inferredScope = localeSubdivision ?? inferredCountry;
+  for (const p of deferred) {
+    if (p.pos.kind !== "name") continue;
+    const got = lookupName(
+      p.pos.name,
+      p.pos.scope,
+      p.lineNumber,
+      inferredScope,
+      true
+    );
+    if (got.kind === "ok") {
+      noteCountry(got.iso);
+      addResolvedPoi(got.lat, got.lon, p);
+    }
+  }
+  function addResolvedPoi(lat, lon, p) {
+    const id = poiIdFor(p.pos, p.alias);
+    const name = p.pos.kind === "name" ? p.pos.name : p.alias;
+    const poi = {
+      id,
+      ...name !== void 0 && { name },
+      lat,
+      lon,
+      ...p.label !== void 0 && { label: p.label },
+      ...p.color !== void 0 && { color: p.color },
+      tags: p.tags,
+      meta: p.meta,
+      lineNumber: p.lineNumber
+    };
+    registerPoi(id, poi, p.lineNumber);
+  }
+  const declaredByName = /* @__PURE__ */ new Map();
+  for (const p of pois) {
+    const fn = p.name ? fold(p.name) : void 0;
+    if (fn && fn !== p.id && !declaredByName.has(fn))
+      declaredByName.set(fn, p.id);
+  }
+  const resolveEndpoint = (ref, line) => {
+    const f = fold(ref);
+    if (registry.has(f)) return f;
+    const aliased = declaredByName.get(f);
+    if (aliased) return aliased;
+    const got = lookupName(ref, void 0, line, inferredCountry, true);
+    if (got.kind !== "ok") return null;
+    noteCountry(got.iso);
+    const poi = {
+      id: f,
+      name: ref,
+      lat: got.lat,
+      lon: got.lon,
+      tags: {},
+      meta: {},
+      lineNumber: line,
+      implicit: true
+    };
+    registerPoi(f, poi, line);
+    return f;
+  };
+  const edges = [];
+  for (const e of parsed.edges) {
+    const fromId = resolveEndpoint(e.from, e.lineNumber);
+    const toId = resolveEndpoint(e.to, e.lineNumber);
+    if (!fromId || !toId) continue;
+    edges.push({
+      fromId,
+      toId,
+      ...e.label !== void 0 && { label: e.label },
+      directed: e.directed,
+      style: e.style,
+      meta: e.meta,
+      tags: e.tags,
+      lineNumber: e.lineNumber
+    });
+  }
+  const resolveStop = (pos, alias, label, tags, sizeValue, line) => {
+    const meta = sizeValue !== void 0 ? { value: sizeValue } : {};
+    if (pos.kind === "coords") {
+      const id = alias ? fold(alias) : `@${pos.lat},${pos.lon}`;
+      if (looksUS(pos.lat, pos.lon)) anyUsPoi = true;
+      else if (!looksNorthAmericaNeighbor(pos.lat, pos.lon)) anyNonNaPoi = true;
+      if (!registry.has(id)) {
+        registerPoi(
+          id,
+          {
+            id,
+            ...alias !== void 0 && { name: alias },
+            lat: pos.lat,
+            lon: pos.lon,
+            ...label !== void 0 && { label },
+            tags,
+            meta,
+            lineNumber: line
+          },
+          line
+        );
+      }
+      return id;
+    }
+    const f = fold(pos.name);
+    if (registry.has(f)) return f;
+    const aliased = declaredByName.get(f);
+    if (aliased) return aliased;
+    const got = lookupName(pos.name, pos.scope, line, inferredScope, true);
+    if (got.kind !== "ok") return null;
+    noteCountry(got.iso);
+    registerPoi(
+      f,
+      {
+        id: f,
+        name: pos.name,
+        lat: got.lat,
+        lon: got.lon,
+        ...label !== void 0 && { label },
+        tags,
+        meta,
+        lineNumber: line
+      },
+      line
+    );
+    return f;
+  };
+  const routes = [];
+  for (const rt of parsed.routes) {
+    const originId = resolveStop(
+      rt.origin,
+      rt.originAlias,
+      rt.originLabel,
+      rt.originTags,
+      rt.originValue,
+      rt.lineNumber
+    );
+    if (!originId) continue;
+    const stopIds = [originId];
+    const legs = [];
+    let prevId = originId;
+    for (const leg of rt.legs) {
+      const destId = resolveStop(
+        leg.dest,
+        leg.destAlias,
+        leg.destLabel,
+        {},
+        // a leg tag colours the LINE (§24B.6), not the destination stop
+        void 0,
+        // a leg's `width:` is leg thickness, not the dest's size
+        leg.lineNumber
+      );
+      if (!destId) continue;
+      legs.push({
+        fromId: prevId,
+        toId: destId,
+        ...leg.label !== void 0 && { label: leg.label },
+        style: leg.style,
+        ...leg.value !== void 0 && { value: leg.value },
+        tags: leg.tags,
+        lineNumber: leg.lineNumber
+      });
+      if (!stopIds.includes(destId)) stopIds.push(destId);
+      prevId = destId;
+    }
+    routes.push({ stopIds, legs, lineNumber: rt.lineNumber });
+  }
+  const hasUsContent = usSubdivisionReferenced || anyUsPoi || localeCountry === "US";
+  const usOriented = !anyNonNaPoi && !regions.some(
+    (r) => r.layer === "country" && !["US", "CA", "MX"].includes(r.iso)
+  ) && hasUsContent;
+  const subdivisions = [];
+  if (usSubdivisionReferenced || usOriented) subdivisions.push("us-states");
+  const regionBoxes = [];
+  for (const ref of referencedRegionIds) {
+    const bb = featureBbox(data.usStates, ref.id);
+    if (bb) regionBoxes.push(bb);
+  }
+  for (const r of regions) {
+    if (r.layer === "country") {
+      const bb = featureBboxPrimary(data.worldCoarse, r.iso);
+      if (bb) regionBoxes.push(bb);
+    }
+  }
+  const points = pois.map((p) => [p.lon, p.lat]);
+  const unioned = unionExtent(regionBoxes, points);
+  const usSubNational = isSubNationalUsExtent(unioned);
+  const localeUsForced = localeCountry === "US" && !localeSubdivision;
+  const DEFAULT_EXTENT = [
+    [-180, -85],
+    [180, 85]
+  ];
+  const basePad = regions.length > 0 ? REGION_PAD_FRACTION : PAD_FRACTION;
+  let extent = unioned ? pad(unioned, basePad) : DEFAULT_EXTENT;
+  const isPoiOnly = pois.length > 0 && regions.length === 0;
+  const containerRegionIds = [];
+  if (isPoiOnly) {
+    const countries = decodeFeatures(data.worldDetail);
+    const states = decodeFeatures(data.usStates);
+    const seen = /* @__PURE__ */ new Set();
+    const containerBoxes = [];
+    for (const p of pois) {
+      const { country, state } = regionAt([p.lon, p.lat], countries, states);
+      const id = state?.iso ?? country?.iso;
+      if (!id || seen.has(id)) continue;
+      seen.add(id);
+      containerRegionIds.push(id);
+      const bb = state ? featureBbox(data.usStates, id) : usOriented ? null : featureBboxPrimary(data.worldCoarse, id);
+      if (bb && !isWholeSphere(bb)) containerBoxes.push(bb);
+    }
+    const containerUnion = unionExtent(containerBoxes, points);
+    if (containerUnion)
+      extent = pad(
+        clampContainerToCluster(containerUnion, points, usOriented),
+        PAD_FRACTION
+      );
+  }
+  if (isPoiOnly || usSubNational && usOriented) {
+    const cx = (extent[0][0] + extent[1][0]) / 2;
+    const cy = (extent[0][1] + extent[1][1]) / 2;
+    const lon = extent[1][0] - extent[0][0];
+    const lat = extent[1][1] - extent[0][1];
+    const longer = Math.max(lon, lat);
+    if (longer > 0 && longer < POI_ZOOM_FLOOR_DEG) {
+      const k = POI_ZOOM_FLOOR_DEG / longer;
+      const halfLon = lon * k / 2;
+      const halfLat = lat * k / 2;
+      extent = [
+        [cx - halfLon, cy - halfLat],
+        [cx + halfLon, cy + halfLat]
+      ];
+    }
+  }
+  const lonSpan = extent[1][0] - extent[0][0];
+  const latSpan = extent[1][1] - extent[0][1];
+  const span = Math.max(lonSpan, latSpan);
+  const maxAbsLat = Math.max(Math.abs(extent[0][1]), Math.abs(extent[1][1]));
+  const usSubNationalZoom = usOriented && usSubNational && !isPoiOnly && !hasAlaskaRef && !hasHawaiiRef && !localeUsForced;
+  let projection;
+  if (usOriented && lonSpan < US_NATIONAL_LON_SPAN && (isPoiOnly || usSubNationalZoom)) {
+    projection = "mercator";
+  } else if (usOriented) {
+    projection = "albers-usa";
+  } else if (span > WORLD_SPAN || maxAbsLat > MERCATOR_MAX_LAT) {
+    projection = "equirectangular";
+  } else {
+    projection = "conic-equal-area";
+  }
+  if (lonSpan >= 180) {
+    extent = [
+      [-180, Math.min(extent[0][1], WORLD_LAT_SOUTH)],
+      [180, Math.max(extent[1][1], WORLD_LAT_NORTH)]
+    ];
+  }
+  result.regions = regions;
+  result.pois = pois;
+  result.edges = edges;
+  result.routes = routes;
+  result.basemaps = {
+    // Tier is intentionally pinned to detail (50m) at ALL scales. Diagrammo maps
+    // are presentational (palette tints, relief hachures, POI hubs), not
+    // survey-grade — recognizability > generalization: 110m coarse drops the
+    // Italian boot to a stump at world scale. `WORLD_SPAN` lives on only for the
+    // projection decision (the `usOriented`/`span > WORLD_SPAN` chain above); it
+    // no longer gates basemap resolution.
+    // `worldCoarse` is still loaded — it's the authoritative name/bbox index
+    // (featureIndex, featureBboxPrimary), not dead code.
+    world: "detail",
+    subdivisions
+  };
+  result.extent = extent;
+  result.projection = projection;
+  result.poiFrameContainers = containerRegionIds;
+  result.error = parsed.error ?? firstError(diagnostics);
+  return result;
+}
+function mostCommonCountry(regions, poiCountries) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const r of regions) {
+    const iso = r.layer === "us-state" ? "US" : r.iso;
+    counts.set(iso, (counts.get(iso) ?? 0) + 1);
+  }
+  for (const iso of poiCountries) {
+    counts.set(iso, (counts.get(iso) ?? 0) + 1);
+  }
+  let best;
+  let bestN = 0;
+  for (const [iso, n] of [...counts.entries()].sort(
+    (a, b) => a[0] < b[0] ? -1 : 1
+  )) {
+    if (n > bestN) {
+      bestN = n;
+      best = iso;
+    }
+  }
+  return best;
+}
+function clampContainerToCluster(container, points, usOriented) {
+  const poi = unionExtent([], points);
+  if (!poi) return container;
+  let [[west, south], [east, north]] = container;
+  const [[pWest, pSouth], [pEast, pNorth]] = poi;
+  const over = containerOvershoot(
+    Math.max(pEast - pWest, pNorth - pSouth),
+    usOriented
+  );
+  south = Math.max(south, pSouth - over);
+  north = Math.min(north, pNorth + over);
+  const wOver = pWest - over;
+  const eOver = pEast + over;
+  west = west >= -180 && west <= pWest ? Math.max(west, wOver) : wOver;
+  east = east <= 180 && east >= pEast ? Math.min(east, eOver) : eOver;
+  return [
+    [west, south],
+    [east, north]
+  ];
+}
+function pad(e, frac) {
+  const dLon = (e[1][0] - e[0][0]) * frac || 1;
+  const dLat = (e[1][1] - e[0][1]) * frac || 1;
+  return [
+    [Math.max(-180, e[0][0] - dLon), Math.max(-90, e[0][1] - dLat)],
+    [Math.min(540, e[1][0] + dLon), Math.min(90, e[1][1] + dLat)]
+  ];
+}
+function firstError(diags) {
+  const e = diags.find((d) => d.severity === "error");
+  return e ? formatDgmoError(e) : null;
+}
+
+export {
+  isSubNationalUsExtent,
+  resolveMap
+};
+//# sourceMappingURL=chunk-FITOLXSX.js.map