@budiauktioner/buildi-primitives 0.1.0

package/dist/web/index.cjs

@@ -0,0 +1,3994 @@
+'use strict';
+
+// src/internal/input-sanitization.ts
+var FORMAT_OR_NOT_ASSIGNED = /[\p{Cf}\p{Cn}]/u;
+var SPACE_SEPARATOR = /[\p{Zs}\p{Zl}\p{Zp}]/u;
+var CONTROL = /\p{Cc}/u;
+function sanitizeInput(input) {
+  let out = "";
+  for (const c of input) {
+    if (c === "\u2018" || c === "\u2019" || c === "\u201A" || c === "\u201B") {
+      out += "'";
+      continue;
+    }
+    if (c === "\u201C" || c === "\u201D" || c === "\u201E" || c === "\u201F" || c === "\xAB" || c === "\xBB") {
+      out += '"';
+      continue;
+    }
+    if (FORMAT_OR_NOT_ASSIGNED.test(c)) {
+      continue;
+    }
+    if (CONTROL.test(c)) {
+      if (c === "	" || c === "\n" || c === "\r") out += " ";
+      continue;
+    }
+    if (SPACE_SEPARATOR.test(c)) {
+      out += " ";
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+var DEFAULT_UI_CULTURE = "sv-SE";
+var state = {
+  uiCulture: DEFAULT_UI_CULTURE};
+var PrimitivesDefaults = {
+  /**
+   * `true` when {@link uiCulture} is Swedish (`sv` or `sv-*`).
+   * Types use this to select between localized and English display names.
+   */
+  get useLocalizedDisplayNames() {
+    const lang = state.uiCulture.toLowerCase().split("-")[0];
+    return lang === "sv";
+  }};
+
+// src/text-scanning/text-candidate-category.ts
+var TextCandidateCategory = {
+  Contact: "Contact",
+  Geography: "Geography"};
+
+// src/text-scanning/text-candidate.ts
+var TextCandidate = class {
+  /** Zero-based start position in the scanned text. */
+  startIndex;
+  /** Number of characters in the original matched span. */
+  length;
+  /** The raw substring from the input text that was matched. */
+  originalText;
+  /**
+   * Short type name, e.g. `EmailAddress` or `SwedishPersonalIdentityNumber`.
+   */
+  typeName;
+  /** Broad category of the matched type. */
+  category;
+  /** Machine-comparable canonical form of the matched value. */
+  normalizedForm;
+  /** Human-readable display form of the matched value. */
+  formattedForm;
+  /**
+   * Display form with sensitive content masked (e.g. `990807-****`).
+   * Produced by the type's `toMaskedString()` helper.
+   */
+  maskedForm;
+  /** Heuristic confidence level. */
+  confidence;
+  /** The successfully parsed instance of the matched type. */
+  value;
+  constructor(opts) {
+    this.startIndex = opts.startIndex;
+    this.length = opts.length;
+    this.originalText = opts.originalText;
+    this.typeName = opts.typeName;
+    this.category = opts.category;
+    this.normalizedForm = opts.normalizedForm;
+    this.formattedForm = opts.formattedForm;
+    this.maskedForm = opts.maskedForm;
+    this.confidence = opts.confidence;
+    this.value = opts.value;
+  }
+  /** Exclusive end position (`startIndex + length`). */
+  get endIndex() {
+    return this.startIndex + this.length;
+  }
+  /** Returns `true` if this candidate's span overlaps with `other`. */
+  overlaps(other) {
+    return this.startIndex < other.endIndex && other.startIndex < this.endIndex;
+  }
+  /** Returns `true` if this candidate's span fully contains `other`. */
+  contains(other) {
+    return this.startIndex <= other.startIndex && this.endIndex >= other.endIndex;
+  }
+};
+
+// src/text-scanning/text-match-confidence.ts
+var TextMatchConfidence = {
+  /**
+   * Pattern match only. High false-positive risk — the matched text merely
+   * fits a syntactic pattern (e.g. a run of digits that happens to be the
+   * right length).
+   */
+  Low: 0,
+  /**
+   * Strong match with checksum or format-specific validation (e.g. a personal
+   * identity number with a valid Luhn check digit and plausible date, or an
+   * IBAN with valid MOD-97).
+   */
+  High: 2
+};
+
+// src/finance/currency.ts
+var KNOWN_CURRENCIES = [
+  { code: "SEK", en: "Swedish krona", sv: "Svensk krona", symbol: "kr", decimalPlaces: 2 },
+  { code: "NOK", en: "Norwegian krone", sv: "Norsk krona", symbol: "kr", decimalPlaces: 2 },
+  { code: "DKK", en: "Danish krone", sv: "Dansk krona", symbol: "kr", decimalPlaces: 2 },
+  { code: "ISK", en: "Icelandic kr\xF3na", sv: "Isl\xE4ndsk krona", symbol: "kr", decimalPlaces: 0 },
+  { code: "EUR", en: "Euro", sv: "Euro", symbol: "\u20AC", decimalPlaces: 2 },
+  {
+    code: "USD",
+    en: "United States dollar",
+    sv: "Amerikansk dollar",
+    symbol: "$",
+    decimalPlaces: 2
+  },
+  { code: "GBP", en: "Pound sterling", sv: "Brittiskt pund", symbol: "\xA3", decimalPlaces: 2 },
+  { code: "CHF", en: "Swiss franc", sv: "Schweizisk franc", symbol: "CHF", decimalPlaces: 2 },
+  { code: "JPY", en: "Japanese yen", sv: "Japansk yen", symbol: "\xA5", decimalPlaces: 0 },
+  { code: "CNY", en: "Chinese yuan", sv: "Kinesisk yuan", symbol: "\xA5", decimalPlaces: 2 },
+  { code: "CAD", en: "Canadian dollar", sv: "Kanadensisk dollar", symbol: "CA$", decimalPlaces: 2 },
+  { code: "AUD", en: "Australian dollar", sv: "Australisk dollar", symbol: "A$", decimalPlaces: 2 },
+  {
+    code: "NZD",
+    en: "New Zealand dollar",
+    sv: "Nyzeel\xE4ndsk dollar",
+    symbol: "NZ$",
+    decimalPlaces: 2
+  },
+  { code: "PLN", en: "Polish z\u0142oty", sv: "Polsk zloty", symbol: "z\u0142", decimalPlaces: 2 },
+  { code: "CZK", en: "Czech koruna", sv: "Tjeckisk koruna", symbol: "K\u010D", decimalPlaces: 2 },
+  { code: "HUF", en: "Hungarian forint", sv: "Ungersk forint", symbol: "Ft", decimalPlaces: 2 },
+  { code: "RON", en: "Romanian leu", sv: "Rum\xE4nsk leu", symbol: "lei", decimalPlaces: 2 },
+  { code: "BGN", en: "Bulgarian lev", sv: "Bulgarisk lev", symbol: "\u043B\u0432", decimalPlaces: 2 },
+  { code: "HRK", en: "Croatian kuna", sv: "Kroatisk kuna", symbol: "kn", decimalPlaces: 2 },
+  { code: "TRY", en: "Turkish lira", sv: "Turkisk lira", symbol: "\u20BA", decimalPlaces: 2 },
+  { code: "RUB", en: "Russian ruble", sv: "Rysk rubel", symbol: "\u20BD", decimalPlaces: 2 },
+  { code: "INR", en: "Indian rupee", sv: "Indisk rupie", symbol: "\u20B9", decimalPlaces: 2 },
+  { code: "BRL", en: "Brazilian real", sv: "Brasiliansk real", symbol: "R$", decimalPlaces: 2 },
+  { code: "ZAR", en: "South African rand", sv: "Sydafrikansk rand", symbol: "R", decimalPlaces: 2 },
+  { code: "MXN", en: "Mexican peso", sv: "Mexikansk peso", symbol: "MX$", decimalPlaces: 2 },
+  {
+    code: "SGD",
+    en: "Singapore dollar",
+    sv: "Singaporiansk dollar",
+    symbol: "S$",
+    decimalPlaces: 2
+  },
+  { code: "HKD", en: "Hong Kong dollar", sv: "Hongkongdollar", symbol: "HK$", decimalPlaces: 2 },
+  { code: "KRW", en: "South Korean won", sv: "Sydkoreansk won", symbol: "\u20A9", decimalPlaces: 0 },
+  { code: "THB", en: "Thai baht", sv: "Thail\xE4ndsk baht", symbol: "\u0E3F", decimalPlaces: 2 },
+  {
+    code: "TWD",
+    en: "New Taiwan dollar",
+    sv: "Taiwanesisk dollar",
+    symbol: "NT$",
+    decimalPlaces: 2
+  },
+  { code: "ILS", en: "Israeli new shekel", sv: "Israelisk shekel", symbol: "\u20AA", decimalPlaces: 2 },
+  {
+    code: "AED",
+    en: "United Arab Emirates dirham",
+    sv: "Emiratisk dirham",
+    symbol: "\u062F.\u0625",
+    decimalPlaces: 2
+  },
+  { code: "SAR", en: "Saudi riyal", sv: "Saudisk riyal", symbol: "\uFDFC", decimalPlaces: 2 },
+  { code: "PHP", en: "Philippine peso", sv: "Filippinsk peso", symbol: "\u20B1", decimalPlaces: 2 },
+  { code: "IDR", en: "Indonesian rupiah", sv: "Indonesisk rupiah", symbol: "Rp", decimalPlaces: 2 },
+  { code: "MYR", en: "Malaysian ringgit", sv: "Malaysisk ringgit", symbol: "RM", decimalPlaces: 2 },
+  { code: "VND", en: "Vietnamese \u0111\u1ED3ng", sv: "Vietnamesisk dong", symbol: "\u20AB", decimalPlaces: 0 },
+  { code: "UAH", en: "Ukrainian hryvnia", sv: "Ukrainsk hryvnia", symbol: "\u20B4", decimalPlaces: 2 },
+  { code: "EGP", en: "Egyptian pound", sv: "Egyptiskt pund", symbol: "E\xA3", decimalPlaces: 2 },
+  { code: "NGN", en: "Nigerian naira", sv: "Nigeriansk naira", symbol: "\u20A6", decimalPlaces: 2 },
+  { code: "KES", en: "Kenyan shilling", sv: "Kenyansk shilling", symbol: "KSh", decimalPlaces: 2 },
+  { code: "COP", en: "Colombian peso", sv: "Colombiansk peso", symbol: "CO$", decimalPlaces: 2 },
+  { code: "ARS", en: "Argentine peso", sv: "Argentinsk peso", symbol: "AR$", decimalPlaces: 2 },
+  { code: "CLP", en: "Chilean peso", sv: "Chilensk peso", symbol: "CL$", decimalPlaces: 0 },
+  { code: "PEN", en: "Peruvian sol", sv: "Peruansk sol", symbol: "S/.", decimalPlaces: 2 }
+];
+var Currency = class _Currency {
+  static typeInfo = Object.freeze({
+    englishName: "Currency",
+    localizedName: "Valuta",
+    emoji: "\u{1F4B1}",
+    sources: Object.freeze([
+      "https://www.iso.org/iso-4217-currency-codes.html",
+      "https://en.wikipedia.org/wiki/ISO_4217"
+    ])
+  });
+  code;
+  englishName;
+  localizedName;
+  symbol;
+  decimalPlaces;
+  constructor(row) {
+    this.code = row.code;
+    this.englishName = row.en;
+    this.localizedName = row.sv;
+    this.symbol = row.symbol;
+    this.decimalPlaces = row.decimalPlaces;
+  }
+  /** @internal */
+  static _fromRow(row) {
+    return new _Currency(row);
+  }
+  /** Display name in current UI culture (Swedish or English). */
+  /**
+   * The currency name as used in its issuing country. Falls back to
+   * {@link englishName} when no issuing country is known.
+   */
+  get nativeName() {
+    const country = Country.all.find(
+      (c) => c.currencyCode != null && c.currencyCode.toUpperCase() === this.code.toUpperCase()
+    );
+    if (country === void 0) return this.englishName;
+    return country.nativeName === country.englishName ? this.englishName : this.localizedName;
+  }
+  get displayName() {
+    return PrimitivesDefaults.useLocalizedDisplayNames ? this.localizedName : this.englishName;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const trimmed = sanitizeInput(input).trim();
+    const byCode = BY_CODE.get(trimmed.toUpperCase());
+    if (byCode) return byCode;
+    const byName = BY_NAME.get(trimmed.toLowerCase());
+    if (byName) return byName;
+    return null;
+  }
+  static parse(input) {
+    const r = _Currency.tryParse(input);
+    if (r === null) throw new Error("Unknown currency.");
+    return r;
+  }
+  static isValid(input) {
+    return _Currency.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _Currency.tryParse(input);
+    if (r) return r.displayName;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _Currency.tryParse(input);
+    if (r) return r.code;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _Currency.normalize(input) === input;
+  }
+  /** All known currencies. */
+  static get all() {
+    return ALL_CURRENCIES;
+  }
+  /** @internal Lookup by symbol. */
+  static tryParseSymbol(symbol) {
+    if (symbol == null || symbol.trim() === "") return null;
+    return BY_SYMBOL.get(symbol.trim().toLowerCase()) ?? null;
+  }
+  toNormalizedString() {
+    return this.code;
+  }
+  toString() {
+    return this.displayName;
+  }
+  toDisplayString() {
+    return this.displayName;
+  }
+  toEnglishString() {
+    return this.englishName;
+  }
+  toNativeString() {
+    return this.nativeName;
+  }
+  equals(other) {
+    return other != null && this.code === other.code;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.code < other.code ? -1 : this.code > other.code ? 1 : 0;
+  }
+  static get SEK() {
+    return BY_CODE.get("SEK");
+  }
+  static get EUR() {
+    return BY_CODE.get("EUR");
+  }
+  static get USD() {
+    return BY_CODE.get("USD");
+  }
+  static get NOK() {
+    return BY_CODE.get("NOK");
+  }
+  static get DKK() {
+    return BY_CODE.get("DKK");
+  }
+  static get GBP() {
+    return BY_CODE.get("GBP");
+  }
+};
+var ALL_CURRENCIES = KNOWN_CURRENCIES.map((r) => Currency._fromRow(r));
+var BY_CODE = /* @__PURE__ */ new Map();
+for (const c of ALL_CURRENCIES) BY_CODE.set(c.code.toUpperCase(), c);
+var BY_NAME = /* @__PURE__ */ new Map();
+for (const c of ALL_CURRENCIES) {
+  BY_NAME.set(c.englishName.toLowerCase(), c);
+  BY_NAME.set(c.localizedName.toLowerCase(), c);
+}
+var BY_SYMBOL = /* @__PURE__ */ new Map();
+for (const c of ALL_CURRENCIES) {
+  if (!BY_SYMBOL.has(c.symbol.toLowerCase())) BY_SYMBOL.set(c.symbol.toLowerCase(), c);
+}
+
+// src/geography/geo-coordinate.ts
+var GeoCoordinate = class _GeoCoordinate {
+  static typeInfo = Object.freeze({
+    englishName: "Geographic Coordinate",
+    localizedName: "Geografisk koordinat",
+    emoji: "\u{1F4CD}",
+    sources: Object.freeze([
+      "https://en.wikipedia.org/wiki/Geographic_coordinate_system",
+      "https://epsg.io/4326"
+    ])
+  });
+  latitude;
+  longitude;
+  constructor(latitude, longitude) {
+    this.latitude = latitude;
+    this.longitude = longitude;
+  }
+  /** @internal */
+  static _unsafe(latitude, longitude) {
+    return new _GeoCoordinate(latitude, longitude);
+  }
+  get latitudeDirection() {
+    return this.latitude >= 0 ? "N" : "S";
+  }
+  get longitudeDirection() {
+    return this.longitude >= 0 ? "E" : "W";
+  }
+  /** Creates a coordinate from explicit latitude and longitude values. */
+  static create(latitude, longitude) {
+    if (!Number.isFinite(latitude) || latitude < -90 || latitude > 90) {
+      throw new RangeError("Latitude must be between -90 and 90.");
+    }
+    if (!Number.isFinite(longitude) || longitude < -180 || longitude > 180) {
+      throw new RangeError("Longitude must be between -180 and 180.");
+    }
+    return _GeoCoordinate._unsafe(latitude, longitude);
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const sanitized = sanitizeInput(input).trim();
+    if (sanitized.length === 0 || sanitized.length > 200) return null;
+    let m;
+    m = sanitized.match(DECIMAL_DEGREES);
+    if (m) return tryDecimal(m.groups.lat, m.groups.lon);
+    m = sanitized.match(SPACE_SEPARATED);
+    if (m) return tryDecimal(m.groups.lat, m.groups.lon);
+    m = sanitized.match(DECIMAL_CARDINAL_SUFFIX);
+    if (m) {
+      return tryDecimalCardinal(
+        m.groups.lat,
+        m.groups.latDir,
+        m.groups.lon,
+        m.groups.lonDir
+      );
+    }
+    m = sanitized.match(CARDINAL_PREFIX);
+    if (m) {
+      return tryDecimalCardinal(
+        m.groups.lat,
+        m.groups.latDir,
+        m.groups.lon,
+        m.groups.lonDir
+      );
+    }
+    m = sanitized.match(DMS);
+    if (m) return tryDms(m.groups);
+    m = sanitized.match(DDM);
+    if (m) return tryDdm(m.groups);
+    return null;
+  }
+  static parse(input) {
+    const r = _GeoCoordinate.tryParse(input);
+    if (r === null) throw new Error("Invalid geographic coordinate.");
+    return r;
+  }
+  static isValid(input) {
+    return _GeoCoordinate.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _GeoCoordinate.tryParse(input);
+    if (r) return r.toString();
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _GeoCoordinate.tryParse(input);
+    if (r) return r.toNormalizedString();
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null) {
+      const trimmed = input.trim();
+      return trimmed.length > 0 ? trimmed : null;
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _GeoCoordinate.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return `${formatNumber(this.latitude)}, ${formatNumber(this.longitude)}`;
+  }
+  toString() {
+    return `${formatNumber(Math.abs(this.latitude))}\xB0${this.latitudeDirection}, ${formatNumber(Math.abs(this.longitude))}\xB0${this.longitudeDirection}`;
+  }
+  /** Returns the coordinate in degrees, minutes, and seconds, e.g. `59°19'45.5"N, 18°4'7"E`. */
+  toDmsString() {
+    const [latDeg, latMin, latSec] = toDmsParts(Math.abs(this.latitude));
+    const [lonDeg, lonMin, lonSec] = toDmsParts(Math.abs(this.longitude));
+    return `${latDeg}\xB0${latMin}'${formatSeconds(latSec)}"${this.latitudeDirection}, ${lonDeg}\xB0${lonMin}'${formatSeconds(lonSec)}"${this.longitudeDirection}`;
+  }
+  /** Distance in kilometers (Haversine) between two coordinates. */
+  static distanceKilometers(a, b) {
+    return haversineKm(a, b);
+  }
+  /** Returns true if coordinates `a` and `b` are within `radiusKm` kilometers of each other. */
+  static isWithinKilometers(a, b, radiusKm) {
+    return _GeoCoordinate.distanceKilometers(a, b) <= radiusKm;
+  }
+  /** Distance in kilometers from this coordinate to `other`. */
+  distanceKilometersTo(other) {
+    return haversineKm(this, other);
+  }
+  /**
+   * Returns true if `other` is within `radiusKm` kilometers of this
+   * coordinate (inclusive).
+   */
+  isWithinKilometers(other, radiusKm) {
+    return this.distanceKilometersTo(other) <= radiusKm;
+  }
+  equals(other) {
+    return other != null && this.latitude === other.latitude && this.longitude === other.longitude;
+  }
+};
+var DECIMAL_DEGREES = /^\s*\(?\s*(?<lat>[+-]?\d+(?:\.\d+)?)\s*[,;]\s*(?<lon>[+-]?\d+(?:\.\d+)?)\s*\)?\s*$/;
+var SPACE_SEPARATED = /^\s*\(?\s*(?<lat>[+-]?\d+(?:\.\d+)?)\s+(?<lon>[+-]?\d+(?:\.\d+)?)\s*\)?\s*$/;
+var DECIMAL_CARDINAL_SUFFIX = /^\s*\(?\s*(?<lat>\d+(?:\.\d+)?)\s*°?\s*(?<latDir>[NSns])\s*[,;\s]\s*(?<lon>\d+(?:\.\d+)?)\s*°?\s*(?<lonDir>[EWewÖöVv])\s*\)?\s*$/u;
+var CARDINAL_PREFIX = /^\s*\(?\s*(?<latDir>[NSns])\s*(?<lat>\d+(?:\.\d+)?)\s*°?\s*[,;\s]\s*(?<lonDir>[EWewÖöVv])\s*(?<lon>\d+(?:\.\d+)?)\s*°?\s*\)?\s*$/u;
+var DMS = /^\s*\(?\s*(?<latDeg>\d+)\s*°\s*(?<latMin>\d+)\s*[′']\s*(?<latSec>\d+(?:\.\d+)?)\s*[″"]\s*(?<latDir>[NSns])\s*[,;\s]\s*(?<lonDeg>\d+)\s*°\s*(?<lonMin>\d+)\s*[′']\s*(?<lonSec>\d+(?:\.\d+)?)\s*[″"]\s*(?<lonDir>[EWewÖöVv])\s*\)?\s*$/u;
+var DDM = /^\s*\(?\s*(?<latDeg>\d+)\s*°\s*(?<latDecMin>\d+(?:\.\d+)?)\s*[′']\s*(?<latDir>[NSns])\s*[,;\s]\s*(?<lonDeg>\d+)\s*°\s*(?<lonDecMin>\d+(?:\.\d+)?)\s*[′']\s*(?<lonDir>[EWewÖöVv])\s*\)?\s*$/u;
+function tryDecimal(latStr, lonStr) {
+  const lat = parseFloat(latStr);
+  const lon = parseFloat(lonStr);
+  if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+  if (!isInRange(lat, lon)) return null;
+  return GeoCoordinate._unsafe(lat, lon);
+}
+function tryDecimalCardinal(latStr, latDir, lonStr, lonDir) {
+  const lat = applyLatDirection(parseFloat(latStr), latDir);
+  const lon = applyLonDirection(parseFloat(lonStr), lonDir);
+  if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+  if (!isInRange(lat, lon)) return null;
+  return GeoCoordinate._unsafe(lat, lon);
+}
+function tryDms(g) {
+  const latDeg = parseFloat(g.latDeg);
+  const latMin = parseFloat(g.latMin);
+  const latSec = parseFloat(g.latSec);
+  const lonDeg = parseFloat(g.lonDeg);
+  const lonMin = parseFloat(g.lonMin);
+  const lonSec = parseFloat(g.lonSec);
+  if (latMin >= 60 || latSec >= 60 || lonMin >= 60 || lonSec >= 60) return null;
+  let lat = round8(latDeg + latMin / 60 + latSec / 3600);
+  let lon = round8(lonDeg + lonMin / 60 + lonSec / 3600);
+  lat = applyLatDirection(lat, g.latDir);
+  lon = applyLonDirection(lon, g.lonDir);
+  if (!isInRange(lat, lon)) return null;
+  return GeoCoordinate._unsafe(lat, lon);
+}
+function tryDdm(g) {
+  const latDeg = parseFloat(g.latDeg);
+  const latDecMin = parseFloat(g.latDecMin);
+  const lonDeg = parseFloat(g.lonDeg);
+  const lonDecMin = parseFloat(g.lonDecMin);
+  if (latDecMin >= 60 || lonDecMin >= 60) return null;
+  let lat = round8(latDeg + latDecMin / 60);
+  let lon = round8(lonDeg + lonDecMin / 60);
+  lat = applyLatDirection(lat, g.latDir);
+  lon = applyLonDirection(lon, g.lonDir);
+  if (!isInRange(lat, lon)) return null;
+  return GeoCoordinate._unsafe(lat, lon);
+}
+function applyLatDirection(lat, dir) {
+  return dir.toUpperCase() === "S" ? -lat : lat;
+}
+function applyLonDirection(lon, dir) {
+  const u = dir.toUpperCase();
+  return u === "W" || u === "V" ? -lon : lon;
+}
+function isInRange(lat, lon) {
+  return lat >= -90 && lat <= 90 && lon >= -180 && lon <= 180;
+}
+function round8(v) {
+  return Math.round(v * 1e8) / 1e8;
+}
+function toDmsParts(dd) {
+  const degrees = Math.trunc(dd);
+  const fracMinutes = (dd - degrees) * 60;
+  const minutes = Math.trunc(fracMinutes);
+  const seconds = Math.round((fracMinutes - minutes) * 600) / 10;
+  return [degrees, minutes, seconds];
+}
+function formatNumber(value) {
+  return value.toString();
+}
+function formatSeconds(seconds) {
+  if (Number.isInteger(seconds)) return seconds.toString();
+  return seconds.toString().replace(/(\.\d*?)0+$/, "$1");
+}
+function haversineKm(a, b) {
+  const R = 6371;
+  const dLat = toRadians(b.latitude - a.latitude);
+  const dLon = toRadians(b.longitude - a.longitude);
+  const lat1 = toRadians(a.latitude);
+  const lat2 = toRadians(b.latitude);
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) ** 2;
+  return R * 2 * Math.atan2(Math.sqrt(h), Math.sqrt(1 - h));
+}
+function toRadians(degrees) {
+  return degrees * (Math.PI / 180);
+}
+
+// src/geography/language.ts
+var TextDirection = {
+  LeftToRight: "LeftToRight",
+  RightToLeft: "RightToLeft"
+};
+var WritingScript = {
+  Unknown: "Unknown",
+  Latin: "Latin",
+  Cyrillic: "Cyrillic",
+  Arabic: "Arabic",
+  Greek: "Greek",
+  Hebrew: "Hebrew",
+  Devanagari: "Devanagari",
+  Bengali: "Bengali",
+  Gurmukhi: "Gurmukhi",
+  Gujarati: "Gujarati",
+  Oriya: "Oriya",
+  Tamil: "Tamil",
+  Telugu: "Telugu",
+  Kannada: "Kannada",
+  Malayalam: "Malayalam",
+  Sinhala: "Sinhala",
+  Thai: "Thai",
+  Lao: "Lao",
+  Tibetan: "Tibetan",
+  Myanmar: "Myanmar",
+  Georgian: "Georgian",
+  Hangul: "Hangul",
+  Ethiopic: "Ethiopic",
+  Canadian: "Canadian",
+  Khmer: "Khmer",
+  Han: "Han",
+  Armenian: "Armenian",
+  Thaana: "Thaana"
+};
+var MAX_INPUT_LENGTH = 100;
+var Language = class _Language {
+  static typeInfo = Object.freeze({
+    englishName: "Language",
+    localizedName: "Spr\xE5k",
+    emoji: "\u{1F5E3}\uFE0F",
+    sources: Object.freeze([
+      "https://www.loc.gov/standards/iso639-2/php/code_list.php",
+      "https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes",
+      "https://iso639-3.sil.org/"
+    ])
+  });
+  alpha2Code;
+  alpha3Code;
+  englishName;
+  localizedName;
+  nativeName;
+  script;
+  direction;
+  constructor(alpha2, alpha3, en, sv, native, script, direction) {
+    this.alpha2Code = alpha2;
+    this.alpha3Code = alpha3;
+    this.englishName = en;
+    this.localizedName = sv;
+    this.nativeName = native;
+    this.script = script;
+    this.direction = direction;
+  }
+  get displayName() {
+    return PrimitivesDefaults.useLocalizedDisplayNames ? this.localizedName : this.englishName;
+  }
+  get value() {
+    return this.alpha2Code;
+  }
+  /** @internal Used by Country and other types. */
+  static _create(alpha2, alpha3, en, sv, native, script, direction = TextDirection.LeftToRight) {
+    return new _Language(alpha2, alpha3, en, sv, native, script, direction);
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const trimmed = sanitizeInput(input).trim();
+    if (trimmed.length === 0 || trimmed.length > MAX_INPUT_LENGTH) return null;
+    const lower = trimmed.toLowerCase();
+    return BY_KEY.get(lower) ?? null;
+  }
+  static parse(input) {
+    const r = _Language.tryParse(input);
+    if (r === null) throw new Error("Unknown language.");
+    return r;
+  }
+  static isValid(input) {
+    return _Language.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _Language.tryParse(input);
+    if (r) return r.displayName;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _Language.tryParse(input);
+    if (r) return r.alpha2Code;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null) {
+      const trimmed = input.trim();
+      return trimmed.length > 0 ? trimmed : null;
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _Language.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return this.alpha2Code;
+  }
+  toDisplayString() {
+    return this.displayName;
+  }
+  toEnglishString() {
+    return this.englishName;
+  }
+  toNativeString() {
+    return this.nativeName;
+  }
+  toString() {
+    return this.displayName;
+  }
+  equals(other) {
+    return other != null && this.alpha2Code === other.alpha2Code;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.alpha2Code < other.alpha2Code ? -1 : this.alpha2Code > other.alpha2Code ? 1 : 0;
+  }
+  /** All recognized ISO 639-1 languages. */
+  static get all() {
+    return ALL;
+  }
+  // Frequently used language constants — populated below ALL.
+  static Afrikaans;
+  static Albanian;
+  static Arabic;
+  static Bulgarian;
+  static Catalan;
+  static Chinese;
+  static Croatian;
+  static Czech;
+  static Danish;
+  static Dutch;
+  static English;
+  static Estonian;
+  static Faroese;
+  static Finnish;
+  static French;
+  static German;
+  static Greek;
+  static Hindi;
+  static Hungarian;
+  static Icelandic;
+  static Italian;
+  static Japanese;
+  static Korean;
+  static Latvian;
+  static Lithuanian;
+  static NorthernSami;
+  static Norwegian;
+  static NorwegianBokmal;
+  static NorwegianNynorsk;
+  static Polish;
+  static Portuguese;
+  static Romanian;
+  static Russian;
+  static Slovak;
+  static Slovenian;
+  static Spanish;
+  static Swahili;
+  static Swedish;
+  static Turkish;
+  static Ukrainian;
+};
+var L = Language._create;
+var ALL = Object.freeze([
+  L("aa", "aar", "Afar", "Afar", "Afaraf", WritingScript.Latin),
+  L("ab", "abk", "Abkhazian", "Abchaziska", "\u0410\u04A7\u0441\u0443\u0430", WritingScript.Cyrillic),
+  L("af", "afr", "Afrikaans", "Afrikaans", "Afrikaans", WritingScript.Latin),
+  L("ak", "aka", "Akan", "Akan", "Akan", WritingScript.Latin),
+  L("am", "amh", "Amharic", "Amhariska", "\u12A0\u121B\u122D\u129B", WritingScript.Ethiopic),
+  L("an", "arg", "Aragonese", "Aragonesiska", "Aragon\xE9s", WritingScript.Latin),
+  L("ar", "ara", "Arabic", "Arabiska", "\u0627\u0644\u0639\u0631\u0628\u064A\u0629", WritingScript.Arabic, TextDirection.RightToLeft),
+  L("as", "asm", "Assamese", "Assamesiska", "\u0985\u09B8\u09AE\u09C0\u09AF\u09BC\u09BE", WritingScript.Bengali),
+  L("av", "ava", "Avaric", "Avariska", "\u0410\u0432\u0430\u0440", WritingScript.Cyrillic),
+  L("ay", "aym", "Aymara", "Aymara", "Aymar", WritingScript.Latin),
+  L("az", "aze", "Azerbaijani", "Azerbajdzjanska", "Az\u0259rbaycan", WritingScript.Latin),
+  L("ba", "bak", "Bashkir", "Basjkiriska", "\u0411\u0430\u0448\u04A1\u043E\u0440\u0442", WritingScript.Cyrillic),
+  L("be", "bel", "Belarusian", "Vitryska", "\u0411\u0435\u043B\u0430\u0440\u0443\u0441\u043A\u0430\u044F", WritingScript.Cyrillic),
+  L("bg", "bul", "Bulgarian", "Bulgariska", "\u0411\u044A\u043B\u0433\u0430\u0440\u0441\u043A\u0438", WritingScript.Cyrillic),
+  L("bh", "bih", "Bihari", "Bihari", "\u092D\u094B\u091C\u092A\u0941\u0930\u0940", WritingScript.Devanagari),
+  L("bi", "bis", "Bislama", "Bislama", "Bislama", WritingScript.Latin),
+  L("bm", "bam", "Bambara", "Bambara", "Bamanankan", WritingScript.Latin),
+  L("bn", "ben", "Bengali", "Bengali", "\u09AC\u09BE\u0982\u09B2\u09BE", WritingScript.Bengali),
+  L("bo", "bod", "Tibetan", "Tibetanska", "\u0F56\u0F7C\u0F51\u0F0B\u0F61\u0F72\u0F42", WritingScript.Tibetan),
+  L("br", "bre", "Breton", "Bretonska", "Brezhoneg", WritingScript.Latin),
+  L("bs", "bos", "Bosnian", "Bosniska", "Bosanski", WritingScript.Latin),
+  L("ca", "cat", "Catalan", "Katalanska", "Catal\xE0", WritingScript.Latin),
+  L("ce", "che", "Chechen", "Tjetjenska", "\u041D\u043E\u0445\u0447\u0438\u0439\u043D", WritingScript.Cyrillic),
+  L("ch", "cha", "Chamorro", "Chamorro", "Chamoru", WritingScript.Latin),
+  L("co", "cos", "Corsican", "Korsikanska", "Corsu", WritingScript.Latin),
+  L("cr", "cre", "Cree", "Cree", "\u14C0\u1426\u1403\u152D\u140D\u140F\u1423", WritingScript.Canadian),
+  L("cs", "ces", "Czech", "Tjeckiska", "\u010Ce\u0161tina", WritingScript.Latin),
+  L("cu", "chu", "Church Slavonic", "Kyrkoslaviska", "\u0421\u043B\u043E\u0432\u0463\u043D\u044C\u0441\u043A\u044A", WritingScript.Cyrillic),
+  L("cv", "chv", "Chuvash", "Tjuvasjiska", "\u0427\u04D1\u0432\u0430\u0448", WritingScript.Cyrillic),
+  L("cy", "cym", "Welsh", "Walesiska", "Cymraeg", WritingScript.Latin),
+  L("da", "dan", "Danish", "Danska", "Dansk", WritingScript.Latin),
+  L("de", "deu", "German", "Tyska", "Deutsch", WritingScript.Latin),
+  L("dv", "div", "Divehi", "Divehi", "\u078B\u07A8\u0788\u07AC\u0780\u07A8", WritingScript.Thaana, TextDirection.RightToLeft),
+  L("dz", "dzo", "Dzongkha", "Dzongkha", "\u0F62\u0FAB\u0F7C\u0F44\u0F0B\u0F41", WritingScript.Tibetan),
+  L("ee", "ewe", "Ewe", "Ewe", "E\u028Begbe", WritingScript.Latin),
+  L("el", "ell", "Greek", "Grekiska", "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC", WritingScript.Greek),
+  L("en", "eng", "English", "Engelska", "English", WritingScript.Latin),
+  L("eo", "epo", "Esperanto", "Esperanto", "Esperanto", WritingScript.Latin),
+  L("es", "spa", "Spanish", "Spanska", "Espa\xF1ol", WritingScript.Latin),
+  L("et", "est", "Estonian", "Estniska", "Eesti", WritingScript.Latin),
+  L("eu", "eus", "Basque", "Baskiska", "Euskara", WritingScript.Latin),
+  L("fa", "fas", "Persian", "Persiska", "\u0641\u0627\u0631\u0633\u06CC", WritingScript.Arabic, TextDirection.RightToLeft),
+  L("ff", "ful", "Fulah", "Fulani", "Fulfulde", WritingScript.Latin),
+  L("fi", "fin", "Finnish", "Finska", "Suomi", WritingScript.Latin),
+  L("fj", "fij", "Fijian", "Fijianska", "Vosa Vakaviti", WritingScript.Latin),
+  L("fo", "fao", "Faroese", "F\xE4r\xF6iska", "F\xF8royskt", WritingScript.Latin),
+  L("fr", "fra", "French", "Franska", "Fran\xE7ais", WritingScript.Latin),
+  L("fy", "fry", "Western Frisian", "Frisiska", "Frysk", WritingScript.Latin),
+  L("ga", "gle", "Irish", "Iriska", "Gaeilge", WritingScript.Latin),
+  L("gd", "gla", "Scottish Gaelic", "Skotsk gaeliska", "G\xE0idhlig", WritingScript.Latin),
+  L("gl", "glg", "Galician", "Galiciska", "Galego", WritingScript.Latin),
+  L("gn", "grn", "Guarani", "Guaran\xED", "Ava\xF1e'\u1EBD", WritingScript.Latin),
+  L("gu", "guj", "Gujarati", "Gujarati", "\u0A97\u0AC1\u0A9C\u0AB0\u0ABE\u0AA4\u0AC0", WritingScript.Gujarati),
+  L("gv", "glv", "Manx", "Manx", "Gaelg", WritingScript.Latin),
+  L("ha", "hau", "Hausa", "Hausa", "Hausa", WritingScript.Latin),
+  L("he", "heb", "Hebrew", "Hebreiska", "\u05E2\u05D1\u05E8\u05D9\u05EA", WritingScript.Hebrew, TextDirection.RightToLeft),
+  L("hi", "hin", "Hindi", "Hindi", "\u0939\u093F\u0928\u094D\u0926\u0940", WritingScript.Devanagari),
+  L("ho", "hmo", "Hiri Motu", "Hiri Motu", "Hiri Motu", WritingScript.Latin),
+  L("hr", "hrv", "Croatian", "Kroatiska", "Hrvatski", WritingScript.Latin),
+  L("ht", "hat", "Haitian Creole", "Haitisk kreol", "Krey\xF2l Ayisyen", WritingScript.Latin),
+  L("hu", "hun", "Hungarian", "Ungerska", "Magyar", WritingScript.Latin),
+  L("hy", "hye", "Armenian", "Armeniska", "\u0540\u0561\u0575\u0565\u0580\u0565\u0576", WritingScript.Armenian),
+  L("ia", "ina", "Interlingua", "Interlingua", "Interlingua", WritingScript.Latin),
+  L("id", "ind", "Indonesian", "Indonesiska", "Bahasa Indonesia", WritingScript.Latin),
+  L("ie", "ile", "Interlingue", "Interlingue", "Interlingue", WritingScript.Latin),
+  L("ig", "ibo", "Igbo", "Igbo", "Igbo", WritingScript.Latin),
+  L("ii", "iii", "Sichuan Yi", "Yi", "\uA188\uA320\uA4A1", WritingScript.Unknown),
+  L("ik", "ipk", "Inupiaq", "Inupiaq", "I\xF1upiaq", WritingScript.Latin),
+  L("io", "ido", "Ido", "Ido", "Ido", WritingScript.Latin),
+  L("is", "isl", "Icelandic", "Isl\xE4ndska", "\xCDslenska", WritingScript.Latin),
+  L("it", "ita", "Italian", "Italienska", "Italiano", WritingScript.Latin),
+  L("iu", "iku", "Inuktitut", "Inuktitut", "\u1403\u14C4\u1483\u144E\u1450\u1466", WritingScript.Canadian),
+  L("ja", "jpn", "Japanese", "Japanska", "\u65E5\u672C\u8A9E", WritingScript.Han),
+  L("jv", "jav", "Javanese", "Javanesiska", "Basa Jawa", WritingScript.Latin),
+  L("ka", "kat", "Georgian", "Georgiska", "\u10E5\u10D0\u10E0\u10D7\u10E3\u10DA\u10D8", WritingScript.Georgian),
+  L("kg", "kon", "Kongo", "Kikongo", "KiKongo", WritingScript.Latin),
+  L("ki", "kik", "Kikuyu", "Kikuyu", "G\u0129k\u0169y\u0169", WritingScript.Latin),
+  L("kj", "kua", "Kuanyama", "Kuanyama", "Kuanyama", WritingScript.Latin),
+  L("kk", "kaz", "Kazakh", "Kazakiska", "\u049A\u0430\u0437\u0430\u049B\u0448\u0430", WritingScript.Cyrillic),
+  L("kl", "kal", "Kalaallisut", "Gr\xF6nl\xE4ndska", "Kalaallisut", WritingScript.Latin),
+  L("km", "khm", "Khmer", "Khmer", "\u1797\u17B6\u179F\u17B6\u1781\u17D2\u1798\u17C2\u179A", WritingScript.Khmer),
+  L("kn", "kan", "Kannada", "Kannada", "\u0C95\u0CA8\u0CCD\u0CA8\u0CA1", WritingScript.Kannada),
+  L("ko", "kor", "Korean", "Koreanska", "\uD55C\uAD6D\uC5B4", WritingScript.Hangul),
+  L("kr", "kau", "Kanuri", "Kanuri", "Kanuri", WritingScript.Latin),
+  L(
+    "ks",
+    "kas",
+    "Kashmiri",
+    "Kashmiri",
+    "\u0915\u0936\u094D\u092E\u0940\u0930\u0940",
+    WritingScript.Arabic,
+    TextDirection.RightToLeft
+  ),
+  L("ku", "kur", "Kurdish", "Kurdiska", "Kurd\xEE", WritingScript.Latin),
+  L("kv", "kom", "Komi", "Komi", "\u041A\u043E\u043C\u0438", WritingScript.Cyrillic),
+  L("kw", "cor", "Cornish", "Korniska", "Kernewek", WritingScript.Latin),
+  L("ky", "kir", "Kyrgyz", "Kirgiziska", "\u041A\u044B\u0440\u0433\u044B\u0437\u0447\u0430", WritingScript.Cyrillic),
+  L("la", "lat", "Latin", "Latin", "Latina", WritingScript.Latin),
+  L("lb", "ltz", "Luxembourgish", "Luxemburgiska", "L\xEBtzebuergesch", WritingScript.Latin),
+  L("lg", "lug", "Ganda", "Luganda", "Luganda", WritingScript.Latin),
+  L("li", "lim", "Limburgish", "Limburgiska", "Limburgs", WritingScript.Latin),
+  L("ln", "lin", "Lingala", "Lingala", "Ling\xE1la", WritingScript.Latin),
+  L("lo", "lao", "Lao", "Laotiska", "\u0E9E\u0EB2\u0EAA\u0EB2\u0EA5\u0EB2\u0EA7", WritingScript.Lao),
+  L("lt", "lit", "Lithuanian", "Litauiska", "Lietuvi\u0173", WritingScript.Latin),
+  L("lu", "lub", "Luba-Katanga", "Luba-Katanga", "Kiluba", WritingScript.Latin),
+  L("lv", "lav", "Latvian", "Lettiska", "Latvie\u0161u", WritingScript.Latin),
+  L("mg", "mlg", "Malagasy", "Malagassiska", "Malagasy", WritingScript.Latin),
+  L("mh", "mah", "Marshallese", "Marshallesiska", "Kajin M\u0327aje\u013C", WritingScript.Latin),
+  L("mi", "mri", "Maori", "Maori", "Te Reo M\u0101ori", WritingScript.Latin),
+  L("mk", "mkd", "Macedonian", "Makedonska", "\u041C\u0430\u043A\u0435\u0434\u043E\u043D\u0441\u043A\u0438", WritingScript.Cyrillic),
+  L("ml", "mal", "Malayalam", "Malayalam", "\u0D2E\u0D32\u0D2F\u0D3E\u0D33\u0D02", WritingScript.Malayalam),
+  L("mn", "mon", "Mongolian", "Mongoliska", "\u041C\u043E\u043D\u0433\u043E\u043B", WritingScript.Cyrillic),
+  L("mr", "mar", "Marathi", "Marathi", "\u092E\u0930\u093E\u0920\u0940", WritingScript.Devanagari),
+  L("ms", "msa", "Malay", "Malajiska", "Bahasa Melayu", WritingScript.Latin),
+  L("mt", "mlt", "Maltese", "Maltesiska", "Malti", WritingScript.Latin),
+  L("my", "mya", "Burmese", "Burmesiska", "\u1019\u103C\u1014\u103A\u1019\u102C\u1005\u102C", WritingScript.Myanmar),
+  L("na", "nau", "Nauru", "Nauru", "Dorerin Naoero", WritingScript.Latin),
+  L("nb", "nob", "Norwegian Bokm\xE5l", "Norska (bokm\xE5l)", "Norsk bokm\xE5l", WritingScript.Latin),
+  L("nd", "nde", "Northern Ndebele", "Nordndebele", "isiNdebele", WritingScript.Latin),
+  L("ne", "nep", "Nepali", "Nepalesiska", "\u0928\u0947\u092A\u093E\u0932\u0940", WritingScript.Devanagari),
+  L("ng", "ndo", "Ndonga", "Ndonga", "Owambo", WritingScript.Latin),
+  L("nl", "nld", "Dutch", "Nederl\xE4ndska", "Nederlands", WritingScript.Latin),
+  L("nn", "nno", "Norwegian Nynorsk", "Norska (nynorsk)", "Norsk nynorsk", WritingScript.Latin),
+  L("no", "nor", "Norwegian", "Norska", "Norsk", WritingScript.Latin),
+  L("nr", "nbl", "Southern Ndebele", "Sydndebele", "isiNdebele", WritingScript.Latin),
+  L("nv", "nav", "Navajo", "Navajo", "Din\xE9 Bizaad", WritingScript.Latin),
+  L("ny", "nya", "Chichewa", "Chichewa", "Chichewa", WritingScript.Latin),
+  L("oc", "oci", "Occitan", "Occitanska", "Occitan", WritingScript.Latin),
+  L("oj", "oji", "Ojibwa", "Ojibwa", "\u140A\u14C2\u1511\u14C8\u142F\u14A7\u140E\u14D0", WritingScript.Canadian),
+  L("om", "orm", "Oromo", "Oromo", "Afaan Oromoo", WritingScript.Latin),
+  L("or", "ori", "Oriya", "Oriya", "\u0B13\u0B21\u0B3C\u0B3F\u0B06", WritingScript.Oriya),
+  L("os", "oss", "Ossetian", "Ossetiska", "\u0418\u0440\u043E\u043D", WritingScript.Cyrillic),
+  L("pa", "pan", "Punjabi", "Punjabi", "\u0A2A\u0A70\u0A1C\u0A3E\u0A2C\u0A40", WritingScript.Gurmukhi),
+  L("pi", "pli", "Pali", "Pali", "\u092A\u093E\u0932\u093F", WritingScript.Devanagari),
+  L("pl", "pol", "Polish", "Polska", "Polski", WritingScript.Latin),
+  L("ps", "pus", "Pashto", "Pashto", "\u067E\u069A\u062A\u0648", WritingScript.Arabic, TextDirection.RightToLeft),
+  L("pt", "por", "Portuguese", "Portugisiska", "Portugu\xEAs", WritingScript.Latin),
+  L("qu", "que", "Quechua", "Quechua", "Runa Simi", WritingScript.Latin),
+  L("rm", "roh", "Romansh", "R\xE4toromanska", "Rumantsch", WritingScript.Latin),
+  L("rn", "run", "Rundi", "Kirundi", "Ikirundi", WritingScript.Latin),
+  L("ro", "ron", "Romanian", "Rum\xE4nska", "Rom\xE2n\u0103", WritingScript.Latin),
+  L("ru", "rus", "Russian", "Ryska", "\u0420\u0443\u0441\u0441\u043A\u0438\u0439", WritingScript.Cyrillic),
+  L("rw", "kin", "Kinyarwanda", "Kinyarwanda", "Ikinyarwanda", WritingScript.Latin),
+  L("sa", "san", "Sanskrit", "Sanskrit", "\u0938\u0902\u0938\u094D\u0915\u0943\u0924\u092E\u094D", WritingScript.Devanagari),
+  L("sc", "srd", "Sardinian", "Sardiska", "Sardu", WritingScript.Latin),
+  L("sd", "snd", "Sindhi", "Sindhi", "\u0633\u0646\u068C\u064A", WritingScript.Arabic, TextDirection.RightToLeft),
+  L("se", "sme", "Northern Sami", "Nordsamiska", "Davvis\xE1megiella", WritingScript.Latin),
+  L("sg", "sag", "Sango", "Sango", "Y\xE2ng\xE2 t\xEE S\xE4ng\xF6", WritingScript.Latin),
+  L("si", "sin", "Sinhala", "Singalesiska", "\u0DC3\u0DD2\u0D82\u0DC4\u0DBD", WritingScript.Sinhala),
+  L("sk", "slk", "Slovak", "Slovakiska", "Sloven\u010Dina", WritingScript.Latin),
+  L("sl", "slv", "Slovenian", "Slovenska", "Sloven\u0161\u010Dina", WritingScript.Latin),
+  L("sm", "smo", "Samoan", "Samoanska", "Gagana S\u0101moa", WritingScript.Latin),
+  L("sn", "sna", "Shona", "Shona", "ChiShona", WritingScript.Latin),
+  L("so", "som", "Somali", "Somaliska", "Soomaali", WritingScript.Latin),
+  L("sq", "sqi", "Albanian", "Albanska", "Shqip", WritingScript.Latin),
+  L("sr", "srp", "Serbian", "Serbiska", "\u0421\u0440\u043F\u0441\u043A\u0438", WritingScript.Cyrillic),
+  L("ss", "ssw", "Swati", "Swati", "SiSwati", WritingScript.Latin),
+  L("st", "sot", "Southern Sotho", "Sotho", "Sesotho", WritingScript.Latin),
+  L("su", "sun", "Sundanese", "Sundanesiska", "Basa Sunda", WritingScript.Latin),
+  L("sv", "swe", "Swedish", "Svenska", "Svenska", WritingScript.Latin),
+  L("sw", "swa", "Swahili", "Swahili", "Kiswahili", WritingScript.Latin),
+  L("ta", "tam", "Tamil", "Tamil", "\u0BA4\u0BAE\u0BBF\u0BB4\u0BCD", WritingScript.Tamil),
+  L("te", "tel", "Telugu", "Telugu", "\u0C24\u0C46\u0C32\u0C41\u0C17\u0C41", WritingScript.Telugu),
+  L("tg", "tgk", "Tajik", "Tadzjikiska", "\u0422\u043E\u04B7\u0438\u043A\u04E3", WritingScript.Cyrillic),
+  L("th", "tha", "Thai", "Thail\xE4ndska", "\u0E44\u0E17\u0E22", WritingScript.Thai),
+  L("ti", "tir", "Tigrinya", "Tigrinja", "\u1275\u130D\u122D\u129B", WritingScript.Ethiopic),
+  L("tk", "tuk", "Turkmen", "Turkmeniska", "T\xFCrkmen", WritingScript.Latin),
+  L("tl", "tgl", "Tagalog", "Tagalog", "Tagalog", WritingScript.Latin),
+  L("tn", "tsn", "Tswana", "Tswana", "Setswana", WritingScript.Latin),
+  L("to", "ton", "Tongan", "Tonganska", "Lea Faka-Tonga", WritingScript.Latin),
+  L("tr", "tur", "Turkish", "Turkiska", "T\xFCrk\xE7e", WritingScript.Latin),
+  L("ts", "tso", "Tsonga", "Tsonga", "Xitsonga", WritingScript.Latin),
+  L("tt", "tat", "Tatar", "Tatariska", "\u0422\u0430\u0442\u0430\u0440", WritingScript.Cyrillic),
+  L("tw", "twi", "Twi", "Twi", "Twi", WritingScript.Latin),
+  L("ty", "tah", "Tahitian", "Tahitiska", "Reo Tahiti", WritingScript.Latin),
+  L(
+    "ug",
+    "uig",
+    "Uyghur",
+    "Uiguriska",
+    "\u0626\u06C7\u064A\u063A\u06C7\u0631\u0686\u06D5",
+    WritingScript.Arabic,
+    TextDirection.RightToLeft
+  ),
+  L("uk", "ukr", "Ukrainian", "Ukrainska", "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430", WritingScript.Cyrillic),
+  L("ur", "urd", "Urdu", "Urdu", "\u0627\u0631\u062F\u0648", WritingScript.Arabic, TextDirection.RightToLeft),
+  L("uz", "uzb", "Uzbek", "Uzbekiska", "O\u02BBzbek", WritingScript.Latin),
+  L("ve", "ven", "Venda", "Venda", "Tshiven\u1E13a", WritingScript.Latin),
+  L("vi", "vie", "Vietnamese", "Vietnamesiska", "Ti\u1EBFng Vi\u1EC7t", WritingScript.Latin),
+  L("vo", "vol", "Volap\xFCk", "Volap\xFCk", "Volap\xFCk", WritingScript.Latin),
+  L("wa", "wln", "Walloon", "Vallonska", "Walon", WritingScript.Latin),
+  L("wo", "wol", "Wolof", "Wolof", "Wollof", WritingScript.Latin),
+  L("xh", "xho", "Xhosa", "Xhosa", "isiXhosa", WritingScript.Latin),
+  L("yi", "yid", "Yiddish", "Jiddisch", "\u05D9\u05D9\u05B4\u05D3\u05D9\u05E9", WritingScript.Hebrew, TextDirection.RightToLeft),
+  L("yo", "yor", "Yoruba", "Yoruba", "Yor\xF9b\xE1", WritingScript.Latin),
+  L("za", "zha", "Zhuang", "Zhuang", "Sa\u026F cue\u014B\u0185", WritingScript.Latin),
+  L("zh", "zho", "Chinese", "Kinesiska", "\u4E2D\u6587", WritingScript.Han),
+  L("zu", "zul", "Zulu", "Zulu", "isiZulu", WritingScript.Latin)
+]);
+var BY_KEY = (() => {
+  const m = /* @__PURE__ */ new Map();
+  for (const lang of ALL) {
+    m.set(lang.alpha2Code, lang);
+    m.set(lang.alpha3Code, lang);
+    m.set(lang.englishName.toLowerCase(), lang);
+    if (!m.has(lang.localizedName.toLowerCase())) {
+      m.set(lang.localizedName.toLowerCase(), lang);
+    }
+    if (lang.nativeName.toLowerCase() !== lang.englishName.toLowerCase() && !m.has(lang.nativeName.toLowerCase())) {
+      m.set(lang.nativeName.toLowerCase(), lang);
+    }
+  }
+  return m;
+})();
+var byA2 = (a2) => BY_KEY.get(a2);
+Language.Afrikaans = byA2("af");
+Language.Albanian = byA2("sq");
+Language.Arabic = byA2("ar");
+Language.Bulgarian = byA2("bg");
+Language.Catalan = byA2("ca");
+Language.Chinese = byA2("zh");
+Language.Croatian = byA2("hr");
+Language.Czech = byA2("cs");
+Language.Danish = byA2("da");
+Language.Dutch = byA2("nl");
+Language.English = byA2("en");
+Language.Estonian = byA2("et");
+Language.Faroese = byA2("fo");
+Language.Finnish = byA2("fi");
+Language.French = byA2("fr");
+Language.German = byA2("de");
+Language.Greek = byA2("el");
+Language.Hindi = byA2("hi");
+Language.Hungarian = byA2("hu");
+Language.Icelandic = byA2("is");
+Language.Italian = byA2("it");
+Language.Japanese = byA2("ja");
+Language.Korean = byA2("ko");
+Language.Latvian = byA2("lv");
+Language.Lithuanian = byA2("lt");
+Language.NorthernSami = byA2("se");
+Language.Norwegian = byA2("no");
+Language.NorwegianBokmal = byA2("nb");
+Language.NorwegianNynorsk = byA2("nn");
+Language.Polish = byA2("pl");
+Language.Portuguese = byA2("pt");
+Language.Romanian = byA2("ro");
+Language.Russian = byA2("ru");
+Language.Slovak = byA2("sk");
+Language.Slovenian = byA2("sl");
+Language.Spanish = byA2("es");
+Language.Swahili = byA2("sw");
+Language.Swedish = byA2("sv");
+Language.Turkish = byA2("tr");
+Language.Ukrainian = byA2("uk");
+
+// src/geography/continent.ts
+var MAX_INPUT_LENGTH2 = 50;
+var Continent = class _Continent {
+  static typeInfo = Object.freeze({
+    englishName: "Continent",
+    localizedName: "Kontinent",
+    emoji: "\u{1F5FA}\uFE0F",
+    sources: Object.freeze([
+      "https://unstats.un.org/unsd/methodology/m49/",
+      "https://datahub.io/core/continent-codes"
+    ])
+  });
+  static Africa = new _Continent("AF", "Africa", "Afrika");
+  static Antarctica = new _Continent("AN", "Antarctica", "Antarktis");
+  static Asia = new _Continent("AS", "Asia", "Asien");
+  static Europe = new _Continent("EU", "Europe", "Europa");
+  static NorthAmerica = new _Continent("NA", "North America", "Nordamerika");
+  static Oceania = new _Continent("OC", "Oceania", "Oceanien");
+  static SouthAmerica = new _Continent("SA", "South America", "Sydamerika");
+  /** All seven continents. */
+  static all = Object.freeze([
+    _Continent.Africa,
+    _Continent.Antarctica,
+    _Continent.Asia,
+    _Continent.Europe,
+    _Continent.NorthAmerica,
+    _Continent.Oceania,
+    _Continent.SouthAmerica
+  ]);
+  code;
+  englishName;
+  localizedName;
+  constructor(code, englishName, localizedName) {
+    this.code = code;
+    this.englishName = englishName;
+    this.localizedName = localizedName;
+  }
+  get displayName() {
+    return PrimitivesDefaults.useLocalizedDisplayNames ? this.localizedName : this.englishName;
+  }
+  get value() {
+    return this.code;
+  }
+  static tryParse(input) {
+    if (input == null) return null;
+    const trimmed = input.trim();
+    if (trimmed.length === 0 || trimmed.length > MAX_INPUT_LENGTH2) return null;
+    const lower = trimmed.toLowerCase();
+    return BY_KEY2.get(lower) ?? null;
+  }
+  static parse(input) {
+    const r = _Continent.tryParse(input);
+    if (r === null) throw new Error("Unknown continent.");
+    return r;
+  }
+  static isValid(input) {
+    return _Continent.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _Continent.tryParse(input);
+    if (r) return r.displayName;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _Continent.tryParse(input);
+    if (r) return r.code;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null) {
+      const trimmed = input.trim();
+      return trimmed.length > 0 ? trimmed : null;
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _Continent.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return this.code;
+  }
+  toString() {
+    return this.displayName;
+  }
+  equals(other) {
+    return other != null && this.code === other.code;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.code < other.code ? -1 : this.code > other.code ? 1 : 0;
+  }
+};
+var BY_KEY2 = (() => {
+  const m = /* @__PURE__ */ new Map();
+  for (const c of Continent.all) {
+    m.set(c.code.toLowerCase(), c);
+    m.set(c.englishName.toLowerCase(), c);
+    m.set(c.localizedName.toLowerCase(), c);
+  }
+  return m;
+})();
+
+// src/geography/country-data.ts
+var C = (alpha2, alpha3, numeric, en, sv, native, callingCode, tld, continent) => ({ alpha2, alpha3, numeric, en, sv, native, callingCode, tld, continent });
+var COUNTRY_ROWS = [
+  C("AF", "AFG", 4, "Afghanistan", "Afghanistan", "\u0627\u0641\u063A\u0627\u0646\u0633\u062A\u0627\u0646", "93", ".af", Continent.Asia),
+  C("AL", "ALB", 8, "Albania", "Albanien", "Shqip\xEBria", "355", ".al", Continent.Europe),
+  C("DZ", "DZA", 12, "Algeria", "Algeriet", "\u0627\u0644\u062C\u0632\u0627\u0626\u0631", "213", ".dz", Continent.Africa),
+  C(
+    "AS",
+    "ASM",
+    16,
+    "American Samoa",
+    "Amerikanska Samoa",
+    "American Samoa",
+    "1",
+    ".as",
+    Continent.Oceania
+  ),
+  C("AD", "AND", 20, "Andorra", "Andorra", "Andorra", "376", ".ad", Continent.Europe),
+  C("AO", "AGO", 24, "Angola", "Angola", "Angola", "244", ".ao", Continent.Africa),
+  C(
+    "AG",
+    "ATG",
+    28,
+    "Antigua and Barbuda",
+    "Antigua och Barbuda",
+    "Antigua and Barbuda",
+    "1",
+    ".ag",
+    Continent.NorthAmerica
+  ),
+  C("AR", "ARG", 32, "Argentina", "Argentina", "Argentina", "54", ".ar", Continent.SouthAmerica),
+  C("AM", "ARM", 51, "Armenia", "Armenien", "\u0540\u0561\u0575\u0561\u057D\u057F\u0561\u0576", "374", ".am", Continent.Asia),
+  C("AW", "ABW", 533, "Aruba", "Aruba", "Aruba", "297", ".aw", Continent.NorthAmerica),
+  C("AU", "AUS", 36, "Australia", "Australien", "Australia", "61", ".au", Continent.Oceania),
+  C("AT", "AUT", 40, "Austria", "\xD6sterrike", "\xD6sterreich", "43", ".at", Continent.Europe),
+  C("AZ", "AZE", 31, "Azerbaijan", "Azerbajdzjan", "Az\u0259rbaycan", "994", ".az", Continent.Asia),
+  C("BS", "BHS", 44, "Bahamas", "Bahamas", "Bahamas", "1", ".bs", Continent.NorthAmerica),
+  C("BH", "BHR", 48, "Bahrain", "Bahrain", "\u0627\u0644\u0628\u062D\u0631\u064A\u0646", "973", ".bh", Continent.Asia),
+  C("BD", "BGD", 50, "Bangladesh", "Bangladesh", "\u09AC\u09BE\u0982\u09B2\u09BE\u09A6\u09C7\u09B6", "880", ".bd", Continent.Asia),
+  C("BB", "BRB", 52, "Barbados", "Barbados", "Barbados", "1", ".bb", Continent.NorthAmerica),
+  C("BY", "BLR", 112, "Belarus", "Belarus", "\u0411\u0435\u043B\u0430\u0440\u0443\u0441\u044C", "375", ".by", Continent.Europe),
+  C("BE", "BEL", 56, "Belgium", "Belgien", "Belgi\xEB", "32", ".be", Continent.Europe),
+  C("BZ", "BLZ", 84, "Belize", "Belize", "Belize", "501", ".bz", Continent.NorthAmerica),
+  C("BJ", "BEN", 204, "Benin", "Benin", "B\xE9nin", "229", ".bj", Continent.Africa),
+  C("BM", "BMU", 60, "Bermuda", "Bermuda", "Bermuda", "1", ".bm", Continent.NorthAmerica),
+  C("BT", "BTN", 64, "Bhutan", "Bhutan", "\u0F60\u0F56\u0FB2\u0F74\u0F42", "975", ".bt", Continent.Asia),
+  C("BO", "BOL", 68, "Bolivia", "Bolivia", "Bolivia", "591", ".bo", Continent.SouthAmerica),
+  C(
+    "BA",
+    "BIH",
+    70,
+    "Bosnia and Herzegovina",
+    "Bosnien och Hercegovina",
+    "Bosna i Hercegovina",
+    "387",
+    ".ba",
+    Continent.Europe
+  ),
+  C("BW", "BWA", 72, "Botswana", "Botswana", "Botswana", "267", ".bw", Continent.Africa),
+  C("BR", "BRA", 76, "Brazil", "Brasilien", "Brasil", "55", ".br", Continent.SouthAmerica),
+  C("BN", "BRN", 96, "Brunei", "Brunei", "Brunei", "673", ".bn", Continent.Asia),
+  C("BG", "BGR", 100, "Bulgaria", "Bulgarien", "\u0411\u044A\u043B\u0433\u0430\u0440\u0438\u044F", "359", ".bg", Continent.Europe),
+  C(
+    "BF",
+    "BFA",
+    854,
+    "Burkina Faso",
+    "Burkina Faso",
+    "Burkina Faso",
+    "226",
+    ".bf",
+    Continent.Africa
+  ),
+  C("BI", "BDI", 108, "Burundi", "Burundi", "Burundi", "257", ".bi", Continent.Africa),
+  C("CV", "CPV", 132, "Cabo Verde", "Kap Verde", "Cabo Verde", "238", ".cv", Continent.Africa),
+  C("KH", "KHM", 116, "Cambodia", "Kambodja", "\u1780\u1798\u17D2\u1796\u17BB\u1787\u17B6", "855", ".kh", Continent.Asia),
+  C("CM", "CMR", 120, "Cameroon", "Kamerun", "Cameroun", "237", ".cm", Continent.Africa),
+  C("CA", "CAN", 124, "Canada", "Kanada", "Canada", "1", ".ca", Continent.NorthAmerica),
+  C(
+    "CF",
+    "CAF",
+    140,
+    "Central African Republic",
+    "Centralafrikanska republiken",
+    "R\xE9publique centrafricaine",
+    "236",
+    ".cf",
+    Continent.Africa
+  ),
+  C("TD", "TCD", 148, "Chad", "Tchad", "Tchad", "235", ".td", Continent.Africa),
+  C("CL", "CHL", 152, "Chile", "Chile", "Chile", "56", ".cl", Continent.SouthAmerica),
+  C("CN", "CHN", 156, "China", "Kina", "\u4E2D\u56FD", "86", ".cn", Continent.Asia),
+  C("CO", "COL", 170, "Colombia", "Colombia", "Colombia", "57", ".co", Continent.SouthAmerica),
+  C("KM", "COM", 174, "Comoros", "Komorerna", "Komori", "269", ".km", Continent.Africa),
+  C("CG", "COG", 178, "Congo", "Kongo", "Congo", "242", ".cg", Continent.Africa),
+  C(
+    "CD",
+    "COD",
+    180,
+    "Congo (Democratic Republic)",
+    "Demokratiska republiken Kongo",
+    "R\xE9publique d\xE9mocratique du Congo",
+    "243",
+    ".cd",
+    Continent.Africa
+  ),
+  C(
+    "CR",
+    "CRI",
+    188,
+    "Costa Rica",
+    "Costa Rica",
+    "Costa Rica",
+    "506",
+    ".cr",
+    Continent.NorthAmerica
+  ),
+  C(
+    "CI",
+    "CIV",
+    384,
+    "C\xF4te d'Ivoire",
+    "Elfenbenskusten",
+    "C\xF4te d'Ivoire",
+    "225",
+    ".ci",
+    Continent.Africa
+  ),
+  C("HR", "HRV", 191, "Croatia", "Kroatien", "Hrvatska", "385", ".hr", Continent.Europe),
+  C("CU", "CUB", 192, "Cuba", "Kuba", "Cuba", "53", ".cu", Continent.NorthAmerica),
+  C("CW", "CUW", 531, "Cura\xE7ao", "Cura\xE7ao", "Cura\xE7ao", "599", ".cw", Continent.NorthAmerica),
+  C("CY", "CYP", 196, "Cyprus", "Cypern", "\u039A\u03CD\u03C0\u03C1\u03BF\u03C2", "357", ".cy", Continent.Europe),
+  C("CZ", "CZE", 203, "Czechia", "Tjeckien", "\u010Cesko", "420", ".cz", Continent.Europe),
+  C("DK", "DNK", 208, "Denmark", "Danmark", "Danmark", "45", ".dk", Continent.Europe),
+  C("DJ", "DJI", 262, "Djibouti", "Djibouti", "Djibouti", "253", ".dj", Continent.Africa),
+  C("DM", "DMA", 212, "Dominica", "Dominica", "Dominica", "1", ".dm", Continent.NorthAmerica),
+  C(
+    "DO",
+    "DOM",
+    214,
+    "Dominican Republic",
+    "Dominikanska republiken",
+    "Rep\xFAblica Dominicana",
+    "1",
+    ".do",
+    Continent.NorthAmerica
+  ),
+  C("EC", "ECU", 218, "Ecuador", "Ecuador", "Ecuador", "593", ".ec", Continent.SouthAmerica),
+  C("EG", "EGY", 818, "Egypt", "Egypten", "\u0645\u0635\u0631", "20", ".eg", Continent.Africa),
+  C(
+    "SV",
+    "SLV",
+    222,
+    "El Salvador",
+    "El Salvador",
+    "El Salvador",
+    "503",
+    ".sv",
+    Continent.NorthAmerica
+  ),
+  C(
+    "GQ",
+    "GNQ",
+    226,
+    "Equatorial Guinea",
+    "Ekvatorialguinea",
+    "Guinea Ecuatorial",
+    "240",
+    ".gq",
+    Continent.Africa
+  ),
+  C("ER", "ERI", 232, "Eritrea", "Eritrea", "\u12A4\u122D\u1275\u122B", "291", ".er", Continent.Africa),
+  C("EE", "EST", 233, "Estonia", "Estland", "Eesti", "372", ".ee", Continent.Europe),
+  C("SZ", "SWZ", 748, "Eswatini", "Eswatini", "eSwatini", "268", ".sz", Continent.Africa),
+  C("ET", "ETH", 231, "Ethiopia", "Etiopien", "\u12A2\u1275\u12EE\u1335\u12EB", "251", ".et", Continent.Africa),
+  C("FJ", "FJI", 242, "Fiji", "Fiji", "Fiji", "679", ".fj", Continent.Oceania),
+  C("FI", "FIN", 246, "Finland", "Finland", "Suomi", "358", ".fi", Continent.Europe),
+  C("FR", "FRA", 250, "France", "Frankrike", "France", "33", ".fr", Continent.Europe),
+  C("GA", "GAB", 266, "Gabon", "Gabon", "Gabon", "241", ".ga", Continent.Africa),
+  C("GM", "GMB", 270, "Gambia", "Gambia", "Gambia", "220", ".gm", Continent.Africa),
+  C("GE", "GEO", 268, "Georgia", "Georgien", "\u10E1\u10D0\u10E5\u10D0\u10E0\u10D7\u10D5\u10D4\u10DA\u10DD", "995", ".ge", Continent.Asia),
+  C("DE", "DEU", 276, "Germany", "Tyskland", "Deutschland", "49", ".de", Continent.Europe),
+  C("GH", "GHA", 288, "Ghana", "Ghana", "Ghana", "233", ".gh", Continent.Africa),
+  C("GI", "GIB", 292, "Gibraltar", "Gibraltar", "Gibraltar", "350", ".gi", Continent.Europe),
+  C("GR", "GRC", 300, "Greece", "Grekland", "\u0395\u03BB\u03BB\u03AC\u03B4\u03B1", "30", ".gr", Continent.Europe),
+  C(
+    "GL",
+    "GRL",
+    304,
+    "Greenland",
+    "Gr\xF6nland",
+    "Kalaallit Nunaat",
+    "299",
+    ".gl",
+    Continent.NorthAmerica
+  ),
+  C("GD", "GRD", 308, "Grenada", "Grenada", "Grenada", "1", ".gd", Continent.NorthAmerica),
+  C("GU", "GUM", 316, "Guam", "Guam", "Guam", "1", ".gu", Continent.Oceania),
+  C("GT", "GTM", 320, "Guatemala", "Guatemala", "Guatemala", "502", ".gt", Continent.NorthAmerica),
+  C("GG", "GGY", 831, "Guernsey", "Guernsey", "Guernsey", "44", ".gg", Continent.Europe),
+  C("GN", "GIN", 324, "Guinea", "Guinea", "Guin\xE9e", "224", ".gn", Continent.Africa),
+  C(
+    "GW",
+    "GNB",
+    624,
+    "Guinea-Bissau",
+    "Guinea-Bissau",
+    "Guin\xE9-Bissau",
+    "245",
+    ".gw",
+    Continent.Africa
+  ),
+  C("GY", "GUY", 328, "Guyana", "Guyana", "Guyana", "592", ".gy", Continent.SouthAmerica),
+  C("HT", "HTI", 332, "Haiti", "Haiti", "Ha\xEFti", "509", ".ht", Continent.NorthAmerica),
+  C("HN", "HND", 340, "Honduras", "Honduras", "Honduras", "504", ".hn", Continent.NorthAmerica),
+  C("HK", "HKG", 344, "Hong Kong", "Hongkong", "\u9999\u6E2F", "852", ".hk", Continent.Asia),
+  C("HU", "HUN", 348, "Hungary", "Ungern", "Magyarorsz\xE1g", "36", ".hu", Continent.Europe),
+  C("IS", "ISL", 352, "Iceland", "Island", "\xCDsland", "354", ".is", Continent.Europe),
+  C("IN", "IND", 356, "India", "Indien", "\u092D\u093E\u0930\u0924", "91", ".in", Continent.Asia),
+  C("ID", "IDN", 360, "Indonesia", "Indonesien", "Indonesia", "62", ".id", Continent.Asia),
+  C("IR", "IRN", 364, "Iran", "Iran", "\u0627\u06CC\u0631\u0627\u0646", "98", ".ir", Continent.Asia),
+  C("IQ", "IRQ", 368, "Iraq", "Irak", "\u0627\u0644\u0639\u0631\u0627\u0642", "964", ".iq", Continent.Asia),
+  C("IE", "IRL", 372, "Ireland", "Irland", "\xC9ire", "353", ".ie", Continent.Europe),
+  C("IM", "IMN", 833, "Isle of Man", "Isle of Man", "Isle of Man", "44", ".im", Continent.Europe),
+  C("IL", "ISR", 376, "Israel", "Israel", "\u05D9\u05E9\u05E8\u05D0\u05DC", "972", ".il", Continent.Asia),
+  C("IT", "ITA", 380, "Italy", "Italien", "Italia", "39", ".it", Continent.Europe),
+  C("JM", "JAM", 388, "Jamaica", "Jamaica", "Jamaica", "1", ".jm", Continent.NorthAmerica),
+  C("JP", "JPN", 392, "Japan", "Japan", "\u65E5\u672C", "81", ".jp", Continent.Asia),
+  C("JE", "JEY", 832, "Jersey", "Jersey", "Jersey", "44", ".je", Continent.Europe),
+  C("JO", "JOR", 400, "Jordan", "Jordanien", "\u0627\u0644\u0623\u0631\u062F\u0646", "962", ".jo", Continent.Asia),
+  C("KZ", "KAZ", 398, "Kazakhstan", "Kazakstan", "\u049A\u0430\u0437\u0430\u049B\u0441\u0442\u0430\u043D", "7", ".kz", Continent.Asia),
+  C("KE", "KEN", 404, "Kenya", "Kenya", "Kenya", "254", ".ke", Continent.Africa),
+  C("KI", "KIR", 296, "Kiribati", "Kiribati", "Kiribati", "686", ".ki", Continent.Oceania),
+  C("KP", "PRK", 408, "North Korea", "Nordkorea", "\uC870\uC120", "850", ".kp", Continent.Asia),
+  C("KR", "KOR", 410, "South Korea", "Sydkorea", "\uB300\uD55C\uBBFC\uAD6D", "82", ".kr", Continent.Asia),
+  C("KW", "KWT", 414, "Kuwait", "Kuwait", "\u0627\u0644\u0643\u0648\u064A\u062A", "965", ".kw", Continent.Asia),
+  C("KG", "KGZ", 417, "Kyrgyzstan", "Kirgizistan", "\u041A\u044B\u0440\u0433\u044B\u0437\u0441\u0442\u0430\u043D", "996", ".kg", Continent.Asia),
+  C("LA", "LAO", 418, "Laos", "Laos", "\u0EA5\u0EB2\u0EA7", "856", ".la", Continent.Asia),
+  C("LV", "LVA", 428, "Latvia", "Lettland", "Latvija", "371", ".lv", Continent.Europe),
+  C("LB", "LBN", 422, "Lebanon", "Libanon", "\u0644\u0628\u0646\u0627\u0646", "961", ".lb", Continent.Asia),
+  C("LS", "LSO", 426, "Lesotho", "Lesotho", "Lesotho", "266", ".ls", Continent.Africa),
+  C("LR", "LBR", 430, "Liberia", "Liberia", "Liberia", "231", ".lr", Continent.Africa),
+  C("LY", "LBY", 434, "Libya", "Libyen", "\u0644\u064A\u0628\u064A\u0627", "218", ".ly", Continent.Africa),
+  C(
+    "LI",
+    "LIE",
+    438,
+    "Liechtenstein",
+    "Liechtenstein",
+    "Liechtenstein",
+    "423",
+    ".li",
+    Continent.Europe
+  ),
+  C("LT", "LTU", 440, "Lithuania", "Litauen", "Lietuva", "370", ".lt", Continent.Europe),
+  C("LU", "LUX", 442, "Luxembourg", "Luxemburg", "L\xEBtzebuerg", "352", ".lu", Continent.Europe),
+  C("MO", "MAC", 446, "Macao", "Macao", "\u6FB3\u9580", "853", ".mo", Continent.Asia),
+  C("MG", "MDG", 450, "Madagascar", "Madagaskar", "Madagasikara", "261", ".mg", Continent.Africa),
+  C("MW", "MWI", 454, "Malawi", "Malawi", "Malawi", "265", ".mw", Continent.Africa),
+  C("MY", "MYS", 458, "Malaysia", "Malaysia", "Malaysia", "60", ".my", Continent.Asia),
+  C("MV", "MDV", 462, "Maldives", "Maldiverna", "\u078B\u07A8\u0788\u07AC\u0780\u07A8\u0783\u07A7\u0787\u07B0\u0796\u07AC", "960", ".mv", Continent.Asia),
+  C("ML", "MLI", 466, "Mali", "Mali", "Mali", "223", ".ml", Continent.Africa),
+  C("MT", "MLT", 470, "Malta", "Malta", "Malta", "356", ".mt", Continent.Europe),
+  C(
+    "MH",
+    "MHL",
+    584,
+    "Marshall Islands",
+    "Marshall\xF6arna",
+    "Marshall Islands",
+    "692",
+    ".mh",
+    Continent.Oceania
+  ),
+  C("MR", "MRT", 478, "Mauritania", "Mauretanien", "\u0645\u0648\u0631\u064A\u062A\u0627\u0646\u064A\u0627", "222", ".mr", Continent.Africa),
+  C("MU", "MUS", 480, "Mauritius", "Mauritius", "Maurice", "230", ".mu", Continent.Africa),
+  C("MX", "MEX", 484, "Mexico", "Mexiko", "M\xE9xico", "52", ".mx", Continent.NorthAmerica),
+  C("FM", "FSM", 583, "Micronesia", "Mikronesien", "Micronesia", "691", ".fm", Continent.Oceania),
+  C("MD", "MDA", 498, "Moldova", "Moldavien", "Moldova", "373", ".md", Continent.Europe),
+  C("MC", "MCO", 492, "Monaco", "Monaco", "Monaco", "377", ".mc", Continent.Europe),
+  C("MN", "MNG", 496, "Mongolia", "Mongoliet", "\u041C\u043E\u043D\u0433\u043E\u043B", "976", ".mn", Continent.Asia),
+  C("ME", "MNE", 499, "Montenegro", "Montenegro", "Crna Gora", "382", ".me", Continent.Europe),
+  C("MA", "MAR", 504, "Morocco", "Marocko", "\u0627\u0644\u0645\u063A\u0631\u0628", "212", ".ma", Continent.Africa),
+  C("MZ", "MOZ", 508, "Mozambique", "Mo\xE7ambique", "Mo\xE7ambique", "258", ".mz", Continent.Africa),
+  C("MM", "MMR", 104, "Myanmar", "Myanmar", "\u1019\u103C\u1014\u103A\u1019\u102C", "95", ".mm", Continent.Asia),
+  C("NA", "NAM", 516, "Namibia", "Namibia", "Namibia", "264", ".na", Continent.Africa),
+  C("NR", "NRU", 520, "Nauru", "Nauru", "Nauru", "674", ".nr", Continent.Oceania),
+  C("NP", "NPL", 524, "Nepal", "Nepal", "\u0928\u0947\u092A\u093E\u0932", "977", ".np", Continent.Asia),
+  C("NL", "NLD", 528, "Netherlands", "Nederl\xE4nderna", "Nederland", "31", ".nl", Continent.Europe),
+  C("NZ", "NZL", 554, "New Zealand", "Nya Zeeland", "Aotearoa", "64", ".nz", Continent.Oceania),
+  C("NI", "NIC", 558, "Nicaragua", "Nicaragua", "Nicaragua", "505", ".ni", Continent.NorthAmerica),
+  C("NE", "NER", 562, "Niger", "Niger", "Niger", "227", ".ne", Continent.Africa),
+  C("NG", "NGA", 566, "Nigeria", "Nigeria", "Nigeria", "234", ".ng", Continent.Africa),
+  C(
+    "MK",
+    "MKD",
+    807,
+    "North Macedonia",
+    "Nordmakedonien",
+    "\u0421\u0435\u0432\u0435\u0440\u043D\u0430 \u041C\u0430\u043A\u0435\u0434\u043E\u043D\u0438\u0458\u0430",
+    "389",
+    ".mk",
+    Continent.Europe
+  ),
+  C("NO", "NOR", 578, "Norway", "Norge", "Norge", "47", ".no", Continent.Europe),
+  C("OM", "OMN", 512, "Oman", "Oman", "\u0639\u0645\u0627\u0646", "968", ".om", Continent.Asia),
+  C("PK", "PAK", 586, "Pakistan", "Pakistan", "\u067E\u0627\u06A9\u0633\u062A\u0627\u0646", "92", ".pk", Continent.Asia),
+  C("PW", "PLW", 585, "Palau", "Palau", "Palau", "680", ".pw", Continent.Oceania),
+  C("PS", "PSE", 275, "Palestine", "Palestina", "\u0641\u0644\u0633\u0637\u064A\u0646", "970", ".ps", Continent.Asia),
+  C("PA", "PAN", 591, "Panama", "Panama", "Panam\xE1", "507", ".pa", Continent.NorthAmerica),
+  C(
+    "PG",
+    "PNG",
+    598,
+    "Papua New Guinea",
+    "Papua Nya Guinea",
+    "Papua Niugini",
+    "675",
+    ".pg",
+    Continent.Oceania
+  ),
+  C("PY", "PRY", 600, "Paraguay", "Paraguay", "Paraguay", "595", ".py", Continent.SouthAmerica),
+  C("PE", "PER", 604, "Peru", "Peru", "Per\xFA", "51", ".pe", Continent.SouthAmerica),
+  C("PH", "PHL", 608, "Philippines", "Filippinerna", "Pilipinas", "63", ".ph", Continent.Asia),
+  C("PL", "POL", 616, "Poland", "Polen", "Polska", "48", ".pl", Continent.Europe),
+  C("PT", "PRT", 620, "Portugal", "Portugal", "Portugal", "351", ".pt", Continent.Europe),
+  C(
+    "PR",
+    "PRI",
+    630,
+    "Puerto Rico",
+    "Puerto Rico",
+    "Puerto Rico",
+    "1",
+    ".pr",
+    Continent.NorthAmerica
+  ),
+  C("QA", "QAT", 634, "Qatar", "Qatar", "\u0642\u0637\u0631", "974", ".qa", Continent.Asia),
+  C("RO", "ROU", 642, "Romania", "Rum\xE4nien", "Rom\xE2nia", "40", ".ro", Continent.Europe),
+  C("RU", "RUS", 643, "Russia", "Ryssland", "\u0420\u043E\u0441\u0441\u0438\u044F", "7", ".ru", Continent.Europe),
+  C("RW", "RWA", 646, "Rwanda", "Rwanda", "Rwanda", "250", ".rw", Continent.Africa),
+  C(
+    "KN",
+    "KNA",
+    659,
+    "Saint Kitts and Nevis",
+    "Saint Kitts och Nevis",
+    "Saint Kitts and Nevis",
+    "1",
+    ".kn",
+    Continent.NorthAmerica
+  ),
+  C(
+    "LC",
+    "LCA",
+    662,
+    "Saint Lucia",
+    "Saint Lucia",
+    "Saint Lucia",
+    "1",
+    ".lc",
+    Continent.NorthAmerica
+  ),
+  C(
+    "VC",
+    "VCT",
+    670,
+    "Saint Vincent and the Grenadines",
+    "Saint Vincent och Grenadinerna",
+    "Saint Vincent and the Grenadines",
+    "1",
+    ".vc",
+    Continent.NorthAmerica
+  ),
+  C("WS", "WSM", 882, "Samoa", "Samoa", "S\u0101moa", "685", ".ws", Continent.Oceania),
+  C("SM", "SMR", 674, "San Marino", "San Marino", "San Marino", "378", ".sm", Continent.Europe),
+  C(
+    "ST",
+    "STP",
+    678,
+    "S\xE3o Tom\xE9 and Pr\xEDncipe",
+    "S\xE3o Tom\xE9 och Pr\xEDncipe",
+    "S\xE3o Tom\xE9 e Pr\xEDncipe",
+    "239",
+    ".st",
+    Continent.Africa
+  ),
+  C("SA", "SAU", 682, "Saudi Arabia", "Saudiarabien", "\u0627\u0644\u0633\u0639\u0648\u062F\u064A\u0629", "966", ".sa", Continent.Asia),
+  C("SN", "SEN", 686, "Senegal", "Senegal", "S\xE9n\xE9gal", "221", ".sn", Continent.Africa),
+  C("RS", "SRB", 688, "Serbia", "Serbien", "\u0421\u0440\u0431\u0438\u0458\u0430", "381", ".rs", Continent.Europe),
+  C("SC", "SYC", 690, "Seychelles", "Seychellerna", "Seychelles", "248", ".sc", Continent.Africa),
+  C(
+    "SL",
+    "SLE",
+    694,
+    "Sierra Leone",
+    "Sierra Leone",
+    "Sierra Leone",
+    "232",
+    ".sl",
+    Continent.Africa
+  ),
+  C("SG", "SGP", 702, "Singapore", "Singapore", "Singapore", "65", ".sg", Continent.Asia),
+  C("SK", "SVK", 703, "Slovakia", "Slovakien", "Slovensko", "421", ".sk", Continent.Europe),
+  C("SI", "SVN", 705, "Slovenia", "Slovenien", "Slovenija", "386", ".si", Continent.Europe),
+  C(
+    "SB",
+    "SLB",
+    90,
+    "Solomon Islands",
+    "Salomon\xF6arna",
+    "Solomon Islands",
+    "677",
+    ".sb",
+    Continent.Oceania
+  ),
+  C("SO", "SOM", 706, "Somalia", "Somalia", "Soomaaliya", "252", ".so", Continent.Africa),
+  C("ZA", "ZAF", 710, "South Africa", "Sydafrika", "Suid-Afrika", "27", ".za", Continent.Africa),
+  C("SS", "SSD", 728, "South Sudan", "Sydsudan", "South Sudan", "211", ".ss", Continent.Africa),
+  C("ES", "ESP", 724, "Spain", "Spanien", "Espa\xF1a", "34", ".es", Continent.Europe),
+  C("LK", "LKA", 144, "Sri Lanka", "Sri Lanka", "\u0DC1\u0DCA\u200D\u0DBB\u0DD3 \u0DBD\u0D82\u0D9A\u0DCF\u0DC0", "94", ".lk", Continent.Asia),
+  C("SD", "SDN", 729, "Sudan", "Sudan", "\u0627\u0644\u0633\u0648\u062F\u0627\u0646", "249", ".sd", Continent.Africa),
+  C("SR", "SUR", 740, "Suriname", "Surinam", "Suriname", "597", ".sr", Continent.SouthAmerica),
+  C("SE", "SWE", 752, "Sweden", "Sverige", "Sverige", "46", ".se", Continent.Europe),
+  C("CH", "CHE", 756, "Switzerland", "Schweiz", "Schweiz", "41", ".ch", Continent.Europe),
+  C("SY", "SYR", 760, "Syria", "Syrien", "\u0633\u0648\u0631\u064A\u0627", "963", ".sy", Continent.Asia),
+  C("TW", "TWN", 158, "Taiwan", "Taiwan", "\u81FA\u7063", "886", ".tw", Continent.Asia),
+  C("TJ", "TJK", 762, "Tajikistan", "Tadzjikistan", "\u0422\u043E\u04B7\u0438\u043A\u0438\u0441\u0442\u043E\u043D", "992", ".tj", Continent.Asia),
+  C("TZ", "TZA", 834, "Tanzania", "Tanzania", "Tanzania", "255", ".tz", Continent.Africa),
+  C("TH", "THA", 764, "Thailand", "Thailand", "\u0E1B\u0E23\u0E30\u0E40\u0E17\u0E28\u0E44\u0E17\u0E22", "66", ".th", Continent.Asia),
+  C("TL", "TLS", 626, "Timor-Leste", "\xD6sttimor", "Timor-Leste", "670", ".tl", Continent.Asia),
+  C("TG", "TGO", 768, "Togo", "Togo", "Togo", "228", ".tg", Continent.Africa),
+  C("TO", "TON", 776, "Tonga", "Tonga", "Tonga", "676", ".to", Continent.Oceania),
+  C(
+    "TT",
+    "TTO",
+    780,
+    "Trinidad and Tobago",
+    "Trinidad och Tobago",
+    "Trinidad and Tobago",
+    "1",
+    ".tt",
+    Continent.NorthAmerica
+  ),
+  C("TN", "TUN", 788, "Tunisia", "Tunisien", "\u062A\u0648\u0646\u0633", "216", ".tn", Continent.Africa),
+  C("TR", "TUR", 792, "Turkey", "Turkiet", "T\xFCrkiye", "90", ".tr", Continent.Asia),
+  C("TM", "TKM", 795, "Turkmenistan", "Turkmenistan", "T\xFCrkmenistan", "993", ".tm", Continent.Asia),
+  C("TV", "TUV", 798, "Tuvalu", "Tuvalu", "Tuvalu", "688", ".tv", Continent.Oceania),
+  C("UG", "UGA", 800, "Uganda", "Uganda", "Uganda", "256", ".ug", Continent.Africa),
+  C("UA", "UKR", 804, "Ukraine", "Ukraina", "\u0423\u043A\u0440\u0430\u0457\u043D\u0430", "380", ".ua", Continent.Europe),
+  C(
+    "AE",
+    "ARE",
+    784,
+    "United Arab Emirates",
+    "F\xF6renade Arabemiraten",
+    "\u0627\u0644\u0625\u0645\u0627\u0631\u0627\u062A",
+    "971",
+    ".ae",
+    Continent.Asia
+  ),
+  C(
+    "GB",
+    "GBR",
+    826,
+    "United Kingdom",
+    "Storbritannien",
+    "United Kingdom",
+    "44",
+    ".uk",
+    Continent.Europe
+  ),
+  C(
+    "US",
+    "USA",
+    840,
+    "United States",
+    "F\xF6renta staterna",
+    "United States",
+    "1",
+    ".us",
+    Continent.NorthAmerica
+  ),
+  C("UY", "URY", 858, "Uruguay", "Uruguay", "Uruguay", "598", ".uy", Continent.SouthAmerica),
+  C("UZ", "UZB", 860, "Uzbekistan", "Uzbekistan", "O\u02BBzbekiston", "998", ".uz", Continent.Asia),
+  C("VU", "VUT", 548, "Vanuatu", "Vanuatu", "Vanuatu", "678", ".vu", Continent.Oceania),
+  C(
+    "VA",
+    "VAT",
+    336,
+    "Vatican City",
+    "Vatikanstaten",
+    "Citt\xE0 del Vaticano",
+    "379",
+    ".va",
+    Continent.Europe
+  ),
+  C("VE", "VEN", 862, "Venezuela", "Venezuela", "Venezuela", "58", ".ve", Continent.SouthAmerica),
+  C("VN", "VNM", 704, "Vietnam", "Vietnam", "Vi\u1EC7t Nam", "84", ".vn", Continent.Asia),
+  C("YE", "YEM", 887, "Yemen", "Jemen", "\u0627\u0644\u064A\u0645\u0646", "967", ".ye", Continent.Asia),
+  C("ZM", "ZMB", 894, "Zambia", "Zambia", "Zambia", "260", ".zm", Continent.Africa),
+  C("ZW", "ZWE", 716, "Zimbabwe", "Zimbabwe", "Zimbabwe", "263", ".zw", Continent.Africa),
+  C("AX", "ALA", 248, "\xC5land Islands", "\xC5land", "\xC5land", "358", ".ax", Continent.Europe),
+  C("FO", "FRO", 234, "Faroe Islands", "F\xE4r\xF6arna", "F\xF8royar", "298", ".fo", Continent.Europe),
+  C("XK", "XKX", 0, "Kosovo", "Kosovo", "Kosova", "383", ".xk", Continent.Europe)
+];
+
+// src/geography/country-coordinates.ts
+var COUNTRY_COORDINATES = Object.freeze({
+  AF: [33, 65],
+  AL: [41, 20],
+  DZ: [28, 3],
+  AS: [-14.27, -170.7],
+  AD: [42.5, 1.5],
+  AO: [-12.5, 18.5],
+  AG: [17.05, -61.8],
+  AR: [-34, -64],
+  AM: [40, 45],
+  AW: [12.5, -69.97],
+  AU: [-27, 133],
+  AT: [47.33, 13.33],
+  AZ: [40.5, 47.5],
+  BS: [24.25, -76],
+  BH: [26, 50.55],
+  BD: [24, 90],
+  BB: [13.17, -59.53],
+  BY: [53, 28],
+  BE: [50.83, 4],
+  BZ: [17.25, -88.75],
+  BJ: [9.5, 2.25],
+  BM: [32.33, -64.75],
+  BT: [27.5, 90.5],
+  BO: [-17, -65],
+  BA: [44, 18],
+  BW: [-22, 24],
+  BR: [-10, -55],
+  BN: [4.5, 114.67],
+  BG: [43, 25],
+  BF: [13, -2],
+  BI: [-3.5, 30],
+  CV: [16, -24],
+  KH: [13, 105],
+  CM: [6, 12],
+  CA: [60, -95],
+  CF: [7, 21],
+  TD: [15, 19],
+  CL: [-30, -71],
+  CN: [35, 105],
+  CO: [4, -72],
+  KM: [-12.17, 44.25],
+  CG: [-1, 15],
+  CD: [0, 25],
+  CR: [10, -84],
+  CI: [8, -5],
+  HR: [45.17, 15.5],
+  CU: [21.5, -80],
+  CW: [12.17, -68.98],
+  CY: [35, 33],
+  CZ: [49.75, 15.5],
+  DK: [56, 10],
+  DJ: [11.5, 43],
+  DM: [15.42, -61.33],
+  DO: [19, -70.67],
+  EC: [-2, -77.5],
+  EG: [27, 30],
+  SV: [13.83, -88.92],
+  GQ: [2, 10],
+  ER: [15, 39],
+  EE: [59, 26],
+  SZ: [-26.5, 31.5],
+  ET: [8, 38],
+  FJ: [-18, 175],
+  FI: [64, 26],
+  FR: [46, 2],
+  GA: [-1, 11.75],
+  GM: [13.47, -16.57],
+  GE: [42, 43.5],
+  DE: [51, 9],
+  GH: [8, -2],
+  GI: [36.13, -5.35],
+  GR: [39, 22],
+  GL: [72, -40],
+  GD: [12.12, -61.67],
+  GU: [13.47, 144.78],
+  GT: [15.5, -90.25],
+  GG: [49.45, -2.54],
+  GN: [11, -10],
+  GW: [12, -15],
+  GY: [5, -59],
+  HT: [19, -72.42],
+  HN: [15, -86.5],
+  HK: [22.25, 114.17],
+  HU: [47, 20],
+  IS: [65, -18],
+  IN: [20, 77],
+  ID: [-5, 120],
+  IR: [32, 53],
+  IQ: [33, 44],
+  IE: [53, -8],
+  IM: [54.23, -4.55],
+  IL: [31.5, 34.75],
+  IT: [42.83, 12.83],
+  JM: [18.25, -77.5],
+  JP: [36, 138],
+  JE: [49.21, -2.13],
+  JO: [31, 36],
+  KZ: [48, 68],
+  KE: [1, 38],
+  KI: [1.42, 173],
+  KP: [40, 127],
+  KR: [37, 127.5],
+  KW: [29.34, 47.66],
+  KG: [41, 75],
+  LA: [18, 105],
+  LV: [57, 25],
+  LB: [33.83, 35.83],
+  LS: [-29.5, 28.5],
+  LR: [6.5, -9.5],
+  LY: [25, 17],
+  LI: [47.17, 9.53],
+  LT: [56, 24],
+  LU: [49.75, 6.17],
+  MO: [22.17, 113.55],
+  MG: [-20, 47],
+  MW: [-13.5, 34],
+  MY: [2.5, 112.5],
+  MV: [3.25, 73],
+  ML: [17, -4],
+  MT: [35.83, 14.58],
+  MH: [9, 168],
+  MR: [20, -12],
+  MU: [-20.28, 57.55],
+  MX: [23, -102],
+  FM: [6.92, 158.25],
+  MD: [47, 29],
+  MC: [43.73, 7.42],
+  MN: [46, 105],
+  ME: [42, 19],
+  MA: [32, -5],
+  MZ: [-18.25, 35],
+  MM: [22, 98],
+  NA: [-22, 17],
+  NR: [-0.53, 166.92],
+  NP: [28, 84],
+  NL: [52.5, 5.75],
+  NZ: [-41, 174],
+  NI: [13, -85],
+  NE: [16, 8],
+  NG: [10, 8],
+  MK: [41.83, 22],
+  NO: [62, 10],
+  OM: [21, 57],
+  PK: [30, 70],
+  PW: [7.5, 134.5],
+  PS: [32, 35.25],
+  PA: [9, -80],
+  PG: [-6, 147],
+  PY: [-23, -58],
+  PE: [-10, -76],
+  PH: [13, 122],
+  PL: [52, 20],
+  PT: [39.5, -8],
+  PR: [18.25, -66.5],
+  QA: [25.5, 51.25],
+  RO: [46, 25],
+  RU: [60, 100],
+  RW: [-2, 30],
+  KN: [17.33, -62.75],
+  LC: [13.88, -61.13],
+  VC: [13.25, -61.2],
+  WS: [-13.58, -172.33],
+  SM: [43.77, 12.42],
+  ST: [1, 7],
+  SA: [25, 45],
+  SN: [14, -14],
+  RS: [44, 21],
+  SC: [-4.58, 55.67],
+  SL: [8.5, -11.5],
+  SG: [1.37, 103.8],
+  SK: [48.67, 19.5],
+  SI: [46.12, 14.82],
+  SB: [-8, 159],
+  SO: [10, 49],
+  ZA: [-29, 24],
+  SS: [8, 30],
+  ES: [40, -4],
+  LK: [7, 81],
+  SD: [15, 30],
+  SR: [4, -56],
+  SE: [62, 15],
+  CH: [47, 8],
+  SY: [35, 38],
+  TW: [23.5, 121],
+  TJ: [39, 71],
+  TZ: [-6, 35],
+  TH: [15, 100],
+  TL: [-8.55, 125.73],
+  TG: [8, 1.17],
+  TO: [-20, -175],
+  TT: [11, -61],
+  TN: [34, 9],
+  TR: [39, 35],
+  TM: [40, 60],
+  TV: [-8, 178],
+  UG: [1, 32],
+  UA: [49, 32],
+  AE: [24, 54],
+  GB: [54, -2],
+  US: [38, -97],
+  UY: [-33, -56],
+  UZ: [41, 64],
+  VU: [-16, 167],
+  VA: [41.9, 12.45],
+  VE: [8, -66],
+  VN: [16, 106],
+  YE: [15, 48],
+  ZM: [-15, 30],
+  ZW: [-20, 30],
+  AX: [60.12, 19.9],
+  FO: [62, -7],
+  XK: [42.67, 21.17]
+});
+
+// src/geography/country-capital.ts
+var CountryCapital = class {
+  englishName;
+  localizedName;
+  nativeName;
+  coordinate;
+  /** @internal */
+  constructor(englishName, localizedName, nativeName, coordinate) {
+    this.englishName = englishName;
+    this.localizedName = localizedName;
+    this.nativeName = nativeName;
+    this.coordinate = coordinate;
+  }
+  /** Capital city name in the current display language. */
+  get displayName() {
+    return PrimitivesDefaults.useLocalizedDisplayNames ? this.localizedName : this.englishName;
+  }
+  toString() {
+    return this.displayName;
+  }
+};
+
+// src/geography/country-capitals.ts
+var RAW = {
+  AF: { en: "Kabul", sv: "Kabul", native: "\u06A9\u0627\u0628\u0644", lat: 34.53, lon: 69.17 },
+  AL: { en: "Tirana", sv: "Tirana", native: "Tiran\xEB", lat: 41.33, lon: 19.82 },
+  DZ: { en: "Algiers", sv: "Alger", native: "\u0627\u0644\u062C\u0632\u0627\u0626\u0631", lat: 36.75, lon: 3.04 },
+  AD: {
+    en: "Andorra la Vella",
+    sv: "Andorra la Vella",
+    native: "Andorra la Vella",
+    lat: 42.51,
+    lon: 1.52
+  },
+  AO: { en: "Luanda", sv: "Luanda", native: "Luanda", lat: -8.84, lon: 13.23 },
+  AG: { en: "St. John's", sv: "Saint John's", native: "St. John's", lat: 17.12, lon: -61.85 },
+  AR: { en: "Buenos Aires", sv: "Buenos Aires", native: "Buenos Aires", lat: -34.61, lon: -58.38 },
+  AM: { en: "Yerevan", sv: "Jerevan", native: "\u0535\u0580\u0587\u0561\u0576", lat: 40.18, lon: 44.51 },
+  AU: { en: "Canberra", sv: "Canberra", native: "Canberra", lat: -35.28, lon: 149.13 },
+  AT: { en: "Vienna", sv: "Wien", native: "Wien", lat: 48.21, lon: 16.37 },
+  AZ: { en: "Baku", sv: "Baku", native: "Bak\u0131", lat: 40.41, lon: 49.87 },
+  BS: { en: "Nassau", sv: "Nassau", native: "Nassau", lat: 25.06, lon: -77.34 },
+  BH: { en: "Manama", sv: "Manama", native: "\u0627\u0644\u0645\u0646\u0627\u0645\u0629", lat: 26.23, lon: 50.59 },
+  BD: { en: "Dhaka", sv: "Dhaka", native: "\u09A2\u09BE\u0995\u09BE", lat: 23.71, lon: 90.41 },
+  BB: { en: "Bridgetown", sv: "Bridgetown", native: "Bridgetown", lat: 13.1, lon: -59.62 },
+  BY: { en: "Minsk", sv: "Minsk", native: "\u041C\u0456\u043D\u0441\u043A", lat: 53.9, lon: 27.57 },
+  BE: { en: "Brussels", sv: "Bryssel", native: "Bruxelles", lat: 50.85, lon: 4.35 },
+  BZ: { en: "Belmopan", sv: "Belmopan", native: "Belmopan", lat: 17.25, lon: -88.77 },
+  BJ: { en: "Porto-Novo", sv: "Porto-Novo", native: "Porto-Novo", lat: 6.5, lon: 2.6 },
+  BT: { en: "Thimphu", sv: "Thimphu", native: "\u0F50\u0F72\u0F58\u0F0B\u0F55\u0F74", lat: 27.47, lon: 89.64 },
+  BO: { en: "Sucre", sv: "Sucre", native: "Sucre", lat: -19.04, lon: -65.26 },
+  BA: { en: "Sarajevo", sv: "Sarajevo", native: "Sarajevo", lat: 43.86, lon: 18.41 },
+  BW: { en: "Gaborone", sv: "Gaborone", native: "Gaborone", lat: -24.65, lon: 25.91 },
+  BR: { en: "Bras\xEDlia", sv: "Bras\xEDlia", native: "Bras\xEDlia", lat: -15.79, lon: -47.88 },
+  BN: {
+    en: "Bandar Seri Begawan",
+    sv: "Bandar Seri Begawan",
+    native: "Bandar Seri Begawan",
+    lat: 4.94,
+    lon: 114.95
+  },
+  BG: { en: "Sofia", sv: "Sofia", native: "\u0421\u043E\u0444\u0438\u044F", lat: 42.7, lon: 23.32 },
+  BF: { en: "Ouagadougou", sv: "Ouagadougou", native: "Ouagadougou", lat: 12.37, lon: -1.52 },
+  BI: { en: "Gitega", sv: "Gitega", native: "Gitega", lat: -3.43, lon: 29.93 },
+  CV: { en: "Praia", sv: "Praia", native: "Praia", lat: 14.92, lon: -23.51 },
+  KH: { en: "Phnom Penh", sv: "Phnom Penh", native: "\u1797\u17D2\u1793\u17C6\u1796\u17C1\u1789", lat: 11.56, lon: 104.93 },
+  CM: { en: "Yaound\xE9", sv: "Yaound\xE9", native: "Yaound\xE9", lat: 3.87, lon: 11.52 },
+  CA: { en: "Ottawa", sv: "Ottawa", native: "Ottawa", lat: 45.42, lon: -75.7 },
+  CF: { en: "Bangui", sv: "Bangui", native: "Bangui", lat: 4.37, lon: 18.59 },
+  TD: { en: "N'Djamena", sv: "N'Djamena", native: "N'Djamena", lat: 12.11, lon: 15.05 },
+  CL: { en: "Santiago", sv: "Santiago", native: "Santiago", lat: -33.45, lon: -70.67 },
+  CN: { en: "Beijing", sv: "Peking", native: "\u5317\u4EAC", lat: 39.91, lon: 116.39 },
+  CO: { en: "Bogot\xE1", sv: "Bogot\xE1", native: "Bogot\xE1", lat: 4.71, lon: -74.07 },
+  KM: { en: "Moroni", sv: "Moroni", native: "Moroni", lat: -11.7, lon: 43.26 },
+  CG: { en: "Brazzaville", sv: "Brazzaville", native: "Brazzaville", lat: -4.27, lon: 15.28 },
+  CD: { en: "Kinshasa", sv: "Kinshasa", native: "Kinshasa", lat: -4.32, lon: 15.31 },
+  CR: { en: "San Jos\xE9", sv: "San Jos\xE9", native: "San Jos\xE9", lat: 9.93, lon: -84.08 },
+  CI: { en: "Yamoussoukro", sv: "Yamoussoukro", native: "Yamoussoukro", lat: 6.82, lon: -5.28 },
+  HR: { en: "Zagreb", sv: "Zagreb", native: "Zagreb", lat: 45.81, lon: 15.98 },
+  CU: { en: "Havana", sv: "Havanna", native: "La Habana", lat: 23.13, lon: -82.38 },
+  CY: { en: "Nicosia", sv: "Nicosia", native: "\u039B\u03B5\u03C5\u03BA\u03C9\u03C3\u03AF\u03B1", lat: 35.17, lon: 33.37 },
+  CZ: { en: "Prague", sv: "Prag", native: "Praha", lat: 50.09, lon: 14.42 },
+  DK: { en: "Copenhagen", sv: "K\xF6penhamn", native: "K\xF8benhavn", lat: 55.68, lon: 12.57 },
+  DJ: { en: "Djibouti", sv: "Djibouti", native: "Djibouti", lat: 11.59, lon: 43.15 },
+  DM: { en: "Roseau", sv: "Roseau", native: "Roseau", lat: 15.3, lon: -61.39 },
+  DO: { en: "Santo Domingo", sv: "Santo Domingo", native: "Santo Domingo", lat: 18.47, lon: -69.9 },
+  EC: { en: "Quito", sv: "Quito", native: "Quito", lat: -0.18, lon: -78.47 },
+  EG: { en: "Cairo", sv: "Kairo", native: "\u0627\u0644\u0642\u0627\u0647\u0631\u0629", lat: 30.04, lon: 31.24 },
+  SV: { en: "San Salvador", sv: "San Salvador", native: "San Salvador", lat: 13.69, lon: -89.19 },
+  GQ: { en: "Malabo", sv: "Malabo", native: "Malabo", lat: 3.75, lon: 8.78 },
+  ER: { en: "Asmara", sv: "Asmara", native: "\u12A3\u1235\u1218\u122B", lat: 15.33, lon: 38.93 },
+  EE: { en: "Tallinn", sv: "Tallinn", native: "Tallinn", lat: 59.44, lon: 24.75 },
+  SZ: { en: "Mbabane", sv: "Mbabane", native: "Mbabane", lat: -26.32, lon: 31.13 },
+  ET: { en: "Addis Ababa", sv: "Addis Abeba", native: "\u12A0\u12F2\u1235 \u12A0\u1260\u1263", lat: 9.02, lon: 38.75 },
+  FJ: { en: "Suva", sv: "Suva", native: "Suva", lat: -18.14, lon: 178.44 },
+  FI: { en: "Helsinki", sv: "Helsingfors", native: "Helsinki", lat: 60.17, lon: 24.94 },
+  FR: { en: "Paris", sv: "Paris", native: "Paris", lat: 48.86, lon: 2.35 },
+  GA: { en: "Libreville", sv: "Libreville", native: "Libreville", lat: 0.39, lon: 9.45 },
+  GM: { en: "Banjul", sv: "Banjul", native: "Banjul", lat: 13.45, lon: -16.58 },
+  GE: { en: "Tbilisi", sv: "Tbilisi", native: "\u10D7\u10D1\u10D8\u10DA\u10D8\u10E1\u10D8", lat: 41.69, lon: 44.8 },
+  DE: { en: "Berlin", sv: "Berlin", native: "Berlin", lat: 52.52, lon: 13.41 },
+  GH: { en: "Accra", sv: "Accra", native: "Accra", lat: 5.56, lon: -0.19 },
+  GR: { en: "Athens", sv: "Aten", native: "\u0391\u03B8\u03AE\u03BD\u03B1", lat: 37.98, lon: 23.73 },
+  GD: { en: "St. George's", sv: "Saint George's", native: "St. George's", lat: 12.05, lon: -61.75 },
+  GT: {
+    en: "Guatemala City",
+    sv: "Guatemala City",
+    native: "Ciudad de Guatemala",
+    lat: 14.63,
+    lon: -90.51
+  },
+  GN: { en: "Conakry", sv: "Conakry", native: "Conakry", lat: 9.54, lon: -13.68 },
+  GW: { en: "Bissau", sv: "Bissau", native: "Bissau", lat: 11.86, lon: -15.6 },
+  GY: { en: "Georgetown", sv: "Georgetown", native: "Georgetown", lat: 6.8, lon: -58.16 },
+  HT: { en: "Port-au-Prince", sv: "Port-au-Prince", native: "P\xF2toprens", lat: 18.54, lon: -72.34 },
+  HN: { en: "Tegucigalpa", sv: "Tegucigalpa", native: "Tegucigalpa", lat: 14.1, lon: -87.22 },
+  HK: { en: "Hong Kong", sv: "Hongkong", native: "\u9999\u6E2F", lat: 22.28, lon: 114.16 },
+  HU: { en: "Budapest", sv: "Budapest", native: "Budapest", lat: 47.5, lon: 19.04 },
+  IS: { en: "Reykjavik", sv: "Reykjavik", native: "Reykjav\xEDk", lat: 64.14, lon: -21.9 },
+  IN: { en: "New Delhi", sv: "New Delhi", native: "\u0928\u0908 \u0926\u093F\u0932\u094D\u0932\u0940", lat: 28.61, lon: 77.21 },
+  ID: { en: "Jakarta", sv: "Jakarta", native: "Jakarta", lat: -6.21, lon: 106.85 },
+  IR: { en: "Tehran", sv: "Teheran", native: "\u062A\u0647\u0631\u0627\u0646", lat: 35.69, lon: 51.39 },
+  IQ: { en: "Baghdad", sv: "Bagdad", native: "\u0628\u063A\u062F\u0627\u062F", lat: 33.34, lon: 44.4 },
+  IE: { en: "Dublin", sv: "Dublin", native: "Baile \xC1tha Cliath", lat: 53.35, lon: -6.26 },
+  IL: { en: "Jerusalem", sv: "Jerusalem", native: "\u05D9\u05E8\u05D5\u05E9\u05DC\u05D9\u05DD", lat: 31.77, lon: 35.23 },
+  IT: { en: "Rome", sv: "Rom", native: "Roma", lat: 41.9, lon: 12.5 },
+  JM: { en: "Kingston", sv: "Kingston", native: "Kingston", lat: 18, lon: -76.79 },
+  JP: { en: "Tokyo", sv: "Tokyo", native: "\u6771\u4EAC", lat: 35.68, lon: 139.69 },
+  JO: { en: "Amman", sv: "Amman", native: "\u0639\u0645\u0651\u0627\u0646", lat: 31.95, lon: 35.93 },
+  KZ: { en: "Astana", sv: "Astana", native: "\u0410\u0441\u0442\u0430\u043D\u0430", lat: 51.17, lon: 71.43 },
+  KE: { en: "Nairobi", sv: "Nairobi", native: "Nairobi", lat: -1.29, lon: 36.82 },
+  KI: { en: "Tarawa", sv: "Tarawa", native: "Tarawa", lat: 1.45, lon: 173 },
+  KP: { en: "Pyongyang", sv: "Pyongyang", native: "\uD3C9\uC591", lat: 39.02, lon: 125.75 },
+  KR: { en: "Seoul", sv: "Seoul", native: "\uC11C\uC6B8", lat: 37.57, lon: 126.98 },
+  KW: { en: "Kuwait City", sv: "Kuwait City", native: "\u0645\u062F\u064A\u0646\u0629 \u0627\u0644\u0643\u0648\u064A\u062A", lat: 29.37, lon: 47.98 },
+  KG: { en: "Bishkek", sv: "Bisjkek", native: "\u0411\u0438\u0448\u043A\u0435\u043A", lat: 42.87, lon: 74.59 },
+  LA: { en: "Vientiane", sv: "Vientiane", native: "\u0EA7\u0EBD\u0E87\u0E88\u0EB1\u0E99", lat: 17.97, lon: 102.63 },
+  LV: { en: "Riga", sv: "Riga", native: "R\u012Bga", lat: 56.95, lon: 24.11 },
+  LB: { en: "Beirut", sv: "Beirut", native: "\u0628\u064A\u0631\u0648\u062A", lat: 33.89, lon: 35.5 },
+  LS: { en: "Maseru", sv: "Maseru", native: "Maseru", lat: -29.31, lon: 27.48 },
+  LR: { en: "Monrovia", sv: "Monrovia", native: "Monrovia", lat: 6.3, lon: -10.8 },
+  LY: { en: "Tripoli", sv: "Tripoli", native: "\u0637\u0631\u0627\u0628\u0644\u0633", lat: 32.9, lon: 13.18 },
+  LI: { en: "Vaduz", sv: "Vaduz", native: "Vaduz", lat: 47.14, lon: 9.52 },
+  LT: { en: "Vilnius", sv: "Vilnius", native: "Vilnius", lat: 54.69, lon: 25.28 },
+  LU: { en: "Luxembourg City", sv: "Luxemburg", native: "L\xEBtzebuerg", lat: 49.61, lon: 6.13 },
+  MO: { en: "Macao", sv: "Macao", native: "\u6FB3\u9580", lat: 22.2, lon: 113.54 },
+  MG: { en: "Antananarivo", sv: "Antananarivo", native: "Antananarivo", lat: -18.91, lon: 47.53 },
+  MW: { en: "Lilongwe", sv: "Lilongwe", native: "Lilongwe", lat: -13.97, lon: 33.79 },
+  MY: { en: "Kuala Lumpur", sv: "Kuala Lumpur", native: "Kuala Lumpur", lat: 3.14, lon: 101.69 },
+  MV: { en: "Mal\xE9", sv: "Mal\xE9", native: "\u0789\u07A7\u078D\u07AC", lat: 4.18, lon: 73.51 },
+  ML: { en: "Bamako", sv: "Bamako", native: "Bamako", lat: 12.65, lon: -8 },
+  MT: { en: "Valletta", sv: "Valletta", native: "Valletta", lat: 35.9, lon: 14.51 },
+  MH: { en: "Majuro", sv: "Majuro", native: "Majuro", lat: 7.09, lon: 171.38 },
+  MR: { en: "Nouakchott", sv: "Nouakchott", native: "\u0646\u0648\u0627\u0643\u0634\u0648\u0637", lat: 18.09, lon: -15.98 },
+  MU: { en: "Port Louis", sv: "Port Louis", native: "Port Louis", lat: -20.16, lon: 57.5 },
+  MX: { en: "Mexico City", sv: "Mexico City", native: "Ciudad de M\xE9xico", lat: 19.43, lon: -99.13 },
+  FM: { en: "Palikir", sv: "Palikir", native: "Palikir", lat: 6.92, lon: 158.16 },
+  MD: { en: "Chi\u0219in\u0103u", sv: "Chi\u0219in\u0103u", native: "Chi\u0219in\u0103u", lat: 47.01, lon: 28.86 },
+  MC: { en: "Monaco", sv: "Monaco", native: "Monaco", lat: 43.73, lon: 7.42 },
+  MN: { en: "Ulaanbaatar", sv: "Ulaanbaatar", native: "\u0423\u043B\u0430\u0430\u043D\u0431\u0430\u0430\u0442\u0430\u0440", lat: 47.91, lon: 106.91 },
+  ME: { en: "Podgorica", sv: "Podgorica", native: "Podgorica", lat: 42.44, lon: 19.26 },
+  MA: { en: "Rabat", sv: "Rabat", native: "\u0627\u0644\u0631\u0628\u0627\u0637", lat: 34.01, lon: -6.84 },
+  MZ: { en: "Maputo", sv: "Maputo", native: "Maputo", lat: -25.97, lon: 32.57 },
+  MM: { en: "Naypyidaw", sv: "Naypyidaw", native: "\u1014\u1031\u1015\u103C\u100A\u103A\u1010\u1031\u102C\u103A", lat: 19.76, lon: 96.07 },
+  NA: { en: "Windhoek", sv: "Windhoek", native: "Windhoek", lat: -22.57, lon: 17.08 },
+  NR: { en: "Yaren", sv: "Yaren", native: "Yaren", lat: -0.55, lon: 166.93 },
+  NP: { en: "Kathmandu", sv: "Kathmandu", native: "\u0915\u093E\u0920\u092E\u093E\u0921\u094C\u0902", lat: 27.7, lon: 85.32 },
+  NL: { en: "Amsterdam", sv: "Amsterdam", native: "Amsterdam", lat: 52.37, lon: 4.9 },
+  NZ: { en: "Wellington", sv: "Wellington", native: "Wellington", lat: -41.29, lon: 174.78 },
+  NI: { en: "Managua", sv: "Managua", native: "Managua", lat: 12.15, lon: -86.27 },
+  NE: { en: "Niamey", sv: "Niamey", native: "Niamey", lat: 13.51, lon: 2.11 },
+  NG: { en: "Abuja", sv: "Abuja", native: "Abuja", lat: 9.06, lon: 7.49 },
+  MK: { en: "Skopje", sv: "Skopje", native: "\u0421\u043A\u043E\u043F\u0458\u0435", lat: 42, lon: 21.43 },
+  NO: { en: "Oslo", sv: "Oslo", native: "Oslo", lat: 59.91, lon: 10.75 },
+  OM: { en: "Muscat", sv: "Muskat", native: "\u0645\u0633\u0642\u0637", lat: 23.59, lon: 58.54 },
+  PK: { en: "Islamabad", sv: "Islamabad", native: "\u0627\u0633\u0644\u0627\u0645 \u0622\u0628\u0627\u062F", lat: 33.69, lon: 73.04 },
+  PW: { en: "Ngerulmud", sv: "Ngerulmud", native: "Ngerulmud", lat: 7.5, lon: 134.62 },
+  PS: { en: "Ramallah", sv: "Ramallah", native: "\u0631\u0627\u0645 \u0627\u0644\u0644\u0647", lat: 31.9, lon: 35.2 },
+  PA: { en: "Panama City", sv: "Panama City", native: "Ciudad de Panam\xE1", lat: 8.98, lon: -79.52 },
+  PG: { en: "Port Moresby", sv: "Port Moresby", native: "Port Moresby", lat: -9.48, lon: 147.15 },
+  PY: { en: "Asunci\xF3n", sv: "Asunci\xF3n", native: "Asunci\xF3n", lat: -25.26, lon: -57.58 },
+  PE: { en: "Lima", sv: "Lima", native: "Lima", lat: -12.05, lon: -77.04 },
+  PH: { en: "Manila", sv: "Manila", native: "Maynila", lat: 14.6, lon: 120.98 },
+  PL: { en: "Warsaw", sv: "Warszawa", native: "Warszawa", lat: 52.23, lon: 21.01 },
+  PT: { en: "Lisbon", sv: "Lissabon", native: "Lisboa", lat: 38.72, lon: -9.14 },
+  PR: { en: "San Juan", sv: "San Juan", native: "San Juan", lat: 18.47, lon: -66.11 },
+  QA: { en: "Doha", sv: "Doha", native: "\u0627\u0644\u062F\u0648\u062D\u0629", lat: 25.29, lon: 51.53 },
+  RO: { en: "Bucharest", sv: "Bukarest", native: "Bucure\u0219ti", lat: 44.43, lon: 26.1 },
+  RU: { en: "Moscow", sv: "Moskva", native: "\u041C\u043E\u0441\u043A\u0432\u0430", lat: 55.76, lon: 37.62 },
+  RW: { en: "Kigali", sv: "Kigali", native: "Kigali", lat: -1.94, lon: 30.06 },
+  KN: { en: "Basseterre", sv: "Basseterre", native: "Basseterre", lat: 17.3, lon: -62.72 },
+  LC: { en: "Castries", sv: "Castries", native: "Castries", lat: 14.01, lon: -61 },
+  VC: { en: "Kingstown", sv: "Kingstown", native: "Kingstown", lat: 13.15, lon: -61.22 },
+  WS: { en: "Apia", sv: "Apia", native: "Apia", lat: -13.83, lon: -171.76 },
+  SM: { en: "San Marino", sv: "San Marino", native: "San Marino", lat: 43.94, lon: 12.45 },
+  ST: { en: "S\xE3o Tom\xE9", sv: "S\xE3o Tom\xE9", native: "S\xE3o Tom\xE9", lat: 0.34, lon: 6.73 },
+  SA: { en: "Riyadh", sv: "Riyadh", native: "\u0627\u0644\u0631\u064A\u0627\u0636", lat: 24.69, lon: 46.72 },
+  SN: { en: "Dakar", sv: "Dakar", native: "Dakar", lat: 14.69, lon: -17.44 },
+  RS: { en: "Belgrade", sv: "Belgrad", native: "\u0411\u0435\u043E\u0433\u0440\u0430\u0434", lat: 44.82, lon: 20.46 },
+  SC: { en: "Victoria", sv: "Victoria", native: "Victoria", lat: -4.62, lon: 55.45 },
+  SL: { en: "Freetown", sv: "Freetown", native: "Freetown", lat: 8.48, lon: -13.23 },
+  SG: { en: "Singapore", sv: "Singapore", native: "Singapore", lat: 1.29, lon: 103.85 },
+  SK: { en: "Bratislava", sv: "Bratislava", native: "Bratislava", lat: 48.14, lon: 17.11 },
+  SI: { en: "Ljubljana", sv: "Ljubljana", native: "Ljubljana", lat: 46.05, lon: 14.51 },
+  SB: { en: "Honiara", sv: "Honiara", native: "Honiara", lat: -9.43, lon: 159.96 },
+  SO: { en: "Mogadishu", sv: "Mogadishu", native: "Muqdisho", lat: 2.05, lon: 45.32 },
+  ZA: { en: "Pretoria", sv: "Pretoria", native: "Pretoria", lat: -25.75, lon: 28.19 },
+  SS: { en: "Juba", sv: "Juba", native: "Juba", lat: 4.85, lon: 31.58 },
+  ES: { en: "Madrid", sv: "Madrid", native: "Madrid", lat: 40.42, lon: -3.7 },
+  LK: {
+    en: "Sri Jayawardenepura Kotte",
+    sv: "Sri Jayawardenepura Kotte",
+    native: "\u0DC1\u0DCA\u200D\u0DBB\u0DD3 \u0DA2\u0DBA\u0DC0\u0DBB\u0DCA\u0DB0\u0DB1\u0DB4\u0DD4\u0DBB \u0D9A\u0DDD\u0DA7\u0DCA\u0DA7\u0DDA",
+    lat: 6.89,
+    lon: 79.92
+  },
+  SD: { en: "Khartoum", sv: "Khartoum", native: "\u0627\u0644\u062E\u0631\u0637\u0648\u0645", lat: 15.59, lon: 32.53 },
+  SR: { en: "Paramaribo", sv: "Paramaribo", native: "Paramaribo", lat: 5.83, lon: -55.17 },
+  SE: { en: "Stockholm", sv: "Stockholm", native: "Stockholm", lat: 59.33, lon: 18.07 },
+  CH: { en: "Bern", sv: "Bern", native: "Bern", lat: 46.95, lon: 7.45 },
+  SY: { en: "Damascus", sv: "Damaskus", native: "\u062F\u0645\u0634\u0642", lat: 33.51, lon: 36.29 },
+  TW: { en: "Taipei", sv: "Taipei", native: "\u81FA\u5317", lat: 25.03, lon: 121.57 },
+  TJ: { en: "Dushanbe", sv: "Dusjanbe", native: "\u0414\u0443\u0448\u0430\u043D\u0431\u0435", lat: 38.56, lon: 68.77 },
+  TZ: { en: "Dodoma", sv: "Dodoma", native: "Dodoma", lat: -6.16, lon: 35.75 },
+  TH: { en: "Bangkok", sv: "Bangkok", native: "\u0E01\u0E23\u0E38\u0E07\u0E40\u0E17\u0E1E\u0E21\u0E2B\u0E32\u0E19\u0E04\u0E23", lat: 13.76, lon: 100.5 },
+  TL: { en: "Dili", sv: "Dili", native: "Dili", lat: -8.56, lon: 125.57 },
+  TG: { en: "Lom\xE9", sv: "Lom\xE9", native: "Lom\xE9", lat: 6.14, lon: 1.21 },
+  TO: { en: "Nuku\u02BBalofa", sv: "Nuku\u02BBalofa", native: "Nuku\u02BBalofa", lat: -21.21, lon: -175.2 },
+  TT: {
+    en: "Port of Spain",
+    sv: "Port of Spain",
+    native: "Port of Spain",
+    lat: 10.66,
+    lon: -61.51
+  },
+  TN: { en: "Tunis", sv: "Tunis", native: "\u062A\u0648\u0646\u0633", lat: 36.81, lon: 10.17 },
+  TR: { en: "Ankara", sv: "Ankara", native: "Ankara", lat: 39.93, lon: 32.86 },
+  TM: { en: "Ashgabat", sv: "Asjchabad", native: "A\u015Fgabat", lat: 37.95, lon: 58.38 },
+  TV: { en: "Funafuti", sv: "Funafuti", native: "Funafuti", lat: -8.52, lon: 179.2 },
+  UG: { en: "Kampala", sv: "Kampala", native: "Kampala", lat: 0.31, lon: 32.58 },
+  UA: { en: "Kyiv", sv: "Kiev", native: "\u041A\u0438\u0457\u0432", lat: 50.45, lon: 30.52 },
+  AE: { en: "Abu Dhabi", sv: "Abu Dhabi", native: "\u0623\u0628\u0648 \u0638\u0628\u064A", lat: 24.45, lon: 54.65 },
+  GB: { en: "London", sv: "London", native: "London", lat: 51.51, lon: -0.13 },
+  US: {
+    en: "Washington, D.C.",
+    sv: "Washington, D.C.",
+    native: "Washington, D.C.",
+    lat: 38.9,
+    lon: -77.04
+  },
+  UY: { en: "Montevideo", sv: "Montevideo", native: "Montevideo", lat: -34.88, lon: -56.19 },
+  UZ: { en: "Tashkent", sv: "Tasjkent", native: "Toshkent", lat: 41.3, lon: 69.28 },
+  VU: { en: "Port Vila", sv: "Port Vila", native: "Port Vila", lat: -17.74, lon: 168.31 },
+  VA: {
+    en: "Vatican City",
+    sv: "Vatikanstaden",
+    native: "Citt\xE0 del Vaticano",
+    lat: 41.9,
+    lon: 12.45
+  },
+  VE: { en: "Caracas", sv: "Caracas", native: "Caracas", lat: 10.49, lon: -66.9 },
+  VN: { en: "Hanoi", sv: "Hanoi", native: "H\xE0 N\u1ED9i", lat: 21.03, lon: 105.85 },
+  YE: { en: "Sana'a", sv: "Sana'a", native: "\u0635\u0646\u0639\u0627\u0621", lat: 15.35, lon: 44.21 },
+  ZM: { en: "Lusaka", sv: "Lusaka", native: "Lusaka", lat: -15.39, lon: 28.32 },
+  ZW: { en: "Harare", sv: "Harare", native: "Harare", lat: -17.83, lon: 31.05 },
+  AX: { en: "Mariehamn", sv: "Mariehamn", native: "Mariehamn", lat: 60.1, lon: 19.94 },
+  FO: { en: "T\xF3rshavn", sv: "Torshamn", native: "T\xF3rshavn", lat: 62.01, lon: -6.77 },
+  XK: { en: "Pristina", sv: "Pristina", native: "Prishtin\xEB", lat: 42.66, lon: 21.17 },
+  GI: { en: "Gibraltar", sv: "Gibraltar", native: "Gibraltar", lat: 36.14, lon: -5.35 },
+  GL: { en: "Nuuk", sv: "Nuuk", native: "Nuuk", lat: 64.17, lon: -51.74 },
+  GG: {
+    en: "St. Peter Port",
+    sv: "Saint Peter Port",
+    native: "St. Peter Port",
+    lat: 49.46,
+    lon: -2.54
+  },
+  IM: { en: "Douglas", sv: "Douglas", native: "Douglas", lat: 54.15, lon: -4.48 },
+  JE: { en: "St. Helier", sv: "Saint Helier", native: "St. Helier", lat: 49.19, lon: -2.1 }
+};
+function getCountryCapital(alpha2) {
+  const r = RAW[alpha2];
+  if (!r) return null;
+  return new CountryCapital(r.en, r.sv, r.native, GeoCoordinate.create(r.lat, r.lon));
+}
+
+// src/geography/country-metadata.ts
+var set = (codes) => {
+  const s = /* @__PURE__ */ new Set();
+  for (const c of codes) s.add(c.toUpperCase());
+  return s;
+};
+var EU_COUNTRIES = set([
+  "AT",
+  "BE",
+  "BG",
+  "HR",
+  "CY",
+  "CZ",
+  "DK",
+  "EE",
+  "FI",
+  "FR",
+  "DE",
+  "GR",
+  "HU",
+  "IE",
+  "IT",
+  "LV",
+  "LT",
+  "LU",
+  "MT",
+  "NL",
+  "PL",
+  "PT",
+  "RO",
+  "SK",
+  "SI",
+  "ES",
+  "SE"
+]);
+var EEA_COUNTRIES = set([
+  "AT",
+  "BE",
+  "BG",
+  "HR",
+  "CY",
+  "CZ",
+  "DK",
+  "EE",
+  "FI",
+  "FR",
+  "DE",
+  "GR",
+  "HU",
+  "IE",
+  "IT",
+  "LV",
+  "LT",
+  "LU",
+  "MT",
+  "NL",
+  "PL",
+  "PT",
+  "RO",
+  "SK",
+  "SI",
+  "ES",
+  "SE",
+  "IS",
+  "LI",
+  "NO"
+]);
+var SCHENGEN_COUNTRIES = set([
+  "AT",
+  "BE",
+  "BG",
+  "HR",
+  "CZ",
+  "DK",
+  "EE",
+  "FI",
+  "FR",
+  "DE",
+  "GR",
+  "HU",
+  "IT",
+  "LV",
+  "LT",
+  "LU",
+  "MT",
+  "NL",
+  "PL",
+  "PT",
+  "RO",
+  "SK",
+  "SI",
+  "ES",
+  "SE",
+  "IS",
+  "LI",
+  "NO",
+  "CH"
+]);
+var NORDIC_COUNTRIES = set(["DK", "FI", "IS", "NO", "SE"]);
+var SEPA_COUNTRIES = set([
+  "AT",
+  "BE",
+  "BG",
+  "HR",
+  "CY",
+  "CZ",
+  "DK",
+  "EE",
+  "FI",
+  "FR",
+  "DE",
+  "GR",
+  "HU",
+  "IE",
+  "IT",
+  "LV",
+  "LT",
+  "LU",
+  "MT",
+  "NL",
+  "PL",
+  "PT",
+  "RO",
+  "SK",
+  "SI",
+  "ES",
+  "SE",
+  "IS",
+  "LI",
+  "NO",
+  "AL",
+  "AD",
+  "MD",
+  "MC",
+  "ME",
+  "MK",
+  "SM",
+  "RS",
+  "CH",
+  "GB",
+  "VA",
+  "GG",
+  "IM",
+  "JE"
+]);
+var COUNTRY_CURRENCIES = Object.freeze({
+  AF: ["AFN"],
+  AL: ["ALL"],
+  DZ: ["DZD"],
+  AS: ["USD"],
+  AD: ["EUR"],
+  AO: ["AOA"],
+  AG: ["XCD"],
+  AR: ["ARS"],
+  AM: ["AMD"],
+  AW: ["AWG"],
+  AU: ["AUD"],
+  AT: ["EUR"],
+  AZ: ["AZN"],
+  BS: ["BSD"],
+  BH: ["BHD"],
+  BD: ["BDT"],
+  BB: ["BBD"],
+  BY: ["BYN"],
+  BE: ["EUR"],
+  BZ: ["BZD"],
+  BJ: ["XOF"],
+  BM: ["BMD"],
+  BT: ["BTN"],
+  BO: ["BOB"],
+  BA: ["BAM"],
+  BW: ["BWP"],
+  BR: ["BRL"],
+  BN: ["BND"],
+  BG: ["BGN"],
+  BF: ["XOF"],
+  BI: ["BIF"],
+  CV: ["CVE"],
+  KH: ["KHR"],
+  CM: ["XAF"],
+  CA: ["CAD"],
+  CF: ["XAF"],
+  TD: ["XAF"],
+  CL: ["CLP"],
+  CN: ["CNY"],
+  CO: ["COP"],
+  KM: ["KMF"],
+  CG: ["XAF"],
+  CD: ["CDF"],
+  CR: ["CRC"],
+  CI: ["XOF"],
+  HR: ["EUR"],
+  CU: ["CUP"],
+  CW: ["ANG"],
+  CY: ["EUR"],
+  CZ: ["CZK"],
+  DK: ["DKK"],
+  DJ: ["DJF"],
+  DM: ["XCD"],
+  DO: ["DOP"],
+  EC: ["USD"],
+  EG: ["EGP"],
+  SV: ["USD"],
+  GQ: ["XAF"],
+  ER: ["ERN"],
+  EE: ["EUR"],
+  SZ: ["SZL"],
+  ET: ["ETB"],
+  FJ: ["FJD"],
+  FI: ["EUR"],
+  FR: ["EUR"],
+  GA: ["XAF"],
+  GM: ["GMD"],
+  GE: ["GEL"],
+  DE: ["EUR"],
+  GH: ["GHS"],
+  GI: ["GIP"],
+  GR: ["EUR"],
+  GL: ["DKK"],
+  GD: ["XCD"],
+  GU: ["USD"],
+  GT: ["GTQ"],
+  GG: ["GBP"],
+  GN: ["GNF"],
+  GW: ["XOF"],
+  GY: ["GYD"],
+  HT: ["HTG"],
+  HN: ["HNL"],
+  HK: ["HKD"],
+  HU: ["HUF"],
+  IS: ["ISK"],
+  IN: ["INR"],
+  ID: ["IDR"],
+  IR: ["IRR"],
+  IQ: ["IQD"],
+  IE: ["EUR"],
+  IM: ["GBP"],
+  IL: ["ILS"],
+  IT: ["EUR"],
+  JM: ["JMD"],
+  JP: ["JPY"],
+  JE: ["GBP"],
+  JO: ["JOD"],
+  KZ: ["KZT"],
+  KE: ["KES"],
+  KI: ["AUD"],
+  KP: ["KPW"],
+  KR: ["KRW"],
+  KW: ["KWD"],
+  KG: ["KGS"],
+  LA: ["LAK"],
+  LV: ["EUR"],
+  LB: ["LBP"],
+  LS: ["LSL"],
+  LR: ["LRD"],
+  LY: ["LYD"],
+  LI: ["CHF"],
+  LT: ["EUR"],
+  LU: ["EUR"],
+  MO: ["MOP"],
+  MG: ["MGA"],
+  MW: ["MWK"],
+  MY: ["MYR"],
+  MV: ["MVR"],
+  ML: ["XOF"],
+  MT: ["EUR"],
+  MH: ["USD"],
+  MR: ["MRU"],
+  MU: ["MUR"],
+  MX: ["MXN"],
+  FM: ["USD"],
+  MD: ["MDL"],
+  MC: ["EUR"],
+  MN: ["MNT"],
+  ME: ["EUR"],
+  MA: ["MAD"],
+  MZ: ["MZN"],
+  MM: ["MMK"],
+  NA: ["NAD"],
+  NR: ["AUD"],
+  NP: ["NPR"],
+  NL: ["EUR"],
+  NZ: ["NZD"],
+  NI: ["NIO"],
+  NE: ["XOF"],
+  NG: ["NGN"],
+  MK: ["MKD"],
+  NO: ["NOK"],
+  OM: ["OMR"],
+  PK: ["PKR"],
+  PW: ["USD"],
+  PS: ["ILS"],
+  PA: ["PAB"],
+  PG: ["PGK"],
+  PY: ["PYG"],
+  PE: ["PEN"],
+  PH: ["PHP"],
+  PL: ["PLN"],
+  PT: ["EUR"],
+  PR: ["USD"],
+  QA: ["QAR"],
+  RO: ["RON"],
+  RU: ["RUB"],
+  RW: ["RWF"],
+  KN: ["XCD"],
+  LC: ["XCD"],
+  VC: ["XCD"],
+  WS: ["WST"],
+  SM: ["EUR"],
+  ST: ["STN"],
+  SA: ["SAR"],
+  SN: ["XOF"],
+  RS: ["RSD"],
+  SC: ["SCR"],
+  SL: ["SLE"],
+  SG: ["SGD"],
+  SK: ["EUR"],
+  SI: ["EUR"],
+  SB: ["SBD"],
+  SO: ["SOS"],
+  ZA: ["ZAR"],
+  SS: ["SSP"],
+  ES: ["EUR"],
+  LK: ["LKR"],
+  SD: ["SDG"],
+  SR: ["SRD"],
+  SE: ["SEK"],
+  CH: ["CHF"],
+  SY: ["SYP"],
+  TW: ["TWD"],
+  TJ: ["TJS"],
+  TZ: ["TZS"],
+  TH: ["THB"],
+  TL: ["USD"],
+  TG: ["XOF"],
+  TO: ["TOP"],
+  TT: ["TTD"],
+  TN: ["TND"],
+  TR: ["TRY"],
+  TM: ["TMT"],
+  TV: ["AUD"],
+  UG: ["UGX"],
+  UA: ["UAH"],
+  AE: ["AED"],
+  GB: ["GBP"],
+  US: ["USD"],
+  UY: ["UYU"],
+  UZ: ["UZS"],
+  VU: ["VUV"],
+  VA: ["EUR"],
+  VE: ["VES"],
+  VN: ["VND"],
+  YE: ["YER"],
+  ZM: ["ZMW"],
+  ZW: ["ZWG"],
+  AX: ["EUR"],
+  FO: ["DKK"],
+  XK: ["EUR"]
+});
+var COUNTRY_LANGUAGES = Object.freeze({
+  AF: ["ps", "fa"],
+  AL: ["sq"],
+  DZ: ["ar"],
+  AD: ["ca"],
+  AO: ["pt"],
+  AG: ["en"],
+  AR: ["es"],
+  AM: ["hy"],
+  AU: ["en"],
+  AT: ["de"],
+  AZ: ["az"],
+  BS: ["en"],
+  BH: ["ar"],
+  BD: ["bn"],
+  BB: ["en"],
+  BY: ["be", "ru"],
+  BE: ["nl", "fr", "de"],
+  BZ: ["en"],
+  BJ: ["fr"],
+  BT: ["dz"],
+  BO: ["es", "qu", "ay"],
+  BA: ["bs", "hr", "sr"],
+  BW: ["en", "tn"],
+  BR: ["pt"],
+  BN: ["ms"],
+  BG: ["bg"],
+  BF: ["fr"],
+  BI: ["rn", "fr"],
+  CV: ["pt"],
+  KH: ["km"],
+  CM: ["fr", "en"],
+  CA: ["en", "fr"],
+  CF: ["fr", "sg"],
+  TD: ["fr", "ar"],
+  CL: ["es"],
+  CN: ["zh"],
+  CO: ["es"],
+  KM: ["ar", "fr"],
+  CG: ["fr"],
+  CD: ["fr"],
+  CR: ["es"],
+  CI: ["fr"],
+  HR: ["hr"],
+  CU: ["es"],
+  CY: ["el", "tr"],
+  CZ: ["cs"],
+  DK: ["da"],
+  DJ: ["fr", "ar"],
+  DM: ["en"],
+  DO: ["es"],
+  EC: ["es"],
+  EG: ["ar"],
+  SV: ["es"],
+  GQ: ["es", "fr", "pt"],
+  ER: ["ti", "ar", "en"],
+  EE: ["et"],
+  SZ: ["en", "ss"],
+  ET: ["am"],
+  FJ: ["en", "fj"],
+  FI: ["fi", "sv"],
+  FR: ["fr"],
+  GA: ["fr"],
+  GM: ["en"],
+  GE: ["ka"],
+  DE: ["de"],
+  GH: ["en"],
+  GR: ["el"],
+  GD: ["en"],
+  GT: ["es"],
+  GN: ["fr"],
+  GW: ["pt"],
+  GY: ["en"],
+  HT: ["ht", "fr"],
+  HN: ["es"],
+  HU: ["hu"],
+  IS: ["is"],
+  IN: ["hi", "en"],
+  ID: ["id"],
+  IR: ["fa"],
+  IQ: ["ar", "ku"],
+  IE: ["en", "ga"],
+  IL: ["he", "ar"],
+  IT: ["it"],
+  JM: ["en"],
+  JP: ["ja"],
+  JO: ["ar"],
+  KZ: ["kk", "ru"],
+  KE: ["en", "sw"],
+  KI: ["en"],
+  KP: ["ko"],
+  KR: ["ko"],
+  KW: ["ar"],
+  KG: ["ky", "ru"],
+  LA: ["lo"],
+  LV: ["lv"],
+  LB: ["ar", "fr"],
+  LS: ["en", "st"],
+  LR: ["en"],
+  LY: ["ar"],
+  LI: ["de"],
+  LT: ["lt"],
+  LU: ["lb", "fr", "de"],
+  MG: ["mg", "fr"],
+  MW: ["en", "ny"],
+  MY: ["ms"],
+  MV: ["dv"],
+  ML: ["fr"],
+  MT: ["mt", "en"],
+  MH: ["en", "mh"],
+  MR: ["ar"],
+  MU: ["en"],
+  MX: ["es"],
+  MD: ["ro"],
+  MC: ["fr"],
+  MN: ["mn"],
+  ME: ["sr"],
+  MA: ["ar"],
+  MZ: ["pt"],
+  MM: ["my"],
+  NA: ["en"],
+  NR: ["en", "na"],
+  NP: ["ne"],
+  NL: ["nl"],
+  NZ: ["en", "mi"],
+  NI: ["es"],
+  NE: ["fr"],
+  NG: ["en"],
+  MK: ["mk"],
+  NO: ["no", "nb", "nn"],
+  OM: ["ar"],
+  PK: ["ur", "en"],
+  PW: ["en"],
+  PA: ["es"],
+  PG: ["en"],
+  PY: ["es", "gn"],
+  PE: ["es", "qu"],
+  PH: ["tl", "en"],
+  PL: ["pl"],
+  PT: ["pt"],
+  QA: ["ar"],
+  RO: ["ro"],
+  RU: ["ru"],
+  RW: ["rw", "fr", "en"],
+  KN: ["en"],
+  LC: ["en"],
+  VC: ["en"],
+  WS: ["sm", "en"],
+  SM: ["it"],
+  ST: ["pt"],
+  SA: ["ar"],
+  SN: ["fr"],
+  RS: ["sr"],
+  SC: ["en", "fr"],
+  SL: ["en"],
+  SG: ["en", "ms", "zh", "ta"],
+  SK: ["sk"],
+  SI: ["sl"],
+  SB: ["en"],
+  SO: ["so", "ar"],
+  ZA: ["en", "af", "zu"],
+  SS: ["en"],
+  ES: ["es"],
+  LK: ["si", "ta"],
+  SD: ["ar", "en"],
+  SR: ["nl"],
+  SE: ["sv"],
+  CH: ["de", "fr", "it", "rm"],
+  SY: ["ar"],
+  TW: ["zh"],
+  TJ: ["tg"],
+  TZ: ["sw", "en"],
+  TH: ["th"],
+  TL: ["pt"],
+  TG: ["fr"],
+  TO: ["en", "to"],
+  TT: ["en"],
+  TN: ["ar"],
+  TR: ["tr"],
+  TM: ["tk"],
+  TV: ["en"],
+  UG: ["en", "sw"],
+  UA: ["uk"],
+  AE: ["ar"],
+  GB: ["en"],
+  US: ["en"],
+  UY: ["es"],
+  UZ: ["uz"],
+  VU: ["en", "fr", "bi"],
+  VA: ["it", "la"],
+  VE: ["es"],
+  VN: ["vi"],
+  YE: ["ar"],
+  ZM: ["en"],
+  ZW: ["en", "sn", "nd"],
+  AS: ["en", "sm"],
+  AW: ["nl"],
+  BM: ["en"],
+  CW: ["nl"],
+  FO: ["fo", "da"],
+  GI: ["en"],
+  GL: ["kl", "da"],
+  GG: ["en"],
+  GU: ["en"],
+  HK: ["zh", "en"],
+  IM: ["en"],
+  JE: ["en"],
+  XK: ["sq", "sr"],
+  MO: ["zh", "pt"],
+  PR: ["es", "en"]
+});
+var COUNTRY_ALIASES = Object.freeze({
+  USA: "US",
+  UK: "GB",
+  Holland: "NL",
+  "Czech Republic": "CZ",
+  "Ivory Coast": "CI",
+  Burma: "MM",
+  Swaziland: "SZ",
+  Persia: "IR",
+  "Great Britain": "GB",
+  England: "GB",
+  UAE: "AE",
+  "South Korea": "KR",
+  "North Korea": "KP",
+  "Republic of Ireland": "IE",
+  Suisse: "CH",
+  Svizzera: "CH",
+  Belgique: "BE",
+  Noreg: "NO",
+  Vitryssland: "BY"
+});
+var PRIMARY_BY_CALLING_CODE = Object.freeze({
+  "1": "US",
+  "44": "GB",
+  "7": "RU"
+});
+
+// src/geography/country.ts
+var MAX_INPUT_LENGTH3 = 100;
+var Country = class _Country {
+  static typeInfo = Object.freeze({
+    englishName: "Country",
+    localizedName: "Land",
+    emoji: "\u{1F30D}",
+    sources: Object.freeze([
+      "https://www.iso.org/iso-3166-country-codes.html",
+      "https://en.wikipedia.org/wiki/ISO_3166-1",
+      "https://www.itu.int/rec/T-REC-E.164/",
+      "https://www.iana.org/domains/root/db",
+      "https://www.wikidata.org/wiki/Property:P625",
+      "https://www.wikidata.org/wiki/Property:P36",
+      "https://www.wikidata.org/wiki/Property:P47"
+    ])
+  });
+  alpha2Code;
+  alpha3Code;
+  numericCode;
+  englishName;
+  localizedName;
+  nativeName;
+  callingCode;
+  topLevelDomain;
+  continent;
+  currencyCodes;
+  languageCodes;
+  constructor(row) {
+    this.alpha2Code = row.alpha2;
+    this.alpha3Code = row.alpha3;
+    this.numericCode = row.numeric;
+    this.englishName = row.en;
+    this.localizedName = row.sv;
+    this.nativeName = row.native;
+    this.callingCode = row.callingCode;
+    this.topLevelDomain = row.tld;
+    this.continent = row.continent;
+    this.currencyCodes = COUNTRY_CURRENCIES[row.alpha2] ?? [];
+    this.languageCodes = COUNTRY_LANGUAGES[row.alpha2] ?? [];
+  }
+  /** The canonical value of this country: its ISO 3166-1 alpha-2 code. */
+  get value() {
+    return this.alpha2Code;
+  }
+  /** Display name in the current culture (Swedish or English). */
+  get displayName() {
+    return PrimitivesDefaults.useLocalizedDisplayNames ? this.localizedName : this.englishName;
+  }
+  /** Culture-independent display form. Always the English name. */
+  get formatted() {
+    return this.englishName;
+  }
+  /** Geographic coordinate of the country (centroid, from Wikidata P625). */
+  get coordinate() {
+    const c = COUNTRY_COORDINATES[this.alpha2Code];
+    if (!c) throw new Error(`No coordinate for country ${this.alpha2Code}.`);
+    return GeoCoordinate.create(c[0], c[1]);
+  }
+  /** Approximate latitude (WGS 84) of the country centroid. */
+  get latitude() {
+    return this.coordinate.latitude;
+  }
+  /** Approximate longitude (WGS 84) of the country centroid. */
+  get longitude() {
+    return this.coordinate.longitude;
+  }
+  /** Capital city, or `null` for entries without a capital (e.g. Antarctica). */
+  get capital() {
+    return getCountryCapital(this.alpha2Code);
+  }
+  get isInEuropeanUnion() {
+    return EU_COUNTRIES.has(this.alpha2Code);
+  }
+  get isInEea() {
+    return EEA_COUNTRIES.has(this.alpha2Code);
+  }
+  get isInSchengen() {
+    return SCHENGEN_COUNTRIES.has(this.alpha2Code);
+  }
+  get isInNordics() {
+    return NORDIC_COUNTRIES.has(this.alpha2Code);
+  }
+  get isInSepa() {
+    return SEPA_COUNTRIES.has(this.alpha2Code);
+  }
+  /** True when the euro is among the country's legal tenders. */
+  get usesEuro() {
+    return this.currencyCodes.includes("EUR");
+  }
+  /** Primary ISO 4217 currency code, or `null` when unknown. */
+  get currencyCode() {
+    return this.currencyCodes[0] ?? null;
+  }
+  /**
+   * Primary legal-tender currency, or `null` when unknown. Countries with
+   * several legal tenders (Cuba, Panama, Namibia) return the first; use
+   * {@link currencies} for the full list.
+   */
+  get currency() {
+    const code = this.currencyCode;
+    return code == null ? null : Currency.tryParse(code);
+  }
+  /** All recognized currencies for this country, in priority order. */
+  get currencies() {
+    return Object.freeze(
+      this.currencyCodes.map((code) => Currency.tryParse(code)).filter((c) => c !== null)
+    );
+  }
+  /**
+   * Primary official language, or `null` when unknown. Countries with several
+   * official languages (Belgium, Switzerland) return the most widely spoken;
+   * use {@link officialLanguages} for the full list.
+   */
+  get primaryLanguage() {
+    const code = this.languageCodes[0];
+    return code == null ? null : Language.tryParse(code);
+  }
+  /** All official languages of the country, in priority order. */
+  get officialLanguages() {
+    return Object.freeze(
+      this.languageCodes.map((code) => Language.tryParse(code)).filter((l) => l !== null)
+    );
+  }
+  static tryParse(input) {
+    if (input == null) return null;
+    const sanitized = sanitizeInput(input).trim();
+    if (sanitized.length === 0 || sanitized.length > MAX_INPUT_LENGTH3) return null;
+    const direct = lookupCi(sanitized);
+    if (direct) return direct;
+    if (sanitized.length > 4 && sanitized.slice(0, 4).toLowerCase() === "the ") {
+      const without = sanitized.slice(4);
+      const stripped = lookupCi(without);
+      if (stripped) return stripped;
+    }
+    return null;
+  }
+  static parse(input) {
+    const r = _Country.tryParse(input);
+    if (r === null) throw new Error("Unknown country.");
+    return r;
+  }
+  static isValid(input) {
+    return _Country.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _Country.tryParse(input);
+    if (r) return r.displayName;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _Country.tryParse(input);
+    if (r) return r.alpha2Code;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null) {
+      const trimmed = input.trim();
+      return trimmed.length > 0 ? trimmed : null;
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _Country.normalize(input) === input;
+  }
+  /** Look up a country by its phone calling code. Primary owner wins for shared codes. */
+  static tryFindByCallingCode(callingCode) {
+    if (callingCode == null) return null;
+    const trimmed = callingCode.trim();
+    if (trimmed.length === 0) return null;
+    return BY_CALLING_CODE.get(trimmed) ?? null;
+  }
+  /** All known countries. */
+  static get all() {
+    return ALL_COUNTRIES;
+  }
+  /**
+   * Returns countries within `radiusKm` of this country, ordered by distance.
+   */
+  findNeighbors(radiusKm) {
+    if (!Number.isFinite(radiusKm) || radiusKm <= 0) {
+      throw new RangeError("radiusKm must be a positive finite number.");
+    }
+    return _Country.findNeighbors(this.coordinate, radiusKm).filter((d) => d.country !== this);
+  }
+  /** Returns countries within `radiusKm` of `coordinate`, ordered by distance. */
+  static findNeighbors(coordinate, radiusKm) {
+    if (!Number.isFinite(radiusKm) || radiusKm <= 0) {
+      throw new RangeError("radiusKm must be a positive finite number.");
+    }
+    const out = [];
+    for (const c of ALL_COUNTRIES) {
+      const dist = GeoCoordinate.distanceKilometers(coordinate, c.coordinate);
+      if (dist <= radiusKm) out.push({ country: c, distanceKilometers: dist });
+    }
+    out.sort((a, b) => a.distanceKilometers - b.distanceKilometers);
+    return out;
+  }
+  /**
+   * Scans unstructured text for country names (4+ chars, word-bounded). Low confidence
+   * because country names can occur in non-geographic contexts.
+   */
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    SCAN_PATTERN.lastIndex = 0;
+    let m;
+    while ((m = SCAN_PATTERN.exec(text)) !== null) {
+      const country = _Country.tryParse(m[0]);
+      if (!country) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: m.index,
+          length: m[0].length,
+          originalText: m[0],
+          typeName: "Country",
+          category: TextCandidateCategory.Geography,
+          normalizedForm: country.toNormalizedString(),
+          formattedForm: country.toString(),
+          maskedForm: country.localizedName,
+          confidence: TextMatchConfidence.Low,
+          value: country
+        })
+      );
+    }
+    return out;
+  }
+  toNormalizedString() {
+    return this.alpha2Code;
+  }
+  toString() {
+    return this.displayName;
+  }
+  toDisplayString() {
+    return this.displayName;
+  }
+  toEnglishString() {
+    return this.englishName;
+  }
+  toNativeString() {
+    return this.nativeName;
+  }
+  equals(other) {
+    return other != null && this.alpha2Code === other.alpha2Code;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.alpha2Code < other.alpha2Code ? -1 : this.alpha2Code > other.alpha2Code ? 1 : 0;
+  }
+  static get Sweden() {
+    return getByAlpha2("SE");
+  }
+  static get Norway() {
+    return getByAlpha2("NO");
+  }
+  static get Finland() {
+    return getByAlpha2("FI");
+  }
+  static get Denmark() {
+    return getByAlpha2("DK");
+  }
+  static get Iceland() {
+    return getByAlpha2("IS");
+  }
+  static get Germany() {
+    return getByAlpha2("DE");
+  }
+  static get Poland() {
+    return getByAlpha2("PL");
+  }
+  static get Estonia() {
+    return getByAlpha2("EE");
+  }
+  static get Lithuania() {
+    return getByAlpha2("LT");
+  }
+  static get Latvia() {
+    return getByAlpha2("LV");
+  }
+  static get Romania() {
+    return getByAlpha2("RO");
+  }
+  static get Bulgaria() {
+    return getByAlpha2("BG");
+  }
+  static get CzechRepublic() {
+    return getByAlpha2("CZ");
+  }
+  static get Spain() {
+    return getByAlpha2("ES");
+  }
+  static get Netherlands() {
+    return getByAlpha2("NL");
+  }
+  static get Greece() {
+    return getByAlpha2("GR");
+  }
+  static get Italy() {
+    return getByAlpha2("IT");
+  }
+  static get Slovenia() {
+    return getByAlpha2("SI");
+  }
+  static get Croatia() {
+    return getByAlpha2("HR");
+  }
+  static get Portugal() {
+    return getByAlpha2("PT");
+  }
+  static get Hungary() {
+    return getByAlpha2("HU");
+  }
+  static get France() {
+    return getByAlpha2("FR");
+  }
+  static get Slovakia() {
+    return getByAlpha2("SK");
+  }
+  static get Belgium() {
+    return getByAlpha2("BE");
+  }
+  static get UnitedKingdom() {
+    return getByAlpha2("GB");
+  }
+  static get Austria() {
+    return getByAlpha2("AT");
+  }
+  static get Cyprus() {
+    return getByAlpha2("CY");
+  }
+  static get Switzerland() {
+    return getByAlpha2("CH");
+  }
+  static get Ireland() {
+    return getByAlpha2("IE");
+  }
+  static get Luxembourg() {
+    return getByAlpha2("LU");
+  }
+  static get Malta() {
+    return getByAlpha2("MT");
+  }
+  static get Liechtenstein() {
+    return getByAlpha2("LI");
+  }
+  /** @internal */
+  static _fromRow(row) {
+    return new _Country(row);
+  }
+};
+var ALL_COUNTRIES = COUNTRY_ROWS.map((r) => Country._fromRow(r));
+var BY_ALPHA2 = /* @__PURE__ */ new Map();
+var BY_NAME2 = /* @__PURE__ */ new Map();
+var BY_CALLING_CODE = /* @__PURE__ */ new Map();
+for (const c of ALL_COUNTRIES) {
+  BY_ALPHA2.set(c.alpha2Code.toUpperCase(), c);
+  BY_NAME2.set(c.alpha2Code.toUpperCase(), c);
+  BY_NAME2.set(c.alpha3Code.toUpperCase(), c);
+  BY_NAME2.set(c.englishName.toLowerCase(), c);
+  if (!BY_NAME2.has(c.localizedName.toLowerCase())) BY_NAME2.set(c.localizedName.toLowerCase(), c);
+  if (c.nativeName.toLowerCase() !== c.englishName.toLowerCase() && !BY_NAME2.has(c.nativeName.toLowerCase())) {
+    BY_NAME2.set(c.nativeName.toLowerCase(), c);
+  }
+  if (!BY_CALLING_CODE.has(c.callingCode)) BY_CALLING_CODE.set(c.callingCode, c);
+}
+for (const [aliasOrCode, alpha2] of Object.entries(COUNTRY_ALIASES)) {
+  const target = BY_ALPHA2.get(alpha2.toUpperCase());
+  if (target) BY_NAME2.set(aliasOrCode.toLowerCase(), target);
+}
+for (const [code, alpha2] of Object.entries(PRIMARY_BY_CALLING_CODE)) {
+  const target = BY_ALPHA2.get(alpha2.toUpperCase());
+  if (target) BY_CALLING_CODE.set(code, target);
+}
+var SCAN_PATTERN = (() => {
+  const names = [...BY_NAME2.keys()].filter((n) => n.length >= 4).sort((a, b) => b.length - a.length).map(escapeRegex);
+  return new RegExp(`(?<![\\p{L}\\p{N}_])(?:${names.join("|")})(?![\\p{L}\\p{N}_])`, "giu");
+})();
+function getByAlpha2(code) {
+  const c = BY_ALPHA2.get(code.toUpperCase());
+  if (!c) throw new Error(`Unknown country code ${code}.`);
+  return c;
+}
+function lookupCi(input) {
+  const upper = input.toUpperCase();
+  const a2 = BY_ALPHA2.get(upper);
+  if (a2) return a2;
+  const lower = input.toLowerCase();
+  return BY_NAME2.get(lower) ?? BY_NAME2.get(upper) ?? null;
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/validation/validation-error-reason.ts
+var ValidationErrorReason = {
+  // --- Common ---
+  InputIsEmpty: "InputIsEmpty",
+  InputTooLong: "InputTooLong",
+  InvalidFormat: "InvalidFormat",
+  // --- Email ---
+  MissingAtSign: "MissingAtSign",
+  InvalidDomain: "InvalidDomain"
+};
+
+// src/validation/validation-issue.ts
+var ValidationIssue = class {
+  reason;
+  englishDescription;
+  localizedDescription;
+  constructor(reason, englishDescription, localizedDescription) {
+    this.reason = reason;
+    this.englishDescription = englishDescription;
+    this.localizedDescription = localizedDescription;
+  }
+  /**
+   * Returns {@link localizedDescription} when
+   * {@link PrimitivesDefaults.useLocalizedDisplayNames} is `true`, otherwise
+   * {@link englishDescription}.
+   */
+  get description() {
+    return PrimitivesDefaults.useLocalizedDisplayNames ? this.localizedDescription : this.englishDescription;
+  }
+};
+
+// src/validation/validation-result.ts
+var ValidationResult = class {
+  rawInput;
+  isValid;
+  issues;
+  /** @internal — use `validResult` / `invalidResult` factories. */
+  constructor(rawInput, isValid, issues) {
+    this.rawInput = rawInput ?? null;
+    this.isValid = isValid;
+    this.issues = Object.freeze([...issues]);
+  }
+};
+function validResult(rawInput) {
+  return new ValidationResult(rawInput, true, []);
+}
+function invalidResult(rawInput, reasonOrIssues, englishDescription, localizedDescription) {
+  if (typeof reasonOrIssues === "string") {
+    if (englishDescription === void 0 || localizedDescription === void 0) {
+      throw new Error("invalidResult requires both english and localized descriptions");
+    }
+    return new ValidationResult(rawInput, false, [
+      new ValidationIssue(reasonOrIssues, englishDescription, localizedDescription)
+    ]);
+  }
+  return new ValidationResult(rawInput, false, reasonOrIssues);
+}
+
+// src/web/email-address.ts
+var PublicEmailProvider = {
+  Unknown: "Unknown",
+  Gmail: "Gmail",
+  Outlook: "Outlook",
+  Yahoo: "Yahoo",
+  ICloud: "ICloud",
+  ProtonMail: "ProtonMail",
+  Aol: "Aol",
+  Gmx: "Gmx",
+  MailCom: "MailCom",
+  Yandex: "Yandex",
+  Zoho: "Zoho",
+  Tuta: "Tuta",
+  Hey: "Hey",
+  DuckDuckGoEmail: "DuckDuckGoEmail",
+  SimpleLogin: "SimpleLogin",
+  WebDe: "WebDe",
+  MailRu: "MailRu",
+  WirtualnaPolska: "WirtualnaPolska",
+  Onet: "Onet",
+  Interia: "Interia",
+  Tlen: "Tlen",
+  Seznam: "Seznam",
+  Libero: "Libero",
+  FreemailHu: "FreemailHu",
+  Abv: "Abv",
+  InboxLv: "InboxLv",
+  UkrNet: "UkrNet",
+  Naver: "Naver",
+  Telia: "Telia",
+  Tele2: "Tele2",
+  Comhem: "Comhem",
+  Bredbandsbolaget: "Bredbandsbolaget",
+  Bredband2: "Bredband2",
+  Ownit: "Ownit",
+  Spray: "Spray",
+  Passagen: "Passagen",
+  Bahnhof: "Bahnhof",
+  Glocalnet: "Glocalnet",
+  OnlineNo: "OnlineNo",
+  Kolumbus: "Kolumbus",
+  Aland: "Aland"
+};
+var MAX_INPUT_LENGTH4 = 320;
+var PROVIDER_DOMAINS = {
+  // International
+  "gmail.com": PublicEmailProvider.Gmail,
+  "googlemail.com": PublicEmailProvider.Gmail,
+  "outlook.com": PublicEmailProvider.Outlook,
+  "outlook.se": PublicEmailProvider.Outlook,
+  "outlook.fr": PublicEmailProvider.Outlook,
+  "outlook.co": PublicEmailProvider.Outlook,
+  "hotmail.com": PublicEmailProvider.Outlook,
+  "hotmail.se": PublicEmailProvider.Outlook,
+  "hotmail.co.uk": PublicEmailProvider.Outlook,
+  "hotmail.fr": PublicEmailProvider.Outlook,
+  "hotmail.de": PublicEmailProvider.Outlook,
+  "hotmail.no": PublicEmailProvider.Outlook,
+  "hotmail.dk": PublicEmailProvider.Outlook,
+  "hotmail.fi": PublicEmailProvider.Outlook,
+  "hotmail.it": PublicEmailProvider.Outlook,
+  "hotmail.es": PublicEmailProvider.Outlook,
+  "live.com": PublicEmailProvider.Outlook,
+  "live.se": PublicEmailProvider.Outlook,
+  "live.fr": PublicEmailProvider.Outlook,
+  "live.dk": PublicEmailProvider.Outlook,
+  "live.co.uk": PublicEmailProvider.Outlook,
+  "live.it": PublicEmailProvider.Outlook,
+  "live.no": PublicEmailProvider.Outlook,
+  "msn.com": PublicEmailProvider.Outlook,
+  "windowslive.com": PublicEmailProvider.Outlook,
+  "yahoo.com": PublicEmailProvider.Yahoo,
+  "yahoo.se": PublicEmailProvider.Yahoo,
+  "yahoo.co.uk": PublicEmailProvider.Yahoo,
+  "yahoo.fr": PublicEmailProvider.Yahoo,
+  "yahoo.de": PublicEmailProvider.Yahoo,
+  "yahoo.it": PublicEmailProvider.Yahoo,
+  "yahoo.es": PublicEmailProvider.Yahoo,
+  "yahoo.gr": PublicEmailProvider.Yahoo,
+  "yahoo.ro": PublicEmailProvider.Yahoo,
+  "yahoo.co": PublicEmailProvider.Yahoo,
+  "yahoo.no": PublicEmailProvider.Yahoo,
+  "ymail.com": PublicEmailProvider.Yahoo,
+  "rocketmail.com": PublicEmailProvider.Yahoo,
+  "icloud.com": PublicEmailProvider.ICloud,
+  "me.com": PublicEmailProvider.ICloud,
+  "mac.com": PublicEmailProvider.ICloud,
+  "protonmail.com": PublicEmailProvider.ProtonMail,
+  "protonmail.ch": PublicEmailProvider.ProtonMail,
+  "proton.me": PublicEmailProvider.ProtonMail,
+  "pm.me": PublicEmailProvider.ProtonMail,
+  "aol.com": PublicEmailProvider.Aol,
+  "aol.se": PublicEmailProvider.Aol,
+  "gmx.com": PublicEmailProvider.Gmx,
+  "gmx.de": PublicEmailProvider.Gmx,
+  "gmx.net": PublicEmailProvider.Gmx,
+  "gmx.at": PublicEmailProvider.Gmx,
+  "mail.com": PublicEmailProvider.MailCom,
+  "email.com": PublicEmailProvider.MailCom,
+  "post.com": PublicEmailProvider.MailCom,
+  "europe.com": PublicEmailProvider.MailCom,
+  "iname.com": PublicEmailProvider.MailCom,
+  "yandex.com": PublicEmailProvider.Yandex,
+  "yandex.ru": PublicEmailProvider.Yandex,
+  "zoho.com": PublicEmailProvider.Zoho,
+  "tuta.io": PublicEmailProvider.Tuta,
+  "tutanota.com": PublicEmailProvider.Tuta,
+  "hey.com": PublicEmailProvider.Hey,
+  "duck.com": PublicEmailProvider.DuckDuckGoEmail,
+  "simplelogin.com": PublicEmailProvider.SimpleLogin,
+  // Regional (Europe)
+  "web.de": PublicEmailProvider.WebDe,
+  "mail.ru": PublicEmailProvider.MailRu,
+  "wp.pl": PublicEmailProvider.WirtualnaPolska,
+  "vp.pl": PublicEmailProvider.WirtualnaPolska,
+  "onet.pl": PublicEmailProvider.Onet,
+  "onet.eu": PublicEmailProvider.Onet,
+  "op.pl": PublicEmailProvider.Onet,
+  "o2.pl": PublicEmailProvider.Onet,
+  "poczta.onet.pl": PublicEmailProvider.Onet,
+  "interia.pl": PublicEmailProvider.Interia,
+  "interia.eu": PublicEmailProvider.Interia,
+  "tlen.pl": PublicEmailProvider.Tlen,
+  "seznam.cz": PublicEmailProvider.Seznam,
+  "libero.it": PublicEmailProvider.Libero,
+  "freemail.hu": PublicEmailProvider.FreemailHu,
+  "abv.bg": PublicEmailProvider.Abv,
+  "inbox.lv": PublicEmailProvider.InboxLv,
+  "ukr.net": PublicEmailProvider.UkrNet,
+  "naver.com": PublicEmailProvider.Naver,
+  // Swedish ISP / portal email
+  "telia.com": PublicEmailProvider.Telia,
+  "telia.se": PublicEmailProvider.Telia,
+  "home.se": PublicEmailProvider.Telia,
+  "swipnet.se": PublicEmailProvider.Telia,
+  "tele2.se": PublicEmailProvider.Tele2,
+  "comhem.se": PublicEmailProvider.Comhem,
+  "bredband.net": PublicEmailProvider.Bredbandsbolaget,
+  "bredbandsbolaget.se": PublicEmailProvider.Bredbandsbolaget,
+  "bredband2.com": PublicEmailProvider.Bredband2,
+  "ownit.nu": PublicEmailProvider.Ownit,
+  "mail.se": PublicEmailProvider.Spray,
+  "spray.se": PublicEmailProvider.Spray,
+  "passagen.se": PublicEmailProvider.Passagen,
+  "bahnhof.se": PublicEmailProvider.Bahnhof,
+  "glocalnet.net": PublicEmailProvider.Glocalnet,
+  // Nordic ISP
+  "online.no": PublicEmailProvider.OnlineNo,
+  "kolumbus.fi": PublicEmailProvider.Kolumbus,
+  "aland.net": PublicEmailProvider.Aland
+};
+var DOMAIN_CORRECTIONS = {
+  // Gmail misspellings
+  "gnail.com": "gmail.com",
+  "gamil.com": "gmail.com",
+  "gmai.com": "gmail.com",
+  "gmil.com": "gmail.com",
+  "gmsil.com": "gmail.com",
+  "gmal.com": "gmail.com",
+  "gmaill.com": "gmail.com",
+  "gamail.com": "gmail.com",
+  "gmail.con": "gmail.com",
+  "gmail.vom": "gmail.com",
+  "gmail.cim": "gmail.com",
+  "gmail.comi": "gmail.com",
+  "gmail.se": "gmail.com",
+  "gmail.co": "gmail.com",
+  // Hotmail / Outlook misspellings
+  "hotmai.com": "hotmail.com",
+  "hotmil.com": "hotmail.com",
+  "hotmsil.com": "hotmail.com",
+  "hotmal.com": "hotmail.com",
+  "homail.com": "hotmail.com",
+  "hotnail.com": "hotmail.com",
+  "hitmail.com": "hotmail.com",
+  "hptmail.com": "hotmail.com",
+  "hmail.com": "hotmail.com",
+  "hotmail.con": "hotmail.com",
+  "hotmail.cpm": "hotmail.com",
+  "hotmail.co": "hotmail.com",
+  "hotmail.vom": "hotmail.com",
+  "hotmail.cim": "hotmail.com",
+  "hotmail.comm": "hotmail.com",
+  "outlook.con": "outlook.com",
+  "putlook.com": "outlook.com",
+  // iCloud misspellings
+  "icloude.com": "icloud.com",
+  "icloud.se": "icloud.com",
+  "icloud.co": "icloud.com",
+  // Onet misspellings
+  "02.pl": "o2.pl"
+};
+var tldCountryMapCache = null;
+function getTldCountryMap() {
+  if (tldCountryMapCache) return tldCountryMapCache;
+  const m = /* @__PURE__ */ new Map();
+  for (const c of Country.all) {
+    if (c.topLevelDomain) m.set(c.topLevelDomain.toLowerCase(), c);
+  }
+  tldCountryMapCache = m;
+  return m;
+}
+var EMAIL_PATTERN = /^(?!\.)[a-zA-Z0-9_](?!.*\.\.)(?:[a-zA-Z0-9._%+-]*[a-zA-Z0-9_%+-])?@(?!-)[a-zA-Z0-9-]+(?<!-)(?:\.(?!-)[a-zA-Z0-9-]+(?<!-))*\.[a-zA-Z]{2,}$/;
+var SCAN_PATTERN2 = /(?<![\w.@])(?!\.)[a-zA-Z0-9](?:[a-zA-Z0-9._%+-]*[a-zA-Z0-9_%+-])?@(?!-)[a-zA-Z0-9-]+(?:\.(?!-)[a-zA-Z0-9-]+)*\.[a-zA-Z]{2,}(?![\w@])/gu;
+function domainToAscii(domain) {
+  try {
+    const ascii = new URL("http://" + domain).hostname;
+    return ascii;
+  } catch {
+    return null;
+  }
+}
+var EmailAddress = class _EmailAddress {
+  static typeInfo = Object.freeze({
+    englishName: "Email Address",
+    localizedName: "E-postadress",
+    emoji: "\u{1F4E7}",
+    sources: Object.freeze([
+      "https://datatracker.ietf.org/doc/html/rfc5321#section-2.3.11",
+      "https://datatracker.ietf.org/doc/html/rfc5321"
+    ])
+  });
+  value;
+  localPart;
+  domain;
+  domainAscii;
+  topLevelDomain;
+  country;
+  provider;
+  originalDomain;
+  get isPublicEmailProvider() {
+    return this.provider != null;
+  }
+  get isInternationalizedDomain() {
+    return this.domain !== this.domainAscii;
+  }
+  get wasCorrected() {
+    return this.originalDomain != null;
+  }
+  constructor(value, localPart, domain, domainAscii, tld, country, provider, originalDomain) {
+    this.value = value;
+    this.localPart = localPart;
+    this.domain = domain;
+    this.domainAscii = domainAscii;
+    this.topLevelDomain = tld;
+    this.country = country;
+    this.provider = provider;
+    this.originalDomain = originalDomain;
+  }
+  /**
+   * Attempts to parse and normalize an email address.
+   *
+   * When `tryCorrectTypos` is `true`, common domain misspellings such as
+   * `gmail.con`, `gnail.com`, or `hotmil.com` are corrected automatically.
+   * The original domain is preserved in `originalDomain`. Typo correction is
+   * opt-in and should only be used when silent correction is acceptable.
+   */
+  static tryParse(input, options) {
+    if (input == null || input.trim() === "") return null;
+    let sanitized = sanitizeInput(input);
+    const ltIndex = sanitized.indexOf("<");
+    if (ltIndex >= 0) {
+      const gtIndex = sanitized.indexOf(">", ltIndex + 1);
+      if (gtIndex > ltIndex) sanitized = sanitized.slice(ltIndex + 1, gtIndex);
+    }
+    sanitized = sanitized.trim();
+    if (sanitized.toLowerCase().startsWith("mailto:")) {
+      sanitized = sanitized.slice(7);
+      const qIndex = sanitized.indexOf("?");
+      if (qIndex >= 0) sanitized = sanitized.slice(0, qIndex);
+    }
+    let normalized = sanitized.replace(/ /g, "").toLowerCase();
+    if (normalized.endsWith(".")) normalized = normalized.slice(0, -1);
+    if (normalized.length === 0 || normalized.length > MAX_INPUT_LENGTH4) return null;
+    const atIndex = normalized.lastIndexOf("@");
+    if (atIndex <= 0 || atIndex === normalized.length - 1) return null;
+    const localPart = normalized.slice(0, atIndex);
+    let domain = normalized.slice(atIndex + 1);
+    let domainForValidation = domain;
+    if (hasNonAscii(domain)) {
+      for (const ch of domain) {
+        const cp = ch.codePointAt(0);
+        if (cp > 127 && !isUnicodeLetter(ch)) return null;
+      }
+      const ascii = domainToAscii(domain);
+      if (ascii == null) return null;
+      domainForValidation = ascii;
+    }
+    const emailForValidation = `${localPart}@${domainForValidation}`;
+    if (!EMAIL_PATTERN.test(emailForValidation)) return null;
+    let originalDomain = null;
+    if (options?.tryCorrectTypos === true) {
+      const corrected = DOMAIN_CORRECTIONS[domain];
+      if (corrected != null) {
+        originalDomain = domain;
+        domain = corrected;
+        normalized = `${localPart}@${domain}`;
+        domainForValidation = domain;
+      }
+    }
+    const lastDot = domain.lastIndexOf(".");
+    const tld = lastDot >= 0 ? domain.slice(lastDot + 1) : "";
+    const country = tld.length > 0 ? getTldCountryMap().get("." + tld) ?? null : null;
+    const provider = PROVIDER_DOMAINS[domain] ?? null;
+    return new _EmailAddress(
+      normalized,
+      localPart,
+      domain,
+      domainForValidation,
+      tld,
+      country,
+      provider,
+      originalDomain
+    );
+  }
+  static parse(input, options) {
+    const r = _EmailAddress.tryParse(input, options);
+    if (r === null) throw new Error("Invalid email address.");
+    return r;
+  }
+  static isValid(input) {
+    return _EmailAddress.tryParse(input) !== null;
+  }
+  /**
+   * Returns a `ValidationResult` describing why the input is invalid,
+   * or a valid result when the input is well-formed.
+   */
+  static validate(input) {
+    if (input == null || input.trim() === "") {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InputIsEmpty,
+        "Input is empty or whitespace.",
+        "V\xE4rdet \xE4r tomt."
+      );
+    }
+    let sanitized = sanitizeInput(input);
+    const ltIndex = sanitized.indexOf("<");
+    if (ltIndex >= 0) {
+      const gtIndex = sanitized.indexOf(">", ltIndex + 1);
+      if (gtIndex > ltIndex) sanitized = sanitized.slice(ltIndex + 1, gtIndex);
+    }
+    sanitized = sanitized.trim();
+    if (sanitized.toLowerCase().startsWith("mailto:")) {
+      sanitized = sanitized.slice(7);
+      const qIndex = sanitized.indexOf("?");
+      if (qIndex >= 0) sanitized = sanitized.slice(0, qIndex);
+    }
+    let normalized = sanitized.replace(/ /g, "").toLowerCase();
+    if (normalized.endsWith(".")) normalized = normalized.slice(0, -1);
+    if (normalized.length === 0 || normalized.length > MAX_INPUT_LENGTH4) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InputTooLong,
+        "Email address is too long.",
+        "E-postadressen \xE4r f\xF6r l\xE5ng."
+      );
+    }
+    const atIndex = normalized.lastIndexOf("@");
+    if (atIndex <= 0 || atIndex === normalized.length - 1) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.MissingAtSign,
+        "Email address must contain an @ sign with text before and after.",
+        "E-postadressen m\xE5ste inneh\xE5lla ett @-tecken med text f\xF6re och efter."
+      );
+    }
+    const localPart = normalized.slice(0, atIndex);
+    const domain = normalized.slice(atIndex + 1);
+    let domainForValidation = domain;
+    if (hasNonAscii(domain)) {
+      for (const ch of domain) {
+        const cp = ch.codePointAt(0);
+        if (cp > 127 && !isUnicodeLetter(ch)) {
+          return invalidResult(
+            input,
+            ValidationErrorReason.InvalidDomain,
+            "Email address has an invalid domain.",
+            "E-postadressen har en ogiltig dom\xE4n."
+          );
+        }
+      }
+      const ascii = domainToAscii(domain);
+      if (ascii == null) {
+        return invalidResult(
+          input,
+          ValidationErrorReason.InvalidDomain,
+          "Email address has an invalid domain.",
+          "E-postadressen har en ogiltig dom\xE4n."
+        );
+      }
+      domainForValidation = ascii;
+    }
+    const emailForValidation = `${localPart}@${domainForValidation}`;
+    if (!EMAIL_PATTERN.test(emailForValidation)) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InvalidFormat,
+        "Invalid email address format.",
+        "Ogiltigt format f\xF6r e-postadress."
+      );
+    }
+    return validResult(input);
+  }
+  /**
+   * Returns the normalized email in lowercase, e.g. `user@example.com`.
+   * Returns `null` for invalid or empty input.
+   */
+  static format(input, options) {
+    const r = _EmailAddress.tryParse(
+      input,
+      options?.tryCorrectTypos != null ? { tryCorrectTypos: options.tryCorrectTypos } : void 0
+    );
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  /** Returns the normalized email, e.g. `user@example.com`, or `null` if invalid. */
+  static normalize(input, options) {
+    return _EmailAddress.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _EmailAddress.normalize(input) === input;
+  }
+  /** Returns the normalized email address, e.g. `user@example.com`. */
+  toNormalizedString() {
+    return this.value;
+  }
+  /** Returns the normalized email address, e.g. `user@example.com`. */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Returns the email with the domain in ASCII (Punycode) form, e.g.
+   * `user@xn--rneholm-b1a.com`. Same as `toString()` for ASCII domains.
+   */
+  toAsciiString() {
+    return this.isInternationalizedDomain ? `${this.localPart}@${this.domainAscii}` : this.value;
+  }
+  /**
+   * Scans unstructured text for potential email addresses. Heuristic; may include false positives.
+   */
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    SCAN_PATTERN2.lastIndex = 0;
+    let m;
+    while ((m = SCAN_PATTERN2.exec(text)) !== null) {
+      const r = _EmailAddress.tryParse(m[0]);
+      if (!r) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: m.index,
+          length: m[0].length,
+          originalText: m[0],
+          typeName: "EmailAddress",
+          category: TextCandidateCategory.Contact,
+          normalizedForm: r.toNormalizedString(),
+          formattedForm: r.toString(),
+          maskedForm: maskEmailAddressInternal(r, false),
+          confidence: TextMatchConfidence.High,
+          value: r
+        })
+      );
+    }
+    return out;
+  }
+  equals(other) {
+    return other != null && this.value === other.value;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.value < other.value ? -1 : this.value > other.value ? 1 : 0;
+  }
+};
+function hasNonAscii(s) {
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) > 127) return true;
+  }
+  return false;
+}
+var UNICODE_LETTER = /\p{L}/u;
+function isUnicodeLetter(ch) {
+  return UNICODE_LETTER.test(ch);
+}
+function maskEmailAddress(email, options) {
+  return maskEmailAddressInternal(email, options?.maskDomain === true);
+}
+function maskEmailAddressInternal(email, maskDomain) {
+  const local = email.localPart;
+  const maskedLocal = local.length <= 1 ? local : local[0] + "*".repeat(Math.min(local.length - 1, 3));
+  if (maskDomain) {
+    const domain = email.domain;
+    const firstDot = domain.indexOf(".");
+    if (firstDot > 0) {
+      const label = domain.slice(0, firstDot);
+      const suffix = domain.slice(firstDot);
+      const maskedDomain = label.length <= 1 ? label : label[0] + "*".repeat(Math.min(label.length - 1, 3));
+      return `${maskedLocal}@${maskedDomain}${suffix}`;
+    }
+  }
+  return `${maskedLocal}@${email.domain}`;
+}
+function toMailtoUri(email) {
+  return `mailto:${email.toNormalizedString()}`;
+}
+
+// src/web/url.ts
+var MAX_INPUT_LENGTH5 = 2048;
+var RESERVED_TLDS = /* @__PURE__ */ new Set(["test", "example", "invalid", "localhost"]);
+var RESERVED_DOMAINS = /* @__PURE__ */ new Set(["example.com", "example.org", "example.net"]);
+var DEFAULT_PORTS = {
+  http: 80,
+  https: 443,
+  ftp: 21,
+  ws: 80,
+  wss: 443,
+  gopher: 70
+};
+var tldCountryMapCache2 = null;
+function getTldCountryMap2() {
+  if (tldCountryMapCache2) return tldCountryMapCache2;
+  const m = /* @__PURE__ */ new Map();
+  for (const c of Country.all) {
+    if (c.topLevelDomain) m.set(c.topLevelDomain.toLowerCase(), c);
+  }
+  tldCountryMapCache2 = m;
+  return m;
+}
+var SCAN_PATTERN3 = /(?:[a-zA-Z][\w+.-]*:\/\/[^\s<>"']+|(?:mailto|tel|sms|callto):[^\s<>"']+|\bwww\.[^\s<>"']+)/gi;
+var IPV4 = /^(?:\d{1,3}\.){3}\d{1,3}$/;
+var ABSOLUTE_URI = /^([a-zA-Z][a-zA-Z0-9+\-.]*):/;
+var HIERARCHICAL_RE = /^([a-zA-Z][a-zA-Z0-9+\-.]*):\/\//;
+var Url = class _Url {
+  static typeInfo = Object.freeze({
+    englishName: "URL",
+    localizedName: "Webbadress",
+    emoji: "\u{1F517}",
+    sources: Object.freeze([
+      "https://datatracker.ietf.org/doc/html/rfc3986",
+      "https://datatracker.ietf.org/doc/html/rfc2606",
+      "https://datatracker.ietf.org/doc/html/rfc6761"
+    ])
+  });
+  /** The normalized URL string, e.g. `https://www.example.com/path`. */
+  value;
+  /** The URI scheme without `://`, e.g. `https`. */
+  scheme;
+  /** The full hostname, e.g. `www.example.com`. Empty for non-hierarchical URIs. */
+  host;
+  /** Explicit port, or `null` when the default port for the scheme is used. */
+  port;
+  /** The path component, e.g. `/path/to/page`. Root paths are `/`. */
+  path;
+  /** Query string without `?`, or `null` when absent. */
+  query;
+  /** Fragment without `#`, or `null` when absent. */
+  fragment;
+  /** Top-level domain without the dot, e.g. `com`, `se`. */
+  topLevelDomain;
+  /** Country associated with a country-code TLD, or `null` for generic TLDs. */
+  country;
+  /** True when the scheme is `https`. */
+  isSecure;
+  /** True when the host is a reserved example/test domain (RFC 2606 / RFC 6761). */
+  isExampleDomain;
+  /** True when the host is an IP address. */
+  isIpAddress;
+  constructor(p) {
+    this.value = p.value;
+    this.scheme = p.scheme;
+    this.host = p.host;
+    this.port = p.port;
+    this.path = p.path;
+    this.query = p.query;
+    this.fragment = p.fragment;
+    this.topLevelDomain = p.tld;
+    this.country = p.country;
+    this.isSecure = p.scheme === "https";
+    this.isExampleDomain = p.isExample;
+    this.isIpAddress = p.isIp;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const trimmed = sanitizeInput(input).trim();
+    if (trimmed.length === 0 || trimmed.length > MAX_INPUT_LENGTH5) return null;
+    let parsed = _Url.#tryParseAbsolute(trimmed);
+    if (parsed == null) {
+      if (!trimmed.includes(".")) return null;
+      parsed = _Url.#tryParseAbsolute("https://" + trimmed);
+      if (parsed == null) return null;
+    }
+    return parsed;
+  }
+  static parse(input) {
+    const r = _Url.tryParse(input);
+    if (r === null) throw new Error("Invalid URL.");
+    return r;
+  }
+  /**
+   * The standard `URL` view of this value, for interop with `fetch` and other
+   * web APIs. The .NET port exposes the same thing as `ToUri()`.
+   */
+  toUrl() {
+    return new URL(this.value);
+  }
+  /** Creates a {@link Url} from a standard `URL`. Throws when it cannot be represented. */
+  static fromUrl(url) {
+    const r = _Url.tryParse(url.href);
+    if (r === null) throw new Error("Invalid URL.");
+    return r;
+  }
+  static isValid(input) {
+    return _Url.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _Url.tryParse(input);
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _Url.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _Url.normalize(input) === input;
+  }
+  /** Returns the normalized URL, e.g. `https://www.example.com/path`. */
+  toNormalizedString() {
+    return this.value;
+  }
+  /** Returns the normalized URL, e.g. `https://www.example.com/path`. */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Scans unstructured text for potential URLs. Heuristic — may include false positives.
+   */
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    SCAN_PATTERN3.lastIndex = 0;
+    let m;
+    while ((m = SCAN_PATTERN3.exec(text)) !== null) {
+      const candidate = trimTrailingPunctuation(m[0]);
+      const url = _Url.tryParse(candidate);
+      if (!url) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: m.index,
+          length: candidate.length,
+          originalText: candidate,
+          typeName: "Url",
+          category: TextCandidateCategory.Contact,
+          normalizedForm: url.toNormalizedString(),
+          formattedForm: url.toString(),
+          maskedForm: maskUrl(url),
+          confidence: TextMatchConfidence.High,
+          value: url
+        })
+      );
+    }
+    return out;
+  }
+  equals(other) {
+    return other != null && this.value === other.value;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.value < other.value ? -1 : this.value > other.value ? 1 : 0;
+  }
+  static #tryParseAbsolute(input) {
+    const m = input.match(ABSOLUTE_URI);
+    if (!m) return null;
+    const scheme = m[1].toLowerCase();
+    if (scheme.includes(".")) return null;
+    const isHierarchical = HIERARCHICAL_RE.test(input);
+    if (isHierarchical) {
+      return _Url.#parseHierarchical(input, scheme);
+    }
+    return _Url.#parseNonHierarchical(input, scheme);
+  }
+  static #parseHierarchical(input, scheme) {
+    let u;
+    try {
+      u = new URL(input);
+    } catch {
+      return null;
+    }
+    const rawHost = u.hostname;
+    const isIp = rawHost.length > 0 && (IPV4.test(rawHost) || rawHost.startsWith("["));
+    let tld = "";
+    if (!isIp && rawHost.length > 0) {
+      const lastDot = rawHost.lastIndexOf(".");
+      tld = lastDot >= 0 ? rawHost.slice(lastDot + 1) : "";
+    }
+    let country = null;
+    if (!isIp && tld.length > 0) {
+      country = getTldCountryMap2().get("." + tld) ?? null;
+    }
+    const isExample = !isIp && rawHost.length > 0 && (RESERVED_TLDS.has(tld.toLowerCase()) || RESERVED_DOMAINS.has(rawHost.toLowerCase()) || rawHost.toLowerCase().endsWith(".example.com") || rawHost.toLowerCase().endsWith(".example.org") || rawHost.toLowerCase().endsWith(".example.net"));
+    let port = null;
+    if (u.port !== "") port = parseInt(u.port, 10);
+    if (port != null && DEFAULT_PORTS[scheme] === port) port = null;
+    const normalized = u.href;
+    const path = u.pathname;
+    const query = u.search.length > 0 ? u.search.slice(1) : null;
+    const fragment = u.hash.length > 0 ? u.hash.slice(1) : null;
+    return new _Url({
+      value: normalized,
+      scheme,
+      host: rawHost,
+      port,
+      path: path.length === 0 ? "/" : path,
+      query,
+      fragment,
+      tld,
+      country,
+      isExample,
+      isIp
+    });
+  }
+  static #parseNonHierarchical(input, scheme) {
+    const colonIdx = input.indexOf(":");
+    if (colonIdx < 0) return null;
+    const rest = input.slice(colonIdx + 1);
+    if (rest.length === 0) return null;
+    let host = "";
+    let tld = "";
+    let country = null;
+    let isExample = false;
+    let path = rest;
+    let query = null;
+    let fragment = null;
+    if (scheme === "mailto") {
+      const qIdx = rest.indexOf("?");
+      let mainPart = rest;
+      if (qIdx >= 0) {
+        mainPart = rest.slice(0, qIdx);
+        const fragIdx = rest.indexOf("#", qIdx);
+        if (fragIdx >= 0) {
+          query = rest.slice(qIdx + 1, fragIdx);
+          fragment = rest.slice(fragIdx + 1);
+        } else {
+          query = rest.slice(qIdx + 1);
+        }
+      } else {
+        const fragIdx = rest.indexOf("#");
+        if (fragIdx >= 0) {
+          mainPart = rest.slice(0, fragIdx);
+          fragment = rest.slice(fragIdx + 1);
+        }
+      }
+      const atIdx = mainPart.lastIndexOf("@");
+      if (atIdx >= 0) {
+        host = mainPart.slice(atIdx + 1).toLowerCase();
+        const lastDot = host.lastIndexOf(".");
+        tld = lastDot >= 0 ? host.slice(lastDot + 1) : "";
+        if (tld.length > 0) {
+          country = getTldCountryMap2().get("." + tld) ?? null;
+        }
+        isExample = RESERVED_TLDS.has(tld.toLowerCase()) || RESERVED_DOMAINS.has(host) || host.endsWith(".example.com") || host.endsWith(".example.org") || host.endsWith(".example.net");
+      }
+      path = mainPart;
+    } else {
+      const qIdx = rest.indexOf("?");
+      if (qIdx >= 0) {
+        path = rest.slice(0, qIdx);
+        const fragIdx = rest.indexOf("#", qIdx);
+        if (fragIdx >= 0) {
+          query = rest.slice(qIdx + 1, fragIdx);
+          fragment = rest.slice(fragIdx + 1);
+        } else {
+          query = rest.slice(qIdx + 1);
+        }
+      } else {
+        const fragIdx = rest.indexOf("#");
+        if (fragIdx >= 0) {
+          path = rest.slice(0, fragIdx);
+          fragment = rest.slice(fragIdx + 1);
+        }
+      }
+    }
+    const normalized = `${scheme}:${rest}`;
+    return new _Url({
+      value: normalized,
+      scheme,
+      host,
+      port: null,
+      path,
+      query,
+      fragment,
+      tld,
+      country,
+      isExample,
+      isIp: false
+    });
+  }
+};
+function trimTrailingPunctuation(value) {
+  let end = value.length;
+  while (end > 0) {
+    const ch = value[end - 1];
+    if (ch === "." || ch === "," || ch === ";" || ch === "!" || ch === "?" || ch === ")" || ch === "]" || ch === ">" || ch === "'" || ch === '"') {
+      if (ch === ")" && value.includes("(")) break;
+      if (ch === "]" && value.includes("[")) break;
+      end--;
+    } else {
+      break;
+    }
+  }
+  return end < value.length ? value.slice(0, end) : value;
+}
+function maskUrl(url) {
+  const schemePrefix = url.scheme + "://";
+  if (!url.value.toLowerCase().startsWith(schemePrefix)) {
+    return `${url.scheme}:***`;
+  }
+  let s = url.scheme + "://" + url.host;
+  if (url.port != null) s += ":" + url.port;
+  if (url.path === "/" || url.path === "") {
+    s += "/";
+  } else {
+    s += "/***";
+  }
+  if (url.query != null) s += "?***";
+  if (url.fragment != null) s += "#***";
+  return s;
+}
+
+exports.EmailAddress = EmailAddress;
+exports.PublicEmailProvider = PublicEmailProvider;
+exports.Url = Url;
+exports.maskEmailAddress = maskEmailAddress;
+exports.maskUrl = maskUrl;
+exports.toMailtoUri = toMailtoUri;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map