@whiteslove/parsing-lexicon 0.5.0 → 0.5.2

package/package.json

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

package/src/geo.js

@@ -160,7 +160,7 @@ export const TASHKENT_AREAS = Object.freeze({
   ]),
   Yunusabad: Object.freeze([
     area('Kashgar', ['кашгар', 'қашқар', 'qashqar', 'kashgar', 'ц 4', 'c 4']), area('Qiyot', ['киёт', 'кият', 'қиёт', 'qiyot', 'kiyot', 'markaz 5', 's 5']),
-    area('Minor', ['минор', 'minor', 'ц 6', 'c 6']), area('TashGRES', ['ташгрэс', 'tashgres']), area('Manzara', ['манзара', 'manzara']),
+    area('Minor', ['минор', 'minor', 'ц 6', 'c 6']), area('ToshGRES', ['ташгрэс', 'tashgres', 'TashGRES', 'toshgres']), area('Manzara', ['манзара', 'manzara']),
   ]),
   Yakkasaray: Object.freeze([
     area('Bashlyk', ['башлык', 'бошлиқ', 'boshliq', 'bashlyk']), area('Kushbegi', ['кушбеги', 'қушбеги', 'qushbegi', 'kushbegi']),

package/src/geography-display.d.ts

@@ -1,13 +1,39 @@
-export type GeographyDisplayKind = 'country' | 'region' | 'city' | 'district' | 'metro' | 'any';
+export type GeographyDisplayKind =
+  | 'country'
+  | 'region'
+  | 'city'
+  | 'district'
+  | 'microdistrict'
+  | 'mahalla'
+  | 'local_area'
+  | 'suburb'
+  | 'settlement'
+  | 'development_area'
+  | 'residential_complex'
+  | 'metro'
+  | 'street'
+  | 'poi'
+  | 'any';
+
+export type GeographyDisplayContext = Readonly<{
+  country?: string | null;
+  city?: string | null;
+}>;
 
 export const GEOGRAPHY_DISPLAY_NAMES: Readonly<Record<string, Readonly<{
   country: Readonly<Record<string, string>>;
   city: Readonly<Record<string, string>>;
   region?: Readonly<Record<string, string>>;
   district: Readonly<Record<string, string>>;
+  microdistrict: Readonly<Record<string, string>>;
   metro: Readonly<Record<string, string>>;
   metroAlias: Readonly<Record<string, string>>;
 }>>>;
 
-export function geographyDisplayName(value: unknown, locale?: string, kind?: GeographyDisplayKind): string;
+export function geographyDisplayName(
+  value: unknown,
+  locale?: string,
+  kind?: GeographyDisplayKind,
+  context?: GeographyDisplayContext | null,
+): string;
 export function geographyMetroLabelWithAlias(value: unknown, locale?: string): string;

package/src/geography-display.js

@@ -1,11 +1,34 @@
 import { COUNTRIES, canonicalCountryCode, countryByCode } from './countries.js';
 import { CITIES, REGIONS } from './geography.js';
+import { dictionaryFor } from './locations.js';
+import { aliasesOf } from './normalization.js';
 
 // Centralized presentation names for canonical geography values.
 // Consumers must not maintain their own country/city/district/metro display dictionaries.
 
 const EMPTY_DISPLAY_NAMES = Object.freeze({});
 
+const LOCATION_KIND_KEYS = Object.freeze({
+  district: Object.freeze(['districts']),
+  microdistrict: Object.freeze(['microdistricts']),
+  mahalla: Object.freeze(['mahallas']),
+  local_area: Object.freeze(['localAreas']),
+  suburb: Object.freeze(['suburbs']),
+  settlement: Object.freeze(['settlements']),
+  development_area: Object.freeze(['developmentAreas']),
+  residential_complex: Object.freeze(['residentialComplexes']),
+  metro: Object.freeze(['metro']),
+  street: Object.freeze(['streets']),
+  poi: Object.freeze(['landmarks', 'pois']),
+});
+
+const CYRILLIC_RE = /[А-ЯЁ]/iu;
+const UZBEK_CYRILLIC_RE = /[ЎҚҒҲўқғҳ]/u;
+const LATIN_RE = /[A-Z]/iu;
+const UZBEK_LATIN_MARKER_RE = /(?:[ʻ‘’ʼ']|\b(?:ko[ʻ‘’ʼ']?chasi|shoh\s+ko[ʻ‘’ʼ']?chasi|bozori|bog[ʻ‘’ʼ']?i|maydoni|masjidi|vokzali|mahallasi|mavzesi|dahasi|massivi|savdo\s+markazi|toshkent|yunusobod|chilonzor|olmazor|o[ʻ‘’ʼ']?zbekiston)\b)/iu;
+const ENGLISH_GENERIC_RE = /\b(?:street|avenue|square|park|bazaar|market|mall|mosque|railway|station|residence|city|garden|museum|theatre|theater|airport|university|hospital|school|district|microdistrict)\b/iu;
+const RUSSIAN_GENERIC_RE = /\b(?:улица|проспект|площадь|сквер|рынок|базар|парк|мечеть|вокзал|аэропорт|университет|больница|школа|район|массив|махалл|жилой|жк|центр)\b/iu;
+
 function countryDisplayNames(locale) {
   return Object.freeze(Object.fromEntries(COUNTRIES.map((item) => [
     item.code,
@@ -22,6 +45,20 @@ export const GEOGRAPHY_DISPLAY_NAMES = Object.freeze({
     metro: EMPTY_DISPLAY_NAMES,
     metroAlias: EMPTY_DISPLAY_NAMES,
   }),
+  uz: Object.freeze({
+    country: countryDisplayNames('uz'),
+    city: Object.freeze({
+      Tashkent: 'Toshkent',
+    }),
+    district: Object.freeze({
+      Chilanzar: 'Chilonzor', Yunusabad: 'Yunusobod', 'Mirzo Ulugbek': 'Mirzo Ulug‘bek',
+      Yakkasaray: 'Yakkasaroy', Shaykhantahur: 'Shayxontohur', Yashnobod: 'Yashnobod', Sergeli: 'Sergeli',
+      Uchtepa: 'Uchtepa', Mirobod: 'Mirobod', Bektemir: 'Bektemir', Almazar: 'Olmazor', Yangihayot: 'Yangihayot',
+    }),
+    microdistrict: EMPTY_DISPLAY_NAMES,
+    metro: EMPTY_DISPLAY_NAMES,
+    metroAlias: EMPTY_DISPLAY_NAMES,
+  }),
   ru: Object.freeze({
     country: countryDisplayNames('ru'),
     city: Object.freeze({
@@ -69,6 +106,8 @@ export const GEOGRAPHY_DISPLAY_NAMES = Object.freeze({
       Tsukrovyi: 'Сахарный',
       Karakamysh: 'Каракамыш', Sebzar: 'Себзар', Tashselmash: 'Ташсельмаш', Aviasozlar: 'Авиасозлар',
       Kuylyuk: 'Куйлюк', Sergeli: 'Сергели массив', Sputnik: 'Спутник', 'Yangi Choshtepa': 'Янги Чоштепа',
+      Olympia: 'Олимпия', Olimpiya: 'Олимпия', Dustlik: 'Дустлик', Karasu: 'Карасу',
+      Traktorsozlar: 'Тракторсозлар', TTZ: 'ТТЗ', Qiyot: 'Кият',
       // Same places as Choshtepa/Takhtapul above, but under the spelling the
       // mahalla registry (uz-location-extensions.js) actually uses as its
       // canonical name -- exact-key lookup means both spellings must be here.
@@ -102,6 +141,16 @@ function languageKey(locale) {
   return String(locale || 'en').toLowerCase().split(/[-_]/)[0];
 }
 
+function numberedMicrodistrictDisplayName(value, locale) {
+  if (languageKey(locale) !== 'ru') return null;
+  const text = String(value || '').trim();
+  const match = text.match(/^(.+?)[\s-]+(\d{1,2}[A-Za-zА-Яа-я]?)$/u);
+  if (!match) return null;
+  const base = GEOGRAPHY_DISPLAY_NAMES.ru.microdistrict?.[match[1]]
+    || GEOGRAPHY_DISPLAY_NAMES.ru.district?.[match[1]];
+  return base ? `${base}-${match[2]}` : null;
+}
+
 function preferredEntityLabel(entry, locale) {
   if (!entry) return null;
   const key = languageKey(locale);
@@ -119,7 +168,70 @@ function countryEntity(value) {
   return code ? countryByCode(code) : null;
 }
 
-export function geographyDisplayName(value, locale = 'en', kind = 'any') {
+function locationEntryFor(value, kind, context) {
+  const keys = LOCATION_KIND_KEYS[kind];
+  const country = canonicalCountryCode(context?.country);
+  const city = String(context?.city || '').trim();
+  if (!keys || !country || !city) return null;
+  const dictionary = dictionaryFor(country, city);
+  if (!dictionary) return null;
+  for (const key of keys) {
+    const entry = (dictionary[key] || []).find((item) => (item.canonical || item.name) === value);
+    if (entry) return entry;
+  }
+  return null;
+}
+
+function bestAlias(aliases, score) {
+  let best = null;
+  let bestScore = -Infinity;
+  for (const alias of aliases) {
+    const value = String(alias || '').trim();
+    if (!value) continue;
+    const valueScore = score(value);
+    if (valueScore > bestScore || (valueScore === bestScore && best && value.length < best.length)) {
+      best = value;
+      bestScore = valueScore;
+    }
+  }
+  return bestScore > 0 ? best : null;
+}
+
+function locationAliasLabel(entry, locale) {
+  if (!entry) return null;
+  const language = languageKey(locale);
+  const explicit = entry.labels?.[language];
+  if (explicit) return explicit;
+  const canonical = entry.canonical || entry.name || null;
+  if (language === 'en') return entry.labels?.en || canonical;
+
+  const aliases = aliasesOf(entry);
+  if (language === 'ru') {
+    return bestAlias(aliases, (alias) => {
+      if (!CYRILLIC_RE.test(alias)) return -10;
+      let score = 5;
+      if (RUSSIAN_GENERIC_RE.test(alias)) score += 8;
+      if (UZBEK_CYRILLIC_RE.test(alias)) score -= 4;
+      return score;
+    }) || canonical;
+  }
+
+  if (language === 'uz') {
+    return bestAlias(aliases, (alias) => {
+      let score = 0;
+      if (LATIN_RE.test(alias)) score += 3;
+      if (UZBEK_LATIN_MARKER_RE.test(alias)) score += 10;
+      if (UZBEK_CYRILLIC_RE.test(alias)) score += 6;
+      if (CYRILLIC_RE.test(alias) && !UZBEK_CYRILLIC_RE.test(alias)) score -= 3;
+      if (ENGLISH_GENERIC_RE.test(alias)) score -= 8;
+      return score;
+    }) || canonical;
+  }
+
+  return canonical;
+}
+
+export function geographyDisplayName(value, locale = 'en', kind = 'any', context = null) {
   const text = String(value || '').trim();
   if (!text) return '';
   const language = languageKey(locale);
@@ -131,9 +243,17 @@ export function geographyDisplayName(value, locale = 'en', kind = 'any') {
   }
   if (kind === 'city') return tables?.city?.[text] || canonicalEntityLabel(CITIES, text, locale) || text;
   if (kind === 'region') return tables?.region?.[text] || canonicalEntityLabel(REGIONS, text, locale) || text;
+
+  const localEntry = locationEntryFor(text, kind, context);
+  if (localEntry) {
+    const localized = locationAliasLabel(localEntry, locale);
+    if (localized) return localized;
+  }
+
   if (kind === 'district') return tables?.district?.[text] || text;
-  if (kind === 'microdistrict') return tables?.microdistrict?.[text] || text;
+  if (kind === 'microdistrict') return tables?.microdistrict?.[text] || numberedMicrodistrictDisplayName(text, locale) || text;
   if (kind === 'metro') return tables?.metro?.[text] || text;
+  if (LOCATION_KIND_KEYS[kind]) return text;
   return tables?.country?.[canonicalCountryCode(text)] || tables?.city?.[text] || tables?.region?.[text] || tables?.district?.[text] || tables?.microdistrict?.[text] || tables?.metro?.[text] || canonicalEntityLabel(CITIES, text, locale) || canonicalEntityLabel(REGIONS, text, locale) || preferredEntityLabel(countryEntity(text), locale) || text;
 }
 

package/src/hiring-salary-context.d.ts

@@ -1,9 +1,11 @@
 export type SalaryCurrencySource = 'explicit' | 'country-default' | 'language-default' | 'unknown';
+export type SalaryPeriodSource = 'explicit' | 'country-default' | 'unknown';
 
 export interface HiringSalaryContextOptions {
   country?: string | null;
   location?: string | null;
   currencyFallback?: 'country' | 'language';
+  periodFallback?: 'country';
 }
 
 export interface ParsedHiringSalaryWithContext {
@@ -16,11 +18,15 @@ export interface ParsedHiringSalaryWithContext {
   approximate: boolean;
   currencySource: SalaryCurrencySource;
   currencyCountry: string | null;
+  periodSource: SalaryPeriodSource;
+  periodCountry: string | null;
   [key: string]: unknown;
 }
 
 export const COUNTRY_DEFAULT_CURRENCIES: Readonly<Record<string, string>>;
+export const COUNTRY_DEFAULT_SALARY_PERIODS: Readonly<Record<string, string>>;
 export function defaultCurrencyForCountry(value: unknown): string | null;
+export function defaultSalaryPeriodForCountry(value: unknown): string | null;
 export function parseHiringSalaryWithContext(
   value: unknown,
   options?: HiringSalaryContextOptions,

package/src/hiring-salary-context.js

@@ -18,11 +18,31 @@ export const COUNTRY_DEFAULT_CURRENCIES = Object.freeze({
   GE: 'GEL',
 });
 
+// These markets conventionally quote ordinary vacancy salaries per month when
+// a posting gives a local compensation amount but omits an explicit period.
+// Keep this deliberately narrow and opt-in: US/GB postings, for example, must
+// not silently become monthly because annual/hourly quoting is also common.
+export const COUNTRY_DEFAULT_SALARY_PERIODS = Object.freeze({
+  UA: 'month',
+  UZ: 'month',
+  KZ: 'month',
+  KG: 'month',
+  RO: 'month',
+  PL: 'month',
+  TR: 'month',
+  GE: 'month',
+});
+
 export function defaultCurrencyForCountry(value) {
   const country = detectCountryCodeFromText(value);
   return country ? COUNTRY_DEFAULT_CURRENCIES[country] || null : null;
 }
 
+export function defaultSalaryPeriodForCountry(value) {
+  const country = detectCountryCodeFromText(value);
+  return country ? COUNTRY_DEFAULT_SALARY_PERIODS[country] || null : null;
+}
+
 function contextCountry(options) {
   return detectCountryCodeFromText(options.country)
     || detectCountryCodeFromText(options.location)
@@ -39,45 +59,59 @@ function languageDefaultCountry(value) {
   return null;
 }
 
-function withCurrencyContext(parsed, value, options) {
+function withContext(parsed, value, options) {
   if (!parsed) return null;
-  if (parsed.currency) {
-    return Object.freeze({
-      ...parsed,
-      currencySource: 'explicit',
-      currencyCountry: null,
-    });
+
+  let currency = parsed.currency;
+  let currencySource = 'explicit';
+  let currencyCountry = null;
+  if (!currency) {
+    let country = null;
+    if (options.currencyFallback === 'country') country = contextCountry(options);
+    else if (options.currencyFallback === 'language') country = languageDefaultCountry(value);
+    currency = country ? COUNTRY_DEFAULT_CURRENCIES[country] || null : null;
+    currencySource = currency
+      ? options.currencyFallback === 'language' ? 'language-default' : 'country-default'
+      : 'unknown';
+    currencyCountry = currency ? country : null;
   }
 
-  let country = null;
-  if (options.currencyFallback === 'country') country = contextCountry(options);
-  else if (options.currencyFallback === 'language') country = languageDefaultCountry(value);
+  let period = parsed.period;
+  let periodSource = period ? 'explicit' : 'unknown';
+  let periodCountry = null;
+  if (!period && options.periodFallback === 'country') {
+    const country = contextCountry(options);
+    const fallback = country ? COUNTRY_DEFAULT_SALARY_PERIODS[country] || null : null;
+    if (fallback) {
+      period = fallback;
+      periodSource = 'country-default';
+      periodCountry = country;
+    }
+  }
 
-  const currency = country ? COUNTRY_DEFAULT_CURRENCIES[country] || null : null;
   return Object.freeze({
     ...parsed,
     currency,
-    currencySource: currency
-      ? options.currencyFallback === 'language' ? 'language-default' : 'country-default'
-      : 'unknown',
-    currencyCountry: currency ? country : null,
+    period,
+    currencySource,
+    currencyCountry,
+    periodSource,
+    periodCountry,
   });
 }
 
 /**
- * Parse salary text and optionally infer a missing currency from geography or
- * unambiguous local salary-language markers.
+ * Parse salary text and optionally infer missing currency/period from geography
+ * or unambiguous local salary-language markers.
  *
- * The fallback is deliberately opt-in. A bare number must never silently become
- * USD merely because a consumer happens to normalize all salaries to USD later.
- * Provenance is returned in `currencySource` so consumers can distinguish an
- * explicit currency from a contextual fallback.
+ * Fallbacks are deliberately opt-in. Provenance is returned so consumers can
+ * distinguish explicit values from contextual defaults.
  */
 export function parseHiringSalaryWithContext(value, options = {}) {
-  return withCurrencyContext(parseSalary(value), 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}*|оклад\p{L}*|вилка\s+оплат\p{L}*|оплата\s+труда|компенсац\p{L}*|ставка)/giu;
+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;
 
 // AI-recruiting/staffing postings (e.g. Mercor) routinely mention funding,
 // valuation or revenue figures in the same listing as the actual salary. A

package/src/hiring-vacancy-fields.d.ts

@@ -1,5 +1,11 @@
 export type HiringEducation = 'doctorate' | 'master' | 'bachelor' | 'higher' | 'secondary';
 export type HiringApplicationLanguage = 'English' | 'Russian' | 'Ukrainian' | 'Uzbek' | 'Kazakh' | 'Romanian';
 
+export interface HiringAgeRange {
+  min: number | null;
+  max: number | null;
+}
+
 export function detectHiringEducation(value: unknown): HiringEducation | null;
 export function detectApplicationLanguage(value: unknown): HiringApplicationLanguage | null;
+export function extractHiringAgeRange(value: unknown): HiringAgeRange | null;

package/src/hiring-vacancy-fields.js

@@ -1,7 +1,14 @@
 import { detectDegreeLevel } from './hiring-requirements.js';
+import { normalizeUnicode } from './normalization.js';
 
 export function detectHiringEducation(value) {
   const text = String(value || '');
+  // Vacancy requirements often state "Bachelor's or Master's degree". That is
+  // an accepted-alternative list, not a Master's minimum; expose the least
+  // restrictive accepted level so filters do not hide valid Bachelor holders.
+  if (/(?:bachelor['’]?s?|бакалавр\p{L}*)[^.;\n]{0,40}(?:or|\/|или|або|sau|yoki)[^.;\n]{0,40}(?:master['’]?s?|магистр\p{L}*|магістр\p{L}*)/iu.test(text)
+    || /(?:master['’]?s?|магистр\p{L}*|магістр\p{L}*)[^.;\n]{0,40}(?:or|\/|или|або|sau|yoki)[^.;\n]{0,40}(?:bachelor['’]?s?|бакалавр\p{L}*)/iu.test(text)) return 'bachelor';
+
   const degree = detectDegreeLevel(text);
   if (degree) return degree;
   if (/higher education|высшее образование|вища освіта|олий маълумот/iu.test(text)) return 'higher';
@@ -21,3 +28,39 @@ export function detectApplicationLanguage(value) {
   if (/romanian|румын/.test(language)) return 'Romanian';
   return null;
 }
+
+function validAge(value) {
+  const age = Number(value);
+  return Number.isFinite(age) && age >= 14 && age <= 90 ? age : null;
+}
+
+/** Extract an explicit vacancy candidate-age requirement without confusing it with experience. */
+export function extractHiringAgeRange(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text) return null;
+
+  const patterns = [
+    // Russian/Ukrainian/Romanian/English labels: "Возраст от 18 до 35 лет".
+    /(?:возраст|вік|age|vârsta|varsta)\s*[:—-]?[^\d]{0,18}(?:от|від|from|de\s+la)?\s*(\d{1,2})\s*(?:[-–—]|до|to|până\s+la|pana\s+la)\s*(\d{1,2})(?:\s*(?:лет|рок\p{L}*|years?|ani))?/iu,
+    // Uzbek Latin/Cyrillic: "18 dan 40 yoshgacha", including common "20 madan" typo.
+    /(?:^|[^\d])(\d{1,2})\s*(?:yosh(?:dan)?|ёш(?:дан)?|dan|дан|madan)?\s*(?:[-–—]|dan\s+|дан\s+)?(?:to|до)?\s*(\d{1,2})\s*(?:yoshgacha|ёшгача|yoshga\s+qadar|ёшга\s+қадар)(?=$|[^\p{L}\p{N}_])/iu,
+    /(?:yosh|ёш)\s*[:—-]?[^\d]{0,18}(\d{1,2})\s*(?:[-–—]|dan\s+|дан\s+|gacha\s+|гача\s+)(\d{1,2})/iu,
+  ];
+
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (!match) continue;
+    const first = validAge(match[1]);
+    const second = validAge(match[2]);
+    if (first == null || second == null) continue;
+    return Object.freeze({ min: Math.min(first, second), max: Math.max(first, second) });
+  }
+
+  const minMatch = text.match(/(?:возраст|вік|age|yosh|ёш)\s*[:—-]?[^\d]{0,16}(?:от|від|from|kamida|камида)?\s*(\d{1,2})\s*\+?(?:\s*(?:лет|рок\p{L}*|years?|yosh|ёш))?/iu);
+  const minimum = validAge(minMatch?.[1]);
+  if (minimum != null) return Object.freeze({ min: minimum, max: null });
+
+  const uzMax = text.match(/(?:^|[^\d])(\d{1,2})\s*(?:yoshgacha|ёшгача)(?=$|[^\p{L}\p{N}_])/iu);
+  const maximum = validAge(uzMax?.[1]);
+  return maximum != null ? Object.freeze({ min: null, max: maximum }) : null;
+}

package/src/hiring-work-semantics.js

@@ -1,4 +1,4 @@
-import { findCanonical } from './normalization.js';
+import { aliasesOf, aliasesToRegex, findCanonical } from './normalization.js';
 import {
   EMPLOYMENT_TYPES,
   EXPERIENCE_REQUIREMENTS,
@@ -27,10 +27,24 @@ const PROBATION_MATCH_ORDER = Object.freeze([
   PROBATION_TERMS.probation,
 ]);
 
+function matchesEmploymentType(text, entry) {
+  // `project` is a useful canonical output but a dangerously generic input:
+  // ordinary vacancy prose says "projects", "Project Tech Stack" and
+  // "international projects" without describing project-based employment.
+  // Its multilingual aliases already encode the actual employment semantics
+  // ("project work", "project-based", "проектная работа", etc.), so only
+  // those aliases are accepted for this one canonical.
+  if (entry.canonical === 'project') {
+    const aliases = aliasesOf(entry);
+    return aliases.length ? aliasesToRegex(aliases).test(text) : false;
+  }
+  return Boolean(findCanonical(text, [entry], { partial: true }));
+}
+
 function collectCanonical(text, entries) {
   const values = [];
   for (const entry of entries) {
-    if (!findCanonical(text, [entry], { partial: true })) continue;
+    if (!matchesEmploymentType(text, entry)) continue;
     if (!values.includes(entry.canonical)) values.push(entry.canonical);
   }
   return values;

package/src/locations.js

@@ -53,42 +53,262 @@ const UZ_BASE_LOCATION_DICTIONARIES = Object.freeze({
   }),
 });
 
-function normalizeUzSemanticLocations(country) {
-  const tashkent = country?.Tashkent;
-  if (!tashkent) return country;
-  const qorasuv = (tashkent.microdistricts || []).find(({ name }) => name === 'Qorasuv');
-  if (!qorasuv) return country;
-
-  // Bare Qorasuv is ambiguous with numbered Qorasuv/Karasu blocks. The
-  // umbrella area therefore requires an area/massif/daha form in free text.
-  const qorasuvAliases = Object.freeze([...new Set([
-    ...(qorasuv.aliases || []).filter((alias) => !/^(?:qorasuv|korasuv|корасув|карасу)$/iu.test(String(alias).trim())),
-    'Qorasuv dahasi',
-    'Qorasuv daha',
-    'Қорасув даҳаси',
-    'Корасув дахаси',
-    'Карасу даха',
-  ])]);
-  const qorasuvArea = Object.freeze({
-    ...qorasuv,
-    type: 'local_area',
-    entityType: 'local_area',
-    parent: 'Mirzo Ulugbek',
-    aliases: qorasuvAliases,
-    re: aliasesToRegex(qorasuvAliases),
+function semanticEntry(entry, name, aliases, entityType) {
+  const all = Object.freeze([...new Set([name, ...aliases].filter(Boolean))]);
+  return Object.freeze({
+    ...entry,
+    canonical: name,
+    name,
+    type: entityType,
+    entityType,
+    aliases: all,
+    re: aliasesToRegex(all),
   });
+}
 
-  return Object.freeze({
-    ...country,
-    Tashkent: Object.freeze({
-      ...tashkent,
-      microdistricts: Object.freeze((tashkent.microdistricts || []).filter(({ name }) => name !== 'Qorasuv')),
-      localAreas: Object.freeze([
-        ...(tashkent.localAreas || []),
-        qorasuvArea,
-      ]),
+function normalizeUzSemanticLocations(country) {
+  let normalized = Object.freeze(Object.fromEntries(
+    Object.entries(country || {}).map(([cityName, data]) => {
+      const localAreas = data?.localAreas || [];
+      if (!localAreas.some(({ name }) => name === 'University area')) return [cityName, data];
+
+      return [cityName, Object.freeze({
+        ...data,
+        localAreas: Object.freeze(localAreas.map((entry) => (
+          entry.name === 'University area'
+            ? semanticEntry(entry, 'University area', [
+              ...(entry.aliases || []),
+              'Universitet hududi',
+              'Universitet atrofi',
+              'Университет ҳудуди',
+              'Университет атрофи',
+            ], 'local_area')
+            : entry
+        ))),
+      })];
     }),
-  });
+  ));
+  const tashkent = normalized?.Tashkent;
+  const qorasuv = (tashkent?.microdistricts || []).find(({ name }) => name === 'Qorasuv');
+
+  if (tashkent && qorasuv) {
+    // Bare Qorasuv is ambiguous with numbered Qorasuv/Karasu blocks. The
+    // umbrella area therefore requires an area/massif/daha form in free text.
+    const qorasuvAliases = Object.freeze([...new Set([
+      ...(qorasuv.aliases || []).filter((alias) => !/^(?:qorasuv|korasuv|корасув|карасу)$/iu.test(String(alias).trim())),
+      'Qorasuv dahasi',
+      'Qorasuv daha',
+      'Қорасув даҳаси',
+      'Корасув дахаси',
+      'Карасу даха',
+    ])]);
+    const qorasuvArea = Object.freeze({
+      ...qorasuv,
+      type: 'local_area',
+      entityType: 'local_area',
+      parent: 'Mirzo Ulugbek',
+      aliases: qorasuvAliases,
+      re: aliasesToRegex(qorasuvAliases),
+    });
+
+    normalized = Object.freeze({
+      ...normalized,
+      Tashkent: Object.freeze({
+        ...tashkent,
+        microdistricts: Object.freeze((tashkent.microdistricts || []).filter(({ name }) => name !== 'Qorasuv')),
+        localAreas: Object.freeze([
+          ...(tashkent.localAreas || []),
+          qorasuvArea,
+        ]),
+      }),
+    });
+  }
+
+  const samarkand = normalized?.Samarkand;
+  if (samarkand) {
+    const landmarks = samarkand.landmarks || [];
+    const localAreas = samarkand.localAreas || [];
+    const streets = samarkand.streets || [];
+
+    // Legacy UZ seeds contain a few Samarkand listing labels as separate
+    // canonicals or under the wrong semantic collection. Normalize them to the
+    // single physical subjects already represented by geo-catalog.
+    const centralPark = landmarks.find(({ name }) => name === 'Central Park');
+    const alisherPark = landmarks.find(({ name }) => name === 'Alisher Navoiy Park');
+    const canonicalPark = centralPark || alisherPark;
+    const parkAliases = [
+      ...(centralPark?.aliases || []),
+      ...(alisherPark?.aliases || []),
+      'Central Park',
+      'Alisher Navoiy Park',
+    ];
+    const normalizedPark = canonicalPark
+      ? semanticEntry(canonicalPark, 'Central Park', parkAliases, 'poi')
+      : null;
+
+    const siyobBazaar = landmarks.find(({ name }) => name === 'Siyob Bazaar');
+    const siabBazaar = landmarks.find(({ name }) => name === 'Siab Bazaar');
+    const canonicalBazaar = siyobBazaar || siabBazaar;
+    const bazaarAliases = [
+      ...(siyobBazaar?.aliases || []),
+      ...(siabBazaar?.aliases || []),
+      'Siyob Bazaar',
+      'Siab Bazaar',
+    ];
+    const normalizedBazaar = canonicalBazaar
+      ? semanticEntry(canonicalBazaar, 'Siyob Bazaar', bazaarAliases, 'poi')
+      : null;
+
+    const universityLocalArea = localAreas.find(({ name }) => name === 'University Boulevard');
+    const universityLandmark = landmarks.find(({ name }) => name === 'University Boulevard');
+    const universityStreet = streets.find(({ name }) => name === 'University Boulevard');
+    const canonicalUniversity = universityStreet || universityLandmark || universityLocalArea;
+    const universityAliases = [
+      ...(universityStreet?.aliases || []),
+      ...(universityLandmark?.aliases || []),
+      ...(universityLocalArea?.aliases || []),
+      'University Boulevard',
+    ];
+    const normalizedUniversity = canonicalUniversity
+      ? semanticEntry(canonicalUniversity, 'University Boulevard', universityAliases, 'street')
+      : null;
+
+    normalized = Object.freeze({
+      ...normalized,
+      Samarkand: Object.freeze({
+        ...samarkand,
+        localAreas: Object.freeze(localAreas.filter(({ name }) => name !== 'University Boulevard')),
+        streets: Object.freeze([
+          ...streets.filter(({ name }) => name !== 'University Boulevard'),
+          ...(normalizedUniversity ? [normalizedUniversity] : []),
+        ]),
+        landmarks: Object.freeze([
+          ...landmarks.filter(({ name }) => ![
+            'Central Park',
+            'Alisher Navoiy Park',
+            'Siyob Bazaar',
+            'Siab Bazaar',
+            'University Boulevard',
+            'Samarkand City',
+          ].includes(name)),
+          ...(normalizedPark ? [normalizedPark] : []),
+          ...(normalizedBazaar ? [normalizedBazaar] : []),
+        ]),
+      }),
+    });
+  }
+
+  const khiva = normalized?.Khiva;
+  if (khiva) {
+    const localAreas = khiva.localAreas || [];
+    const ichanKala = localAreas.find(({ name }) => name === 'Ichan Kala');
+    const oldCity = localAreas.find(({ name }) => name === 'Old City');
+
+    if (ichanKala && oldCity) {
+      // UNESCO identifies Itchan Kala as the historic inner-city of Khiva.
+      // Keep listing-friendly Old City forms as aliases of that one place.
+      const normalizedIchanKala = semanticEntry(ichanKala, 'Ichan Kala', [
+        ...(ichanKala.aliases || []),
+        ...(oldCity.aliases || []),
+        'Old City',
+      ], 'local_area');
+
+      normalized = Object.freeze({
+        ...normalized,
+        Khiva: Object.freeze({
+          ...khiva,
+          localAreas: Object.freeze([
+            ...localAreas.filter(({ name }) => !['Ichan Kala', 'Old City'].includes(name)),
+            normalizedIchanKala,
+          ]),
+        }),
+      });
+    }
+  }
+
+  const angren = normalized?.Angren;
+  if (angren) {
+    const microdistricts = angren.microdistricts || [];
+    const localAreas = angren.localAreas || [];
+    const mahallas = angren.mahallas || [];
+    const streets = angren.streets || [];
+    const legacyMicrodistrictNames = new Set([
+      '1 microdistrict',
+      '2 microdistrict',
+      '3 microdistrict',
+      '4 microdistrict',
+      '5 microdistrict',
+    ]);
+
+    const quarterRows = Object.freeze([
+      ['2 quarter', ['2-daha','2 daha','2 dahasi','2-й квартал','2 квартал','2 microdistrict','2 микрорайон','2-mikrorayon','2 mikrorayon','2 мкр']],
+      ['3 quarter', ['3-daha','3 daha','3 dahasi','3-й квартал','3 квартал','3 microdistrict','3 микрорайон','3-mikrorayon','3 mikrorayon','3 мкр']],
+      ['5 quarter', ['5-daha','5 daha','5 dahasi','5-й квартал','5 квартал','5 microdistrict','5 микрорайон','5-mikrorayon','5 mikrorayon','5 мкр']],
+      ['6 quarter', ['6-daha','6 daha','6 dahasi','6-й квартал','6 квартал']],
+      ['7 quarter', ['7-daha','7 daha','7 dahasi','7-й квартал','7 квартал']],
+      ['8 quarter', ['8-daha','8 daha','8 dahasi','8-й квартал','8 квартал']],
+      ['9 quarter', ['9-daha','9 daha','9 dahasi','9-й квартал','9 квартал']],
+      ['10 quarter', ['10-daha','10 daha','10 dahasi','10-й квартал','10 квартал']],
+      ['11 quarter', ['11-daha','11 daha','11 dahasi','11-й квартал','11 квартал']],
+      ['32 quarter', ['32-daha','32 daha','32 dahasi','32-й квартал','32 квартал']],
+      ['2/2 quarter', ['2/2-daha','2/2 daha','2/2 dahasi','2/2 квартал']],
+      ['2/5 quarter', ['2/5-daha','2/5 daha','2/5 dahasi','2/5 квартал']],
+      ['3/2 quarter', ['3/2-daha','3/2 daha','3/2 dahasi','3/2 квартал']],
+      ['3/3 quarter', ['3/3-daha','3/3 daha','3/3 dahasi','3/3 квартал']],
+      ['4/5 quarter', ['4/5-daha','4/5 daha','4/5 dahasi','4/5 квартал']],
+      ['4/6 quarter', ['4/6-daha','4/6 daha','4/6 dahasi','4/6 квартал']],
+      ['5/1A quarter', ['5/1A-daha','5/1A daha','5/1A dahasi','5/1-A daha','5/1-A dahasi','5/1A квартал','5/1-A квартал']],
+      ['5/1B quarter', ['5/1B-daha','5/1B daha','5/1B dahasi','5/1-B daha','5/1-B dahasi','5/1B квартал','5/1-B квартал']],
+      ['5/3 quarter', ['5/3-daha','5/3 daha','5/3 dahasi','5/3 квартал']],
+      ['5/4 quarter', ['5/4-daha','5/4 daha','5/4 dahasi','5/4 квартал']],
+      ['5/5 quarter', ['5/5-daha','5/5 daha','5/5 dahasi','5/5 квартал']],
+      ['6/4 quarter', ['6/4-daha','6/4 daha','6/4 dahasi','6/4 квартал']],
+      ['18/19 quarter', ['18/19-daha','18/19 daha','18/19 dahasi','18/19 квартал']],
+    ]);
+    const verifiedQuarterNames = new Set(quarterRows.map(([name]) => name));
+    const quarterEntries = quarterRows.map(([name, aliases]) => semanticEntry({}, name, aliases, 'microdistrict'));
+
+    const geologLocalArea = localAreas.find(({ name }) => name === 'Geolog');
+    const geologAliases = [
+      ...(geologLocalArea?.aliases || []),
+      'Geolog MFY',
+      'Geolog mahallasi',
+      "Geolog mahalla fuqarolar yig'ini",
+      'Геолог МФЙ',
+      'махалля Геолог',
+    ];
+    const geologMahalla = semanticEntry(geologLocalArea || {}, 'Geolog', geologAliases, 'mahalla');
+
+    const verifiedStreetRows = Object.freeze([
+      ['Amir Temur Street', ['Amir Temur ko‘chasi',"Amir Temur ko'chasi",'улица Амира Темура','ул. Амира Темура']],
+      ['Bunyodkor Street', ['Bunyodkor ko‘chasi',"Bunyodkor ko'chasi",'Бунёдкор кўчаси','улица Бунёдкор','ул. Бунёдкор']],
+      ['Ohangaron Street', ['Ohangaron ko‘chasi',"Ohangaron ko'chasi",'Оҳангарон кўчаси','улица Ахангаран','улица Охангарон']],
+    ]);
+    const verifiedStreetNames = new Set(verifiedStreetRows.map(([name]) => name));
+    const verifiedStreets = verifiedStreetRows.map(([name, aliases]) => semanticEntry({}, name, aliases, 'street'));
+
+    normalized = Object.freeze({
+      ...normalized,
+      Angren: Object.freeze({
+        ...angren,
+        mahallas: Object.freeze([
+          ...mahallas.filter(({ name }) => name !== 'Geolog'),
+          geologMahalla,
+        ]),
+        microdistricts: Object.freeze([
+          ...microdistricts.filter(({ name }) => !legacyMicrodistrictNames.has(name) && !verifiedQuarterNames.has(name)),
+          ...quarterEntries,
+        ]),
+        localAreas: Object.freeze(localAreas.filter(({ name }) => name !== 'Geolog')),
+        streets: Object.freeze([
+          ...streets.filter(({ name }) => !verifiedStreetNames.has(name)),
+          ...verifiedStreets,
+        ]),
+      }),
+    });
+  }
+
+  return normalized;
 }
 
 const ODESA_FONTAN_STATION_RE = /^(?:[5-9]|1[0-6]) Fontan Station$/u;

package/src/money-core.js

@@ -8,7 +8,10 @@ import {
 // Monetary values in job descriptions commonly combine thousands grouping with
 // decimals (e.g. 137,000.00 or 137.000,00). Keep the grouped variants ahead of
 // the generic decimal form so a range parser consumes the complete endpoint.
-export const MONEY_NUMBER_PATTERN = '(?:\\d{1,3}(?:[ \\u00a0]\\d{3})+(?:[.,]\\d+)?|\\d{1,3}(?:,\\d{3})+(?:\\.\\d+)?|\\d{1,3}(?:\\.\\d{3})+(?:,\\d+)?|\\d+(?:[.,]\\d+)?)';
+// Local boards also occasionally split a salary with a mistyped first group
+// ("4 00 000" instead of "400 000"). Accept that only when there are at least
+// two spaced groups, which keeps ordinary two-number prose out of money parsing.
+export const MONEY_NUMBER_PATTERN = '(?:\\d{1,3}(?:[ \\u00a0]\\d{2,3}){2,}(?:[.,]\\d+)?|\\d{1,3}(?:[ \\u00a0]\\d{3})+(?:[.,]\\d+)?|\\d{1,3}(?:,\\d{3})+(?:\\.\\d+)?|\\d{1,3}(?:\\.\\d{3})+(?:,\\d+)?|\\d+(?:[.,]\\d+)?)';
 export const MONEY_SCALE_PATTERN = 'k|к|тыс\\.?|тысяч(?:а|и)?|тис\\.?|thousand|ming|мың|m|м|млн\\.?|mln|million|миллион(?:ов)?|мільйон(?:ів)?|bn|млрд|mlrd|billion';
 // Each scale group needs the token-boundary guard MONEY_SINGLE_RE already has
 // below: without it, "2 до 3 месяцев" reads "м" off "месяцев" as the million

package/src/money.js

@@ -32,9 +32,11 @@ export {
 // following phone-like number as a protected contact span.
 const CONTACT_MARKER_RE = /(?<![\p{L}\p{N}_])(?:телефон|тел\.?|phone|mobile|mob\.?|whatsapp|viber|telegram|контакт|contact|aloqa|murojaat|bog(?:['’ʻʼ‘`])?lanish)\s*[:：—-]?\s*$/iu;
 const JOBS_I18N_PERIOD_RE = /\bjobs\.per(hour|day|shift|week|month|year|project|piece)\b/iu;
+const TIME_RANGE_RE = /(?<!\d)(?:[01]?\d|2[0-3])[:.][0-5]\d\s*(?:[-–—]\s*(?:[01]?\d|2[0-3])[:.][0-5]\d)?(?!\d)/gu;
+const WORK_RATIO_RE = /(?<!\d)[1-7]\s*\/\s*[1-7](?!\d)/gu;
 
 function hasSalaryContext(text) {
-  return /(?:salary|зарплат|з\s*п\b|оплат|ставк|доход|оклад|компенсац|maosh|oylik|ish\s+haqi|жалақы|айлық|еңбекақы|salariu|оплата)/iu.test(text);
+  return /(?:salary|зарплат|заработ\p{L}*\s+плат|з\s*[\/\\.\-]?\s*п(?=$|[^\p{L}\p{N}_])|оплат|ставк|доход|оклад|компенсац|maosh|oylik|ish\s+haqi|жалақы|айлық|еңбекақы|salariu|💵|💰)/iu.test(text);
 }
 
 function periodFromText(text) {
@@ -57,7 +59,26 @@ function protectedPhoneSpans(text) {
   });
 }
 
-function overlapsProtectedPhone(start, end, spans) {
+function regexSpans(text, pattern) {
+  const spans = [];
+  pattern.lastIndex = 0;
+  for (const match of text.matchAll(pattern)) {
+    const start = match.index ?? 0;
+    spans.push({ start, end: start + match[0].length });
+  }
+  pattern.lastIndex = 0;
+  return spans;
+}
+
+function protectedNonMoneySpans(text) {
+  return [
+    ...protectedPhoneSpans(text),
+    ...regexSpans(text, TIME_RANGE_RE),
+    ...regexSpans(text, WORK_RATIO_RE),
+  ];
+}
+
+function overlapsProtectedSpan(start, end, spans) {
   return spans.some((span) => start < span.end && end > span.start);
 }
 
@@ -75,7 +96,7 @@ function rangeSearchText(text) {
   // MONEY_RANGE_RE intentionally parses numeric structure only. Currency symbols
   // may legally repeat around both endpoints ("$55 — $65"); blank them with
   // equal-length whitespace so the range parser can see the numbers while all
-  // original indices still line up with phone protection/context scoring.
+  // original indices still line up with contact/time protection and scoring.
   let normalized = text;
   for (const symbol of Object.keys(CURRENCY_SYMBOL_CANDIDATES)) {
     normalized = normalized.split(symbol).join(' '.repeat(symbol.length));
@@ -90,7 +111,7 @@ function bestRange(text, protectedSpans) {
   for (const match of searchable.matchAll(ranges)) {
     const start = match.index ?? 0;
     const end = start + match[0].length;
-    if (overlapsProtectedPhone(start, end, protectedSpans)) continue;
+    if (overlapsProtectedSpan(start, end, protectedSpans)) continue;
     const scaled = Boolean(match[2] || match[4]);
     const score = moneyContextScore(text, start, end, scaled);
     if (score <= 0) continue;
@@ -114,7 +135,7 @@ export function parseSalary(value) {
     || NUMBER_MULTIPLIERS.some((entry) => findCanonical(text, [entry], { partial: true }));
   if (!salaryContext && !negotiable) return null;
 
-  const protectedSpans = protectedPhoneSpans(text);
+  const protectedSpans = protectedNonMoneySpans(text);
   const range = bestRange(text, protectedSpans);
   let min = null;
   let max = null;
@@ -132,7 +153,7 @@ export function parseSalary(value) {
     for (const match of text.matchAll(MONEY_SINGLE_RE)) {
       const start = match.index ?? 0;
       const end = start + match[0].length;
-      if (overlapsProtectedPhone(start, end, protectedSpans)) continue;
+      if (overlapsProtectedSpan(start, end, protectedSpans)) continue;
       const window = text.slice(Math.max(0, start - 24), Math.min(text.length, end + 32));
       const scaled = Boolean(match[2]);
       const score = moneyContextScore(text, start, end, scaled);

package/src/uz-location-extensions.js

@@ -344,7 +344,10 @@ export const UZ_LOCATION_EXTENSIONS = Object.freeze({
 
   Navoiy: city({
     mahallas: [{ name: 'Guliston', aliases: ['Гулистон'], confidence: 'official' }],
-    microdistricts: numberedMicrodistricts([1,2,3,4,5,6,7,8,9,10,11,12]),
+    microdistricts: [
+      ...numberedMicrodistricts([1,2,3,4,5,6,7,8,9,10,11,12]),
+      ['17 microdistrict','17-kichik nohiya','17 kichik nohiya','17-й микрорайон','17 микрорайон','17-mikrorayon','17 mikrorayon','17 мкр'],
+    ],
     localAreas: [['Uzbekiston Massiv',"O'zbekiston massivi",'Узбекистон массив','Ўзбекистон массиви'],['Yangi Navoiy','Янги Навои','Янги Навоий'],['Center','Markaz','Центр'],['Sputnik','Спутник'],['Railway Station area','Вокзал']],
     landmarks: [['Alisher Navoiy Park',"Alisher Navoiy bog'i",'парк Алишера Навои'],['Farhod Palace of Culture','Farhod madaniyat saroyi','Дворец культуры Фархад'],['Navoiy Mining and Metallurgical Company','Navoiy kon-metallurgiya kombinati','НГМК','NGMK','Навоийский ГМК'],['Navoi International Airport','Navoiy aeroporti','NVI']],
   }),
@@ -370,7 +373,13 @@ export const UZ_LOCATION_EXTENSIONS = Object.freeze({
 
   Almalyk: city({
     mahallas: [{ name: 'Kamalak', aliases: ['Камалак','Радуга'], confidence: 'official' }],
-    microdistricts: numberedMicrodistricts([1,2,3,4,5]),
+    microdistricts: [
+      ...numberedMicrodistricts([1,2,3,4,5]),
+      ['5/1 microdistrict','5/1-kichik nohiya','5/1 kichik nohiya','5/1 микрорайон'],
+      ['5/2 microdistrict','5/2-kichik nohiya','5/2 kichik nohiya','5/2 микрорайон'],
+      ['5/3 microdistrict','5/3-kichik nohiya','5/3 kichik nohiya','5/3 микрорайон'],
+      ['Yubileyny microdistrict','Yubileyny','Yubiley kichi- nohiya','Yubiley kichik nohiya','Юбилейный микрорайон','Юбилейный'],
+    ],
     localAreas: [['Center','Markaz','Центр'],['Old City','Eski shahar','Старый город'],['New City','Yangi shahar','Новый город'],['Metallurg','Металлург'],['Sports Palace area','Дворец спорта'],['Railway Station area','Вокзал']],
     landmarks: [['Almalyk MMC','АГМК','AGMK','ОКМК','OKMK','Олмалиқ КМК','Almalyk Mining and Metallurgical Complex'],['Metallurg Stadium','Metallurg stadioni','стадион Металлург']],
   }),