@whiteslove/parsing-lexicon 0.6.16 → 0.6.17

package/package.json

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

package/src/housing-money.d.ts

@@ -4,6 +4,19 @@ export type HousingPriceParseResult = Readonly<{
   approximate: boolean;
 }>;
 
-export function parseHousingPrice(value: unknown, fallbackCurrency?: string): HousingPriceParseResult;
-export function parseHousingPricePerSqm(value: unknown, fallbackCurrency?: string): HousingPriceParseResult;
-export const parsePriceFromText: typeof parseHousingPrice;
+export type HousingMoneyParseContext = Readonly<{
+  country?: string;
+  currency?: string;
+  fallbackCurrency?: string;
+  dealType?: 'sale' | 'longRent' | 'shortRent' | string | null;
+}>;
+
+export function parseHousingPrice(
+  value: unknown,
+  context?: string | HousingMoneyParseContext,
+): HousingPriceParseResult;
+export function parseHousingPricePerSqm(
+  value: unknown,
+  context?: string | HousingMoneyParseContext,
+): HousingPriceParseResult;
+export const parsePriceFromText: typeof parseHousingPrice;

package/src/housing-money.js

@@ -9,6 +9,11 @@ import {
 } from './money-core.js';
 import { maskPhoneLikeSpans } from './contact.js';
 import { DEPOSIT_TERMS, SELLER_TERMS } from './housing.js';
+import { COUNTRIES, canonicalCountryCode, countryByCode } from './countries.js';
+import {
+  classifyHousingSingleMSpans,
+  HOUSING_NUMERIC_SPAN_TYPES,
+} from './housing-numeric-spans.js';
 
 const PRICE_KEYWORD = '(?:цена|ціна|нарх(?:и)?|narx(?:i)?|price|стоимост[ьи]|аренд(?:а|ная\\s+плата)?|rent)';
 // moneyCurrencyPattern() includes short codes (cad, ron, aed...) with no
