@whiteslove/parsing-lexicon 0.10.2 → 0.10.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whiteslove/parsing-lexicon",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "Shared deterministic multilingual parsing lexicon for WhitesLove housing and hiring services",
   "repository": {
     "type": "git",

package/src/country-context.d.ts

@@ -8,3 +8,4 @@ export type CountryContext = Readonly<{
 export function countryContext(value: unknown): CountryContext | null;
 export function countryCurrency(value: unknown): string | null;
 export function countryPhoneHint(value: unknown): string | null;
+export function countryCodeForCity(city: unknown): string;

package/src/country-context.js

@@ -1,4 +1,6 @@
 import { canonicalCountryCode, countryByCode } from './countries.js';
+import { CITIES } from './geography.js';
+import { findCanonical } from './normalization.js';
 
 export function countryContext(value) {
   const code = canonicalCountryCode(value);
@@ -20,3 +22,12 @@ export function countryCurrency(value) {
 export function countryPhoneHint(value) {
   return countryContext(value)?.phoneCountry || null;
 }
+
+// A context that names only the city ("Tashkent") still fixes the country and
+// with it the default currency. Without this a Tashkent listing parsed with
+// `{ city }` alone had no fallback currency and consumers filled the gap with
+// their own default (KZT), mislabelling so'm prices.
+export function countryCodeForCity(city) {
+  if (!city) return '';
+  return findCanonical(String(city), CITIES)?.country || '';
+}

package/src/housing-commercial.js

@@ -50,7 +50,7 @@ export function looksParkingOnly(value) {
 // classifyTelegramAgency in whiteslove.me-backend-platform's
 // apps/flats/src/scrapers/telegram.js). If you're tempted to merge these,
 // check that call site's expectations first.
-const DIRECT_OWNER_RE = /(?:без\s+(?:макл(?:ер[а-яё]*)?|посредник[а-яё]*|ри[еэ]?лтор[а-яё]*|агент[а-яё]*)|от\s+(?:собственник[а-яё]*|хозяин[а-яё]*)|від\s+(?:власник[а-яіїґ]*|власниц[яії][а-яіїґ]*|господар[а-яіїґ]*)|без\s+(?:посередник[а-яіїґ]*|рі[єе]лтор[а-яіїґ]*|агент[а-яіїґ]*)|прямо\s+від\s+(?:власник[а-яіїґ]*|власниц[яії][а-яіїґ]*|господар[а-яіїґ]*)|(?:власник|власниця)\s+(?:зда[єе]|прода[єе])|no\s+(?:agency|broker|realtor|agent)|owner\s+direct|direct\s+from\s+(?:owner|landlord)|f(?:ă|a)r(?:ă|a)\s+(?:agen(?:ț|t)ie|intermediar\w*)|direct\s+(?:de\s+la\s+)?proprietar|makler\s*[- ]?siz|maklersiz|bez\s*makler(?:a|ov)?|bezmakler(?:a|ov)?|vositachi\s*[- ]?siz|vositachisiz|egasidan|uy\s+egasidan|делдалсыз|делдал\s*жоқ|иесінен|үй\s+иесінен)/iu;
+const DIRECT_OWNER_RE = /(?:(?:makler|vositachi)(?:lar)?\s+bilan\s+ishla(?:n)?may\p{L}*|(?:makler|vositachi)(?:lar)?\s+(?:bezovta|bezota)\s+qilma\p{L}*|(?:с\s+)?(?:ри[еэ]лтор|маклер|агент(?:ств)?|посредник)\p{L}*\s+(?:просьба\s+)?не\s+(?:беспокоить|работа\p{L}*|звонить)|без\s+(?:макл(?:ер[а-яё]*)?|посредник[а-яё]*|ри[еэ]?лтор[а-яё]*|агент[а-яё]*)|от\s+(?:собственник[а-яё]*|хозяин[а-яё]*)|від\s+(?:власник[а-яіїґ]*|власниц[яії][а-яіїґ]*|господар[а-яіїґ]*)|без\s+(?:посередник[а-яіїґ]*|рі[єе]лтор[а-яіїґ]*|агент[а-яіїґ]*)|прямо\s+від\s+(?:власник[а-яіїґ]*|власниц[яії][а-яіїґ]*|господар[а-яіїґ]*)|(?:власник|власниця)\s+(?:зда[єе]|прода[єе])|no\s+(?:agency|broker|realtor|agent)|owner\s+direct|direct\s+from\s+(?:owner|landlord)|f(?:ă|a)r(?:ă|a)\s+(?:agen(?:ț|t)ie|intermediar\w*)|direct\s+(?:de\s+la\s+)?proprietar|makler\s*[- ]?siz|maklersiz|bez\s*makler(?:a|ov)?|bezmakler(?:a|ov)?|vositachi\s*[- ]?siz|vositachisiz|egasidan|uy\s+egasidan|делдалсыз|делдал\s*жоқ|иесінен|үй\s+иесінен)/iu;
 
 // Cross-language "no commission" signals. Direct-owner language implies zero
 // commission even without an explicit "no commission" phrase.

package/src/housing-listing-enrichment.js

@@ -33,7 +33,7 @@ const APPLIANCE_PATTERNS = Object.freeze([
 const FIRST_RENT_UZ_RE = /(?:hali\s+hech\s+kim\s+(?:yashamagan|turmagan)|ҳали\s+ҳеч\s+ким\s+(?:яшамаган|турмаган))/iu;
 const LANDLORD_PRESENT_RE = /(?:xozaykali|hojaykali|xo['’]?jaykali|с\s+хозяйк(?:ой|ой\s+в\s+квартире)|хозяйк\p{L}*\s+(?:жив[её]т|прожива\p{L}*)|with\s+(?:the\s+)?(?:landlord|owner)\s+(?:present|living\s+in)|cu\s+proprietar(?:ul)?\s+în\s+cas(?:ă|a)|үй\s*иесі\s+(?:тұрады|бірге\s+тұрады))/iu;
 const STUDENT_RE = /(?:studentlar\s+uchun|talabalar\s+uchun|(?<![\p{L}\p{N}_])(?:student(?:ka)?|talaba)(?:lar)?(?:ga)?\s+(?:qiz|yigit|o['’ʻʼ‘`]?g['’ʻʼ‘`]?il\s+bola|bola)(?:lar)?(?:ga)?(?![\p{L}\p{N}_])|(?<![\p{L}\p{N}_])(?:studentlar|talabalar)ga(?![\p{L}\p{N}_])|студент(?:ам|ы|ок|ов)?\s+(?:можно|для)|для\s+студент|students?\s+(?:only|welcome)|for\s+students|pentru\s+studen[țt]i|studen[țt]i(?:lor)?|студенттерге|студенттер\s+үшін|(?:oila|oyla)(?:ga|lar|li)?\s+yoki\s+\d{1,2}\s+ta\s+bola(?:lar)?(?:ga)?\s+(?:ijara(?:ga)?\s+)?(?:beril|topshiril))/iu;
-const NO_BROKER_RE = /(?:bez\s*makler|maklersiz|vositachisiz|без\s+(?:маклер|посредник|риелтор|риэлтор|комисси)|no\s+(?:broker|agent|commission|agency\s+fee)|f[ăa]r[ăa]\s+(?:comision|agen[țt]ie|intermediari)|делдалсыз|комиссиясыз)/iu;
+const NO_BROKER_RE = /(?:(?:makler|vositachi)(?:lar)?\s+bilan\s+ishla(?:n)?may\p{L}*|(?:makler|vositachi)(?:lar)?\s+(?:bezovta|bezota)\s+qilma\p{L}*|(?:с\s+)?(?:ри[еэ]лтор|маклер|агент(?:ств)?|посредник)\p{L}*\s+(?:просьба\s+)?не\s+(?:беспокоить|работа\p{L}*|звонить)|bez\s*makler|maklersiz|vositachisiz|без\s+(?:маклер|посредник|риелтор|риэлтор|комисси)|no\s+(?:broker|agent|commission|agency\s+fee)|f[ăa]r[ăa]\s+(?:comision|agen[țt]ie|intermediari)|делдалсыз|комиссиясыз)/iu;
 const BROKER_RE = /(?:makler|vositachi|макл(?:ер[а-яё]*)?|ри[еэ]лтор[а-яё]*|агентств[а-яё]*|комисси[а-яё]*|broker|realtor|commission|comision(?:ul)?|agen[țt]ie|delda[lл]\p{L}*|делдал\p{L}*)/iu;
 const MEN_RE = /(?:o['’ʻʼ‘`]?g['’ʻʼ‘`]?il\s+bola(?:lar)?(?:ga)?|ogil\s+bola(?:lar)?(?:ga)?|sherik\s+bola|эркак(?:лар)?|erkak(?:lar)?(?:ga)?|только\s+(?:мужчин|парн)|\bmen\s+only\b|b[ăa]rba[țt]i(?:lor)?|b[ăa]ie[țt]i(?:lor)?|жігіттерге|жігіттер(?:ге)?|хлопц(?:ям|і|ів)?|чоловік(?:ам|и)?)/iu;
 const WOMEN_RE = /(?:qiz(?:lar)?(?:ga)?|ayol(?:lar)?(?:ga|ni)?|киз(?:лар)?(?:га)?|аёл(?:лар)?(?:га|ни)?|девушк\p{L}*|женщин\p{L}*|girls?\s+only|women\s+only|fete(?:lor)?|femei(?:lor)?|қыздарға|қыздар(?:ға)?|дівчат(?:ам|а|ок)?|жінк(?:ам|и)?)/iu;

package/src/housing-listing-fields.js

@@ -10,7 +10,7 @@ const bool = (text, positive, negative = null) => {
 };
 
 const REFRIGERATOR_RE = /(?:холодильник\p{L}*|haladelnik|xolodilnik|muzlatgich|refrigerator|fridge)/iu;
-const WASHING_MACHINE_RE = /(?:кир\s*машин\p{L}*|кирмошин\p{L}*|стиральн\p{L}*\s+машин\p{L}*|washing\s+machine|kir\s*moshina|kirmoshina|kir\s*yuvish\s+mashin\p{L}*)/iu;
+const WASHING_MACHINE_RE = /(?:кир\s*машин\p{L}*|кирмошин\p{L}*|стиральн\p{L}*\s+машин\p{L}*|washing\s+machine|kir\s*m[ao]shin\p{L}*|kirmoshina|kir\s*yuvish\s+mashin\p{L}*)/iu;
 
 function listedUzbekAbsence(text, appliance) {
   // Marketplace Uzbek frequently puts a single "yo'q" after a short,
@@ -173,7 +173,7 @@ export function parseHousingListingFields(value, { country = '', dealType = null
   const washingMachine = applianceState(
     text,
     WASHING_MACHINE_RE,
-    /(?:без|нет)\s+(?:кир\s*машин\p{L}*|кирмошин\p{L}*|стиральн\p{L}*\s+машин\p{L}*|kir\s*moshina|kirmoshina)|(?:кир\s*машин\p{L}*|кирмошин\p{L}*|стиральн\p{L}*\s+машин\p{L}*|kir\s*moshina|kirmoshina)\s+(?:нет|yo['’ʻʼ`]?q|йўқ)|no\s+washing\s+machine/iu,
+    /(?:без|нет)\s+(?:кир\s*машин\p{L}*|кирмошин\p{L}*|стиральн\p{L}*\s+машин\p{L}*|kir\s*m[ao]shin\p{L}*|kirmoshina)|(?:кир\s*машин\p{L}*|кирмошин\p{L}*|стиральн\p{L}*\s+машин\p{L}*|kir\s*m[ao]shin\p{L}*|kirmoshina)\s+(?:нет|yo['’ʻʼ`]?q|йўқ)|no\s+washing\s+machine/iu,
   );
 
   return deepFreeze({

package/src/housing-money.js

@@ -10,6 +10,7 @@ import {
 import { maskPhoneLikeSpans } from './contact.js';
 import { DEPOSIT_TERMS, SELLER_TERMS } from './housing.js';
 import { COUNTRIES, canonicalCountryCode, countryByCode } from './countries.js';
+import { countryCodeForCity } from './country-context.js';
 import { extractTemporalCandidates } from './temporal.js';
 import {
   classifyHousingSingleMSpans,
@@ -92,7 +93,7 @@ const PRICE_AMOUNT_BEFORE_CURRENCY_RE = new RegExp(`${PRICE_CURRENCY_BEFORE_NUMB
 
 function moneyParsingContext(value = '') {
   if (value && typeof value === 'object' && !Array.isArray(value)) {
-    const country = canonicalCountryCode(value.country) || '';
+    const country = canonicalCountryCode(value.country) || countryCodeForCity(value.city);
     const currency = String(value.currency || value.fallbackCurrency || countryByCode(country)?.currency || '')
       .trim()
       .toUpperCase();
@@ -102,6 +103,14 @@ function moneyParsingContext(value = '') {
   }
 
   const currency = String(value || '').trim().toUpperCase();
+  // A bare country code ("UZ") is not a currency. Treat it as the country so
+  // the fallback becomes its currency rather than the literal string "UZ".
+  const namedCountry = currency && !COUNTRIES.some((item) => item.currency === currency)
+    ? canonicalCountryCode(value)
+    : null;
+  if (namedCountry) {
+    return { country: namedCountry, currency: countryByCode(namedCountry)?.currency || '', dealType: null };
+  }
   const countryMatches = currency
     ? COUNTRIES.filter((item) => item.currency === currency)
     : [];
@@ -406,6 +415,25 @@ export function parseHousingPricePerSqm(value, context = '') {
   });
 }
 
+// An unlabelled amount far below any real local price is a USD price written
+// without its sign: "Цена 500" is 500 USD, never 500 KZT or 500 UAH. The floors
+// sit well under the cheapest genuine local rent/sale so a real tenge or
+// hryvnia price is never reclassified. UZS has its own rule below.
+const LOCAL_PRICE_FLOORS = Object.freeze({
+  KZT: Object.freeze({ sale: 1_000_000, daily: 1_000, rent: 10_000 }),
+  UAH: Object.freeze({ sale: 100_000, daily: null, rent: 1_000 }),
+});
+const DAILY_RENT_RE = /(?:посуточн|суточн|сутк|за\s+ночь|подобов|доба|tunlik|kunlik|sutkaga|тәулік|per\s+night|daily)/iu;
+
+function lowLocalAmountCurrency(amount, currency, dealType, text) {
+  const floors = LOCAL_PRICE_FLOORS[currency];
+  if (!floors || amount == null) return currency;
+  const floor = dealType === 'sale' ? floors.sale
+    : dealType === 'shortRent' || DAILY_RENT_RE.test(text) ? floors.daily
+      : floors.rent;
+  return floor != null && amount > 0 && amount < floor ? 'USD' : currency;
+}
+
 export function parseHousingPrice(value, context = '') {
   const { country, currency: fallbackCurrency, dealType } = moneyParsingContext(context);
   const original = String(value || '');
@@ -427,9 +455,12 @@ export function parseHousingPrice(value, context = '') {
   // regional formats below remain as deterministic fallbacks until each is
   // represented by a richer candidate extractor.
   if (preferredCandidate && preferredCandidate.confidence >= 0.65) {
+    const candidateCurrency = preferredCandidate.currency || fallbackCurrency || '';
     const result = {
       amount: preferredCandidate.amount,
-      currency: preferredCandidate.currency || fallbackCurrency || '',
+      currency: preferredCandidate.explicitCurrency
+        ? candidateCurrency
+        : lowLocalAmountCurrency(preferredCandidate.amount, candidateCurrency, dealType, priceText),
       approximate: preferredCandidate.approximate,
     };
     if (preferredCandidate.range) result.range = preferredCandidate.range;
@@ -606,6 +637,8 @@ export function parseHousingPrice(value, context = '') {
     // turned "800 000" per person into an 800,000 USD rent.
     const monthlyRent = dealType === 'longRent' && price >= 100_000;
     currency = price >= 1_000_000 || monthlyRent || (dailyUzbek && price >= 10_000) ? 'UZS' : 'USD';
+  } else if (!explicit && currency === fallbackCurrency) {
+    currency = lowLocalAmountCurrency(price, currency, dealType, priceText);
   }
 
   return Object.freeze({ amount: price, currency, approximate: price != null && APPROXIMATE_RE.test(priceText) });

package/src/housing-structured.js

@@ -6,7 +6,7 @@ import { DEPOSIT_TERMS, SELLER_TERMS, UTILITY_TERMS } from './housing.js';
 import { GENERIC_LANDMARK_TERMS } from './landmarks.js';
 import { LOCATION_RELATIONS, parseHousingContext } from './housing-context.js';
 import { isHousingCommercialAd, resolveHousingIntent } from './housing-intent.js';
-import { countryCurrency, countryPhoneHint } from './country-context.js';
+import { countryCodeForCity, countryCurrency, countryPhoneHint } from './country-context.js';
 import { findTelegramContacts, maskPhoneLikeSpans, parsePhoneNumbers } from './contact.js';
 import { parseHousingAddress } from './housing-address.js';
 import { parseHousingListingFields } from './housing-listing-fields.js';
@@ -81,6 +81,14 @@ export function parseHousingRoomCount(value) {
     if (rooms != null && rooms >= 1 && rooms <= 20) return rooms;
   }
 
+  // "1в2 комнатная" / "2 в 3-х комн.": a flat replanned from one room count
+  // into another is listed as the resulting layout.
+  const replanned = text.match(/(?:^|[^\p{L}\p{N}])\d{1,2}\s*(?:-\s*х\s*)?(?:к\.?\s*)?в\s*(\d{1,2})\s*(?:-\s*(?:х|ти|и|ух|[её]х)\s*)?(?:комн\p{L}*|к(?:\.|\b)|xona)/iu);
+  if (replanned) {
+    const rooms = toNumber(replanned[1]);
+    if (rooms != null && rooms >= 1 && rooms <= 20) return rooms;
+  }
+
   const describedRooms = [...text.matchAll(/(?:^|[^\p{L}\p{N}_])(\d{1,2})\s*ta\s+(?:katta|kichkina)\s+xona(?=$|[^\p{L}\p{N}_])/giu)];
   if (describedRooms.length > 1) {
     const total = describedRooms.reduce((sum, match) => sum + Number(match[1]), 0);
@@ -414,7 +422,7 @@ export function parseHousingStructured(value, options = {}) {
   const original = String(value ?? '');
   const sourcePost = parseHousingSourcePost(original, { source: options.source });
   const text = sourcePost.text;
-  const country = String(options.country || '').trim();
+  const country = String(options.country || '').trim() || countryCodeForCity(options.city);
   const fallbackCurrency = options.fallbackCurrency || countryCurrency(country) || '';
   const phoneCountry = options.phoneCountry || countryPhoneHint(country) || null;
   const intent = resolveHousingIntent(text);

package/src/housing.js

@@ -120,8 +120,8 @@ export const CURRENCIES = Object.freeze([
 
 export const SELLER_TERMS = Object.freeze({
   owner: group('owner', {
-    ru: ['собственник', 'хозяин', 'от хозяина', 'без посредников', 'без посредника', 'без риелтора', 'без риэлтора', 'без маклера', 'без маклер', 'без агента'], en: ['owner', 'direct owner', 'no agent', 'no broker', 'no realtor'], uk: ['власник', 'власниця', 'від власника', 'без посередників'], ro: ['proprietar', 'direct proprietar', 'fără agenție', 'fara agentie', 'fără intermediari'],
-    uzLatn: ['egasi', 'uy egasi', 'mulkdor', 'maklersiz', 'vositachisiz'], uzCyrl: ['эгаси', 'уй эгаси', 'мулкдор', 'маклерсиз', 'воситачисиз', 'без маклер'], kk: ['иесі', 'үй иесі', 'меншік иесі', 'делдалсыз'],
+    ru: ['собственник', 'хозяин', 'от хозяина', 'без посредников', 'без посредника', 'без риелтора', 'без риэлтора', 'без маклера', 'без маклер', 'без агента', 'с риелторами не работаю', 'с риэлторами не работаю', 'с маклерами не работаю', 'с агентствами не работаю', 'риелторам не беспокоить', 'риэлторам не беспокоить', 'агентствам не беспокоить'], en: ['owner', 'direct owner', 'no agent', 'no broker', 'no realtor'], uk: ['власник', 'власниця', 'від власника', 'без посередників'], ro: ['proprietar', 'direct proprietar', 'fără agenție', 'fara agentie', 'fără intermediari'],
+    uzLatn: ['egasi', 'uy egasi', 'mulkdor', 'maklersiz', 'vositachisiz', 'bezmakler', 'bez makler', 'maklerlar bilan ishlanmaydi', 'maklerlar bilan ishlamaymiz', 'makler bilan ishlanmaydi', 'maklerlar bezovta qilmasin'], uzCyrl: ['эгаси', 'уй эгаси', 'мулкдор', 'маклерсиз', 'воситачисиз', 'без маклер', 'маклерлар билан ишланмайди', 'маклерлар безовта қилмасин'], kk: ['иесі', 'үй иесі', 'меншік иесі', 'делдалсыз'],
   }),
   agency: group('agency', {
     ru: ['агентство', 'агент', 'риелтор', 'риэлтор', 'маклер', 'посредник'], en: ['agency', 'agent', 'realtor', 'broker'], uk: ['агентство', 'агент', 'рієлтор', 'риелтор', 'посередник'], ro: ['agenție', 'agentie', 'agent imobiliar', 'agenție imobiliară', 'agentie imobiliara', 'broker'],

package/src/normalization.js

@@ -3,16 +3,39 @@ import { LEXICON_LANGUAGES } from './lexicon-core.js';
 const APOSTROPHES_RE = /[’‘ʻʼ`´]/g;
 const DASHES_RE = /[‐‑‒–—―]/g;
 
+// Parsing one vacancy or listing runs dozens of matchers over the same text,
+// and each normalizes it again from scratch: profiling the workforce
+// enrichment showed normalization among the top costs at ~170-490 ms per
+// vacancy. These functions are pure, so each keeps a small cache of its
+// recent long inputs. Short strings (dictionary aliases, single words) are
+// cheaper to normalize than to cache and are left alone; the cap bounds
+// memory to a few recent texts per function.
+const MEMO_MIN_LENGTH = 200;
+const MEMO_MAX_ENTRIES = 32;
+
+function memoizeLongText(fn) {
+  const cache = new Map();
+  return (value) => {
+    if (typeof value !== 'string' || value.length < MEMO_MIN_LENGTH) return fn(value);
+    const hit = cache.get(value);
+    if (hit !== undefined) return hit;
+    const result = fn(value);
+    if (cache.size >= MEMO_MAX_ENTRIES) cache.delete(cache.keys().next().value);
+    cache.set(value, result);
+    return result;
+  };
+}
+
 /** Normalize Unicode and punctuation variants without destroying letters. */
-export function normalizeUnicode(value) {
+export const normalizeUnicode = memoizeLongText(function normalizeUnicode(value) {
   return String(value ?? '')
     .normalize('NFKC')
     .replace(APOSTROPHES_RE, "'")
     .replace(DASHES_RE, '-');
-}
+});
 
 /** Stable comparison form for parser dictionaries. */
-export function normalizeForMatch(value) {
+export const normalizeForMatch = memoizeLongText(function normalizeForMatch(value) {
   return normalizeUnicode(value)
     .toLocaleLowerCase()
     .replace(/ё/g, 'е')
@@ -20,10 +43,10 @@ export function normalizeForMatch(value) {
     .replace(/[^\p{L}\p{N}]+/gu, ' ')
     .replace(/\s+/g, ' ')
     .trim();
-}
+});
 
 /** Search-only apostrophe compaction for Uzbek/Karakalpak variants. */
-function normalizeCompactApostropheForMatch(value) {
+const normalizeCompactApostropheForMatch = memoizeLongText(function normalizeCompactApostropheForMatch(value) {
   return normalizeUnicode(value)
     .toLocaleLowerCase()
     .replace(/ё/g, 'е')
@@ -32,7 +55,7 @@ function normalizeCompactApostropheForMatch(value) {
     .replace(/[^\p{L}\p{N}]+/gu, ' ')
     .replace(/\s+/g, ' ')
     .trim();
-}
+});
 
 export const CYRILLIC_SEARCH_MAP = Object.freeze({
   а: 'a', б: 'b', в: 'v', г: 'g', д: 'd', е: 'e', ё: 'e', ж: 'zh', з: 'z',
@@ -65,21 +88,21 @@ const KARAKALPAK_LATIN_PATTERN_EQUIVALENCE = Object.freeze({
 });
 
 /** Search-oriented Cyrillic folding; canonical identity still comes from explicit aliases. */
-export function foldCyrillicForSearch(value) {
+export const foldCyrillicForSearch = memoizeLongText(function foldCyrillicForSearch(value) {
   return normalizeUnicode(value)
     .toLocaleLowerCase()
     .split('')
     .map((char) => CYRILLIC_SEARCH_MAP[char] ?? char)
     .join('');
-}
+});
 
-function foldKazakhForSearch(value) {
+const foldKazakhForSearch = memoizeLongText(function foldKazakhForSearch(value) {
   return normalizeUnicode(value)
     .toLocaleLowerCase()
     .split('')
     .map((char) => KAZAKH_SEARCH_EQUIVALENCE[char] ?? char)
     .join('');
-}
+});
 
 function foldKarakalpakLatinForSearch(value) {
   return normalizeUnicode(value)
@@ -287,6 +310,8 @@ function matcherFor(entries, { transliteration = true } = {}) {
  * Return every canonical match with original-text offsets. Colliding aliases are
  * deliberately returned as multiple matches instead of silently choosing one.
  */
+const UZBEK_APOSTROPHE_CONTINUATION_RE = /^[og]['’ʻʼ‘`]\p{L}/iu;
+
 export function findAllCanonical(value, entries, { transliteration = true } = {}) {
   const text = normalizeUnicode(value ?? '');
   if (!text || !entries?.length) return [];
@@ -300,6 +325,10 @@ export function findAllCanonical(value, entries, { transliteration = true } = {}
     const alias = match[0];
     const start = match.index ?? 0;
     const end = start + alias.length;
+    // Uzbek Latin writes oʻ/gʻ with an apostrophe inside the word, so an alias
+    // that stops on o/g right before one ("bog" in "bog'laning", "contact us")
+    // has matched only the front of a longer word.
+    if (UZBEK_APOSTROPHE_CONTINUATION_RE.test(text.slice(end - 1, end + 2))) continue;
     const keys = normalizedAliasKeys(alias, { transliteration });
     const candidates = [];
     for (const key of keys) {

package/src/tashkent-housing-geography.js

@@ -213,7 +213,7 @@ export function matchTashkentNumberedArea(value, canonical) {
   if (!text) return null;
   const alternatives = normalizedAlternatives(aliases);
   let match = text.match(new RegExp(
-    `(?:^|\\s)(?:${alternatives})(?:\\s+${NUMBERED_CONTEXT})?\\s+(\\d{1,2})(?:\\s*([adад]))?(?:\\s+${NUMBERED_SUFFIX_CONTEXT})*(?:\\s|$)`,
+    `(?:^|\\s)(?:${alternatives})(?:\\s+${NUMBERED_CONTEXT})?\\s+(\\d{1,2})(?:\\s*([adад]))?(?:\\s*(?:кв|kv)(?=\\s|$))?(?:\\s+${NUMBERED_SUFFIX_CONTEXT})*(?:\\s|$)`,
     'iu',
   ));