@whiteslove/parsing-lexicon 0.2.0

package/src/hiring-source-semantics.js

@@ -0,0 +1,293 @@
+import { CANDIDATE_FIELD_TERMS, JOB_FIELD_TERMS } from './hiring.js';
+import { aliasesOf, escapeRegex, normalizeUnicode } from './normalization.js';
+import { parseSalary } from './money.js';
+import { extractCandidateName } from './hiring-candidate-fields.js';
+import { countryCurrency } from './country-context.js';
+
+const FIELD_EXTRA_ALIASES = Object.freeze({
+  candidate: Object.freeze({
+    name: ['xodim', 'hodim', 'nomzod', 'candidate', 'f.i.o.', 'f i sh'],
+    profession: ["so'ralgan ish joyi", "so'ralgan ish turi", 'qidirayotgan kasb'],
+    skills: ['texnologiya', 'stack'],
+    salary: ['narx', 'narxi'],
+    address: ['hozirgi manzil', 'yashash joyi'],
+    contact: ['murojaat', 'boglanish'],
+    employmentType: ['format', 'bandlik', 'ish vaqti'],
+  }),
+  job: Object.freeze({
+    title: ['vacancy', 'position', 'role', 'job', 'вакансия', 'позиция', 'посада', 'loc de muncă', 'loc de munca', 'post', 'angajare'],
+    company: ['company', 'employer', 'компания', 'работодатель', 'роботодавець', 'компанія', 'companie', 'angajator', 'tashkilot', 'ish beruvchi'],
+    location: ['location', 'city', 'локация', 'локація', 'город', 'місто', 'locație', 'locatie', 'oraș', 'oras', 'manzil', 'shahar'],
+  }),
+});
+
+function entryAliases(entry, extras = []) {
+  return [...new Set([entry?.canonical, ...aliasesOf(entry || {}), ...extras].filter(Boolean))];
+}
+
+function fieldAliasPattern(value) {
+  return escapeRegex(normalizeUnicode(value).trim())
+    .replace(/[\s\-–—'’‘`ʻʼ]+/g, "[\\s\\-–—'’‘`ʻʼ]*");
+}
+
+function extractField(value, entry, extras = [], maxLength = 220) {
+  const text = String(value || '');
+  const aliases = entryAliases(entry, extras).sort((a, b) => b.length - a.length);
+  if (!text || !aliases.length) return null;
+  const label = aliases.map(fieldAliasPattern).join('|');
+  const match = text.match(new RegExp(`(?:^|\\n)[^\\p{L}\\p{N}\\n]{0,10}(?:${label})\\s*[:：—-]\\s*([^\\n]{1,${maxLength}})`, 'iu'));
+  return match?.[1]?.trim() || null;
+}
+
+export function extractCandidateStructuredField(value, key, maxLength = 220) {
+  return extractField(value, CANDIDATE_FIELD_TERMS[key], FIELD_EXTRA_ALIASES.candidate[key] || [], maxLength);
+}
+
+export function extractJobStructuredField(value, key, maxLength = 220) {
+  return extractField(value, JOB_FIELD_TERMS[key], FIELD_EXTRA_ALIASES.job[key] || [], maxLength);
+}
+
+export function extractCandidateDisplayName(value) {
+  const text = String(value || '');
+  const structured = extractCandidateName(text);
+  if (structured) return structured;
+  const linkedIn = text.match(/(?:резюме|resume)\s*\|\s*(\p{Lu}\p{Ll}+(?:\s+\p{Lu}(?:\p{Ll}+|\.))?)/iu)?.[1]
+    || text.match(/(?:^|\n)(\p{Lu}\p{Ll}+(?:\s+\p{Lu}\p{Ll}+)+)\s+-\s+(?:HR|Developer|Engineer|Manager|Designer)\b/iu)?.[1];
+  if (linkedIn) return linkedIn.trim().slice(0, 100);
+  const introduced = text.match(/(?:^|\n)(?:вітаю,?\s+)?мене\s+звати\s+(\p{Lu}\p{Ll}+)/iu)?.[1];
+  if (introduced) return introduced.trim().slice(0, 100);
+  const handleName = text.match(/@(\p{Lu}\p{Ll}{2,})(?:_|\p{Lu}|\d)/u)?.[1];
+  if (handleName) return handleName.trim().slice(0, 100);
+  return text.match(/(?:^|\n)(\p{Lu}\p{Ll}+)\s+\d+\+?\s+(?:рок\p{L}*|лет|years?)\s+(?:у|в|in)\s+(?:HR|IT)\b/iu)?.[1]?.trim().slice(0, 100) || '';
+}
+
+const APPROXIMATE_EXPERIENCE_RE = /(?:\b(?:about|around|approximately|approx\.?|circa)\b|(?:примерно|около|приблизно|близько|yaqin|atrofida|qariyb))/iu;
+
+function approximateExperienceSignal(context) {
+  return APPROXIMATE_EXPERIENCE_RE.test(context) ? { approximate: true } : {};
+}
+
+function validYears(raw) {
+  const years = Number(String(raw || '').replace(',', '.'));
+  return Number.isFinite(years) && years >= 0 && years <= 60 ? years : null;
+}
+
+export function extractCandidateExperienceMentions(value) {
+  const text = String(value || '');
+  const mentions = [];
+  const segments = text.split(/\n|(?<=[.!?])\s+/u).map((segment) => segment.trim()).filter(Boolean);
+  for (const segment of segments) {
+    const months = segment.match(/(?:опыт(?:\s+работы)?|досвід(?:\s+роботи)?|experience|experiență|staj|tajriba(?:m)?|ish\s+tajribasi)[^\n.!?]{0,100}?(\d{1,2})\s*(?:мес(?:яц\p{L}*)?\.?|міс(?:яц\p{L}*)?\.?|months?|mo\b|oy(?:lik)?)/iu);
+    if (months?.[1]) {
+      const count = Number(months[1]);
+      if (Number.isFinite(count) && count > 0 && count < 24) {
+        const from = (months.index || 0) + months[0].length;
+        const context = `${months[0]} ${segment.slice(from, from + 100)}`.replace(/\s+/g, ' ').trim();
+        mentions.push(Object.freeze({ years: Math.round((count / 12) * 10) / 10, context, ...approximateExperienceSignal(context) }));
+      }
+      continue;
+    }
+    const reverse = segment.match(/(\d+(?:[.,]\d+)?)\+?\s*(?:лет|год(?:а|ов)?|рок(?:и|ів)?|years?|ani|an|yil(?:ga|lik)?|йил(?:га|лик)?)[^\n.!?]{0,140}?(?:опыт|досвід|experience|experiență|staj|tajriba(?:m)?)/iu);
+    if (reverse?.[1]) {
+      const years = validYears(reverse[1]);
+      if (years != null) {
+        const context = reverse[0].replace(/\s+/g, ' ').trim();
+        mentions.push(Object.freeze({ years, context, ...approximateExperienceSignal(context) }));
+      }
+      continue;
+    }
+    const direct = segment.match(/(?:опыт(?:\s+работы)?|досвід(?:\s+роботи)?|experience|experiență|staj|tajriba(?:m)?|ish\s+tajribasi)[^\n.!?]{0,100}?(\d+(?:[.,]\d+)?)\+?\s*(?:лет|год(?:а|ов)?|рок(?:и|ів)?|years?|ani|an|yil|йил)?/iu);
+    if (!direct?.[1]) continue;
+    const years = validYears(direct[1]);
+    if (years == null) continue;
+    const tailStart = (direct.index || 0) + direct[0].length;
+    const context = `${direct[0]} ${segment.slice(tailStart, tailStart + 100)}`.replace(/\s+/g, ' ').trim();
+    mentions.push(Object.freeze({ years, context, ...approximateExperienceSignal(context) }));
+  }
+  return Object.freeze(mentions);
+}
+
+const EXTRA_CURRENCIES = Object.freeze([
+  ['TJS', /(?:\bTJS\b|сомони)/iu],
+  ['TMT', /(?:\bTMT\b|манат\p{L}*)/iu],
+]);
+
+function sourceCurrency(text) {
+  for (const [code, pattern] of EXTRA_CURRENCIES) if (pattern.test(text)) return code;
+  return null;
+}
+
+function parseLooseNumber(raw, suffix = '') {
+  const scale = /^(?:кк|kk|млн|mln|million)$/iu.test(suffix) ? 1_000_000
+    : /^(?:к|k|тыс|тис|ming|thousand)$/iu.test(suffix) ? 1_000
+      : 1;
+  const value = String(raw || '').replace(/\u00a0/g, ' ').replace(/\s+/g, '').trim();
+  if (!value) return null;
+  let base;
+  if (/^\d{1,3}([.,])\d{3}(?:\1\d{3})*$/.test(value)) base = Number(value.replace(/[.,]/g, ''));
+  else if (scale > 1 && /^\d+[.,]\d{1,2}$/.test(value)) base = Number(value.replace(',', '.'));
+  else base = Number(value.replace(/[.,]/g, ''));
+  const parsed = Math.round(base * scale);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+const SOURCE_AMOUNT_RE = /(\d[\d\s.,]*\d|\d)(?:\s*(кк|kk|млн|mln|million|к|k|тыс|тис|ming|thousand))?(?:\s*(?:[-–—…]{1,3}|до|to|dan\s+gacha|gacha)\s*(\d[\d\s.,]*\d|\d)(?:\s*(кк|kk|млн|mln|million|к|k|тыс|тис|ming|thousand))?)?/iu;
+
+export function parseHiringSourceSalary(value) {
+  const text = String(value || '').replace(/(?<=\d)\s*(?:кк|kk)(?![\p{L}\p{N}_])/giu, ' mln ');
+  const parsed = parseSalary(text);
+  if (parsed?.currency && (parsed.min != null || parsed.max != null)) return parsed;
+  const currency = sourceCurrency(text);
+  if (!currency) return parsed;
+  const match = text.match(SOURCE_AMOUNT_RE);
+  if (!match) return parsed;
+  const first = parseLooseNumber(match[1], match[2]);
+  const second = match[3] ? parseLooseNumber(match[3], match[4]) : null;
+  if (first == null && second == null) return parsed;
+  const low = first ?? second;
+  const high = second ?? first;
+  return Object.freeze({
+    min: low != null && high != null ? Math.min(low, high) : low,
+    max: low != null && high != null ? Math.max(low, high) : high,
+    currency,
+    period: parsed?.period ?? null,
+    gross: parsed?.gross ?? null,
+    negotiable: parsed?.negotiable ?? false,
+    approximate: parsed?.approximate ?? false,
+  });
+}
+
+export function parseCandidateSalary(value, country = '') {
+  const field = extractCandidateStructuredField(value, 'salary', 140);
+  if (!field) return null;
+  const defaultCurrency = defaultHiringCurrency(country);
+  let parsed = parseHiringSourceSalary(field);
+  if (!parsed || (parsed.min == null && parsed.max == null)) {
+    const match = field.match(SOURCE_AMOUNT_RE);
+    if (!match) return null;
+    const first = parseLooseNumber(match[1], match[2]);
+    const second = match[3] ? parseLooseNumber(match[3], match[4]) : null;
+    if (first == null && second == null) return null;
+    const low = first ?? second;
+    const high = second ?? first;
+    parsed = Object.freeze({
+      min: low != null && high != null ? Math.min(low, high) : low,
+      max: /\+/.test(field) ? null : (low != null && high != null ? Math.max(low, high) : high),
+      currency: defaultCurrency,
+      period: null,
+      gross: null,
+      negotiable: false,
+      approximate: false,
+    });
+  }
+  return Object.freeze({ ...parsed, currency: parsed.currency || defaultCurrency });
+}
+
+export function detectUsLocation(value) {
+  return /\bunited states\b|\busa\b|\bu\.s\.?\b|\bUS(?:\s+remote)?\b|\b(?:AL|AK|AZ|AR|CA|CO|CT|DE|FL|GA|HI|ID|IL|IN|IA|KS|KY|LA|ME|MD|MA|MI|MN|MS|MO|MT|NE|NV|NH|NJ|NM|NY|NC|ND|OH|OK|OR|PA|RI|SC|SD|TN|TX|UT|VT|VA|WA|WV|WI|WY|DC)\b/i.test(String(value || ''));
+}
+
+const NEGATIVE_SPONSORSHIP_RE = /(?:\bno\s+(?:visa\s+|immigration\s+|employment\s+)?sponsorship\b|\b(?:will\s+not|cannot|can't|unable\s+to|not\s+able\s+to)\s+sponsor\b|\bdo(?:es)?\s+not\s+(?:offer|provide)\s+(?:visa\s+|immigration\s+|employment\s+)?sponsorship\b|\bwithout\s+(?:the\s+need\s+for\s+)?(?:(?:current\s+(?:and\/or|or)\s+future|current|future)\s+)?(?:employer\s+|visa\s+)?sponsorship\b|\bmust\s+(?:be\s+)?(?:legally\s+)?authoriz\w+\s+to\s+work[^.!?]{0,80}\bwithout\s+(?:current\s+or\s+future\s+|current\s+|future\s+)?sponsorship\b|\bmust\s+not\s+require\s+(?:current\s+or\s+future\s+|current\s+|future\s+)?(?:visa\s+|employment\s+)?sponsorship\b|\b(?:current\s+and\/or\s+future|current\s+or\s+future)\s+sponsorship\s+(?:is\s+)?not\s+(?:available|provided|offered)\b|\bsponsorship\s+(?:is\s+)?not\s+(?:available|provided|offered)\b|\bno\s+c2c(?:\s+or\s+visa\s+sponsorship)?\b|\bmay\s+not\s+be\s+able\s+to\b[^\n!?]{0,450}\b(?:sponsor|support|provide)\b[^\n!?]{0,180}\bsponsorship\b|\b(?:will|can|may)\s+not\b[^\n!?]{0,220}\b(?:support|provide)\b[^\n!?]{0,160}\bsponsorship\b|\bnot\s+(?:currently\s+)?(?:able\s+to\s+)?(?:support|provide)\b[^\n!?]{0,160}\bsponsorship\b)/iu;
+const POSITIVE_SPONSORSHIP_RE = /(?:\bwill\s+sponsor\b|\bwe\s+sponsor\b|\b(?:can|may)\s+sponsor\b|\bopen\s+to\s+(?:visa\s+)?sponsorship\b|\bvisa\s+sponsorship\s+(?:is\s+)?(?:available|provided|offered|possible)\b|\b(?:h-?1b|h1-b)\s+(?:visa\s+)?sponsorship\b|\bh-?1b\s+transfer\b|\bimmigration\s+sponsorship\b|\bemployment\s+visa\s+sponsorship\b|\bwork\s+visa\s+sponsorship\b|\bsponsor(?:ing)?\s+(?:qualified|eligible|selected)\s+candidates\b|\beligible\s+for\s+(?:visa\s+)?sponsorship\b|\bvisa\s+support\b|\bwork\s+visa\s+support\b)/iu;
+
+export function detectVisaSponsorshipWording(value) {
+  const text = String(value || '');
+  if (NEGATIVE_SPONSORSHIP_RE.test(text)) return 'notOffered';
+  if (POSITIVE_SPONSORSHIP_RE.test(text)) return 'offered';
+  return null;
+}
+
+export const TEMPORARY_WORK_AUTH_RE = /\b(?:opt|cpt|stem\s+opt)\b/iu;
+
+export function detectRecruitmentAgency(value) {
+  return /recruit(?:ment|ing) agency|staffing agency|talent agency|кадров(?:ое|е) агентство|рекрут(?:ингов|инг)\p{L}* агентство|агентство по подбору/iu.test(String(value || ''));
+}
+
+const NICE_TO_HAVE_RE = /(will be a plus|is a plus|as a plus|nice to have|would be a plus|plus:|плюсом|будет плюсом|буде плюсом|перевагою|преимуществом|will be an advantage)/iu;
+export function extractNiceToHaveContext(value, maxLength = 500) {
+  const text = String(value || '');
+  const match = NICE_TO_HAVE_RE.exec(text);
+  if (!match?.index && match?.index !== 0) return '';
+  return text.slice(match.index + match[0].length, match.index + match[0].length + Math.max(40, Math.min(1500, Number(maxLength) || 500))).trim();
+}
+
+const CANDIDATE_FORM_RE = /(?:^|\n)\s*[^\p{L}\p{N}\n]{0,8}(?:ism(?:i|im)?(?:\s*[-–—]\s*(?:familya|familiya))?|familya|familiya|f\.?i\.?o\.?|фио|имя|yoshi|yoshim|tug(?:['’‘])ilgan\s+yili|возраст|qidirayotgan\s+kasb|so(?:['’‘])ralgan\s+ish\s+(?:joyi|turi)|yashash\s+manzili|ma(?:['’‘])lumoti|ожидаемая\s+работа|желаемая\s+(?:должность|работа)|tajribasi?|опыт\s+работы)\s*[:—-]/imu;
+const CV_MARKER_RE = /(?:резюме|resume|\bcv\b|curriculum vitae|анкета|профиль кандидата|профіль кандидата|кандидат(?:ка)?|candidate profile|mening\s+(?:cv|rezume)|my\s+cv)/iu;
+const FIRST_PERSON_CANDIDATE_RE = /(?:^|\n)\s*[^\p{L}\p{N}\n]{0,6}(?:я[\s—,-]|я\s+(?:ищу|шукаю)(?![\p{L}\p{N}_])|(?:ищу|шукаю)(?![\p{L}\p{N}_])|men[\s,]|mening[\s,]|my name is|i am a|i'm a|ismim\b)/iu;
+const PERSONAL_PROFILE_RE = /(?:^|[^\p{L}\p{N}_])(?:(?:1[6-9]|[2-6]\d)\s*(?:лет|года?|рок(?:и|ів)?|years?\s+old)|(?:студент(?:ка|ом|кой)?|student))(?![\p{L}\p{N}_])/iu;
+const CANDIDATE_CONTACT_RE = /(?:\+?\d[\d\s()\-]{7,}|@[a-z0-9_]{4,}|(?:telegram|телефон|phone|tel|aloqa|murojaat|bog(?:'|’)lanish)\s*[:—-])/iu;
+const EMPTY_CANDIDATE_RECOMMENDATION_RE = /^(?:колеги[,!\s]*)?(?:вітаю[,!\s]*)?рекомендую\s+(?:класного\s+)?кандидат\p{L}*[.!\s]+(?:контакт\p{L}*\s+та\s+)?резюме\s+додаю\.?$/iu;
+const CANDIDATE_SECTION_PATTERNS = Object.freeze([
+  /(?:опыт|досвід|experience|staj|tajriba|ish\s+tajribasi)/iu,
+  /(?:skills|навыки|навички|умею|стек|stack|technologies|texnologiyalar|ko(?:'|’)nikmalar)/iu,
+  /(?:education|образован|освіт|o(?:'|’)qish|ta(?:'|’)lim|университет|університет|university|college|institut)/iu,
+  /(?:languages|языки|мови|til(?:lar)?|language skills)/iu,
+  /(?:contact|контакт|telegram|телефон|phone|tel|bog(?:'|’)lanish|aloqa)/iu,
+]);
+
+export function detectCandidatePostSignals(value) {
+  const text = String(value || '').split('\n').map((line) => line.replace(/\s+/g, ' ').trim()).filter(Boolean).join('\n').trim();
+  return Object.freeze({
+    candidateForm: CANDIDATE_FORM_RE.test(text),
+    cvMarker: CV_MARKER_RE.test(text),
+    firstPerson: FIRST_PERSON_CANDIDATE_RE.test(text),
+    personalProfile: PERSONAL_PROFILE_RE.test(text),
+    contact: CANDIDATE_CONTACT_RE.test(text),
+    emptyRecommendation: EMPTY_CANDIDATE_RECOMMENDATION_RE.test(text.replace(/\s+/g, ' ')),
+    sectionCount: CANDIDATE_SECTION_PATTERNS.filter((pattern) => pattern.test(text)).length,
+  });
+}
+
+function candidateBlockLabels(key) {
+  return entryAliases(CANDIDATE_FIELD_TERMS[key], FIELD_EXTRA_ALIASES.candidate[key] || [])
+    .sort((a, b) => b.length - a.length)
+    .map(fieldAliasPattern);
+}
+
+export function extractCandidateStructuredBlock(value, key, maxLength = 800) {
+  const text = String(value || '');
+  const labels = candidateBlockLabels(key);
+  if (!text || !labels.length) return null;
+  const label = labels.join('|');
+  const allLabels = Object.keys(CANDIDATE_FIELD_TERMS)
+    .flatMap((candidateKey) => candidateBlockLabels(candidateKey))
+    .filter(Boolean)
+    .join('|');
+  const match = text.match(new RegExp(`(?:^|\\n)[^\\p{L}\\p{N}\\n]{0,10}(?:${label})\\s*[:：—-]?\\s*\\n([\\s\\S]{1,${maxLength}}?)(?=\\n[^\\p{L}\\p{N}\\n]{0,10}(?:${allLabels})\\s*[:：—-]|$)`, 'iu'));
+  return match?.[1]?.replace(/\s+/g, ' ').trim() || null;
+}
+
+export function defaultHiringCurrency(country) {
+  return countryCurrency(country);
+}
+
+const HIRING_CHARITY_APPEAL_RE = /(?:шелтер|притулок|прихисток|благодійн\p{L}*|благотворительн\p{L}*|донат\p{L}*|пожертв\p{L}*|збір\s+(?:кошт|грош)\p{L}*|сбор\s+средств|допоможіть|допомогти\s+(?:родин|дідус|бабус)\p{L}*|потребує\s+допомоги|нуждается\s+в\s+помощи|опікунств\p{L}*|інвалідніст\p{L}*|карта\s+для\s+допомоги|реквізити\s+для|monobank|банка\s+збор)/iu;
+
+export function isHiringCharityAppeal(value) {
+  const text = String(value || '');
+  if (!text) return false;
+  const matches = text.match(new RegExp(HIRING_CHARITY_APPEAL_RE.source, 'giu')) || [];
+  return matches.length >= 2;
+}
+
+const RECRUITING_OPPORTUNITY_SIGNALS = Object.freeze([
+  /(?:\blaboratory\b|\bacademy\b|\bbootcamp\b|\btraining\s+program\b|\binternship\s+program\b|лабораторія|лаборатория|академія|академия|буткемп)/iu,
+  /(?:запрошує|приглашает|приглашаем|набір|набор)[^.]{0,100}(?:кандидат|учасник|участник)/iu,
+  /(?:(?:реєстрац|регистрац)\p{L}*\s+до|\bregistration\b\s+(?:until|by))/iu,
+  /(?:(?:старт|початок)\s*[—:,-]?\s*\d{1,2}\s+\p{L}+|\bstart\b\s*[—:,-]?\s*\d{1,2})/iu,
+  /(?:кількість\s+місць|количество\s+мест|\blimited\s+spots\b|менторськ|менторск|\bmentorship\b)/iu,
+]);
+
+export function isHiringRecruitingOpportunity(value) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return false;
+  return RECRUITING_OPPORTUNITY_SIGNALS.filter((pattern) => pattern.test(text)).length >= 2;
+}
+
+export function sameHiringProfessionFamily(a, b) {
+  const left = String(a || '').trim().toLowerCase().replace(/[_-]+/g, ' ');
+  const right = String(b || '').trim().toLowerCase().replace(/[_-]+/g, ' ');
+  if (!left || !right) return false;
+  if (left === right) return true;
+  return /(?:^|\s)developer$/u.test(left) && /(?:^|\s)developer$/u.test(right);
+}

package/src/hiring-temporal.d.ts

@@ -0,0 +1,15 @@
+export const HIRING_MONTHS: Readonly<Record<string, number>>;
+export const UNICODE_LEFT_BOUNDARY: string;
+export const UNICODE_RIGHT_BOUNDARY: string;
+export const TODAY_RE: RegExp;
+export const YESTERDAY_RE: RegExp;
+export const HOURS_AGO_RE: RegExp;
+export const DAYS_AGO_RE: RegExp;
+export const AGO_SUFFIX: string;
+export const WEEKS_AGO_RE: RegExp;
+export const MONTHS_AGO_RE: RegExp;
+export const YEARS_AGO_RE: RegExp;
+
+export function parseHiringActivityDate(value: unknown, now?: Date): string | null;
+export function parseHiringDayMonthDate(value: unknown, now?: Date): string | null;
+export function extractHiringDeadline(value: unknown): string | null;

package/src/hiring-temporal.js

@@ -0,0 +1,67 @@
+export const HIRING_MONTHS = Object.freeze({
+  январь: 0, января: 0, february: 1, февраль: 1, февраля: 1,
+  март: 2, марта: 2, april: 3, апрель: 3, апреля: 3,
+  may: 4, май: 4, мая: 4, june: 5, июнь: 5, июня: 5,
+  july: 6, июль: 6, июля: 6, august: 7, август: 7, августа: 7,
+  september: 8, сентябрь: 8, сентября: 8, october: 9, октябрь: 9, октября: 9,
+  november: 10, ноябрь: 10, ноября: 10, december: 11, декабрь: 11, декабря: 11,
+  ianuarie: 0, februarie: 1, martie: 2, aprilie: 3, mai: 4, iunie: 5,
+  iulie: 6, august: 7, septembrie: 8, octombrie: 9, noiembrie: 10, decembrie: 11,
+  січня: 0, лютого: 1, березня: 2, квітня: 3, травня: 4, червня: 5,
+  липня: 6, серпня: 7, вересня: 8, жовтня: 9, листопада: 10, грудня: 11,
+});
+
+export const UNICODE_LEFT_BOUNDARY = '(?<![\\p{L}\\p{N}])';
+export const UNICODE_RIGHT_BOUNDARY = '(?![\\p{L}\\p{N}])';
+export const TODAY_RE = new RegExp(`${UNICODE_LEFT_BOUNDARY}(?:сегодня|сьогодні|bugun|today|astăzi|azi)${UNICODE_RIGHT_BOUNDARY}`, 'iu');
+export const YESTERDAY_RE = new RegExp(`${UNICODE_LEFT_BOUNDARY}(?:вчера|вчора|kecha|yesterday|ieri)${UNICODE_RIGHT_BOUNDARY}`, 'iu');
+export const HOURS_AGO_RE = new RegExp(`(?:^|\\s)(\\d{1,3})\\s*(?:ч\\.?|час(?:а|ов)?|год(?:ину|ини)|soat|hours?|hrs?|ore|oră)${UNICODE_RIGHT_BOUNDARY}`, 'iu');
+export const DAYS_AGO_RE = new RegExp(`(?:^|\\s)(\\d{1,3})\\s*(?:дн(?:я|ей|і|ів)?|день|days?|kun|zile|zi)${UNICODE_RIGHT_BOUNDARY}`, 'iu');
+export const AGO_SUFFIX = '(?:\\s*(?:назад|тому|раніше|oldin|ago|în urmă))';
+export const WEEKS_AGO_RE = new RegExp(`(?:^|\\s)(\\d{1,2})\\s*(?:недел(?:ю|и|ь)|тижн(?:ів|і|я)|hafta|weeks?|săptămân\\p{L}*)${AGO_SUFFIX}`, 'iu');
+export const MONTHS_AGO_RE = new RegExp(`(?:^|\\s)(\\d{1,2})\\s*(?:мес(?:яц\\p{L}*)?\\.?|міс(?:яц\\p{L}*)?\\.?|oy|months?|lun\\p{L}*)${AGO_SUFFIX}`, 'iu');
+export const YEARS_AGO_RE = new RegExp(`(?:^|\\s)(\\d{1,2})\\s*(?:год(?:а|ов)?|лет|рік|рок(?:и|ів)|yil|years?|ani|an)${AGO_SUFFIX}`, 'iu');
+
+export function parseHiringActivityDate(value, now = new Date()) {
+  const text = String(value || '');
+  if (TODAY_RE.test(text)) return now.toISOString();
+  if (YESTERDAY_RE.test(text)) return new Date(now.getTime() - 86_400_000).toISOString();
+  const absolute = text.match(/(?<![\p{L}\p{N}])(\d{1,2})\s+([\p{L}]+),?\s+(20\d{2})(?![\p{L}\p{N}])/iu);
+  if (absolute) {
+    const month = HIRING_MONTHS[absolute[2].toLocaleLowerCase('ru')];
+    if (month != null) return new Date(Date.UTC(Number(absolute[3]), month, Number(absolute[1]), 12)).toISOString();
+  }
+  const dotted = text.match(/(?<![\d])(\d{1,2})[./-](\d{1,2})[./-](20\d{2})(?![\d])/);
+  if (dotted) return new Date(Date.UTC(Number(dotted[3]), Number(dotted[2]) - 1, Number(dotted[1]), 12)).toISOString();
+  const hours = text.match(HOURS_AGO_RE);
+  if (hours) return new Date(now.getTime() - Number(hours[1]) * 3_600_000).toISOString();
+  const days = text.match(DAYS_AGO_RE);
+  if (days) return new Date(now.getTime() - Number(days[1]) * 86_400_000).toISOString();
+  const weeks = text.match(WEEKS_AGO_RE);
+  if (weeks) return new Date(now.getTime() - Number(weeks[1]) * 7 * 86_400_000).toISOString();
+  const months = text.match(MONTHS_AGO_RE);
+  if (months) return new Date(now.getTime() - Number(months[1]) * 30 * 86_400_000).toISOString();
+  const years = text.match(YEARS_AGO_RE);
+  if (years) return new Date(now.getTime() - Number(years[1]) * 365 * 86_400_000).toISOString();
+  return null;
+}
+
+export function parseHiringDayMonthDate(value, now = new Date()) {
+  const text = String(value || '');
+  const match = text.match(new RegExp(`${UNICODE_LEFT_BOUNDARY}(\\d{1,2})\\s+(\\p{L}+)${UNICODE_RIGHT_BOUNDARY}`, 'iu'));
+  if (!match) return null;
+  const month = HIRING_MONTHS[match[2].toLocaleLowerCase('ru')];
+  if (month == null) return null;
+  const day = Number(match[1]);
+  let time = Date.UTC(now.getUTCFullYear(), month, day, 12);
+  if (time > now.getTime() + 48 * 60 * 60 * 1000) time = Date.UTC(now.getUTCFullYear() - 1, month, day, 12);
+  return new Date(time).toISOString();
+}
+
+const DEADLINE_MARKER_RE = /(?:application\s+deadline|apply\s+by|closing\s+date|deadline|дедлайн|срок(?:\s+подачи)?|термін(?:\s+подання)?)[\s:–—-]{0,8}([^.;\n]{3,55})/iu;
+const DEADLINE_DATE_RE = /\b(?:\d{4}-\d{2}-\d{2}|\d{1,2}[./-]\d{1,2}[./-]\d{2,4}|\d{1,2}\s+(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?|янв\p{L}*|фев\p{L}*|мар\p{L}*|апр\p{L}*|ма[йя]|июн\p{L}*|июл\p{L}*|авг\p{L}*|сен\p{L}*|окт\p{L}*|ноя\p{L}*|дек\p{L}*)\.?\s+\d{2,4})\b/iu;
+
+export function extractHiringDeadline(value) {
+  const marker = DEADLINE_MARKER_RE.exec(String(value || ''));
+  return marker?.[1]?.match(DEADLINE_DATE_RE)?.[0]?.trim() || null;
+}

package/src/hiring-vacancy-fields.d.ts

@@ -0,0 +1,5 @@
+export type HiringEducation = 'doctorate' | 'master' | 'bachelor' | 'higher' | 'secondary';
+export type HiringApplicationLanguage = 'English' | 'Russian' | 'Ukrainian' | 'Uzbek' | 'Kazakh' | 'Romanian';
+
+export function detectHiringEducation(value: unknown): HiringEducation | null;
+export function detectApplicationLanguage(value: unknown): HiringApplicationLanguage | null;

package/src/hiring-vacancy-fields.js

@@ -0,0 +1,23 @@
+import { detectDegreeLevel } from './hiring-requirements.js';
+
+export function detectHiringEducation(value) {
+  const text = String(value || '');
+  const degree = detectDegreeLevel(text);
+  if (degree) return degree;
+  if (/higher education|высшее образование|вища освіта|олий маълумот/iu.test(text)) return 'higher';
+  return null;
+}
+
+export function detectApplicationLanguage(value) {
+  const text = String(value || '');
+  const match = /(?:submit|send|provide|отправ\p{L}*|пришл\p{L}*|направ\p{L}*|подай\p{L}*|надішл\p{L}*)[^.;\n]{0,35}(?:application|resume|résumé|cv|резюме)[^.;\n]{0,20}[^\p{L}\p{N}](?:in|на|у|в)\s+(english|russian|ukrainian|uzbek|kazakh|romanian|английском|русском|украинском|українською|українській|узбекском|казахском|румынском)(?![\p{L}\p{N}])/iu.exec(text);
+  if (!match?.[1]) return null;
+  const language = match[1].toLowerCase();
+  if (/english|англий/.test(language)) return 'English';
+  if (/russian|русск/.test(language)) return 'Russian';
+  if (/ukrain|укра/.test(language)) return 'Ukrainian';
+  if (/uzbek|узбек/.test(language)) return 'Uzbek';
+  if (/kazakh|казах/.test(language)) return 'Kazakh';
+  if (/romanian|румын/.test(language)) return 'Romanian';
+  return null;
+}

package/src/hiring-work-semantics.d.ts

@@ -0,0 +1,34 @@
+export type HiringEmploymentType =
+  | 'full_time'
+  | 'part_time'
+  | 'contract'
+  | 'project'
+  | 'freelance'
+  | 'temporary'
+  | 'internship'
+  | 'volunteer'
+  | 'seasonal';
+
+export type HiringWorkMode = 'remote' | 'hybrid' | 'onsite';
+
+export type HiringWorkSchedule =
+  | 'fiveTwo'
+  | 'twoTwo'
+  | 'sixOne'
+  | 'threeThree'
+  | 'oneThree'
+  | 'twentyFourFortyEight'
+  | 'shift'
+  | 'flexible'
+  | 'day'
+  | 'night'
+  | 'rotational';
+
+export type HiringProbationKind = 'probation' | 'noProbation' | 'paidProbation' | 'unpaidProbation';
+export type HiringExperienceRequirement = 'noExperience' | 'experienceRequired';
+
+export function detectEmploymentTypes(value: unknown): readonly HiringEmploymentType[];
+export function detectWorkModes(value: unknown): readonly HiringWorkMode[];
+export function detectWorkSchedules(value: unknown): readonly HiringWorkSchedule[];
+export function detectProbation(value: unknown): HiringProbationKind | null;
+export function detectExperienceRequirement(value: unknown): HiringExperienceRequirement | null;

package/src/hiring-work-semantics.js

@@ -0,0 +1,72 @@
+import { findCanonical } from './normalization.js';
+import {
+  EMPLOYMENT_TYPES,
+  EXPERIENCE_REQUIREMENTS,
+  PROBATION_TERMS,
+  SCHEDULE_TERMS,
+  WORK_MODES,
+} from './hiring.js';
+import { parseExperience, WORK_SCHEDULE_EXTENSIONS } from './hiring-advanced.js';
+
+const EMPLOYMENT_OUTPUT = Object.freeze({
+  fullTime: 'full_time',
+  partTime: 'part_time',
+  contract: 'contract',
+  project: 'project',
+  freelance: 'freelance',
+  temporary: 'temporary',
+  internship: 'internship',
+  volunteer: 'volunteer',
+  seasonal: 'seasonal',
+});
+
+const PROBATION_MATCH_ORDER = Object.freeze([
+  PROBATION_TERMS.paid,
+  PROBATION_TERMS.unpaid,
+  PROBATION_TERMS.noProbation,
+  PROBATION_TERMS.probation,
+]);
+
+function collectCanonical(text, entries) {
+  const values = [];
+  for (const entry of entries) {
+    if (!findCanonical(text, [entry], { partial: true })) continue;
+    if (!values.includes(entry.canonical)) values.push(entry.canonical);
+  }
+  return values;
+}
+
+export function detectEmploymentTypes(value) {
+  return Object.freeze(
+    collectCanonical(String(value || ''), EMPLOYMENT_TYPES)
+      .map((canonical) => EMPLOYMENT_OUTPUT[canonical])
+      .filter(Boolean),
+  );
+}
+
+export function detectWorkModes(value) {
+  return Object.freeze(collectCanonical(String(value || ''), WORK_MODES));
+}
+
+export function detectWorkSchedules(value) {
+  return Object.freeze(collectCanonical(String(value || ''), [...SCHEDULE_TERMS, ...WORK_SCHEDULE_EXTENSIONS]));
+}
+
+export function detectProbation(value) {
+  const text = String(value || '');
+  for (const entry of PROBATION_MATCH_ORDER) {
+    if (findCanonical(text, [entry], { partial: true })) return entry.canonical;
+  }
+  return null;
+}
+
+export function detectExperienceRequirement(value) {
+  const text = String(value || '');
+  const parsed = parseExperience(text);
+  if (parsed?.requirement === 'none') return 'noExperience';
+  if (parsed?.requirement === 'required') return 'experienceRequired';
+  for (const entry of Object.values(EXPERIENCE_REQUIREMENTS)) {
+    if (findCanonical(text, [entry], { partial: true })) return entry.canonical;
+  }
+  return null;
+}