@whiteslove/parsing-lexicon 0.2.7 → 0.2.10

package/package.json

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

package/src/contact.js

@@ -166,7 +166,9 @@ export function parsePrimaryContact(value) {
     const digits = intl[0].replace(/\D/g, '');
     if (digits.length >= 10 && digits.length <= 15) return `+${digits}`;
   }
-  const keyword = text.match(/(?:tel|тел|phone|моб|whats?app|viber|telegram|звонит|звоніть|aloqa|byla|contact)[^\d+]{0,8}(\+?\d[\d\s().-]{6,}\d)/iu);
+  // Bounded like the `trailing` keyword below: "тел"/"phone" must be a whole
+  // word, not a suffix of an unrelated word ("хостел", "котел").
+  const keyword = text.match(/(?<![\p{L}\p{N}_])(?:tel|тел|phone|моб|whats?app|viber|telegram|звонит|звоніть|aloqa|byla|contact)(?![\p{L}\p{N}_])[^\d+]{0,8}(\+?\d[\d\s().-]{6,}\d)/iu);
   if (keyword) {
     const digits = keyword[1].replace(/\D/g, '');
     if (digits.length >= 9 && digits.length <= 15) return keyword[1].trim();

package/src/hiring-context-compat.js

@@ -0,0 +1,22 @@
+import { parseHiringContext as parseBaseHiringContext } from './hiring-context.js';
+
+const EXPLICIT_POSITIVE_VISA_SPONSORSHIP_RE = /\bwe\s+do\s+sponsor\s+visas?\b/i;
+
+/**
+ * Compatibility refinements for real-world hiring copy that is intentionally
+ * more specific than the generic alias catalog. Keep this wrapper tiny so the
+ * base multilingual context parser remains the single source of truth.
+ */
+export function parseHiringContext(value, options = {}) {
+  const text = String(value || '');
+  const parsed = parseBaseHiringContext(text, options);
+  if (!EXPLICIT_POSITIVE_VISA_SPONSORSHIP_RE.test(text)
+    || parsed.workAuthorization.includes('sponsorshipOffered')) {
+    return parsed;
+  }
+
+  return Object.freeze({
+    ...parsed,
+    workAuthorization: Object.freeze([...parsed.workAuthorization, 'sponsorshipOffered']),
+  });
+}

package/src/hiring-semantics.js

@@ -19,7 +19,10 @@ const STATUS_ONLY_RE = /^(?:talaba|student|студент(?:ка)?|студен
 const FLEXIBLE_ROLE_RE = /^(?:нет|без)\s+разницы(?:\s+.*)?$|^не\s*важно(?:\s+.*)?$|^farqi\s+yo['’ʻʼ‘`]?q$|^любая\s+(?:работа|занятость)(?:\s+.*)?$/iu;
 const NON_ROLE_RE = /^(?:удал[её]нно|работа\s+на\s+удал[её]н\p{L}*\s+основе|remote|onlayn|online|онлайн|farqi\s+yo['’ʻʼ‘`]?q|bilmaym\p{L}*|ish\s+ker(?:e|a)\s+onlayn|любая\s+(?:работа|занятость)|немає|нет|не\s+указано|not\s+specified)$/iu;
 const REMOTE_NEGATIVE_RE = /(?:onsite|on-site|office\s+only|тільки\s+офіс|только\s+офис|офисн(?:ый|ая)\s+формат|офлайн|без\s+удал[её]нк|удал[её]нк\p{L}*\s+не\s+рассматрива|не\s+рассматрива\p{L}*\s+удал[её]н|remote\s+(?:not|no)|faqat\s+ofis|ofisda\s+ish(?:lash)?)/iu;
-const REMOTE_POSITIVE_RE = /(?:\bremote\b|\bremotely\b|удал[её]н(?:но|ка|ный|ная|н\p{L}*)?|віддален(?:о|а|ий)?|дистанц(?:ионно|ійно)|masofaviy|(?<!\p{L})onlayn(?!\p{L})|online\s+(?:work|job)|онлайн\s+работ)/iu;
+// The open `\p{L}*` suffixes used to match "удаленность"/"віддаленості" (an
+// object's distance from something) as a remote-work preference. Case
+// endings are now enumerated explicitly and both stems are token-bounded.
+const REMOTE_POSITIVE_RE = /(?:\bremote\b|\bremotely\b|(?<!\p{L})удал[её]н(?:но|ка|н(?:ый|ая|ую|ых|ым|ой|ое|ые))?(?!\p{L})|(?<!\p{L})віддален(?:о|а|ий)?(?!\p{L})|дистанц(?:ионно|ійно)|masofaviy|(?<!\p{L})onlayn(?!\p{L})|online\s+(?:work|job)|онлайн\s+работ)/iu;
 
 const FEATURE_RULES = Object.freeze([
   ['student', /\bstudent\b|студент|студентк|talaba/iu],

package/src/hiring-source-semantics.js

@@ -197,7 +197,12 @@ export function detectVisaSponsorshipWording(value) {
   return null;
 }
 
-export const TEMPORARY_WORK_AUTH_RE = /\b(?:opt|cpt|stem\s+opt)\b/iu;
+// Bare "opt" needs case-sensitive "OPT" (the Optional Practical Training
+// abbreviation is written that way in real postings) — a case-insensitive
+// `\bopt\b` also matched the common English verb ("opt-in", "opt out").
+// "cpt" and "stem opt" don't collide with ordinary words, so they stay
+// case-insensitive via explicit character classes instead of the `i` flag.
+export const TEMPORARY_WORK_AUTH_RE = /\b(?:[Cc][Pp][Tt]|[Ss][Tt][Ee][Mm]\s+[Oo][Pp][Tt])\b|\bOPT\b/u;
 
 export function detectRecruitmentAgency(value) {
   return /recruit(?:ment|ing) agency|staffing agency|talent agency|кадров(?:ое|е) агентство|рекрут(?:ингов|инг)\p{L}* агентство|агентство по подбору/iu.test(String(value || ''));

package/src/housing-language.d.ts

@@ -1,4 +1,4 @@
-export type HousingTextLanguage = 'ru' | 'uk' | 'en' | 'uz';
+export type HousingTextLanguage = 'ru' | 'uk' | 'en' | 'uz' | 'ro' | 'kk';
 
 export function housingTextIsInLanguage(value: unknown, language: string): boolean;
 export function detectHousingTextLanguage(value: unknown): HousingTextLanguage | null;

package/src/housing-language.js

@@ -18,7 +18,7 @@ const HOUSING_LANGUAGE_SIGNALS = Object.freeze({
     minimum: 2,
   },
   uk: {
-    pattern: /(?:квартир\p{L}*|кімнат\p{L}*|поверх\p{L}*|будинк\p{L}*|цін\p{L}*|здається|продається|оренд\p{L}*|поруч|метро|сімейн\p{L}*|комунальн\p{L}*|ремонт\p{L}*|меблі\p{L}*|балкон\p{L}*|район\p{L}*)/giu,
+    pattern: /(?:квартир\p{L}*|кімнат\p{L}*|поверх\p{L}*|будинк\p{L}*|цін\p{L}*|здається|продається|оренд\p{L}*|поруч|метро|сімейн\p{L}*|комунальн\p{L}*|ремонт\p{L}*|мебл\p{L}*|балкон\p{L}*|район\p{L}*)/giu,
     minimum: 2,
   },
   en: {
@@ -29,6 +29,14 @@ const HOUSING_LANGUAGE_SIGNALS = Object.freeze({
     pattern: /(?:kvartira\p{L}*|xona\p{L}*|qavat\p{L}*|uy\p{L}*|narx\p{L}*|ijara\p{L}*|beriladi|sotiladi|yaqin|metro|mebel\p{L}*|balkon\p{L}*|tuman\p{L}*)/giu,
     minimum: 2,
   },
+  ro: {
+    pattern: /(?:apartament\p{L}*|cameră\p{L}*|camera\p{L}*|etaj\p{L}*|cas[aă]\p{L}*|case\p{L}*|pre[țt]\p{L}*|închiri\p{L}*|inchiri\p{L}*|vânz\p{L}*|vanz\p{L}*|metrou\p{L}*|famil\p{L}*|utilit\p{L}*|mobilat\p{L}*|balcon\p{L}*|cartier\p{L}*)/giu,
+    minimum: 2,
+  },
+  kk: {
+    pattern: /(?:пәтер\p{L}*|бөлме\p{L}*|қабат\p{L}*|үй\p{L}*|баға\p{L}*|жалд\p{L}*|жалғ\p{L}*|сат\p{L}*|жақын\p{L}*|метро\p{L}*|отбасы\p{L}*|коммунал\p{L}*|жиһаз\p{L}*|балкон\p{L}*|аудан\p{L}*)/giu,
+    minimum: 2,
+  },
 });
 
 function signalCount(text, language) {

package/src/housing-money.js

@@ -10,7 +10,15 @@ import {
 import { maskPhoneLikeSpans } from './contact.js';
 
 const PRICE_KEYWORD = '(?:цена|ціна|нарх(?:и)?|narx|price|стоимост[ьи]|аренд(?:а|ная\\s+плата)?|rent)';
-const PRICE_CURRENCY = `(?:${moneyCurrencyPattern()})`;
+// moneyCurrencyPattern() includes short codes (cad, ron, aed...) with no
+// boundary of its own, so "100 cadastru" would otherwise read "cad" off an
+// unrelated word as the Canadian dollar. Only the side facing away from the
+// paired number gets a boundary: the side facing the number is legitimately
+// adjacent to a digit with no separator ("350$", "$100"), so guarding it
+// too would reject those ordinary forms.
+const CURRENCY_ALT = `(?:${moneyCurrencyPattern()})`;
+const PRICE_CURRENCY_AFTER_NUMBER = `(?:${CURRENCY_ALT}(?![\\p{L}\\p{N}_]))`;
+const PRICE_CURRENCY_BEFORE_NUMBER = `(?:(?<![\\p{L}\\p{N}_])${CURRENCY_ALT})`;
 
 function escapeRegex(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -51,8 +59,11 @@ export function parseHousingPrice(value, fallbackCurrency = '') {
 
   if (price == null) {
     let tagged = null;
-    const reNumSym = new RegExp(`(${MONEY_NUMBER_PATTERN})\\s*${PRICE_CURRENCY}`, 'ig');
-    const reSymNum = new RegExp(`${PRICE_CURRENCY}\\s*(${MONEY_NUMBER_PATTERN})`, 'ig');
+    // 'u' is required for the \p{L}/\p{N} boundary escapes to work as
+    // Unicode property classes — without it they silently match nothing,
+    // which had made the boundary guard a no-op.
+    const reNumSym = new RegExp(`(${MONEY_NUMBER_PATTERN})\\s*${PRICE_CURRENCY_AFTER_NUMBER}`, 'igu');
+    const reSymNum = new RegExp(`${PRICE_CURRENCY_BEFORE_NUMBER}\\s*(${MONEY_NUMBER_PATTERN})`, 'igu');
     for (const regex of [reNumSym, reSymNum]) {
       let match;
       while ((match = regex.exec(text)) !== null) {

package/src/housing-safety.js

@@ -7,6 +7,47 @@ import { isRoomOnlyHousing } from './housing-source-aliases.js';
 // demand for one woman, which it is not.
 const CLAUSE = String.raw`[^\r\n.!?]`;
 
+// "не" can attach to either side of the demand — "не нужна одна девушка" and
+// "одна девушка не нужна" both negate it — so both the count word and the
+// verb carry their own guard. Scoped tightly to right before each token
+// rather than a whole-text negation scan, so an unrelated "не" elsewhere in
+// the clause (e.g. "девушку, не курящую" — a non-smoking woman) does not
+// suppress a real demand.
+const NOT_NEGATED_RU = String.raw`(?<!не\s{0,3})`;
+
+// `\b` is ASCII-only in JS even under the `u` flag — it never fires around
+// Cyrillic text, so a lookahead built on `\b` after "эмас" silently never
+// matches and the guard becomes a no-op. Use the same explicit
+// letter/digit/underscore boundary the rest of the lexicon relies on.
+const WORD_END = String.raw`(?=$|[^\p{L}\p{N}_])`;
+const NOT_NEGATED_UZ = String.raw`(?!\s*emas${WORD_END})`;
+const NOT_NEGATED_UZ_CYRL = String.raw`(?!\s*эмас${WORD_END})`;
+
+const NOT_NEGATED_RO = String.raw`(?<!nu\s{0,3})`;
+const NOT_NEGATED_KK = String.raw`(?!\s*емес${WORD_END})`;
+
+// Romanian places the "single" adjective on either side of the noun — "o
+// singură fată" and "o fată singură" are both natural — so the count phrase
+// covers both orders rather than picking one.
+const RO_FEMALE_NOUN = String.raw`(?:fat[aă]\p{L}*|fete\p{L}*|femei\p{L}*)`;
+const RO_COUNT_NOUN = String.raw`(?:o\s+singur[aă]\s+${RO_FEMALE_NOUN}|o\s+${RO_FEMALE_NOUN}\s+singur[aă]|1\s+${RO_FEMALE_NOUN})`;
+
+// A point guard right before the verb only blocks *that* instance of the verb
+// from matching — it does not stop the engine from skipping past a negated
+// "не нужна" to a second, unnegated verb word later in the same gap (e.g.
+// "не нужна, ищем" would otherwise still complete via "ищем"). Building the
+// gap out of "not the start of a standalone negation word" repeated
+// character-by-character keeps any negation out of the whole span, not just
+// its own position. `emas`/`эмас`/`емес` trail their verb rather than lead
+// it ("kerak emas"), so those languages' gaps guard the same way as their
+// point guard — excluding the negation word wherever it falls in the gap.
+const gapExcluding = (word, max) => `(?:(?!${word}${WORD_END})${CLAUSE}){0,${max}}`;
+const GAP_NO_NEGATION_RU = (max) => gapExcluding('не', max);
+const GAP_NO_NEGATION_RO = (max) => gapExcluding('nu', max);
+const GAP_NO_NEGATION_UZ = (max) => gapExcluding('emas', max);
+const GAP_NO_NEGATION_UZ_CYRL = (max) => gapExcluding('эмас', max);
+const GAP_NO_NEGATION_KK = (max) => gapExcluding('емес', max);
+
 /**
  * Wording that seeks exactly one female tenant, as opposed to the generic
  * "women only" audience wording that ordinary women-only listings use.
@@ -16,30 +57,63 @@ const CLAUSE = String.raw`[^\r\n.!?]`;
 const SINGLE_FEMALE_TENANT_PATTERNS = Object.freeze([
   // ru: "только одна девушка", "нужна 1 девушка", "ищу одну женщину", "подселю одну девушку"
   new RegExp(
-    String.raw`(?:только|лише|нужн\p{L}*|потрібн\p{L}*|ищ[еуy]\p{L}*|шука\p{L}*|подсел\p{L}*|підсел\p{L}*)`
-    + CLAUSE + `{0,24}`
-    + String.raw`(?:^|[^\p{L}\p{N}_])(?:одн(?:а|ої|ой|у|ту)|1)\s+(?:девушк\p{L}*|дівчин\p{L}*|женщин\p{L}*|жінк\p{L}*)`,
+    NOT_NEGATED_RU
+    + String.raw`(?:только|лише|нужн\p{L}*|потрібн\p{L}*|ищ[еуy]\p{L}*|шука\p{L}*|подсел\p{L}*|підсел\p{L}*)`
+    + GAP_NO_NEGATION_RU(24)
+    + NOT_NEGATED_RU
+    + String.raw`[^\p{L}\p{N}_](?:одн(?:а|ої|ой|у)|1)\s+(?:девушк\p{L}*|дівчин\p{L}*|женщин\p{L}*|жінк\p{L}*)`,
     'iu',
   ),
   // uk/ru reversed order: "одна девушка нужна"
   new RegExp(
-    String.raw`(?:^|[^\p{L}\p{N}_])(?:одн(?:а|ої|ой|у)|1)\s+(?:девушк\p{L}*|дівчин\p{L}*|женщин\p{L}*|жінк\p{L}*)`
-    + CLAUSE + `{0,18}`
+    NOT_NEGATED_RU
+    + String.raw`(?:^|[^\p{L}\p{N}_])(?:одн(?:а|ої|ой|у)|1)\s+(?:девушк\p{L}*|дівчин\p{L}*|женщин\p{L}*|жінк\p{L}*)`
+    + GAP_NO_NEGATION_RU(18)
+    + NOT_NEGATED_RU
     + String.raw`(?:нужн\p{L}*|потрібн\p{L}*|треба|ищ[еуy]\p{L}*|шука\p{L}*)`,
     'iu',
   ),
+  // ro: "doar o singură fată", "am nevoie de 1 fată", "caut o fată singură"
+  new RegExp(
+    NOT_NEGATED_RO
+    + String.raw`(?:doar|caut\p{L}*|căut\p{L}*|trebuie|nevoie\p{L}*)`
+    + GAP_NO_NEGATION_RO(24)
+    + NOT_NEGATED_RO
+    + `[^\\p{L}\\p{N}_]${RO_COUNT_NOUN}`,
+    'iu',
+  ),
+  // ro reversed order: "o singură fată e nevoie"
+  new RegExp(
+    NOT_NEGATED_RO
+    + `(?:^|[^\\p{L}\\p{N}_])${RO_COUNT_NOUN}`
+    + GAP_NO_NEGATION_RO(18)
+    + NOT_NEGATED_RO
+    + String.raw`(?:doar|trebuie|nevoie\p{L}*|caut[aă]\p{L}*)`,
+    'iu',
+  ),
   // uzLatn: "faqat 1 ta qiz kerak", "bitta ayol ijarachi kerak"
   new RegExp(
     String.raw`(?:faqat\s+)?(?:^|[^\p{L}\p{N}_])(?:1|bitta)\s*(?:ta\s*)?(?:qiz|ayol)`
-    + CLAUSE + `{0,18}`
-    + String.raw`(?:ijarachi\s*)?(?:kerak|kere|kerakli)`,
+    + GAP_NO_NEGATION_UZ(18)
+    + String.raw`(?:ijarachi\s*)?(?:kerak|kere|kerakli)`
+    + NOT_NEGATED_UZ,
     'iu',
   ),
   // uzCyrl: "фақат 1 та қиз керак"
   new RegExp(
     String.raw`(?:фақат\s+)?(?:^|[^\p{L}\p{N}_])(?:1|битта)\s*(?:та\s*)?(?:қиз|аёл)`
-    + CLAUSE + `{0,18}`
-    + String.raw`(?:ижарачи\s*)?(?:керак|керакли)`,
+    + GAP_NO_NEGATION_UZ_CYRL(18)
+    + String.raw`(?:ижарачи\s*)?(?:керак|керакли)`
+    + NOT_NEGATED_UZ_CYRL,
+    'iu',
+  ),
+  // kk: "тек бір қыз керек", "бір қызға орын керек" — Kazakh is verb-final,
+  // so unlike the Slavic/Romance pairs above only this one order is natural.
+  new RegExp(
+    String.raw`(?:тек\s+)?(?:^|[^\p{L}\p{N}_])(?:бір|1)\s+(?:қыз|әйел)\p{L}*`
+    + GAP_NO_NEGATION_KK(18)
+    + String.raw`(?:керек|қажет|ізде)\p{L}*`
+    + NOT_NEGATED_KK,
     'iu',
   ),
 ]);

package/src/housing-text.js

@@ -114,7 +114,9 @@ export function parseHousingFloorFromText(value) {
     if (valid(floor, total)) return { floor, totalFloors: total };
   }
 
-  const notLetter = '(?!н|ей|ів|ност|ка|ки|s)';
+  // "li" excludes Uzbek "N qavatli" (an N-storey building), which states the
+  // building's total floor count, not which floor this unit is on.
+  const notLetter = '(?!н|ей|ів|ност|ка|ки|s|li)';
   const single = t.match(new RegExp(`(\\d{1,2})[^\\S\\r\\n]*-?[^\\S\\r\\n]*(?:го|ом|ым|ой|ий|nd|rd|th|st|й|м|е)?[^\\S\\r\\n]*${floorWord}${notLetter}`)) || t.match(new RegExp(`${floorWord}\\s*[:№#]?\\s*(\\d{1,2})\\b`));
   if (single) {
     const floor = Number(single[1]);
@@ -132,6 +134,17 @@ export function parseHousingFloorFromText(value) {
     const total = Number(bare[2]);
     if (floor >= 1 && floor <= 40 && total >= 2 && total <= 40 && floor <= total) return { floor, totalFloors: total };
   }
+
+  // A building's total floor count ("8 qavatli uy", "этажность: 9") is still
+  // worth reporting even when no unit floor is stated at all.
+  const totalOnly =
+    t.match(/(?:этажность|этажей|поверхови|поверховість|qavatlar(?:\s*soni)?|qavatli|қабатты?)\D{0,6}(\d{1,2})/) ||
+    t.match(/([1-9]\d?)\s*-?\s*(?:этажн[а-яё]*|поверхов[а-яіїґ]*|qavatli|қабатты?)\s*(?:дом|здани|будин|uy|bino)?/i);
+  if (totalOnly) {
+    const total = Number(totalOnly[1]);
+    if (total >= 1 && total <= 200) return { floor: null, totalFloors: total };
+  }
+
   return { floor: null, totalFloors: null };
 }
 

package/src/housing-title.js

@@ -15,18 +15,32 @@ const CATEGORY = String.raw`(?:`
   + String.raw`|(?:apartments?|flats?|houses?|rooms?)\s+for\s+(?:rent|sale)`
   + String.raw`|rentals?|daily\s+rentals?`
   + String.raw`|ijaraga\s+berish|ijara|sotuvi`
+  // ro: "închiriere pe termen lung/scurt", "apartamente de vânzare" (subject
+  // leads here, so this alt embeds its own subject like the English "for
+  // rent/sale" form above), bare "închiriere"/"chirie"/"vânzare"
+  + String.raw`|(?:închiri\p{L}*|inchiri\p{L}*)\s+pe\s+termen\s+(?:lung|scurt)`
+  + String.raw`|(?:apartament\p{L}*|cas[aă]\p{L}*|case\p{L}*)\s+de\s+(?:vânzare|vanzare|închiriat|inchiriat)`
+  + String.raw`|închiri\p{L}*|inchiri\p{L}*|chirie\p{L}*|vânz\p{L}*|vanz\p{L}*`
+  // kk: "жалдау"/"жалға"/"жалға беру" (long rent), "ұзақ мерзімге жалдау"
+  // (long rent, spelled out), "тәуліктік жалдау" (short rent), "сату"/"сатылым"
+  + String.raw`|ұзақ\s+мерзімге\s+жалд\p{L}*|тәулік\p{L}*\s+жалд\p{L}*`
+  + String.raw`|жалд\p{L}*|жалғ\p{L}*(?:\s+беру\p{L}*)?|сат\p{L}*`
   + String.raw`)`;
 
 const SUBJECT = String.raw`(?:`
   + String.raw`квартир\p{L}*|кімнат\p{L}*|комнат\p{L}*|будинк\p{L}*|будинків|дом\p{L}*|житл\p{L}*|нерухомост\p{L}*|недвижимост\p{L}*`
   + String.raw`|apartments?|flats?|houses?|rooms?|property|real\s+estate`
   + String.raw`|kvartira\p{L}*|uylar|xona\p{L}*`
+  + String.raw`|apartament\p{L}*|cameră\p{L}*|camera\p{L}*|cas[aă]\p{L}*|case\p{L}*|locuinț\p{L}*|locuinta\p{L}*`
+  + String.raw`|пәтер\p{L}*|бөлме\p{L}*|үй\p{L}*`
   + String.raw`)`;
 
-// Only a single trailing locality clause counts as part of the heading — one
-// short comma- or dash-separated fragment such as ", Подільський район".
-// Anything richer means the title is saying something about this property.
-const LOCALITY_TAIL = String.raw`(?:\s*[,–—-]\s*[^\r\n,]{1,40})?`;
+// Trailing locality clauses, comma- or dash-separated, such as
+// ", Подільський район, біля станції метро". Each clause is capped in length
+// so this stays a location tail rather than swallowing real content — but a
+// digit anywhere still wins first via SPECIFIC_DETAIL, which is the actual
+// guard against misreading a real title as generic.
+const LOCALITY_TAIL = String.raw`(?:\s*[,–—-]\s*[^\r\n,]{1,40}){0,3}`;
 
 const GENERIC_TITLE_PATTERN = new RegExp(
   `^\\s*${CATEGORY}(?:\\s+${SUBJECT})?${LOCALITY_TAIL}\\s*$`,

package/src/housing.js

@@ -219,7 +219,10 @@ export function resolveHousingPropertyType(value) {
   const flat = PROPERTY_TYPES.find((entry) => entry.canonical === 'flat');
   if (flat && findCanonical(text, [flat], { partial: true })) return 'flat';
   const genericUzbekHome = /(?:^|[^\p{L}\p{N}_])(?:uy|уй)(?=$|[^\p{L}\p{N}_])/iu.test(text);
-  const explicitHouse = /(?:hovli|xovli|ҳовли|ховли|house|casa|dom|villa|будин|коттедж|вілл|вилл|(?:^|[^\p{L}\p{N}_])(?:дом|үй)(?=$|[^\p{L}\p{N}_]))/iu.test(text);
+  // "dom" is only 3 letters and matches as a bare substring of unrelated
+  // English words (e.g. "seldom", "random"), so it needs the same token
+  // boundary already applied to its Cyrillic counterpart "дом" below.
+  const explicitHouse = /(?:hovli|xovli|ҳовли|ховли|house|casa|villa|будин|коттедж|вілл|вилл|(?:^|[^\p{L}\p{N}_])(?:дом|үй|dom)(?=$|[^\p{L}\p{N}_]))/iu.test(text);
   if (genericUzbekHome && !explicitHouse) return null;
   return findCanonical(text, PROPERTY_TYPES, { partial: true })?.canonical || null;
 }

package/src/index.js

@@ -43,6 +43,7 @@ export * from './housing-structured.js';
 export * from './hiring.js';
 export * from './hiring-languages.js';
 export * from './hiring-context.js';
+export { parseHiringContext } from './hiring-context-compat.js';
 export * from './money.js';
 export * from './hiring-professions.js';
 export * from './hiring-advanced.js';

package/src/money-core.js

@@ -5,17 +5,51 @@ import {
   NUMBER_MULTIPLIERS,
 } from './money-lexicon.js';
 
-export const MONEY_NUMBER_PATTERN = '\\d{1,3}(?:[ \\u00a0.,]\\d{3})+|\\d+(?:[.,]\\d+)?';
+// 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+)?)';
 export const MONEY_SCALE_PATTERN = 'k|к|тыс\\.?|тысяч(?:а|и)?|тис\\.?|thousand|ming|мың|m|м|млн\\.?|mln|million|миллион(?:ов)?|мільйон(?:ів)?|bn|млрд|mlrd|billion';
-export const MONEY_RANGE_RE = new RegExp(`(${MONEY_NUMBER_PATTERN})\\s*(${MONEY_SCALE_PATTERN})?\\s*(?:-|–|—|до|to|bis|dan\\s+gacha)\\s*(${MONEY_NUMBER_PATTERN})\\s*(${MONEY_SCALE_PATTERN})?`, 'iu');
+// Each scale group needs the token-boundary guard MONEY_SINGLE_RE already has
+// below: without it, "2 до 3 месяцев" reads "м" off "месяцев" as the million
+// abbreviation and turns 3 into 3,000,000. The boundary is nested inside the
+// optional group (rather than placed after it) so a scale match that fails
+// the boundary check simply falls back to "no scale" instead of failing the
+// whole alternative — otherwise a no-space separator like "5до10" (no scale
+// present at all) would stop matching, since "до" doesn't satisfy the
+// boundary either.
+export const MONEY_RANGE_RE = new RegExp(`(${MONEY_NUMBER_PATTERN})\\s*(?:(${MONEY_SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_]))?\\s*(?:-|–|—|до|to|bis|dan\\s+gacha)\\s*(${MONEY_NUMBER_PATTERN})\\s*(?:(${MONEY_SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_]))?`, 'iu');
 export const MONEY_SINGLE_RE = new RegExp(`(${MONEY_NUMBER_PATTERN})\\s*(${MONEY_SCALE_PATTERN})?(?=$|[^\\p{L}\\p{N}_])`, 'giu');
 
 export function parseNumericAmount(raw) {
   let value = String(raw || '').replace(/\u00a0/g, ' ').trim();
   if (!value) return null;
-  const grouped = /\d[ ,.]\d{3}(?:[ ,.]\d{3})*/.test(value);
-  if (grouped) value = value.replace(/[ ,.]/g, '');
-  else value = value.replace(/\s+/g, '').replace(',', '.');
+
+  // Spaces are unambiguous thousands separators in supported salary formats.
+  value = value.replace(/\s+/g, '');
+
+  const lastComma = value.lastIndexOf(',');
+  const lastDot = value.lastIndexOf('.');
+  if (lastComma >= 0 && lastDot >= 0) {
+    // When both separators are present, the final separator is decimal and the
+    // other one is grouping: 137,000.00 / 137.000,00.
+    const decimal = lastComma > lastDot ? ',' : '.';
+    const grouping = decimal === ',' ? /\./g : /,/g;
+    value = value.replace(grouping, '');
+    if (decimal === ',') value = value.replace(',', '.');
+  } else {
+    const separator = lastComma >= 0 ? ',' : lastDot >= 0 ? '.' : null;
+    if (separator) {
+      const escaped = separator === '.' ? '\\.' : ',';
+      const groupingRe = new RegExp(`^\\d{1,3}(?:${escaped}\\d{3})+$`);
+      if (groupingRe.test(value)) {
+        value = value.split(separator).join('');
+      } else if (separator === ',') {
+        value = value.replace(',', '.');
+      }
+    }
+  }
+
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : null;
 }

package/src/money.js

@@ -1,6 +1,7 @@
 import { findPhoneLikeSpans } from './contact.js';
 import { aliasesOf, findCanonical, normalizeUnicode } from './normalization.js';
 import {
+  CURRENCY_SYMBOL_CANDIDATES,
   CURRENCY_TERMS,
   NUMBER_MULTIPLIERS,
   SALARY_MODIFIERS,
@@ -26,13 +27,22 @@ export {
   parseScaledAmount,
 } from './money-core.js';
 
-const CONTACT_MARKER_RE = /(?:телефон|тел\.?|phone|mobile|mob\.?|whatsapp|viber|telegram|контакт|contact|aloqa|murojaat|bog(?:['’ʻʼ‘`])?lanish)\s*[:：—-]?\s*$/iu;
+// A leading boundary keeps "тел"/"phone" etc. from matching as a suffix of an
+// unrelated word ("хостел", "котел", "telegraph"), which would wrongly mark a
+// 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;
 
 function hasSalaryContext(text) {
   return /(?:salary|зарплат|з\s*п\b|оплат|ставк|доход|оклад|компенсац|maosh|oylik|ish\s+haqi|жалақы|айлық|еңбекақы|salariu|оплата)/iu.test(text);
 }
 
 function periodFromText(text) {
+  // Some vacancy sources leak untranslated i18n keys into salary strings,
+  // e.g. "$208K/jobs.perWeek". Treat those markers as first-class periods
+  // instead of letting consumers fall back to an incorrect monthly salary.
+  const jobsMarker = String(text || '').match(JOBS_I18N_PERIOD_RE);
+  if (jobsMarker?.[1]) return jobsMarker[1].toLowerCase();
   return findCanonical(text, SALARY_PERIODS, { partial: true })?.canonical || null;
 }
 
@@ -61,10 +71,23 @@ function moneyContextScore(text, start, end, scaled = false) {
   return score;
 }
 
+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.
+  let normalized = text;
+  for (const symbol of Object.keys(CURRENCY_SYMBOL_CANDIDATES)) {
+    normalized = normalized.split(symbol).join(' '.repeat(symbol.length));
+  }
+  return normalized;
+}
+
 function bestRange(text, protectedSpans) {
   const ranges = new RegExp(MONEY_RANGE_RE.source, 'giu');
   const candidates = [];
-  for (const match of text.matchAll(ranges)) {
+  const searchable = rangeSearchText(text);
+  for (const match of searchable.matchAll(ranges)) {
     const start = match.index ?? 0;
     const end = start + match[0].length;
     if (overlapsProtectedPhone(start, end, protectedSpans)) continue;

package/src/tashkent-housing-geography.js

@@ -124,7 +124,11 @@ const DISTRICT_CONTEXT_ALIASES = Object.freeze({
 
 const NUMBERED_CONTEXT = '(?:tumani|тумани|district|район|massiv|массив)';
 const NUMBERED_SUFFIX_CONTEXT = '(?:chi|чи|й|квартал|kvartal|hudud(?:da)?|худуд(?:да)?)';
-const DISTRICT_MARKER = '(?:район|туман\\p{L}*|tumani|district)';
+// The open \p{L}* suffix used to swallow any trailing letters, so
+// "туманность" (an unrelated word) satisfied this as if "туман" (district)
+// had been mentioned. {0,4} covers real case endings (туманда, туманидан)
+// while excluding unrelated 5+-letter continuations.
+const DISTRICT_MARKER = '(?:район|туман\\p{L}{0,4}|tumani|district)';
 
 function normalizedAlternatives(values) {
   return values