@whiteslove/parsing-lexicon 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MARHARYTA KUBAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,137 @@
+# @whiteslove/parsing-lexicon
+
+Deterministic multilingual parsing primitives shared by Whiteslove housing and hiring services.
+
+The package is the canonical home for lexical data, normalization and reusable deterministic extraction. It is intentionally network-free and does **not** contain UI copy, persistence rules, source orchestration or consumer-specific business logic.
+
+## What it covers
+
+### Geography
+
+- Countries and multilingual aliases for the markets used by Whiteslove services.
+- Canonical city, region, district, microdistrict, locality and metro matching.
+- Uzbekistan and Kazakhstan location extensions.
+- Ukraine city/region catalog with current and historical names, major/regional city detail and metro/location extensions.
+- Tashkent districts, metro, colloquial areas, residential complexes and POIs.
+- Odesa metropolitan entities with separate administrative, suburb/locality, informal-area, development-area, POI and search-cluster semantics.
+- Normalization for apostrophe/dash variants and Cyrillic search folding across RU/UZ/KZ/UA input.
+
+### Housing
+
+- Deal/action and listing-kind taxonomy.
+- Property/building type, condition, layout, furniture and listing-status context.
+- Rooms, bedrooms, floors, total floors, building year and area extraction.
+- Deposit, prepayment, utilities and commission/payment context.
+- Seller/agency/owner confidence and no-commission semantics.
+- Tenant policies, documents, financing, availability and location relations.
+- Infrastructure/proximity extraction such as walking time to metro.
+
+### Hiring
+
+- Candidate vs vacancy intent and non-content/spam classification.
+- Section-aware vacancy/CV parsing.
+- Profession taxonomy and profession context without duplicating consumer technology-skill catalogs.
+- Salary range, currency and pay-period extraction.
+- Experience requirements and seniority.
+- Work mode, employment types, schedules and probation.
+- Languages, CEFR levels and requirement relation (`required`, `preferred`, `notRequired`, `candidateHas`).
+- Work authorization, visa sponsorship, relocation, contracts, benefits and hiring status context.
+
+## Architecture
+
+Consumers should resolve data in this order:
+
+```text
+structured source fields
+  -> shared canonical lexicon
+  -> deterministic parser
+  -> AI fallback / enrichment
+```
+
+Lexical aliases belong here. Consumers keep source adapters, persistence, ranking/filtering semantics and UI/API contracts.
+
+The package must remain dependency-light and must never require a runtime lexicon HTTP service, Redis or a message broker.
+
+## Usage
+
+```js
+import {
+  canonicalCity,
+  canonicalTashkentMetro,
+  normalizeForMatch,
+  parseHousingStructured,
+  parseHiringContext,
+  parseHiringSalary,
+} from '@whiteslove/parsing-lexicon';
+
+canonicalCity('Қарағанды', 'KZ');
+// Karaganda
+
+canonicalTashkentMetro('метро Максим Горький');
+// Buyuk Ipak Yoli
+
+normalizeForMatch('Oʻzbekiston');
+// o zbekiston
+
+parseHousingStructured('3 xona, 5/9, 78 m², depozit 500$, metroga 5 minut piyoda');
+
+parseHiringSalary('Salary: $3,000–4,500 per month');
+
+parseHiringContext(
+  'Senior Frontend Engineer. English B2 required. Remote. Visa sponsorship available.',
+  { mode: 'vacancy', title: 'Senior Frontend Engineer' },
+);
+```
+
+Subpath exports are available for consumers that need narrower modules, including `./geo`, `./locations`, `./housing-context`, `./housing-structured`, `./hiring-context`, `./hiring-professions` and `./money`.
+
+## Data-quality rules
+
+- Add aliases to the existing canonical entity instead of creating source-specific regex tables.
+- Keep administrative entities distinct from colloquial/search concepts.
+- Preserve ambiguity guards where a bare term can mean several things.
+- Structured source fields take precedence over inferred values.
+- Add a regression for every production parsing bug.
+- Canonical dictionaries are immutable at runtime.
+- Duplicate canonical/alias entries and unsupported language-key drift are covered by invariants.
+
+## Lexicon statistics
+
+Snapshot for `c509d92` (2026-08-25). The audit traverses exported lexicon data from `src/`, excludes functions, regular expressions and obvious service/path strings, then normalizes strings with Unicode NFKC, trim, whitespace collapse and lowercase.
+
+| Metric | Count |
+| --- | ---: |
+| Alias/translation-like string occurrences across exports | 153,617 |
+| Unique alias/translation strings, exact | 17,681 |
+| **Unique alias/translation strings, normalized** | **17,397** |
+| All exported lexicon strings, normalized | 17,406 |
+| Normalization merge groups | 282 |
+
+The occurrence count is intentionally much larger than the unique count because aggregate modules re-export the same canonical datasets. For package size and vocabulary breadth, the normalized unique count is the useful number.
+
+### Vocabulary by domain
+
+| Domain | Occurrences across exports | Unique exact | Unique normalized |
+| --- | ---: | ---: | ---: |
+| Geography / locations | 64,898 | 10,149 | **9,967** |
+| Hiring — professions & skills | 6,738 | 2,350 | **2,324** |
+| Hiring — other semantics | 3,592 | 2,589 | **2,558** |
+| Housing | 2,554 | 1,975 | **1,971** |
+| Hiring — languages | 552 | 495 | **478** |
+| Country / source aliases | 170 | 126 | **126** |
+
+Domain rows are not additive: the same canonical string can be reachable through multiple exported structures and categories.
+
+Language totals are not inferred from script alone because many valid aliases are intentionally shared or untagged (for example names that are identical in RU/UK or EN/UZ Latin). A language-by-language table should therefore be generated only from explicitly language-tagged data rather than guessed from Unicode characters.
+
+## Development
+
+Requires Node.js 20+.
+
+```bash
+npm install
+npm test
+npm pack
+```
+
+`npm pack` produces the distributable `@whiteslove/parsing-lexicon` tarball from the files declared in `package.json`.

