@johnmorrisdotca/kuni 1.5.0 → 1.6.0

package/dist/cities.cjs

@@ -0,0 +1,686 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cities.ts
+var cities_exports = {};
+__export(cities_exports, {
+  CITY_TIERS: () => CITY_TIERS,
+  citiesOf: () => citiesOf,
+  cityById: () => cityById,
+  citySet: () => citySet,
+  loadCities: () => loadCities
+});
+module.exports = __toCommonJS(cities_exports);
+
+// src/data/codes.data.ts
+var COUNTRY_CODES = [
+  "AD",
+  "AE",
+  "AF",
+  "AG",
+  "AI",
+  "AL",
+  "AM",
+  "AO",
+  "AQ",
+  "AR",
+  "AS",
+  "AT",
+  "AU",
+  "AW",
+  "AX",
+  "AZ",
+  "BA",
+  "BB",
+  "BD",
+  "BE",
+  "BF",
+  "BG",
+  "BH",
+  "BI",
+  "BJ",
+  "BL",
+  "BM",
+  "BN",
+  "BO",
+  "BQ",
+  "BR",
+  "BS",
+  "BT",
+  "BV",
+  "BW",
+  "BY",
+  "BZ",
+  "CA",
+  "CC",
+  "CD",
+  "CF",
+  "CG",
+  "CH",
+  "CI",
+  "CK",
+  "CL",
+  "CM",
+  "CN",
+  "CO",
+  "CR",
+  "CU",
+  "CV",
+  "CW",
+  "CX",
+  "CY",
+  "CZ",
+  "DE",
+  "DJ",
+  "DK",
+  "DM",
+  "DO",
+  "DZ",
+  "EC",
+  "EE",
+  "EG",
+  "EH",
+  "ER",
+  "ES",
+  "ET",
+  "FI",
+  "FJ",
+  "FK",
+  "FM",
+  "FO",
+  "FR",
+  "GA",
+  "GB",
+  "GD",
+  "GE",
+  "GF",
+  "GG",
+  "GH",
+  "GI",
+  "GL",
+  "GM",
+  "GN",
+  "GP",
+  "GQ",
+  "GR",
+  "GS",
+  "GT",
+  "GU",
+  "GW",
+  "GY",
+  "HK",
+  "HM",
+  "HN",
+  "HR",
+  "HT",
+  "HU",
+  "ID",
+  "IE",
+  "IL",
+  "IM",
+  "IN",
+  "IO",
+  "IQ",
+  "IR",
+  "IS",
+  "IT",
+  "JE",
+  "JM",
+  "JO",
+  "JP",
+  "KE",
+  "KG",
+  "KH",
+  "KI",
+  "KM",
+  "KN",
+  "KP",
+  "KR",
+  "KW",
+  "KY",
+  "KZ",
+  "LA",
+  "LB",
+  "LC",
+  "LI",
+  "LK",
+  "LR",
+  "LS",
+  "LT",
+  "LU",
+  "LV",
+  "LY",
+  "MA",
+  "MC",
+  "MD",
+  "ME",
+  "MF",
+  "MG",
+  "MH",
+  "MK",
+  "ML",
+  "MM",
+  "MN",
+  "MO",
+  "MP",
+  "MQ",
+  "MR",
+  "MS",
+  "MT",
+  "MU",
+  "MV",
+  "MW",
+  "MX",
+  "MY",
+  "MZ",
+  "NA",
+  "NC",
+  "NE",
+  "NF",
+  "NG",
+  "NI",
+  "NL",
+  "NO",
+  "NP",
+  "NR",
+  "NU",
+  "NZ",
+  "OM",
+  "PA",
+  "PE",
+  "PF",
+  "PG",
+  "PH",
+  "PK",
+  "PL",
+  "PM",
+  "PN",
+  "PR",
+  "PS",
+  "PT",
+  "PW",
+  "PY",
+  "QA",
+  "RE",
+  "RO",
+  "RS",
+  "RU",
+  "RW",
+  "SA",
+  "SB",
+  "SC",
+  "SD",
+  "SE",
+  "SG",
+  "SH",
+  "SI",
+  "SJ",
+  "SK",
+  "SL",
+  "SM",
+  "SN",
+  "SO",
+  "SR",
+  "SS",
+  "ST",
+  "SV",
+  "SX",
+  "SY",
+  "SZ",
+  "TC",
+  "TD",
+  "TF",
+  "TG",
+  "TH",
+  "TJ",
+  "TK",
+  "TL",
+  "TM",
+  "TN",
+  "TO",
+  "TR",
+  "TT",
+  "TV",
+  "TW",
+  "TZ",
+  "UA",
+  "UG",
+  "UM",
+  "US",
+  "UY",
+  "UZ",
+  "VA",
+  "VC",
+  "VE",
+  "VG",
+  "VI",
+  "VN",
+  "VU",
+  "WF",
+  "WS",
+  "XK",
+  "YE",
+  "YT",
+  "ZA",
+  "ZM",
+  "ZW"
+];
+
+// src/codes.ts
+var CODE_SET = new Set(COUNTRY_CODES);
+var isCountryCode = (value) => typeof value === "string" && CODE_SET.has(value);
+
+// src/data/city-aliases.data.ts
+var CITY_ALIASES = {};
+
+// src/data/city-loaders.data.ts
+var CITY_LOADERS = {
+  ad: () => import("./cities/ad.cjs"),
+  ae: () => import("./cities/ae.cjs"),
+  af: () => import("./cities/af.cjs"),
+  ag: () => import("./cities/ag.cjs"),
+  ai: () => import("./cities/ai.cjs"),
+  al: () => import("./cities/al.cjs"),
+  am: () => import("./cities/am.cjs"),
+  ao: () => import("./cities/ao.cjs"),
+  ar: () => import("./cities/ar.cjs"),
+  as: () => import("./cities/as.cjs"),
+  at: () => import("./cities/at.cjs"),
+  au: () => import("./cities/au.cjs"),
+  aw: () => import("./cities/aw.cjs"),
+  ax: () => import("./cities/ax.cjs"),
+  az: () => import("./cities/az.cjs"),
+  ba: () => import("./cities/ba.cjs"),
+  bb: () => import("./cities/bb.cjs"),
+  bd: () => import("./cities/bd.cjs"),
+  be: () => import("./cities/be.cjs"),
+  bf: () => import("./cities/bf.cjs"),
+  bg: () => import("./cities/bg.cjs"),
+  bh: () => import("./cities/bh.cjs"),
+  bi: () => import("./cities/bi.cjs"),
+  bj: () => import("./cities/bj.cjs"),
+  bl: () => import("./cities/bl.cjs"),
+  bm: () => import("./cities/bm.cjs"),
+  bn: () => import("./cities/bn.cjs"),
+  bo: () => import("./cities/bo.cjs"),
+  bq: () => import("./cities/bq.cjs"),
+  br: () => import("./cities/br.cjs"),
+  bs: () => import("./cities/bs.cjs"),
+  bt: () => import("./cities/bt.cjs"),
+  bw: () => import("./cities/bw.cjs"),
+  by: () => import("./cities/by.cjs"),
+  bz: () => import("./cities/bz.cjs"),
+  ca: () => import("./cities/ca.cjs"),
+  cc: () => import("./cities/cc.cjs"),
+  cd: () => import("./cities/cd.cjs"),
+  cf: () => import("./cities/cf.cjs"),
+  cg: () => import("./cities/cg.cjs"),
+  ch: () => import("./cities/ch.cjs"),
+  ci: () => import("./cities/ci.cjs"),
+  ck: () => import("./cities/ck.cjs"),
+  cl: () => import("./cities/cl.cjs"),
+  cm: () => import("./cities/cm.cjs"),
+  cn: () => import("./cities/cn.cjs"),
+  co: () => import("./cities/co.cjs"),
+  cr: () => import("./cities/cr.cjs"),
+  cu: () => import("./cities/cu.cjs"),
+  cv: () => import("./cities/cv.cjs"),
+  cw: () => import("./cities/cw.cjs"),
+  cx: () => import("./cities/cx.cjs"),
+  cy: () => import("./cities/cy.cjs"),
+  cz: () => import("./cities/cz.cjs"),
+  de: () => import("./cities/de.cjs"),
+  dj: () => import("./cities/dj.cjs"),
+  dk: () => import("./cities/dk.cjs"),
+  dm: () => import("./cities/dm.cjs"),
+  do: () => import("./cities/do.cjs"),
+  dz: () => import("./cities/dz.cjs"),
+  ec: () => import("./cities/ec.cjs"),
+  ee: () => import("./cities/ee.cjs"),
+  eg: () => import("./cities/eg.cjs"),
+  eh: () => import("./cities/eh.cjs"),
+  er: () => import("./cities/er.cjs"),
+  es: () => import("./cities/es.cjs"),
+  et: () => import("./cities/et.cjs"),
+  fi: () => import("./cities/fi.cjs"),
+  fj: () => import("./cities/fj.cjs"),
+  fk: () => import("./cities/fk.cjs"),
+  fm: () => import("./cities/fm.cjs"),
+  fo: () => import("./cities/fo.cjs"),
+  fr: () => import("./cities/fr.cjs"),
+  ga: () => import("./cities/ga.cjs"),
+  gb: () => import("./cities/gb.cjs"),
+  gd: () => import("./cities/gd.cjs"),
+  ge: () => import("./cities/ge.cjs"),
+  gf: () => import("./cities/gf.cjs"),
+  gg: () => import("./cities/gg.cjs"),
+  gh: () => import("./cities/gh.cjs"),
+  gi: () => import("./cities/gi.cjs"),
+  gl: () => import("./cities/gl.cjs"),
+  gm: () => import("./cities/gm.cjs"),
+  gn: () => import("./cities/gn.cjs"),
+  gp: () => import("./cities/gp.cjs"),
+  gq: () => import("./cities/gq.cjs"),
+  gr: () => import("./cities/gr.cjs"),
+  gs: () => import("./cities/gs.cjs"),
+  gt: () => import("./cities/gt.cjs"),
+  gu: () => import("./cities/gu.cjs"),
+  gw: () => import("./cities/gw.cjs"),
+  gy: () => import("./cities/gy.cjs"),
+  hn: () => import("./cities/hn.cjs"),
+  hr: () => import("./cities/hr.cjs"),
+  ht: () => import("./cities/ht.cjs"),
+  hu: () => import("./cities/hu.cjs"),
+  id: () => import("./cities/id.cjs"),
+  ie: () => import("./cities/ie.cjs"),
+  il: () => import("./cities/il.cjs"),
+  im: () => import("./cities/im.cjs"),
+  in: () => import("./cities/in.cjs"),
+  io: () => import("./cities/io.cjs"),
+  iq: () => import("./cities/iq.cjs"),
+  ir: () => import("./cities/ir.cjs"),
+  is: () => import("./cities/is.cjs"),
+  it: () => import("./cities/it.cjs"),
+  je: () => import("./cities/je.cjs"),
+  jm: () => import("./cities/jm.cjs"),
+  jo: () => import("./cities/jo.cjs"),
+  jp: () => import("./cities/jp.cjs"),
+  ke: () => import("./cities/ke.cjs"),
+  kg: () => import("./cities/kg.cjs"),
+  kh: () => import("./cities/kh.cjs"),
+  ki: () => import("./cities/ki.cjs"),
+  km: () => import("./cities/km.cjs"),
+  kn: () => import("./cities/kn.cjs"),
+  kp: () => import("./cities/kp.cjs"),
+  kr: () => import("./cities/kr.cjs"),
+  kw: () => import("./cities/kw.cjs"),
+  ky: () => import("./cities/ky.cjs"),
+  kz: () => import("./cities/kz.cjs"),
+  la: () => import("./cities/la.cjs"),
+  lb: () => import("./cities/lb.cjs"),
+  lc: () => import("./cities/lc.cjs"),
+  li: () => import("./cities/li.cjs"),
+  lk: () => import("./cities/lk.cjs"),
+  lr: () => import("./cities/lr.cjs"),
+  ls: () => import("./cities/ls.cjs"),
+  lt: () => import("./cities/lt.cjs"),
+  lu: () => import("./cities/lu.cjs"),
+  lv: () => import("./cities/lv.cjs"),
+  ly: () => import("./cities/ly.cjs"),
+  ma: () => import("./cities/ma.cjs"),
+  mc: () => import("./cities/mc.cjs"),
+  md: () => import("./cities/md.cjs"),
+  me: () => import("./cities/me.cjs"),
+  mf: () => import("./cities/mf.cjs"),
+  mg: () => import("./cities/mg.cjs"),
+  mh: () => import("./cities/mh.cjs"),
+  mk: () => import("./cities/mk.cjs"),
+  ml: () => import("./cities/ml.cjs"),
+  mm: () => import("./cities/mm.cjs"),
+  mn: () => import("./cities/mn.cjs"),
+  mo: () => import("./cities/mo.cjs"),
+  mp: () => import("./cities/mp.cjs"),
+  mq: () => import("./cities/mq.cjs"),
+  mr: () => import("./cities/mr.cjs"),
+  ms: () => import("./cities/ms.cjs"),
+  mt: () => import("./cities/mt.cjs"),
+  mu: () => import("./cities/mu.cjs"),
+  mv: () => import("./cities/mv.cjs"),
+  mw: () => import("./cities/mw.cjs"),
+  mx: () => import("./cities/mx.cjs"),
+  my: () => import("./cities/my.cjs"),
+  mz: () => import("./cities/mz.cjs"),
+  na: () => import("./cities/na.cjs"),
+  nc: () => import("./cities/nc.cjs"),
+  ne: () => import("./cities/ne.cjs"),
+  nf: () => import("./cities/nf.cjs"),
+  ng: () => import("./cities/ng.cjs"),
+  ni: () => import("./cities/ni.cjs"),
+  nl: () => import("./cities/nl.cjs"),
+  no: () => import("./cities/no.cjs"),
+  np: () => import("./cities/np.cjs"),
+  nr: () => import("./cities/nr.cjs"),
+  nu: () => import("./cities/nu.cjs"),
+  nz: () => import("./cities/nz.cjs"),
+  om: () => import("./cities/om.cjs"),
+  pa: () => import("./cities/pa.cjs"),
+  pe: () => import("./cities/pe.cjs"),
+  pf: () => import("./cities/pf.cjs"),
+  pg: () => import("./cities/pg.cjs"),
+  ph: () => import("./cities/ph.cjs"),
+  pk: () => import("./cities/pk.cjs"),
+  pl: () => import("./cities/pl.cjs"),
+  pm: () => import("./cities/pm.cjs"),
+  pn: () => import("./cities/pn.cjs"),
+  pr: () => import("./cities/pr.cjs"),
+  ps: () => import("./cities/ps.cjs"),
+  pt: () => import("./cities/pt.cjs"),
+  pw: () => import("./cities/pw.cjs"),
+  py: () => import("./cities/py.cjs"),
+  qa: () => import("./cities/qa.cjs"),
+  re: () => import("./cities/re.cjs"),
+  ro: () => import("./cities/ro.cjs"),
+  rs: () => import("./cities/rs.cjs"),
+  ru: () => import("./cities/ru.cjs"),
+  rw: () => import("./cities/rw.cjs"),
+  sa: () => import("./cities/sa.cjs"),
+  sb: () => import("./cities/sb.cjs"),
+  sc: () => import("./cities/sc.cjs"),
+  sd: () => import("./cities/sd.cjs"),
+  se: () => import("./cities/se.cjs"),
+  sg: () => import("./cities/sg.cjs"),
+  sh: () => import("./cities/sh.cjs"),
+  si: () => import("./cities/si.cjs"),
+  sk: () => import("./cities/sk.cjs"),
+  sl: () => import("./cities/sl.cjs"),
+  sm: () => import("./cities/sm.cjs"),
+  sn: () => import("./cities/sn.cjs"),
+  so: () => import("./cities/so.cjs"),
+  sr: () => import("./cities/sr.cjs"),
+  ss: () => import("./cities/ss.cjs"),
+  st: () => import("./cities/st.cjs"),
+  sv: () => import("./cities/sv.cjs"),
+  sx: () => import("./cities/sx.cjs"),
+  sy: () => import("./cities/sy.cjs"),
+  sz: () => import("./cities/sz.cjs"),
+  tc: () => import("./cities/tc.cjs"),
+  td: () => import("./cities/td.cjs"),
+  tf: () => import("./cities/tf.cjs"),
+  tg: () => import("./cities/tg.cjs"),
+  th: () => import("./cities/th.cjs"),
+  tj: () => import("./cities/tj.cjs"),
+  tl: () => import("./cities/tl.cjs"),
+  tm: () => import("./cities/tm.cjs"),
+  tn: () => import("./cities/tn.cjs"),
+  to: () => import("./cities/to.cjs"),
+  tr: () => import("./cities/tr.cjs"),
+  tt: () => import("./cities/tt.cjs"),
+  tv: () => import("./cities/tv.cjs"),
+  tw: () => import("./cities/tw.cjs"),
+  tz: () => import("./cities/tz.cjs"),
+  ua: () => import("./cities/ua.cjs"),
+  ug: () => import("./cities/ug.cjs"),
+  us: () => import("./cities/us.cjs"),
+  uy: () => import("./cities/uy.cjs"),
+  uz: () => import("./cities/uz.cjs"),
+  va: () => import("./cities/va.cjs"),
+  vc: () => import("./cities/vc.cjs"),
+  ve: () => import("./cities/ve.cjs"),
+  vg: () => import("./cities/vg.cjs"),
+  vi: () => import("./cities/vi.cjs"),
+  vn: () => import("./cities/vn.cjs"),
+  vu: () => import("./cities/vu.cjs"),
+  wf: () => import("./cities/wf.cjs"),
+  ws: () => import("./cities/ws.cjs"),
+  xk: () => import("./cities/xk.cjs"),
+  ye: () => import("./cities/ye.cjs"),
+  yt: () => import("./cities/yt.cjs"),
+  za: () => import("./cities/za.cjs"),
+  zm: () => import("./cities/zm.cjs"),
+  zw: () => import("./cities/zw.cjs")
+};
+
+// src/cities.ts
+var CITY_TIERS = Object.freeze(["capitals", "1m", "100k", "15k"]);
+var EARTH_KM = 6371.0088;
+var RADIANS = Math.PI / 180;
+var EMPTY = Object.freeze([]);
+var EMPTY_AT = Object.freeze([]);
+var normalId = (id) => typeof id === "string" ? id.trim().replace(/^NE:/i, "ne:").replace(/^q/, "Q") : null;
+var unit = (lat, lon) => {
+  const cosine = Math.cos(lat * RADIANS);
+  return [cosine * Math.cos(lon * RADIANS), cosine * Math.sin(lon * RADIANS), Math.sin(lat * RADIANS)];
+};
+var kmAt = (here, vectors, offset) => {
+  const x = vectors[offset];
+  const y = vectors[offset + 1];
+  const z = vectors[offset + 2];
+  const cross = Math.hypot(here[1] * z - here[2] * y, here[2] * x - here[0] * z, here[0] * y - here[1] * x);
+  return EARTH_KM * Math.atan2(cross, here[0] * x + here[1] * y + here[2] * z);
+};
+var isPoint = (point) => typeof point === "object" && point !== null && Number.isFinite(point.lat) && Number.isFinite(point.lon) && Math.abs(point.lat) <= 90;
+var citySet = (...lists) => {
+  const seen = /* @__PURE__ */ new Set();
+  const cities = [];
+  for (const list of lists) {
+    for (const city of list) {
+      if (seen.has(city.id)) continue;
+      seen.add(city.id);
+      cities.push(city);
+    }
+  }
+  const ids = /* @__PURE__ */ new Map();
+  const countries = /* @__PURE__ */ new Map();
+  const subdivisions = /* @__PURE__ */ new Map();
+  const add = (groups, key, city) => {
+    if (key === null) return;
+    const list = groups.get(key);
+    if (list === void 0) groups.set(key, [city]);
+    else list.push(city);
+  };
+  for (const city of cities) {
+    ids.set(city.id, city);
+    add(countries, city.country, city);
+    add(subdivisions, city.subdivision, city);
+  }
+  const vectors = new Float64Array(cities.length * 3);
+  cities.forEach((city, at) => vectors.set(unit(city.lat, city.lon), at * 3));
+  const allowed = (city, country, minPopulation) => (country === null || city.country === country) && (minPopulation <= 0 || (city.population ?? 0) >= minPopulation);
+  const countryOf = (options) => typeof options?.country === "string" ? options.country.trim().toUpperCase() : null;
+  const populationOf = (options) => Number.isFinite(options?.minPopulation) ? options.minPopulation : 0;
+  const nearest = (point, options) => {
+    if (!isPoint(point)) return null;
+    const here = unit(point.lat, point.lon);
+    const country = countryOf(options);
+    const minPopulation = populationOf(options);
+    const maxKm = Number.isFinite(options?.maxKm) ? options.maxKm : Infinity;
+    let best = -Infinity;
+    let at = -1;
+    for (let index = 0; index < cities.length; index += 1) {
+      const offset = index * 3;
+      const dot = here[0] * vectors[offset] + here[1] * vectors[offset + 1] + here[2] * vectors[offset + 2];
+      if (dot > best && allowed(cities[index], country, minPopulation)) {
+        best = dot;
+        at = index;
+      }
+    }
+    if (at < 0) return null;
+    const km = kmAt(here, vectors, at * 3);
+    return km > maxKm ? null : { city: cities[at], km };
+  };
+  const within = (point, km, options) => {
+    if (!isPoint(point) || !(km >= 0)) return EMPTY_AT;
+    const here = unit(point.lat, point.lon);
+    const country = countryOf(options);
+    const minPopulation = populationOf(options);
+    const limit = Math.min(km, Number.isFinite(options?.maxKm) ? options.maxKm : Infinity);
+    const least = Math.cos(Math.min(limit / EARTH_KM, Math.PI));
+    const found = [];
+    for (let index = 0; index < cities.length; index += 1) {
+      const offset = index * 3;
+      const dot = here[0] * vectors[offset] + here[1] * vectors[offset + 1] + here[2] * vectors[offset + 2];
+      if (dot < least - 1e-12 || !allowed(cities[index], country, minPopulation)) continue;
+      const away = kmAt(here, vectors, offset);
+      if (away <= limit) found.push({ city: cities[index], km: away });
+    }
+    found.sort((a, b) => a.km - b.km);
+    return Object.freeze(found);
+  };
+  return Object.freeze({
+    cities: Object.freeze(cities),
+    byId: (id) => {
+      const key = normalId(id);
+      return key === null ? null : ids.get(CITY_ALIASES[key] ?? key) ?? null;
+    },
+    inCountry: (code) => typeof code === "string" ? countries.get(code.trim().toUpperCase()) ?? EMPTY : EMPTY,
+    inSubdivision: (code) => typeof code === "string" ? subdivisions.get(code.trim().toUpperCase()) ?? EMPTY : EMPTY,
+    nearest,
+    within
+  });
+};
+var fromCountries = async (least, below) => {
+  const lists = await Promise.all(Object.values(CITY_LOADERS).map(async (load) => (await load()).CITIES));
+  return Object.freeze(lists.flatMap((list) => list.filter((city) => (city.population ?? 0) >= least && (city.population ?? 0) < below)).sort((a, b) => (b.population ?? 0) - (a.population ?? 0) || (a.id < b.id ? -1 : 1)));
+};
+var TIER_LOADERS = {
+  capitals: async () => (await import("./cities/capitals.cjs")).capitalCities(),
+  "1m": async () => (await import("./cities/1m.cjs")).cities1m(),
+  "100k": async () => (await import("./cities/100k.cjs")).cities100k(),
+  "15k": () => fromCountries(15e3, 1e5)
+};
+var loadCities = async (...tiers) => {
+  for (const tier of tiers) if (!CITY_TIERS.includes(tier)) throw new RangeError(`"${String(tier)}" is not a tier of cities: ${CITY_TIERS.join(", ")}`);
+  const lists = await Promise.all([...new Set(tiers)].map(async (tier) => await TIER_LOADERS[tier]()));
+  return citySet(...lists);
+};
+var citiesOf = async (countryCode) => {
+  const code = typeof countryCode === "string" ? countryCode.trim().toUpperCase() : "";
+  if (!isCountryCode(code)) return null;
+  const loader = CITY_LOADERS[code.toLowerCase()];
+  if (loader === void 0) return EMPTY;
+  return (await loader()).CITIES;
+};
+var cityById = async (id) => {
+  if (typeof id !== "string") return null;
+  const key = normalId(id);
+  const wanted = CITY_ALIASES[key] ?? key;
+  for (const tier of CITY_TIERS) {
+    const found = (await TIER_LOADERS[tier]()).find((city) => city.id === wanted);
+    if (found !== void 0) return found;
+  }
+  return null;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CITY_TIERS,
+  citiesOf,
+  cityById,
+  citySet,
+  loadCities
+});