@whiteslove/parsing-lexicon 0.6.2 → 0.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whiteslove/parsing-lexicon",
-  "version": "0.6.2",
+  "version": "0.6.5",
   "description": "Shared deterministic multilingual parsing lexicon for WhitesLove housing and hiring services",
   "repository": {
     "type": "git",
@@ -37,6 +37,9 @@
     },
     "./central-asia": "./src/central-asia.js",
     "./ukraine": "./src/ukraine.js",
+    "./ua-geo-coordinates": { "types": "./src/ua-geo-coordinates.d.ts", "import": "./src/ua-geo-coordinates.js" },
+    "./ua-geo-resolver": { "types": "./src/ua-geo-resolver.d.ts", "import": "./src/ua-geo-resolver.js" },
+    "./uz-geo-coordinates": { "types": "./src/uz-geo-coordinates.d.ts", "import": "./src/uz-geo-coordinates.js" },
     "./location-merge": "./src/location-merge.js",
     "./locations": "./src/locations-runtime.js",
     "./kg-location-extensions": "./src/kg-location-extensions.js",
@@ -50,6 +53,7 @@
     "./tashkent-colloquial": "./src/tashkent-colloquial.js",
     "./tashkent-residential-complexes": "./src/tashkent-residential-complexes.js",
     "./tashkent-pois": "./src/tashkent-pois.js",