package/index.d.ts

@@ -0,0 +1,375 @@
+export type LexiconLanguage = 'all' | 'ru' | 'en' | 'uk' | 'ro' | 'uzLatn' | 'uzCyrl' | 'kaaLat' | 'kaaCyrl' | 'kk';
+export type CountryCode = 'UZ' | 'KZ' | 'UA' | 'RO' | 'KG' | 'GE' | 'AZ' | 'AM' | 'MD' | 'TJ' | 'TM' | 'PL' | 'DE' | 'GB' | 'US' | 'CA' | 'CN' | 'JP' | 'KR' | 'TW';
+export type AliasMap = Readonly<Partial<Record<LexiconLanguage, readonly string[]>>>;
+export type LexiconEntity = Readonly<{
+  canonical: string;
+  aliases: AliasMap;
+  country?: CountryCode;
+  city?: string;
+  code?: string;
+  currency?: string;
+  region?: string;
+  type?: string;
+  status?: string;
+  priority?: string;
+  localCanonical?: string;
+  contextRequired?: boolean;
+  multiplier?: number;
+}>;
+export type MetroStation = Readonly<{
+  canonical: string;
+  name: string;
+  type: 'metro';
+  country: 'UZ';
+  city: 'Tashkent';
+  line: string;
+  labels: Readonly<{ ru: string; en: string }>;
+  aliases: readonly string[];
+  re: RegExp;
+}>;
+export type LocationEntry = Readonly<{
+  canonical: string;
+  name: string;
+  type?: string;
+  aliases: readonly string[];
+  re: RegExp;
+  entityType?: string;
+  country?: CountryCode;
+  city?: string;
+  district?: string;
+  parent?: string;
+  confidence?: string;
+  language?: string;
+}>;
+export type ResidentialComplexEntry = Readonly<{
+  canonical: string;
+  name: string;
+  aliases: readonly string[];
+  ambiguous: boolean;
+  re: RegExp;
+}>;
+export type PoiEntry = Readonly<{
+  canonical: string;
+  name: string;
+  category: string;
+  aliases: readonly string[];
+  re: RegExp;
+  contextRequired: boolean;
+  contextRe: RegExp | null;
+}>;
+export type MetropolitanEntity = Readonly<{
+  canonical: string;
+  name: string;
+  type: string;
+  aliases: readonly string[];
+  re: RegExp;
+  parent: string | null;
+  cluster: string | null;
+  contextRequired: boolean;
+  contextRe: RegExp | null;
+}>;
+export type SearchCluster = Readonly<{
+  canonical?: string;
+  name: string;
+  type: 'search_cluster';
+  administrative: false;
+  country?: CountryCode;
+  city?: string;
+  members: readonly string[];
+}>;
+export type AreaEntry = Readonly<{
+  canonical: string;
+  name: string;
+  type: 'local_area';
+  country: 'UZ';
+  city: 'Tashkent';
+  aliases: readonly string[];
+}>;
+export type LocationCityDictionary = Readonly<{
+  districts?: readonly LocationEntry[];
+  microdistricts?: readonly LocationEntry[];
+  mahallas?: readonly LocationEntry[];
+  localAreas?: readonly LocationEntry[];
+  suburbs?: readonly LocationEntry[];
+  settlements?: readonly LocationEntry[];
+  metro?: readonly LocationEntry[] | readonly MetroStation[];
+  residentialComplexes?: readonly LocationEntry[];
+  streets?: readonly LocationEntry[];
+  landmarks?: readonly LocationEntry[];
+  pois?: readonly LocationEntry[];
+  searchClusters?: readonly LocationEntry[];
+}>;
+export type CentralAsiaLocationMatch = Readonly<{
+  country: 'KZ' | 'UZ' | null;
+  city: string;
+  type: string;
+  key: string;
+  name: string;
+  aliases: readonly string[];
+  district: string | null;
+  parent: string | null;
+  confidence: string | null;
+  language: string | null;
+}>;
+export type CentralAsiaLocationResult = Readonly<{
+  city: string | null;
+  matches: readonly CentralAsiaLocationMatch[];
+  searchClusters: readonly SearchCluster[];
+  candidates: readonly Readonly<{ city: string; matches: readonly CentralAsiaLocationMatch[] }>[];
+}>;
+
+export type ProfessionEntry = Readonly<{
+  id: string;
+  canonical: string;
+  group: string;
+  family: string;
+  aliases: readonly string[];
+  strongAliases: readonly string[];
+  weakAliases: readonly string[];
+  strongRe: RegExp;
+  weakRe: RegExp | null;
+}>;
+export type ProfessionMatch = Readonly<{
+  id: string;
+  canonical: string;
+  group: string;
+  family: string;
+  score: number;
+  strength: 'strong' | 'weak';
+  matched: string;
+}>;
+export type SalaryParseResult = Readonly<{
+  min: number | null;
+  max: number | null;
+  currency: string | null;
+  period: 'hour' | 'day' | 'shift' | 'week' | 'month' | 'year' | 'project' | 'piece' | null;
+  gross: boolean | null;
+  negotiable: boolean;
+  approximate: boolean;
+}>;
+export type ExperienceParseResult = Readonly<{
+  requirement: 'none' | 'preferred' | 'required';
+  minYears: number | null;
+  maxYears: number | null;
+}>;
+export type CanonicalMatch<T> = Readonly<{
+  entry: T;
+  canonical: string | null;
+  alias: string;
+  sourceAlias: string;
+  normalizedAlias: string;
+  start: number;
+  end: number;
+}>;
+export type LexiconValidationError = Readonly<{
+  kind: string;
+  [key: string]: unknown;
+}>;
+export type LexiconValidationReport = Readonly<{
+  ok: boolean;
+  errors: readonly LexiconValidationError[];
+}>;
+
+export const LEXICON_LANGUAGES: readonly LexiconLanguage[];
+export const COUNTRY_CODES: readonly CountryCode[];
+export function deepFreeze<T>(value: T): Readonly<T>;
+export function freezeAliases(aliases?: AliasMap | readonly string[]): AliasMap | readonly string[];
+export function lexiconEntity(canonical: string, aliases?: AliasMap, extra?: Record<string, unknown>): LexiconEntity;
+export function locationEntity(canonical: string, aliases?: readonly string[], extra?: Record<string, unknown>): LocationEntry;
+
+export function normalizeUnicode(value: unknown): string;
+export function normalizeForMatch(value: unknown): string;
+export function foldCyrillicForSearch(value: unknown): string;
+export function normalizedAliasKeys(value: unknown, options?: { transliteration?: boolean }): string[];
+export function aliasesOf(entry: { aliases?: AliasMap | readonly string[] }): string[];
+export function buildAliasIndex<T>(entries: readonly T[], options?: { transliteration?: boolean }): Map<string, T>;
+export function getAliasIndex<T>(entries: readonly T[], options?: { transliteration?: boolean }): Map<string, T>;
+export function getAliasOwnersIndex<T>(entries: readonly T[], options?: { transliteration?: boolean }): Map<string, ReadonlyArray<Readonly<{ entry: T; sourceAlias: string; searchAlias: string }>>>;
+export function findCanonical<T extends { canonical?: string; name?: string; aliases?: AliasMap | readonly string[] }>(value: unknown, entries: readonly T[], options?: { partial?: boolean; transliteration?: boolean }): T | null;
+export function findAllCanonical<T extends { canonical?: string; name?: string; aliases?: AliasMap | readonly string[] }>(value: unknown, entries: readonly T[], options?: { transliteration?: boolean }): CanonicalMatch<T>[];
+export function collectAliasCollisions(entries: readonly unknown[], options?: { includeSearchFolds?: boolean; allowed?: readonly string[] }): ReadonlyArray<Readonly<{ alias: string; canonicals: readonly string[] }>>;
+export function validateAliasCollisions(entries: readonly unknown[], options?: { includeSearchFolds?: boolean; allowed?: readonly string[] }): true;
+export function validateLexicon(entries: readonly unknown[], options?: { allowedCollisions?: readonly string[]; allowedLanguageKeys?: readonly LexiconLanguage[]; allowDuplicateCanonicals?: boolean }): LexiconValidationReport;
+export function assertValidLexicon(entries: readonly unknown[], options?: { allowedCollisions?: readonly string[]; allowedLanguageKeys?: readonly LexiconLanguage[]; allowDuplicateCanonicals?: boolean }): true;
+export function escapeRegex(value: unknown): string;
+export function aliasesToRegex(values: readonly string[], flags?: string): RegExp;
+
+export const COUNTRIES: readonly LexiconEntity[];
+export function canonicalCountry(value: unknown): string | null;
+export function canonicalCountryCode(value: unknown): CountryCode | null;
+export function countryByCode(value: unknown): LexiconEntity | null;
+
+export const UZ_CITIES: readonly LexiconEntity[];
+export const KZ_CITIES: readonly LexiconEntity[];
+export const UA_CITIES: readonly LexiconEntity[];
+export const RO_CITIES: readonly LexiconEntity[];
+export const KG_CITIES: readonly LexiconEntity[];
+export const GLOBAL_CITIES: readonly LexiconEntity[];
+/** Canonical cross-country city catalog. */
+export const CITIES: readonly LexiconEntity[];
+export const CITIES_BY_COUNTRY: Readonly<Partial<Record<CountryCode, readonly LexiconEntity[]>>>;
+export function canonicalCity(value: unknown, country?: CountryCode | string | null): string | null;
+/** @deprecated Use CITIES. */
+export const GEOGRAPHY_CITIES: readonly LexiconEntity[];
+/** @deprecated Use CITIES_BY_COUNTRY. */
+export const GEOGRAPHY_CITIES_BY_COUNTRY: Readonly<Partial<Record<CountryCode, readonly LexiconEntity[]>>>;
+/** @deprecated Use canonicalCity. */
+export function canonicalAnyCity(value: unknown, country?: CountryCode | string | null): string | null;
+export const UA_ADDITIONAL_CITIES: readonly LexiconEntity[];
+export const UA_CITY_CATALOG: readonly LexiconEntity[];
+export const UA_CITY_HISTORICAL_ALIASES: Readonly<Record<string, readonly string[]>>;
+export function canonicalUkraineCity(value: unknown): string | null;
+export const UA_LOCATION_TERMS: Readonly<Record<string, readonly string[]>>;
+
+export const KZ_CITY_ADDITIONS: readonly LexiconEntity[];
+export const KZ_CITY_CATALOG: readonly LexiconEntity[];
+export const KZ_SEARCH_TARGETS: readonly LexiconEntity[];
+export const UZ_CITY_ADDITIONS: readonly LexiconEntity[];
+export const UZ_CITY_CATALOG: readonly LexiconEntity[];
+export const UZ_SEARCH_TARGETS: readonly LexiconEntity[];
+export const KZ_LOCATION_TERMS: Readonly<Record<string, readonly string[]>>;
+export const UZ_LOCATION_TERMS: Readonly<Record<string, readonly string[]>>;
+export function canonicalKazakhstanCity(value: unknown): string | null;
+export function canonicalUzbekistanCity(value: unknown): string | null;
+export function canonicalCentralAsiaCity(value: unknown, country?: 'KZ' | 'UZ' | null): string | null;
+export function centralAsiaCityAliases(canonical: string, country?: 'KZ' | 'UZ' | null): readonly string[];
+
+export const TASHKENT_DISTRICTS: readonly LexiconEntity[];
+export function canonicalTashkentDistrict(value: unknown): string | null;
+export const TASHKENT_METRO: readonly MetroStation[];
+export function tashkentMetroStation(value: unknown): MetroStation | null;
+export function canonicalTashkentMetro(value: unknown): string | null;
+export function tashkentMetroLabels(): Record<string, { ru: string; en: string; line: string }>;
+export const TASHKENT_AREAS: Readonly<Record<string, readonly AreaEntry[]>>;
+export const TASHKENT_AREA_ADDITIONS: Readonly<Record<string, readonly AreaEntry[]>>;
+export const FULL_TASHKENT_AREAS: Readonly<Record<string, readonly AreaEntry[]>>;
+export const TASHKENT_RESIDENTIAL_COMPLEXES: readonly ResidentialComplexEntry[];
+export function matchTashkentResidentialComplex(value: unknown): ResidentialComplexEntry | null;
+export function canonicalTashkentResidentialComplex(value: unknown): string | null;
+export const TASHKENT_PARKS: readonly PoiEntry[];
+export const TASHKENT_SQUARES: readonly PoiEntry[];
+export const TASHKENT_MARKETS: readonly PoiEntry[];
+export const TASHKENT_MALLS: readonly PoiEntry[];
+export const TASHKENT_ATTRACTIONS: readonly PoiEntry[];
+export const TASHKENT_CULTURAL_POIS: readonly PoiEntry[];
+export const TASHKENT_TRANSPORT_POIS: readonly PoiEntry[];
+export const TASHKENT_UNIVERSITIES: readonly PoiEntry[];
+export const TASHKENT_MEDICAL_POIS: readonly PoiEntry[];
+export const TASHKENT_LEGACY_LANDMARKS: readonly PoiEntry[];
+export const TASHKENT_POI_GROUPS: Readonly<Record<string, readonly PoiEntry[]>>;
+export const TASHKENT_LANDMARKS: readonly PoiEntry[];
+export function matchTashkentPoi(value: unknown, category?: string | null): PoiEntry | null;
+
+export const ODESA_LOCAL_AREAS: readonly MetropolitanEntity[];
+export const ODESA_MICRODISTRICT_EXTENSIONS: readonly MetropolitanEntity[];
+export const ODESA_SUBURBS: readonly MetropolitanEntity[];
+export const ODESA_DEVELOPMENT_AREAS: readonly MetropolitanEntity[];
+export const ODESA_RIVIERA_ENTITIES: readonly MetropolitanEntity[];
+export const ODESA_CONTEXT_POIS: readonly MetropolitanEntity[];
+export const ODESA_METROPOLITAN_ENTITIES: readonly MetropolitanEntity[];
+export const ODESA_SEARCH_CLUSTERS: readonly SearchCluster[];
+export function matchOdesaMetropolitanEntities(value: unknown): Readonly<{ matches: readonly MetropolitanEntity[]; searchClusters: readonly SearchCluster[] }>;
+export function matchOdesaMetropolitanEntity(value: unknown, type?: string | null): MetropolitanEntity | null;
+
+export const UZ_REGIONS: readonly LexiconEntity[];
+export const KZ_REGIONS: readonly LexiconEntity[];
+export const UA_REGIONS: readonly LexiconEntity[];
+export const RO_REGIONS: readonly LexiconEntity[];
+export const REGIONS: readonly LexiconEntity[];
+export const REGIONS_BY_COUNTRY: Readonly<Partial<Record<CountryCode, readonly LexiconEntity[]>>>;
+export function canonicalRegion(value: unknown, country?: CountryCode | string | null): string | null;
+
+export const LOCATION_LIST_KEYS: readonly string[];
+export function locationEntry(name: string, ...aliases: string[]): LocationEntry;
+export function locationEntries(rows?: readonly (readonly string[])[]): readonly LocationEntry[];
+export function mergeLocationEntries(...lists: readonly LocationEntry[][]): readonly LocationEntry[];
+export function mergeLocationCityDictionaries(...dictionaries: readonly LocationCityDictionary[]): LocationCityDictionary;
+export function mergeLocationCountries(...countries: readonly Readonly<Record<string, LocationCityDictionary>>[]): Readonly<Record<string, LocationCityDictionary>>;
+
+export const LOCATION_DICTIONARIES: Readonly<Record<string, Readonly<Record<string, LocationCityDictionary>>>>;
+export const UA_EXTRA_LOCATION_DICTIONARIES: Readonly<Record<string, LocationCityDictionary>>;
+export const UA_REGION_ENTRIES: readonly LocationEntry[];
+export const UA_SECONDARY_CITIES: Readonly<Record<string, { aliases: readonly string[]; re: RegExp; microdistricts?: readonly LocationEntry[] }>>;
+export function matchUkraineRegion(text: unknown): LocationEntry | null;
+export function matchUkraineSecondaryCity(text: unknown): ({ city: string; aliases: readonly string[]; re: RegExp; microdistricts?: readonly LocationEntry[] }) | null;
+export function dictionaryFor(countryCode: CountryCode, city: string): LocationCityDictionary | null;
+export function locationCities(countryCode: CountryCode): Readonly<Record<string, LocationCityDictionary>>;
+export function matchDictionaryLocation(text: unknown, countryCode: CountryCode, city?: string | null): { city: string; type: string; name: string; aliases: readonly string[] } | null;
+
+export const KZ_LOCATION_EXTENSIONS: Readonly<Record<string, LocationCityDictionary>>;
+export const KZ_SEARCH_CLUSTERS: readonly SearchCluster[];
+export const KZ_AMBIGUOUS_LOCAL_NAMES: readonly string[];
+export const UZ_LOCATION_EXTENSIONS: Readonly<Record<string, LocationCityDictionary>>;
+export const UZ_AMBIGUOUS_LOCAL_NAMES: readonly string[];
+export const UZ_KARAKALPAK_LANGUAGE_TAGS: readonly string[];
+export const KZ_EXPANDED_LOCATION_DICTIONARIES: Readonly<Record<string, LocationCityDictionary>>;
+export const UZ_EXPANDED_LOCATION_DICTIONARIES: Readonly<Record<string, LocationCityDictionary>>;
+export const CENTRAL_ASIA_LOCATION_DICTIONARIES: Readonly<Record<'KZ' | 'UZ', Readonly<Record<string, LocationCityDictionary>>>>;
+export function centralAsiaLocationCities(countryCode: 'KZ' | 'UZ'): Readonly<Record<string, LocationCityDictionary>>;
+export function centralAsiaLocationCity(countryCode: 'KZ' | 'UZ', city: string): LocationCityDictionary | null;
+export function matchCentralAsiaLocationEntities(text: unknown, countryCode: 'KZ' | 'UZ', preferredCity?: string | null): CentralAsiaLocationResult;
+export function matchCentralAsiaLocationEntity(text: unknown, countryCode: 'KZ' | 'UZ', preferredCity?: string | null, type?: string | null): CentralAsiaLocationMatch | null;
+
+export const GENERIC_LANDMARK_TERMS: readonly LexiconEntity[];
+
+export const ADDRESS_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const DEAL_TYPES: readonly LexiconEntity[];
+export const HOUSING_OCCUPANCY_TYPES: readonly LexiconEntity[];
+export const PROPERTY_TYPES: readonly LexiconEntity[];
+export const ROOM_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const FLOOR_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const AREA_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const CURRENCIES: readonly LexiconEntity[];
+export const SELLER_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const DEPOSIT_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const UTILITY_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const APPLIANCE_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const AMENITY_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const TENANT_TERMS: Readonly<Record<string, LexiconEntity>>;
+export function flattenAliases(item: { aliases?: AliasMap }): string[];
+
+export const HIRING_INTENT: Readonly<Record<string, LexiconEntity>>;
+export const CANDIDATE_FIELD_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const JOB_FIELD_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const EMPLOYMENT_TYPES: readonly LexiconEntity[];
+export const WORK_MODES: readonly LexiconEntity[];
+export const SCHEDULE_TERMS: readonly LexiconEntity[];
+export const PROBATION_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const EXPERIENCE_REQUIREMENTS: Readonly<Record<string, LexiconEntity>>;
+export const SKILL_FIELD_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const BENEFIT_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const SENIORITY_TERMS: readonly LexiconEntity[];
+export const PROFESSION_TERMS: readonly LexiconEntity[];
+export const PERSON_LINEAGE_TERMS: Readonly<{ female: readonly string[]; male: readonly string[] }>;
+
+export const CURRENCY_TERMS: readonly LexiconEntity[];
+export const SALARY_PERIODS: readonly LexiconEntity[];
+export const SALARY_MODIFIERS: Readonly<Record<string, LexiconEntity>>;
+export const NUMBER_MULTIPLIERS: readonly LexiconEntity[];
+export function parseSalary(value: unknown): SalaryParseResult | null;
+export function salaryCurrency(value: unknown): string | null;
+export function salaryPeriod(value: unknown): SalaryParseResult['period'];
+export function currencyAliases(code: string): readonly string[];
+
+export const PROFESSION_CATALOG: readonly ProfessionEntry[];
+export const PROFESSION_GROUPS: ReadonlyArray<Readonly<{ id: string; canonical: string; family: string; aliases: readonly string[]; professions: readonly string[] }>>;
+export const SENIORITY_LEVELS: ReadonlyArray<Readonly<{ canonical: string; aliases: readonly string[]; score: number; re: RegExp }>>;
+export function matchProfessions(value: unknown, options?: { limit?: number; allowWeak?: boolean }): ProfessionMatch[];
+export function matchProfession(value: unknown, options?: { allowWeak?: boolean }): ProfessionMatch | null;
+export function matchProfessionGroup(value: unknown): Readonly<{ id: string; canonical: string; family: string; aliases: readonly string[]; professions: readonly string[]; score: number; matched: string }> | null;
+export function matchSeniority(value: unknown): Readonly<{ canonical: string; score: number; matched: string; index: number }> | null;
+export function professionByCanonical(canonical: string): ProfessionEntry | null;
+
+export const HIRING_INTENT_EXTENSIONS: Readonly<Record<'candidate' | 'employer', LexiconEntity>>;
+export const HIRING_NEGATIVE_INTENT: readonly LexiconEntity[];
+export const VACANCY_FIELD_TERMS: Readonly<Record<string, LexiconEntity>>;
+export const WORK_SCHEDULE_EXTENSIONS: readonly LexiconEntity[];
+export const EXPERIENCE_MODIFIERS: readonly LexiconEntity[];
+export function detectHiringNegativeIntent(value: unknown): Readonly<{ canonical: string; matched: string }> | null;
+export function classifyHiringIntent(value: unknown): Readonly<{ intent: 'candidate' | 'employer' | 'negative' | null; reason: string | null; matched: string | null; confidence: number }>;
+export function parseExperience(value: unknown): ExperienceParseResult | null;
+
+export * from './src/housing-context.js';
+export * from './src/hiring-context.js';
+export * from './src/housing-intent.js';
+export * from './src/housing-structured.js';

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@whiteslove/parsing-lexicon",
+  "version": "0.2.0",
+  "description": "Shared deterministic multilingual parsing lexicon for Whiteslove housing and hiring services",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AmoneMisa/parsing-lexicon.git"
+  },
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": { "types": "./index.d.ts", "import": "./src/index.js" },
+    "./lexicon-core": "./src/lexicon-core.js",
+    "./normalization": "./src/normalization.js",
+    "./countries": "./src/countries.js",
+    "./country-context": { "types": "./src/country-context.d.ts", "import": "./src/country-context.js" },
+    "./geo": "./src/geo.js",
+    "./geography": "./src/geography.js",
+    "./geography-display": { "types": "./src/geography-display.d.ts", "import": "./src/geography-display.js" },
+    "./geography-detection": { "types": "./src/geography-detection.d.ts", "import": "./src/geography-detection.js" },
+    "./central-asia": "./src/central-asia.js",
+    "./ukraine": "./src/ukraine.js",
+    "./location-merge": "./src/location-merge.js",
+    "./locations": "./src/locations.js",
+    "./kz-location-extensions": "./src/kz-location-extensions.js",
+    "./uz-location-extensions": "./src/uz-location-extensions.js",
+    "./central-asia-locations": "./src/central-asia-locations.js",
+    "./ua-location-extensions-major": "./src/ua-location-extensions-major.js",
+    "./ua-location-extensions-regional": "./src/ua-location-extensions-regional.js",
+    "./ua-location-extensions-metro": "./src/ua-location-extensions-metro.js",
+    "./landmarks": "./src/landmarks.js",
+    "./tashkent-colloquial": "./src/tashkent-colloquial.js",
+    "./tashkent-residential-complexes": "./src/tashkent-residential-complexes.js",
+    "./tashkent-pois": "./src/tashkent-pois.js",
+    "./tashkent-housing-geography": { "types": "./src/tashkent-housing-geography.d.ts", "import": "./src/tashkent-housing-geography.js" },
+    "./odesa-metropolitan": "./src/odesa-metropolitan.js",
+    "./housing": "./src/housing.js",
+    "./housing-intent": { "types": "./src/housing-intent.d.ts", "import": "./src/housing-intent.js" },
+    "./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-source-aliases": { "types": "./src/housing-source-aliases.d.ts", "import": "./src/housing-source-aliases.js" },
+    "./hiring": "./src/hiring.js",
+    "./hiring-languages": "./src/hiring-languages.js",
+    "./hiring-language-extensions": { "types": "./src/hiring-language-extensions.d.ts", "import": "./src/hiring-language-extensions.js" },
+    "./hiring-context": { "types": "./src/hiring-context.d.ts", "import": "./src/hiring-context.js" },
+    "./hiring-source-aliases": { "types": "./src/hiring-source-aliases.d.ts", "import": "./src/hiring-source-aliases.js" },
+    "./hiring-source-semantics": { "types": "./src/hiring-source-semantics.d.ts", "import": "./src/hiring-source-semantics.js" },
+    "./hiring-requirements": { "types": "./src/hiring-requirements.d.ts", "import": "./src/hiring-requirements.js" },
+    "./hiring-semantics": { "types": "./src/hiring-semantics.d.ts", "import": "./src/hiring-semantics.js" },
+    "./hiring-work-semantics": { "types": "./src/hiring-work-semantics.d.ts", "import": "./src/hiring-work-semantics.js" },
+    "./hiring-candidate-fields": { "types": "./src/hiring-candidate-fields.d.ts", "import": "./src/hiring-candidate-fields.js" },
+    "./hiring-temporal": { "types": "./src/hiring-temporal.d.ts", "import": "./src/hiring-temporal.js" },
+    "./hiring-vacancy-fields": { "types": "./src/hiring-vacancy-fields.d.ts", "import": "./src/hiring-vacancy-fields.js" },
+    "./hiring-location-fields": { "types": "./src/hiring-location-fields.d.ts", "import": "./src/hiring-location-fields.js" },
+    "./hiring-salary-context": { "types": "./src/hiring-salary-context.d.ts", "import": "./src/hiring-salary-context.js" },
+    "./money": "./src/money.js",
+    "./currency": { "types": "./src/currency.d.ts", "import": "./src/currency.js" },
+    "./contact": { "types": "./src/contact.d.ts", "import": "./src/contact.js" },
+    "./housing-money": { "types": "./src/housing-money.d.ts", "import": "./src/housing-money.js" },
+    "./hiring-professions": "./src/hiring-professions.js",
+    "./hiring-skills": { "types": "./src/hiring-skills.d.ts", "import": "./src/hiring-skills.js" },
+    "./hiring-advanced": "./src/hiring-advanced.js"
+  },
+  "files": ["src", "index.d.ts", "README.md"],
+  "sideEffects": false,
+  "engines": { "node": ">=20" },
+  "scripts": { "test": "node --test" },
+  "dependencies": {
+    "libphonenumber-js": "^1.11.20"
+  },
+  "keywords": ["parsing", "lexicon", "uzbek", "kazakh", "ukrainian", "romanian", "russian", "housing", "hiring", "salary", "professions", "geography"],
+  "license": "MIT"
+}