@whiteslove/parsing-lexicon 0.2.0

package/src/money-lexicon.js

@@ -0,0 +1,79 @@
+import { lexiconEntity } from './lexicon-core.js';
+
+const group = (canonical, aliases, extra = {}) => lexiconEntity(canonical, aliases, extra);
+
+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('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', 'фунт'] }),
+  group('TRY', { ru: ['₺', 'try', 'лира', 'лир'], en: ['₺', 'try', 'turkish lira'], uk: ['₺', 'try', 'ліра', 'лір'], ro: ['₺', 'try', 'liră turcească', 'lira turceasca'], uzLatn: ['₺', 'try', 'lira'], uzCyrl: ['₺', 'лира'], kk: ['₺', 'try', 'лира'] }),
+  group('GEL', { ru: ['₾', 'gel', 'лари'], en: ['₾', 'gel', 'lari'], uk: ['₾', 'gel', 'ларі'], ro: ['₾', 'gel', 'lari'], uzLatn: ['₾', 'gel', 'lari'], uzCyrl: ['₾', 'лари'], kk: ['₾', 'gel', 'лари'] }),
+  group('AED', { ru: ['aed', 'дирхам', 'дирхамов'], en: ['aed', 'dirham', 'dirhams'], uk: ['aed', 'дирхам', 'дирхамів'], ro: ['aed', 'dirham'], uzLatn: ['aed', 'dirham'], uzCyrl: ['aed', 'дирҳам'], kk: ['aed', 'дирхам'] }),
+  group('PLN', { ru: ['pln', 'злотый', 'злотых'], en: ['pln', 'zloty', 'zł'], uk: ['pln', 'злотий', 'злотих'], ro: ['pln', 'zlot'], uzLatn: ['pln', 'zloty'], uzCyrl: ['pln'], kk: ['pln'] }),
+  group('RON', { ru: ['ron', 'лей', 'леев'], en: ['ron', 'romanian leu', 'lei'], uk: ['ron', 'лей', 'леїв'], ro: ['ron', 'leu', 'lei'], uzLatn: ['ron'], uzCyrl: ['ron'], kk: ['ron'] }),
+  group('KGS', { ru: ['kgs', 'сом', 'сомов'], en: ['kgs', 'kyrgyz som'], uk: ['kgs', 'сом'], ro: ['kgs'], uzLatn: ['kgs', 'som'], uzCyrl: ['kgs', 'сом'], kk: ['kgs', 'сом'] }),
+  group('CHF', { ru: ['chf', 'швейцарский франк', 'швейцарских франков'], en: ['chf', 'swiss franc', 'swiss francs'], uk: ['chf', 'швейцарський франк'], ro: ['chf', 'franc elvețian', 'franc elvetian'], uzLatn: ['chf', 'shveytsariya franki'], uzCyrl: ['chf'], kk: ['chf', 'швейцар франкі'] }),
+  group('CNY', { ru: ['cny', 'rmb', 'юань', 'юаней', '元'], en: ['cny', 'rmb', 'yuan', 'renminbi', '元'], uk: ['cny', 'юань', 'юанів'], ro: ['cny', 'yuan'], uzLatn: ['cny', 'yuan'], uzCyrl: ['cny', 'юань'], kk: ['cny', 'юань'] }),
+  group('JPY', { ru: ['jpy', 'иена', 'иены', 'иен', '円'], en: ['jpy', 'yen', 'japanese yen', '円'], uk: ['jpy', 'єна', 'єн'], ro: ['jpy', 'yen'], uzLatn: ['jpy', 'yen'], uzCyrl: ['jpy', 'иена'], kk: ['jpy', 'иена'] }),
+  group('KRW', { ru: ['₩', 'krw', 'вона', 'вон'], en: ['₩', 'krw', 'won', 'south korean won'], uk: ['₩', 'krw', 'вона'], ro: ['₩', 'krw', 'won'], uzLatn: ['₩', 'krw', 'won'], uzCyrl: ['₩', 'krw'], kk: ['₩', 'krw', 'вон'] }),
+  group('CAD', { ru: ['cad', 'канадский доллар', 'канадских долларов'], en: ['cad', 'canadian dollar', 'canadian dollars'], uk: ['cad', 'канадський долар'], ro: ['cad', 'dolar canadian'], uzLatn: ['cad', 'kanada dollari'], uzCyrl: ['cad'], kk: ['cad', 'канада доллары'] }),
+  group('AUD', { ru: ['aud', 'австралийский доллар', 'австралийских долларов'], en: ['aud', 'australian dollar', 'australian dollars'], uk: ['aud', 'австралійський долар'], ro: ['aud', 'dolar australian'], uzLatn: ['aud', 'avstraliya dollari'], uzCyrl: ['aud'], kk: ['aud', 'австралия доллары'] }),
+  group('NZD', { ru: ['nzd', 'новозеландский доллар'], en: ['nzd', 'new zealand dollar', 'new zealand dollars'], uk: ['nzd', 'новозеландський долар'], ro: ['nzd', 'dolar neozeelandez'], uzLatn: ['nzd'], uzCyrl: ['nzd'], kk: ['nzd'] }),
+  group('SGD', { ru: ['sgd', 'сингапурский доллар'], en: ['sgd', 'singapore dollar', 'singapore dollars'], uk: ['sgd', 'сінгапурський долар'], ro: ['sgd', 'dolar singaporez'], uzLatn: ['sgd'], uzCyrl: ['sgd'], kk: ['sgd'] }),
+  group('HKD', { ru: ['hkd', 'гонконгский доллар'], en: ['hkd', 'hong kong dollar', 'hong kong dollars'], uk: ['hkd', 'гонконзький долар'], ro: ['hkd', 'dolar hong kong'], uzLatn: ['hkd'], uzCyrl: ['hkd'], kk: ['hkd'] }),
+  group('INR', { ru: ['₹', 'inr', 'рупия', 'рупии', 'рупий'], en: ['₹', 'inr', 'indian rupee', 'indian rupees', 'rupee', 'rupees'], uk: ['₹', 'inr', 'рупія', 'рупій'], ro: ['₹', 'inr', 'rupie indiană', 'rupie indiana'], uzLatn: ['₹', 'inr', 'rupiya'], uzCyrl: ['₹', 'inr'], kk: ['₹', 'inr', 'рупия'] }),
+  group('CZK', { ru: ['czk', 'чешская крона', 'чешских крон'], en: ['czk', 'czech koruna', 'czech crown'], uk: ['czk', 'чеська крона'], ro: ['czk', 'coroană cehă', 'coroana ceha'], uzLatn: ['czk'], uzCyrl: ['czk'], kk: ['czk'] }),
+  group('HUF', { ru: ['huf', 'форинт', 'форинтов'], en: ['huf', 'forint', 'hungarian forint'], uk: ['huf', 'форинт'], ro: ['huf', 'forint'], uzLatn: ['huf'], uzCyrl: ['huf'], kk: ['huf'] }),
+  group('BGN', { ru: ['bgn', 'лев', 'лева', 'левов'], en: ['bgn', 'bulgarian lev', 'lev'], uk: ['bgn', 'болгарський лев'], ro: ['bgn', 'leva bulgărească', 'leva bulgareasca'], uzLatn: ['bgn'], uzCyrl: ['bgn'], kk: ['bgn'] }),
+  group('MDL', { ru: ['mdl', 'молдавский лей', 'молдавских леев'], en: ['mdl', 'moldovan leu', 'moldovan lei'], uk: ['mdl', 'молдовський лей'], ro: ['mdl', 'leu moldovenesc', 'lei moldovenești', 'lei moldovenesti'], uzLatn: ['mdl'], uzCyrl: ['mdl'], kk: ['mdl'] }),
+  group('AZN', { ru: ['₼', 'azn', 'манат', 'манатов'], en: ['₼', 'azn', 'azerbaijani manat', 'manat'], uk: ['₼', 'azn', 'манат'], ro: ['₼', 'azn', 'manat azer'], uzLatn: ['₼', 'azn', 'manat'], uzCyrl: ['₼', 'azn'], kk: ['₼', 'azn', 'манат'] }),
+  group('AMD', { ru: ['֏', 'amd', 'драм', 'драмов'], en: ['֏', 'amd', 'armenian dram', 'dram'], uk: ['֏', 'amd', 'драм'], ro: ['֏', 'amd', 'dram armean'], uzLatn: ['֏', 'amd'], uzCyrl: ['֏', 'amd'], kk: ['֏', 'amd', 'драм'] }),
+  group('TJS', { ru: ['tjs', 'сомони'], en: ['tjs', 'tajikistani somoni', 'somoni'], uk: ['tjs', 'сомоні'], ro: ['tjs', 'somoni'], uzLatn: ['tjs', 'somoni'], uzCyrl: ['tjs', 'сомони'], kk: ['tjs', 'сомони'] }),
+  group('TMT', { ru: ['tmt', 'туркменский манат'], en: ['tmt', 'turkmen manat'], uk: ['tmt', 'туркменський манат'], ro: ['tmt', 'manat turkmen'], uzLatn: ['tmt', 'turkman manati'], uzCyrl: ['tmt'], kk: ['tmt'] }),
+]);
+
+export const CURRENCY_SYMBOL_CANDIDATES = Object.freeze({
+  '$': Object.freeze(['USD', 'CAD', 'AUD', 'NZD', 'SGD', 'HKD']),
+  '€': Object.freeze(['EUR']),
+  '₴': Object.freeze(['UAH']),
+  '₽': Object.freeze(['RUB']),
+  '£': Object.freeze(['GBP']),
+  '₺': Object.freeze(['TRY']),
+  '₾': Object.freeze(['GEL']),
+  '₩': Object.freeze(['KRW']),
+  '₹': Object.freeze(['INR']),
+  '₼': Object.freeze(['AZN']),
+  '֏': Object.freeze(['AMD']),
+  '¥': Object.freeze(['JPY', 'CNY']),
+  '￥': Object.freeze(['JPY', 'CNY']),
+});
+
+export const SALARY_PERIODS = Object.freeze([
+  group('hour', { ru: ['в час', 'за час', 'почасово', 'часовая ставка'], en: ['per hour', 'hourly', '/hour', '/hr'], uk: ['за годину', 'на годину', 'погодинно'], ro: ['pe oră', 'pe ora', 'orar'], uzLatn: ['soatiga', 'soatlik'], uzCyrl: ['соатига', 'соатлик'], kk: ['сағатына', 'сағаттық'] }),
+  group('day', { ru: ['в день', 'за день', 'дневная ставка'], en: ['per day', 'daily', '/day'], uk: ['за день', 'на день', 'щодня'], ro: ['pe zi', 'zilnic'], uzLatn: ['kuniga', 'kunlik'], uzCyrl: ['кунига', 'кунлик'], kk: ['күніне', 'күндік'] }),
+  group('shift', { ru: ['за смену', 'смена', 'за выход'], en: ['per shift', 'shift rate'], uk: ['за зміну', 'зміна'], ro: ['pe tură', 'pe tura'], uzLatn: ['smenaga', 'smena uchun'], uzCyrl: ['сменага', 'смена учун'], kk: ['ауысымға', 'ауысым үшін'] }),
+  group('week', { ru: ['в неделю', 'за неделю', 'еженедельно'], en: ['per week', 'weekly', '/week'], uk: ['на тиждень', 'за тиждень', 'щотижня'], ro: ['pe săptămână', 'pe saptamana', 'săptămânal'], uzLatn: ['haftasiga', 'haftalik'], uzCyrl: ['ҳафтасига', 'ҳафталик'], kk: ['аптасына', 'апталық'] }),
+  group('month', { ru: ['в месяц', 'за месяц', 'месячная', 'ежемесячно', 'в мес'], en: ['per month', 'monthly', '/month', '/mo', 'pcm'], uk: ['на місяць', 'за місяць', 'щомісяця'], ro: ['pe lună', 'pe luna', 'lunar'], uzLatn: ['oyiga', 'oylik'], uzCyrl: ['ойига', 'ойлик'], kk: ['айына', 'айлық'] }),
+  group('year', { ru: ['в год', 'за год', 'годовая', 'годовых'], en: ['per year', 'yearly', 'annual', 'annually', '/year', 'p.a.'], uk: ['на рік', 'за рік', 'річна'], ro: ['pe an', 'anual'], uzLatn: ['yiliga', 'yillik'], uzCyrl: ['йилига', 'йиллик'], kk: ['жылына', 'жылдық'] }),
+  group('project', { ru: ['за проект', 'за заказ'], en: ['per project', 'project fee'], uk: ['за проєкт', 'за замовлення'], ro: ['pe proiect'], uzLatn: ['loyiha uchun', 'buyurtma uchun'], uzCyrl: ['лойиҳа учун', 'буюртма учун'], kk: ['жобаға', 'тапсырысқа'] }),
+  group('piece', { ru: ['сдельно', 'за единицу', 'за штуку'], en: ['piece rate', 'per piece', 'per item'], uk: ['відрядно', 'за одиницю'], ro: ['la bucată', 'la bucata'], uzLatn: ['dona uchun', 'ishbay'], uzCyrl: ['дона учун', 'ишбай'], kk: ['данасына', 'кесімді'] }),
+]);
+
+export const SALARY_MODIFIERS = Object.freeze({
+  from: group('from', { ru: ['от', 'начиная с'], en: ['from', 'starting at', 'at least'], uk: ['від', 'починаючи від'], ro: ['de la', 'începând de la', 'incepand de la'], uzLatn: ['dan', 'kamida'], uzCyrl: ['дан', 'камида'], kk: ['бастап', 'кемінде'] }),
+  to: group('to', { ru: ['до', 'максимум'], en: ['up to', 'maximum', 'max'], uk: ['до', 'максимум'], ro: ['până la', 'pana la', 'maximum'], uzLatn: ['gacha', 'maksimum'], uzCyrl: ['гача', 'максимум'], kk: ['дейін', 'максимум'] }),
+  approx: group('approx', { ru: ['около', 'примерно', 'порядка'], en: ['about', 'approx', 'approximately', 'around'], uk: ['близько', 'приблизно'], ro: ['aproximativ', 'circa'], uzLatn: ['taxminan', 'atrofida'], uzCyrl: ['тахминан', 'атрофида'], kk: ['шамамен', 'шамасы'] }),
+  negotiable: group('negotiable', { ru: ['по договоренности', 'по договорённости', 'договорная', 'обсуждается'], en: ['negotiable', 'competitive salary', 'salary discussed', 'doe'], uk: ['за домовленістю', 'договірна'], ro: ['negociabil', 'salariu negociabil'], uzLatn: ['kelishiladi', 'kelishilgan holda'], uzCyrl: ['келишилади'], kk: ['келісім бойынша', 'келісіледі'] }),
+  gross: group('gross', { ru: ['gross', 'гросс', 'до налогов', 'до вычета налогов', 'до вычета ндфл'], en: ['gross', 'before tax', 'pre-tax'], uk: ['gross', 'до податків', 'до вирахування податків'], ro: ['brut', 'înainte de taxe', 'inainte de taxe'], uzLatn: ['soliqdan oldin', 'gross'], uzCyrl: ['солиқдан олдин'], kk: ['салыққа дейін', 'gross'] }),
+  net: group('net', { ru: ['net', 'нетто', 'на руки', 'чистыми', 'после налогов', 'после вычета налогов'], en: ['net', 'after tax', 'take home', 'take-home'], uk: ['net', 'нетто', 'на руки', 'після податків'], ro: ['net', 'după taxe', 'dupa taxe'], uzLatn: ['qo‘lga', "qo'lga", 'soliqdan keyin', 'net'], uzCyrl: ['қўлга', 'солиқдан кейин'], kk: ['қолға', 'салықтан кейін', 'net'] }),
+});
+
+export const NUMBER_MULTIPLIERS = Object.freeze([
+  group('thousand', { ru: ['к', 'тыс', 'тыс.', 'тысяч', 'тысячи'], en: ['k', 'thousand'], uk: ['к', 'тис', 'тис.', 'тисяч'], ro: ['k', 'mii'], uzLatn: ['k', 'ming'], uzCyrl: ['минг'], kk: ['k', 'мың'] }, { multiplier: 1_000 }),
+  group('million', { ru: ['м', 'млн', 'млн.', 'миллион', 'миллионов'], en: ['m', 'mln', 'million', 'millions'], uk: ['м', 'млн', 'мільйон', 'мільйонів'], ro: ['m', 'mil', 'milioane'], uzLatn: ['m', 'mln', 'million'], uzCyrl: ['млн', 'миллион'], kk: ['м', 'млн', 'миллион'] }, { multiplier: 1_000_000 }),
+  group('billion', { ru: ['млрд', 'миллиард', 'миллиардов'], en: ['bn', 'billion'], uk: ['млрд', 'мільярд'], ro: ['mld', 'miliard'], uzLatn: ['mlrd', 'billion'], uzCyrl: ['млрд', 'миллиард'], kk: ['млрд', 'миллиард'] }, { multiplier: 1_000_000_000 }),
+]);

