@whiteslove/parsing-lexicon 0.2.0

package/src/contact.js

@@ -0,0 +1,159 @@
+import { parsePhoneNumberFromString } from 'libphonenumber-js/min';
+
+// Broad phone-like detection used by other parsers for exclusion/classification.
+// It deliberately stays tolerant and does not validate against a country plan.
+const PHONE_LIKE_RE = /\+?\d(?:[\t \u00a0().-]*\d){9,}/g;
+
+// Contact extraction may start from shorter national formats, but candidates are
+// only returned after libphonenumber validation.
+const PHONE_CANDIDATE_RE = /\+?\d(?:[\t \u00a0().-]*\d){6,}(?:[\t \u00a0]*(?:ext\.?|extension|x|доб\.?|дод\.?)\s*\d{1,6})?/giu;
+const PHONE_EXTENSION_RE = /[\t \u00a0]*(?:ext\.?|extension|x|доб\.?|дод\.?)\s*(\d{1,6})$/iu;
+
+const TELEGRAM_USERNAME_RE = /^[A-Za-z0-9_]{5,32}$/;
+const TELEGRAM_LINK_RE = /(?:https?:\/\/)?(?:t\.me|telegram\.me|telegram\.dog)\/([A-Za-z0-9_]{5,32})(?:\/[0-9]+)?(?:[/?#][^\s]*)?/giu;
+const TELEGRAM_TG_RE = /tg:\/\/resolve\?[^\s]*?\bdomain=([A-Za-z0-9_]{5,32})\b[^\s]*/giu;
+const TELEGRAM_MENTION_RE = /(^|[^\p{L}\p{N}_@])@([A-Za-z0-9_]{5,32})\b/gu;
+
+function normalizedCountryHint(value) {
+  const country = String(value || '').trim().toUpperCase();
+  return /^[A-Z]{2}$/.test(country) ? country : undefined;
+}
+
+function splitPhoneExtension(raw) {
+  const match = String(raw || '').match(PHONE_EXTENSION_RE);
+  if (!match) return { base: String(raw || '').trim(), extension: null };
+  return {
+    base: String(raw || '').slice(0, match.index).trim(),
+    extension: match[1] || null,
+  };
+}
+
+export function findPhoneLikeSpans(value) {
+  const text = String(value || '');
+  const spans = [];
+  for (const match of text.matchAll(PHONE_LIKE_RE)) {
+    const raw = match[0];
+    const digits = raw.replace(/\D/g, '');
+    if (digits.length < 10) continue;
+    const start = match.index ?? 0;
+    spans.push(Object.freeze({
+      start,
+      end: start + raw.length,
+      raw,
+      digits,
+    }));
+  }
+  return Object.freeze(spans);
+}
+
+export function maskPhoneLikeSpans(value, replacement = ' ') {
+  const text = String(value || '');
+  const spans = findPhoneLikeSpans(text);
+  if (!spans.length) return text;
+
+  let out = '';
+  let cursor = 0;
+  for (const span of spans) {
+    out += text.slice(cursor, span.start);
+    out += replacement;
+    cursor = span.end;
+  }
+  return out + text.slice(cursor);
+}
+
+export function parsePhoneNumbers(value, options = {}) {
+  const text = String(value || '');
+  const countryHint = normalizedCountryHint(options.countryHint);
+  const includePossible = options.includePossible === true;
+  const out = [];
+  const seen = new Set();
+
+  for (const match of text.matchAll(PHONE_CANDIDATE_RE)) {
+    const raw = match[0].trim();
+    const { base, extension } = splitPhoneExtension(raw);
+    const parsed = parsePhoneNumberFromString(base, countryHint);
+    if (!parsed) continue;
+    const valid = parsed.isValid();
+    const possible = parsed.isPossible();
+    if (!valid && !(includePossible && possible)) continue;
+
+    const key = `${parsed.number}:${extension || parsed.ext || ''}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+
+    const start = match.index ?? 0;
+    out.push(Object.freeze({
+      start,
+      end: start + match[0].length,
+      raw,
+      digits: base.replace(/\D/g, ''),
+      number: parsed.number,
+      nationalNumber: parsed.nationalNumber,
+      national: parsed.formatNational(),
+      international: parsed.formatInternational(),
+      country: parsed.country || null,
+      countryCallingCode: parsed.countryCallingCode,
+      extension: extension || parsed.ext || null,
+      valid,
+      possible,
+    }));
+  }
+
+  return Object.freeze(out);
+}
+
+export function normalizePhone(value, options = {}) {
+  return parsePhoneNumbers(value, options)[0] || null;
+}
+
+function telegramContact(username, raw, start, source) {
+  const normalized = String(username || '').replace(/^@/, '');
+  if (!TELEGRAM_USERNAME_RE.test(normalized)) return null;
+  return Object.freeze({
+    start,
+    end: start + raw.length,
+    raw,
+    username: normalized,
+    handle: `@${normalized}`,
+    url: `https://t.me/${normalized}`,
+    source,
+  });
+}
+
+/**
+ * Extract public Telegram username contacts from mentions and links.
+ * Message/channel transport parsing stays in consumers; this helper owns only
+ * reusable contact normalization.
+ */
+export function findTelegramContacts(value) {
+  const text = String(value || '');
+  const found = [];
+  const seen = new Set();
+
+  const push = (username, raw, start, source) => {
+    const contact = telegramContact(username, raw, start, source);
+    if (!contact) return;
+    const key = contact.username.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    found.push(contact);
+  };
+
+  for (const match of text.matchAll(TELEGRAM_LINK_RE)) {
+    push(match[1], match[0], match.index ?? 0, 'url');
+  }
+  for (const match of text.matchAll(TELEGRAM_TG_RE)) {
+    push(match[1], match[0], match.index ?? 0, 'tg');
+  }
+  for (const match of text.matchAll(TELEGRAM_MENTION_RE)) {
+    const prefix = match[1] || '';
+    const raw = `@${match[2]}`;
+    push(match[2], raw, (match.index ?? 0) + prefix.length, 'mention');
+  }
+
+  return Object.freeze(found.sort((a, b) => a.start - b.start));
+}
+
+export function normalizeTelegramContact(value) {
+  return findTelegramContacts(value)[0] || null;
+}

package/src/countries.js

@@ -0,0 +1,175 @@
+import { findCanonical } from './normalization.js';
+import { deepFreeze, freezeAliases } from './lexicon-core.js';
+
+const country = (code, canonical, currency, aliases) => deepFreeze({
+  code,
+  canonical,
+  type: 'country',
+  currency,
+  aliases: freezeAliases(aliases),
+});
+
+/** Canonical countries used by housing/hiring ingestion. */
+export const COUNTRIES = Object.freeze([
+  country('UZ', 'Uzbekistan', 'UZS', {
+    en: ['Uzbekistan', 'Republic of Uzbekistan'],
+    ru: ['Узбекистан', 'Республика Узбекистан'],
+    uk: ['Узбекистан', 'Республіка Узбекистан'],
+    ro: ['Uzbekistan', 'Republica Uzbekistan'],
+    uzLatn: ["O'zbekiston", "O'zbekiston Respublikasi", 'Ozbekiston'],
+    uzCyrl: ['Ўзбекистон', 'Ўзбекистон Республикаси'],
+    kk: ['Өзбекстан', 'Өзбекстан Республикасы'],
+  }),
+  country('KZ', 'Kazakhstan', 'KZT', {
+    en: ['Kazakhstan', 'Republic of Kazakhstan'],
+    ru: ['Казахстан', 'Республика Казахстан'],
+    uk: ['Казахстан', 'Республіка Казахстан'],
+    ro: ['Kazahstan', 'Republica Kazahstan', 'Kazakhstan'],
+    uzLatn: ["Qozog'iston", "Qozog'iston Respublikasi"],
+    uzCyrl: ['Қозоғистон', 'Қозоғистон Республикаси'],
+    kk: ['Қазақстан', 'Қазақстан Республикасы'],
+  }),
+  country('UA', 'Ukraine', 'UAH', {
+    en: ['Ukraine'],
+    ru: ['Украина'],
+    uk: ['Україна'],
+    ro: ['Ucraina'],
+    uzLatn: ['Ukraina'],
+    uzCyrl: ['Украина'],
+    kk: ['Украина'],
+  }),
+  country('RO', 'Romania', 'RON', {
+    en: ['Romania'],
+    ru: ['Румыния'],
+    uk: ['Румунія'],
+    ro: ['România', 'Romania'],
+    uzLatn: ['Ruminiya'],
+    uzCyrl: ['Руминия'],
+    kk: ['Румыния'],
+  }),
+  country('KG', 'Kyrgyzstan', 'KGS', {
+    en: ['Kyrgyzstan', 'Kyrgyz Republic'],
+    ru: ['Кыргызстан', 'Киргизия', 'Кыргызская Республика'],
+    uk: ['Киргизстан', 'Киргизька Республіка'],
+    ro: ['Kârgâzstan', 'Kyrgyzstan'],
+    uzLatn: ["Qirg'iziston"],
+    uzCyrl: ['Қирғизистон'],
+    kk: ['Қырғызстан', 'Қырғыз Республикасы'],
+  }),
+  country('GE', 'Georgia', 'GEL', {
+    en: ['Georgia'],
+    ru: ['Грузия'],
+    uk: ['Грузія'],
+    ro: ['Georgia'],
+  }),
+  country('AZ', 'Azerbaijan', 'AZN', {
+    en: ['Azerbaijan'],
+    ru: ['Азербайджан'],
+    uk: ['Азербайджан'],
+    ro: ['Azerbaidjan'],
+  }),
+  country('AM', 'Armenia', 'AMD', {
+    en: ['Armenia'],
+    ru: ['Армения'],
+    uk: ['Вірменія'],
+    ro: ['Armenia'],
+  }),
+  country('MD', 'Moldova', 'MDL', {
+    en: ['Moldova', 'Republic of Moldova'],
+    ru: ['Молдова'],
+    uk: ['Молдова'],
+    ro: ['Moldova', 'Republica Moldova'],
+  }),
+  country('TJ', 'Tajikistan', 'TJS', {
+    en: ['Tajikistan'],
+    ru: ['Таджикистан'],
+    uk: ['Таджикистан'],
+    ro: ['Tadjikistan'],
+  }),
+  country('TM', 'Turkmenistan', 'TMT', {
+    en: ['Turkmenistan'],
+    ru: ['Туркменистан'],
+    uk: ['Туркменістан'],
+    ro: ['Turkmenistan'],
+  }),
+  country('PL', 'Poland', 'PLN', {
+    en: ['Poland'],
+    ru: ['Польша'],
+    uk: ['Польща'],
+    ro: ['Polonia'],
+    all: ['Polska'],
+  }),
+  country('DE', 'Germany', 'EUR', {
+    en: ['Germany'],
+    ru: ['Германия'],
+    uk: ['Німеччина'],
+    ro: ['Germania'],
+    all: ['Deutschland'],
+  }),
+  country('GB', 'United Kingdom', 'GBP', {
+    en: ['United Kingdom', 'UK', 'Great Britain', 'Britain', 'England'],
+    ru: ['Великобритания', 'Британия', 'Англия'],
+    uk: ['Велика Британія', 'Британія', 'Англія'],
+    ro: ['Regatul Unit', 'Marea Britanie'],
+  }),
+  country('US', 'United States', 'USD', {
+    en: ['United States', 'United States of America', 'USA', 'U.S.', 'US'],
+    ru: ['США', 'Соединенные Штаты', 'Соединённые Штаты'],
+    uk: ['США', 'Сполучені Штати'],
+    ro: ['Statele Unite', 'SUA'],
+  }),
+  country('CA', 'Canada', 'CAD', {
+    en: ['Canada'],
+    ru: ['Канада'],
+    uk: ['Канада'],
+    ro: ['Canada'],
+  }),
+  country('CN', 'China', 'CNY', {
+    en: ['China', "People's Republic of China", 'PRC'],
+    ru: ['Китай'],
+    uk: ['Китай'],
+    ro: ['China'],
+    all: ['中国', '中华人民共和国'],
+  }),
+  country('JP', 'Japan', 'JPY', {
+    en: ['Japan'],
+    ru: ['Япония'],
+    uk: ['Японія'],
+    ro: ['Japonia'],
+    all: ['日本'],
+  }),
+  country('KR', 'South Korea', 'KRW', {
+    en: ['South Korea', 'Republic of Korea', 'Korea'],
+    ru: ['Южная Корея', 'Корея'],
+    uk: ['Південна Корея', 'Корея'],
+    ro: ['Coreea de Sud', 'Coreea'],
+    all: ['대한민국', '한국'],
+  }),
+  country('TW', 'Taiwan', 'TWD', {
+    en: ['Taiwan'],
+    ru: ['Тайвань'],
+    uk: ['Тайвань'],
+    ro: ['Taiwan'],
+    all: ['臺灣', '台灣'],
+  }),
+]);
+
+const COUNTRY_BY_CODE = new Map(COUNTRIES.map((item) => [item.code, item]));
+
+export function canonicalCountry(value) {
+  if (!value) return null;
+  const direct = COUNTRY_BY_CODE.get(String(value).trim().toUpperCase());
+  if (direct) return direct.canonical;
+  return findCanonical(value, COUNTRIES)?.canonical || null;
+}
+
+export function canonicalCountryCode(value) {
+  if (!value) return null;
+  const direct = COUNTRY_BY_CODE.get(String(value).trim().toUpperCase());
+  if (direct) return direct.code;
+  return findCanonical(value, COUNTRIES)?.code || null;
+}
+
+export function countryByCode(value) {
+  return COUNTRY_BY_CODE.get(String(value || '').trim().toUpperCase()) || null;
+}

package/src/country-context.d.ts

@@ -0,0 +1,10 @@
+export type CountryContext = Readonly<{
+  code: string;
+  country: string;
+  currency: string | null;
+  phoneCountry: string;
+}>;
+
+export function countryContext(value: unknown): CountryContext | null;
+export function countryCurrency(value: unknown): string | null;
+export function countryPhoneHint(value: unknown): string | null;

package/src/country-context.js

@@ -0,0 +1,22 @@
+import { canonicalCountryCode, countryByCode } from './countries.js';
+
+export function countryContext(value) {
+  const code = canonicalCountryCode(value);
+  if (!code) return null;
+  const country = countryByCode(code);
+  if (!country) return null;
+  return Object.freeze({
+    code: country.code,
+    country: country.canonical,
+    currency: country.currency || null,
+    phoneCountry: country.code,
+  });
+}
+
+export function countryCurrency(value) {
+  return countryContext(value)?.currency || null;
+}
+
+export function countryPhoneHint(value) {
+  return countryContext(value)?.phoneCountry || null;
+}

package/src/currency.d.ts

@@ -0,0 +1,14 @@
+export type CurrencyDisplay = Readonly<{
+  code: string;
+  symbol: string;
+  name: string;
+}>;
+
+export const CURRENCY_TERMS: readonly import('../index.d.ts').LexiconEntity[];
+export const CURRENCY_SYMBOL_CANDIDATES: Readonly<Record<string, readonly string[]>>;
+export function moneyCurrencyCandidatesFromText(value: unknown): readonly string[];
+export function moneyCurrencyFromText(value: unknown, fallbackCurrency?: string | null): string | null;
+export function moneyCurrencyPattern(): string;
+export function currencyDisplay(code: unknown, locale?: string): CurrencyDisplay | null;
+export function currencySymbol(code: unknown, locale?: string): string | null;
+export function currencyName(code: unknown, locale?: string): string | null;

package/src/currency.js

@@ -0,0 +1,66 @@
+import { CURRENCY_TERMS } from './money-lexicon.js';
+
+export {
+  CURRENCY_SYMBOL_CANDIDATES,
+  CURRENCY_TERMS,
+} from './money-lexicon.js';
+
+export {
+  moneyCurrencyCandidatesFromText,
+  moneyCurrencyFromText,
+  moneyCurrencyPattern,
+} from './money-core.js';
+
+const LOCALE_ALIASES = Object.freeze({
+  uzLatn: 'uz-Latn',
+  uzCyrl: 'uz-Cyrl',
+  kk: 'kk',
+  uk: 'uk',
+  ro: 'ro',
+  ru: 'ru',
+  en: 'en',
+});
+
+function normalizedLocale(locale) {
+  const raw = String(locale || 'en').trim();
+  return LOCALE_ALIASES[raw] || raw || 'en';
+}
+
+function supportedCurrency(code) {
+  const normalized = String(code || '').trim().toUpperCase();
+  return CURRENCY_TERMS.some((entry) => entry.canonical === normalized) ? normalized : null;
+}
+
+function currencyPart(code, locale, currencyDisplay) {
+  try {
+    const parts = new Intl.NumberFormat(normalizedLocale(locale), {
+      style: 'currency',
+      currency: code,
+      currencyDisplay,
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 0,
+    }).formatToParts(1);
+    return parts.find((part) => part.type === 'currency')?.value || code;
+  } catch {
+    return code;
+  }
+}
+
+/** Localized display metadata without a second hand-maintained currency catalog. */
+export function currencyDisplay(code, locale = 'en') {
+  const canonical = supportedCurrency(code);
+  if (!canonical) return null;
+  return Object.freeze({
+    code: canonical,
+    symbol: currencyPart(canonical, locale, 'narrowSymbol'),
+    name: currencyPart(canonical, locale, 'name'),
+  });
+}
+
+export function currencySymbol(code, locale = 'en') {
+  return currencyDisplay(code, locale)?.symbol || null;
+}
+
+export function currencyName(code, locale = 'en') {
+  return currencyDisplay(code, locale)?.name || null;
+}

package/src/geo.js

@@ -0,0 +1,169 @@
+import { aliasesToRegex, findCanonical } from './normalization.js';
+import { deepFreeze, lexiconEntity } from './lexicon-core.js';
+
+const entity = (canonical, aliases, extra = {}) => lexiconEntity(canonical, aliases, { type: extra.type || (extra.country ? 'city' : 'district'), ...(!extra.country ? { country: 'UZ', city: 'Tashkent' } : {}), ...extra });
+
+export { UZ_CITIES, KZ_CITIES } from './geography-central-asia.js';
+
+// Compatibility for the historical ./geo subpath. Canonical city ownership lives in geography.js.
+export { CITIES, CITIES_BY_COUNTRY, canonicalCity } from './geography.js';
+
+export const TASHKENT_DISTRICTS = Object.freeze([
+  entity('Almazar', { uzLatn: ['Olmazor', 'Olmazor tumani'], uzCyrl: ['Олмазор', 'Олмазор тумани'], ru: ['Алмазар', 'Алмазарский район'], en: ['Almazar', 'Olmazor district'] }),
+  entity('Bektemir', { uzLatn: ['Bektemir', 'Bektemir tumani'], uzCyrl: ['Бектемир', 'Бектемир тумани'], ru: ['Бектемир', 'Бектемирский район'], en: ['Bektemir'] }),
+  entity('Mirobod', { uzLatn: ['Mirobod', 'Mirobod tumani'], uzCyrl: ['Миробод', 'Миробод тумани'], ru: ['Мирабад', 'Мирабадский район'], en: ['Mirobod', 'Mirabad'] }),
+  entity('Mirzo Ulugbek', { uzLatn: ["Mirzo Ulug'bek", 'Mirzo Ulugbek', "Mirzo Ulug'bek tumani"], uzCyrl: ['Мирзо Улуғбек', 'Мирзо Улуғбек тумани'], ru: ['Мирзо-Улугбекский район', 'Мирзо Улугбек'], en: ['Mirzo Ulugbek', 'Mirzo Ulughbek'] }),
+  entity('Sergeli', { uzLatn: ['Sergeli', 'Sergeli tumani'], uzCyrl: ['Сергели', 'Сергели тумани'], ru: ['Сергелийский район', 'Сергели'], en: ['Sergeli'] }),
+  entity('Uchtepa', { uzLatn: ['Uchtepa', 'Uchtepa tumani'], uzCyrl: ['Учтепа', 'Учтепа тумани'], ru: ['Учтепинский район', 'Учтепа'], en: ['Uchtepa'] }),
+  entity('Chilanzar', { uzLatn: ['Chilonzor', 'Chilonzor tumani', 'Chilanzar'], uzCyrl: ['Чилонзор', 'Чилонзор тумани'], ru: ['Чиланзар', 'Чиланзарский район'], en: ['Chilanzar', 'Chilonzor'] }),
+  entity('Shaykhantahur', { uzLatn: ['Shayxontohur', 'Shayxontohur tumani', 'Shaykhantahur'], uzCyrl: ['Шайхонтоҳур', 'Шайхонтоҳур тумани', 'Шайхонтохур'], ru: ['Шайхантахур', 'Шайхантахурский район'], en: ['Shaykhantahur', 'Shayxontohur'] }),
+  entity('Yunusabad', { uzLatn: ['Yunusobod', 'Yunusobod tumani', 'Yunusabad'], uzCyrl: ['Юнусобод', 'Юнусобод тумани'], ru: ['Юнусабад', 'Юнусабадский район'], en: ['Yunusabad', 'Yunusobod'] }),
+  entity('Yakkasaray', { uzLatn: ['Yakkasaroy', 'Yakkasaroy tumani', 'Yakkasaray'], uzCyrl: ['Яккасарой', 'Яккасарой тумани'], ru: ['Яккасарай', 'Яккасарайский район'], en: ['Yakkasaray', 'Yakkasaroy'] }),
+  entity('Yangihayot', { uzLatn: ['Yangihayot', 'Yangihayot tumani'], uzCyrl: ['Янгиҳаёт', 'Янгиҳаёт тумани', 'Янгихаёт'], ru: ['Янгихаётский район', 'Янгихаёт'], en: ['Yangihayot'] }),
+  entity('Yashnobod', { uzLatn: ['Yashnobod', 'Yashnobod tumani'], uzCyrl: ['Яшнобод', 'Яшнобод тумани'], ru: ['Яшнабад', 'Яшнабадский район'], en: ['Yashnobod', 'Yashnabad'] }),
+]);
+
+export function canonicalTashkentDistrict(value) {
+  return findCanonical(value, TASHKENT_DISTRICTS, { partial: true })?.canonical || null;
+}
+
+function station(name, ru, en, line, aliases = []) {
+  const allAliases = [...new Set([name, ru, en, ...aliases])];
+  return deepFreeze({
+    canonical: name,
+    name,
+    type: 'metro',
+    country: 'UZ',
+    city: 'Tashkent',
+    line,
+    labels: { ru, en },
+    aliases: allAliases,
+    re: aliasesToRegex(allAliases),
+  });
+}
+
+export const TASHKENT_METRO = Object.freeze([
+  station('Buyuk Ipak Yoli', 'Буюк Ипак Йули', 'Buyuk Ipak Yoli', 'chilonzor', ['Buyuk Ipak Yuli', "Buyuk Ipak Yo'li", 'Buyuk Ipak Yo‘li', 'Buyuk Ipak Yoʻli', 'Буюк Ипак Йўли', 'БИЙ', 'Максим Горький', 'Максима Горького', 'Горького', 'Maxim Gorky', 'Maksim Gorkiy']),
+  station('Pushkin', 'Пушкин', 'Pushkin', 'chilonzor'),
+  station('Hamid Olimjon', 'Хамид Алимджан', 'Hamid Olimjon', 'chilonzor', ['Хамид Олимжон', 'Hamid Alimjan', 'Hamid Alimjon']),
+  station('Amir Temur Xiyoboni', 'Амир Темур Хиёбони', 'Amir Temur Xiyoboni', 'chilonzor', ['Сквер', 'Amir Timur Square', 'Amir Temur']),
+  station('Mustaqillik Maydoni', 'Мустакиллик майдони', 'Mustaqillik Maydoni', 'chilonzor', ['Мустақиллик майдони', 'Площадь Независимости', 'Independence Square']),
+  station('Paxtakor', 'Пахтакор', 'Paxtakor', 'chilonzor', ['Pakhtakor']),
+  station('Xalqlar Dostligi', 'Халклар Дустлиги', 'Xalqlar Dostligi', 'chilonzor', ["Xalqlar Do'stligi", 'Xalqlar Do‘stligi', 'Xalqlar Doʻstligi', 'Халклар Дўстлиги', 'Халқлар Дўстлиги', 'Дружба народов', 'Bunyodkor', 'Бунёдкор']),
+  station('Milliy Bog', 'Миллий Бог', 'Milliy Bog', 'chilonzor', ["Milliy Bog'", 'Milliy Bog‘', 'Milliy Bogʻ', 'Миллий Боғ', 'Yoshlik', 'Ёшлик']),
+  station('Novza', 'Новза', 'Novza', 'chilonzor', ['Хамза', 'Hamza', 'Hamza metro', 'метро Хамза']),
+  station('Mirzo Ulugbek', 'Мирзо Улугбек', 'Mirzo Ulugbek', 'chilonzor', ["Mirzo Ulug'bek", 'Mirzo Ulug‘bek', 'Mirzo Ulugʻbek', 'Мирзо Улуғбек', 'М. Улугбек', 'метро М. Улугбек']),
+  station('Chilonzor', 'Чиланзар', 'Chilonzor', 'chilonzor', ['Чилонзор', 'Chilanzar', 'метро Чиланзар', 'Chilonzor metro']),
+  station('Olmazor', 'Алмазар', 'Olmazor', 'chilonzor', ['Олмазор', 'Almazar', 'Сабир Рахимов', 'Собир Рахимов', 'Sobir Raximov', 'Sabir Rakhimov']),
+  station('Choshtepa', 'Чаштепа', 'Choshtepa', 'chilonzor', ['Чоштепа']),
+  station('Ozgarish', 'Узгариш', 'Ozgarish', 'chilonzor', ["O'zgarish", 'O‘zgarish', 'Oʻzgarish', 'Ўзгариш']),
+  station('Sergeli', 'Сергели', 'Sergeli', 'chilonzor', ['метро Сергели', 'Sergeli metro']),
+  station('Yangihayot', 'Янгихаёт', 'Yangihayot', 'chilonzor', ['Янгиҳаёт', 'Янгихаят']),
+  station('Chinor', 'Чинар', 'Chinor', 'chilonzor', ['Чинор']),
+  station('Beruniy', 'Беруни', 'Beruniy', 'ozbekiston', ['Beruni']),
+  station('Tinchlik', 'Тинчлик', 'Tinchlik', 'ozbekiston'),
+  station('Chorsu', 'Чорсу', 'Chorsu', 'ozbekiston'),
+  station('Gafur Gulom', 'Гафур Гулям', 'Gafur Gulom', 'ozbekiston', ["G'afur G'ulom", 'G‘afur G‘ulom', 'Gʻafur Gʻulom', 'Ғафур Ғулом']),
+  station('Alisher Navoi', 'Алишер Навои', 'Alisher Navoi', 'ozbekiston', ['Alisher Navoiy', 'Алишер Навоий']),
+  station('Ozbekiston', 'Узбекистан', 'Ozbekiston', 'ozbekiston', ["O'zbekiston", 'O‘zbekiston', 'Oʻzbekiston', 'Ўзбекистон']),
+  station('Kosmonavtlar', 'Космонавтлар', 'Kosmonavtlar', 'ozbekiston', ['Космонавты']),
+  station('Oybek', 'Ойбек', 'Oybek', 'ozbekiston'),
+  station('Toshkent', 'Ташкент', 'Toshkent', 'ozbekiston', ['Тошкент', 'Tashkent metro', 'метро Ташкент']),
+  station('Mashinasozlar', 'Машинасозлар', 'Mashinasozlar', 'ozbekiston'),
+  station('Dostlik', 'Дустлик', 'Dostlik', 'ozbekiston', ["Do'stlik", 'Do‘stlik', 'Doʻstlik', 'Дўстлик']),
+  station('Turkiston', 'Туркистон', 'Turkiston', 'yunusobod', ['Туркестан']),
+  station('Yunusobod', 'Юнусабад', 'Yunusobod', 'yunusobod', ['Юнусобод', 'Yunusabad', 'метро Юнусабад', 'Yunusobod metro']),
+  station('Shahriston', 'Шахристан', 'Shahriston', 'yunusobod', ['Шахристон']),
+  station('Bodomzor', 'Бадамзар', 'Bodomzor', 'yunusobod', ['Бодомзор']),
+  station('Minor', 'Минор', 'Minor', 'yunusobod'),
+  station('Abdulla Qodiriy', 'Абдулла Кадыри', 'Abdulla Qodiriy', 'yunusobod', ['Абдулла Кодири', 'Абдулла Қодирий', 'Abdulla Kadiri']),
+  station('Yunus Rajabiy', 'Юнус Раджаби', 'Yunus Rajabiy', 'yunusobod', ['Yunus Rajabi']),
+  station('Ming Orik', 'Мингурик', 'Ming Orik', 'yunusobod', ["Ming O'rik", 'Ming O‘rik', 'Ming Oʻrik', 'Минг Урик', 'Мингўрик']),
+  station('Texnopark', 'Технопарк', 'Texnopark', 'circle', ['Technopark']),
+  station('Yashnobod', 'Яшнабад', 'Yashnobod', 'circle', ['Яшнобод']),
+  station('Tuzel', 'Тузель', 'Tuzel', 'circle'),
+  station('Olmos', 'Алмас', 'Olmos', 'circle', ['Олмос']),
+  station('Rohat', 'Рохат', 'Rohat', 'circle'),
+  station('Yangiobod', 'Янгиабад', 'Yangiobod', 'circle', ['Янгиобод']),
+  station('Qoyliq', 'Куйлюк', 'Qoyliq', 'circle', ['Qo‘yliq', "Qo'yliq", 'Qoʻyliq', 'Қўйлиқ', 'Куйлик', 'Куйлюк метро']),
+  station('Matonat', 'Матонат', 'Matonat', 'circle'),
+  station('Qiyot', 'Кият', 'Qiyot', 'circle', ['Киёт', 'Қиёт']),
+  station('Tolariq', 'Толарык', 'Tolariq', 'circle', ['Толарик', 'Толариқ']),
+  station('Xonobod', 'Хонабад', 'Xonobod', 'circle', ['Ханабад']),
+  station('Quruvchilar', 'Курувчилар', 'Quruvchilar', 'circle', ['Қурувчилар']),
+  station('Turon', 'Туран', 'Turon', 'circle', ['Турон']),
+  station('Qipchoq', 'Кипчак', 'Qipchoq', 'circle', ['Қипчоқ']),
+]);
+
+const TASHKENT_METRO_BY_NAME = new Map(TASHKENT_METRO.map((item) => [item.name, item]));
+
+export function tashkentMetroStation(value) {
+  if (!value) return null;
+  const direct = TASHKENT_METRO_BY_NAME.get(String(value));
+  if (direct) return direct;
+  return TASHKENT_METRO.find((item) => item.re.test(String(value))) || null;
+}
+
+export function canonicalTashkentMetro(value) {
+  return tashkentMetroStation(value)?.canonical || null;
+}
+
+export function tashkentMetroLabels() {
+  return Object.fromEntries(TASHKENT_METRO.map((item) => [item.name, { ru: item.labels.ru, en: item.labels.en, line: item.line }]));
+}
+
+const area = (name, aliases) => deepFreeze({ canonical: name, name, type: 'local_area', country: 'UZ', city: 'Tashkent', aliases });
+
+export const TASHKENT_AREAS = Object.freeze({
+  Almazar: Object.freeze([
+    area('Sebzar', ['себзар', 'sebzar', 'ц 17', 'ц 18', 'c 17', 'c 18']),
+    area('Karakamysh-1/2', ['каракамыш 1 2', 'қорақамиш 1 2', 'qoraqamish 1 2', 'karakamish 1 2']),
+    area('Karakamysh-2/3', ['каракамыш 2 3', 'қорақамиш 2 3', 'qoraqamish 2 3', 'karakamish 2 3']),
+    area('Karakamysh-2/4', ['каракамыш 2 4', 'қорақамиш 2 4', 'qoraqamish 2 4', 'karakamish 2 4']),
+    area('Karakamysh-2/5', ['каракамыш 2 5', 'қорақамиш 2 5', 'qoraqamish 2 5', 'karakamish 2 5']),
+    area('Olympia', ['олимпия', 'olimpiya', 'olympia']), area('Vuzgorodok', ['вузгородок', 'вуз городок', 'vuzgorodok']),
+    area('Medgorodok', ['медгородок', 'мед городок', 'medgorodok']), area('Takhtapul', ['тахтапуль', 'тахтапул', 'taxtapul', 'takhtapul']),
+    area('Chimbay', ['чимбай', 'chimboy', 'chimbay']),
+  ]),
+  Mirobod: Object.freeze([
+    area('Hospitalny', ['госпитальный', 'госпиталка', 'hospitalny']), area('Lolazor', ['лолазор', 'lolazor']),
+    area('Oltinkul', ['алтынкуль', 'олтинкул', 'олтинкўл', 'oltinkol', 'oltinkul']), area('Movarounnahr', ['мавераннахр', 'мовароуннахр', 'movarounnahr']),
+  ]),
+  'Mirzo Ulugbek': Object.freeze([
+    area('Buyuk Ipak Yuli', ['буюк ипак йули', 'буюк ипак йўли', 'buyuk ipak yuli', "buyuk ipak yo'li", 'ц 1', 'c 1']),
+    area('Alay', ['олой', 'алайский', 'алайск', 'alay', 'ц 2', 'c 2']),
+    ...[1, 2, 3, 4, 6].map((n) => area(`Karasu-${n}`, [`карасу ${n}`, `қорасув ${n}`, `qorasuv ${n}`, `karasu ${n}`])),
+    ...[1, 2, 3, 4].map((n) => area(`TTZ-${n}`, [`ттз ${n}`, `ttz ${n}`])),
+    area('Yalangach', ['ялангач', 'yalangach', "yalang'och"]), area('Feruza', ['феруза', 'feruza']), area('Geofizika', ['геофизика', 'поселок геофизиков', 'geofizika']),
+  ]),
+  Sergeli: Object.freeze([
+    area('Sergeli Car Bazaar', ['сергели машинный базар', 'сергели машина бозор', 'sergeli moshina bozor', 'sergile moshena bozor', 'sergele moshina bozor']),
+    area('Yangi Sergeli', ['янги сергели', 'yangi sergeli']), area('Stroygorod', ['стройгород', 'stroygorod']),
+  ]),
+  Chilanzar: Object.freeze([
+    area('Nakkoshlik', ['наккошлык', 'наққошлик', 'naqqoshlik']), area('Al-Khorezmi-1', ['аль хорезми 1', 'ал хорезми 1', 'al xorazmiy 1', 'al khorezmi 1']),
+  ]),
+  Shaykhantahur: Object.freeze([
+    area('Labzak', ['лабзак', 'labzak', 'ц 13', 'c 13']), area('Khadra', ['хадра', 'xadra', 'khadra', 'ц 14', 'c 14']),
+    area('Jangoh', ['джангох', 'жангох', 'jangoh', 'ц 15', 'c 15']), area('Karatash', ['караташ', 'қоратош', 'qoratosh', 'karatash']),
+    area('Chorsu', ['чорсу', 'chorsu']), area('Beshagach', ['бешагач', "beshyog'och", 'beshagach']), area('Beltepa', ['белтепа', 'beltepa']),
+  ]),
+  Yunusabad: Object.freeze([
+    area('Kashgar', ['кашгар', 'қашқар', 'qashqar', 'kashgar', 'ц 4', 'c 4']), area('Kiyot', ['киёт', 'қиёт', 'qiyot', 'kiyot', 'ц 5', 'c 5']),
+    area('Minor', ['минор', 'minor', 'ц 6', 'c 6']), area('TashGRES', ['ташгрэс', 'tashgres']),
+  ]),
+  Yakkasaray: Object.freeze([
+    area('Bashlyk', ['башлык', 'бошлиқ', 'boshliq', 'bashlyk']), area('Kushbegi', ['кушбеги', 'қушбеги', 'qushbegi', 'kushbegi']),
+    area('Rakat', ['ракат', 'rakat']), area('Rakatboshi', ['ракатбоши', 'rakatboshi']),
+  ]),
+  Yangihayot: Object.freeze([
+    area('Uzgarish', ['узгарыш', 'ўзгариш', "o'zgarish", 'uzgarish']), area('Dustlik-1', ['дустлик 1', 'дўстлик 1', "do'stlik 1", 'dustlik 1']),
+    area('Dustlik-2', ['дустлик 2', 'дўстлик 2', "do'stlik 2", 'dustlik 2']), area('Yangi Choshtepa', ['янги чоштепа', 'yangi choshtepa']), area('Sputnik', ['спутник', 'йўлдош', "yo'ldosh", 'yoldosh']),
+  ]),
+  Yashnobod: Object.freeze([
+    area('Kuylyuk Center', ['куйлюк центр', 'куйлик центр', "qo'yliq markaz", 'kuylyuk center']),
+    ...[1, 2, 3, 4].map((n) => area(`Aviasozlar-${n}`, [`авиасозлар ${n}`, `городок авиастроителей ${n}`, `aviasozlar ${n}`])),
+    ...[1, 2, 3, 4].map((n) => area(`Tuzel-${n}`, [`тузель ${n}`, `tuzel ${n}`])),
+    area('Tashselmash', ['ташсельмаш', 'tashselmash']), area('Alimkent', ['алимкент', 'olimkent', 'alimkent']), area('Shohimardon', ['шохимардон', 'shohimardon']),
+  ]),
+});