+    "./tashkent-gastronomic-streets": "./src/tashkent-gastronomic-streets.js",
     "./tashkent-housing-geography": {
       "types": "./src/tashkent-housing-geography.d.ts",
       "import": "./src/tashkent-housing-geography.js"

package/src/central-asia-locations.js

@@ -1,4 +1,4 @@
-import { LOCATION_DICTIONARIES } from './locations.js';
+import { LOCATION_DICTIONARIES } from './locations-runtime.js';
 import { LOCATION_LIST_KEYS } from './location-merge.js';
 import { CITIES_BY_COUNTRY, canonicalCity } from './geography.js';
 import { aliasesOf, aliasesToRegex, normalizeForMatch } from './normalization.js';
@@ -6,7 +6,7 @@ import { KZ_AMBIGUOUS_LOCAL_NAMES, KZ_SEARCH_CLUSTERS } from './kz-location-exte
 import { UZ_AMBIGUOUS_LOCAL_NAMES } from './uz-location-extensions.js';
 
 // Compatibility names retained for consumers. The canonical dictionaries are
-// assembled once in locations.js; matcher layers must consume, not re-merge.
+// assembled once in the public runtime registry; matcher layers must consume, not re-merge.
 export const KZ_EXPANDED_LOCATION_DICTIONARIES = LOCATION_DICTIONARIES.KZ || Object.freeze({});
 export const UZ_EXPANDED_LOCATION_DICTIONARIES = LOCATION_DICTIONARIES.UZ || Object.freeze({});
 
@@ -139,6 +139,86 @@ function semanticBounds(value, match) {
   return { start, end };
 }
 
+const NUMBERED_LOCAL_AREA_NAME_RE = /(?:^|[-–—/\s])\d{1,2}[aа]?(?=$|[^\p{L}\p{N}_])/iu;
+const NUMBERED_CHILD_SUFFIX_RE = /^\s*[-–—/]\s*\d{1,2}[aа]?(?=$|[^\p{L}\p{N}_])/iu;
+
+function isUmbrellaAreaPrefixOfNumberedBlock(value, candidate) {
+  if (candidate.type !== 'local_area') return false;
+  if (NUMBERED_LOCAL_AREA_NAME_RE.test(String(candidate.name || ''))) return false;
+  return NUMBERED_CHILD_SUFFIX_RE.test(value.slice(candidate.end));
+}
+
+const RESIDENTIAL_MARKER_TEXT = String.raw`(?:ж\.?\s*к\.?|жил(?:ой|ого)?\s+комплекс\p{L}*|residential\s+complex|turar\s+joy\s+majmuasi|tjm)`;
+const residentialMarkedAliasCache = new WeakMap();
+
+function stripResidentialMarker(value) {
+  return String(value || '')
+    .replace(new RegExp(`^\\s*${RESIDENTIAL_MARKER_TEXT}\\s*[:\\-–—]?\\s*`, 'iu'), '')
+    .replace(new RegExp(`\\s*${RESIDENTIAL_MARKER_TEXT}\\s*$`, 'iu'), '')
+    .trim();
+}
+
+function residentialMarkedAliasRegex(item) {
+  if (residentialMarkedAliasCache.has(item)) return residentialMarkedAliasCache.get(item);
+  const aliases = [...new Set([item?.name, ...(item?.aliases || [])]
+    .map(stripResidentialMarker)
+    .filter(Boolean))];
+  const re = aliases.length ? aliasesToRegex(aliases) : null;
+  residentialMarkedAliasCache.set(item, re);
+  return re;
+}
+
+function markedResidentialMatch(value, item) {
+  const aliasRe = residentialMarkedAliasRegex(item);
+  if (!aliasRe) return null;
+  const markerRe = new RegExp(`(?:^|[^\\p{L}\\p{N}_])${RESIDENTIAL_MARKER_TEXT}\\s*[:\\-–—]?\\s*`, 'giu');
+  for (const marker of value.matchAll(markerRe)) {
+    const tailStart = (marker.index ?? 0) + marker[0].length;
+    const tail = value.slice(tailStart, Math.min(value.length, tailStart + 96));
+    const aliasMatch = tail.match(aliasRe);
+    if (!aliasMatch) continue;
+    const offset = aliasMatch.index ?? 0;
+    if (offset > 0 && /\S/u.test(tail.slice(0, offset))) continue;
+    return { 0: aliasMatch[0], index: tailStart + offset };
+  }
+  return null;
+}
+
+const LOCATION_CLAUSE_BOUNDARY_RE = /[\n\r.!?;|]/u;
+const PRIMARY_LOCATION_PREFIX_RE = /(?:(?:^|[^\p{L}\p{N}_])(?:адрес|локаци(?:я|и)|расположени(?:е|я)|находится)\s*[:\-–—]?\s*|(?:^|[^\p{L}\p{N}_])(?:в|на)\s+(?:(?:ж\.?\s*к\.?|жил(?:ом|ой)\s+комплекс\p{L}*|микрорайон\p{L}*|мкр\.?|массив\p{L}*|махалл\p{L}*|mahalla|massiv|district|район\p{L}*|metro|метро)\s*)?)$/iu;
+const NEARBY_LOCATION_PREFIX_RE = /(?:^|[^\p{L}\p{N}_])(?:до|около|возле|рядом(?:\s+(?:с|со))?|недалеко\s+от|неподал[её]ку\s+от|вблизи|напротив|ориентир(?:ом)?|near|nearby|close\s+to|next\s+to|opposite|landmark|yaqin(?:ida)?|yonida|mo['’ʻ]?ljal|яқин(?:ида)?|ёнида|мўлжал|жақын|жанында|маңында)(?=$|[^\p{L}\p{N}_])[\s\S]{0,96}$/iu;
+const DISTANCE_LOCATION_PREFIX_RE = /(?:\d+(?:[.,]\d+)?\s*(?:мин(?:ут\p{L}*)?|min(?:ute)?s?|daqiqa|м|m|метр\p{L}*|км|km)\s*(?:от|до|from|to)\s+)[\s\S]{0,80}$/iu;
+const NEARBY_LOCATION_SUFFIX_RE = /^\s*(?:[-—–:]\s*)?(?:(?:\d+(?:[.,]\d+)?\s*(?:мин(?:ут\p{L}*)?|min(?:ute)?s?|daqiqa|м|m|метр\p{L}*|км|km))|(?:рядом|поблизости|nearby|yaqin(?:ida)?|яқин(?:ида)?|жақын))(?=$|[^\p{L}\p{N}_])/iu;
+
+function clauseStart(value, start) {
+  for (let index = start - 1; index >= 0; index -= 1) {
+    if (LOCATION_CLAUSE_BOUNDARY_RE.test(value[index])) return index + 1;
+  }
+  return 0;
+}
+
+function clauseEnd(value, end) {
+  for (let index = end; index < value.length; index += 1) {
+    if (LOCATION_CLAUSE_BOUNDARY_RE.test(value[index])) return index;
+  }
+  return value.length;
+}
+
+function locationMentionRole(value, candidate) {
+  const start = clauseStart(value, candidate.start);
+  const end = clauseEnd(value, candidate.end);
+  const before = value.slice(start, candidate.start);
+  const after = value.slice(candidate.end, end);
+
+  // A direct subject marker later in the same clause wins over an unrelated
+  // earlier temporal "до": "до пятницы квартира в ЖК X" is still ЖК X itself.
+  if (PRIMARY_LOCATION_PREFIX_RE.test(before)) return 'primary';
+  if (NEARBY_LOCATION_PREFIX_RE.test(before) || DISTANCE_LOCATION_PREFIX_RE.test(before) || NEARBY_LOCATION_SUFFIX_RE.test(after)) {
+    return 'nearby';
+  }
+  return 'mentioned';
+}
+
 function publicMatch(candidate) {
   const { start, end, matchedText, explicitContext, ...result } = candidate;
   return Object.freeze(result);
@@ -149,7 +229,8 @@ function findEntryMatches(text, cityName, data) {
   const raw = [];
   for (const key of LOCATION_LIST_KEYS) {
     for (const item of data?.[key] || []) {
-      const match = value.match(item?.re);
+      const match = value.match(item?.re)
+        || (key === 'residentialComplexes' ? markedResidentialMatch(value, item) : null);
       if (!match) continue;
       const { start, end } = semanticBounds(value, match);
       const candidate = {
@@ -167,8 +248,11 @@ function findEntryMatches(text, cityName, data) {
         end,
         matchedText: value.slice(start, end),
         explicitContext: false,
+        role: 'mentioned',
       };
+      if (isUmbrellaAreaPrefixOfNumberedBlock(value, candidate)) continue;
       candidate.explicitContext = hasExplicitContext(value, candidate);
+      candidate.role = locationMentionRole(value, candidate);
       raw.push(candidate);
     }
   }

package/src/central-asia.js

@@ -51,6 +51,9 @@ export const UZ_SEARCH_TARGETS = Object.freeze([
   city("Ellikqal'a", { uzLatn: ["Ellikqal'a", 'Ellikkala'], kaaLat: ['Elliqala'], ru: ['Элликкала'], en: ['Ellikkala'] }, { country: 'UZ', type: 'search_target', priority: 'P4', region: "Qoraqalpog'iston" }),
 ]);
 
+/** Canonical Kyrgyzstan city catalog used by geography consumers. */
+export const KG_CITY_CATALOG = CITIES_BY_COUNTRY.KG;
+
 export const KZ_LOCATION_TERMS = Object.freeze({
   microdistrict: Object.freeze(['микрорайон', 'микр.', 'микр', 'мкр.', 'мкр', 'м-н', 'мкр-н', 'ықшамаудан', 'ықш.ауд.', 'ықш']),
   residentialArea: Object.freeze(['жилой массив', 'жилмассив', 'ж/м', 'ж.м.', 'тұрғын алабы', 'тұрғын массиві', 'массив']),
@@ -66,6 +69,14 @@ export const UZ_LOCATION_TERMS = Object.freeze({
   residentialComplex: Object.freeze(['ЖК', 'жк', 'turar joy majmuasi', 'residential complex', 'residence']),
 });
 
+export const KG_LOCATION_TERMS = Object.freeze({
+  city: Object.freeze(['шаар', 'шаары', 'город', 'г.', 'city']),
+  district: Object.freeze(['район', 'району', 'р-н', 'district']),
+  microdistrict: Object.freeze(['микрорайон', 'мкр', 'мкр.', 'кичирайон', 'кичи район']),
+  residentialArea: Object.freeze(['жилмассив', 'жилой массив', 'массив', 'конуш', 'жаңы конуш']),
+  residentialComplex: Object.freeze(['ЖК', 'жк', 'жилой комплекс', 'турак жай комплекси', 'residential complex', 'residence']),
+});
+
 export function canonicalKazakhstanCity(value) {
   return canonicalCity(value, 'KZ');
 }
@@ -74,14 +85,27 @@ export function canonicalUzbekistanCity(value) {
   return canonicalCity(value, 'UZ');
 }
 
+export function canonicalKyrgyzstanCity(value) {
+  return canonicalCity(value, 'KG');
+}
+
 export function canonicalCentralAsiaCity(value, country = null) {
   if (country === 'KZ') return canonicalKazakhstanCity(value);
   if (country === 'UZ') return canonicalUzbekistanCity(value);
-  return canonicalKazakhstanCity(value) || canonicalUzbekistanCity(value);
+  if (country === 'KG') return canonicalKyrgyzstanCity(value);
+  return canonicalKazakhstanCity(value)
+    || canonicalUzbekistanCity(value)
+    || canonicalKyrgyzstanCity(value);
 }
 
 export function centralAsiaCityAliases(canonical, country) {
-  const catalog = country === 'KZ' ? KZ_CITY_CATALOG : country === 'UZ' ? UZ_CITY_CATALOG : [...KZ_CITY_CATALOG, ...UZ_CITY_CATALOG];
+  const catalog = country === 'KZ'
+    ? KZ_CITY_CATALOG
+    : country === 'UZ'
+      ? UZ_CITY_CATALOG
+      : country === 'KG'
+        ? KG_CITY_CATALOG
+        : [...KZ_CITY_CATALOG, ...UZ_CITY_CATALOG, ...KG_CITY_CATALOG];
   const item = catalog.find((entry) => entry.canonical === canonical);
   return item ? Object.freeze([...new Set([item.canonical, ...aliasesOf(item)])]) : Object.freeze([]);
 }

package/src/geo.js

@@ -48,7 +48,7 @@ export const TASHKENT_METRO = Object.freeze([
   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('Paxtakor', 'Пахтакор', 'Paxtakor', 'chilonzor'),
   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', 'метро Хамза']),
@@ -123,9 +123,9 @@ export const TASHKENT_AREAS = Object.freeze({
     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('Chimbay', ['чимбай', 'chimboy', 'chimbay']),
-    area('Takhtapul', ['тахтапуль', 'тахтапул', 'taxtapul', 'takhtapul']),
+    area('Medgorodok', ['медгородок', 'мед городок', 'medgorodok', 'TashMI-2', 'TashMI 2', 'ToshMI-2', 'ToshMI 2', 'ТашМИ-2', 'ТашМИ 2', 'ТошМИ-2', 'ТошМИ 2', 'новый ташми', 'новый ташми-2', 'янги ташми', 'yangi tashmi']),
+    area('Chimbay', ['чимбай', 'чимбой', 'chimboy', 'chimbay']),
+    area('Taxtapul', ['тахтапуль', 'тахтапул', 'taxtapul', 'takhtapul', 'Takhtapul']),
   ]),
   Mirobod: Object.freeze([
     area('Hospitalny', ['госпитальный', 'госпиталка', 'hospitalny']),
@@ -140,13 +140,13 @@ export const TASHKENT_AREAS = Object.freeze({
     area('Traktorsozlar-2', ['тракторсозлар 2', 'traktorsozlar 2', 'ттз 2', 'ttz 2']),
     area('TTZ-3', ['ттз 3', 'ttz 3']),
     area('Traktorsozlar-4', ['тракторсозлар 4', 'traktorsozlar 4', 'ттз 4', 'ttz 4']),
-    area('Yalangach', ['ялангач', 'yalangach', "yalang'och"]), area('Feruza', ['феруза', 'feruza']), area('Geofizika', ['геофизика', 'поселок геофизиков', 'geofizika']),
+    area('Yalangach', ['ялангач', 'ялангач массив', 'yalangach', "yalang'och", "yalang'och dahasi", 'высоковольтный', 'массив высоковольтный']), area('Feruza', ['феруза', 'feruza']), area('Geofizika', ['геофизика', 'поселок геофизиков', 'geofizika']),
   ]),
   Uchtepa: Object.freeze([
     area('Lolazor', ['лолазор', 'lolazor']),
   ]),
   Sergeli: Object.freeze([
-    area('Yangi Sergeli', ['янги сергели', 'yangi sergeli']), area('Stroygorod', ['стройгород', 'stroygorod']),
+    area('Yangi Sergeli', ['янги сергели', 'yangi sergeli']),
     area('Uzgarish', ['узгарыш', 'ўзгариш', "o'zgarish", 'uzgarish']),
   ]),
   Chilanzar: Object.freeze([
@@ -176,4 +176,4 @@ export const TASHKENT_AREAS = Object.freeze({
     ...[1, 2, 3, 4].map((n) => area(`Tuzel-${n}`, [`тузель ${n}`, `tuzel ${n}`])),
     area('Tashselmash', ['ташсельмаш', 'tashselmash']), area('Alimkent', ['алимкент', 'olimkent', 'alimkent']), area('Shohimardon', ['шохимардон', 'shohimardon']),
   ]),
-});
+});

package/src/geography-display.js

@@ -1,6 +1,6 @@
 import { COUNTRIES, canonicalCountryCode, countryByCode } from './countries.js';
 import { CITIES, REGIONS } from './geography.js';
-import { dictionaryFor } from './locations.js';
+import { dictionaryFor } from './locations-runtime.js';
 import { aliasesOf } from './normalization.js';
 
 // Centralized presentation names for canonical geography values.

package/src/geography-zone-display.js

@@ -1,5 +1,5 @@
 import { geographyDisplayName } from './geography-display.js';
-import { dictionaryFor } from './locations.js';
+import { dictionaryFor } from './locations-runtime.js';
 import { aliasesOf, findCanonical } from './normalization.js';
 import { canonicalCountryCode } from './countries.js';
 

package/src/geography.js

@@ -57,10 +57,19 @@ const RO_CITIES_BASE = Object.freeze([
 export const RO_CITIES = Object.freeze([...RO_CITIES_BASE, ...RO_CITY_EXTENSIONS]);
 
 export const KG_CITIES = Object.freeze([
-  entity('Bishkek', { ru: ['Бишкек'], en: ['Bishkek'], kk: ['Бішкек'], uzLatn: ['Bishkek'] }, { country: 'KG', type: 'city' }),
-  entity('Osh', { ru: ['Ош'], en: ['Osh'], kk: ['Ош'], uzLatn: ['Osh'] }, { country: 'KG', type: 'city' }),
-  entity('Karakol', { ru: ['Каракол'], en: ['Karakol'], kk: ['Қаракөл'], uzLatn: ['Karakol'] }, { country: 'KG', type: 'city' }),
-
+  entity('Bishkek', { ky: ['Бишкек'], ru: ['Бишкек'], en: ['Bishkek'], kk: ['Бішкек'], uzLatn: ['Bishkek'] }, { country: 'KG', type: 'city' }),
+  entity('Osh', { ky: ['Ош'], ru: ['Ош'], en: ['Osh'], kk: ['Ош'], uzLatn: ['Osh'] }, { country: 'KG', type: 'city' }),
+  entity('Jalal-Abad', { ky: ['Жалал-Абад', 'Жалал Абад'], ru: ['Джалал-Абад', 'Джалал Абад'], en: ['Jalal-Abad', 'Jalalabad'] }, { country: 'KG', type: 'city' }),
+  entity('Karakol', { ky: ['Каракол'], ru: ['Каракол', 'Пржевальск'], en: ['Karakol', 'Przhevalsk'], kk: ['Қаракөл'], uzLatn: ['Karakol'] }, { country: 'KG', type: 'city' }),
+  entity('Tokmok', { ky: ['Токмок'], ru: ['Токмок'], en: ['Tokmok'] }, { country: 'KG', type: 'city' }),
+  entity('Naryn', { ky: ['Нарын'], ru: ['Нарын'], en: ['Naryn'] }, { country: 'KG', type: 'city' }),
+  entity('Talas', { ky: ['Талас'], ru: ['Талас'], en: ['Talas'] }, { country: 'KG', type: 'city' }),
+  entity('Batken', { ky: ['Баткен'], ru: ['Баткен'], en: ['Batken'] }, { country: 'KG', type: 'city' }),
+  entity('Kara-Balta', { ky: ['Кара-Балта', 'Кара Балта'], ru: ['Кара-Балта', 'Кара Балта'], en: ['Kara-Balta', 'Kara Balta'] }, { country: 'KG', type: 'city' }),
+  entity('Balykchy', { ky: ['Балыкчы'], ru: ['Балыкчи'], en: ['Balykchy', 'Balykchi'] }, { country: 'KG', type: 'city' }),
+  entity('Kant', { ky: ['Кант'], ru: ['Кант'], en: ['Kant'] }, { country: 'KG', type: 'city' }),
+  entity('Uzgen', { ky: ['Өзгөн', 'Озгон'], ru: ['Узген', 'Озгон'], en: ['Uzgen', 'Özgön', 'Ozgon'] }, { country: 'KG', type: 'city' }),
+  entity('Kyzyl-Kiya', { ky: ['Кызыл-Кыя', 'Кызыл Кыя'], ru: ['Кызыл-Кия', 'Кызыл Кия'], en: ['Kyzyl-Kiya', 'Kyzyl Kiya'] }, { country: 'KG', type: 'city' }),
 ]);
 
 /** Canonical cities used across global hiring and housing ingestion. */

package/src/hiring-requirements.js

@@ -21,12 +21,12 @@ export function detectHiringSeniority(value) {
     ['director', /\b(?:engineering\s+)?director\b|директор/i],
     ['principal', /\bprincipal\b(?=[^,;\n]{0,60}\b(?:engineer|developer|architect)\b)/i],
     ['staff', /\bstaff\b(?=[^,;\n]{0,60}\b(?:engineer|developer|architect)\b)/i],
-    ['lead', /\b(?:team\s*lead|tech\s*lead|lead\s+(?:engineer|developer|frontend|backend))\b|тимлид|техлид|ведущ\w*/i],
+    ['lead', /\b(?:team\s*lead|tech\s*lead|lead\s+(?:engineer|developer|frontend|backend))\b|тимлид|техлид|ведущ\w*|yetakchi\s+(?:dasturchi|mutaxassis|muhandis)|жетекші\s+(?:бағдарламашы|маман|инженер)/iu],
     ['manager', /\bengineering manager\b|руководител/i],
-    ['senior', /\bsenior\b(?=[^,;\n]{0,60}\b(?:engineer|developer|frontend|backend|software)\b)|сеньор|старш\w*\s+(?:разработ|инженер)/i],
-    ['middle', /\b(?:middle|mid[- ]?level)\b(?=[^,;\n]{0,60}\b(?:engineer|developer|frontend|backend|software)\b)|мидл/i],
-    ['junior', /\bjunior\b(?=[^,;\n]{0,60}\b(?:engineer|developer|frontend|backend|software)\b)|джун\w*|младш\w*/i],
-    ['intern', /\b(?:intern|trainee)\b|стаж[ёе]р|стажир/i],
+    ['senior', /\bsenior\b(?=[^,;\n]{0,60}\b(?:engineer|developer|frontend|backend|software)\b)|сеньор|старш\w*\s+(?:разработ|инженер)|katta\s+(?:dasturchi|mutaxassis|muhandis)|аға\s+(?:бағдарламашы|маман|инженер)/iu],
+    ['middle', /\b(?:middle|mid[- ]?level)\b(?=[^,;\n]{0,60}\b(?:engineer|developer|frontend|backend|software)\b)|мидл|o['’ʻ]?rta\s+(?:dasturchi|mutaxassis|muhandis)|орта\s+(?:бағдарламашы|маман|инженер)/iu],
+    ['junior', /\bjunior\b(?=[^,;\n]{0,60}\b(?:engineer|developer|frontend|backend|software)\b)|джун\w*|младш\w*|kichik\s+(?:dasturchi|mutaxassis|muhandis)|кіші\s+(?:бағдарламашы|маман|инженер)/iu],
+    ['intern', /\b(?:intern|trainee)\b|стаж[ёе]р|стажир|amaliyotchi|stajyor|тәжірибеден\s+өтуші|стажер/iu],
   ];
   return checks.find(([, pattern]) => pattern.test(text))?.[0] || null;
 }

package/src/hiring-salary-context.js

@@ -111,7 +111,11 @@ export function parseHiringSalaryWithContext(value, options = {}) {
   return withContext(parseSalary(value), value, options);
 }
 
-const VACANCY_COMPENSATION_RE = /(?:salary|salary\s+range|base\s+pay|pay\s+range|annual\s+pay|compensation(?:\s+range)?|заработн\p{L}*\s+плат\p{L}*|зарплат\p{L}*|з\s*[\/\\.\-]?\s*п(?=$|[^\p{L}\p{N}_])|оклад\p{L}*|вилка\s+оплат\p{L}*|оплата\s+труда|компенсац\p{L}*|ставка|💵|💰)/giu;
+// Include short local-board labels/markers used in real vacancy feeds: `З/п`,
+// `ЗП`, and the money emoji that ish-bor-style cards use before a salary field.
+// The marker is still required for long prose so unrelated large numbers are not
+// promoted to compensation merely because the vacancy happens to be in UZ/KZ.
+const VACANCY_COMPENSATION_RE = /(?:💵|💰|salary|salary\s+range|base\s+pay|pay\s+range|annual\s+pay|compensation(?:\s+range)?|з\s*[/\\.\-]?\s*п\b|заработн\p{L}*\s+плат\p{L}*|зарплат\p{L}*|оклад\p{L}*|вилка\s+оплат\p{L}*|оплата\s+труда|компенсац\p{L}*|ставка)/giu;
 
 // AI-recruiting/staffing postings (e.g. Mercor) routinely mention funding,
 // valuation or revenue figures in the same listing as the actual salary. A
@@ -141,4 +145,4 @@ export function parseHiringVacancySalary(value, options = {}) {
     if (parsed && (parsed.min != null || parsed.max != null)) return parsed;
   }
   return null;
-}
+}

package/src/hiring-temporal.js

@@ -9,6 +9,10 @@ export const HIRING_MONTHS = Object.freeze({
   iulie: 6, august: 7, septembrie: 8, octombrie: 9, noiembrie: 10, decembrie: 11,
   січня: 0, лютого: 1, березня: 2, квітня: 3, травня: 4, червня: 5,
   липня: 6, серпня: 7, вересня: 8, жовтня: 9, листопада: 10, грудня: 11,
+  yanvar: 0, fevral: 1, mart: 2, aprel: 3, iyun: 5,
+  iyul: 6, avgust: 7, sentabr: 8, oktabr: 9, noyabr: 10, dekabr: 11,
+  қаңтар: 0, ақпан: 1, наурыз: 2, сәуір: 3, мамыр: 4, маусым: 5,
+  шілде: 6, тамыз: 7, қыркүйек: 8, қазан: 9, қараша: 10, желтоқсан: 11,
 });
 
 export const UNICODE_LEFT_BOUNDARY = '(?<![\\p{L}\\p{N}])';

package/src/housing-address.js

@@ -8,7 +8,7 @@ const ADDRESS_LABEL_RE = /(?:адрес|адреса|адресація|адре
 const PREFIX_STREET_MARKER = String.raw`(?:(?:ул(?:ица)?|вул(?:иця)?|пр|просп(?:ект)?|пр-т|переул(?:ок)?|пров(?:улок)?|проезд|наб(?:ережная)?|шоссе|str(?:ada)?|street|st|avenue|ave|road|rd|көше)\.?)`;
 const POSTFIX_STREET_MARKER = String.raw`(?:ko['’ʼ\u02bc]?cha(?:si)?|кўча(?:си)?|коча(?:си)?|kocha(?:si)?)`;
 const POSTFIX_STREET_TYPE = String.raw`(?:вулиця|улица|провулок|переулок|проспект|бульвар|набережна|набережная|шосе|шоссе|площа|площадь|узвіз|спуск|алея|аллея|дорога|тупик)`;
-const HOUSE_MARKER = String.raw`(?:дом|д\.|будинок|буд\.|house|h\.|uy|уй|nr\.?|no\.?|№)`;
+const HOUSE_MARKER = String.raw`(?:дом|д\.|будинок|буд\.|house|h\.|uy|уй|үй|nr\.?|no\.?|№)`;
 const BUILDING_MARKER = String.raw`(?:корп(?:ус)?\.?|к\.|строен(?:ие)?|стр\.|будова|секц(?:ия|ія)?|bloc|corp|building|bldg\.?|korpus)`;
 const NUMBER_TOKEN = String.raw`\d{1,5}(?:[-\/]?[\p{L}])?(?:[\/-]\d{1,4}(?:[-\/]?[\p{L}])?)?`;
 const STREET_WORD = String.raw`[\p{L}'’.-]{2,48}`;

package/src/housing-card-fields.js

@@ -39,6 +39,7 @@ const PLACE_KINDS = Object.freeze([
 const NEARBY_BLOCK_RE = /(?:^|\n)[^\n]{0,30}?(?:что\s+(?:есть|находится)\s+р[яa]дом|р[яa]дом(?:\s+(?:есть|находятся|расположены|с\s+домом))?|непода[лл][её]ку|поблизости|в\s+шаговой\s+доступности|окружени[ие]|ориентир(?:ы|ами)?|yaqinida|atrofida|yonida|nearby|landmarks?)\s*[:—-]?\s*([^\n]{4,500})/iu;
 const NEARBY_NOISE_RE = /^(?:и|а|в|на|у|до|от|все|вс[её]|есть|рядом|близко|недалеко|минут\p{L}*|пешком|транспорт|остановк\p{L}*|магазин|магазины|аптека|аптеки|садик|садики|всё\s+необходимое|развит\p{L}*)$/iu;
 const NEARBY_FILLER_RE = /(?:инфраструктур\p{L}*|все\s+необходимо|вс[её]\s+рядом|шаговой\s+доступност|развитый\s+район)/iu;
+const QUARTER_NEARBY_PREFIX_RE = /(?:^|[\s,;:—–-])(?:до|рядом\s+(?:с|со)|недалеко\s+от|возле|около|ориентир\s*[:—–-]?|near(?:by)?|close\s+to|lângă|aproape\s+de)\s*$/iu;
 
 function enumeratedNearby(text) {
   const blocks = [...text.matchAll(new RegExp(NEARBY_BLOCK_RE.source, `${NEARBY_BLOCK_RE.flags}g`))]
@@ -61,18 +62,33 @@ function enumeratedNearby(text) {
   return items;
 }
 
+function isNearbyQuarterReference(text, match) {
+  const start = match?.index ?? -1;
+  if (start < 0) return false;
+  const before = text.slice(Math.max(0, start - 64), start);
+  return QUARTER_NEARBY_PREFIX_RE.test(before);
+}
+
+function firstPrimaryQuarterMatch(text, pattern) {
+  const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+  for (const match of text.matchAll(new RegExp(pattern.source, flags))) {
+    if (!isNearbyQuarterReference(text, match)) return match;
+  }
+  return null;
+}
+
 export function parseHousingQuarterLabel(value) {
   const text = String(value || '');
   if (!text) return null;
   if (/(?:^|[^\p{L}\p{N}_])(?:глинк[аи]?|glinka)(?:$|[^\p{L}\p{N}_])/iu.test(text)) return 'Glinka';
-  const match = text.match(/(\d{1,3})\s*(?:-?\s*(?:chi|чи))?\s*[-\s]?\s*(?:квартал|кв-?л(?=$|[^\p{L}\p{N}_])|kvartal(?:i)?|квартил|kvartil|мкр(?=$|[^\p{L}\p{N}_])|микрорайон|массив|massiv|daha(?:si|dan)?|hudud|худуд)/iu)
-    || text.match(/(?:квартал|kvartal(?:i)?|квартил|kvartil|мкр|микрорайон|массив|massiv|daha(?:si|dan)?|hudud|худуд)\s*[-№#]?\s*(\d{1,3})/iu)
-    || text.match(/(?:чиланзар|chilonzor|chilanzar)\s*[-№#]?\s*(\d{1,2})(?!\d)/iu);
+  const match = firstPrimaryQuarterMatch(text, /(\d{1,3})\s*(?:-?\s*(?:chi|чи))?\s*[-\s]?\s*(?:квартал|кв-?л(?=$|[^\p{L}\p{N}_])|kvartal(?:i)?|квартил|kvartil|мкр(?=$|[^\p{L}\p{N}_])|микрорайон|массив|massiv|daha(?:si|dan)?|hudud|худуд)/iu)
+    || firstPrimaryQuarterMatch(text, /(?:квартал|kvartal(?:i)?|квартил|kvartil|мкр|микрорайон|массив|massiv|daha(?:si|dan)?|hudud|худуд)\s*[-№#]?\s*(\d{1,3})/iu)
+    || firstPrimaryQuarterMatch(text, /(?:чиланзар|chilonzor|chilanzar)\s*[-№#]?\s*(\d{1,2})(?!\d)/iu);
   if (match) {
     const label = `${Number(match[1])} kvartal`;
     return STREET_LIKE_PLACE_RE.test(label) ? null : label;
   }
-  const centralBlock = text.match(/(?:^|[^\p{L}\p{N}_])(?:ц|c)\s*[-–]?\s*(\d{1,2})(?:$|[^\p{L}\p{N}_])/iu);
+  const centralBlock = firstPrimaryQuarterMatch(text, /(?:^|[^\p{L}\p{N}_])(?:ц|c)\s*[-–]?\s*(\d{1,2})(?:$|[^\p{L}\p{N}_])/iu);
   return centralBlock ? `C-${Number(centralBlock[1])}` : null;
 }
 

package/src/housing-display.js

@@ -24,10 +24,23 @@ const DISPLAY = Object.freeze({
     'Bobur Park': 'Парк Бобура', 'Independence Square': 'Площадь Независимости', 'Mega Planet': 'Mega Planet',
     'Bek Baraka': 'Бек-Барака', Khadra: 'Хадра',
   }),
+  uk: Object.freeze({
+    Park: 'Парк', Metro: 'Метро', 'Bus stop': 'Автобусна зупинка', 'Public transport': 'Громадський транспорт',
+    'Main road': 'Головна дорога', Clinic: 'Клініка', 'Maternity hospital': 'Пологовий будинок', Hospital: 'Лікарня',
+    School: 'Школа', Kindergarten: 'Дитячий садок', Childcare: 'Дитячі заклади', University: 'Університет',
+    'Shopping center': 'Торговий центр', Shop: 'Магазин', Korzinka: 'Korzinka', Supermarket: 'Супермаркет',
+    Market: 'Ринок', Cafe: 'Кафе', Restaurant: 'Ресторан', Playground: 'Дитячий майданчик', Pharmacy: 'Аптека',
+    Mosque: 'Мечеть', Church: 'Церква', 'Railway station': 'Залізничний вокзал', Airport: 'Аеропорт',
+    'Bobur Park': 'Парк Бабура', 'Independence Square': 'Площа Незалежності', 'Mega Planet': 'Mega Planet',
+    'Bek Baraka': 'Бек-Барака', Khadra: 'Хадра',
+  }),
 });
 
 function languageKey(locale) {
-  return String(locale || 'en').toLowerCase().startsWith('ru') ? 'ru' : 'en';
+  const key = String(locale || 'en').toLowerCase();
+  if (key.startsWith('uk')) return 'uk';
+  if (key.startsWith('ru')) return 'ru';
+  return 'en';
 }
 
 function exactPoi(value) {

package/src/housing-listing-enrichment.js

@@ -3,6 +3,7 @@ import { findAllCanonical, normalizeUnicode } from './normalization.js';
 import { GENERIC_LANDMARK_TERMS } from './landmarks.js';
 import { matchTashkentHousingDistrict, matchTashkentHousingMetro, matchTashkentHousingQuarter } from './tashkent-housing-geography.js';
 import { TASHKENT_LANDMARKS } from './tashkent-pois.js';
+import { TASHKENT_RESIDENTIAL_COMPLEXES, matchTashkentResidentialComplex } from './tashkent-residential-complexes.js';
 import { parseHousingRoomCount, parseHousingFloor, parseHousingAreas } from './housing-structured.js';
 import { parseHousingListingFields } from './housing-listing-fields.js';
 import { parseHousingResidentialComplex } from './housing-text.js';
@@ -26,18 +27,21 @@ 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}*))/iu;
-const STUDENT_RE = /(?:studentlar\s+uchun|talabalar\s+uchun|студент(?:ам|ы|ок|ов)?\s+(?:можно|для)|для\s+студент)/iu;
-const NO_BROKER_RE = /(?:bez\s+makler|maklersiz|vositachisiz|без\s+(?:маклер|посредник|риелтор|риэлтор|комисси))/iu;
-const BROKER_RE = /(?:makler|vositachi|макл(?:ер[а-яё]*)?|ри[еэ]лтор[а-яё]*|агентств[а-яё]*|комисси[а-яё]*|broker|realtor|commission)/iu;
-const MEN_RE = /(?:o['’ʻʼ‘`]?g['’ʻʼ‘`]?il\s+bola(?:lar)?(?:ga)?|ogil\s+bola(?:lar)?(?:ga)?|sherik\s+bola|эркак(?:лар)?|erkak(?:lar)?(?:ga)?|только\s+(?:мужчин|парн))/iu;
-const WOMEN_RE = /(?:qiz(?:lar)?(?:ga)?|ayol(?:lar)?(?:ga|ni)?|киз(?:лар)?(?:га)?|аёл(?:лар)?(?:га|ни)?|девушк\p{L}*|женщин\p{L}*|girls?\s+only|women\s+only)/iu;
-const FAMILY_RE = /(?:семь\p{L}*|family|oila(?:ga|lar|li)?|oila\s+uchun|оилага|оелага|оилавий|oelaga)/iu;
-const ROOM_SHARE_RE = /(?:sherik(?:ka|lik|likga)?|шерик(?:ка|лик)?|roommate|flatmate|подселени|койко[-\s]?мест|место\s+в\s+(?:комнат|квартир)|birga\s+yashash(?:ga)?|kvartira(?:ga|da)?[^\r\n.!?]{0,36}(?:\d+|bitta|1)\s*(?:ta\s*)?(?:qiz|ayol)[^\r\n.!?]{0,20}(?:ijarachi\s*)?(?:kerak|kere))/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|студент(?:ам|ы|ок|ов)?\s+(?:можно|для)|для\s+студент|students?\s+(?:only|welcome)|for\s+students|pentru\s+studen[țt]i|studen[țt]i(?:lor)?|студенттерге|студенттер\s+үшін)/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 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;
+const FAMILY_RE = /(?:семь\p{L}*|family|oila(?:ga|lar|li)?|oila\s+uchun|оилага|оелага|оилавий|oelaga|famil(?:ie|ia)|cuplu(?:ri)?|отбасына|отбасылы|жанұяға|сім['’ʼ]?[яїі](?:ям|ям[иі])?|сімейн\p{L}*)/iu;
+const ROOM_SHARE_RE = /(?:sherik(?:ka|lik|likga)?|шерик(?:ка|лик)?|roommate|flatmate|подселени|койко[-\s]?мест|место\s+в\s+(?:комнат|квартир)|birga\s+yashash(?:ga)?|kvartira(?:ga|da)?[^\r\n.!?]{0,36}(?:\d+|bitta|1)\s*(?:ta\s*)?(?:qiz|ayol)[^\r\n.!?]{0,20}(?:ijarachi\s*)?(?:kerak|kere)|coleg\s+de\s+(?:apartament|camer[ăa])|bed\s+space|бөлмелес(?:\s+керек)?|көрші\s+керек)/iu;
 const AIR_CONDITIONER_RE = /(?:кондицион|air\s*con|konditsioner|kandit(?:s|c)?aner|kanditsaner|кандитсанер)/iu;
 const PER_PERSON_PRICE_RE = /(?:kishi\s+boshiga|киши\s+бошига)\s*(\d{1,3}(?:[\s.,]\d{3})*|\d+(?:[.,]\d+)?)\s*(ming|минг|million|mln|млн)?(?:dan|дан)?/iu;
 const WALK_MINUTES_RE = /(?:yayov|piyoda|пешком)\s*(\d{1,2})\s*(?:daqiqa|min(?:ute)?s?|минут)/iu;
 const TRANSIT_ROUTES_RE = /(?:aftobuslar|avtobuslar|автобуслар|автобусы)[^\r\n\d]{0,24}((?:\d{1,4}[\s,;/]*){1,10})/iu;
+const NEARBY_RELATION_TAIL_RE = /(?<!\p{L})(?:рядом\s+(?:с|со)|недалеко\s+от|возле|около|ориентир\s*[:—–-]?|near(?:by)?|close\s+to|lângă|aproape\s+de)(?!\p{L})[^.!?\r\n;]*/giu;
+const NEARBY_TRAVEL_TAIL_RE = /(?<!\p{L})(?:до|până\s+la)(?!\p{L})[^.!?\r\n;]{0,96}(?<!\p{L})\d{1,3}\s*(?:мин(?:ут(?:ы|а|ах)?|\.?)?|min(?:ute)?s?|дақиқ\p{L}*|daqiqa|км|km|метр(?:а|ов)?|m)(?!\p{L})[^.!?\r\n;]*/giu;
+const RESIDENTIAL_CONTEXT_RE = /(?:ж\.?\s*к\.?|жил(?:ой|ого)\s+комплекс|новострой(?:ка|ки)?|residential\s+complex|residence|turar\s+joy|uy[-\s]?joy|majmua|массив)/iu;
 
 function unique(values) {
   return [...new Set(values.filter(Boolean))];
@@ -47,6 +51,42 @@ function categoryOf(entry) {
   return entry?.category || GENERIC_CATEGORY[entry?.canonical] || 'landmark';
 }
 
+function nearbyReferenceRanges(text) {
+  const ranges = [];
+  for (const pattern of [NEARBY_RELATION_TAIL_RE, NEARBY_TRAVEL_TAIL_RE]) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    for (const match of text.matchAll(regex)) {
+      const start = match.index ?? 0;
+      ranges.push({ start, end: start + match[0].length });
+    }
+  }
+  return ranges;
+}
+
+function insideNearbyReference(match, ranges) {
+  return ranges.some((range) => match.start >= range.start && match.end <= range.end);
+}
+
+function withoutNearbyLocationReferences(text) {
+  return String(text || '')
+    .replace(NEARBY_RELATION_TAIL_RE, ' ')
+    .replace(NEARBY_TRAVEL_TAIL_RE, ' ');
+}
+
+function hasResidentialContext(text, match) {
+  if (!match.entry?.ambiguous) return true;
+  const context = text.slice(Math.max(0, match.start - 36), Math.min(text.length, match.end + 36));
+  return RESIDENTIAL_CONTEXT_RE.test(context);
+}
+
+function residentialComplexNearbyMatches(text) {
+  const ranges = nearbyReferenceRanges(text);
+  if (!ranges.length) return [];
+  return findAllCanonical(text, TASHKENT_RESIDENTIAL_COMPLEXES)
+    .filter((match) => insideNearbyReference(match, ranges) && hasResidentialContext(text, match))
+    .map((match) => ({ canonical: match.canonical, category: 'residential_complex', start: match.start }));
+}
+
 function extensionMatches(text) {
   return findAllCanonical(text, HOUSING_POI_EXTENSIONS).map((match) => ({
     canonical: match.canonical,
@@ -83,7 +123,7 @@ function genericMatches(text) {
 export function parseHousingNearby(value) {
   const text = normalizeUnicode(value ?? '');
   if (!text) return deepFreeze([]);
-  const specific = [...extensionMatches(text), ...catalogPoiMatches(text)].sort((a, b) => a.start - b.start);
+  const specific = [...extensionMatches(text), ...catalogPoiMatches(text), ...residentialComplexNearbyMatches(text)].sort((a, b) => a.start - b.start);
   const specificCategories = new Set(specific.map((item) => item.category));
   const generic = genericMatches(text)
     .filter((item) => !specificCategories.has(item.category))
@@ -201,7 +241,10 @@ export function parseHousingListingEnrichment(value, { country = '' } = {}) {
   const quarter = matchTashkentHousingQuarter(text);
   const district = matchTashkentHousingDistrict(text)?.name || quarter?.district || null;
   const metro = matchTashkentHousingMetro(text)?.name || null;
-  const parsedRc = specificResidentialComplex(text) || parseHousingResidentialComplex(text);
+  const primaryResidentialText = withoutNearbyLocationReferences(text);
+  const parsedRc = specificResidentialComplex(primaryResidentialText)
+    || matchTashkentResidentialComplex(primaryResidentialText)?.name
+    || parseHousingResidentialComplex(primaryResidentialText);
   const commission = parseHousingCommission(text);
   const commissionAmount = parseHousingCommissionAmount(text);
   const address = parseHousingAddress(text);

package/src/housing-money.js

@@ -271,4 +271,4 @@ export function parseHousingPrice(value, fallbackCurrency = '') {
 }
 
 // Compatibility name for callers migrating from Flat Finder's local parser.
-export const parsePriceFromText = parseHousingPrice;
+export const parsePriceFromText = parseHousingPrice;

package/src/housing-poi-extensions.js

@@ -108,6 +108,12 @@ export const HOUSING_POI_EXTENSIONS = Object.freeze([
     uzLatn: ['Assalom Jomiy', 'Assalom Jomiy turar joy majmuasi'],
     uzCyrl: ['Ассалом Жомий'],
   }, { category: 'residential_complex', display: { ru: 'ЖК «Ассалом Жомий»', en: 'Assalom Jomiy' } }),
+  group('Assalom Sohil', {
+    ru: ['Ассалом Сохил', 'ЖК Ассалом Сохил', 'жилой комплекс Ассалом Сохил'],
+    en: ['Assalom Sohil', 'Assalom Sohil residential complex'],
+    uzLatn: ['Assalom Sohil', 'Assalom Sohil turar joy majmuasi'],
+    uzCyrl: ['Ассалом Сохил'],
+  }, { category: 'residential_complex', display: { ru: 'ЖК «Ассалом Сохил»', en: 'Assalom Sohil' } }),
   group('Jomiy Roundabout', {
     ru: ['круг Жомий', 'круг жомий', 'кольцо Жомий'],
     en: ['Jomiy Roundabout', 'Jomiy circle'],

package/src/housing-source-aliases.js

@@ -10,6 +10,7 @@ export const HOUSING_DEAL_TYPE_EXTENSIONS = Object.freeze([
   group('longRent', {
     ru: ['снять', 'в месяц', 'месяц'],
     en: ['monthly'],
+    uk: ['зняти', 'на місяць', 'місяць'],
     uzLatn: ['ijaraga', 'oyiga', 'beriladi'],
     uzCyrl: ['ижарага', 'ойига', 'берилади'],
     kk: ['айына'],
@@ -17,6 +18,7 @@ export const HOUSING_DEAL_TYPE_EXTENSIONS = Object.freeze([
   group('shortRent', {
     ru: ['сутки', 'суток', 'суточно'],
     en: ['daily'],
+    uk: ['доба', 'діб', 'подобово'],
     uzLatn: ['kunlik', 'sutkalik'],
     uzCyrl: ['кунлик', 'суткалик'],
     kk: ['тәуліктік'],
@@ -27,6 +29,7 @@ export const HOUSING_ROOM_ONLY_EXTENSIONS = Object.freeze([
   group('roomOnly', {
     ru: ['шеринг'],
     en: ['room only'],
+    uk: ['шерінг'],
     uzLatn: ['student qizlarga', 'talaba qizlarga', 'opshijit dom', 'obshijit dom'],
     uzCyrl: ['студент қизларга', 'талаба қизларга'],
   }),

package/src/housing-structured.js

@@ -84,6 +84,23 @@ export function parseHousingFloor(value) {
   const text = normalizeUnicode(value ?? '');
   if (!text) return deepFreeze({ floor: null, totalFloors: null });
 
+  // Common classifieds shorthand is rooms/floor/total floors, e.g. 2/10/16.
+  // It must be checked before the generic floor/total fraction parser or the
+  // first two numbers would incorrectly become floor=2, totalFloors=10.
+  // Requiring the triple to occupy its own line avoids treating dates as this
+  // housing-specific shorthand inside ordinary prose.
+  const compactTriple = text.match(/(?:^|[\r\n])\s*(\d{1,2})\s*[\/\\]\s*(\d{1,3})\s*[\/\\]\s*(\d{1,3})\s*(?=$|[\r\n])/u);
+  if (compactTriple) {
+    const rooms = toNumber(compactTriple[1]);
+    const floor = toNumber(compactTriple[2]);
+    const totalFloors = toNumber(compactTriple[3]);
+    if (rooms != null && rooms >= 1 && rooms <= 20
+      && floor != null && totalFloors != null
+      && floor >= 1 && floor <= totalFloors && totalFloors <= 200) {
+      return deepFreeze({ floor, totalFloors });
+    }
+  }
+
   const fraction = text.match(/(?:^|[^\d])(\d{1,3})\s*[\/\\]\s*(\d{1,3})(?=$|[^\d])/u);
   if (fraction) {
     const floor = toNumber(fraction[1]);
@@ -142,7 +159,7 @@ const AREA_LABELS = Object.freeze([
   ['total', /(?:общая\s+площадь|площадь|total\s+area|surface\s+area|suprafa(?:ță|ta)(?:\s+total(?:ă|a))?|umumiy\s+maydon|жалпы\s+аудан)/iu],
 ]);
 
-const AREA_UNIT_RE = String.raw`(?:м²|м2|m²|m2|sqm|sq\.?\s*m|mp|кв\.?\s*м|квадрат\p{L}*)`;
+const AREA_UNIT_RE = String.raw`(?:м²|м2|m²|m2|sqm|sq\.?\s*m|mp|кв\.?\s*м|кв2|квадрат\p{L}*)`;
 
 function areaAfterLabel(text, labelRe) {
   const re = new RegExp(`${labelRe.source}\\s*[:=-]?\\s*(\\d{1,4}(?:[.,]\\d{1,2})?)\\s*${AREA_UNIT_RE}`, 'iu');