package/src/money.js

@@ -0,0 +1,154 @@
+import { findPhoneLikeSpans } from './contact.js';
+import { aliasesOf, findCanonical, normalizeUnicode } from './normalization.js';
+import {
+  CURRENCY_TERMS,
+  NUMBER_MULTIPLIERS,
+  SALARY_MODIFIERS,
+  SALARY_PERIODS,
+} from './money-lexicon.js';
+import {
+  MONEY_RANGE_RE,
+  MONEY_SINGLE_RE,
+  moneyCurrencyFromText,
+  parseScaledAmount,
+} from './money-core.js';
+
+export { CURRENCY_TERMS, NUMBER_MULTIPLIERS, SALARY_MODIFIERS, SALARY_PERIODS } from './money-lexicon.js';
+export {
+  MONEY_NUMBER_PATTERN,
+  MONEY_RANGE_RE,
+  MONEY_SCALE_PATTERN,
+  MONEY_SINGLE_RE,
+  moneyCurrencyFromText,
+  moneyCurrencyPattern,
+  moneyScaleMultiplier,
+  parseNumericAmount,
+  parseScaledAmount,
+} from './money-core.js';
+
+const CONTACT_MARKER_RE = /(?:телефон|тел\.?|phone|mobile|mob\.?|whatsapp|viber|telegram|контакт|contact|aloqa|murojaat|bog(?:['’ʻʼ‘`])?lanish)\s*[:：—-]?\s*$/iu;
+
+function hasSalaryContext(text) {
+  return /(?:salary|зарплат|з\s*п\b|оплат|ставк|доход|оклад|компенсац|maosh|oylik|ish\s+haqi|жалақы|айлық|еңбекақы|salariu|оплата)/iu.test(text);
+}
+
+function periodFromText(text) {
+  return findCanonical(text, SALARY_PERIODS, { partial: true })?.canonical || null;
+}
+
+function hasModifier(text, key) {
+  return Boolean(findCanonical(text, [SALARY_MODIFIERS[key]], { partial: true }));
+}
+
+function protectedPhoneSpans(text) {
+  return findPhoneLikeSpans(text).filter((span) => {
+    const prefix = text.slice(Math.max(0, span.start - 32), span.start);
+    return CONTACT_MARKER_RE.test(prefix);
+  });
+}
+
+function overlapsProtectedPhone(start, end, spans) {
+  return spans.some((span) => start < span.end && end > span.start);
+}
+
+function moneyContextScore(text, start, end, scaled = false) {
+  const window = text.slice(Math.max(0, start - 36), Math.min(text.length, end + 40));
+  let score = 0;
+  if (moneyCurrencyFromText(window)) score += 5;
+  if (hasSalaryContext(window)) score += 4;
+  if (periodFromText(window)) score += 2;
+  if (scaled) score += 1;
+  return score;
+}
+
+function bestRange(text, protectedSpans) {
+  const ranges = new RegExp(MONEY_RANGE_RE.source, 'giu');
+  const candidates = [];
+  for (const match of text.matchAll(ranges)) {
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    if (overlapsProtectedPhone(start, end, protectedSpans)) continue;
+    const scaled = Boolean(match[2] || match[4]);
+    const score = moneyContextScore(text, start, end, scaled);
+    if (score <= 0) continue;
+    candidates.push({ match, score, start });
+  }
+  candidates.sort((a, b) => b.score - a.score || a.start - b.start);
+  return candidates[0]?.match || null;
+}
+
+export function parseSalary(value) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text) return null;
+
+  const currency = moneyCurrencyFromText(text);
+  const negotiable = hasModifier(text, 'negotiable');
+  const gross = hasModifier(text, 'gross') ? true : hasModifier(text, 'net') ? false : null;
+  const period = periodFromText(text);
+
+  const salaryContext = hasSalaryContext(text)
+    || Boolean(currency)
+    || NUMBER_MULTIPLIERS.some((entry) => findCanonical(text, [entry], { partial: true }));
+  if (!salaryContext && !negotiable) return null;
+
+  const protectedSpans = protectedPhoneSpans(text);
+  const range = bestRange(text, protectedSpans);
+  let min = null;
+  let max = null;
+  const approximate = hasModifier(text, 'approx');
+
+  if (range) {
+    const firstScale = range[2] || range[4] || null;
+    const secondScale = range[4] || range[2] || null;
+    min = parseScaledAmount(range[1], firstScale);
+    max = parseScaledAmount(range[3], secondScale);
+    if (min != null && max != null && min > max) [min, max] = [max, min];
+  } else {
+    MONEY_SINGLE_RE.lastIndex = 0;
+    const candidates = [];
+    for (const match of text.matchAll(MONEY_SINGLE_RE)) {
+      const start = match.index ?? 0;
+      const end = start + match[0].length;
+      if (overlapsProtectedPhone(start, end, protectedSpans)) continue;
+      const window = text.slice(Math.max(0, start - 24), Math.min(text.length, end + 32));
+      const scaled = Boolean(match[2]);
+      const score = moneyContextScore(text, start, end, scaled);
+      if (score <= 0) continue;
+      const parsed = parseScaledAmount(match[1], match[2]);
+      if (parsed == null) continue;
+      if (!scaled && !moneyCurrencyFromText(window) && parsed >= 1900 && parsed <= 2100 && !hasSalaryContext(window)) continue;
+      candidates.push({ value: parsed, score, start });
+    }
+    candidates.sort((a, b) => b.score - a.score || a.start - b.start);
+    if (candidates.length) {
+      const valueAmount = candidates[0].value;
+      if (hasModifier(text, 'to')) max = valueAmount;
+      else if (hasModifier(text, 'from') || /\+\s*(?:$|\D)/u.test(text)) min = valueAmount;
+      else min = max = valueAmount;
+    }
+  }
+
+  if (min == null && max == null && !negotiable) return null;
+  return Object.freeze({
+    min,
+    max,
+    currency,
+    period,
+    gross,
+    negotiable,
+    approximate,
+  });
+}
+
+export function salaryCurrency(value) {
+  return moneyCurrencyFromText(String(value || ''));
+}
+
+export function salaryPeriod(value) {
+  return periodFromText(String(value || ''));
+}
+
+export function currencyAliases(code) {
+  const entry = CURRENCY_TERMS.find((item) => item.canonical === code);
+  return entry ? [entry.canonical, ...aliasesOf(entry)] : [];
+}

package/src/normalization.js

@@ -0,0 +1,384 @@
+import { LEXICON_LANGUAGES } from './lexicon-core.js';
+
+const APOSTROPHES_RE = /[’‘ʻʼ`´]/g;
+const DASHES_RE = /[‐‑‒–—―]/g;
+
+/** Normalize Unicode and punctuation variants without destroying letters. */
+export function normalizeUnicode(value) {
+  return String(value ?? '')
+    .normalize('NFKC')
+    .replace(APOSTROPHES_RE, "'")
+    .replace(DASHES_RE, '-');
+}
+
+/** Stable comparison form for parser dictionaries. */
+export function normalizeForMatch(value) {
+  return normalizeUnicode(value)
+    .toLocaleLowerCase()
+    .replace(/ё/g, 'е')
+    .replace(/['-]+/g, ' ')
+    .replace(/[^\p{L}\p{N}]+/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/** Search-only apostrophe compaction for Uzbek/Karakalpak variants. */
+function normalizeCompactApostropheForMatch(value) {
+  return normalizeUnicode(value)
+    .toLocaleLowerCase()
+    .replace(/ё/g, 'е')
+    .replace(/'+/g, '')
+    .replace(/-+/g, ' ')
+    .replace(/[^\p{L}\p{N}]+/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+const CYRILLIC_SEARCH_MAP = Object.freeze({
+  а: 'a', б: 'b', в: 'v', г: 'g', д: 'd', е: 'e', ё: 'e', ж: 'zh', з: 'z',
+  и: 'i', й: 'y', к: 'k', л: 'l', м: 'm', н: 'n', о: 'o', п: 'p', р: 'r',
+  с: 's', т: 't', у: 'u', ф: 'f', х: 'h', ц: 'ts', ч: 'ch', ш: 'sh', щ: 'shch',
+  ъ: '', ы: 'y', ь: '', э: 'e', ю: 'yu', я: 'ya',
+  ў: 'o', қ: 'q', ғ: 'g', ҳ: 'h',
+  ә: 'a', і: 'i', ң: 'ng', ө: 'o', ұ: 'u', ү: 'u', һ: 'h',
+  є: 'ye', ї: 'yi', ґ: 'g',
+});
+
+const KAZAKH_SEARCH_EQUIVALENCE = Object.freeze({
+  ә: 'а', ғ: 'г', қ: 'к', ң: 'н', ө: 'о', ұ: 'у', ү: 'у', і: 'и', һ: 'х',
+});
+
+/** Search-oriented Cyrillic folding; canonical identity still comes from explicit aliases. */
+export function foldCyrillicForSearch(value) {
+  return normalizeUnicode(value)
+    .toLocaleLowerCase()
+    .split('')
+    .map((char) => CYRILLIC_SEARCH_MAP[char] ?? char)
+    .join('');
+}
+
+function foldKazakhForSearch(value) {
+  return normalizeUnicode(value)
+    .toLocaleLowerCase()
+    .split('')
+    .map((char) => KAZAKH_SEARCH_EQUIVALENCE[char] ?? char)
+    .join('');
+}
+
+export function normalizedAliasKeys(value, { transliteration = true } = {}) {
+  const forms = transliteration
+    ? [value, foldCyrillicForSearch(value), foldKazakhForSearch(value)]
+    : [value];
+  return [...new Set(forms.flatMap((form) => [
+    normalizeForMatch(form),
+    normalizeCompactApostropheForMatch(form),
+  ]).filter(Boolean))];
+}
+
+export function aliasesOf(entry) {
+  const aliases = entry?.aliases;
+  if (Array.isArray(aliases)) return aliases;
+  if (!aliases || typeof aliases !== 'object') return [];
+  return Object.values(aliases).flatMap((values) => Array.isArray(values) ? values : []);
+}
+
+function valuesOf(entry) {
+  return [entry?.canonical, entry?.name, ...aliasesOf(entry)].filter(Boolean);
+}
+
+function createAliasIndex(entries, { transliteration = true } = {}) {
+  const index = new Map();
+  for (const entry of entries || []) {
+    for (const value of valuesOf(entry)) {
+      for (const key of normalizedAliasKeys(value, { transliteration })) {
+        if (!index.has(key)) index.set(key, entry);
+      }
+    }
+  }
+  return index;
+}
+
+function createAliasOwnersIndex(entries, { transliteration = true } = {}) {
+  const index = new Map();
+  for (const entry of entries || []) {
+    for (const sourceAlias of valuesOf(entry)) {
+      const searchForms = transliteration
+        ? [sourceAlias, foldCyrillicForSearch(sourceAlias), foldKazakhForSearch(sourceAlias)]
+        : [sourceAlias];
+      for (const searchAlias of searchForms) {
+        for (const key of normalizedAliasKeys(searchAlias, { transliteration: false })) {
+          if (!key) continue;
+          const owners = index.get(key) || [];
+          if (!owners.some((owner) => owner.entry === entry && owner.sourceAlias === sourceAlias)) {
+            owners.push(Object.freeze({ entry, sourceAlias, searchAlias }));
+          }
+          index.set(key, owners);
+        }
+      }
+    }
+  }
+  return index;
+}
+
+/** Build a fresh alias index. Prefer getAliasIndex() for repeated parser calls. */
+export function buildAliasIndex(entries, options = {}) {
+  return createAliasIndex(entries, options);
+}
+
+const DEFAULT_ALIAS_INDEX_CACHE = new WeakMap();
+const DIRECT_ALIAS_INDEX_CACHE = new WeakMap();
+const DEFAULT_OWNERS_INDEX_CACHE = new WeakMap();
+const DIRECT_OWNERS_INDEX_CACHE = new WeakMap();
+const DEFAULT_MATCHER_CACHE = new WeakMap();
+const DIRECT_MATCHER_CACHE = new WeakMap();
+
+/** Cached alias index for stable/frozen lexicon arrays. */
+export function getAliasIndex(entries, { transliteration = true } = {}) {
+  if (!entries || (typeof entries !== 'object' && typeof entries !== 'function')) {
+    return createAliasIndex(entries, { transliteration });
+  }
+  const cache = transliteration ? DEFAULT_ALIAS_INDEX_CACHE : DIRECT_ALIAS_INDEX_CACHE;
+  let index = cache.get(entries);
+  if (!index) {
+    index = createAliasIndex(entries, { transliteration });
+    cache.set(entries, index);
+  }
+  return index;
+}
+
+export function getAliasOwnersIndex(entries, { transliteration = true } = {}) {
+  if (!entries || (typeof entries !== 'object' && typeof entries !== 'function')) {
+    return createAliasOwnersIndex(entries, { transliteration });
+  }
+  const cache = transliteration ? DEFAULT_OWNERS_INDEX_CACHE : DIRECT_OWNERS_INDEX_CACHE;
+  let index = cache.get(entries);
+  if (!index) {
+    index = createAliasOwnersIndex(entries, { transliteration });
+    cache.set(entries, index);
+  }
+  return index;
+}
+
+export function findCanonical(value, entries, { partial = false, transliteration = true } = {}) {
+  if (!value) return null;
+  const index = getAliasIndex(entries, { transliteration });
+  for (const key of normalizedAliasKeys(value, { transliteration })) {
+    const exact = index.get(key);
+    if (exact) return exact;
+  }
+  if (!partial) return null;
+
+  const textKeys = normalizedAliasKeys(value, { transliteration });
+  let best = null;
+  let bestLength = 0;
+  for (const [alias, entry] of index) {
+    if (alias.length <= bestLength) continue;
+    if (textKeys.some((text) => ` ${text} `.includes(` ${alias} `))) {
+      best = entry;
+      bestLength = alias.length;
+    }
+  }
+  return best;
+}
+
+export function escapeRegex(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function aliasPattern(value) {
+  return escapeRegex(normalizeUnicode(value).trim())
+    .replace(/[\s\-–—'’‘`ʻʼ]+/g, "[\\s\\-–—'’‘`ʻʼ]*");
+}
+
+function matcherFor(entries, { transliteration = true } = {}) {
+  const cache = transliteration ? DEFAULT_MATCHER_CACHE : DIRECT_MATCHER_CACHE;
+  if (entries && typeof entries === 'object' && cache.has(entries)) return cache.get(entries);
+
+  const owners = createAliasOwnersIndex(entries, { transliteration });
+  const searchAliases = [...new Set(
+    [...owners.values()].flatMap((values) => values.map((owner) => owner.searchAlias)),
+  )]
+    .filter(Boolean)
+    .sort((a, b) => b.length - a.length);
+
+  const result = searchAliases.length
+    ? Object.freeze({
+        owners,
+        re: new RegExp(`(?<![\\p{L}\\p{N}_])(?:${searchAliases.map(aliasPattern).join('|')})(?![\\p{L}\\p{N}_])`, 'giu'),
+      })
+    : Object.freeze({ owners, re: null });
+
+  if (entries && typeof entries === 'object') cache.set(entries, result);
+  return result;
+}
+
+/**
+ * Return every canonical match with original-text offsets. Colliding aliases are
+ * deliberately returned as multiple matches instead of silently choosing one.
+ */
+export function findAllCanonical(value, entries, { transliteration = true } = {}) {
+  const text = normalizeUnicode(value ?? '');
+  if (!text || !entries?.length) return [];
+  const { owners, re } = matcherFor(entries, { transliteration });
+  if (!re) return [];
+
+  re.lastIndex = 0;
+  const matches = [];
+  const seen = new Set();
+  for (const match of text.matchAll(re)) {
+    const alias = match[0];
+    const start = match.index ?? 0;
+    const end = start + alias.length;
+    const keys = normalizedAliasKeys(alias, { transliteration });
+    const candidates = [];
+    for (const key of keys) {
+      for (const owner of owners.get(key) || []) candidates.push(owner);
+    }
+    for (const owner of candidates) {
+      const canonical = owner.entry?.canonical || owner.entry?.name || null;
+      const id = `${start}:${end}:${canonical}:${owner.sourceAlias}`;
+      if (seen.has(id)) continue;
+      seen.add(id);
+      matches.push(Object.freeze({
+        entry: owner.entry,
+        canonical,
+        alias,
+        sourceAlias: owner.sourceAlias,
+        normalizedAlias: normalizeForMatch(alias),
+        start,
+        end,
+      }));
+    }
+  }
+  return matches.sort((a, b) => a.start - b.start || (b.end - b.start) - (a.end - a.start));
+}
+
+/** Collect aliases mapping to more than one canonical entity. */
+export function collectAliasCollisions(entries, { includeSearchFolds = false, allowed = [] } = {}) {
+  const allowedSet = new Set(allowed.map(normalizeForMatch));
+  const owners = new Map();
+  for (const entry of entries || []) {
+    const canonical = entry?.canonical || entry?.name;
+    if (!canonical) continue;
+    for (const value of [canonical, ...aliasesOf(entry)].filter(Boolean)) {
+      const keys = normalizedAliasKeys(value, { transliteration: includeSearchFolds });
+      for (const key of keys) {
+        if (!key || allowedSet.has(key)) continue;
+        const set = owners.get(key) || new Set();
+        set.add(canonical);
+        owners.set(key, set);
+      }
+    }
+  }
+  return [...owners.entries()]
+    .filter(([, canonicals]) => canonicals.size > 1)
+    .map(([alias, canonicals]) => Object.freeze({ alias, canonicals: Object.freeze([...canonicals]) }));
+}
+
+export function validateAliasCollisions(entries, options = {}) {
+  const collisions = collectAliasCollisions(entries, options);
+  if (collisions.length) {
+    const preview = collisions.slice(0, 8).map((item) => `${item.alias} -> ${item.canonicals.join(', ')}`).join('; ');
+    throw new Error(`Lexicon alias collisions detected (${collisions.length}): ${preview}`);
+  }
+  return true;
+}
+
+/**
+ * Validate structural lexicon invariants without changing source data.
+ * Intentional cross-entity collisions can be allow-listed by normalized alias.
+ */
+export function validateLexicon(entries, {
+  allowedCollisions = [],
+  allowedLanguageKeys = LEXICON_LANGUAGES,
+  allowDuplicateCanonicals = false,
+} = {}) {
+  const errors = [];
+  const canonicalOwners = new Map();
+  const aliasOwners = new Map();
+  const allowedCollisionSet = new Set(allowedCollisions.map(normalizeForMatch));
+  const languageSet = new Set(allowedLanguageKeys);
+
+  for (const [entryIndex, entry] of (entries || []).entries()) {
+    const canonical = entry?.canonical || entry?.name;
+    if (!canonical || !String(canonical).trim()) {
+      errors.push(Object.freeze({ kind: 'missingCanonical', entryIndex }));
+      continue;
+    }
+
+    const canonicalKey = normalizeForMatch(canonical);
+    const canonicalAliasOwners = aliasOwners.get(canonicalKey) || new Set();
+    canonicalAliasOwners.add(canonical);
+    aliasOwners.set(canonicalKey, canonicalAliasOwners);
+    if (!allowDuplicateCanonicals && canonicalOwners.has(canonicalKey)) {
+      errors.push(Object.freeze({ kind: 'duplicateCanonical', canonical, firstIndex: canonicalOwners.get(canonicalKey), entryIndex }));
+    } else if (!canonicalOwners.has(canonicalKey)) {
+      canonicalOwners.set(canonicalKey, entryIndex);
+    }
+
+    const aliasMap = entry?.aliases;
+    if (aliasMap && !Array.isArray(aliasMap) && typeof aliasMap === 'object') {
+      for (const key of Object.keys(aliasMap)) {
+        if (!languageSet.has(key)) errors.push(Object.freeze({ kind: 'unknownLanguageKey', canonical, key, entryIndex }));
+      }
+    }
+
+    const aliasMapEntries = aliasMap && !Array.isArray(aliasMap) && typeof aliasMap === 'object'
+      ? Object.entries(aliasMap).flatMap(([language, values]) => (Array.isArray(values) ? values : []).map((alias, aliasIndex) => ({ alias, aliasIndex, language })))
+      : (Array.isArray(aliasMap) ? aliasMap : []).map((alias, aliasIndex) => ({ alias, aliasIndex, language: null }));
+    const localExactAliases = new Map();
+    for (const { alias, aliasIndex, language } of aliasMapEntries) {
+      if (typeof alias !== 'string' || !alias.trim()) {
+        errors.push(Object.freeze({ kind: 'emptyAlias', canonical, aliasIndex, entryIndex, language }));
+        continue;
+      }
+      const normalized = normalizeForMatch(alias) || normalizeUnicode(alias).toLocaleLowerCase().trim();
+      if (!normalized) {
+        errors.push(Object.freeze({ kind: 'emptyNormalizedAlias', canonical, alias, aliasIndex, entryIndex, language }));
+        continue;
+      }
+      // Search normalization intentionally collapses spelling variants such as
+      // ё/е, apostrophe glyphs and hyphen/space forms. Those are useful aliases,
+      // not structural duplicates. A duplicate is the same source spelling
+      // modulo Unicode normalization, case and whitespace only.
+      const rawIdentity = String(alias).normalize('NFKC').toLocaleLowerCase().replace(/\s+/g, ' ').trim();
+      const duplicateKey = `${language || '*'}:${rawIdentity}`;
+      if (localExactAliases.has(duplicateKey)) {
+        errors.push(Object.freeze({ kind: 'duplicateAlias', canonical, alias, normalizedAlias: normalized, firstAliasIndex: localExactAliases.get(duplicateKey), aliasIndex, entryIndex, language }));
+      } else {
+        localExactAliases.set(duplicateKey, aliasIndex);
+      }
+
+      const owners = aliasOwners.get(normalized) || new Set();
+      owners.add(canonical);
+      aliasOwners.set(normalized, owners);
+    }
+  }
+
+  for (const [alias, canonicals] of aliasOwners) {
+    if (canonicals.size > 1 && !allowedCollisionSet.has(alias)) {
+      errors.push(Object.freeze({ kind: 'crossCanonicalCollision', alias, canonicals: Object.freeze([...canonicals]) }));
+    }
+  }
+
+  return Object.freeze({ ok: errors.length === 0, errors: Object.freeze(errors) });
+}
+
+export function assertValidLexicon(entries, options = {}) {
+  const report = validateLexicon(entries, options);
+  if (!report.ok) {
+    const preview = report.errors.slice(0, 10).map((item) => JSON.stringify(item)).join('; ');
+    throw new Error(`Lexicon invariant validation failed (${report.errors.length}): ${preview}`);
+  }
+  return true;
+}
+
+export function aliasesToRegex(values, flags = 'iu') {
+  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);
+}