@@ -30,7 +35,12 @@ function escapeRegex(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+// One-letter `m/м` is deliberately excluded from the generic multiplier set.
+// Its meaning is resolved by housing-numeric-spans.js first, so area/distance/
+// microdistrict notation cannot leak into money parsing while explicit price
+// contexts can still use compact million shorthand.
 const SCALE_PATTERN = [...new Set(NUMBER_MULTIPLIERS.flatMap((entry) => aliasesOf(entry)).filter(Boolean))]
+  .filter((alias) => !/^[mм]$/iu.test(String(alias)))
   .sort((a, b) => String(b).length - String(a).length)
   .map(escapeRegex)
   .join('|');
@@ -51,6 +61,32 @@ const PER_SQM_BEFORE_AMOUNT_RE = new RegExp(
   'igu',
 );
 
+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,
+]);
+
+function moneyParsingContext(value = '') {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    const country = canonicalCountryCode(value.country) || '';
+    const currency = String(value.currency || value.fallbackCurrency || countryByCode(country)?.currency || '')
+      .trim()
+      .toUpperCase();
+    const rawDealType = String(value.dealType || '').trim();
+    const dealType = ['sale', 'longRent', 'shortRent'].includes(rawDealType) ? rawDealType : null;
+    return { country, currency, dealType };
+  }
+
+  const currency = String(value || '').trim().toUpperCase();
+  const countryMatches = currency
+    ? COUNTRIES.filter((item) => item.currency === currency)
+    : [];
+  return {
+    country: countryMatches.length === 1 ? countryMatches[0].code : '',
+    currency,
+    dealType: null,
+  };
+}
+
 function parsedMoneyAmount(numberValue, scaleValue) {
   const amount = scaleValue
     ? parseScaledAmount(numberValue, scaleValue)
@@ -99,6 +135,22 @@ function maskRanges(text, ranges) {
   return masked;
 }
 
+function maskPatternMatches(text, patterns) {
+  let masked = text;
+  for (const pattern of patterns) {
+    pattern.lastIndex = 0;
+    masked = masked.replace(pattern, (match) => ' '.repeat(match.length));
+  }
+  return masked;
+}
+
+function maskHousingStructuralSpans(text, context) {
+  const strictMasked = maskPatternMatches(text, COMMON_HOUSING_STRUCTURE_PATTERNS);
+  const nonMoneySpans = classifyHousingSingleMSpans(strictMasked, context)
+    .filter((span) => span.type !== HOUSING_NUMERIC_SPAN_TYPES.MONEY);
+  return maskRanges(strictMasked, nonMoneySpans);
+}
+
 function isPaymentScopedAmount(text, start, end) {
   const left = text
     .slice(Math.max(0, start - 56), start)
@@ -108,16 +160,31 @@ function isPaymentScopedAmount(text, start, end) {
     .slice(end, Math.min(text.length, end + 28))
     .split(/[\r\n.;!?]/u)[0] || '';
 
-  // "deposit 500$" / "commission 100$" are payment details, not the
-  // listing price. For the reverse form ("500$ deposit"), only suppress the
-  // amount when there is no explicit price/rent label immediately to its left;
-  // this preserves text such as "rent 800$, deposit 500$".
+  // Prefix payment labels bind to the amount on their right: "deposit 500$".
   if (findCanonical(left, PAYMENT_AMOUNT_TERMS, { partial: true })) return true;
+
+  // A suffix label binds only when it appears before another numeric token.
+  // This prevents the listing price in "6000грн+комуналка+6000(залог)" from
+  // being suppressed merely because the later deposit keyword is nearby, while
+  // still excluding direct suffix forms such as "500$ deposit".
+  const nextDigit = right.search(/\d/u);
+  const suffixScope = nextDigit === -1 ? right : right.slice(0, nextDigit);
   return !PRICE_KEYWORD_RE.test(left)
-    && Boolean(findCanonical(right, PAYMENT_AMOUNT_TERMS, { partial: true }));
+    && Boolean(findCanonical(suffixScope, PAYMENT_AMOUNT_TERMS, { partial: true }));
+}
+
+function parseContextualSingleLetterMillion(text, context) {
+  for (const span of classifyHousingSingleMSpans(text, context)) {
+    if (span.type !== HOUSING_NUMERIC_SPAN_TYPES.MONEY) continue;
+    if (isPaymentScopedAmount(text, span.start, span.end)) continue;
+    const amount = span.amount * 1_000_000;
+    if (amount >= 1_000_000 && amount <= 5_000_000_000) return Math.round(amount);
+  }
+  return null;
 }
 
-export function parseHousingPricePerSqm(value, fallbackCurrency = '') {
+export function parseHousingPricePerSqm(value, context = '') {
+  const { currency: fallbackCurrency } = moneyParsingContext(context);
   const original = String(value || '');
   if (!original) return Object.freeze({ amount: null, currency: fallbackCurrency || '', approximate: false });
 
@@ -135,18 +202,21 @@ export function parseHousingPricePerSqm(value, fallbackCurrency = '') {
   });
 }
 
-export function parseHousingPrice(value, fallbackCurrency = '') {
+export function parseHousingPrice(value, context = '') {
+  const { country, currency: fallbackCurrency, dealType } = moneyParsingContext(context);
   const original = String(value || '');
   if (!original) return Object.freeze({ amount: null, currency: fallbackCurrency || '', approximate: false });
 
   // Contact spans are removed once, before every money branch. A phone can
   // therefore never win as a labelled, currency-tagged or fallback amount.
   const text = maskPhoneLikeSpans(original);
-  // Unit prices are not listing totals. Mask their exact spans before running
-  // the ordinary total-price parser so "От 13 млн за м2" cannot become a
-  // 13,000,000 UZS apartment price. The dedicated parser above still exposes
-  // the unit price to consumers that need it.
-  const priceText = maskRanges(text, perSquareMeterMatches(text, fallbackCurrency));
+  // Unit prices are not listing totals. Mask their exact spans first. Then the
+  // shared numeric-span classifier masks all N m/Nм spans that resolve to area,
+  // distance, microdistrict or unknown; only positively classified money spans
+  // remain visible to the price parser.
+  const withoutUnitPrices = maskRanges(text, perSquareMeterMatches(text, fallbackCurrency));
+  const numericContext = { country, dealType };
+  const priceText = maskHousingStructuralSpans(withoutUnitPrices, numericContext);
   let currency = moneyCurrencyFromText(priceText, fallbackCurrency || '')
     || moneyCurrencyFromText(text, fallbackCurrency || '')
     || '';
@@ -195,6 +265,17 @@ export function parseHousingPrice(value, fallbackCurrency = '') {
     }
   }
 
+  // Single-letter million shorthand is accepted only when the numeric-span
+  // classifier resolves the span as money. This supports explicit "price 2m"
+  // / "2m USD" everywhere and bare compact "800m" only for Uzbek sale context.
+  if (price == null) {
+    const contextualMillion = parseContextualSingleLetterMillion(priceText, numericContext);
+    if (contextualMillion != null) {
+      price = contextualMillion;
+      currency = moneyCurrencyFromText(priceText, fallbackCurrency || '') || fallbackCurrency || '';
+    }
+  }
+
   const labelled = priceText.match(new RegExp(
     `${PRICE_KEYWORD}\\s*[:\\-–—]?\\s*(${MONEY_NUMBER_PATTERN})(?:\\s*(${SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_]))?`,
     'iu',
@@ -237,22 +318,10 @@ export function parseHousingPrice(value, fallbackCurrency = '') {
   }
 
   if (price == null) {
-    // Multiplier aliases include useful one-letter forms such as `m` and `k`.
-    // Require the alias to end at a token boundary so measurements/words like
-    // `500 m2` and `5 minut` cannot be promoted to 500 million / 5 million.
     const match = priceText.match(new RegExp(`(\\d+(?:[.,]\\d+)?)\\s*(${SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_])`, 'iu'));
     if (match) {
-      // Ukrainian listings abbreviate a microdistrict as “531 м/р”. The
-      // one-letter million scale is otherwise valid, but this trailing
-      // “/р” makes the token an area identifier, never a price.
-      const tail = priceText.slice((match.index ?? 0) + match[0].length);
-      if (/^\s*\/\s*[рr](?=$|[^\p{L}\p{N}_])/iu.test(tail)) {
-        // Fall through to the ordinary bare-number pass, which can still
-        // recover a genuine rent amount later in the listing.
-      } else {
       const amount = parseScaledAmount(match[1], match[2]);
       if (amount != null && amount >= 1000 && amount <= 5_000_000_000) price = Math.round(amount);
-      }
     }
   }
 

package/src/housing-numeric-spans.js

@@ -0,0 +1,93 @@
+import { canonicalCountryCode } from './countries.js';
+import { moneyCurrencyPattern, parseNumericAmount } from './money-core.js';
+
+export const HOUSING_NUMERIC_SPAN_TYPES = Object.freeze({
+  MONEY: 'money',
+  AREA: 'area',
+  DISTANCE: 'distance',
+  MICRODISTRICT: 'microdistrict',
+  UNKNOWN: 'unknown',
+});
+
+const PRICE_LABEL_BEFORE_RE = /(?:цена|ціна|нарх(?:и)?|narx(?:i)?|price|стоимост[ьи]|аренд(?:а|ная\s+плата)?|rent)[^\r\n]{0,16}$/iu;
+const CURRENCY_AFTER_RE = new RegExp(
+  `^\\s*(?:uzbek(?:istan)?\\s+)?(?:${moneyCurrencyPattern()})(?![\\p{L}\\p{N}_])`,
+  'iu',
+);
+const UZ_SALE_SIGNAL_RE = /(?:sotiladi|sotuv(?:da)?|sotaman|прода[её]тся|продам|продаж[аеи]|for\s+sale|sale)/iu;
+const UNICODE_TOKEN_END = String.raw`(?![\p{L}\p{N}_])`;
+
+const MICRODISTRICT_AFTER_RE = /^\s*\/\s*[rр](?=$|[^\p{L}\p{N}_])/iu;
+const AREA_BEFORE_RE = /(?:общ(?:ая)?\.?\s*пл(?:ощад[ьи])?\.?|загальн\p{L}*\s+площ\p{L}*|площа|площадь|umumiy\s+maydon|maydon|area|surface|suprafa(?:ță|ta))[^\r\n,;]{0,12}$/iu;
+const AREA_AFTER_RE = new RegExp(
+  `^[\\s,;:()\\-–—]*(?:общ(?:ая)?\\.?\\s*пл(?:ощад[ьи])?\\.?|загальн\\p{L}*\\s+площ\\p{L}*|площа|площадь|kv\\.?\\s*m|sqm|sq\\.?\\s*m|umumiy\\s+maydon|maydon|area|surface|suprafa(?:ță|ta))${UNICODE_TOKEN_END}`,
+  'iu',
+);
+
+const DISTANCE_OBJECT = String.raw`(?:metro(?:ga|dan|gacha)?|метро|maktab(?:ga|dan|gacha)?|school|школ\p{L}*|bozor(?:ga|dan|gacha)?|market|рынок\p{L}*|bekat(?:ga|dan|gacha)?|stop|station|остановк\p{L}*|park(?:ga|dan|gacha)?|парк\p{L}*|aeroport(?:ga|dan|gacha)?|airport|аэропорт\p{L}*|do['’ʻʼ]?kon(?:ga|dan|gacha)?|магазин\p{L}*)`;
+const DISTANCE_BEFORE_RE = new RegExp(
+  `(?:${DISTANCE_OBJECT}|masofa|distance|(?:до|от|to|from)\\s+${DISTANCE_OBJECT})[^\\r\\n,;]{0,14}$`,
+  'iu',
+);
+const DISTANCE_AFTER_RE = new RegExp(
+  `^[\\s,;:()\\-–—]*(?:(?:gacha|гача|masofa|distance|metr\\p{L}*|метр\\p{L}*)${UNICODE_TOKEN_END}|(?:до|от|to|from)\\s+${DISTANCE_OBJECT}${UNICODE_TOKEN_END}|${DISTANCE_OBJECT}${UNICODE_TOKEN_END}|(?:walk(?:ing)?|piyoda)\\s+(?:to\\s+)?${DISTANCE_OBJECT}${UNICODE_TOKEN_END})`,
+  'iu',
+);
+
+const SINGLE_M_CANDIDATE_RE = /(?<![\p{L}\p{N}_])(\d{1,4}(?:[.,]\d{1,2})?)([ \u00A0]*)([mм])(?![\p{L}\p{N}_])/giu;
+
+function normalizedDealType(value) {
+  const dealType = String(value || '').trim();
+  return ['sale', 'longRent', 'shortRent'].includes(dealType) ? dealType : null;
+}
+
+function classifySingleMSpan(text, match, { country, dealType }) {
+  const start = match.index ?? 0;
+  const end = SINGLE_M_CANDIDATE_RE.lastIndex;
+  const before = text.slice(Math.max(0, start - 64), start);
+  const after = text.slice(end, Math.min(text.length, end + 64));
+
+  if (MICRODISTRICT_AFTER_RE.test(after)) return HOUSING_NUMERIC_SPAN_TYPES.MICRODISTRICT;
+  if (AREA_BEFORE_RE.test(before) || AREA_AFTER_RE.test(after)) return HOUSING_NUMERIC_SPAN_TYPES.AREA;
+  if (DISTANCE_BEFORE_RE.test(before) || DISTANCE_AFTER_RE.test(after)) return HOUSING_NUMERIC_SPAN_TYPES.DISTANCE;
+
+  const explicitPrice = PRICE_LABEL_BEFORE_RE.test(before);
+  const explicitCurrency = CURRENCY_AFTER_RE.test(after);
+  if (explicitPrice || explicitCurrency) return HOUSING_NUMERIC_SPAN_TYPES.MONEY;
+
+  const compact = match[2].length === 0;
+  const localSaleSignal = country === 'UZ' && UZ_SALE_SIGNAL_RE.test(`${before} ${after}`);
+  if (country === 'UZ' && compact && (dealType === 'sale' || localSaleSignal)) {
+    return HOUSING_NUMERIC_SPAN_TYPES.MONEY;
+  }
+
+  return HOUSING_NUMERIC_SPAN_TYPES.UNKNOWN;
+}
+
+export function classifyHousingSingleMSpans(value, options = {}) {
+  const text = String(value || '');
+  if (!text) return Object.freeze([]);
+
+  const country = canonicalCountryCode(options.country) || String(options.country || '').trim().toUpperCase();
+  const dealType = normalizedDealType(options.dealType);
+  const spans = [];
+
+  SINGLE_M_CANDIDATE_RE.lastIndex = 0;
+  let match;
+  while ((match = SINGLE_M_CANDIDATE_RE.exec(text)) !== null) {
+    const amount = parseNumericAmount(match[1]);
+    if (amount == null) continue;
+    const start = match.index ?? 0;
+    const end = SINGLE_M_CANDIDATE_RE.lastIndex;
+    spans.push(Object.freeze({
+      start,
+      end,
+      raw: match[0],
+      amount,
+      compact: match[2].length === 0,
+      type: classifySingleMSpan(text, match, { country, dealType }),
+    }));
+  }
+
+  return Object.freeze(spans);
+}

package/src/housing-structured.d.ts

@@ -65,6 +65,7 @@ export type HousingStructuredOptions = Readonly<{
   country?: string;
   fallbackCurrency?: string;
   phoneCountry?: string;
+  dealType?: 'sale' | 'longRent' | 'shortRent' | string | null;
   source?: string;
   knownStreet?: string | null;
   allowBareAddress?: boolean;
@@ -92,7 +93,10 @@ export type HousingStructuredResult = Readonly<{
 
 export function parseHousingRoomCount(value: unknown): number | null;
 export function parseHousingFloor(value: unknown): Readonly<{ floor: number | null; totalFloors: number | null }>;
-export function parseHousingAreas(value: unknown): HousingAreaDetails;
+export function parseHousingAreas(
+  value: unknown,
+  options?: Pick<HousingStructuredOptions, 'country' | 'dealType'>,
+): HousingAreaDetails;
 export function parseHousingPayments(value: unknown): HousingPaymentContext;
 export function parseHousingSeller(value: unknown): Readonly<{ type: 'owner' | 'agency' | null; confidence: number }>;
 export function parseHousingInfrastructure(value: unknown): readonly HousingInfrastructureMatch[];

package/src/housing-structured.js

@@ -13,6 +13,10 @@ import { parseHousingListingFields } from './housing-listing-fields.js';
 import { parseHousingPrice } from './housing-money.js';
 import { parseHousingAmenities, parseHousingResidentialComplex } from './housing-text.js';
 import { parseHousingSourcePost } from './housing-source-aliases.js';
+import {
+  classifyHousingSingleMSpans,
+  HOUSING_NUMERIC_SPAN_TYPES,
+} 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],
@@ -63,11 +67,6 @@ function parseCompactSpec(text) {
 }
 
 function currencyNear(text) {
-  // findCanonical's partial match requires the alias to be its own
-  // space-delimited token, so a currency symbol glued directly to its
-  // number with no space ("500.$", "350$") never matches. Fall back to
-  // moneyCurrencyFromText, which detects symbols and codes independent of
-  // surrounding whitespace (used by parseHousingPrice for the same reason).
   return findCanonical(text, CURRENCY_TERMS, { partial: true })?.canonical
     || moneyCurrencyFromText(text) || null;
 }
@@ -76,11 +75,6 @@ export function parseHousingRoomCount(value) {
   const text = normalizeUnicode(value ?? '');
   if (!text) return null;
 
-  // Uzbek market shorthand: a unit formally registered as N rooms that was
-  // physically converted into a different count ("1 xonali ... 2 xona
-  // qilingan" — nominally 1-room, made into 2). The converted count is the
-  // one that matters and must win over the nominal count mentioned earlier
-  // in the same text.
   const converted = text.match(/(\d{1,2})\s*(?:ta\s*)?xona(?:ga)?\s+(?:qilingan|aylantirilgan|bo['’ʻʼ‘`]?lingan)(?=$|[^\p{L}\p{N}_])/iu);
   if (converted) {
     const rooms = toNumber(converted[1]);
@@ -99,14 +93,10 @@ export function parseHousingRoomCount(value) {
     if (rooms != null && rooms >= 1 && rooms <= 20) return rooms;
   }
 
-  // Structured "Label - Value" reposts (Telegram channel copies of OLX ads)
-  // put the label before the number: "Комнат - 4" instead of "4 комнаты".
   const reversed = text.match(/(?:комнат\p{L}*|xona(?:lar)?(?:i)?|хона(?:лар)?(?:и|лик|ли)?|rooms?)\s*[-:–—]\s*(\d{1,2})(?=$|[^\p{L}\p{N}])/iu);
   const reversedRooms = toNumber(reversed?.[1]);
   if (reversedRooms != null && reversedRooms >= 1 && reversedRooms <= 20) return reversedRooms;
 
-  // Listings that only carry the compact "1/5/12-50m" shorthand state the room
-  // count in its first number.
   return parseCompactSpec(text)?.rooms ?? null;
 }
 
@@ -114,17 +104,11 @@ export function parseHousingFloor(value) {
   const text = normalizeUnicode(value ?? '');
   if (!text) return deepFreeze({ floor: null, totalFloors: null });
 
-  // The rooms/floor/total shorthand must be read before the generic
-  // floor/total fraction parser or its first two numbers would incorrectly
-  // become floor=2, totalFloors=10 for "2/10/16".
   const compactSpec = parseCompactSpec(text);
   if (compactSpec) {
     return deepFreeze({ floor: compactSpec.floor, totalFloors: compactSpec.totalFloors });
   }
 
-  // Skip a pair that is merely the head of a rooms/floor/total triple the
-  // shorthand parser above rejected: there the floor and the total floors are
-  // the second and third numbers, never the first two.
   const fraction = text.match(/(?:^|[^\d])(\d{1,3})\s*[\/\\]\s*(\d{1,3})(?!\s*[\/\\]\s*\d)(?=$|[^\d])/u);
   if (fraction) {
     const floor = toNumber(fraction[1]);
@@ -143,9 +127,6 @@ export function parseHousingFloor(value) {
     }
   }
 
-  // Prefer the common "7 этаж" form before trying "этаж 7". Otherwise the
-  // marker-first parser can consume the next unrelated number (for example
-  // "7 этаж 44м²") and report floor 44.
   const beforeMarker = text.match(/(?:^|[^\d])(\d{1,3})\s*-?\s*(?:(?:chi|чи)\s*)?(?:этаж(?:да)?|поверх|floor|etaj|qavat(?:i(?:da(?:gi)?)?|da)?|қабат(?:ы(?:нда(?:ғы)?)?|та)?|кават(?:и(?:да(?:ги)?)?|да)?|қават(?:и(?:да(?:ги)?)?|да)?)(?=$|[^\p{L}\p{N}_])/iu);
   let floor = toNumber(beforeMarker?.[1]);
   let totalFloors = null;
@@ -164,7 +145,6 @@ export function parseHousingFloor(value) {
   }
 
   if (totalFloors == null) {
-    // Structured "Label - Value" reposts: "Этажность - 5" instead of "5 этажей".
     const reversedTotal = text.match(/(?:этажность|поверховість|qavatlilik|қабаттылық)\s*[-:–—]\s*(\d{1,3})(?=$|[^\p{L}\p{N}])/iu);
     totalFloors = toNumber(reversedTotal?.[1]);
   }
@@ -180,17 +160,18 @@ const AREA_LABELS = Object.freeze([
   ['kitchen', /(?:площадь\s+кухни|кухня|kitchen(?:\s+area)?|bucătărie|bucatarie|oshxona|асүй)/iu],
   ['balcony', /(?:балкон|лоджия|balcony|loggia|balcon|balkon)/iu],
   ['terrace', /(?:терраса|terrace|teras(?:ă|a)|terrasa)/iu],
-  ['total', /(?:общая\s+площадь|площадь|total\s+area|surface\s+area|suprafa(?:ță|ta)(?:\s+total(?:ă|a))?|umumiy\s+maydon|жалпы\s+аудан)/iu],
+  ['total', /(?:общ(?:ая)?\.?\s*пл(?:ощад[ьи])?\.?|общая\s+площадь|загальн\p{L}*\s+площ\p{L}*|площа|площадь|total\s+area|surface\s+area|suprafa(?:ță|ta)(?:\s+total(?:ă|a))?|umumiy\s+maydon|жалпы\s+аудан)/iu],
 ]);
 
 const AREA_UNIT_RE = String.raw`(?:м²|м2|m²|m2|sqm|sq\.?\s*m|mp|кв\.?\s*м|кв2|квадрат\p{L}*)`;
+const AREA_UNIT_AFTER_LABEL_RE = String.raw`(?:${AREA_UNIT_RE}|[mм])`;
 
 function areaAfterLabel(text, labelRe) {
-  const re = new RegExp(`${labelRe.source}\\s*[:=-]?\\s*(\\d{1,4}(?:[.,]\\d{1,2})?)\\s*${AREA_UNIT_RE}`, 'iu');
+  const re = new RegExp(`${labelRe.source}\\s*[:=-]?\\s*(\\d{1,4}(?:[.,]\\d{1,2})?)\\s*${AREA_UNIT_AFTER_LABEL_RE}(?=$|[^\\p{L}\\p{N}_])`, 'iu');
   return toNumber(text.match(re)?.[1]);
 }
 
-export function parseHousingAreas(value) {
+export function parseHousingAreas(value, options = {}) {
   const text = normalizeUnicode(value ?? '');
   const result = { total: null, living: null, kitchen: null, balcony: null, terrace: null };
   if (!text) return deepFreeze(result);
@@ -200,8 +181,11 @@ export function parseHousingAreas(value) {
     const generic = text.match(new RegExp(`(?:^|[^\\d])(\\d{1,4}(?:[.,]\\d{1,2})?)\\s*${AREA_UNIT_RE}(?=$|[^\\p{L}\\p{N}])`, 'iu'));
     result.total = toNumber(generic?.[1]);
   }
-  // The compact "1/5/12-50m" shorthand glues the area to the floor block, where
-  // the unit is often a bare "m" the generic area matcher cannot trust alone.
+  if (result.total == null) {
+    const typedArea = classifyHousingSingleMSpans(text, options)
+      .find((span) => span.type === HOUSING_NUMERIC_SPAN_TYPES.AREA);
+    result.total = typedArea?.amount ?? null;
+  }
   if (result.total == null) result.total = parseCompactSpec(text)?.areaSqm ?? null;
   for (const key of Object.keys(result)) {
     const number = result[key];
@@ -319,7 +303,7 @@ function distanceFromWindow(window, entityOffset = 0) {
       : /(?:на\s+машине|by\s+car|drive|mashinada|көлікпен)/iu.test(local) ? 'drive' : null;
     candidates.push({ distance: Math.abs(index - entityOffset), value: Number(match[1]), unit: 'minute', mode });
   }
-  const metricRe = /(\d{1,4}(?:[.,]\d+)?)\s*(км|km|километр\p{L}*|м|meter(?:s)?|метр\p{L}*)/giu;
+  const metricRe = /(\d{1,4}(?:[.,]\d+)?)\s*(км|km|километр\p{L}*|м|m(?![\p{L}\p{N}_])|meter(?:s)?|метр\p{L}*)/giu;
   for (const match of window.matchAll(metricRe)) {
     const index = match.index ?? 0;
     const rawUnit = match[2].toLocaleLowerCase();
@@ -431,11 +415,16 @@ export function parseHousingStructured(value, options = {}) {
   const fallbackCurrency = options.fallbackCurrency || countryCurrency(country) || '';
   const phoneCountry = options.phoneCountry || countryPhoneHint(country) || null;
   const intent = resolveHousingIntent(text);
-  const listingFields = parseHousingListingFields(text, { country, dealType: intent?.dealType || null });
+  const sourceDealType = ['sale', 'longRent', 'shortRent'].includes(String(options.dealType || ''))
+    ? String(options.dealType)
+    : null;
+  const effectiveDealType = intent?.dealType || sourceDealType || null;
+  const listingFields = parseHousingListingFields(text, { country, dealType: effectiveDealType });
   const parsedPayments = parseHousingPaymentDetails(text);
-  const payments = intent?.dealType === 'sale'
+  const payments = effectiveDealType === 'sale'
     ? deepFreeze({ ...parsedPayments, utilities: null })
     : parsedPayments;
+  const numericOptions = { country, dealType: effectiveDealType };
 
   return deepFreeze({
     text,
@@ -447,8 +436,12 @@ export function parseHousingStructured(value, options = {}) {
     context: parseHousingContext(text),
     rooms: parseHousingRoomCount(text),
     floor: parseHousingFloor(text),
-    area: parseHousingAreas(text),
-    price: parseHousingPrice(text, fallbackCurrency),
+    area: parseHousingAreas(text, numericOptions),
+    price: parseHousingPrice(text, {
+      country,
+      currency: fallbackCurrency,
+      dealType: effectiveDealType,
+    }),
     address: parseHousingAddress(text, {
       knownStreet: options.knownStreet || null,
       allowDelimitedBare: options.allowDelimitedBareAddress === true,