@whiteslove/parsing-lexicon 0.2.6 → 0.2.9

package/index.d.ts

@@ -373,6 +373,11 @@ export * from './src/housing-context.js';
 export * from './src/hiring-context.js';
 export * from './src/housing-intent.js';
 export * from './src/housing-structured.js';
+export * from './src/housing-safety.js';
+export * from './src/housing-title.js';
+export * from './src/housing-language.js';
+export * from './src/housing-features.js';
+export * from './src/housing-listing-fields.js';
 
 // housing semantic helper declarations added in 0.2.5
 export function resolveHousingOccupancy(value: unknown): 'wholeProperty' | 'room' | 'sharedRoom' | 'bedSpace' | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whiteslove/parsing-lexicon",
-  "version": "0.2.6",
+  "version": "0.2.9",
   "description": "Shared deterministic multilingual parsing lexicon for Whiteslove housing and hiring services",
   "repository": {
     "type": "git",
@@ -41,6 +41,11 @@
     "./housing-context": { "types": "./src/housing-context.d.ts", "import": "./src/housing-context.js" },
     "./housing-address": { "types": "./src/housing-address.d.ts", "import": "./src/housing-address.js" },
     "./housing-structured": { "types": "./src/housing-structured.d.ts", "import": "./src/housing-structured.js" },
+    "./housing-safety": { "types": "./src/housing-safety.d.ts", "import": "./src/housing-safety.js" },
+    "./housing-title": { "types": "./src/housing-title.d.ts", "import": "./src/housing-title.js" },
+    "./housing-language": { "types": "./src/housing-language.d.ts", "import": "./src/housing-language.js" },
+    "./housing-features": { "types": "./src/housing-features.d.ts", "import": "./src/housing-features.js" },
+    "./housing-listing-fields": { "types": "./src/housing-listing-fields.d.ts", "import": "./src/housing-listing-fields.js" },
     "./housing-text": { "types": "./src/housing-text.d.ts", "import": "./src/housing-text.js" },
     "./housing-source-aliases": { "types": "./src/housing-source-aliases.d.ts", "import": "./src/housing-source-aliases.js" },
     "./hiring": "./src/hiring.js",

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-features.d.ts

@@ -0,0 +1,8 @@
+export type HousingFeatures = Readonly<{
+  internet: boolean | null;
+  courtyard: boolean | null;
+  gazebo: boolean | null;
+  petsAllowed: boolean | null;
+}>;
+
+export function parseHousingFeatures(value: unknown): HousingFeatures;

package/src/housing-language.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,81 @@
+import { normalizeUnicode } from './normalization.js';
+
+// Uzbek and Kazakh Cyrillic carry letters no Slavic alphabet uses. Their
+// presence rules out "this text is already Russian/Ukrainian" even though the
+// housing vocabulary overlaps heavily. `і` is deliberately absent: it is an
+// ordinary Ukrainian letter.
+const NON_SLAVIC_CYRILLIC = /[ўқғҳәөүұңһ]/iu;
+const SLAVIC_LANGUAGES = new Set(['ru', 'uk']);
+
+/**
+ * Housing vocabulary that reliably indicates the language a listing body is
+ * written in. Deliberately common words: the goal is deciding whether a reader
+ * needs a translation, not identifying rare dialects.
+ */
+const HOUSING_LANGUAGE_SIGNALS = Object.freeze({
+  ru: {
+    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,
+  },
+  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,
+    minimum: 2,
+  },
+  en: {
+    pattern: /(?:^|[^\p{L}])(?:apartment|flat|house|room|bedroom|floor|price|rent|rental|sale|family|utilities|near|available|furnished|balcony|district|deposit)(?=$|[^\p{L}])/giu,
+    minimum: 3,
+  },
+  uz: {
+    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) {
+  const signal = HOUSING_LANGUAGE_SIGNALS[language];
+  if (!signal) return 0;
+  return (text.match(signal.pattern) || []).length;
+}
+
+/**
+ * True when the housing text already reads as the given language, i.e. a reader
+ * of that language does not need it translated.
+ *
+ * Uses a per-language evidence threshold rather than a single hit, because one
+ * shared word ("metro", "balkon") appears across all of these languages.
+ */
+export function housingTextIsInLanguage(value, language) {
+  const text = normalizeUnicode(value ?? '').toLocaleLowerCase();
+  if (!text.trim()) return false;
+  const signal = HOUSING_LANGUAGE_SIGNALS[language];
+  if (!signal) return false;
+  // Uzbek/Kazakh Cyrillic text reuses Slavic housing words but is neither.
+  if (SLAVIC_LANGUAGES.has(language) && NON_SLAVIC_CYRILLIC.test(text)) return false;
+  return signalCount(text, language) >= signal.minimum;
+}
+
+/**
+ * Best-guess language of a housing text, or null when no language reaches its
+ * evidence threshold.
+ */
+export function detectHousingTextLanguage(value) {
+  const text = normalizeUnicode(value ?? '').toLocaleLowerCase();
+  if (!text.trim()) return null;
+
+  let best = null;
+  for (const language of Object.keys(HOUSING_LANGUAGE_SIGNALS)) {
+    if (SLAVIC_LANGUAGES.has(language) && NON_SLAVIC_CYRILLIC.test(text)) continue;
+    const count = signalCount(text, language);
+    if (count < HOUSING_LANGUAGE_SIGNALS[language].minimum) continue;
+    if (!best || count > best.count) best = { language, count };
+  }
+  return best?.language ?? null;
+}

package/src/housing-listing-fields.d.ts

@@ -0,0 +1,49 @@
+export type HousingMinRentTerm = Readonly<{
+  value: number;
+  unit: 'day' | 'week' | 'month' | 'year';
+}>;
+
+export type HousingUtilitiesAmount = Readonly<{
+  amount: number;
+  currency: string | null;
+  approximate: boolean;
+}>;
+
+export type HousingListingFields = Readonly<{
+  bedrooms: number | null;
+  bathrooms: number | null;
+  buildingYear: number | null;
+  balcony: boolean | null;
+  terrace: boolean | null;
+  privateYard: boolean | null;
+  courtyard: boolean | null;
+  gazebo: boolean | null;
+  dishwasher: boolean | null;
+  airConditioner: boolean | null;
+  gas: boolean | null;
+  newBuilding: boolean | null;
+  communalSeparated: boolean | null;
+  parking: boolean | null;
+  elevator: boolean | null;
+  heating: boolean | null;
+  hotWater: boolean | null;
+  internet: boolean | null;
+  petsAllowed: boolean | null;
+  childrenAllowed: boolean | null;
+  smokingAllowed: boolean | null;
+  negotiable: boolean | null;
+  furnished: boolean | null;
+  depositRequired: boolean | null;
+  firstRent: boolean | null;
+  minRentTerm: HousingMinRentTerm | null;
+  availableFrom: string | null;
+  utilitiesAmount: HousingUtilitiesAmount | null;
+}>;
+
+/**
+ * Empty input yields an empty object, so every field is optional on the result.
+ */
+export function parseHousingListingFields(
+  value: unknown,
+  options?: { country?: string },
+): Readonly<Partial<HousingListingFields>>;

package/src/housing-money.js

@@ -10,7 +10,10 @@ 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.
+const PRICE_CURRENCY = `(?:(?<![\\p{L}\\p{N}_])(?:${moneyCurrencyPattern()})(?![\\p{L}\\p{N}_]))`;
 
 function escapeRegex(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -51,8 +54,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 PRICE_CURRENCY's \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}`, 'igu');
+    const reSymNum = new RegExp(`${PRICE_CURRENCY}\\s*(${MONEY_NUMBER_PATTERN})`, 'igu');
     for (const regex of [reNumSym, reSymNum]) {
       let match;
       while ((match = regex.exec(text)) !== null) {

package/src/housing-safety.d.ts

@@ -0,0 +1,7 @@
+export type HousingSafetySignals = Readonly<{
+  roomOnly: boolean;
+  singleFemaleTenantSought: boolean;
+}>;
+
+export function seeksSingleFemaleTenant(value: unknown): boolean;
+export function parseHousingSafetySignals(value: unknown): HousingSafetySignals;

package/src/housing-safety.js

@@ -0,0 +1,149 @@
+import { deepFreeze } from './lexicon-core.js';
+import { normalizeUnicode } from './normalization.js';
+import { isRoomOnlyHousing } from './housing-source-aliases.js';
+
+// Clause-scoped gap: the demand and the person must sit in the same sentence.
+// Crossing `.`/`!`/`?`/newline let "Ищу жильё. Одна девушка уже живёт" read as a
+// 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.
+ * The count matters: a landlord addressing one specific woman is the signal,
+ * not a flat that happens to prefer female tenants.
+ */
+const SINGLE_FEMALE_TENANT_PATTERNS = Object.freeze([
+  // ru: "только одна девушка", "нужна 1 девушка", "ищу одну женщину", "подселю одну девушку"
+  new RegExp(
+    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(
+    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)`
+    + 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*)?(?:қиз|аёл)`
+    + 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',
+  ),
+]);
+
+/**
+ * True when the text asks for exactly one female tenant.
+ *
+ * Deliberately narrower than the `women` audience: "только для девушек" is an
+ * ordinary preference and must not match, while "нужна одна девушка" does.
+ */
+export function seeksSingleFemaleTenant(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text.trim()) return false;
+  return SINGLE_FEMALE_TENANT_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+/**
+ * Linguistic safety signals for a housing listing.
+ *
+ * This reports only what the wording says. Whether a given combination is
+ * treated as a risk — and any price policy applied on top — belongs to the
+ * consuming service, not to the lexicon.
+ */
+export function parseHousingSafetySignals(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text.trim()) {
+    return deepFreeze({ roomOnly: false, singleFemaleTenantSought: false });
+  }
+  return deepFreeze({
+    roomOnly: isRoomOnlyHousing(text),
+    singleFemaleTenantSought: seeksSingleFemaleTenant(text),
+  });
+}

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.d.ts

@@ -0,0 +1,2 @@
+export function isGenericHousingTitle(value: unknown): boolean;
+export function hasMeaningfulHousingTitle(value: unknown): boolean;

package/src/housing-title.js

@@ -0,0 +1,84 @@
+import { normalizeUnicode } from './normalization.js';
+
+/**
+ * Marketplace category headings that some sources (notably OLX) hand back in
+ * place of a real listing title. They name a whole search category rather than
+ * one property, so a consumer must not present them as the listing's own title.
+ *
+ * The English forms already embed the subject ("long-term apartment rentals"),
+ * so the subject is matched as an optional trailing word rather than required.
+ */
+const CATEGORY = String.raw`(?:`
+  + String.raw`(?:довгостроков\p{L}*|долгосрочн\p{L}*|короткостроков\p{L}*|краткосрочн\p{L}*|подобов\p{L}*|посуточн\p{L}*)\s+(?:оренда|аренда|найм)`
+  + String.raw`|(?:оренда|аренда|найм|продаж|продажа)`
+  + String.raw`|(?:long|short)[- ]?term\s+(?:apartment\s+|flat\s+|house\s+|room\s+)?rentals?`
+  + 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`)`;
+
+// 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*$`,
+  'iu',
+);
+
+// Digits are the cheapest proof a title says something specific: a room count,
+// an area, a price or a street number. "2-к квартира, 54 м²" is a real title
+// even though it opens with the same words as the category heading.
+const SPECIFIC_DETAIL = /\d/u;
+
+function titleContent(value) {
+  return normalizeUnicode(value ?? '')
+    .replace(
+      /[\p{Extended_Pictographic}\p{Emoji_Presentation}\p{Emoji_Modifier}\p{Variation_Selector}\p{Join_Control}]/gu,
+      '',
+    )
+    .replace(/[^\p{L}\p{N}]+/gu, '');
+}
+
+/**
+ * True when the title is a marketplace category heading rather than a title
+ * describing this specific property.
+ */
+export function isGenericHousingTitle(value) {
+  const text = normalizeUnicode(value ?? '').replace(/\s+/g, ' ').trim();
+  if (!text) return false;
+  if (SPECIFIC_DETAIL.test(text)) return false;
+  return GENERIC_TITLE_PATTERN.test(text);
+}
+
+/**
+ * True when the title can stand on its own in a listing card or popup.
+ *
+ * Rejects titles carrying almost no letters or digits (emoji- or
+ * punctuation-only) as well as marketplace category headings.
+ */
+export function hasMeaningfulHousingTitle(value) {
+  if (titleContent(value).length < 3) return false;
+  return !isGenericHousingTitle(value);
+}

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

@@ -36,10 +36,14 @@ export * from './housing-context.js';
 export * from './housing-address.js';
 export * from './housing-features.js';
 export * from './housing-listing-fields.js';
+export * from './housing-safety.js';
+export * from './housing-title.js';
+export * from './housing-language.js';
 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