@qinisolabs/qiniso 0.1.0

package/dist/chunk-TDQYIG3R.js

@@ -0,0 +1,1892 @@
+// ../identifiers/dist/data/iban-countries.json
+var iban_countries_default = {
+  AD: { length: 24, name: "Andorra" },
+  AE: { length: 23, name: "United Arab Emirates" },
+  AL: { length: 28, name: "Albania" },
+  AT: { length: 20, name: "Austria" },
+  AZ: { length: 28, name: "Azerbaijan" },
+  BA: { length: 20, name: "Bosnia and Herzegovina" },
+  BE: { length: 16, name: "Belgium" },
+  BG: { length: 22, name: "Bulgaria" },
+  BH: { length: 22, name: "Bahrain" },
+  BR: { length: 29, name: "Brazil" },
+  BY: { length: 28, name: "Belarus" },
+  CH: { length: 21, name: "Switzerland" },
+  CR: { length: 22, name: "Costa Rica" },
+  CY: { length: 28, name: "Cyprus" },
+  CZ: { length: 24, name: "Czechia" },
+  DE: { length: 22, name: "Germany" },
+  DK: { length: 18, name: "Denmark" },
+  DO: { length: 28, name: "Dominican Republic" },
+  EE: { length: 20, name: "Estonia" },
+  EG: { length: 29, name: "Egypt" },
+  ES: { length: 24, name: "Spain" },
+  FI: { length: 18, name: "Finland" },
+  FO: { length: 18, name: "Faroe Islands" },
+  FR: { length: 27, name: "France" },
+  GB: { length: 22, name: "United Kingdom" },
+  GE: { length: 22, name: "Georgia" },
+  GI: { length: 23, name: "Gibraltar" },
+  GL: { length: 18, name: "Greenland" },
+  GR: { length: 27, name: "Greece" },
+  GT: { length: 28, name: "Guatemala" },
+  HR: { length: 21, name: "Croatia" },
+  HU: { length: 28, name: "Hungary" },
+  IE: { length: 22, name: "Ireland" },
+  IL: { length: 23, name: "Israel" },
+  IQ: { length: 23, name: "Iraq" },
+  IS: { length: 26, name: "Iceland" },
+  IT: { length: 27, name: "Italy" },
+  JO: { length: 30, name: "Jordan" },
+  KW: { length: 30, name: "Kuwait" },
+  KZ: { length: 20, name: "Kazakhstan" },
+  LB: { length: 28, name: "Lebanon" },
+  LC: { length: 32, name: "Saint Lucia" },
+  LI: { length: 21, name: "Liechtenstein" },
+  LT: { length: 20, name: "Lithuania" },
+  LU: { length: 20, name: "Luxembourg" },
+  LV: { length: 21, name: "Latvia" },
+  LY: { length: 25, name: "Libya" },
+  MC: { length: 27, name: "Monaco" },
+  MD: { length: 24, name: "Moldova" },
+  ME: { length: 22, name: "Montenegro" },
+  MK: { length: 19, name: "North Macedonia" },
+  MR: { length: 27, name: "Mauritania" },
+  MT: { length: 31, name: "Malta" },
+  MU: { length: 30, name: "Mauritius" },
+  NL: { length: 18, name: "Netherlands" },
+  NO: { length: 15, name: "Norway" },
+  PK: { length: 24, name: "Pakistan" },
+  PL: { length: 28, name: "Poland" },
+  PS: { length: 29, name: "Palestine" },
+  PT: { length: 25, name: "Portugal" },
+  QA: { length: 29, name: "Qatar" },
+  RO: { length: 24, name: "Romania" },
+  RS: { length: 22, name: "Serbia" },
+  SA: { length: 24, name: "Saudi Arabia" },
+  SC: { length: 31, name: "Seychelles" },
+  SE: { length: 24, name: "Sweden" },
+  SI: { length: 19, name: "Slovenia" },
+  SK: { length: 24, name: "Slovakia" },
+  SM: { length: 27, name: "San Marino" },
+  TN: { length: 24, name: "Tunisia" },
+  TR: { length: 26, name: "Turkey" },
+  UA: { length: 29, name: "Ukraine" },
+  VA: { length: 22, name: "Vatican City" },
+  VG: { length: 24, name: "British Virgin Islands" },
+  XK: { length: 20, name: "Kosovo" }
+};
+
+// ../identifiers/dist/iban.js
+var REGISTRY = iban_countries_default;
+function mod97(rearranged) {
+  let remainder = 0;
+  for (const ch of rearranged) {
+    const code = ch.charCodeAt(0);
+    const value = code >= 65 && code <= 90 ? code - 55 : code - 48;
+    remainder = value > 9 ? (remainder * 100 + value) % 97 : (remainder * 10 + value) % 97;
+  }
+  return remainder;
+}
+function normalizeIban(input) {
+  return input.replace(/[\s]/g, "").toUpperCase();
+}
+function validateIban(input) {
+  const normalized = normalizeIban(input);
+  const result = {
+    input,
+    normalized,
+    valid: false,
+    countryCode: null,
+    country: null,
+    checkDigits: null,
+    bban: null,
+    errors: []
+  };
+  if (!/^[A-Z0-9]+$/.test(normalized)) {
+    result.errors.push("IBAN contains characters other than letters and digits.");
+    return result;
+  }
+  if (normalized.length < 4) {
+    result.errors.push("IBAN is too short to contain a country code and check digits.");
+    return result;
+  }
+  const cc = normalized.slice(0, 2);
+  const checkDigits = normalized.slice(2, 4);
+  const bban = normalized.slice(4);
+  result.countryCode = cc;
+  result.checkDigits = checkDigits;
+  result.bban = bban;
+  const spec = REGISTRY[cc];
+  if (!spec) {
+    result.errors.push(`Unknown or unsupported IBAN country code "${cc}".`);
+    return result;
+  }
+  result.country = spec.name;
+  if (!/^[A-Z]{2}[0-9]{2}/.test(normalized)) {
+    result.errors.push("Country code must be 2 letters followed by 2 check digits.");
+    return result;
+  }
+  if (normalized.length !== spec.length) {
+    result.errors.push(`Wrong length for ${spec.name}: expected ${spec.length}, got ${normalized.length}.`);
+    return result;
+  }
+  const rearranged = normalized.slice(4) + normalized.slice(0, 4);
+  if (mod97(rearranged) !== 1) {
+    result.errors.push("Checksum failed (ISO 7064 mod-97): the IBAN is not valid.");
+    return result;
+  }
+  result.valid = true;
+  return result;
+}
+function ibanCheckDigits(countryCode, bban) {
+  const cc = countryCode.toUpperCase();
+  const rearranged = bban.toUpperCase() + cc + "00";
+  const remainder = mod97(rearranged);
+  return String(98 - remainder).padStart(2, "0");
+}
+function supportedIbanCountries() {
+  return Object.keys(REGISTRY);
+}
+
+// ../identifiers/dist/data/card-bins.json
+var card_bins_default = {
+  note: "IIN/BIN brand ranges. Detection uses longest-prefix-wins across all rules.",
+  brands: [
+    {
+      brand: "Visa",
+      rules: [{ min: 4, max: 4, len: 1 }],
+      lengths: [13, 16, 19]
+    },
+    {
+      brand: "Mastercard",
+      rules: [
+        { min: 51, max: 55, len: 2 },
+        { min: 2221, max: 2720, len: 4 }
+      ],
+      lengths: [16]
+    },
+    {
+      brand: "American Express",
+      rules: [
+        { min: 34, max: 34, len: 2 },
+        { min: 37, max: 37, len: 2 }
+      ],
+      lengths: [15]
+    },
+    {
+      brand: "Discover",
+      rules: [
+        { min: 6011, max: 6011, len: 4 },
+        { min: 644, max: 649, len: 3 },
+        { min: 65, max: 65, len: 2 },
+        { min: 622126, max: 622925, len: 6 }
+      ],
+      lengths: [16, 19]
+    },
+    {
+      brand: "Diners Club",
+      rules: [
+        { min: 300, max: 305, len: 3 },
+        { min: 3095, max: 3095, len: 4 },
+        { min: 36, max: 36, len: 2 },
+        { min: 38, max: 39, len: 2 }
+      ],
+      lengths: [14, 16, 19]
+    },
+    {
+      brand: "JCB",
+      rules: [{ min: 3528, max: 3589, len: 4 }],
+      lengths: [16, 17, 18, 19]
+    },
+    {
+      brand: "UnionPay",
+      rules: [{ min: 62, max: 62, len: 2 }],
+      lengths: [16, 17, 18, 19]
+    }
+  ]
+};
+
+// ../identifiers/dist/card.js
+var BRANDS = card_bins_default.brands;
+function luhnValid(digits2) {
+  if (!/^\d+$/.test(digits2))
+    return false;
+  let sum = 0;
+  let double = false;
+  for (let i = digits2.length - 1; i >= 0; i--) {
+    let d = digits2.charCodeAt(i) - 48;
+    if (double) {
+      d *= 2;
+      if (d > 9)
+        d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+function luhnCheckDigit(partial) {
+  let sum = 0;
+  let double = true;
+  for (let i = partial.length - 1; i >= 0; i--) {
+    let d = partial.charCodeAt(i) - 48;
+    if (double) {
+      d *= 2;
+      if (d > 9)
+        d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return String((10 - sum % 10) % 10);
+}
+function detectBrand(digits2) {
+  if (!/^\d+$/.test(digits2))
+    return null;
+  let best = null;
+  for (const spec of BRANDS) {
+    for (const rule of spec.rules) {
+      if (digits2.length < rule.len)
+        continue;
+      const prefix = Number(digits2.slice(0, rule.len));
+      if (prefix >= rule.min && prefix <= rule.max) {
+        if (!best || rule.len > best.len) {
+          best = { brand: spec.brand, lengths: spec.lengths, len: rule.len };
+        }
+      }
+    }
+  }
+  return best ? { brand: best.brand, lengths: best.lengths } : null;
+}
+function validateCard(input) {
+  const normalized = input.replace(/[\s-]/g, "");
+  const result = {
+    input,
+    normalized,
+    valid: false,
+    luhnValid: false,
+    brand: null,
+    lengthValid: null,
+    errors: []
+  };
+  if (!/^\d+$/.test(normalized)) {
+    result.errors.push("Card number contains non-digit characters.");
+    return result;
+  }
+  if (normalized.length < 12 || normalized.length > 19) {
+    result.errors.push("Card number length is outside the valid 12-19 digit range.");
+    return result;
+  }
+  result.luhnValid = luhnValid(normalized);
+  if (!result.luhnValid)
+    result.errors.push("Luhn checksum failed.");
+  const detected = detectBrand(normalized);
+  if (detected) {
+    result.brand = detected.brand;
+    result.lengthValid = detected.lengths.includes(normalized.length);
+    if (!result.lengthValid) {
+      result.errors.push(`Length ${normalized.length} is not valid for ${detected.brand} (expected ${detected.lengths.join("/")}).`);
+    }
+  }
+  result.valid = result.luhnValid && result.lengthValid !== false;
+  return result;
+}
+
+// ../identifiers/dist/isbn.js
+function isbn13CheckDigit(first12) {
+  if (!/^\d{12}$/.test(first12)) {
+    throw new Error("isbn13CheckDigit expects exactly 12 digits.");
+  }
+  let sum = 0;
+  for (let i = 0; i < 12; i++) {
+    const d = first12.charCodeAt(i) - 48;
+    sum += i % 2 === 0 ? d : d * 3;
+  }
+  return String((10 - sum % 10) % 10);
+}
+function validateIsbn13(input) {
+  const normalized = input.replace(/[\s-]/g, "");
+  const result = {
+    input,
+    normalized,
+    valid: false,
+    type: null,
+    checkDigit: null,
+    errors: []
+  };
+  if (!/^\d{13}$/.test(normalized)) {
+    result.errors.push("ISBN-13 must be exactly 13 digits (after removing hyphens/spaces).");
+    return result;
+  }
+  if (!/^(978|979)/.test(normalized)) {
+    result.errors.push('ISBN-13 must begin with the "978" or "979" GS1 prefix.');
+    return result;
+  }
+  result.type = "ISBN-13";
+  const expected = isbn13CheckDigit(normalized.slice(0, 12));
+  result.checkDigit = expected;
+  if (expected !== normalized[12]) {
+    result.errors.push(`Check digit failed: expected ${expected}, got ${normalized[12]}.`);
+    return result;
+  }
+  result.valid = true;
+  return result;
+}
+
+// ../identifiers/dist/vin.js
+var TRANSLIT = {
+  A: 1,
+  B: 2,
+  C: 3,
+  D: 4,
+  E: 5,
+  F: 6,
+  G: 7,
+  H: 8,
+  J: 1,
+  K: 2,
+  L: 3,
+  M: 4,
+  N: 5,
+  P: 7,
+  R: 9,
+  S: 2,
+  T: 3,
+  U: 4,
+  V: 5,
+  W: 6,
+  X: 7,
+  Y: 8,
+  Z: 9,
+  "0": 0,
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "4": 4,
+  "5": 5,
+  "6": 6,
+  "7": 7,
+  "8": 8,
+  "9": 9
+};
+var WEIGHTS = [8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2];
+function vinCheckDigit(vin) {
+  const v = vin.toUpperCase();
+  if (v.length !== 17 || !/^[A-HJ-NPR-Z0-9]{17}$/.test(v)) {
+    throw new Error("vinCheckDigit expects 17 chars from the VIN alphabet (no I/O/Q).");
+  }
+  let sum = 0;
+  for (let i = 0; i < 17; i++) {
+    if (i === 8)
+      continue;
+    sum += TRANSLIT[v[i]] * WEIGHTS[i];
+  }
+  const r = sum % 11;
+  return r === 10 ? "X" : String(r);
+}
+function validateVin(input) {
+  const normalized = input.trim().toUpperCase();
+  const result = {
+    input,
+    normalized,
+    valid: false,
+    checkDigit: null,
+    expectedCheckDigit: null,
+    errors: []
+  };
+  if (normalized.length !== 17) {
+    result.errors.push(`VIN must be exactly 17 characters (got ${normalized.length}).`);
+    return result;
+  }
+  if (/[IOQ]/.test(normalized)) {
+    result.errors.push("VIN must not contain the letters I, O or Q.");
+    return result;
+  }
+  if (!/^[A-HJ-NPR-Z0-9]{17}$/.test(normalized)) {
+    result.errors.push("VIN contains characters outside the allowed alphabet.");
+    return result;
+  }
+  const expected = vinCheckDigit(normalized);
+  result.checkDigit = normalized[8];
+  result.expectedCheckDigit = expected;
+  if (expected !== normalized[8]) {
+    result.errors.push(`Check digit (position 9) failed: expected ${expected}, got ${normalized[8]}.`);
+    return result;
+  }
+  result.valid = true;
+  return result;
+}
+
+// ../network/dist/data/tlds.json
+var tlds_default = ["aaa", "aarp", "abb", "abbott", "abbvie", "abc", "able", "abogado", "abudhabi", "ac", "academy", "accenture", "accountant", "accountants", "aco", "actor", "ad", "ads", "adult", "ae", "aeg", "aero", "aetna", "af", "afl", "africa", "ag", "agakhan", "agency", "ai", "aig", "airbus", "airforce", "airtel", "akdn", "al", "alibaba", "alipay", "allfinanz", "allstate", "ally", "alsace", "alstom", "am", "amazon", "americanexpress", "americanfamily", "amex", "amfam", "amica", "amsterdam", "analytics", "android", "anquan", "anz", "ao", "aol", "apartments", "app", "apple", "aq", "aquarelle", "ar", "arab", "aramco", "archi", "army", "arpa", "art", "arte", "as", "asda", "asia", "associates", "at", "athleta", "attorney", "au", "auction", "audi", "audible", "audio", "auspost", "author", "auto", "autos", "aw", "aws", "ax", "axa", "az", "azure", "ba", "baby", "baidu", "banamex", "band", "bank", "bar", "barcelona", "barclaycard", "barclays", "barefoot", "bargains", "baseball", "basketball", "bauhaus", "bayern", "bb", "bbc", "bbt", "bbva", "bcg", "bcn", "bd", "be", "beats", "beauty", "beer", "berlin", "best", "bestbuy", "bet", "bf", "bg", "bh", "bharti", "bi", "bible", "bid", "bike", "bing", "bingo", "bio", "biz", "bj", "black", "blackfriday", "blockbuster", "blog", "bloomberg", "blue", "bm", "bms", "bmw", "bn", "bnpparibas", "bo", "boats", "boehringer", "bofa", "bom", "bond", "boo", "book", "booking", "bosch", "bostik", "boston", "bot", "boutique", "box", "br", "bradesco", "bridgestone", "broadway", "broker", "brother", "brussels", "bs", "bt", "build", "builders", "business", "buy", "buzz", "bv", "bw", "by", "bz", "bzh", "ca", "cab", "cafe", "cal", "call", "calvinklein", "cam", "camera", "camp", "canon", "capetown", "capital", "capitalone", "car", "caravan", "cards", "care", "career", "careers", "cars", "casa", "case", "cash", "casino", "cat", "catering", "catholic", "cba", "cbn", "cbre", "cc", "cd", "center", "ceo", "cern", "cf", "cfa", "cfd", "cg", "ch", "chanel", "channel", "charity", "chase", "chat", "cheap", "chintai", "christmas", "chrome", "church", "ci", "cipriani", "circle", "cisco", "citadel", "citi", "citic", "city", "ck", "cl", "claims", "cleaning", "click", "clinic", "clinique", "clothing", "cloud", "club", "clubmed", "cm", "cn", "co", "coach", "codes", "coffee", "college", "cologne", "com", "commbank", "community", "company", "compare", "computer", "comsec", "condos", "construction", "consulting", "contact", "contractors", "cooking", "cool", "coop", "corsica", "country", "coupon", "coupons", "courses", "cpa", "cr", "credit", "creditcard", "creditunion", "cricket", "crown", "crs", "cruise", "cruises", "cu", "cuisinella", "cv", "cw", "cx", "cy", "cymru", "cyou", "cz", "dad", "dance", "data", "date", "dating", "datsun", "day", "dclk", "dds", "de", "deal", "dealer", "deals", "degree", "delivery", "dell", "deloitte", "delta", "democrat", "dental", "dentist", "desi", "design", "dev", "dhl", "diamonds", "diet", "digital", "direct", "directory", "discount", "discover", "dish", "diy", "dj", "dk", "dm", "dnp", "do", "docs", "doctor", "dog", "domains", "dot", "download", "drive", "dtv", "dubai", "dupont", "durban", "dvag", "dvr", "dz", "earth", "eat", "ec", "eco", "edeka", "edu", "education", "ee", "eg", "email", "emerck", "energy", "engineer", "engineering", "enterprises", "epson", "equipment", "er", "ericsson", "erni", "es", "esq", "estate", "et", "eu", "eurovision", "eus", "events", "exchange", "expert", "exposed", "express", "extraspace", "fage", "fail", "fairwinds", "faith", "family", "fan", "fans", "farm", "farmers", "fashion", "fast", "fedex", "feedback", "ferrari", "ferrero", "fi", "fidelity", "fido", "film", "final", "finance", "financial", "fire", "firestone", "firmdale", "fish", "fishing", "fit", "fitness", "fj", "fk", "flickr", "flights", "flir", "florist", "flowers", "fly", "fm", "fo", "foo", "food", "football", "ford", "forex", "forsale", "forum", "foundation", "fox", "fr", "free", "fresenius", "frl", "frogans", "frontier", "ftr", "fujitsu", "fun", "fund", "furniture", "futbol", "fyi", "ga", "gal", "gallery", "gallo", "gallup", "game", "games", "gap", "garden", "gay", "gb", "gbiz", "gd", "gdn", "ge", "gea", "gent", "genting", "george", "gf", "gg", "ggee", "gh", "gi", "gift", "gifts", "gives", "giving", "gl", "glass", "gle", "global", "globo", "gm", "gmail", "gmbh", "gmo", "gmx", "gn", "godaddy", "gold", "goldpoint", "golf", "goodyear", "goog", "google", "gop", "got", "gov", "gp", "gq", "gr", "grainger", "graphics", "gratis", "green", "gripe", "grocery", "group", "gs", "gt", "gu", "gucci", "guge", "guide", "guitars", "guru", "gw", "gy", "hair", "hamburg", "hangout", "haus", "hbo", "hdfc", "hdfcbank", "health", "healthcare", "help", "helsinki", "here", "hermes", "hiphop", "hisamitsu", "hitachi", "hiv", "hk", "hkt", "hm", "hn", "hockey", "holdings", "holiday", "homedepot", "homegoods", "homes", "homesense", "honda", "horse", "hospital", "host", "hosting", "hot", "hotels", "hotmail", "house", "how", "hr", "hsbc", "ht", "hu", "hughes", "hyatt", "hyundai", "ibm", "icbc", "ice", "icu", "id", "ie", "ieee", "ifm", "ikano", "il", "im", "imamat", "imdb", "immo", "immobilien", "in", "inc", "industries", "infiniti", "info", "ing", "ink", "institute", "insurance", "insure", "int", "international", "intuit", "investments", "io", "ipiranga", "iq", "ir", "irish", "is", "ismaili", "ist", "istanbul", "it", "itau", "itv", "jaguar", "java", "jcb", "je", "jeep", "jetzt", "jewelry", "jio", "jll", "jm", "jmp", "jnj", "jo", "jobs", "joburg", "jot", "joy", "jp", "jpmorgan", "jprs", "juegos", "juniper", "kaufen", "kddi", "ke", "kerryhotels", "kerryproperties", "kfh", "kg", "kh", "ki", "kia", "kids", "kim", "kindle", "kitchen", "kiwi", "km", "kn", "koeln", "komatsu", "kosher", "kp", "kpmg", "kpn", "kr", "krd", "kred", "kuokgroup", "kw", "ky", "kyoto", "kz", "la", "lacaixa", "lamborghini", "lamer", "land", "landrover", "lanxess", "lasalle", "lat", "latino", "latrobe", "law", "lawyer", "lb", "lc", "lds", "lease", "leclerc", "lefrak", "legal", "lego", "lexus", "lgbt", "li", "lidl", "life", "lifeinsurance", "lifestyle", "lighting", "like", "lilly", "limited", "limo", "lincoln", "link", "live", "living", "lk", "llc", "llp", "loan", "loans", "locker", "locus", "lol", "london", "lotte", "lotto", "love", "lpl", "lplfinancial", "lr", "ls", "lt", "ltd", "ltda", "lu", "lundbeck", "luxe", "luxury", "lv", "ly", "ma", "madrid", "maif", "maison", "makeup", "man", "management", "mango", "map", "market", "marketing", "markets", "marriott", "marshalls", "mattel", "mba", "mc", "mckinsey", "md", "me", "med", "media", "meet", "melbourne", "meme", "memorial", "men", "menu", "merck", "merckmsd", "mg", "mh", "miami", "microsoft", "mil", "mini", "mint", "mit", "mitsubishi", "mk", "ml", "mlb", "mls", "mm", "mma", "mn", "mo", "mobi", "mobile", "moda", "moe", "moi", "mom", "monash", "money", "monster", "mormon", "mortgage", "moscow", "moto", "motorcycles", "mov", "movie", "mp", "mq", "mr", "ms", "msd", "mt", "mtn", "mtr", "mu", "museum", "music", "mv", "mw", "mx", "my", "mz", "na", "nab", "nagoya", "name", "navy", "nba", "nc", "ne", "nec", "net", "netbank", "netflix", "network", "neustar", "new", "news", "next", "nextdirect", "nexus", "nf", "nfl", "ng", "ngo", "nhk", "ni", "nico", "nike", "nikon", "ninja", "nissan", "nissay", "nl", "no", "nokia", "norton", "now", "nowruz", "nowtv", "np", "nr", "nra", "nrw", "ntt", "nu", "nyc", "nz", "obi", "observer", "office", "okinawa", "olayan", "olayangroup", "ollo", "om", "omega", "one", "ong", "onl", "online", "ooo", "open", "oracle", "orange", "org", "organic", "origins", "osaka", "otsuka", "ott", "ovh", "pa", "page", "panasonic", "paris", "pars", "partners", "parts", "party", "pay", "pccw", "pe", "pet", "pf", "pfizer", "pg", "ph", "pharmacy", "phd", "philips", "phone", "photo", "photography", "photos", "physio", "pics", "pictet", "pictures", "pid", "pin", "ping", "pink", "pioneer", "pizza", "pk", "pl", "place", "play", "playstation", "plumbing", "plus", "pm", "pn", "pnc", "pohl", "poker", "politie", "porn", "post", "pr", "praxi", "press", "prime", "pro", "prod", "productions", "prof", "progressive", "promo", "properties", "property", "protection", "pru", "prudential", "ps", "pt", "pub", "pw", "pwc", "py", "qa", "qpon", "quebec", "quest", "racing", "radio", "re", "read", "realestate", "realtor", "realty", "recipes", "red", "redumbrella", "rehab", "reise", "reisen", "reit", "reliance", "ren", "rent", "rentals", "repair", "report", "republican", "rest", "restaurant", "review", "reviews", "rexroth", "rich", "richardli", "ricoh", "ril", "rio", "rip", "ro", "rocks", "rodeo", "rogers", "room", "rs", "rsvp", "ru", "rugby", "ruhr", "run", "rw", "rwe", "ryukyu", "sa", "saarland", "safe", "safety", "sakura", "sale", "salon", "samsclub", "samsung", "sandvik", "sandvikcoromant", "sanofi", "sap", "sarl", "sas", "save", "saxo", "sb", "sbi", "sbs", "sc", "scb", "schaeffler", "schmidt", "scholarships", "school", "schule", "schwarz", "science", "scot", "sd", "se", "search", "seat", "secure", "security", "seek", "select", "sener", "services", "seven", "sew", "sex", "sexy", "sfr", "sg", "sh", "shangrila", "sharp", "shell", "shia", "shiksha", "shoes", "shop", "shopping", "shouji", "show", "si", "silk", "sina", "singles", "site", "sj", "sk", "ski", "skin", "sky", "skype", "sl", "sling", "sm", "smart", "smile", "sn", "sncf", "so", "soccer", "social", "softbank", "software", "sohu", "solar", "solutions", "song", "sony", "soy", "spa", "space", "sport", "spot", "sr", "srl", "ss", "st", "stada", "staples", "star", "statebank", "statefarm", "stc", "stcgroup", "stockholm", "storage", "store", "stream", "studio", "study", "style", "su", "sucks", "supplies", "supply", "support", "surf", "surgery", "suzuki", "sv", "swatch", "swiss", "sx", "sy", "sydney", "systems", "sz", "tab", "taipei", "talk", "taobao", "target", "tatamotors", "tatar", "tattoo", "tax", "taxi", "tc", "tci", "td", "tdk", "team", "tech", "technology", "tel", "temasek", "tennis", "teva", "tf", "tg", "th", "thd", "theater", "theatre", "tiaa", "tickets", "tienda", "tips", "tires", "tirol", "tj", "tjmaxx", "tjx", "tk", "tkmaxx", "tl", "tm", "tmall", "tn", "to", "today", "tokyo", "tools", "top", "toray", "toshiba", "total", "tours", "town", "toyota", "toys", "tr", "trade", "trading", "training", "travel", "travelers", "travelersinsurance", "trust", "trv", "tt", "tube", "tui", "tunes", "tushu", "tv", "tvs", "tw", "tz", "ua", "ubank", "ubs", "ug", "uk", "unicom", "university", "uno", "uol", "ups", "us", "uy", "uz", "va", "vacations", "vana", "vanguard", "vc", "ve", "vegas", "ventures", "verisign", "versicherung", "vet", "vg", "vi", "viajes", "video", "vig", "viking", "villas", "vin", "vip", "virgin", "visa", "vision", "viva", "vivo", "vlaanderen", "vn", "vodka", "volvo", "vote", "voting", "voto", "voyage", "vu", "wales", "walmart", "walter", "wang", "wanggou", "watch", "watches", "weather", "weatherchannel", "webcam", "weber", "website", "wed", "wedding", "weibo", "weir", "wf", "whoswho", "wien", "wiki", "williamhill", "win", "windows", "wine", "winners", "wme", "woodside", "work", "works", "world", "wow", "ws", "wtc", "wtf", "xbox", "xerox", "xihuan", "xin", "xn--11b4c3d", "xn--1ck2e1b", "xn--1qqw23a", "xn--2scrj9c", "xn--30rr7y", "xn--3bst00m", "xn--3ds443g", "xn--3e0b707e", "xn--3hcrj9c", "xn--3pxu8k", "xn--42c2d9a", "xn--45br5cyl", "xn--45brj9c", "xn--45q11c", "xn--4dbrk0ce", "xn--4gbrim", "xn--54b7fta0cc", "xn--55qw42g", "xn--55qx5d", "xn--5su34j936bgsg", "xn--5tzm5g", "xn--6frz82g", "xn--6qq986b3xl", "xn--80adxhks", "xn--80ao21a", "xn--80aqecdr1a", "xn--80asehdb", "xn--80aswg", "xn--8y0a063a", "xn--90a3ac", "xn--90ae", "xn--90ais", "xn--9dbq2a", "xn--9et52u", "xn--9krt00a", "xn--b4w605ferd", "xn--bck1b9a5dre4c", "xn--c1avg", "xn--c2br7g", "xn--cck2b3b", "xn--cckwcxetd", "xn--cg4bki", "xn--clchc0ea0b2g2a9gcd", "xn--czr694b", "xn--czrs0t", "xn--czru2d", "xn--d1acj3b", "xn--d1alf", "xn--e1a4c", "xn--eckvdtc9d", "xn--efvy88h", "xn--fct429k", "xn--fhbei", "xn--fiq228c5hs", "xn--fiq64b", "xn--fiqs8s", "xn--fiqz9s", "xn--fjq720a", "xn--flw351e", "xn--fpcrj9c3d", "xn--fzc2c9e2c", "xn--fzys8d69uvgm", "xn--g2xx48c", "xn--gckr3f0f", "xn--gecrj9c", "xn--gk3at1e", "xn--h2breg3eve", "xn--h2brj9c", "xn--h2brj9c8c", "xn--hxt814e", "xn--i1b6b1a6a2e", "xn--imr513n", "xn--io0a7i", "xn--j1aef", "xn--j1amh", "xn--j6w193g", "xn--jlq480n2rg", "xn--jvr189m", "xn--kcrx77d1x4a", "xn--kprw13d", "xn--kpry57d", "xn--kput3i", "xn--l1acc", "xn--lgbbat1ad8j", "xn--mgb9awbf", "xn--mgba3a3ejt", "xn--mgba3a4f16a", "xn--mgba7c0bbn0a", "xn--mgbaam7a8h", "xn--mgbab2bd", "xn--mgbah1a3hjkrd", "xn--mgbai9azgqp6j", "xn--mgbayh7gpa", "xn--mgbbh1a", "xn--mgbbh1a71e", "xn--mgbc0a9azcg", "xn--mgbca7dzdo", "xn--mgbcpq6gpa1a", "xn--mgberp4a5d4ar", "xn--mgbgu82a", "xn--mgbi4ecexp", "xn--mgbpl2fh", "xn--mgbt3dhd", "xn--mgbtx2b", "xn--mgbx4cd0ab", "xn--mix891f", "xn--mk1bu44c", "xn--mxtq1m", "xn--ngbc5azd", "xn--ngbe9e0a", "xn--ngbrx", "xn--node", "xn--nqv7f", "xn--nqv7fs00ema", "xn--nyqy26a", "xn--o3cw4h", "xn--ogbpf8fl", "xn--otu796d", "xn--p1acf", "xn--p1ai", "xn--pgbs0dh", "xn--pssy2u", "xn--q7ce6a", "xn--q9jyb4c", "xn--qcka1pmc", "xn--qxa6a", "xn--qxam", "xn--rhqv96g", "xn--rovu88b", "xn--rvc1e0am3e", "xn--s9brj9c", "xn--ses554g", "xn--t60b56a", "xn--tckwe", "xn--tiq49xqyj", "xn--unup4y", "xn--vermgensberater-ctb", "xn--vermgensberatung-pwb", "xn--vhquv", "xn--vuq861b", "xn--w4r85el8fhu5dnra", "xn--w4rs40l", "xn--wgbh1c", "xn--wgbl6a", "xn--xhq521b", "xn--xkc2al3hye2a", "xn--xkc2dl3a5ee0h", "xn--y9a3aq", "xn--yfro4i67o", "xn--ygbi2ammx", "xn--zfr164b", "xxx", "xyz", "yachts", "yahoo", "yamaxun", "yandex", "ye", "yodobashi", "yoga", "yokohama", "you", "youtube", "yt", "yun", "za", "zappos", "zara", "zero", "zip", "zm", "zone", "zuerich", "zw"];
+
+// ../network/dist/tld.js
+var SET = new Set(tlds_default.map((t) => t.toLowerCase()));
+function isKnownTld(tld) {
+  return SET.has(tld.toLowerCase().replace(/^\./, ""));
+}
+function knownTldCount() {
+  return SET.size;
+}
+function validateTld(input) {
+  const tld = input.trim().toLowerCase().replace(/^\./, "");
+  const valid = SET.has(tld);
+  return {
+    input,
+    tld,
+    valid,
+    isIdn: tld.startsWith("xn--"),
+    errors: valid ? [] : [`".${tld}" is not a delegated TLD in the IANA root zone.`]
+  };
+}
+
+// ../network/dist/domain.js
+var LABEL_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+function validateDomain(input) {
+  const normalized = input.trim().toLowerCase().replace(/\.$/, "");
+  const labels = normalized.split(".");
+  const errors = [];
+  if (labels.length < 2)
+    errors.push("A domain needs at least a name and a TLD.");
+  if (!labels.every((l) => LABEL_RE.test(l)))
+    errors.push("Contains an invalid label.");
+  if (normalized.length > 253)
+    errors.push("Domain exceeds 253 characters.");
+  const tld = labels.length >= 2 ? labels[labels.length - 1] : null;
+  const tldKnown = tld ? isKnownTld(tld) : false;
+  if (tld && !tldKnown)
+    errors.push(`TLD ".${tld}" is not in the IANA root zone.`);
+  return { input, normalized, valid: errors.length === 0, tld, tldKnown, errors };
+}
+
+// ../network/dist/ip.js
+function isIPv4(s) {
+  const parts = s.split(".");
+  if (parts.length !== 4)
+    return false;
+  for (const p of parts) {
+    if (!/^\d{1,3}$/.test(p))
+      return false;
+    if (p.length > 1 && p[0] === "0")
+      return false;
+    if (Number(p) > 255)
+      return false;
+  }
+  return true;
+}
+function isIPv6(s) {
+  if (s.includes("%"))
+    return false;
+  const parts = s.split("::");
+  if (parts.length > 2)
+    return false;
+  const groups = (seg) => seg === "" ? [] : seg.split(":");
+  const all = parts.length === 2 ? [...groups(parts[0]), ...groups(parts[1])] : groups(parts[0]);
+  let count = 0;
+  for (let i = 0; i < all.length; i++) {
+    const g = all[i];
+    if (g === "")
+      return false;
+    const isFinal = i === all.length - 1;
+    if (isFinal && g.includes(".")) {
+      if (!isIPv4(g))
+        return false;
+      count += 2;
+    } else {
+      if (!/^[0-9a-fA-F]{1,4}$/.test(g))
+        return false;
+      count += 1;
+    }
+  }
+  return parts.length === 2 ? count <= 7 : count === 8;
+}
+function validateIp(input) {
+  const s = input.trim();
+  if (isIPv4(s))
+    return { input, valid: true, version: 4, errors: [] };
+  if (isIPv6(s))
+    return { input, valid: true, version: 6, errors: [] };
+  return { input, valid: false, version: null, errors: ["Not a valid IPv4 or IPv6 address."] };
+}
+
+// ../network/dist/uuid.js
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var NIL_RE = /^0{8}-0{4}-0{4}-0{4}-0{12}$/;
+function validateUuid(input) {
+  const s = input.trim();
+  if (!UUID_RE.test(s)) {
+    return {
+      input,
+      valid: false,
+      version: null,
+      variant: null,
+      isNil: false,
+      errors: ["Not a canonical UUID (expected 8-4-4-4-12 hex digits)."]
+    };
+  }
+  const isNil = NIL_RE.test(s);
+  const version = isNil ? 0 : parseInt(s[14], 16);
+  const v = parseInt(s[19], 16);
+  let variant = "reserved";
+  if ((v & 8) === 0)
+    variant = "NCS (legacy)";
+  else if ((v & 12) === 8)
+    variant = "RFC 4122";
+  else if ((v & 14) === 12)
+    variant = "Microsoft (legacy)";
+  return { input, valid: true, version, variant, isNil, errors: [] };
+}
+
+// ../network/dist/url.js
+function validateUrl(input) {
+  const s = input.trim();
+  let u;
+  try {
+    u = new URL(s);
+  } catch {
+    return {
+      input,
+      valid: false,
+      protocol: null,
+      hostname: null,
+      tld: null,
+      tldKnown: false,
+      port: null,
+      path: null,
+      errors: ["Not a parseable absolute URL (needs a scheme, e.g. https://\u2026)."]
+    };
+  }
+  const host = u.hostname;
+  const tld = host.includes(".") ? host.split(".").pop().toLowerCase() : null;
+  const tldKnown = tld ? isKnownTld(tld) : false;
+  const errors = [];
+  if (tld && !tldKnown)
+    errors.push(`Host TLD ".${tld}" is not in the IANA root zone.`);
+  return {
+    input,
+    valid: true,
+    protocol: u.protocol.replace(":", ""),
+    hostname: host,
+    tld,
+    tldKnown,
+    port: u.port || null,
+    path: u.pathname || null,
+    errors
+  };
+}
+
+// ../network/dist/email.js
+var LOCAL_RE = /^[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+)*$/;
+var LABEL_RE2 = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$/;
+function validateEmail(input) {
+  const s = input.trim();
+  const at = s.lastIndexOf("@");
+  const errors = [];
+  if (at <= 0 || at === s.length - 1) {
+    return { input, valid: false, local: null, domain: null, tld: null, tldKnown: false, errors: ["Missing local part or domain around '@'."] };
+  }
+  const local = s.slice(0, at);
+  const domain = s.slice(at + 1);
+  if (local.length > 64 || !LOCAL_RE.test(local))
+    errors.push("Invalid local part (before '@').");
+  const labels = domain.split(".");
+  if (labels.length < 2)
+    errors.push("Domain must have at least one dot.");
+  if (!labels.every((l) => LABEL_RE2.test(l)))
+    errors.push("Invalid domain label.");
+  if (domain.length > 253)
+    errors.push("Domain exceeds 253 characters.");
+  const tld = labels.length >= 2 ? labels[labels.length - 1].toLowerCase() : null;
+  const tldKnown = tld ? isKnownTld(tld) : false;
+  if (tld && !tldKnown)
+    errors.push(`Domain TLD ".${tld}" is not in the IANA root zone.`);
+  return { input, valid: errors.length === 0, local, domain, tld, tldKnown, errors };
+}
+
+// ../finance/dist/isin.js
+function expand(body) {
+  let out = "";
+  for (const c of body) {
+    out += /[0-9]/.test(c) ? c : (c.charCodeAt(0) - 55).toString();
+  }
+  return out;
+}
+function luhnCheckDigit2(digits2) {
+  let sum = 0;
+  let dbl = true;
+  for (let i = digits2.length - 1; i >= 0; i--) {
+    let d = digits2.charCodeAt(i) - 48;
+    if (dbl) {
+      d *= 2;
+      if (d > 9)
+        d -= 9;
+    }
+    sum += d;
+    dbl = !dbl;
+  }
+  return (10 - sum % 10) % 10;
+}
+function validateIsin(input) {
+  const s = input.trim().toUpperCase().replace(/\s/g, "");
+  const base = {
+    input,
+    normalized: s,
+    valid: false,
+    countryCode: null,
+    checkDigit: null,
+    expectedCheckDigit: null,
+    errors: []
+  };
+  if (!/^[A-Z]{2}[A-Z0-9]{9}[0-9]$/.test(s)) {
+    return { ...base, errors: ["Not an ISIN (expected 2-letter country + 9 alphanumeric + 1 check digit)."] };
+  }
+  const expected = luhnCheckDigit2(expand(s.slice(0, 11)));
+  const actual = Number(s[11]);
+  return {
+    ...base,
+    valid: expected === actual,
+    countryCode: s.slice(0, 2),
+    checkDigit: s[11],
+    expectedCheckDigit: String(expected),
+    errors: expected === actual ? [] : [`Checksum failed (ISO 6166 Luhn): expected check digit ${expected}.`]
+  };
+}
+
+// ../finance/dist/cusip.js
+function charValue(c) {
+  if (/[0-9]/.test(c))
+    return Number(c);
+  if (/[A-Z]/.test(c))
+    return c.charCodeAt(0) - 55;
+  return { "*": 36, "@": 37, "#": 38 }[c] ?? -1;
+}
+function validateCusip(input) {
+  const s = input.trim().toUpperCase().replace(/\s/g, "");
+  const base = {
+    input,
+    normalized: s,
+    valid: false,
+    checkDigit: null,
+    expectedCheckDigit: null,
+    errors: []
+  };
+  if (!/^[0-9A-Z*@#]{8}[0-9]$/.test(s)) {
+    return { ...base, errors: ["Not a CUSIP (expected 8 alphanumeric chars + 1 check digit)."] };
+  }
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    let v = charValue(s[i]);
+    if (i % 2 === 1)
+      v *= 2;
+    sum += Math.floor(v / 10) + v % 10;
+  }
+  const expected = (10 - sum % 10) % 10;
+  const actual = Number(s[8]);
+  return {
+    ...base,
+    valid: expected === actual,
+    checkDigit: s[8],
+    expectedCheckDigit: String(expected),
+    errors: expected === actual ? [] : [`Checksum failed (CUSIP mod-10): expected check digit ${expected}.`]
+  };
+}
+
+// ../finance/dist/sedol.js
+var WEIGHTS2 = [1, 3, 1, 7, 3, 9];
+function charValue2(c) {
+  return /[0-9]/.test(c) ? Number(c) : c.charCodeAt(0) - 55;
+}
+function validateSedol(input) {
+  const s = input.trim().toUpperCase().replace(/\s/g, "");
+  const base = {
+    input,
+    normalized: s,
+    valid: false,
+    checkDigit: null,
+    expectedCheckDigit: null,
+    errors: []
+  };
+  if (!/^[0-9BCDFGHJKLMNPQRSTVWXYZ]{6}[0-9]$/.test(s)) {
+    return { ...base, errors: ["Not a SEDOL (expected 6 alphanumeric chars, no vowels, + 1 check digit)."] };
+  }
+  let sum = 0;
+  for (let i = 0; i < 6; i++)
+    sum += charValue2(s[i]) * WEIGHTS2[i];
+  const expected = (10 - sum % 10) % 10;
+  const actual = Number(s[6]);
+  return {
+    ...base,
+    valid: expected === actual,
+    checkDigit: s[6],
+    expectedCheckDigit: String(expected),
+    errors: expected === actual ? [] : [`Checksum failed (SEDOL weighted mod-10): expected check digit ${expected}.`]
+  };
+}
+
+// ../finance/dist/lei.js
+function validateLei(input) {
+  const s = input.trim().toUpperCase().replace(/\s/g, "");
+  if (!/^[0-9A-Z]{18}[0-9]{2}$/.test(s)) {
+    return { input, normalized: s, valid: false, errors: ["Not an LEI (expected 20 chars: 18 alphanumeric + 2 check digits)."] };
+  }
+  let rem = 0;
+  for (const c of s) {
+    const part = /[0-9]/.test(c) ? c : (c.charCodeAt(0) - 55).toString();
+    for (const d of part)
+      rem = (rem * 10 + (d.charCodeAt(0) - 48)) % 97;
+  }
+  const valid = rem === 1;
+  return {
+    input,
+    normalized: s,
+    valid,
+    errors: valid ? [] : ["Checksum failed (ISO 7064 MOD 97-10): the LEI is not valid."]
+  };
+}
+
+// ../finance/dist/aba.js
+function validateAba(input) {
+  const s = input.trim().replace(/\s|-/g, "");
+  if (!/^\d{9}$/.test(s)) {
+    return { input, normalized: s, valid: false, errors: ["Not a routing number (expected 9 digits)."] };
+  }
+  const d = s.split("").map(Number);
+  const sum = 3 * (d[0] + d[3] + d[6]) + 7 * (d[1] + d[4] + d[7]) + 1 * (d[2] + d[5] + d[8]);
+  const valid = sum % 10 === 0;
+  return {
+    input,
+    normalized: s,
+    valid,
+    errors: valid ? [] : ["Checksum failed (ABA weighted mod-10): the routing number is not valid."]
+  };
+}
+
+// ../crypto/dist/eth.js
+import { keccak_256 } from "@noble/hashes/sha3";
+function toEip55(hexLower) {
+  const hash = keccak_256(new TextEncoder().encode(hexLower));
+  let out = "";
+  for (let i = 0; i < hexLower.length; i++) {
+    const c = hexLower[i];
+    if (c >= "0" && c <= "9") {
+      out += c;
+    } else {
+      const byte = hash[i >> 1];
+      const nibble = i % 2 === 0 ? byte >> 4 : byte & 15;
+      out += nibble >= 8 ? c.toUpperCase() : c;
+    }
+  }
+  return out;
+}
+function validateEthAddress(input) {
+  const s = input.trim();
+  if (!/^0x[0-9a-fA-F]{40}$/.test(s)) {
+    return { input, valid: false, checksumStatus: "none", expected: null, errors: ["Not an Ethereum address (expected 0x followed by 40 hex chars)."] };
+  }
+  const body = s.slice(2);
+  const allLower = body === body.toLowerCase();
+  const allUpper = body === body.toUpperCase();
+  if (allLower || allUpper) {
+    return { input, valid: true, checksumStatus: "none", expected: "0x" + toEip55(body.toLowerCase()), errors: [] };
+  }
+  const expected = "0x" + toEip55(body.toLowerCase());
+  const ok = s === expected;
+  return {
+    input,
+    valid: ok,
+    checksumStatus: ok ? "valid" : "invalid",
+    expected,
+    errors: ok ? [] : ["EIP-55 checksum failed: the mixed-case capitalisation does not match (likely a typo)."]
+  };
+}
+
+// ../crypto/dist/btc.js
+import { base58check, bech32, bech32m } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha256";
+var b58c = base58check(sha256);
+var BASE58_VERSIONS = {
+  0: { type: "P2PKH", network: "mainnet" },
+  5: { type: "P2SH", network: "mainnet" },
+  111: { type: "P2PKH", network: "testnet" },
+  196: { type: "P2SH", network: "testnet" }
+};
+var HRP = { bc: "mainnet", tb: "testnet", bcrt: "regtest" };
+function validateBtcAddress(input) {
+  const s = input.trim();
+  const fail = (msg) => ({ input, valid: false, type: null, network: null, errors: [msg] });
+  if (/^(bc1|tb1|bcrt1)/i.test(s)) {
+    const lower = s.toLowerCase();
+    const hrp = lower.startsWith("bcrt1") ? "bcrt" : lower.slice(0, 2);
+    for (const [coder, isM] of [[bech32, false], [bech32m, true]]) {
+      try {
+        const dec = coder.decode(lower, 90);
+        const version = dec.words[0];
+        if (version === 0 === isM)
+          continue;
+        const type = version === 0 ? "SegWit v0 (P2WPKH/P2WSH)" : version === 1 ? "Taproot (P2TR)" : `SegWit v${version}`;
+        return { input, valid: true, type, network: HRP[hrp] ?? null, errors: [] };
+      } catch {
+      }
+    }
+    return fail("Invalid SegWit (bech32/bech32m) address \u2014 checksum or format failed.");
+  }
+  try {
+    const data = b58c.decode(s);
+    const version = data[0];
+    const info = BASE58_VERSIONS[version];
+    if (!info)
+      return fail(`Valid Base58Check, but unknown version byte 0x${version.toString(16)}.`);
+    return { input, valid: true, type: info.type, network: info.network, errors: [] };
+  } catch {
+    return fail("Not a valid Bitcoin address (Base58Check checksum or format failed).");
+  }
+}
+
+// ../national-id/dist/brazil.js
+function digits(s) {
+  return s.replace(/\D/g, "").split("").map(Number);
+}
+function validateCpf(input) {
+  const clean = input.replace(/\D/g, "");
+  const base = { input, normalized: clean, valid: false, errors: [] };
+  if (clean.length !== 11)
+    return { ...base, errors: ["CPF must have 11 digits."] };
+  if (/^(\d)\1{10}$/.test(clean))
+    return { ...base, errors: ["Invalid CPF (all digits identical)."] };
+  const d = digits(clean);
+  const check = (len) => {
+    let sum = 0;
+    for (let i = 0; i < len; i++)
+      sum += d[i] * (len + 1 - i);
+    const r = sum * 10 % 11;
+    return r === 10 ? 0 : r;
+  };
+  const ok = check(9) === d[9] && check(10) === d[10];
+  return { ...base, valid: ok, errors: ok ? [] : ["Checksum failed (CPF mod-11)."] };
+}
+function validateCnpj(input) {
+  const clean = input.replace(/\D/g, "");
+  const base = { input, normalized: clean, valid: false, errors: [] };
+  if (clean.length !== 14)
+    return { ...base, errors: ["CNPJ must have 14 digits."] };
+  if (/^(\d)\1{13}$/.test(clean))
+    return { ...base, errors: ["Invalid CNPJ (all digits identical)."] };
+  const d = digits(clean);
+  const check = (len) => {
+    const weights = len === 12 ? [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] : [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+    let sum = 0;
+    for (let i = 0; i < len; i++)
+      sum += d[i] * weights[i];
+    const r = sum % 11;
+    return r < 2 ? 0 : 11 - r;
+  };
+  const ok = check(12) === d[12] && check(13) === d[13];
+  return { ...base, valid: ok, errors: ok ? [] : ["Checksum failed (CNPJ mod-11)."] };
+}
+
+// ../national-id/dist/saId.js
+function luhnValid2(num) {
+  let sum = 0;
+  let dbl = false;
+  for (let i = num.length - 1; i >= 0; i--) {
+    let d = num.charCodeAt(i) - 48;
+    if (dbl) {
+      d *= 2;
+      if (d > 9)
+        d -= 9;
+    }
+    sum += d;
+    dbl = !dbl;
+  }
+  return sum % 10 === 0;
+}
+function validateSaId(input) {
+  const clean = input.replace(/\s/g, "");
+  const base = {
+    input,
+    normalized: clean,
+    valid: false,
+    dateOfBirth: null,
+    gender: null,
+    citizenship: null,
+    errors: []
+  };
+  if (!/^\d{13}$/.test(clean))
+    return { ...base, errors: ["SA ID must be 13 digits."] };
+  const yy = +clean.slice(0, 2);
+  const mm = +clean.slice(2, 4);
+  const dd = +clean.slice(4, 6);
+  const errors = [];
+  if (mm < 1 || mm > 12)
+    errors.push("Invalid month in date of birth.");
+  if (dd < 1 || dd > 31)
+    errors.push("Invalid day in date of birth.");
+  if (!luhnValid2(clean))
+    errors.push("Checksum failed (Luhn).");
+  const citizenshipDigit = +clean[10];
+  if (citizenshipDigit > 1)
+    errors.push("Invalid citizenship digit (must be 0 or 1).");
+  if (errors.length)
+    return { ...base, errors };
+  const century = yy <= 25 ? "20" : "19";
+  const dob = `${century}${String(yy).padStart(2, "0")}-${String(mm).padStart(2, "0")}-${String(dd).padStart(2, "0")}`;
+  const gender = +clean.slice(6, 10) >= 5e3 ? "male" : "female";
+  const citizenship = citizenshipDigit === 0 ? "citizen" : "permanent resident";
+  return { ...base, valid: true, dateOfBirth: dob, gender, citizenship, errors: [] };
+}
+
+// ../national-id/dist/spain.js
+var LETTERS = "TRWAGMYFPDXBNJZSQVHLCKE";
+function validateDni(input) {
+  const s = input.toUpperCase().replace(/[\s-]/g, "");
+  const base = { input, normalized: s, valid: false, type: null, errors: [] };
+  let numberPart;
+  let type;
+  if (/^[0-9]{8}[A-Z]$/.test(s)) {
+    numberPart = s.slice(0, 8);
+    type = "DNI";
+  } else if (/^[XYZ][0-9]{7}[A-Z]$/.test(s)) {
+    const prefix = { X: "0", Y: "1", Z: "2" }[s[0]];
+    numberPart = prefix + s.slice(1, 8);
+    type = "NIE";
+  } else {
+    return { ...base, errors: ["Not a valid DNI (8 digits + letter) or NIE (X/Y/Z + 7 digits + letter)."] };
+  }
+  const expected = LETTERS[Number(numberPart) % 23];
+  const ok = s[s.length - 1] === expected;
+  return {
+    ...base,
+    valid: ok,
+    type,
+    errors: ok ? [] : [`Control letter failed (mod-23): expected '${expected}'.`]
+  };
+}
+
+// ../national-id/dist/verhoeff.js
+var D = [
+  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+  [1, 2, 3, 4, 0, 6, 7, 8, 9, 5],
+  [2, 3, 4, 0, 1, 7, 8, 9, 5, 6],
+  [3, 4, 0, 1, 2, 8, 9, 5, 6, 7],
+  [4, 0, 1, 2, 3, 9, 5, 6, 7, 8],
+  [5, 9, 8, 7, 6, 0, 4, 3, 2, 1],
+  [6, 5, 9, 8, 7, 1, 0, 4, 3, 2],
+  [7, 6, 5, 9, 8, 2, 1, 0, 4, 3],
+  [8, 7, 6, 5, 9, 3, 2, 1, 0, 4],
+  [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
+];
+var P = [
+  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+  [1, 5, 7, 6, 2, 8, 3, 0, 9, 4],
+  [5, 8, 0, 9, 1, 4, 2, 6, 7, 3],
+  [8, 9, 1, 6, 0, 4, 3, 5, 2, 7],
+  [9, 4, 5, 3, 1, 2, 6, 8, 7, 0],
+  [4, 2, 8, 6, 5, 7, 3, 9, 0, 1],
+  [2, 7, 9, 3, 8, 0, 6, 4, 1, 5],
+  [7, 0, 4, 6, 9, 1, 3, 2, 5, 8]
+];
+var INV = [0, 4, 3, 2, 1, 5, 6, 7, 8, 9];
+function verhoeffValid(num) {
+  let c = 0;
+  const rev = num.split("").reverse();
+  for (let i = 0; i < rev.length; i++) {
+    c = D[c][P[i % 8][Number(rev[i])]];
+  }
+  return c === 0;
+}
+function verhoeffGenerate(num) {
+  let c = 0;
+  const rev = num.split("").reverse();
+  for (let i = 0; i < rev.length; i++) {
+    c = D[c][P[(i + 1) % 8][Number(rev[i])]];
+  }
+  return INV[c];
+}
+
+// ../national-id/dist/aadhaar.js
+function validateAadhaar(input) {
+  const clean = input.replace(/\s/g, "");
+  const base = { input, normalized: clean, valid: false, errors: [] };
+  if (!/^\d{12}$/.test(clean))
+    return { ...base, errors: ["Aadhaar must be 12 digits."] };
+  if (clean[0] === "0" || clean[0] === "1")
+    return { ...base, errors: ["Aadhaar cannot start with 0 or 1."] };
+  const ok = verhoeffValid(clean);
+  return { ...base, valid: ok, errors: ok ? [] : ["Checksum failed (Verhoeff)."] };
+}
+
+// ../academic/dist/isbn10.js
+function validateIsbn10(input) {
+  const s = input.replace(/[\s-]/g, "").toUpperCase();
+  const base = { input, normalized: s, valid: false, expectedCheck: null, errors: [] };
+  if (!/^\d{9}[\dX]$/.test(s))
+    return { ...base, errors: ["Not an ISBN-10 (9 digits + check digit 0-9 or X)."] };
+  let sum = 0;
+  for (let i = 0; i < 9; i++)
+    sum += Number(s[i]) * (10 - i);
+  const r = (11 - sum % 11) % 11;
+  const expected = r === 10 ? "X" : String(r);
+  const ok = expected === s[9];
+  return { ...base, valid: ok, expectedCheck: expected, errors: ok ? [] : [`Checksum failed (ISBN-10 mod-11): expected '${expected}'.`] };
+}
+
+// ../academic/dist/issn.js
+function validateIssn(input) {
+  const s = input.replace(/[\s-]/g, "").toUpperCase();
+  const base = { input, normalized: s, valid: false, expectedCheck: null, errors: [] };
+  if (!/^\d{7}[\dX]$/.test(s))
+    return { ...base, errors: ["Not an ISSN (7 digits + check digit 0-9 or X)."] };
+  let sum = 0;
+  for (let i = 0; i < 7; i++)
+    sum += Number(s[i]) * (8 - i);
+  const r = (11 - sum % 11) % 11;
+  const expected = r === 10 ? "X" : String(r);
+  const ok = expected === s[7];
+  return { ...base, valid: ok, expectedCheck: expected, errors: ok ? [] : [`Checksum failed (ISSN mod-11): expected '${expected}'.`] };
+}
+
+// ../academic/dist/orcid.js
+function mod11_2(first15) {
+  let total = 0;
+  for (const c of first15)
+    total = (total + Number(c)) * 2 % 11;
+  const result = (12 - total % 11) % 11;
+  return result === 10 ? "X" : String(result);
+}
+function validateOrcid(input) {
+  const s = input.replace(/[\s-]/g, "").replace(/^https?:\/\/orcid\.org\//i, "").toUpperCase();
+  const base = { input, normalized: s, valid: false, expectedCheck: null, errors: [] };
+  if (!/^\d{15}[\dX]$/.test(s))
+    return { ...base, errors: ["Not an ORCID (16 chars: 15 digits + check digit 0-9 or X)."] };
+  const expected = mod11_2(s.slice(0, 15));
+  const ok = expected === s[15];
+  return { ...base, valid: ok, expectedCheck: expected, errors: ok ? [] : [`Checksum failed (ISO 7064 MOD 11-2): expected '${expected}'.`] };
+}
+
+// ../locale/dist/dates.js
+var DAYFIRST = { "en-GB": true, "en-US": false };
+var ISO = /^\d{4}-\d{2}-\d{2}$/;
+var NUMERIC = /^(\d{1,2})[/.\-](\d{1,2})[/.\-](\d{4})$/;
+function pad(n) {
+  return String(n).padStart(2, "0");
+}
+function buildIso(y, m, d) {
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  if (dt.getUTCFullYear() === y && dt.getUTCMonth() === m - 1 && dt.getUTCDate() === d) {
+    return `${y}-${pad(m)}-${pad(d)}`;
+  }
+  return null;
+}
+function parseDate(text, locale = "en-GB") {
+  locale = locale || "en-GB";
+  let dayfirst = DAYFIRST[locale] ?? true;
+  const s = (text ?? "").trim();
+  if (!s)
+    return { valid: false, reason: "empty input", locale };
+  if (ISO.test(s)) {
+    const [y, m, d] = s.split("-").map(Number);
+    const iso = buildIso(y, m, d);
+    return iso ? { valid: true, iso, locale, dayfirst: false, input: text } : { valid: false, reason: "impossible date", locale, input: text };
+  }
+  const num = s.match(NUMERIC);
+  if (num) {
+    const a = Number(num[1]);
+    const b = Number(num[2]);
+    const y = Number(num[3]);
+    const day = dayfirst ? a : b;
+    const month = dayfirst ? b : a;
+    const iso = buildIso(y, month, day);
+    return iso ? { valid: true, iso, locale, dayfirst, input: text } : { valid: false, reason: "unparseable or impossible date", locale, input: text };
+  }
+  const cleaned = s.replace(/(\d+)(st|nd|rd|th)\b/gi, "$1");
+  const parsed = new Date(cleaned);
+  if (!isNaN(parsed.getTime())) {
+    const iso = buildIso(parsed.getFullYear(), parsed.getMonth() + 1, parsed.getDate());
+    if (iso)
+      return { valid: true, iso, locale, dayfirst, input: text };
+  }
+  return { valid: false, reason: "unparseable or impossible date", locale, input: text };
+}
+
+// ../locale/dist/phone.js
+import { parsePhoneNumberFromString } from "libphonenumber-js";
+function validatePhone(number, region = "GB") {
+  region = (region || "GB").toUpperCase();
+  let parsed;
+  try {
+    parsed = parsePhoneNumberFromString(String(number), region);
+  } catch {
+    parsed = void 0;
+  }
+  if (!parsed || !parsed.isValid()) {
+    return { valid: false, reason: "not a valid number for region", region, input: number };
+  }
+  return {
+    valid: true,
+    e164: parsed.number,
+    national: parsed.formatNational(),
+    international: parsed.formatInternational(),
+    type: parsed.getType() ?? "unknown",
+    region,
+    input: number
+  };
+}
+
+// ../locale/dist/currency.js
+var DEFAULT_LOCALE = { GBP: "en-GB", USD: "en-US" };
+function formatMoney(amount, currency = "GBP", locale) {
+  currency = (currency || "GBP").toUpperCase();
+  const loc = locale || DEFAULT_LOCALE[currency] || "en-US";
+  try {
+    const formatted = new Intl.NumberFormat(loc, { style: "currency", currency }).format(amount);
+    return { ok: true, formatted, amount, currency, locale: loc };
+  } catch (e) {
+    return { ok: false, reason: String(e), amount, currency, locale: loc };
+  }
+}
+
+// ../locale/dist/holidays.js
+import Holidays from "date-holidays";
+var COUNTRIES = new Holidays().getCountries();
+function supported(country) {
+  return Object.prototype.hasOwnProperty.call(COUNTRIES, country);
+}
+var DEFAULT_SUBDIV = { GB: "ENG" };
+var COUNT_TYPES = /* @__PURE__ */ new Set(["public", "bank"]);
+function makeCal(country, subdiv) {
+  if (subdiv) {
+    try {
+      return new Holidays(country, subdiv);
+    } catch {
+    }
+  }
+  return new Holidays(country);
+}
+function isoOf(h) {
+  return h.date.slice(0, 10);
+}
+function isHoliday(date, country = "GB", subdiv) {
+  country = (country || "GB").toUpperCase();
+  if (!supported(country))
+    return { ok: false, reason: `country ${country} not supported` };
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
+    return { ok: false, reason: `bad date: ${date}` };
+  const used = subdiv || DEFAULT_SUBDIV[country] || void 0;
+  const cal = makeCal(country, used);
+  const res = cal.isHoliday(/* @__PURE__ */ new Date(`${date}T12:00:00`));
+  const matches = Array.isArray(res) ? res.filter((h) => COUNT_TYPES.has(h.type)) : [];
+  const hit = matches[0];
+  return {
+    ok: true,
+    date,
+    country,
+    subdiv: used ?? null,
+    is_holiday: matches.length > 0,
+    name: hit ? hit.name : null
+  };
+}
+function nextHoliday(country = "GB", after, subdiv) {
+  country = (country || "GB").toUpperCase();
+  if (!supported(country))
+    return { ok: false, reason: `country ${country} not supported` };
+  const start = after && /^\d{4}-\d{2}-\d{2}$/.test(after) ? after : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const used = subdiv || DEFAULT_SUBDIV[country] || void 0;
+  const cal = makeCal(country, used);
+  const startYear = Number(start.slice(0, 4));
+  for (const yr of [startYear, startYear + 1]) {
+    const all = (cal.getHolidays(yr) || []).filter((h) => COUNT_TYPES.has(h.type)).map((h) => ({ iso: isoOf(h), name: h.name })).filter((h) => h.iso >= start).sort((a, b) => a.iso.localeCompare(b.iso));
+    if (all.length) {
+      return { ok: true, country, subdiv: used ?? null, date: all[0].iso, name: all[0].name };
+    }
+  }
+  return { ok: false, reason: "none found in window" };
+}
+
+// ../locale/dist/data/uk_vat.json
+var uk_vat_default = {
+  country: "GB",
+  tax_name: "VAT",
+  source: "HM Revenue & Customs standard-rate history (public record)",
+  last_verified: "2026-06-14",
+  note: "Standard rate only. Reduced (5%) and zero rates are separate and not modelled here. Ranges are inclusive of start, exclusive of next start. Verify pre-1991 values before production use.",
+  standard_rate_history: [
+    { from: "1979-06-18", rate: 15 },
+    { from: "1991-04-01", rate: 17.5 },
+    { from: "2008-12-01", rate: 15, note: "Temporary cut (financial crisis)" },
+    { from: "2010-01-01", rate: 17.5, note: "Reverted" },
+    { from: "2011-01-04", rate: 20, note: "Current standard rate" }
+  ],
+  reduced_rate: 5,
+  zero_rate: 0
+};
+
+// ../locale/dist/data/us_sales_tax.json
+var us_sales_tax_default = {
+  country: "US",
+  tax_name: "Sales tax (state base rate)",
+  national_vat: 0,
+  source: "Commonly published 2025 state base sales-tax rates (e.g. Tax Foundation). VERIFY against an authoritative feed before production billing.",
+  last_verified: "2026-06-14",
+  note: "The US has NO national VAT. These are STATE BASE rates only; local (county/city/district) rates add on top and can add several percent. Five states (AK, DE, MT, NH, OR) levy no state sales tax (Alaska allows local). HI and NM are gross-receipts taxes shown as equivalents. Treat as indicative, not authoritative for invoicing.",
+  no_state_sales_tax: ["AK", "DE", "MT", "NH", "OR"],
+  state_base_rates: {
+    AL: 4,
+    AK: 0,
+    AZ: 5.6,
+    AR: 6.5,
+    CA: 7.25,
+    CO: 2.9,
+    CT: 6.35,
+    DE: 0,
+    FL: 6,
+    GA: 4,
+    HI: 4,
+    ID: 6,
+    IL: 6.25,
+    IN: 7,
+    IA: 6,
+    KS: 6.5,
+    KY: 6,
+    LA: 5,
+    ME: 5.5,
+    MD: 6,
+    MA: 6.25,
+    MI: 6,
+    MN: 6.875,
+    MS: 7,
+    MO: 4.225,
+    MT: 0,
+    NE: 5.5,
+    NV: 6.85,
+    NH: 0,
+    NJ: 6.625,
+    NM: 4.875,
+    NY: 4,
+    NC: 4.75,
+    ND: 5,
+    OH: 5.75,
+    OK: 4.5,
+    OR: 0,
+    PA: 6,
+    RI: 7,
+    SC: 6,
+    SD: 4.2,
+    TN: 7,
+    TX: 6.25,
+    UT: 6.1,
+    VT: 6,
+    VA: 5.3,
+    WA: 6.5,
+    WV: 6,
+    WI: 5,
+    WY: 4,
+    DC: 6
+  },
+  rate_notes: {
+    LA: "Raised to 5.0% effective 2025-01-01 (was 4.45%).",
+    SD: "Reduced to 4.2% (2023), scheduled to revert to 4.5% in 2027.",
+    NM: "Gross-receipts tax; state portion ~4.875%.",
+    HI: "General excise tax (GET) 4.0%, economically broader than a sales tax.",
+    UT: "Includes mandatory statewide local add-ons (state base 4.85% + 1.25%).",
+    VA: "Includes 1% mandatory local add-on (4.3% state + 1.0%)."
+  }
+};
+
+// ../locale/dist/vat.js
+var UK = uk_vat_default;
+var US = us_sales_tax_default;
+function ukVat(date) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
+    return { ok: false, reason: `bad date: ${date}` };
+  let applicable = null;
+  for (const band of UK.standard_rate_history) {
+    if (band.from <= date)
+      applicable = band;
+    else
+      break;
+  }
+  if (!applicable) {
+    return { ok: false, reason: `no UK VAT rate recorded for ${date}` };
+  }
+  return {
+    ok: true,
+    country: "GB",
+    tax_name: "VAT",
+    rate: applicable.rate,
+    date,
+    effective_from: applicable.from,
+    kind: "standard",
+    note: applicable.note ?? null,
+    source: UK.source,
+    last_verified: UK.last_verified
+  };
+}
+function usTax(date, state) {
+  const base = {
+    ok: true,
+    country: "US",
+    tax_name: "Sales tax",
+    national_vat: 0,
+    date,
+    note: US.note,
+    source: US.source,
+    last_verified: US.last_verified
+  };
+  if (!state) {
+    return { ...base, rate: 0, scope: "national (US has no VAT; supply a state for sales tax)" };
+  }
+  const st = state.toUpperCase();
+  const rate = US.state_base_rates[st];
+  if (rate === void 0)
+    return { ok: false, reason: `unknown US state code: ${st}` };
+  return {
+    ...base,
+    rate,
+    scope: "state base rate (local taxes add on top)",
+    state: st,
+    state_note: US.rate_notes[st]
+  };
+}
+function vatRate(country = "GB", date, state) {
+  country = (country || "GB").toUpperCase();
+  const d = date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  if (country === "GB")
+    return ukVat(d);
+  if (country === "US")
+    return usTax(d, state);
+  return { ok: false, reason: `country ${country} not supported in v1 (GB, US only)` };
+}
+
+// ../locale/dist/address.js
+var UK_POSTCODE = /\b(GIR ?0AA|[A-PR-UWYZ][A-HK-Y]?[0-9][0-9A-HJKPS-UW]? ?[0-9][ABD-HJLNP-UW-Z]{2})\b/i;
+var US_STATE_ZIP = /\b([A-Z]{2})\s+(\d{5}(?:-\d{4})?)\b/;
+var UK_HINT = /\b(United Kingdom|U\.?K\.?|England|Scotland|Wales|Northern Ireland)\b/i;
+var US_HINT = /\b(United States|U\.?S\.?A?\.?)\b/i;
+var US_STATES = /* @__PURE__ */ new Set([
+  "AL",
+  "AK",
+  "AZ",
+  "AR",
+  "CA",
+  "CO",
+  "CT",
+  "DE",
+  "FL",
+  "GA",
+  "HI",
+  "ID",
+  "IL",
+  "IN",
+  "IA",
+  "KS",
+  "KY",
+  "LA",
+  "ME",
+  "MD",
+  "MA",
+  "MI",
+  "MN",
+  "MS",
+  "MO",
+  "MT",
+  "NE",
+  "NV",
+  "NH",
+  "NJ",
+  "NM",
+  "NY",
+  "NC",
+  "ND",
+  "OH",
+  "OK",
+  "OR",
+  "PA",
+  "RI",
+  "SC",
+  "SD",
+  "TN",
+  "TX",
+  "UT",
+  "VT",
+  "VA",
+  "WA",
+  "WV",
+  "WI",
+  "WY",
+  "DC"
+]);
+function normaliseUk(pc) {
+  const c = pc.replace(/\s+/g, "").toUpperCase();
+  return c.slice(0, -3) + " " + c.slice(-3);
+}
+function guessCity(raw, country, postcode, state) {
+  const parts = raw.split(",").map((p) => p.trim()).filter(Boolean);
+  if (!parts.length)
+    return null;
+  if (country === "US" && state && postcode) {
+    for (let i = 0; i < parts.length; i++) {
+      if (parts[i].includes(state) && parts[i].includes(postcode) && i > 0)
+        return parts[i - 1];
+    }
+  }
+  if (country === "GB" && postcode) {
+    const pcKey = postcode.replace(/\s+/g, "").toUpperCase();
+    for (const p of parts) {
+      if (p.replace(/\s+/g, "").toUpperCase().includes(pcKey)) {
+        const cleaned = p.replace(UK_POSTCODE, "").replace(/[,\s]+$/, "").trim();
+        if (cleaned)
+          return cleaned;
+      }
+    }
+    return parts.length >= 2 ? parts[parts.length - 2] : null;
+  }
+  return null;
+}
+function confidence(country, postcode, city) {
+  const score = (country ? 1 : 0) + (postcode ? 1 : 0) + (city ? 1 : 0);
+  return ["none", "low", "medium", "high"][score];
+}
+function parseAddress(text) {
+  const raw = (text ?? "").trim();
+  if (!raw)
+    return { ok: false, reason: "empty input" };
+  const ukPc = raw.match(UK_POSTCODE);
+  const usSz = raw.match(US_STATE_ZIP);
+  const usValid = !!(usSz && US_STATES.has(usSz[1].toUpperCase()));
+  let country = null;
+  let postcode = null;
+  let state = null;
+  if (ukPc && !usValid) {
+    country = "GB";
+    postcode = normaliseUk(ukPc[1]);
+  } else if (usValid && usSz) {
+    country = "US";
+    state = usSz[1].toUpperCase();
+    postcode = usSz[2];
+  } else if (UK_HINT.test(raw)) {
+    country = "GB";
+    postcode = ukPc ? normaliseUk(ukPc[1]) : null;
+  } else if (US_HINT.test(raw)) {
+    country = "US";
+  }
+  const city = guessCity(raw, country, postcode, state);
+  return { ok: true, input: raw, country, postcode, state, city, confidence: confidence(country, postcode, city) };
+}
+
+// ../vat/dist/vat.js
+import { checkVAT, countries } from "jsvat-next";
+function validateVat(input, country) {
+  let raw = String(input ?? "").toUpperCase().replace(/[\s.\-]/g, "");
+  if (country && !/^[A-Z]{2}/.test(raw)) {
+    raw = country.toUpperCase().slice(0, 2) + raw;
+  }
+  const r = checkVAT(raw, countries);
+  const cc = r.country?.isoCode?.short ?? null;
+  return {
+    input,
+    normalized: raw,
+    valid: !!r.isValid,
+    country: r.country?.name ?? null,
+    countryCode: cc,
+    errors: r.isValid ? [] : ["Invalid VAT number \u2014 format or checksum failed (NOTE: this does not check VIES registration)."]
+  };
+}
+
+// src/branding.ts
+var PUBLIC_BASE = "https://qiniso.qinisolabs.workers.dev";
+var LOGO_SVG = `<svg width="512" height="512" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="Qiniso">
+  <defs>
+    <linearGradient id="emerald" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#10b981"/>
+      <stop offset="1" stop-color="#047857"/>
+    </linearGradient>
+  </defs>
+  <rect x="16" y="16" width="480" height="480" rx="112" fill="url(#emerald)"/>
+  <circle cx="236" cy="252" r="120" fill="none" stroke="#ffffff" stroke-width="42"/>
+  <path d="M238 300 L300 366 L420 190" fill="none" stroke="#ffffff" stroke-width="42" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>`;
+var ICONS = [
+  { src: `${PUBLIC_BASE}/icon.svg`, mimeType: "image/svg+xml", sizes: ["any"] }
+];
+
+// src/core.ts
+var TOOLS = [
+  {
+    name: "validate_iban",
+    description: "USE THIS to verify an IBAN (international bank account number) before relying on it \u2014 instead of guessing whether it looks right. Checks the country, the country-specific length, and the ISO 7064 mod-97 checksum, and returns the country, check digits and BBAN. Call this whenever a user supplies a bank account for a payment, payout or invoice.",
+    argName: "iban",
+    argDescription: "The IBAN to validate; spaces are ignored.",
+    run: (v) => validateIban(v)
+  },
+  {
+    name: "validate_card",
+    description: "USE THIS to check a payment card number's structure before using it \u2014 never assume a card number is valid or guess its brand. Verifies the Luhn checksum, detects the brand (Visa, Mastercard, Amex, Discover, Diners, JCB, UnionPay) from its BIN, and checks the length. Does NOT check whether the card is real, active or has funds.",
+    argName: "number",
+    argDescription: "The card number; spaces and dashes are ignored.",
+    run: (v) => validateCard(v)
+  },
+  {
+    name: "validate_isbn",
+    description: "USE THIS to verify an ISBN-13 book identifier instead of trusting that 13 digits are correct. Checks the 978/979 prefix and the mod-10 weighted check digit, and returns the expected check digit when it fails.",
+    argName: "isbn",
+    argDescription: "The ISBN-13; hyphens and spaces are ignored.",
+    run: (v) => validateIsbn13(v)
+  },
+  {
+    name: "validate_vin",
+    description: "USE THIS to verify a vehicle VIN before acting on it \u2014 do not assume a 17-character string is a valid VIN. Checks the allowed alphabet (no I/O/Q) and the ISO 3779 transliteration check digit in position 9, and returns the expected check digit when it fails.",
+    argName: "vin",
+    argDescription: "The 17-character VIN to validate.",
+    run: (v) => validateVin(v)
+  },
+  {
+    name: "validate_tld",
+    description: "USE THIS to check whether a top-level domain is real before trusting a domain or link \u2014 do NOT guess whether a TLD like .zip, .corp, .crypto or .web exists. Checks the suffix against the authoritative IANA root-zone list (kept current). Returns valid:false for TLDs that are not actually delegated.",
+    argName: "tld",
+    argDescription: "The TLD to check, with or without a leading dot (e.g. 'zip' or '.zip').",
+    run: (v) => validateTld(v)
+  },
+  {
+    name: "validate_domain",
+    description: "USE THIS to verify a domain name's structure AND that its TLD is a real IANA-delegated suffix \u2014 instead of assuming a domain is legitimate. Catches invalid labels and made-up TLDs (e.g. example.corp). Returns the TLD and whether it is known.",
+    argName: "domain",
+    argDescription: "The domain name, e.g. 'example.com'.",
+    run: (v) => validateDomain(v)
+  },
+  {
+    name: "validate_ip",
+    description: "USE THIS to verify an IP address before relying on it \u2014 do not assume a dotted or colon string is valid. Strictly checks IPv4 (RFC 791, rejects leading zeros / out-of-range octets) and IPv6 (RFC 4291, including '::' compression and embedded IPv4), and returns the version.",
+    argName: "ip",
+    argDescription: "The IPv4 or IPv6 address to validate.",
+    run: (v) => validateIp(v)
+  },
+  {
+    name: "validate_uuid",
+    description: "USE THIS to verify a UUID and read its version/variant instead of guessing \u2014 e.g. to tell a v4 (random) from a v7 (time-ordered) UUID. Checks the canonical 8-4-4-4-12 form and returns version, variant and whether it is the nil UUID.",
+    argName: "uuid",
+    argDescription: "The UUID string to validate.",
+    run: (v) => validateUuid(v)
+  },
+  {
+    name: "validate_url",
+    description: "USE THIS to verify a URL before fetching or storing it \u2014 parses it with the WHATWG URL standard and additionally checks that the host's TLD is a real IANA suffix. Returns protocol, hostname, port, path and whether the TLD is known.",
+    argName: "url",
+    argDescription: "The absolute URL to validate (e.g. https://example.com/path).",
+    run: (v) => validateUrl(v)
+  },
+  {
+    name: "validate_email",
+    description: "USE THIS to check an email address's syntax AND that its domain TLD is real, before saving or sending \u2014 instead of trusting raw input. Validates the local part and domain (RFC 5321/5322 subset) and flags made-up TLDs. Does NOT check deliverability.",
+    argName: "email",
+    argDescription: "The email address to validate.",
+    run: (v) => validateEmail(v)
+  },
+  {
+    name: "validate_isin",
+    description: "USE THIS to verify an ISIN (international securities identifier) before relying on it \u2014 never assume a 12-character code is valid. Checks the format and the ISO 6166 Luhn check digit, and returns the country code. Call this when a user supplies a security/instrument identifier.",
+    argName: "isin",
+    argDescription: "The 12-character ISIN, e.g. US0378331005.",
+    run: (v) => validateIsin(v)
+  },
+  {
+    name: "validate_cusip",
+    description: "USE THIS to verify a CUSIP (North American securities identifier) instead of trusting 9 characters. Checks the CUSIP mod-10 check digit and returns the expected digit when it fails.",
+    argName: "cusip",
+    argDescription: "The 9-character CUSIP, e.g. 037833100.",
+    run: (v) => validateCusip(v)
+  },
+  {
+    name: "validate_sedol",
+    description: "USE THIS to verify a SEDOL (LSE securities identifier) before relying on it. Checks the no-vowels alphabet and the weighted mod-10 check digit.",
+    argName: "sedol",
+    argDescription: "The 7-character SEDOL, e.g. B0YBKJ7.",
+    run: (v) => validateSedol(v)
+  },
+  {
+    name: "validate_lei",
+    description: "USE THIS to verify a Legal Entity Identifier (LEI) before relying on it \u2014 do not assume a 20-character code is valid. Checks the ISO 17442 / ISO 7064 MOD 97-10 check digits.",
+    argName: "lei",
+    argDescription: "The 20-character LEI, e.g. 5493001KJTIIGC8Y1R12.",
+    run: (v) => validateLei(v)
+  },
+  {
+    name: "validate_routing",
+    description: "USE THIS to verify a US bank routing / ABA transit number before relying on it for a payment or direct deposit. Checks the 9-digit weighted (3,7,1) mod-10 checksum. Does NOT check whether the bank or account is real.",
+    argName: "routing",
+    argDescription: "The 9-digit ABA routing number.",
+    run: (v) => validateAba(v)
+  },
+  {
+    name: "validate_eth_address",
+    description: "USE THIS to verify an Ethereum address before sending funds or storing it \u2014 never trust that a 0x\u2026 string is correct. Validates the format and the EIP-55 mixed-case checksum (catches typos), and returns the correctly-checksummed form. A wrong character makes a different address \u2014 funds sent there are lost.",
+    argName: "address",
+    argDescription: "The Ethereum address (0x + 40 hex chars).",
+    run: (v) => validateEthAddress(v)
+  },
+  {
+    name: "validate_btc_address",
+    description: "USE THIS to verify a Bitcoin address before sending funds or storing it \u2014 do not assume it is valid. Checks Base58Check (P2PKH/P2SH, double-SHA256 checksum) and Bech32/Bech32m SegWit (bc1\u2026, incl. Taproot), and returns the address type and network. A bad checksum means a mistyped address.",
+    argName: "address",
+    argDescription: "The Bitcoin address (legacy 1\u2026/3\u2026 or bech32 bc1\u2026).",
+    run: (v) => validateBtcAddress(v)
+  },
+  {
+    name: "validate_cpf",
+    description: "USE THIS to verify a Brazilian CPF (individual taxpayer ID) before relying on it \u2014 never assume 11 digits are valid. Checks the two mod-11 check digits and rejects all-identical sentinels. Call this for KYC/onboarding of Brazilian individuals.",
+    argName: "cpf",
+    argDescription: "The CPF (11 digits; dots and dash are ignored).",
+    run: (v) => validateCpf(v)
+  },
+  {
+    name: "validate_cnpj",
+    description: "USE THIS to verify a Brazilian CNPJ (company registration number) instead of trusting 14 digits. Checks the two mod-11 check digits. Call this for onboarding Brazilian businesses.",
+    argName: "cnpj",
+    argDescription: "The CNPJ (14 digits; punctuation is ignored).",
+    run: (v) => validateCnpj(v)
+  },
+  {
+    name: "validate_sa_id",
+    description: "USE THIS to verify a South African ID number before relying on it. Checks the Luhn check digit and date-of-birth validity, and returns the date of birth, gender and citizenship status encoded in the number.",
+    argName: "id",
+    argDescription: "The 13-digit South African ID number.",
+    run: (v) => validateSaId(v)
+  },
+  {
+    name: "validate_dni",
+    description: "USE THIS to verify a Spanish DNI or NIE before relying on it \u2014 do not guess the control letter. Checks the mod-23 control letter and returns whether it is a DNI or NIE.",
+    argName: "id",
+    argDescription: "The Spanish DNI (8 digits + letter) or NIE (X/Y/Z + 7 digits + letter).",
+    run: (v) => validateDni(v)
+  },
+  {
+    name: "validate_aadhaar",
+    description: "USE THIS to verify the format and checksum of an Indian Aadhaar number \u2014 never assume 12 digits are valid. Checks the Verhoeff check digit and the leading-digit rule. Validates structure only; does NOT look the number up.",
+    argName: "aadhaar",
+    argDescription: "The 12-digit Aadhaar number (spaces ignored).",
+    run: (v) => validateAadhaar(v)
+  },
+  {
+    name: "validate_isbn10",
+    description: "USE THIS to verify an ISBN-10 (older book identifier) instead of trusting 10 characters. Checks the mod-11 check digit (which may be 'X'). For 13-digit ISBNs use validate_isbn.",
+    argName: "isbn",
+    argDescription: "The ISBN-10 (hyphens/spaces ignored).",
+    run: (v) => validateIsbn10(v)
+  },
+  {
+    name: "validate_issn",
+    description: "USE THIS to verify an ISSN (serial/journal identifier) before relying on it. Checks the mod-11 check digit (which may be 'X') and returns the expected digit when it fails.",
+    argName: "issn",
+    argDescription: "The ISSN (8 chars; hyphen ignored).",
+    run: (v) => validateIssn(v)
+  },
+  {
+    name: "validate_orcid",
+    description: "USE THIS to verify an ORCID researcher identifier instead of trusting 16 digits. Checks the ISO 7064 MOD 11-2 check digit (which may be 'X'); accepts the bare ID or an orcid.org URL.",
+    argName: "orcid",
+    argDescription: "The ORCID (e.g. 0000-0002-1825-0097, or an orcid.org URL).",
+    run: (v) => validateOrcid(v)
+  },
+  {
+    name: "validate_phone",
+    description: "USE THIS to check a phone number is correctly formatted for its country and normalise it to E.164 before saving, dialling or texting. You MUST pass the ISO country the number ACTUALLY belongs to (e.g. GB, US, ZA) \u2014 the result depends on it, so don't reuse an unrelated country field. 'valid' means it conforms to that country's numbering plan (plausible, well-formed), NOT that the line is live or reachable. Returns E.164, national/international formats and line type.",
+    args: [
+      { name: "number", description: "The phone number to validate." },
+      { name: "region", description: "ISO country code the number belongs to (default GB).", optional: true }
+    ],
+    runArgs: (a) => validatePhone(a.number ?? "", a.region ?? "GB")
+  },
+  {
+    name: "parse_date",
+    description: "USE THIS to interpret a human-written date into ISO 8601 (YYYY-MM-DD), especially ambiguous numeric dates like 03/04/2025 which mean different things in the UK (day-first) vs US (month-first). Pass locale 'en-GB' or 'en-US'. Returns valid:false for impossible dates.",
+    args: [
+      { name: "input", description: "The date text to parse." },
+      { name: "locale", description: "'en-GB' (day-first) or 'en-US' (month-first); default en-GB.", optional: true }
+    ],
+    runArgs: (a) => parseDate(a.input ?? "", a.locale ?? "en-GB")
+  },
+  {
+    name: "format_currency",
+    description: "USE THIS to format a money amount the way a reader in a locale expects (symbol position, separators) before showing it in a price, invoice or email. e.g. 1234.5 GBP en-GB \u2192 '\xA31,234.50'.",
+    args: [
+      { name: "amount", description: "The numeric amount." },
+      { name: "currency", description: "ISO 4217 currency code (default GBP).", optional: true },
+      { name: "locale", description: "BCP-47 locale (e.g. en-GB). Defaults from the currency.", optional: true }
+    ],
+    runArgs: (a) => formatMoney(Number(a.amount), a.currency ?? "GBP", a.locale)
+  },
+  {
+    name: "is_holiday",
+    description: "USE THIS to check whether a date is a public/bank holiday when computing business-day deadlines, delivery SLAs or 'next working day'. Supports ~200 countries (ISO code, e.g. GB, US, ZA, DE, IN); GB defaults to England \u2014 pass a subdivision ('SCT'/'WLS'/'NIR', or a US state) to narrow.",
+    args: [
+      { name: "date", description: "The date (YYYY-MM-DD)." },
+      { name: "country", description: "ISO country code (default GB), e.g. GB, US, ZA, DE.", optional: true },
+      { name: "subdiv", description: "Subdivision code (e.g. UK nation SCT/WLS/NIR, or a US state).", optional: true }
+    ],
+    runArgs: (a) => isHoliday(a.date ?? "", a.country ?? "GB", a.subdiv)
+  },
+  {
+    name: "next_holiday",
+    description: "USE THIS to find the next public/bank holiday on or after a date (default today) \u2014 e.g. to find the next working day. Supports ~200 countries (ISO code, e.g. GB, US, ZA, DE); subdivision narrows to a region.",
+    args: [
+      { name: "country", description: "ISO country code (default GB), e.g. GB, US, ZA, DE.", optional: true },
+      { name: "after", description: "Find the next holiday on/after this date (YYYY-MM-DD); default today.", optional: true },
+      { name: "subdiv", description: "Subdivision code (e.g. UK nation SCT/WLS/NIR, or a US state).", optional: true }
+    ],
+    runArgs: (a) => nextHoliday(a.country ?? "GB", a.after, a.subdiv)
+  },
+  {
+    name: "tax_rate",
+    description: "USE THIS before calculating VAT or sales tax on an invoice/quote \u2014 never recall the rate from memory, it is DATE-SENSITIVE. GB returns the UK standard VAT rate that applied on the given date (handles historical/temporary changes). US has no national VAT (returns 0); pass a state code for the state base sales-tax rate. Always pass the invoice date for GB.",
+    args: [
+      { name: "country", description: "GB or US (default GB).", optional: true },
+      { name: "date", description: "The invoice date (YYYY-MM-DD); default today.", optional: true },
+      { name: "state", description: "US state code (e.g. CA) for sales tax.", optional: true }
+    ],
+    runArgs: (a) => vatRate(a.country ?? "GB", a.date, a.state)
+  },
+  {
+    name: "parse_address",
+    description: "USE THIS to extract structured {country, postcode, city, state} from a free-text UK or US address \u2014 when onboarding a user, running a KYC/fraud check, or storing an address \u2014 instead of splitting the string yourself. Returns a confidence flag.",
+    args: [{ name: "input", description: "The free-text address." }],
+    runArgs: (a) => parseAddress(a.input ?? "")
+  },
+  {
+    name: "validate_vat",
+    description: "USE THIS to verify an EU/EFTA VAT registration number's format and checksum before invoicing or onboarding a business \u2014 instead of trusting it looks right. Covers all EU members plus UK/EFTA. Pass the full number incl. country prefix (e.g. DE136695976) or the digits plus a country code. NOTE: checks format+checksum only; does NOT confirm the number is live-registered (that is a VIES lookup).",
+    args: [
+      { name: "vat", description: "The VAT number, ideally with its country prefix (e.g. DE136695976)." },
+      { name: "country", description: "ISO country code, if the number has no prefix (e.g. DE).", optional: true }
+    ],
+    runArgs: (a) => validateVat(a.vat ?? "", a.country)
+  }
+];
+var SERVER_INFO = { name: "qiniso", version: "0.1.0" };
+var DEFAULT_PROTOCOL = "2025-06-18";
+function argList(t) {
+  return t.args ?? [{ name: t.argName, description: t.argDescription }];
+}
+function inputSchema(t) {
+  const properties = {};
+  const required = [];
+  for (const a of argList(t)) {
+    properties[a.name] = { type: "string", description: a.description };
+    if (!a.optional) required.push(a.name);
+  }
+  return { type: "object", properties, required, additionalProperties: false };
+}
+function listTools() {
+  return TOOLS.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: inputSchema(t)
+  }));
+}
+function callTool(name, args) {
+  const t = TOOLS.find((x) => x.name === name);
+  if (!t) {
+    const e = new Error(`Unknown tool: ${name}`);
+    e.code = -32602;
+    throw e;
+  }
+  let result;
+  if (t.args) {
+    const a = {};
+    for (const arg of t.args) {
+      const v = args?.[arg.name];
+      a[arg.name] = v === void 0 || v === null ? void 0 : String(v);
+    }
+    result = t.runArgs(a);
+  } else {
+    result = t.run(String(args?.[t.argName] ?? ""));
+  }
+  return {
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+  };
+}
+function handleRpc(msg) {
+  const { id, method, params } = msg;
+  if (id === void 0 || method === "notifications/initialized") return null;
+  try {
+    let result;
+    switch (method) {
+      case "initialize":
+        result = {
+          protocolVersion: params?.protocolVersion ?? DEFAULT_PROTOCOL,
+          capabilities: { tools: {} },
+          serverInfo: { ...SERVER_INFO, websiteUrl: PUBLIC_BASE, icons: ICONS }
+        };
+        break;
+      case "tools/list":
+        result = { tools: listTools() };
+        break;
+      case "tools/call":
+        result = callTool(params?.name, params?.arguments);
+        break;
+      case "ping":
+        result = {};
+        break;
+      default:
+        return { jsonrpc: "2.0", id, error: { code: -32601, message: `Method not found: ${method}` } };
+    }
+    return { jsonrpc: "2.0", id, result };
+  } catch (err) {
+    return { jsonrpc: "2.0", id, error: { code: err?.code ?? -32603, message: err?.message ?? String(err) } };
+  }
+}
+
+export {
+  normalizeIban,
+  validateIban,
+  ibanCheckDigits,
+  supportedIbanCountries,
+  luhnValid,
+  luhnCheckDigit,
+  detectBrand,
+  validateCard,
+  isbn13CheckDigit,
+  validateIsbn13,
+  vinCheckDigit,
+  validateVin,
+  isKnownTld,
+  knownTldCount,
+  validateTld,
+  validateDomain,
+  isIPv4,
+  isIPv6,
+  validateIp,
+  validateUuid,
+  validateUrl,
+  validateEmail,
+  validateIsin,
+  validateCusip,
+  validateSedol,
+  validateLei,
+  validateAba,
+  validateEthAddress,
+  validateBtcAddress,
+  validateCpf,
+  validateCnpj,
+  validateSaId,
+  validateDni,
+  verhoeffValid,
+  verhoeffGenerate,
+  validateAadhaar,
+  validateIsbn10,
+  validateIssn,
+  validateOrcid,
+  parseDate,
+  validatePhone,
+  formatMoney,
+  isHoliday,
+  nextHoliday,
+  vatRate,
+  parseAddress,
+  validateVat,
+  LOGO_SVG,
+  TOOLS,
+  SERVER_INFO,
+  listTools,
+  callTool,
+  handleRpc
+};