@whiteslove/parsing-lexicon 0.9.8 → 0.9.10

package/README.md

@@ -85,7 +85,44 @@ parseHiringContext(
 );
 ```
 
-Subpath exports are available for consumers that need narrower modules, including `./geo`, `./locations`, `./housing-context`, `./housing-structured`, `./hiring-context`, `./hiring-professions` and `./money`.
+Subpath exports are available for consumers that need narrower modules, including `./geo`, `./locations`, `./housing-context`, `./housing-structured`, `./hiring-context`, `./hiring-professions`, `./housing-money`, `./money` and `./currency`.
+
+### Money & currency
+
+Currency and magnitude vocabulary (symbols, ISO codes, spelled-out names, and
+regional stand-ins like "у.е.") lives here once, in `money-lexicon.js`. A
+consumer that needs to know whether some text mentions money at all — a fast
+pre-filter before running the heavier parsers below, e.g. when scanning many
+HTML card candidates scraped from a page — should use `moneyMentionPattern()`
+rather than hand-copying a currency symbol list. A hand-copied list silently
+drifts from this one; that exact bug (a missing "₸"/KZT symbol, and a missing
+"у.е." token) is why this section exists.
+
+```js
+import {
+  moneyCurrencyPattern,   // just the currency alternation, e.g. for building a custom matcher
+  moneyMentionPattern,    // currency OR a bare magnitude word ("15 млн") — boundary-guarded
+  moneyCurrencyFromText,  // -> 'KZT' | 'USD' | ... | null
+} from '@whiteslove/parsing-lexicon/currency';
+import { parseHousingPrice } from '@whiteslove/parsing-lexicon/housing-money';
+import { parseSalary } from '@whiteslove/parsing-lexicon/money';
+
+const looksLikeMoney = new RegExp(moneyMentionPattern(), 'iu');
+looksLikeMoney.test('300 000 ₸ в месяц'); // true
+looksLikeMoney.test('2 до 3 месяцев');    // false — "м" inside "месяцев" does not count
+
+moneyCurrencyFromText('300 000 ₸ в месяц'); // 'KZT'
+
+parseHousingPrice('12 500 000 сум', 'UZS');
+// -> { amount: 12500000, currency: 'UZS' }
+```
+
+Do not write a source-local regex for "does this text contain a price" or
+"what currency is this" — both already exist here and are kept in sync with
+the full currency/magnitude vocabulary used by `parseHousingPrice`/
+`parseSalary`. If a currency form you need is missing, add it to
+`CURRENCY_TERMS` in `money-lexicon.js` (and `CURRENCY_SYMBOL_CANDIDATES` if
+it's a standalone symbol) rather than working around the gap in the consumer.
 
 ## Data-quality rules
 

package/package.json

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

package/src/alias-prefilter.js

@@ -107,6 +107,41 @@ function indexFor(entries) {
   return index;
 }
 
+/** Every GRAM-length window of `text`, precomputed once for reuse across lists. */
+export function computeTextGrams(text) {
+  return textGrams(String(text || ''));
+}
+
+function candidateIndices(entries, value, grams) {
+  const { byGram, always } = indexFor(entries);
+  const candidates = new Set(always);
+  for (const gram of grams) {
+    const bucket = byGram.get(gram);
+    if (!bucket) continue;
+    for (const i of bucket) candidates.add(i);
+  }
+  return [...candidates].sort((a, b) => a - b);
+}
+
+/**
+ * Every entry in `entries` (original list order) the text could plausibly
+ * contain, per the gram index — a filter, not a verdict. Callers still run
+ * their own verification (regex, exact-token match, ...) on what comes back;
+ * see the module doc for why this is safe even for non-regex verifiers.
+ *
+ * `grams`, from `computeTextGrams()`, lets a caller scanning the same text
+ * against many lists compute the O(text length) gram pass once instead of
+ * once per list.
+ */
+export function candidateEntries(entries, text, grams) {
+  if (!Array.isArray(entries) || !entries.length) return [];
+  const value = String(text || '');
+  if (!value) return [];
+
+  const indices = candidateIndices(entries, value, grams || textGrams(value));
+  return indices.map((i) => entries[i]);
+}
+
 /**
  * First entry in `entries` whose alias regex matches `text`.
  *
@@ -124,16 +159,8 @@ export function matchFirstEntry(entries, text, accept) {
   const value = String(text || '');
   if (!value) return undefined;
 
-  const { byGram, always } = indexFor(entries);
-  const candidates = new Set(always);
-  for (const gram of textGrams(value)) {
-    const bucket = byGram.get(gram);
-    if (!bucket) continue;
-    for (const i of bucket) candidates.add(i);
-  }
-  if (!candidates.size) return undefined;
-
-  for (const i of [...candidates].sort((a, b) => a - b)) {
+  const indices = candidateIndices(entries, value, textGrams(value));
+  for (const i of indices) {
     const entry = entries[i];
     // `re` carries no /g flag, so exec() is stateless and safe to reuse here.
     const match = entry?.re?.exec(value);

package/src/central-asia-locations.js

@@ -2,6 +2,7 @@ import { LOCATION_DICTIONARIES } from './locations-runtime.js';
 import { isMapDataEntry, LOCATION_LIST_KEYS } from './location-merge.js';
 import { CITIES_BY_COUNTRY, canonicalCity } from './geography.js';
 import { aliasesOf, aliasesToRegex, normalizeForMatch } from './normalization.js';
+import { candidateEntries, computeTextGrams } from './alias-prefilter.js';
 import { KZ_AMBIGUOUS_LOCAL_NAMES, KZ_SEARCH_CLUSTERS } from './kz-location-extensions.js';
 import { UZ_AMBIGUOUS_LOCAL_NAMES } from './uz-location-extensions.js';
 
@@ -237,12 +238,13 @@ function mapDataMatch(value, normalizedValue, item) {
   return null;
 }
 
-function findEntryMatches(text, cityName, data, { includeMapData = false } = {}) {
+function findEntryMatches(text, cityName, data, { includeMapData = false, grams = null } = {}) {
   const value = String(text || '');
   const normalizedValue = normalizeForMatch(value);
+  const textGrams = grams || computeTextGrams(value);
   const raw = [];
   for (const key of LOCATION_LIST_KEYS) {
-    for (const item of data?.[key] || []) {
+    for (const item of candidateEntries(data?.[key] || [], value, textGrams)) {
       if (isMapDataEntry(item) && !includeMapData) continue;
       const match = (isMapDataEntry(item) ? mapDataMatch(value, normalizedValue, item) : value.match(item?.re))
         || (key === 'residentialComplexes' ? markedResidentialMatch(value, item) : null);
@@ -329,16 +331,17 @@ export function matchCentralAsiaLocationEntities(text, countryCode, preferredCit
   const preferred = canonicalCity(preferredCity, countryCode) || preferredCity;
   const explicit = explicitCityFromText(text, countryCode);
   const scopedCity = preferred && country[preferred] ? preferred : explicit && country[explicit] ? explicit : null;
+  const grams = computeTextGrams(text);
 
   if (scopedCity) {
-    const matches = findEntryMatches(text, scopedCity, country[scopedCity], { includeMapData: true });
+    const matches = findEntryMatches(text, scopedCity, country[scopedCity], { includeMapData: true, grams });
     const clusters = clusterMatches(matches, countryCode);
     return Object.freeze({ city: scopedCity, matches: Object.freeze(matches), searchClusters: Object.freeze(clusters), candidates: Object.freeze([]) });
   }
 
   const byCity = [];
   for (const [cityName, data] of Object.entries(country)) {
-    const matches = findEntryMatches(text, cityName, data);
+    const matches = findEntryMatches(text, cityName, data, { grams });
     if (matches.length) byCity.push({ city: cityName, matches });
   }
 

package/src/currency.d.ts

@@ -9,6 +9,7 @@ export const CURRENCY_SYMBOL_CANDIDATES: Readonly<Record<string, readonly string
 export function moneyCurrencyCandidatesFromText(value: unknown): readonly string[];
 export function moneyCurrencyFromText(value: unknown, fallbackCurrency?: string | null): string | null;
 export function moneyCurrencyPattern(): string;
+export function moneyMentionPattern(): string;
 export function currencyDisplay(code: unknown, locale?: string): CurrencyDisplay | null;
 export function currencySymbol(code: unknown, locale?: string): string | null;
 export function currencyName(code: unknown, locale?: string): string | null;

package/src/currency.js

@@ -9,6 +9,7 @@ export {
   moneyCurrencyCandidatesFromText,
   moneyCurrencyFromText,
   moneyCurrencyPattern,
+  moneyMentionPattern,
 } from './money-core.js';
 
 const LOCALE_ALIASES = Object.freeze({

package/src/housing-money.js

@@ -62,6 +62,34 @@ const COMMON_HOUSING_STRUCTURE_PATTERNS = Object.freeze([
   /(?:^|[^\p{L}\p{N}_])\d{1,5}(?:[.,]\d{1,2})?\s*(?:м(?:2|²)|m(?:2|²)|sqm|sq\.?\s*m|м\s*кв\.?)\s*(?=$|[^\p{L}\p{N}_])/giu,
 ]);
 
+// These five patterns are built once here rather than inside
+// extractHousingMoneyCandidates(): they depend only on the module-level
+// constants above (PRICE_KEYWORD/MONEY_NUMBER_PATTERN/SCALE_PATTERN/
+// PRICE_CURRENCY_*), never on the text being parsed, yet that function runs
+// once per listing card. Constructing them with `new RegExp(...)` per call
+// forces V8 to recompile a pattern that embeds moneyCurrencyPattern()'s
+// ~250-branch currency alternation under the unicode ('u') flag from
+// scratch every time; on a catalogue page with dozens of cards this
+// repeated compilation of a large unicode-mode regex is expensive enough to
+// exhaust the heap (observed as an OOM inside V8's regex code generation).
+// Reusing the same compiled RegExp objects removes that per-call cost —
+// they carry the /g flag but are only ever driven through matchAll(), which
+// takes its own internal copy and never mutates lastIndex on the original.
+const EXPANDED_UZBEK_THOUSANDS_RE = new RegExp(
+  `${PRICE_KEYWORD}[^\\d\\r\\n]{0,16}(\\d{4})(?:[.]|[\\s\\u00a0])000\\s*(?:с[ўу]м|so['‘’ʻʼ]?m|som|sum|uzs)(?=$|[^\\p{L}\\p{N}_])`,
+  'igu',
+);
+const LABELLED_PRICE_RANGE_RE = new RegExp(
+  `${PRICE_KEYWORD}\\s*[:=\\-–—]?\\s*(${MONEY_NUMBER_PATTERN})\\s*(?:(${SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_]))?\\s*(?:-{1,3}|–|—|to|до|dan\\s+gacha)\\s*(${MONEY_NUMBER_PATTERN})\\s*(?:(${SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_]))?(?=$|[^\\p{L}\\p{N}_])`,
+  'igu',
+);
+const LABELLED_SCALE_RE = new RegExp(
+  `${PRICE_KEYWORD}\\s*[:=\\-–—]?\\s*(${MONEY_NUMBER_PATTERN})\\s*(${SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_])`,
+  'igu',
+);
+const PRICE_AMOUNT_AFTER_CURRENCY_RE = new RegExp(`(${MONEY_NUMBER_PATTERN})\\s*[.]?\\s*${PRICE_CURRENCY_AFTER_NUMBER}`, 'igu');
+const PRICE_AMOUNT_BEFORE_CURRENCY_RE = new RegExp(`${PRICE_CURRENCY_BEFORE_NUMBER}\\s*(${MONEY_NUMBER_PATTERN})`, 'igu');
+
 function moneyParsingContext(value = '') {
   if (value && typeof value === 'object' && !Array.isArray(value)) {
     const country = canonicalCountryCode(value.country) || '';
@@ -239,11 +267,7 @@ export function extractHousingMoneyCandidates(value, context = '') {
   // amount, while `2 million 500` is a single split-million amount rather
   // than two competing prices.  These must be extracted before the shorter
   // generic currency/scale candidates below.
-  const expandedUzbekThousandsRe = new RegExp(
-    `${PRICE_KEYWORD}[^\\d\\r\\n]{0,16}(\\d{4})(?:[.]|[\\s\\u00a0])000\\s*(?:с[ўу]м|so['‘’ʻʼ]?m|som|sum|uzs)(?=$|[^\\p{L}\\p{N}_])`,
-    'igu',
-  );
-  for (const match of text.matchAll(expandedUzbekThousandsRe)) {
+  for (const match of text.matchAll(EXPANDED_UZBEK_THOUSANDS_RE)) {
     const start = match.index ?? 0;
     addCandidate({
       amount: Number(match[1]) * 1000,
@@ -262,11 +286,7 @@ export function extractHousingMoneyCandidates(value, context = '') {
   // lower bound through the legacy single-price result.  It must be collected
   // before generic amounts so the second endpoint cannot be selected merely
   // because it is larger.
-  const labelledPriceRangeRe = new RegExp(
-    `${PRICE_KEYWORD}\\s*[:=\\-–—]?\\s*(${MONEY_NUMBER_PATTERN})\\s*(?:(${SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_]))?\\s*(?:-{1,3}|–|—|to|до|dan\\s+gacha)\\s*(${MONEY_NUMBER_PATTERN})\\s*(?:(${SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_]))?(?=$|[^\\p{L}\\p{N}_])`,
-    'igu',
-  );
-  for (const match of text.matchAll(labelledPriceRangeRe)) {
+  for (const match of text.matchAll(LABELLED_PRICE_RANGE_RE)) {
     // A scale stated on only one endpoint applies to both: "50-60 тыс сум"
     // means 50,000-60,000, not 50-60,000. Mirrors money.js's range parsing.
     const firstScale = match[2] || match[4] || null;
@@ -310,11 +330,7 @@ export function extractHousingMoneyCandidates(value, context = '') {
   // glyph. In Uzbek listing prose, "narxi 850 ming" conventionally means
   // 850,000 UZS; retaining `scale` prevents a later generic fallback from
   // mistaking the base number for USD.
-  const labelledScaleRe = new RegExp(
-    `${PRICE_KEYWORD}\\s*[:=\\-–—]?\\s*(${MONEY_NUMBER_PATTERN})\\s*(${SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_])`,
-    'igu',
-  );
-  for (const match of text.matchAll(labelledScaleRe)) {
+  for (const match of text.matchAll(LABELLED_SCALE_RE)) {
     const start = match.index ?? 0;
     const end = start + match[0].length;
     const scale = match[2];
@@ -339,10 +355,7 @@ export function extractHousingMoneyCandidates(value, context = '') {
     });
   }
 
-  for (const regex of [
-    new RegExp(`(${MONEY_NUMBER_PATTERN})\\s*[.]?\\s*${PRICE_CURRENCY_AFTER_NUMBER}`, 'igu'),
-    new RegExp(`${PRICE_CURRENCY_BEFORE_NUMBER}\\s*(${MONEY_NUMBER_PATTERN})`, 'igu'),
-  ]) {
+  for (const regex of [PRICE_AMOUNT_AFTER_CURRENCY_RE, PRICE_AMOUNT_BEFORE_CURRENCY_RE]) {
     for (const match of text.matchAll(regex)) {
       const amount = parseNumericAmount(match[1]);
       const start = match.index ?? 0; const end = start + match[0].length;

package/src/housing-structured.js

@@ -19,16 +19,16 @@ import {
 } from './housing-numeric-spans.js';
 
 const NUMBER_WORDS = Object.freeze([
-  [/(?<![\p{L}\p{N}_])(?:однушк\p{L}*|однокомнатн\p{L}*|bir\s+xona(?:li)?|бир\s+хона(?:ли|лик)?|1\s*(?:-\s*)?к(?:омн\p{L}*)?|1\s*(?:-\s*)?xona(?:li)?|1\s*(?:-\s*)?хона(?:лик|ли)?|1\s*бөлмелі|one[- ]bedroom|one[- ]room)(?![\p{L}\p{N}_])/iu, 1],
-  [/(?<![\p{L}\p{N}_])(?:двушк\p{L}*|двухкомнатн\p{L}*|ikki\s+xona(?:li)?|икки\s+хона(?:ли|лик)?|2\s*(?:-\s*)?к(?:омн\p{L}*)?|2\s*(?:-\s*)?xona(?:li)?|2\s*(?:-\s*)?хона(?:лик|ли)?|2\s*бөлмелі|two[- ]bedroom|two[- ]room)(?![\p{L}\p{N}_])/iu, 2],
-  [/(?<![\p{L}\p{N}_])(?:тр[её]шк\p{L}*|трехкомнатн\p{L}*|трёхкомнатн\p{L}*|uch\s+xona(?:li)?|уч\s+хона(?:ли|лик)?|3\s*(?:-\s*)?к(?:омн\p{L}*)?|3\s*(?:-\s*)?xona(?:li)?|3\s*(?:-\s*)?хона(?:лик|ли)?|3\s*бөлмелі|three[- ]bedroom|three[- ]room)(?![\p{L}\p{N}_])/iu, 3],
-  [/(?<![\p{L}\p{N}_])(?:четыр[её]хкомнатн\p{L}*|четыр[её]шк\p{L}*|to['’]?rt\s+xona(?:li)?|tort\s+xona(?:li)?|тўрт\s+хона(?:ли|лик)?|турт\s+хона(?:ли|лик)?|4\s*(?:-\s*)?к(?:омн\p{L}*)?|4\s*(?:-\s*)?xona(?:li)?|4\s*(?:-\s*)?хона(?:лик|ли)?|4\s*бөлмелі|four[- ]bedroom|four[- ]room)(?![\p{L}\p{N}_])/iu, 4],
-  [/(?<![\p{L}\p{N}_])(?:пятикомнатн\p{L}*|besh\s+xona(?:li)?|беш\s+хона(?:ли|лик)?|5\s*(?:-\s*)?к(?:омн\p{L}*)?|5\s*(?:-\s*)?xona(?:li)?|5\s*(?:-\s*)?хона(?:лик|ли)?|five[- ]bedroom|five[- ]room)(?![\p{L}\p{N}_])/iu, 5],
-  [/(?<![\p{L}\p{N}_])(?:шестикомнатн\p{L}*|olti\s+xona(?:li)?|олти\s+хона(?:ли|лик)?|6\s*(?:-\s*)?к(?:омн\p{L}*)?|6\s*(?:-\s*)?xona(?:li)?|6\s*(?:-\s*)?хона(?:лик|ли)?|six[- ]bedroom|six[- ]room)(?![\p{L}\p{N}_])/iu, 6],
-  [/(?<![\p{L}\p{N}_])(?:семикомнатн\p{L}*|yetti\s+xona(?:li)?|етти\s+хона(?:ли|лик)?|7\s*(?:-\s*)?к(?:омн\p{L}*)?|7\s*(?:-\s*)?xona(?:li)?|7\s*(?:-\s*)?хона(?:лик|ли)?|seven[- ]bedroom|seven[- ]room)(?![\p{L}\p{N}_])/iu, 7],
-  [/(?<![\p{L}\p{N}_])(?:восьмикомнатн\p{L}*|sakkiz\s+xona(?:li)?|саккиз\s+хона(?:ли|лик)?|8\s*(?:-\s*)?к(?:омн\p{L}*)?|8\s*(?:-\s*)?xona(?:li)?|8\s*(?:-\s*)?хона(?:лик|ли)?|eight[- ]bedroom|eight[- ]room)(?![\p{L}\p{N}_])/iu, 8],
-  [/(?<![\p{L}\p{N}_])(?:девятикомнатн\p{L}*|to['’]?qqiz\s+xona(?:li)?|toqqiz\s+xona(?:li)?|тўққиз\s+хона(?:ли|лик)?|токкиз\s+хона(?:ли|лик)?|9\s*(?:-\s*)?к(?:омн\p{L}*)?|9\s*(?:-\s*)?xona(?:li)?|9\s*(?:-\s*)?хона(?:лик|ли)?|nine[- ]bedroom|nine[- ]room)(?![\p{L}\p{N}_])/iu, 9],
-  [/(?<![\p{L}\p{N}_])(?:десятикомнатн\p{L}*|o['’]?n\s+xona(?:li)?|on\s+xona(?:li)?|ўн\s+хона(?:ли|лик)?|он\s+хона(?:ли|лик)?|10\s*(?:-\s*)?к(?:омн\p{L}*)?|10\s*(?:-\s*)?xona(?:li)?|10\s*(?:-\s*)?хона(?:лик|ли)?|ten[- ]bedroom|ten[- ]room)(?![\p{L}\p{N}_])/iu, 10],
+  [/(?<![\p{L}\p{N}_])(?:однушк\p{L}*|однокомнатн\p{L}*|однокімнатн\p{L}*|bir\s+xona(?:li)?|бир\s+хона(?:ли|лик)?|1\s*(?:-\s*)?к(?:омн\p{L}*)?|1\s*(?:-\s*)?xona(?:li)?|1\s*(?:-\s*)?хона(?:лик|ли)?|1\s*бөлмелі|one[- ]bedroom|one[- ]room)(?![\p{L}\p{N}_])/iu, 1],
+  [/(?<![\p{L}\p{N}_])(?:двушк\p{L}*|двухкомнатн\p{L}*|двокімнатн\p{L}*|ikki\s+xona(?:li)?|икки\s+хона(?:ли|лик)?|2\s*(?:-\s*)?к(?:омн\p{L}*)?|2\s*(?:-\s*)?xona(?:li)?|2\s*(?:-\s*)?хона(?:лик|ли)?|2\s*бөлмелі|two[- ]bedroom|two[- ]room)(?![\p{L}\p{N}_])/iu, 2],
+  [/(?<![\p{L}\p{N}_])(?:тр[её]шк\p{L}*|трехкомнатн\p{L}*|трёхкомнатн\p{L}*|трикімнатн\p{L}*|uch\s+xona(?:li)?|уч\s+хона(?:ли|лик)?|3\s*(?:-\s*)?к(?:омн\p{L}*)?|3\s*(?:-\s*)?xona(?:li)?|3\s*(?:-\s*)?хона(?:лик|ли)?|3\s*бөлмелі|three[- ]bedroom|three[- ]room)(?![\p{L}\p{N}_])/iu, 3],
+  [/(?<![\p{L}\p{N}_])(?:четыр[её]хкомнатн\p{L}*|четыр[её]шк\p{L}*|чотирикімнатн\p{L}*|to['’]?rt\s+xona(?:li)?|tort\s+xona(?:li)?|тўрт\s+хона(?:ли|лик)?|турт\s+хона(?:ли|лик)?|4\s*(?:-\s*)?к(?:омн\p{L}*)?|4\s*(?:-\s*)?xona(?:li)?|4\s*(?:-\s*)?хона(?:лик|ли)?|4\s*бөлмелі|four[- ]bedroom|four[- ]room)(?![\p{L}\p{N}_])/iu, 4],
+  [/(?<![\p{L}\p{N}_])(?:пятикомнатн\p{L}*|п['’]ятикімнатн\p{L}*|besh\s+xona(?:li)?|беш\s+хона(?:ли|лик)?|5\s*(?:-\s*)?к(?:омн\p{L}*)?|5\s*(?:-\s*)?xona(?:li)?|5\s*(?:-\s*)?хона(?:лик|ли)?|five[- ]bedroom|five[- ]room)(?![\p{L}\p{N}_])/iu, 5],
+  [/(?<![\p{L}\p{N}_])(?:шестикомнатн\p{L}*|шестикімнатн\p{L}*|olti\s+xona(?:li)?|олти\s+хона(?:ли|лик)?|6\s*(?:-\s*)?к(?:омн\p{L}*)?|6\s*(?:-\s*)?xona(?:li)?|6\s*(?:-\s*)?хона(?:лик|ли)?|six[- ]bedroom|six[- ]room)(?![\p{L}\p{N}_])/iu, 6],
+  [/(?<![\p{L}\p{N}_])(?:семикомнатн\p{L}*|семикімнатн\p{L}*|yetti\s+xona(?:li)?|етти\s+хона(?:ли|лик)?|7\s*(?:-\s*)?к(?:омн\p{L}*)?|7\s*(?:-\s*)?xona(?:li)?|7\s*(?:-\s*)?хона(?:лик|ли)?|seven[- ]bedroom|seven[- ]room)(?![\p{L}\p{N}_])/iu, 7],
+  [/(?<![\p{L}\p{N}_])(?:восьмикомнатн\p{L}*|восьмикімнатн\p{L}*|sakkiz\s+xona(?:li)?|саккиз\s+хона(?:ли|лик)?|8\s*(?:-\s*)?к(?:омн\p{L}*)?|8\s*(?:-\s*)?xona(?:li)?|8\s*(?:-\s*)?хона(?:лик|ли)?|eight[- ]bedroom|eight[- ]room)(?![\p{L}\p{N}_])/iu, 8],
+  [/(?<![\p{L}\p{N}_])(?:девятикомнатн\p{L}*|дев['’]ятикімнатн\p{L}*|to['’]?qqiz\s+xona(?:li)?|toqqiz\s+xona(?:li)?|тўққиз\s+хона(?:ли|лик)?|токкиз\s+хона(?:ли|лик)?|9\s*(?:-\s*)?к(?:омн\p{L}*)?|9\s*(?:-\s*)?xona(?:li)?|9\s*(?:-\s*)?хона(?:лик|ли)?|nine[- ]bedroom|nine[- ]room)(?![\p{L}\p{N}_])/iu, 9],
+  [/(?<![\p{L}\p{N}_])(?:десятикомнатн\p{L}*|десятикімнатн\p{L}*|o['’]?n\s+xona(?:li)?|on\s+xona(?:li)?|ўн\s+хона(?:ли|лик)?|он\s+хона(?:ли|лик)?|10\s*(?:-\s*)?к(?:омн\p{L}*)?|10\s*(?:-\s*)?xona(?:li)?|10\s*(?:-\s*)?хона(?:лик|ли)?|ten[- ]bedroom|ten[- ]room)(?![\p{L}\p{N}_])/iu, 10],
 ]);
 
 // Common classifieds shorthand: rooms/floor/total floors, optionally followed

package/src/housing-text.js

@@ -75,23 +75,29 @@ export function parseHousingResidentialComplex(value) {
   return /[a-zA-Zа-яёіїґ]{2,}/i.test(name) ? name : null;
 }
 
+const AREA_UNIT = String.raw`(?:m2|m²|мкв|м2|м²|sq\s?m|кв\.?\s*м|квадрат[а-яёіїґ]*(?:\s*м(?:етр(?:а|ов)?)?)?)`;
+// Built once: parseHousingAreaFromText() runs per listing card, and neither
+// pattern depends on the text being parsed (see the CURRENCY_ALT comment in
+// housing-money.js for why rebuilding a regex on every call is costly).
+const AREA_LABELLED_RE = new RegExp(
+  String.raw`(?:общая\s+площадь|площадь\s+общая|total\s+area|umumiy\s+maydon|suprafa(?:ță|ta)\s+total(?:ă|a)?)\s*[:=\-]?\s*(\d{1,4}(?:[.,]\d{1,2})?)\s*${AREA_UNIT}`,
+  'iu',
+);
+const AREA_GENERIC_RE = new RegExp(String.raw`(?<![\d.,])(\d{1,4}(?:[.,]\d{1,2})?)\s*${AREA_UNIT}`, 'iu');
+
 export function parseHousingAreaFromText(value) {
   const text = String(value || '');
   if (!text) return null;
 
-  const unit = String.raw`(?:m2|m²|мкв|м2|м²|sq\s?m|кв\.?\s*м|квадрат[а-яёіїґ]*(?:\s*м(?:етр(?:а|ов)?)?)?)`;
   const toArea = (raw) => {
     const number = Number(String(raw || '').replace(/\s+/g, '').replace(',', '.'));
     return Number.isFinite(number) && number > 0 && number <= 100000 ? number : null;
   };
 
-  const labelled = text.match(new RegExp(
-    String.raw`(?:общая\s+площадь|площадь\s+общая|total\s+area|umumiy\s+maydon|suprafa(?:ță|ta)\s+total(?:ă|a)?)\s*[:=\-]?\s*(\d{1,4}(?:[.,]\d{1,2})?)\s*${unit}`,
-    'iu',
-  ));
+  const labelled = text.match(AREA_LABELLED_RE);
   if (labelled) return toArea(labelled[1]);
 
-  const generic = text.match(new RegExp(String.raw`(?<![\d.,])(\d{1,4}(?:[.,]\d{1,2})?)\s*${unit}`, 'iu'));
+  const generic = text.match(AREA_GENERIC_RE);
   if (generic) return toArea(generic[1]);
 
   const compact = text.match(/(?:^|\n)[^\d\r\n]{0,8}[1-9]\s*[¹²³⁴⁵⁶⁷⁸⁹]?\s*\/\s*[0-9]{1,2}\s*\/\s*[0-9]{1,2}\s+(\d{2,4}(?:[.,]\d{1,2})?)\s*кв(?=\s|$)/im);

package/src/housing.js

@@ -210,7 +210,7 @@ export function looksHousingRoomOnly(value) {
   if (!text) return false;
   const occupancy = resolveHousingOccupancy(text);
   if (occupancy === 'room' || occupancy === 'sharedRoom' || occupancy === 'bedSpace') return true;
-  return /подселени|підселен|комнату\s+в|кімнату\s+в|сда[её]тся\s+комната|сдается\s+комната|сдам\s+комнату|здам\s+кімнат|room\s+in\s+a\s+(?:shared\s+)?flat|room\s+for\s+rent|shared\s+(?:flat|apartment|room)|roommate|flatmate|xona\s+ijaraga|xona\s+beriladi|sherik(?:ka|lik)|шерик(?:ка|лик)|(?:1|бир)\s*та\s*(?:бола|киши|қиз|киз)\s*керак|1\s*хонага[^\r\n]{0,40}(?:киши|одам)\s*турилади|бөлме\s+жалға|închiriez\s+camer[ăa]|ищу[^\r\n]{0,60}сосед|ищем[^\r\n]{0,60}сосед|нужен[^\r\n]{0,60}сосед|нужна[^\r\n]{0,60}сосед|шукаю[^\r\n]{0,60}сусід|шукаємо[^\r\n]{0,60}сусід|потрібен[^\r\n]{0,60}сусід|потрібна[^\r\n]{0,60}сусід|співмешкан|співжител|соседк|сусідк/iu.test(text);
+  return /подселени|підселен|комнату\s+в(?![\p{L}\p{N}_])|кімнату\s+в(?![\p{L}\p{N}_])|сда[её]тся\s+комната|сдается\s+комната|сдам\s+комнату|здам\s+кімнат|room\s+in\s+a\s+(?:shared\s+)?flat|room\s+for\s+rent|shared\s+(?:flat|apartment|room)|roommate|flatmate|xona\s+ijaraga|xona\s+beriladi|sherik(?:ka|lik)|шерик(?:ка|лик)|(?:1|бир)\s*та\s*(?:бола|киши|қиз|киз)\s*керак|1\s*хонага[^\r\n]{0,40}(?:киши|одам)\s*турилади|бөлме\s+жалға|închiriez\s+camer[ăa]|ищу[^\r\n]{0,60}сосед|ищем[^\r\n]{0,60}сосед|нужен[^\r\n]{0,60}сосед|нужна[^\r\n]{0,60}сосед|шукаю[^\r\n]{0,60}сусід|шукаємо[^\r\n]{0,60}сусід|потрібен[^\r\n]{0,60}сусід|потрібна[^\r\n]{0,60}сусід|співмешкан|співжител|соседк|сусідк/iu.test(text);
 }
 
 export function resolveHousingPropertyType(value) {

package/src/locations-runtime.js

@@ -8,6 +8,7 @@ import {
 import { isMapDataEntry, LOCATION_LIST_KEYS, mergeLocationCountries } from './location-merge.js';
 import { canonicalCity } from './geography.js';
 import { normalizeForMatch } from './normalization.js';
+import { candidateEntries, computeTextGrams } from './alias-prefilter.js';
 import { KG_LOCATION_EXTENSIONS } from './kg-location-extensions.js';
 import { KG_BISHKEK_AREA_EXTENSIONS } from './kg-bishkek-area-extensions.js';
 import { KG_BISHKEK_STREET_EXTENSIONS } from './kg-bishkek-street-extensions.js';
@@ -180,11 +181,12 @@ export function matchDictionaryLocation(text, countryCode, city = null) {
   const cities = canonical && country[canonical] ? [[canonical, country[canonical]]] : Object.entries(country);
   const value = String(text || '');
   const normalizedValue = normalizeForMatch(value);
+  const grams = computeTextGrams(value);
   let best = null;
 
   for (const [cityName, data] of cities) {
     for (const type of LOCATION_LIST_KEYS) {
-      for (const entry of data[type] || []) {
+      for (const entry of candidateEntries(data[type] || [], value, grams)) {
         const mapData = isMapDataEntry(entry);
         const match = mapData ? mapDataMatch(entry, normalizedValue) : entry?.re?.exec(value);
         if (!match) continue;

package/src/money-core.d.ts

@@ -8,3 +8,4 @@ export function parseScaledAmount(raw: unknown, scale?: unknown): number | null;
 export function moneyCurrencyCandidatesFromText(value: unknown): readonly string[];
 export function moneyCurrencyFromText(value: unknown, fallbackCurrency?: string | null): string | null;
 export function moneyCurrencyPattern(): string;
+export function moneyMentionPattern(): string;

package/src/money-core.js

@@ -1,4 +1,4 @@
-import { aliasesOf, escapeRegex, findCanonical } from './normalization.js';
+import { aliasesOf, escapeRegex, findCanonical, findCanonicalCandidates } from './normalization.js';
 import {
   CURRENCY_SYMBOL_CANDIDATES,
   CURRENCY_TERMS,
@@ -67,11 +67,25 @@ export function parseScaledAmount(raw, scale) {
   return value == null ? null : value * moneyScaleMultiplier(scale);
 }
 
-function explicitCurrencyFromText(value) {
+// A term like "сом" can be a partial-match tie between multiple currencies
+// (e.g. Kyrgyzstani "сом"/KGS and Uzbek "so'm"/UZS both fold to the search
+// key "som"). Returns every tied currency, in registration order, so callers
+// can break the tie using their own context instead of always keeping
+// whichever currency happens to be registered first in the lexicon.
+function explicitCurrencyCandidates(value) {
   const text = String(value || '');
   // Ambiguous glyphs are removed so they cannot hide an explicit ISO/name token.
   const lexicalText = text.replace(/[$¥￥]/g, ' ');
-  return findCanonical(lexicalText, CURRENCY_TERMS, { partial: true })?.canonical || null;
+  return findCanonicalCandidates(lexicalText, CURRENCY_TERMS, { partial: true })
+    .map((entry) => entry?.canonical)
+    .filter(Boolean);
+}
+
+function explicitCurrencyFromText(value, fallbackCurrency = null) {
+  const candidates = explicitCurrencyCandidates(value);
+  if (!candidates.length) return null;
+  const fallback = String(fallbackCurrency || '').trim().toUpperCase();
+  return fallback && candidates.includes(fallback) ? fallback : candidates[0];
 }
 
 export function moneyCurrencyCandidatesFromText(value) {
@@ -81,7 +95,7 @@ export function moneyCurrencyCandidatesFromText(value) {
     if (currency && !candidates.includes(currency)) candidates.push(currency);
   };
 
-  add(explicitCurrencyFromText(text));
+  explicitCurrencyCandidates(text).forEach(add);
 
   for (const [symbol, currencies] of Object.entries(CURRENCY_SYMBOL_CANDIDATES)) {
     if (!text.includes(symbol)) continue;
@@ -96,7 +110,7 @@ export function moneyCurrencyCandidatesFromText(value) {
 }
 
 export function moneyCurrencyFromText(value, fallbackCurrency = null) {
-  const explicit = explicitCurrencyFromText(value);
+  const explicit = explicitCurrencyFromText(value, fallbackCurrency);
   if (explicit) return explicit;
 
   const candidates = moneyCurrencyCandidatesFromText(value);
@@ -112,3 +126,19 @@ export function moneyCurrencyPattern() {
     .map(escapeRegex)
     .join('|');
 }
+
+// A cheap "does this text mention money at all" pre-filter — a currency term
+// or a bare magnitude word (e.g. "15 млн", no currency spelled out) both
+// count. Consumers that need to reject non-money text fast before running a
+// full parseSalary/parseHousingPrice pass (e.g. scanning many HTML card
+// candidates) can test against this instead of hand-copying a currency list,
+// which drifts from the lexicon's own (see MONEY_SCALE_PATTERN for the
+// magnitude half already used by MONEY_RANGE_RE/MONEY_SINGLE_RE).
+//
+// Word-boundary guarded for the same reason MONEY_RANGE_RE/MONEY_SINGLE_RE
+// are: MONEY_SCALE_PATTERN includes bare single-letter abbreviations like "м"
+// (million) that would otherwise match inside an unrelated word — e.g. "2 до
+// 3 месяцев" ("months") must never register as a money mention.
+export function moneyMentionPattern() {
+  return `(?<![\\p{L}\\p{N}_])(?:${moneyCurrencyPattern()}|${MONEY_SCALE_PATTERN})(?![\\p{L}\\p{N}_])`;
+}

package/src/money-lexicon.js

@@ -6,7 +6,7 @@ export const CURRENCY_TERMS = Object.freeze([
   group('USD', { ru: ['$', 'usd', 'доллар', 'доллара', 'долларов', 'бакс', 'у.е.', 'у е'], en: ['$', 'usd', 'dollar', 'dollars', 'us dollar'], uk: ['$', 'usd', 'долар', 'долари', 'доларів'], ro: ['$', 'usd', 'dolar', 'dolari'], uzLatn: ['$', 'usd', 'dollar'], uzCyrl: ['$', 'доллар'], kk: ['$', 'usd', 'доллар'] }),
   group('EUR', { ru: ['€', 'eur', 'евро'], en: ['€', 'eur', 'euro', 'euros'], uk: ['€', 'eur', 'євро'], ro: ['€', 'eur', 'euro'], uzLatn: ['€', 'eur', 'yevro'], uzCyrl: ['€', 'евро'], kk: ['€', 'eur', 'еуро'] }),
   group('UZS', { ru: ['сум', 'сумов', 'узс'], en: ['uzs', 'uzbek som'], uk: ['uzs', 'сум'], ro: ['uzs'], uzLatn: ["so'm", 'so‘m', 'soʻm', 'sum', 'uzs'], uzCyrl: ['сўм', 'сум'], kk: ['uzs'] }),
-  group('KZT', { ru: ['тенге', 'тг', 'kzt'], en: ['kzt', 'tenge'], uk: ['тенге', 'kzt'], ro: ['kzt', 'tenge'], uzLatn: ['kzt', 'tenge'], uzCyrl: ['kzt', 'тенге'], kk: ['теңге', 'тенге', 'тг', 'kzt'] }),
+  group('KZT', { ru: ['₸', 'тенге', 'тг', 'kzt'], en: ['₸', 'kzt', 'tenge'], uk: ['₸', 'тенге', 'kzt'], ro: ['₸', 'kzt', 'tenge'], uzLatn: ['₸', 'kzt', 'tenge'], uzCyrl: ['₸', 'kzt', 'тенге'], kk: ['₸', 'теңге', 'тенге', 'тг', 'kzt'] }),
   group('UAH', { ru: ['грн', 'гривна', 'гривны', 'гривен', '₴', 'uah'], en: ['uah', 'hryvnia', 'hryvnias', '₴'], uk: ['грн', 'гривня', 'гривні', 'гривень', '₴', 'uah'], ro: ['uah', 'hrivne', 'grivne'], uzLatn: ['uah'], uzCyrl: ['uah'], kk: ['uah'] }),
   group('RUB', { ru: ['₽', 'руб', 'руб.', 'рубль', 'рубля', 'рублей', 'rub', 'rur'], en: ['₽', 'rub', 'rur', 'ruble', 'rubles'], uk: ['₽', 'руб', 'рублів', 'rub'], ro: ['₽', 'rub', 'ruble'], uzLatn: ['₽', 'rub', 'rubl'], uzCyrl: ['₽', 'рубль'], kk: ['₽', 'rub', 'рубль'] }),
   group('GBP', { ru: ['£', 'gbp', 'фунт', 'фунтов'], en: ['£', 'gbp', 'pound', 'pounds', 'sterling'], uk: ['£', 'gbp', 'фунт', 'фунтів'], ro: ['£', 'gbp', 'liră sterlină', 'lira sterlina'], uzLatn: ['£', 'gbp', 'funt'], uzCyrl: ['£', 'фунт'], kk: ['£', 'gbp', 'фунт'] }),
@@ -41,6 +41,7 @@ export const CURRENCY_SYMBOL_CANDIDATES = Object.freeze({
   '€': Object.freeze(['EUR']),
   '₴': Object.freeze(['UAH']),
   '₽': Object.freeze(['RUB']),
+  '₸': Object.freeze(['KZT']),
   '£': Object.freeze(['GBP']),
   '₺': Object.freeze(['TRY']),
   '₾': Object.freeze(['GEL']),

package/src/money.js

@@ -22,6 +22,7 @@ export {
   MONEY_SINGLE_RE,
   moneyCurrencyFromText,
   moneyCurrencyPattern,
+  moneyMentionPattern,
   moneyScaleMultiplier,
   parseNumericAmount,
   parseScaledAmount,

package/src/normalization.js

@@ -183,32 +183,68 @@ export function getAliasOwnersIndex(entries, { transliteration = true } = {}) {
   return index;
 }
 
-export function findCanonical(value, entries, { partial = false, transliteration = true } = {}) {
-  if (!value) return null;
+/**
+ * Every entry tied for the longest partial alias match, in the order they
+ * first reach that length. Exact matches always resolve unambiguously to a
+ * single entry. Callers that need to disambiguate a partial tie against
+ * caller-supplied context (e.g. a fallback currency) should use this instead
+ * of findCanonical(), which silently keeps only the first-registered entry.
+ */
+export function findCanonicalCandidates(value, entries, { partial = false, transliteration = true } = {}) {
+  if (!value) return [];
   const index = getAliasIndex(entries, { transliteration });
   for (const key of normalizedAliasKeys(value, { transliteration })) {
     const exact = index.get(key);
-    if (exact) return exact;
+    if (exact) return [exact];
   }
-  if (!partial) return null;
+  if (!partial) return [];
 
   const textKeys = normalizedAliasKeys(value, { transliteration });
-  let best = null;
+  let tied = [];
   let bestLength = 0;
   for (const [alias, entry] of index) {
-    if (alias.length <= bestLength) continue;
-    if (textKeys.some((text) => ` ${text} `.includes(` ${alias} `))) {
-      best = entry;
+    if (alias.length < bestLength) continue;
+    if (!textKeys.some((text) => ` ${text} `.includes(` ${alias} `))) continue;
+    if (alias.length > bestLength) {
       bestLength = alias.length;
+      tied = [entry];
+    } else if (!tied.includes(entry)) {
+      tied.push(entry);
     }
   }
-  return best;
+  return tied;
+}
+
+export function findCanonical(value, entries, options = {}) {
+  return findCanonicalCandidates(value, entries, options)[0] || null;
 }
 
 export function escapeRegex(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+// A word-boundary class scoped to the scripts this lexicon actually targets
+// (Latin incl. Romanian/Karakalpak diacritics, Cyrillic incl. supplement,
+// digits, underscore) instead of the full-Unicode \p{L}\p{N} property
+// escapes. Under V8's unicode ('u') regex mode, \p{L}/\p{N} character
+// classes compile to disproportionately large native code — benchmarked at
+// roughly 20x slower and 4x more memory per compiled entry than this
+// explicit range, which matters a lot here: aliasesToRegex()/matcherFor()
+// compile one such regex per lexicon entry or per matcher (`entry.re`
+// getters across the location/housing/hiring dictionaries, and
+// findAllCanonical()'s combined matcher), and a single city's street list
+// alone can hold thousands of entries. See the apps/flats housing-source-
+// crawler OOM this was diagnosed against (norieltor.com.ua and others).
+const ALIAS_BOUNDARY_CLASS = 'A-Za-z0-9_\\u00C0-\\u02AF\\u0370-\\u03FF\\u0400-\\u052F';
+// For literal alternation (aliasesToRegex: "either start-of-string or a
+// non-word char"), the class itself must be negated.
+const ALIAS_NON_BOUNDARY_RE_SOURCE = `[^${ALIAS_BOUNDARY_CLASS}]`;
+// For lookaround (matcherFor: "not preceded/followed by a word char"), the
+// negation belongs on the lookaround itself, not inside the class too --
+// `(?<![^X])` double-negates into "must be adjacent to X", the opposite of
+// the intended boundary check.
+const ALIAS_WORD_RE_SOURCE = `[${ALIAS_BOUNDARY_CLASS}]`;
+
 function aliasPattern(value) {
   const source = normalizeUnicode(value).trim();
   let pattern = '';
@@ -239,7 +275,7 @@ function matcherFor(entries, { transliteration = true } = {}) {
   const result = searchAliases.length
     ? Object.freeze({
         owners,
-        re: new RegExp(`(?<![\\p{L}\\p{N}_])(?:${searchAliases.map(aliasPattern).join('|')})(?![\\p{L}\\p{N}_])`, 'giu'),
+        re: new RegExp(`(?<!${ALIAS_WORD_RE_SOURCE})(?:${searchAliases.map(aliasPattern).join('|')})(?!${ALIAS_WORD_RE_SOURCE})`, 'gi'),
       })
     : Object.freeze({ owners, re: null });
 
@@ -408,12 +444,15 @@ export function assertValidLexicon(entries, options = {}) {
   return true;
 }
 
-export function aliasesToRegex(values, flags = 'iu') {
+export function aliasesToRegex(values, flags = 'i') {
   const alternatives = [...new Set(values || [])]
     .filter((value) => typeof value === 'string' && value.trim())
     .map((value) => normalizeUnicode(value).trim())
     .sort((a, b) => b.length - a.length)
     .map(aliasPattern);
   if (!alternatives.length) throw new TypeError('aliasesToRegex() requires at least one non-empty alias');
-  return new RegExp(`(?:^|[^\\p{L}\\p{N}_])(?:${alternatives.join('|')})(?:$|[^\\p{L}\\p{N}_])`, flags);
+  return new RegExp(
+    `(?:^|${ALIAS_NON_BOUNDARY_RE_SOURCE})(?:${alternatives.join('|')})(?:$|${ALIAS_NON_BOUNDARY_RE_SOURCE})`,
+    flags.replace('u', ''),
+  );
 }