@mapslibvn/core 0.4.0

package/dist/index.js

@@ -0,0 +1,830 @@
+// src/attribution.ts
+var ATTRIBUTION_LINKS = [
+  {
+    text: "\xA9 MapsLibVN",
+    href: "https://github.com/dotienphong/maps-library-vietnam"
+  },
+  {
+    text: "\xA9 OpenStreetMap contributors",
+    href: "https://www.openstreetmap.org/copyright",
+    license: "ODbL"
+  },
+  { text: "\xA9 OpenMapTiles", href: "https://openmaptiles.org/" },
+  {
+    text: "Places: Overture Maps Foundation",
+    href: "https://overturemaps.org/",
+    license: "CDLA-Permissive 2.0"
+  },
+  {
+    text: "Foursquare OS Places",
+    href: "https://opensource.foursquare.com/os-places/",
+    license: "Apache-2.0"
+  }
+];
+var withLicense = (link, text) => link.license ? `${text} (${link.license})` : text;
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function join(parts) {
+  const [mapsLibVN, osm, openMapTiles, overture, foursquare] = parts;
+  return `${mapsLibVN} \xB7 ${osm} \xB7 ${openMapTiles} \xB7 ${overture}, ${foursquare}`;
+}
+function attributionText() {
+  return join(ATTRIBUTION_LINKS.map((link) => withLicense(link, link.text)));
+}
+function attributionHtml() {
+  return join(
+    ATTRIBUTION_LINKS.map(
+      (link) => withLicense(
+        link,
+        `<a href="${link.href}" target="_blank" rel="noopener">${escapeHtml(link.text)}</a>`
+      )
+    )
+  );
+}
+
+// src/errors.ts
+var MapsLibVNError = class extends Error {
+  status;
+  code;
+  requestId;
+  constructor(status, code, message, requestId) {
+    super(message);
+    this.name = "MapsLibVNError";
+    this.status = status;
+    this.code = code;
+    this.requestId = requestId;
+  }
+};
+
+// src/poi-sources.ts
+var POI_SOURCES = ["osm", "overture", "fsq"];
+var POI_SOURCE_PROFILES = {
+  all: ["osm", "overture", "fsq"],
+  osm: ["osm"],
+  "osm-fsq": ["osm", "fsq"],
+  "overture-fsq": ["overture", "fsq"],
+  overture: ["overture"],
+  fsq: ["fsq"]
+};
+var DEFAULT_POI_SOURCES = POI_SOURCE_PROFILES.all;
+var isPoiSource = (value) => POI_SOURCES.includes(value);
+function normalizePoiSources(list) {
+  if (list.length === 0 || !list.every(isPoiSource)) return null;
+  const set = new Set(list);
+  return POI_SOURCES.filter((source) => set.has(source));
+}
+function parsePoiSourcesCsv(raw) {
+  const trimmed = raw?.trim() ?? "";
+  if (!trimmed) return [...DEFAULT_POI_SOURCES];
+  if (trimmed === "all") return [...POI_SOURCE_PROFILES.all];
+  return normalizePoiSources(trimmed.split(",").map((part) => part.trim()));
+}
+function poiSourcesKey(sources) {
+  return (normalizePoiSources(sources) ?? []).join(",");
+}
+function profileForSources(sources) {
+  const key = poiSourcesKey(sources);
+  for (const [profile, list] of Object.entries(POI_SOURCE_PROFILES)) {
+    if (list.join(",") === key) return profile;
+  }
+  return null;
+}
+function poiSourceClause(arrayExpr) {
+  return `(p.primary_source = ANY(${arrayExpr}) OR p.created_by = 'user')`;
+}
+
+// src/client.ts
+function createClient(options) {
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const poiSources = normalizePoiSources(options.poiSources ?? DEFAULT_POI_SOURCES);
+  if (!poiSources) {
+    throw new Error(`poiSources kh\xF4ng h\u1EE3p l\u1EC7: ${JSON.stringify(options.poiSources)}`);
+  }
+  const sources = poiSourcesKey(poiSources);
+  const doFetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+  const baseHeaders = () => ({
+    ...options.headers ?? {},
+    "X-Api-Key": options.apiKey
+  });
+  async function parseOrThrow(response) {
+    if (!response.ok) {
+      let body = {};
+      try {
+        body = await response.json();
+      } catch {
+      }
+      throw new MapsLibVNError(
+        response.status,
+        body.error?.code ?? "http_error",
+        body.error?.message ?? `HTTP ${response.status}`,
+        body.error?.request_id
+      );
+    }
+    return await response.json();
+  }
+  async function get(path, params = {}) {
+    const url = new URL(baseUrl + path);
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) url.searchParams.set(key, String(value));
+    }
+    const response = await doFetch(url, {
+      headers: baseHeaders()
+    });
+    return parseOrThrow(response);
+  }
+  async function post(path, body) {
+    const response = await doFetch(new URL(baseUrl + path), {
+      method: "POST",
+      headers: { ...baseHeaders(), "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    return parseOrThrow(response);
+  }
+  return {
+    baseUrl,
+    attribution: () => get("/v1/attribution"),
+    styleUrl: (theme) => `${baseUrl}/v1/styles/${theme}.json?key=${encodeURIComponent(options.apiKey)}&sources=${encodeURIComponent(sources)}`,
+    autocomplete: (q, opts = {}) => get("/v1/autocomplete", {
+      q,
+      near: opts.near?.join(","),
+      limit: opts.limit,
+      types: opts.types?.join(","),
+      sources
+    }),
+    search: (q, opts = {}) => get("/v1/search", {
+      q,
+      category: opts.category,
+      near: opts.near?.join(","),
+      radius: opts.radius,
+      bbox: opts.bbox?.join(","),
+      limit: opts.limit,
+      offset: opts.offset,
+      sources
+    }),
+    nearby: (opts) => get("/v1/nearby", {
+      lat: opts.lat,
+      lng: opts.lng,
+      radius: opts.radius,
+      category: opts.category,
+      limit: opts.limit,
+      sources
+    }),
+    getPlace: (id) => get(`/v1/places/${encodeURIComponent(id)}`),
+    geocode: (q, opts = {}) => get("/v1/geocode", {
+      q,
+      near: opts.near?.join(","),
+      limit: opts.limit
+    }),
+    reverse: (lat, lng) => get("/v1/reverse", { lat, lng, sources }),
+    /** Gửi đóng góp/sửa POI (spec 6.1). Khoá phải có scope edits:write. */
+    suggestEdit: (edit) => post("/v1/edits", edit)
+  };
+}
+
+// src/abbrev.json
+var abbrev_default = {
+  "tp.": "thanh pho",
+  "tt.": "thi tran",
+  "tx.": "thi xa",
+  "p.": "phuong",
+  "q.": "quan",
+  "h.": "huyen",
+  "x.": "xa",
+  "d.": "duong",
+  "ng.": "nguyen",
+  kp: "khu pho",
+  cty: "cong ty",
+  cp: "co phan"
+};
+
+// src/brand_alias.json
+var brand_alias_default = {
+  highlands: ["highlands coffee", "highland coffee", "highland"],
+  cong: ["cong caphe", "cong ca phe", "cong cafe", "cong coffee"],
+  "the coffee house": ["tch", "coffee house"],
+  "phuc long": ["phuc long coffee tea", "phuc long tea coffee", "phuc long coffee"],
+  "trung nguyen": ["trung nguyen legend", "trung nguyen e-coffee", "trung nguyen coffee"],
+  starbucks: ["starbucks coffee", "starbucks reserve"],
+  "circle k": ["circlek"],
+  winmart: ["vinmart", "vinmart plus", "winmart plus"],
+  coopmart: ["co opmart", "co op mart", "coop mart", "saigon co op"],
+  "bach hoa xanh": ["bhx"],
+  "family mart": ["familymart"],
+  gs25: ["gs 25"],
+  "pho 24": ["pho24"],
+  kfc: ["kentucky fried chicken"],
+  vietcombank: ["ngan hang vietcombank", "ngan hang tmcp ngoai thuong viet nam", "vcb"],
+  techcombank: ["ngan hang techcombank", "tcb"],
+  agribank: ["ngan hang agribank", "ngan hang nong nghiep va phat trien nong thon"],
+  bidv: ["ngan hang bidv", "ngan hang dau tu va phat trien viet nam"],
+  vietinbank: ["ngan hang vietinbank", "ngan hang cong thuong viet nam"],
+  pharmacity: ["nha thuoc pharmacity"],
+  "long chau": ["nha thuoc long chau", "fpt long chau"],
+  "an khang": ["nha thuoc an khang"],
+  "the gioi di dong": ["tgdd"],
+  "dien may xanh": ["dmx"],
+  "fpt shop": ["fptshop"]
+};
+
+// src/normalize.ts
+var ABBREV = abbrev_default;
+var BRAND_ALIAS = brand_alias_default;
+var NAME_FILLERS = [
+  "cong ty",
+  "cty",
+  "tnhh",
+  "mtv",
+  "co phan",
+  "cua hang",
+  "quan",
+  "tiem",
+  "nha hang",
+  "shop",
+  "cafe",
+  "ca phe",
+  "coffee"
+];
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var ABBREV_RULES = Object.entries(ABBREV).map(([key, value]) => {
+  const after = key.endsWith(".") ? "" : "(?=[\\s\\d,.]|$)";
+  return {
+    re: new RegExp(`(^|[\\s,.(])${escapeRegExp(key)}${after}`, "g"),
+    replacement: `$1${value} `
+  };
+});
+var ALIAS_RULES = Object.entries(BRAND_ALIAS).flatMap(([canonical, variants]) => variants.map((variant) => ({ variant, canonical }))).sort((a, b) => b.variant.length - a.variant.length);
+function stripDiacritics(s) {
+  return s.normalize("NFD").replace(/\p{M}/gu, "").replace(/đ/g, "d").replace(/Đ/g, "D");
+}
+function expandAbbrev(s) {
+  let out = s;
+  for (const { re, replacement } of ABBREV_RULES) out = out.replace(re, replacement);
+  out = out.replace(/(^|\s)f\.?(?=\s*\d)/g, "$1phuong ");
+  return out.replace(/ {2,}/g, " ").trim();
+}
+function normalizeVi(input) {
+  let s = stripDiacritics(input.normalize("NFC").toLowerCase());
+  s = expandAbbrev(s);
+  s = s.replace(/[^a-z0-9/\-\s]/g, " ");
+  s = s.replace(/\s*\/\s*/g, "/");
+  s = s.replace(/\s+-\s+/g, " ");
+  return s.replace(/\s+/g, " ").trim();
+}
+function applyBrandAlias(s) {
+  for (const { variant, canonical } of ALIAS_RULES) {
+    if (s === variant) return canonical;
+    if (s.startsWith(`${variant} `)) return canonical + s.slice(variant.length);
+  }
+  return s;
+}
+function nameCore(input) {
+  const norm = normalizeVi(input);
+  let s = norm;
+  let changed = true;
+  while (changed && s) {
+    changed = false;
+    for (const filler of NAME_FILLERS) {
+      if (s === filler) {
+        s = "";
+        break;
+      }
+      if (s.startsWith(`${filler} `)) {
+        s = s.slice(filler.length + 1);
+        changed = true;
+      }
+    }
+  }
+  return applyBrandAlias(s || norm);
+}
+
+// src/provinces.json
+var provinces_default = {
+  "H\xE0 N\u1ED9i": ["ha noi", "hanoi", "hn"],
+  Hu\u1EBF: ["hue", "thua thien hue", "thua thien-hue"],
+  "Lai Ch\xE2u": ["lai chau"],
+  "\u0110i\u1EC7n Bi\xEAn": ["dien bien"],
+  "S\u01A1n La": ["son la"],
+  "L\u1EA1ng S\u01A1n": ["lang son"],
+  "Qu\u1EA3ng Ninh": ["quang ninh", "ha long"],
+  "Thanh H\xF3a": ["thanh hoa"],
+  "Ngh\u1EC7 An": ["nghe an", "vinh"],
+  "H\xE0 T\u0129nh": ["ha tinh"],
+  "Cao B\u1EB1ng": ["cao bang"],
+  "Tuy\xEAn Quang": ["tuyen quang", "ha giang"],
+  "L\xE0o Cai": ["lao cai", "yen bai", "sa pa", "sapa"],
+  "Th\xE1i Nguy\xEAn": ["thai nguyen", "bac kan", "bac can"],
+  "Ph\xFA Th\u1ECD": ["phu tho", "vinh phuc", "hoa binh", "viet tri"],
+  "B\u1EAFc Ninh": ["bac ninh", "bac giang"],
+  "H\u01B0ng Y\xEAn": ["hung yen", "thai binh"],
+  "H\u1EA3i Ph\xF2ng": ["hai phong", "hai duong"],
+  "Ninh B\xECnh": ["ninh binh", "ha nam", "nam dinh"],
+  "Qu\u1EA3ng Tr\u1ECB": ["quang tri", "quang binh", "dong hoi"],
+  "\u0110\xE0 N\u1EB5ng": ["da nang", "danang", "quang nam", "hoi an", "tam ky"],
+  "Qu\u1EA3ng Ng\xE3i": ["quang ngai", "kon tum"],
+  "Gia Lai": ["gia lai", "binh dinh", "quy nhon", "pleiku"],
+  "Kh\xE1nh H\xF2a": ["khanh hoa", "ninh thuan", "nha trang", "cam ranh", "phan rang"],
+  "L\xE2m \u0110\u1ED3ng": ["lam dong", "dak nong", "dac nong", "binh thuan", "da lat", "dalat", "phan thiet"],
+  "\u0110\u1EAFk L\u1EAFk": ["dak lak", "dac lac", "daklak", "phu yen", "buon ma thuot", "tuy hoa"],
+  "Th\xE0nh ph\u1ED1 H\u1ED3 Ch\xED Minh": ["ho chi minh", "hcm", "tphcm", "sai gon", "saigon", "binh duong", "ba ria vung tau", "ba ria-vung tau", "ba ria", "vung tau", "thu dau mot", "di an"],
+  "\u0110\u1ED3ng Nai": ["dong nai", "binh phuoc", "bien hoa", "dong xoai"],
+  "T\xE2y Ninh": ["tay ninh", "long an", "tan an"],
+  "C\u1EA7n Th\u01A1": ["can tho", "soc trang", "hau giang", "vi thanh"],
+  "V\u0129nh Long": ["vinh long", "ben tre", "tra vinh"],
+  "\u0110\u1ED3ng Th\xE1p": ["dong thap", "tien giang", "my tho", "cao lanh", "sa dec"],
+  "C\xE0 Mau": ["ca mau", "bac lieu"],
+  "An Giang": ["an giang", "kien giang", "rach gia", "phu quoc", "long xuyen", "chau doc"]
+};
+
+// src/address.ts
+var PROVINCE_BY_ALIAS = /* @__PURE__ */ new Map();
+for (const [name, aliases] of Object.entries(provinces_default)) {
+  PROVINCE_BY_ALIAS.set(normalizeVi(name).replace(/^thanh pho /, ""), name);
+  for (const a of aliases) PROVINCE_BY_ALIAS.set(a, name);
+}
+var NUM = String.raw`(?:\d+(?:[a-z](?![a-z])\d*)?(?:-\d+[a-z]?)?|[a-z]{1,2}\d+[a-z]?)`;
+var NUM_LEAD = String.raw`(?:\d+(?:[a-z](?![a-z])\d*)?(?:-\d+[a-z]?)?|(?![pqf]\d|tp\d|ql\d|tl\d|dt\d|hl\d)[a-z]{1,2}\d+[a-z]?)`;
+var HN = String.raw`${NUM_LEAD}(?:/${NUM})*`;
+var ALLEY_KW = String.raw`(?:hem|ngo|ngach|kiet)`;
+var PREFIX = String.raw`(?:(?:so(?:\s*nha)?|sn|lo|can|kiot)\.?\s*)?`;
+var RE_PREFIX = new RegExp(`^${PREFIX}`);
+var RE_STREET = new RegExp(
+  String.raw`^${PREFIX}(${HN})?\s*((?:${ALLEY_KW}\s*${HN}\s*)*)((?:duong|d\.|pho)\s+(?!so\b|[a-z]{1,2}\d))?(.*)$`
+);
+var RE_ALLEY_EACH = new RegExp(String.raw`(${ALLEY_KW})\s*(${HN})`, "g");
+var RE_STREET_LIKE = new RegExp(
+  String.raw`^${PREFIX}${NUM_LEAD}(?:/|\s|$)|\b${ALLEY_KW}\s*\d|^(?:duong|d\.|pho)\s`
+);
+var RE_STREET_WORD = /^(?:duong|d\.|pho)\s/;
+var RE_POSITIONAL = /^(?:gan|doi dien|cuoi|canh)\s/;
+var RE_TINH = /^(?:tinh(?!\s+lo\b)|t\.)\s+(.+)$/;
+var RE_CITY = /^(?:thanh pho(?=[\s\d])\s*|tp\.?\s*)(.+)$/;
+var RE_DISTRICT = /^(?:(?:quan|huyen|thi xa)(?=[\s\d])\s*|(?:q\.|h\.|tx\.)\s*)(.+)$|^q\s*(\d.*)$|^district\s+(.+)$/;
+var RE_WARD = /^(?:(?:phuong|xa(?!\s+lo\b)|thi tran)(?=[\s\d])\s*|(?:p\.|x\.|tt\.|f\.)\s*|tt\s+)(.+)$|^[pf]\s*(\d.*)$|^(.+?)\s+ward$/;
+var RE_IGNORE = /^(?:to|khu pho|kp|ap|thon|xom|khom|khu vuc|kv|to dan pho|tdp|lo|toa nha|tn|chung cu|cc|block|tang|lau|can ho|kdc|khu dan cu|kdt|khu do thi|kcn|khu cong nghiep|kcx|khu che xuat|khu cong nghe cao|khu|cu xa|cx|ttm|tttm)\b/;
+var RE_SPLIT = /\s(?=(?:phuong|xa(?!\s+lo\b)|thi tran|quan|huyen|thi xa|thanh pho|tinh(?!\s+lo\b))(?:\s|\d)|(?:p|q|f|tp|tt|tx|h|x)\.\s*\S|tp\s*\S)|(?<!\b(?:lo|can|kiot|block|toa|khu|so))\s(?=[pqf]\s*\d)/g;
+var RE_SPLIT_PART = /\s(?=(?:phuong|thi tran|quan|huyen|thi xa|thanh pho|tinh(?!\s+lo\b))(?:\s|\d)|(?:p|q|f|tp|tt|tx|h)\.\s*\S|tp\s*\S)|(?<!\b(?:lo|can|kiot|block|toa|khu|so))\s(?=[pqf]\s*\d)/g;
+var keyOf = (s) => stripDiacritics(s.toLowerCase());
+var cleanTail = (s) => s.trim().replace(/^[\s,.;:\-/]+|[\s,.;:-]+$/g, "");
+function lookupProvince(part) {
+  const n = normalizeVi(part).replace(/^(?:tinh|thanh pho|tp)\s+/, "");
+  return PROVINCE_BY_ALIAS.get(n);
+}
+function isStreetWord(orig, at, word) {
+  if (word.startsWith("d.")) return true;
+  const c0 = orig[at] ?? "";
+  if (word.startsWith("duong"))
+    return c0 === "\u0110" || c0 === "\u0111" || c0 === "D" || c0 === "d" ? c0 === "\u0110" || c0 === "\u0111" : false;
+  const c2 = orig[at + 2] ?? "";
+  return c2 === "\u1ED1" || c2 === "\u1ED0";
+}
+function mergeChain(fromAlley, fromHn) {
+  const startsWith = (a, b) => b.every((x, i) => a[i] === x);
+  if (startsWith(fromHn, fromAlley)) return fromHn;
+  if (startsWith(fromAlley, fromHn)) return fromAlley;
+  return [...fromAlley, ...fromHn];
+}
+function parseStreetPart(orig, key, out) {
+  const m = RE_STREET.exec(key);
+  if (!m) return;
+  const [, hnRaw, alleyText = "", streetWord = "", rest0 = ""] = m;
+  let rest = rest0;
+  let restAt = key.length - rest0.length;
+  if (streetWord && !isStreetWord(orig, restAt - streetWord.length, streetWord)) {
+    rest = streetWord + rest0;
+    restAt -= streetWord.length;
+  }
+  let hn;
+  let hnAt = -1;
+  if (hnRaw) {
+    const prefixLen = RE_PREFIX.exec(key)?.[0].length ?? 0;
+    hnAt = key.indexOf(hnRaw, prefixLen);
+    hn = orig.slice(hnAt, hnAt + hnRaw.length);
+  }
+  if (hn && !alleyText && /^thang\s+\d/.test(rest.trim())) {
+    out.street = cleanTail(orig.slice(hnAt));
+    out.streetNorm = normalizeVi(out.street);
+    return;
+  }
+  const street = cleanTail(
+    orig.slice(restAt).replace(/\s(?:[Kk]hóm|[Tt]ổ|[Ấấ]p|KP|[Kk]hu phố)\s+\d.*$/, "")
+  );
+  if (street) {
+    out.street = street;
+    out.streetNorm = normalizeVi(street);
+  }
+  const alleys = [...alleyText.matchAll(RE_ALLEY_EACH)];
+  const alleyNums = alleys.map((a) => a[2].toUpperCase().split("/")).reverse().flat();
+  const segs = hn ? hn.split("/") : [];
+  const house = segs.at(-1);
+  const chain = mergeChain(
+    alleyNums,
+    segs.slice(0, -1).map((s) => s.toUpperCase())
+  );
+  if (alleys.length) {
+    out.alleyKeyword = alleys[0]?.[1];
+    out.alleyChain = chain;
+    if (house) {
+      out.houseInAlley = house;
+      out.housenumber = [...chain, house].join("/");
+    }
+  } else if (hn) {
+    out.housenumber = hn;
+    out.alleyChain = chain;
+    if (chain.length && house) out.houseInAlley = house;
+  }
+}
+function parseAddress(input) {
+  const out = { alleyChain: [], confidence: 0 };
+  const rememberAdmin = (key, value) => {
+    out.adminOriginal ??= {};
+    if (!out.adminOriginal[key]) out.adminOriginal[key] = value;
+  };
+  const orig = input.normalize("NFC").replace(/\([^)]*\)?/g, " ").replace(/\s+/g, " ").replace(/\s+[-–—]\s+/g, ", ").trim().replace(/,?\s*(?:việt nam|viet nam|vietnam)\.?\s*$/i, "").replace(/,?\s*\b\d{5,6}\s*$/, "").trim();
+  if (!orig) return out;
+  const splitBy = (s, re) => {
+    const key = keyOf(s);
+    const cuts = [...key.matchAll(re)].map((m) => m.index ?? 0);
+    return [0, ...cuts].map((start, i, arr) => cleanTail(s.slice(start, arr[i + 1]))).filter(Boolean);
+  };
+  const commaParts = orig.split(",").map(cleanTail).filter(Boolean);
+  const parts = commaParts.length === 1 ? splitBy(orig, RE_SPLIT) : commaParts.flatMap((p) => splitBy(p, RE_SPLIT_PART));
+  let streetIdx = -1;
+  let firstAdminIdx = Number.POSITIVE_INFINITY;
+  const unknown = [];
+  const numbers = [];
+  parts.forEach((part, i) => {
+    const key = keyOf(part);
+    if (!key || RE_POSITIONAL.test(key)) return;
+    const markAdmin = () => {
+      firstAdminIdx = Math.min(firstAdminIdx, i);
+    };
+    if (streetIdx < 0 && RE_STREET_LIKE.test(key)) {
+      parseStreetPart(part, key, out);
+      streetIdx = i;
+      return;
+    }
+    if (streetIdx >= 0 && !out.street && i === streetIdx + 1 && RE_STREET_WORD.test(key)) {
+      parseStreetPart(part, key, out);
+      return;
+    }
+    const tinh = RE_TINH.exec(key);
+    if (tinh) {
+      markAdmin();
+      rememberAdmin("province", part);
+      out.province = lookupProvince(tinh[1] ?? "") ?? cleanTail(part.slice(key.length - (tinh[1] ?? "").length));
+      return;
+    }
+    const city = RE_CITY.exec(key);
+    if (city) {
+      markAdmin();
+      const rest = city[1] ?? "";
+      const prov2 = lookupProvince(rest);
+      if (prov2) {
+        rememberAdmin("province", part);
+        out.province = prov2;
+      } else if (!out.district) {
+        rememberAdmin("district", part);
+        out.district = cleanTail(part.slice(key.length - rest.length));
+      }
+      return;
+    }
+    const d = RE_DISTRICT.exec(key);
+    if (d) {
+      markAdmin();
+      const rest = d[1] ?? d[2] ?? d[3] ?? "";
+      if (!out.district) {
+        rememberAdmin("district", part);
+        out.district = cleanTail(part.slice(key.length - rest.length));
+      }
+      return;
+    }
+    const w = RE_WARD.exec(key);
+    if (w) {
+      markAdmin();
+      const rest = w[1] ?? w[2] ?? w[3] ?? "";
+      const at = w[3] !== void 0 ? 0 : key.length - rest.length;
+      if (!out.ward) {
+        rememberAdmin("ward", part);
+        out.ward = cleanTail(part.slice(at, at + rest.length));
+      }
+      return;
+    }
+    const prov = lookupProvince(part);
+    if (prov) {
+      markAdmin();
+      rememberAdmin("province", part);
+      out.province = prov;
+      return;
+    }
+    if (RE_IGNORE.test(key)) return;
+    if (/^\d+$/.test(key)) {
+      numbers.push(part);
+      return;
+    }
+    unknown.push({ part, i });
+  });
+  if (!out.street && unknown.length) {
+    const k = unknown.findIndex((u) => u.i > streetIdx && u.i < firstAdminIdx);
+    if (k >= 0) {
+      const [first] = unknown.splice(k, 1);
+      const keep = {
+        housenumber: out.housenumber,
+        alleyChain: out.alleyChain,
+        houseInAlley: out.houseInAlley
+      };
+      parseStreetPart(first.part, keyOf(first.part), out);
+      if (keep.housenumber && !out.housenumber) {
+        out.housenumber = keep.housenumber;
+        out.alleyChain = keep.alleyChain;
+        if (keep.houseInAlley !== void 0) out.houseInAlley = keep.houseInAlley;
+      }
+      streetIdx = Math.max(streetIdx, first.i);
+    }
+  }
+  for (const u of unknown) {
+    if (u.i < streetIdx) continue;
+    if (!out.ward) out.ward = u.part;
+    else if (!out.district) out.district = u.part;
+  }
+  for (const n of numbers) {
+    if (!out.ward) out.ward = n;
+    else if (!out.district) out.district = n;
+  }
+  out.confidence = Math.round(
+    ((out.housenumber ? 0.25 : 0) + (out.street ? 0.35 : 0) + (out.ward ? 0.15 : 0) + (out.district ? 0.1 : 0) + (out.province ? 0.15 : 0)) * 100
+  ) / 100;
+  return out;
+}
+
+// src/admin-alias.ts
+var PREFIX2 = /^(?:tinh|thanh pho|tp|quan|huyen|thi xa|phuong|xa|thi tran)\s+/;
+var prefixOf = (value, fallback) => {
+  const normalized = normalizeVi(value ?? "");
+  const match = /^(tinh|thanh pho|quan|huyen|thi xa|phuong|xa|thi tran)\s+/.exec(normalized);
+  return match?.[1] ?? fallback;
+};
+var coreOf = (value) => normalizeVi(value ?? "").replace(PREFIX2, "");
+function adminAliasKeys(input) {
+  const original = input.adminOriginal ?? {};
+  const ward = coreOf(input.ward ?? original.ward);
+  const district = coreOf(input.district ?? original.district);
+  const canonicalProvince = coreOf(input.province);
+  const originalProvince = coreOf(original.province);
+  const province = ["hcm", "tphcm"].includes(originalProvince) ? canonicalProvince : originalProvince || canonicalProvince;
+  const wardPart = ward ? `${prefixOf(original.ward, "phuong")} ${ward}` : "";
+  const districtPart = district ? `${prefixOf(original.district, "quan")} ${district}` : "";
+  const keys = [];
+  const add = (...parts) => {
+    const key = parts.filter(Boolean).join(" ");
+    if (key && !keys.includes(key)) keys.push(key);
+  };
+  if (wardPart && districtPart && province) add(wardPart, districtPart, province);
+  if (wardPart && districtPart) add(wardPart, districtPart);
+  if (wardPart && province) add(wardPart, province);
+  if (wardPart) add(wardPart);
+  if (ward && !/^\d+$/.test(ward)) add(ward);
+  if (districtPart && province) add(districtPart, province);
+  if (districtPart) add(districtPart);
+  if (district && !/^\d+$/.test(district)) add(district);
+  if (originalProvince) add(originalProvince);
+  if (canonicalProvince) add(canonicalProvince);
+  return keys;
+}
+
+// src/style-transform.ts
+var POI_LAYER_ID = "poi";
+var SOVEREIGNTY_LABEL_ID = "sovereignty-label";
+function isPoiStyleLayer(layer) {
+  return layer.id === POI_LAYER_ID || layer.source === "poi";
+}
+function nameExpression(lang) {
+  return ["coalesce", ["get", `name:${lang}`], ["get", "name"]];
+}
+function isNameLabelLayer(layer) {
+  if (layer.type !== "symbol" || layer.id === SOVEREIGNTY_LABEL_ID) return false;
+  const textField = layer.layout?.["text-field"];
+  return textField !== void 0 && JSON.stringify(textField).includes("name");
+}
+function mapLayers(style, fn) {
+  return { ...style, layers: (style.layers ?? []).map(fn) };
+}
+function localizeStyle(style, lang) {
+  if (lang === "vi") return style;
+  return mapLayers(
+    style,
+    (layer) => isNameLabelLayer(layer) ? { ...layer, layout: { ...layer.layout, "text-field": nameExpression(lang) } } : layer
+  );
+}
+function hidePoiLayer(style) {
+  return mapLayers(
+    style,
+    (layer) => isPoiStyleLayer(layer) ? { ...layer, layout: { ...layer.layout, visibility: "none" } } : layer
+  );
+}
+
+// src/toponym_alias.json
+var toponym_alias_default = {
+  "quy nhon": {
+    variants: [
+      "qui nhon"
+    ],
+    source: "osm:node/369487010 alt_name"
+  },
+  "dak lak": {
+    variants: [
+      "darlac",
+      "daklak"
+    ],
+    source: "osm:relation/1884034 alt_name"
+  },
+  "buon ma thuot": {
+    variants: [
+      "buon me thuot",
+      "ban me thuot",
+      "buon ma thot"
+    ],
+    source: "osm:node/2502425156 alt_name"
+  },
+  "da nang": {
+    variants: [
+      "tourane"
+    ],
+    source: "osm:relation/1891418 old_name"
+  },
+  hue: {
+    variants: [
+      "thua thien hue",
+      "thua thien"
+    ],
+    source: "osm:relation/1891483 old_name"
+  },
+  "tan son nhat": {
+    variants: [
+      "tan son nhut"
+    ],
+    source: "osm:node/13097604035 old_name"
+  },
+  "hoi an": {
+    variants: [
+      "faifo"
+    ],
+    source: "osm:node/110506070 old_name"
+  },
+  "soc trang": {
+    variants: [
+      "khanh hung"
+    ],
+    source: "osm:node/369487102 old_name"
+  },
+  "can tho": {
+    variants: [
+      "tay do",
+      "phong dinh"
+    ],
+    source: "osm:node/948325197 old_name"
+  },
+  "ca mau": {
+    variants: [
+      "an xuyen"
+    ],
+    source: "osm:relation/1873490 old_name"
+  },
+  "ha noi": {
+    variants: [
+      "thang long"
+    ],
+    source: "osm:relation/1903516 old_name"
+  }
+};
+
+// src/toponym.ts
+var isEntry = (value) => typeof value === "object" && value !== null && "variants" in value && "source" in value;
+var TOPONYM_ALIAS = Object.fromEntries(
+  Object.entries(toponym_alias_default).filter(
+    (pair) => !pair[0].startsWith("$") && isEntry(pair[1])
+  )
+);
+var escapeRegExp2 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var RULES = Object.entries(TOPONYM_ALIAS).flatMap(([canonical, { variants }]) => variants.map((variant) => ({ variant, canonical }))).sort((a, b) => b.variant.length - a.variant.length).map(({ variant, canonical }) => ({
+  re: new RegExp(`(^|\\s)${escapeRegExp2(variant)}(?=\\s|$)`, "g"),
+  replacement: `$1${canonical}`
+}));
+function applyToponymAlias(normalized) {
+  let out = normalized;
+  for (const { re, replacement } of RULES) out = out.replace(re, replacement);
+  return out;
+}
+
+// src/vi_key_rules.json
+var vi_key_rules_default = {
+  $comment: [
+    "B\u1EA3ng lu\u1EADt kho\xE1 ng\u1EEF \xE2m \u2014 spec 05/09 m\u1EE5c 6.2. \u0110\u1EB7t \u1EDF d\u1EEF li\u1EC7u \u0111\u1EC3 ch\u1EC9nh m\xE0 kh\xF4ng s\u1EEDa logic.",
+    "\xC1p SAU normalizeVi v\xE0 applyToponymAlias, theo T\u1EEANG T\u1EEA, r\u1ED3i n\u1ED1i kh\xF4ng kho\u1EA3ng tr\u1EAFng.",
+    "Th\u1EE9 t\u1EF1 c\xF3 \xFD ngh\u0129a: \u0111\u1EA7u t\u1EEB \u2192 \xE2m cu\u1ED1i \u2192 i/y. `ngh` ph\u1EA3i tr\u01B0\u1EDBc `gh`; `gi` ph\u1EA3i tr\u01B0\u1EDBc `r`/`d`.",
+    "KH\xD4NG \xE1p l/n: 'H\xE0 N\u1ED9i' \u2194 'H\xE0 L\u1ED9i' va ch\u1EA1m t\xEAn ri\xEAng th\u1EADt qu\xE1 nhi\u1EC1u (spec n\xF3i r\xF5).",
+    "Ch\u1EC9 d\xF9ng \u1EDF b\u1EADc 3 n\xEAn va ch\u1EA1m ch\u1EC9 \u1EA3nh h\u01B0\u1EDFng th\u1EE9 t\u1EF1 trong nh\xF3m m\u1EDD, kh\xF4ng l\xE0m sai b\u1EADc 1/2."
+  ],
+  wordStart: [
+    ["^ngh", "ng"],
+    ["^gh", "g"],
+    ["^ph", "f"],
+    ["^gi(?=[aeiouy])", "d"],
+    ["^r", "d"],
+    ["^tr", "c"],
+    ["^ch", "c"],
+    ["^x", "s"],
+    ["^k(?=[aou])", "c"]
+  ],
+  wordEnd: [
+    ["ng$", "n"],
+    ["nh$", "n"],
+    ["t$", "c"]
+  ],
+  anywhere: [
+    ["quy", "qui"],
+    ["([bcdfghklmnpqrstvx])y$", "$1i"]
+  ]
+};
+
+// src/vi-key.ts
+var RULES2 = vi_key_rules_default;
+var compile = (rules) => rules.map(([pattern, replacement]) => ({ re: new RegExp(pattern), replacement }));
+var WORD_START = compile(RULES2.wordStart);
+var WORD_END = compile(RULES2.wordEnd);
+var ANYWHERE = compile(RULES2.anywhere);
+function viKey(normalized) {
+  const words = normalized.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+  return words.map((word) => {
+    let w = word;
+    for (const { re, replacement } of WORD_START) w = w.replace(re, replacement);
+    for (const { re, replacement } of WORD_END) w = w.replace(re, replacement);
+    for (const { re, replacement } of ANYWHERE) w = w.replace(re, replacement);
+    return w;
+  }).join("");
+}
+
+// src/search-keys.ts
+function searchKeys(nameNorm, nameAlt) {
+  const alts = filterNameAlt(nameNorm, nameAlt);
+  return {
+    nameKey: viKey(applyToponymAlias(nameNorm)),
+    nameAltNorm: alts.length ? alts.map((a) => normalizeVi(a)).join(" | ") : null
+  };
+}
+function filterNameAlt(nameNorm, nameAlt) {
+  const seen = /* @__PURE__ */ new Set([nameNorm]);
+  const out = [];
+  for (const raw of nameAlt ?? []) {
+    const norm = normalizeVi(raw ?? "");
+    if (!norm || seen.has(norm)) continue;
+    seen.add(norm);
+    out.push(raw);
+  }
+  return out;
+}
+
+// src/telex.ts
+var TELEX_PATTERN = /(aa|ee|oo|dd|[aeiouy][sfrxj]\b|[a-z][1-9]\b)/;
+function looksLikeTelex(normalized) {
+  return TELEX_PATTERN.test(normalized);
+}
+function foldTelex(normalized) {
+  return normalized.replace(/aa/g, "a").replace(/ee/g, "e").replace(/oo/g, "o").replace(/dd/g, "d").replace(/aw/g, "a").replace(/ow/g, "o").replace(/uw/g, "u").replace(/([aeiouy](?:ch|ng|nh|[cmnpt])?)[sfrxj]\b/g, "$1").replace(/([a-z])[1-9]\b/g, "$1").replace(/\s+/g, " ").trim();
+}
+export {
+  ATTRIBUTION_LINKS,
+  DEFAULT_POI_SOURCES,
+  MapsLibVNError,
+  NAME_FILLERS,
+  POI_LAYER_ID,
+  POI_SOURCES,
+  POI_SOURCE_PROFILES,
+  TOPONYM_ALIAS,
+  adminAliasKeys,
+  applyBrandAlias,
+  applyToponymAlias,
+  attributionHtml,
+  attributionText,
+  createClient,
+  expandAbbrev,
+  filterNameAlt,
+  foldTelex,
+  hidePoiLayer,
+  isNameLabelLayer,
+  isPoiStyleLayer,
+  localizeStyle,
+  looksLikeTelex,
+  nameCore,
+  nameExpression,
+  normalizePoiSources,
+  normalizeVi,
+  parseAddress,
+  parsePoiSourcesCsv,
+  poiSourceClause,
+  poiSourcesKey,
+  profileForSources,
+  searchKeys,
+  stripDiacritics,
+  viKey
+};