@whiteslove/parsing-lexicon 0.2.0

package/src/hiring-requirements.js

@@ -0,0 +1,170 @@
+import { parseExperience } from './hiring-advanced.js';
+
+export const SENIORITY_RANK = Object.freeze({
+  intern: 0,
+  junior: 1,
+  middle: 2,
+  senior: 3,
+  staff: 4,
+  lead: 4,
+  manager: 4,
+  principal: 5,
+  director: 6,
+});
+
+export function detectHiringSeniority(value) {
+  const text = String(value || '');
+  const target = /\b(?:looking|searching)\s+for\s+(?:an?\s+)?(?:a\s+)?(intern|junior|middle|mid|senior|staff|principal|lead)\b/i.exec(text)?.[1];
+  const normalize = (item) => item.toLowerCase() === 'mid' ? 'middle' : item.toLowerCase();
+  if (target) return normalize(target);
+  const checks = [
+    ['director', /\b(?:engineering\s+)?director\b|директор/i],
+    ['principal', /\bprincipal\b(?=[^,;\n]{0,60}\b(?:engineer|developer|architect)\b)/i],
+    ['staff', /\bstaff\b(?=[^,;\n]{0,60}\b(?:engineer|developer|architect)\b)/i],
+    ['lead', /\b(?:team\s*lead|tech\s*lead|lead\s+(?:engineer|developer|frontend|backend))\b|тимлид|техлид|ведущ\w*/i],
+    ['manager', /\bengineering manager\b|руководител/i],
+    ['senior', /\bsenior\b(?=[^,;\n]{0,60}\b(?:engineer|developer|frontend|backend|software)\b)|сеньор|старш\w*\s+(?:разработ|инженер)/i],
+    ['middle', /\b(?:middle|mid[- ]?level)\b(?=[^,;\n]{0,60}\b(?:engineer|developer|frontend|backend|software)\b)|мидл/i],
+    ['junior', /\bjunior\b(?=[^,;\n]{0,60}\b(?:engineer|developer|frontend|backend|software)\b)|джун\w*|младш\w*/i],
+    ['intern', /\b(?:intern|trainee)\b|стаж[ёе]р|стажир/i],
+  ];
+  return checks.find(([, pattern]) => pattern.test(text))?.[0] || null;
+}
+
+export function detectDegreeLevel(value) {
+  const text = String(value || '');
+  if (/\b(?:ph\.?d\.?|doctorate|doctoral degree)\b|доктор(?:ская| наук)/i.test(text)) return 'doctorate';
+  if (/master['’]?s degree|master degree|магистр|магістр/i.test(text)) return 'master';
+  if (/bachelor['’]?s degree|bachelor degree|бакалавр/i.test(text)) return 'bachelor';
+  if (/secondary education|среднее образование|середня освіта/i.test(text)) return 'secondary';
+  return null;
+}
+
+export function detectDegreeFields(value) {
+  const text = String(value || '');
+  const fields = [];
+  if (/computer science|computer engineering|software engineering|information technology|informatics|інформатик|информатик/i.test(text)) fields.push('computer_science');
+  if (/\bengineering\b|инженерн|інженерн/i.test(text)) fields.push('engineering');
+  if (/\b(?:civil\s+)?law\b|legal studies|юридич|юриспруд|право\b/i.test(text)) fields.push('law');
+  if (/forensic|criminal investigation|криминалист|криміналіст|следствен|слідч/i.test(text)) fields.push('forensics');
+  if (/business|economics|finance|management|эконом|економ/i.test(text)) fields.push('business');
+  return Object.freeze([...new Set(fields)]);
+}
+
+export function extractRequiredExperienceYears(value) {
+  const parsed = parseExperience(value);
+  return typeof parsed?.minYears === 'number' ? parsed.minYears : null;
+}
+
+export function hasUsWorkAuthorization(value) {
+  const text = String(value || '');
+  return /\b(?:u\.?s\.?|united states)\s+citizen\b|\bgreen card\b|\bpermanent resident\b|\bemployment authorization document\b|\bEAD\b|\bauthoriz\w+\s+to\s+work\s+in\s+(?:the\s+)?(?:u\.?s\.?|united states)(?:[^.!?]{0,50}\bwithout\s+sponsorship\b)?|\bno\s+(?:visa\s+)?sponsorship\s+required\b/i.test(text);
+}
+
+export function requiresUsSponsorship(value) {
+  const text = String(value || '');
+  if (hasUsWorkAuthorization(text)) return false;
+  if (/\b(?:require|requires|requiring|need|needs|seeking)\b[^.!?]{0,60}\b(?:visa|employment)\s+sponsorship\b|\bneed\s+(?:an?\s+)?(?:h-?1b|work visa)\b/i.test(text)) return true;
+  const citizenship = /\bcitizenship\s*[:\-]\s*([^\n|,;]{2,45})/i.exec(text)?.[1];
+  if (citizenship && !/^\s*(?:u\.?s\.?a?|united states|american)\b/i.test(citizenship)) return true;
+  return null;
+}
+
+export function isNoSponsorshipRequirement(value) {
+  const text = String(value || '');
+  return /(?:\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|\bwithout\s+(?:the\s+need\s+for\s+)?(?:current\s+or\s+future\s+)?(?:employer\s+|visa\s+)?sponsorship\b|\bmust\s+(?:be\s+)?(?:legally\s+)?authoriz\w+\s+to\s+work[^.!?]{0,100}\bwithout\s+(?:current\s+or\s+future\s+)?sponsorship\b|\bsponsorship\s+(?:is\s+)?not\s+(?:available|provided|offered)\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(?:sponsor|support|provide)\b[^\n!?]{0,160}\bsponsorship\b|\bnot\s+(?:currently\s+)?(?:able\s+to\s+)?(?:sponsor|support|provide)\b[^\n!?]{0,160}\bsponsorship\b)/i.test(text);
+}
+
+const REQUIRED_MARKER_RE = /\b(requirements?|qualifications?|minimum qualifications?|required skills?|must[- ]?have|you have|what (?:we|you) (?:are looking for|need|bring)|you(?:'|’)ll need|who you are|ideal candidate|what makes you a fit)\b|требован|квалификац|обязательн|необходим(?:о|ые|ый)|что мы (?:жд[её]м|ожидаем)|кого мы ищем|вимог|кваліфікац|обов['’]?язков|необхідн|кого ми шукаємо/i;
+const OPTIONAL_MARKER_RE = /\b(nice to have|preferred qualifications?|preferred skills?|bonus points?|would be a plus|plus if|desirable)\b|желательн|будет плюсом|буде плюсом|преимуществ|бажан/i;
+const HARD_REQUIREMENT_RE = /\b(must|need to|required|proficien(?:t|cy)|expertise in|experience (?:with|in)|knowledge of|familiarity with|hands[- ]on)\b|обязател|требуется|необходим|знание|опыт (?:с|в)|владение|умение|потрібн|необхідн|досвід (?:з|у|в)|знання/i;
+const NOISE_RE = /\b(equal opportunity|eeo|diversity and inclusion|reasonable accommodation|candidate privacy|privacy notice|background check|recruit(?:ment|ing) process|talent acquisition team|compensation range|pay transparency)\b|процесс найма|процес найму|политик[аи] конфиденциальности|політик[аи] конфіденційності/i;
+const SECTION_BREAK_RE = /\b(what we offer|benefits|perks|about us|about the company|our company|compensation|salary|responsibilities|what you(?:'|’)ll do|your role)\b|что мы предлагаем|условия работы|о компании|про компанію|обязанности|обов['’]?язки/i;
+
+export function bucketVacancyText(value) {
+  const segments = String(value || '').replace(/[•●▪◦·]/g, '. ').split(/\n+|(?<=[.!?;])\s+/).map((part) => part.trim()).filter(Boolean);
+  const buckets = { required: [], optional: [], context: [], noise: [] };
+  let active = null;
+  let ttl = 0;
+  for (const segment of segments) {
+    if (NOISE_RE.test(segment)) { buckets.noise.push(segment); active = null; ttl = 0; continue; }
+    buckets.context.push(segment);
+    if (OPTIONAL_MARKER_RE.test(segment)) { active = 'optional'; ttl = 6; buckets.optional.push(segment); continue; }
+    if (REQUIRED_MARKER_RE.test(segment)) { active = 'required'; ttl = 8; buckets.required.push(segment); continue; }
+    if (SECTION_BREAK_RE.test(segment)) { active = null; ttl = 0; }
+    if (HARD_REQUIREMENT_RE.test(segment)) { buckets.required.push(segment); continue; }
+    if (active && ttl > 0) { buckets[active].push(segment); ttl -= 1; }
+  }
+  return Object.freeze({ required: buckets.required.join(' '), optional: buckets.optional.join(' '), context: buckets.context.join(' '), noise: buckets.noise.join(' ') });
+}
+
+const CV_SECTION_HEADING_RE = /^\s*(profile|professional profile|summary|professional summary|about me|work experience|professional experience|experience|employment|employment history|projects?|pet projects?|hobbies|skills|technical skills|tech stack|education|languages?|contact|additional information)\s*:?[\s]*$/i;
+
+export function classifyCvSectionHeading(value) {
+  const heading = CV_SECTION_HEADING_RE.exec(String(value || '').trim())?.[1];
+  if (!heading) return null;
+  const normalized = heading.toLowerCase();
+  if (/work experience|professional experience|^experience$|employment/.test(normalized)) return 'experience';
+  if (/project|hobbies/.test(normalized)) return 'projects';
+  if (/profile|summary|about me/.test(normalized)) return 'profile';
+  if (/skills|tech stack/.test(normalized)) return 'skills';
+  if (/education/.test(normalized)) return 'education';
+  return 'other';
+}
+
+export function extractCvSection(value, wanted) {
+  const lines = String(value || '').replace(/\r/g, '').split('\n');
+  const collected = [];
+  let section = 'other';
+  let sawHeading = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const nextSection = classifyCvSectionHeading(trimmed);
+    if (nextSection) {
+      section = nextSection;
+      sawHeading = true;
+      continue;
+    }
+    if (section === wanted && trimmed) collected.push(trimmed);
+  }
+  return sawHeading ? collected.join('\n') : '';
+}
+
+function monthIndex(year, month = 1) {
+  return year * 12 + Math.max(1, Math.min(12, month)) - 1;
+}
+
+export function extractCvExperienceYears(value, referenceDate = new Date()) {
+  const raw = String(value || '');
+  const experienceSection = extractCvSection(raw, 'experience');
+  const datedSource = experienceSection || raw;
+  const intervals = [];
+  const ranges = /\b(19\d{2}|20\d{2})(?:[-/.](0?[1-9]|1[0-2]))?\s*(?:-|–|—|to)\s*(?:(present|current|now)|((?:19|20)\d{2})(?:[-/.](0?[1-9]|1[0-2]))?)/gi;
+  for (const match of datedSource.matchAll(ranges)) {
+    const startYear = Number(match[1]);
+    const startMonth = Number(match[2] || 1);
+    const endYear = match[3] ? referenceDate.getFullYear() : Number(match[4]);
+    const endMonth = match[3] ? referenceDate.getMonth() + 1 : Number(match[5] || 12);
+    if (!startYear || !endYear) continue;
+    const start = monthIndex(startYear, startMonth);
+    const end = monthIndex(endYear, endMonth);
+    if (end >= start && end - start <= 12 * 50) intervals.push([start, end]);
+  }
+  intervals.sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const interval of intervals) {
+    const last = merged[merged.length - 1];
+    if (!last || interval[0] > last[1] + 1) merged.push([...interval]);
+    else last[1] = Math.max(last[1], interval[1]);
+  }
+  const datedMonths = merged.reduce((sum, [start, end]) => sum + end - start + 1, 0);
+  const datedYears = datedMonths ? datedMonths / 12 : 0;
+  let explicitYears = 0;
+  const explicit = /\b(?:over|more than|at least|about|approximately|approx\.?|around)?\s*(\d{1,2}(?:[.,]\d)?)\+?\s*(?:years?|yrs?)\s+(?:of\s+)?(?:hands[- ]on\s+|professional\s+|commercial\s+)?experience\b/gi;
+  for (const match of raw.matchAll(explicit)) {
+    const years = Number(match[1]?.replace(',', '.'));
+    if (Number.isFinite(years) && years >= 0 && years <= 50) explicitYears = Math.max(explicitYears, years);
+  }
+  const result = Math.max(datedYears, explicitYears);
+  return result > 0 ? Math.round(result * 10) / 10 : null;
+}

package/src/hiring-salary-context.d.ts

@@ -0,0 +1,27 @@
+export type SalaryCurrencySource = 'explicit' | 'country-default' | 'language-default' | 'unknown';
+
+export interface HiringSalaryContextOptions {
+  country?: string | null;
+  location?: string | null;
+  currencyFallback?: 'country' | 'language';
+}
+
+export interface ParsedHiringSalaryWithContext {
+  min: number | null;
+  max: number | null;
+  currency: string | null;
+  period: string | null;
+  negotiable: boolean;
+  gross: boolean | null;
+  approximate: boolean;
+  currencySource: SalaryCurrencySource;
+  currencyCountry: string | null;
+  [key: string]: unknown;
+}
+
+export const COUNTRY_DEFAULT_CURRENCIES: Readonly<Record<string, string>>;
+export function defaultCurrencyForCountry(value: unknown): string | null;
+export function parseHiringSalaryWithContext(
+  value: unknown,
+  options?: HiringSalaryContextOptions,
+): ParsedHiringSalaryWithContext | null;

package/src/hiring-salary-context.js

@@ -0,0 +1,76 @@
+import { detectCountryCodeFromText } from './geography-detection.js';
+import { parseSalary } from './money.js';
+
+/**
+ * Default local currencies used only as an opt-in fallback when salary text
+ * contains an amount but no explicit currency. Explicit currency always wins.
+ */
+export const COUNTRY_DEFAULT_CURRENCIES = Object.freeze({
+  US: 'USD',
+  GB: 'GBP',
+  UA: 'UAH',
+  UZ: 'UZS',
+  KZ: 'KZT',
+  KG: 'KGS',
+  RO: 'RON',
+  PL: 'PLN',
+  TR: 'TRY',
+  GE: 'GEL',
+});
+
+export function defaultCurrencyForCountry(value) {
+  const country = detectCountryCodeFromText(value);
+  return country ? COUNTRY_DEFAULT_CURRENCIES[country] || null : null;
+}
+
+function contextCountry(options) {
+  return detectCountryCodeFromText(options.country)
+    || detectCountryCodeFromText(options.location)
+    || null;
+}
+
+function languageDefaultCountry(value) {
+  const text = String(value || '');
+  // Use only language signals that are specific enough to avoid turning generic
+  // Russian/English salary text into a local currency guess. Uzbek and Kazakh
+  // salary/period vocabulary is deterministic enough for this fallback.
+  if (/(?:^|[^\p{L}\p{N}])(?:oylik|oyiga|maosh|ish\s+haqi|ойлик|ойига|маош|иш\s+ҳақи)(?=$|[^\p{L}\p{N}])/iu.test(text)) return 'UZ';
+  if (/(?:^|[^\p{L}\p{N}])(?:жалақы|еңбекақы|айлық|айына)(?=$|[^\p{L}\p{N}])/iu.test(text)) return 'KZ';
+  return null;
+}
+
+/**
+ * Parse salary text and optionally infer a missing currency from geography or
+ * unambiguous local salary-language markers.
+ *
+ * The fallback is deliberately opt-in. A bare number must never silently become
+ * USD merely because a consumer happens to normalize all salaries to USD later.
+ * Provenance is returned in `currencySource` so consumers can distinguish an
+ * explicit currency from a contextual fallback.
+ */
+export function parseHiringSalaryWithContext(value, options = {}) {
+  const parsed = parseSalary(value);
+  if (!parsed) return null;
+
+  if (parsed.currency) {
+    return Object.freeze({
+      ...parsed,
+      currencySource: 'explicit',
+      currencyCountry: null,
+    });
+  }
+
+  let country = null;
+  if (options.currencyFallback === 'country') country = contextCountry(options);
+  else if (options.currencyFallback === 'language') country = languageDefaultCountry(value);
+
+  const currency = country ? COUNTRY_DEFAULT_CURRENCIES[country] || null : null;
+  return Object.freeze({
+    ...parsed,
+    currency,
+    currencySource: currency
+      ? options.currencyFallback === 'language' ? 'language-default' : 'country-default'
+      : 'unknown',
+    currencyCountry: currency ? country : null,
+  });
+}

package/src/hiring-semantics.d.ts

@@ -0,0 +1,29 @@
+import type { DegreeLevel } from './hiring-requirements.js';
+
+export type CandidateFeatureCode = 'student' | 'parentalLeave' | 'noExperience' | 'partTime' | 'nightShift' | 'openToRelocation';
+export type HiringScopeCode = 'architecture' | 'leadership' | 'mentoring' | 'scale' | 'ownership';
+
+export function isCandidateNonTargetContext(value: unknown): boolean;
+export function extractCandidateTargetContext(value: unknown): string;
+export function extractCandidateSkillField(value: unknown): string | null;
+export function extractCandidateRoleField(value: unknown): string | null;
+export function extractCandidateGoalField(value: unknown): string | null;
+export function extractCandidateLocationField(value: unknown): string | null;
+export function isCandidateStatusOnly(value: unknown): boolean;
+export function isFlexibleCandidateRole(value: unknown): boolean;
+export function isCandidateNonRoleValue(value: unknown): boolean;
+export function extractCandidateGoalRole(value: unknown): string | null;
+export function extractCandidateWorkHistory(value: unknown): string;
+export function detectCandidateFeatureCodes(value: unknown): readonly CandidateFeatureCode[];
+export function extractCandidateContactHours(value: unknown): string | null;
+export function extractCandidateSalaryField(value: unknown): string | null;
+export function detectCandidateRelocationPreference(value: unknown): boolean | null;
+export function detectCandidateRemotePreference(value: unknown): boolean | null;
+export function detectCandidateProfessionLabels(targetValue: unknown, skillValue?: unknown): readonly string[];
+export function detectManagementRole(title: unknown, value?: unknown): true | null;
+export function detectHiringScopeSignals(value: unknown, options?: { mode?: 'vacancy' | 'candidate' }): readonly HiringScopeCode[];
+export function detectDegreeRequirement(value: unknown): Readonly<{
+  level?: DegreeLevel;
+  field?: string;
+  equivalentExperience: boolean;
+}>;

package/src/hiring-semantics.js

@@ -0,0 +1,218 @@
+import { detectDegreeFields, detectDegreeLevel } from './hiring-requirements.js';
+import { matchExtendedProfessions } from './hiring-source-aliases.js';
+
+const NON_TARGET_CONTEXT_RE = /(?:опыт\s+работы|досвід\s+роботи|work\s+experience|previous|раньше|ранее|прежде|работал|работала|працював|працювала|worked\s+(?:as|at)|oldin|avval|ishlagan|ishladim|tajriba|диплом|diplom|mutaxassisligim)/iu;
+const TARGET_CONTEXT_RE = /(?:ищу\s+(?:работу|подработку)|шукаю\s+(?:роботу|підробіток)|желаемая\s+(?:должность|работа)|бажана\s+(?:посада|робота)|target\s+role|desired\s+(?:role|position)|looking\s+for\s+(?:a\s+)?(?:job|work)|open\s+to\s+work|menga\s+ish\s+kerak|ish\s+(?:kerak|qidiryapman|qidiraman|izlayapman)|ish\s+joyi\s+kerak|lavozim|kasb|soha|soxa|maqsad(?:im)?)/iu;
+
+const SKILLS_FIELD_RE = /(?:^|\n)[^\p{L}\p{N}\n]{0,10}(?:skills|навыки|навички|стек|stack|technologies|texnologiya(?:lar)?|ko(?:'|’)nikmalar)\s*[:—-]\s*([^\n]{2,500})/iu;
+const WORK_HISTORY_BLOCK_RE = /(?:^|\n)\s*(?:опыт\s+работы|досвід\s+роботи|work\s+experience|previous\s+(?:jobs?|positions?)|tajriba|ish\s+tajribasi)\s*[:—-]?\s*([\s\S]{1,2600}?)(?=\n\s*(?:навыки|навички|skills|образование|освіта|education|контакт|contact|ожидания|salary|языки|мови|languages)\s*[:—-]|$)/iu;
+const WORK_HISTORY_LINE_RE = /(?:работал[аи]?|працюва(?:в|ла)|worked\s+(?:as|at)|oldin|avval|ishlagan|ishladim|ishlaganman|tajriba(?:m)?\s+bor)/iu;
+const GOAL_ROLE_RE = /\b((?:(?:frontend|front-end|backend|back-end|full[- ]?stack|mobile|android|ios)\s+)?(?:dasturchi|developer|programmer))\s+sifatida\s+(?:ish\s+(?:topish|qidirish|izlash)|ishlash)\b/iu;
+const CONTACT_HOURS_RE = /(?:^|\n)[^\p{L}\p{N}\n]{0,10}(?:murojaat\s+qilish\s+vaqti|aloqa\s+vaqti|qo(?:'|’)ng(?:'|’)iroq\s+vaqti|bog(?:'|’)lanish\s+vaqti|время\s+(?:связи|звонков|для\s+связи)|звонить\s+(?:с|в)|contact\s+(?:hours|time)|call\s+time)\s*[:—-]?\s*([^\n]{3,60})/iu;
+const SALARY_FIELD_RE = /(?:^|\n)[^\p{L}\p{N}\n]{0,10}(?:narxi?|salary|expected\s+salary|зарплата|зп|бажана\s+зарплата|oylik|maosh|ish\s+haqi)\s*[:—-]\s*([^\n]{1,120})/iu;
+const ROLE_FIELD_RE = /(?:^|\n)[^\p{L}\p{N}\n]{0,8}(?:желаемая\s+(?:работа|должность)|бажана\s+(?:робота|посада)|target\s+role|desired\s+(?:role|position)|position|role|должность|посада|lavozim|kasbi|kasb|qidirayotgan\s+kasb|so(?:'|’)ralgan\s+ish\s+turi)\s*[:：—-]\s*([^\n]{1,220})/iu;
+const GOAL_FIELD_RE = /(?:^|\n)[^\p{L}\p{N}\n]{0,8}(?:maqsad|мақсад|goal|цель|мета)\s*[:：—-]\s*([^\n]{1,220})/iu;
+const LOCATION_FIELD_RE = /(?:^|\n)[^\p{L}\p{N}\n]{0,8}(?:location|локация|локація|country|страна|країна)\s*[:：—-]\s*([^\n]{1,220})/iu;
+const LOCATION_COMPACT_RE = /(?:^|\n)[^\p{L}\p{N}\n]{0,8}(?:location|локация|локація|country|страна|країна)\s+(#?[\p{L}][^\n]{0,120})/iu;
+
+const STATUS_ONLY_RE = /^(?:talaba|student|студент(?:ка)?|студент(?:ка)?ка|o(?:'|’)quvchi|учащ(?:ийся|аяся))$/iu;
+const FLEXIBLE_ROLE_RE = /^(?:нет|без)\s+разницы(?:\s+.*)?$|^не\s*важно(?:\s+.*)?$|^farqi\s+yo['’ʻʼ‘`]?q$|^любая\s+(?:работа|занятость)(?:\s+.*)?$/iu;
+const NON_ROLE_RE = /^(?:удал[её]нно|работа\s+на\s+удал[её]н\p{L}*\s+основе|remote|onlayn|online|онлайн|farqi\s+yo['’ʻʼ‘`]?q|bilmaym\p{L}*|ish\s+ker(?:e|a)\s+onlayn|любая\s+(?:работа|занятость)|немає|нет|не\s+указано|not\s+specified)$/iu;
+const REMOTE_NEGATIVE_RE = /(?:onsite|on-site|office\s+only|тільки\s+офіс|только\s+офис|офисн(?:ый|ая)\s+формат|офлайн|без\s+удал[её]нк|удал[её]нк\p{L}*\s+не\s+рассматрива|не\s+рассматрива\p{L}*\s+удал[её]н|remote\s+(?:not|no)|faqat\s+ofis|ofisda\s+ish(?:lash)?)/iu;
+const REMOTE_POSITIVE_RE = /(?:\bremote\b|\bremotely\b|удал[её]н(?:но|ка|ный|ная|н\p{L}*)?|віддален(?:о|а|ий)?|дистанц(?:ионно|ійно)|masofaviy|(?<!\p{L})onlayn(?!\p{L})|online\s+(?:work|job)|онлайн\s+работ)/iu;
+
+const FEATURE_RULES = Object.freeze([
+  ['student', /\bstudent\b|студент|студентк|talaba/iu],
+  ['parentalLeave', /декрет|в\s+декрете|у\s+декреті|maternity\s+leave|parental\s+leave/iu],
+  ['noExperience', /без\s+опыта|без\s+досвіду|no\s+experience|tajriba\s+yo(?:'|’)q/iu],
+  ['partTime', /подработк|підробіт|part[-\s]?time|неполный\s+день|неповн(?:ий|а)\s+день|yarim\s+stavka/iu],
+  ['nightShift', /ночн(?:ая|ую|ой)\s+смен|нічн(?:а|у|ої)\s+змін|night\s+shift|tungi\s+smena/iu],
+  ['openToRelocation', /готов\p{L}*\s+к\s+переезду|готов\p{L}*\s+переехать|готов\p{L}*\s+до\s+переїзду|relocat(?:e|ion)|ko(?:'|’)chib\s+o(?:'|’)tish/iu],
+]);
+
+const RELOCATION_NEGATIVE_RE = /не\s+готов\p{L}*\s+к\s+переезду|не\s+розгляда\p{L}*\s+переїзд|not\s+(?:open|ready)\s+to\s+relocat/iu;
+const RELOCATION_POSITIVE_RE = /готов\p{L}*\s+к\s+переезду|готов\p{L}*\s+переехать|готов\p{L}*\s+до\s+переїзду|relocat(?:e|ion)|ko(?:'|’)chib\s+o(?:'|’)tish/iu;
+
+const SPECIAL_CANDIDATE_PROFESSIONS = Object.freeze([
+  ['HR / Recruiter', /#(?:hr|hrd|hrbp|hrgeneralist|peopleops)\b|\b(?:hr\s+lead|head\s+of\s+hr|people\s+partner|talent\s+operations|кадров\p{L}*\s+аудит)\b/iu],
+  ['Sales Manager', /(?:sotuv|savdo)\s+(?:menejer|menejr|menedjer|manager)|\bsales\s+manager\b|менеджер\s+(?:по\s+)?продаж|менеджер\s+з\s+продаж/iu],
+  ['Backend Developer', /\bbackend\s+(?:developer|engineer)\b|\bback[- ]?end\s+(?:developer|engineer)\b|backend\s+dasturchi|серверн(?:ый|ий)\s+разработчик/iu],
+  ['Frontend Developer', /\bfrontend\s+(?:developer|engineer)\b|\bfront[- ]?end\s+(?:developer|engineer)\b|frontend\s+dasturchi/iu],
+  ['AI / ML Engineer', /\b(?:ai|artificial\s+intelligence|machine\s+learning|ml)\s*(?:\/\s*(?:ai|ml))?\s*(?:engineer|developer)\b|\b(?:engineer|developer)\s+(?:ai|ml|machine\s+learning)\b/iu],
+  ['Penetration Tester', /\b(?:penetration\s+tester|penetration\s+testing|pentest(?:er|ing)?)\b|пентест(?:ер|инг)?/iu],
+  ['Network Administrator', /\b(?:network\s+administrator|network\s+admin)\b|(?:tarmoq|тармоқ)[^\n]{0,70}(?:administrator|admin(?:strator)?i?|администратор)/iu],
+  ['System Administrator', /\b(?:system\s+administrator|system\s+admin|sysadmin)\b|(?:tizim|тизим)[^\n]{0,50}(?:administrator|admin(?:strator)?i?|администратор)|системн(?:ый|ий)\s+администратор/iu],
+  ['Cybersecurity Specialist', /\b(?:cybersecurity|cyber\s+security|information\s+security)\b|кибербезопасност|кібербезпек|информационн(?:ая|ой)\s+безопасност|інформаційн(?:а|ої)\s+безпек|axborot\s+xavfsizligi/iu],
+  ['Data Scientist', /\bdata\s+scientist\b|\bdata\s+science\b|дата\s+саентист/iu],
+  ['Data Engineer', /\bdata\s+engineer\b|инженер\s+данных|інженер\s+даних/iu],
+]);
+
+const SCOPE_SIGNALS = Object.freeze([
+  Object.freeze({
+    code: 'architecture',
+    vacancy: /\barchitect(?:ure|ing)?\b|\bsystem design\b|\btechnical roadmap\b|\blong[- ]term solutions?\b/i,
+    candidate: /\barchitect(?:ed|ure|ing)?\b|\bsystem design\b|\btechnical roadmap\b|\bsolution architecture\b/i,
+  }),
+  Object.freeze({
+    code: 'leadership',
+    vacancy: /\btechnical leader(?:ship)?\b|\bengineering standards\b|\bdrive product vision\b|\blead technical\b/i,
+    candidate: /\btechnical leader(?:ship)?\b|\bengineering standards\b|\bled\s+(?:a\s+)?(?:team|project|initiative)\b|\btech(?:nical)? lead\b/i,
+  }),
+  Object.freeze({
+    code: 'mentoring',
+    vacancy: /\bmentor(?:ing|ed)?\s+(?:other\s+)?(?:engineers?|developers?|team members?)\b|\bcoach(?:ing|ed)?\s+(?:engineers?|developers?)\b/i,
+    candidate: /\bmentor(?:ing|ed)?\s+(?:other\s+)?(?:engineers?|developers?|team members?)\b|\bcoach(?:ing|ed)?\s+(?:engineers?|developers?)\b/i,
+  }),
+  Object.freeze({
+    code: 'scale',
+    vacancy: /\b(?:millions?|billions?)\s+of\s+(?:users|people|requests|events)\b|\bat scale\b|\bhigh[- ]scale\b|\blarge[- ]scale\b/i,
+    candidate: /\b(?:millions?|billions?)\s+of\s+(?:users|requests|events)\b|\bat scale\b|\bhigh[- ]scale\b|\blarge[- ]scale\b|\bhigh[- ]traffic\b/i,
+  }),
+  Object.freeze({
+    code: 'ownership',
+    vacancy: /\bown\s+(?:critical\s+)?(?:features?|systems?|services?|roadmap)\b|\bproduct owner\b|\bdrive product\b/i,
+    candidate: /\bown(?:ed|ership)?\s+(?:features?|systems?|services?|roadmap|product)\b|\bproduct owner\b|\bdrove\s+(?:a\s+)?(?:feature|product|initiative)\b/i,
+  }),
+]);
+
+const fieldValue = (value, re) => String(value || '').match(re)?.[1]?.trim() || null;
+
+export function isCandidateNonTargetContext(value) {
+  return NON_TARGET_CONTEXT_RE.test(String(value || ''));
+}
+
+export function extractCandidateTargetContext(value) {
+  const lines = String(value || '').split('\n').map((line) => line.trim()).filter(Boolean);
+  const picked = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    if (!TARGET_CONTEXT_RE.test(lines[i])) continue;
+    for (let offset = 0; offset < 3 && i + offset < lines.length; offset += 1) {
+      const line = lines[i + offset];
+      if (offset > 0 && NON_TARGET_CONTEXT_RE.test(line)) break;
+      picked.push(line);
+    }
+  }
+  return picked.join('\n');
+}
+
+export function extractCandidateSkillField(value) {
+  return fieldValue(value, SKILLS_FIELD_RE);
+}
+
+export function extractCandidateRoleField(value) {
+  return fieldValue(value, ROLE_FIELD_RE);
+}
+
+export function extractCandidateGoalField(value) {
+  return fieldValue(value, GOAL_FIELD_RE);
+}
+
+export function extractCandidateLocationField(value) {
+  return fieldValue(value, LOCATION_FIELD_RE) || fieldValue(value, LOCATION_COMPACT_RE);
+}
+
+export function isCandidateStatusOnly(value) {
+  return STATUS_ONLY_RE.test(String(value || '').trim());
+}
+
+export function isFlexibleCandidateRole(value) {
+  return FLEXIBLE_ROLE_RE.test(String(value || '').trim());
+}
+
+export function isCandidateNonRoleValue(value) {
+  return NON_ROLE_RE.test(String(value || '').trim());
+}
+
+export function extractCandidateGoalRole(value) {
+  return String(value || '').match(GOAL_ROLE_RE)?.[1]?.trim() || null;
+}
+
+export function extractCandidateWorkHistory(value) {
+  const text = String(value || '');
+  const explicit = text.match(WORK_HISTORY_BLOCK_RE)?.[1];
+  if (explicit) return explicit;
+  return text.split(/\n|(?<=[.!?])\s+/u).filter((line) => WORK_HISTORY_LINE_RE.test(line)).join('\n');
+}
+
+export function detectCandidateFeatureCodes(value) {
+  const text = String(value || '');
+  return Object.freeze(FEATURE_RULES.filter(([, re]) => re.test(text)).map(([code]) => code));
+}
+
+export function extractCandidateContactHours(value) {
+  const raw = String(value || '').match(CONTACT_HOURS_RE)?.[1];
+  if (!raw) return null;
+  const cleaned = raw.replace(/\s{2,}/g, ' ').replace(/[.;,]+$/, '').trim();
+  return /\b24\s*\/\s*7\b|\d{1,2}[:.]\d{2}|\d{1,2}\s*[-–—]\s*\d{1,2}/.test(cleaned)
+    ? cleaned.slice(0, 60)
+    : null;
+}
+
+export function extractCandidateSalaryField(value) {
+  return fieldValue(value, SALARY_FIELD_RE);
+}
+
+export function detectCandidateRelocationPreference(value) {
+  const text = String(value || '');
+  if (RELOCATION_NEGATIVE_RE.test(text)) return false;
+  if (RELOCATION_POSITIVE_RE.test(text)) return true;
+  return null;
+}
+
+export function detectCandidateRemotePreference(value) {
+  const text = String(value || '');
+  if (REMOTE_NEGATIVE_RE.test(text)) return false;
+  if (REMOTE_POSITIVE_RE.test(text)) return true;
+  return null;
+}
+
+export function detectCandidateProfessionLabels(targetValue, skillValue = '') {
+  const target = String(targetValue || '');
+  const special = SPECIAL_CANDIDATE_PROFESSIONS
+    .filter(([, re]) => re.test(target))
+    .map(([label]) => label);
+  if (special.length) return Object.freeze([...new Set(special)]);
+
+  const matched = matchExtendedProfessions(target, { limit: 8, allowWeak: true }).map((item) => item.label);
+  if (matched.length) return Object.freeze([...new Set(matched)]);
+
+  const skills = String(skillValue || '');
+  if (!skills) return Object.freeze([]);
+  if (/\bflutter\b|\bdart\b/iu.test(skills)) return Object.freeze(['Mobile Developer']);
+
+  const sysadminBase = /\bcisco\b/iu.test(skills)
+    && /\b(?:linux|windows\s+server|active\s+directory|network(?:ing)?)\b/iu.test(skills);
+  const specializedTools = /\b(?:devops|sre|docker|kubernetes|k8s|terraform|ansible|jenkins|gitlab\s+ci|github\s+actions|ci\/?cd|aws|azure|gcp|ai|ml|mlops|artificial\s+intelligence|machine\s+learning|deep\s+learning|data\s+scien(?:ce|tist)|tensorflow|pytorch|scikit[- ]?learn|llm|langchain|developer|software\s+engineer|programmer|разработчик|программист|react|angular|vue(?:\.js)?|next(?:\.js)?|node(?:\.js)?|django|laravel|spring\s+boot|asp\.net)\b/iu.test(skills);
+  if (sysadminBase && !specializedTools) return Object.freeze(['System Administrator']);
+
+  const strongDeveloperSkill = /\b(?:react|vue\.?\s*js|angular|node\.?\s*js|next\.?\s*js|django|laravel|fastapi|flask|spring|asp\.?net|ruby\s+on\s+rails)\b/iu.test(skills);
+  const softwareSignals = (skills.match(/\b(?:python|java(?:script)?|typescript|php|react|vue\.?\s*js|angular|node\.?\s*js|next\.?\s*js|django|laravel|fastapi|flask|spring|asp\.?net|sql|html|css|c\+\+|c#|golang)\b/giu) || []).length;
+  return strongDeveloperSkill || softwareSignals >= 2
+    ? Object.freeze(['Software Developer'])
+    : Object.freeze([]);
+}
+
+export function detectManagementRole(title, value = '') {
+  const heading = String(title || '');
+  const text = String(value || '');
+  if (/\b(?:head|director|chief|manager|supervisor|team\s*lead|tech\s*lead)\b|руководител|начальник|директор|тимлид|заведующ/i.test(heading)) return true;
+  if (/manage(?:s|ment|ing)?\s+(?:a\s+)?(?:team|people|staff)|people management|direct reports|руковод(?:ить|ство)\s+(?:команд|сотруд)|управлени[ея]\s+(?:команд|персонал)/i.test(text)) return true;
+  return null;
+}
+
+export function detectHiringScopeSignals(value, options = {}) {
+  const mode = options.mode === 'candidate' ? 'candidate' : 'vacancy';
+  const text = String(value || '');
+  return Object.freeze(SCOPE_SIGNALS.filter((signal) => signal[mode].test(text)).map((signal) => signal.code));
+}
+
+export function detectDegreeRequirement(value) {
+  const text = String(value || '');
+  const level = detectDegreeLevel(text) || undefined;
+  const fields = detectDegreeFields(text);
+  let field;
+  if (fields.includes('computer_science')) field = 'computer_science';
+  else if (fields.includes('engineering') && /\bengineering\b[^.;\n]{0,60}\bdegree\b|\bdegree\b[^.;\n]{0,60}\bengineering\b/i.test(text)) field = 'engineering';
+  const equivalentExperience = /equivalent\s+(?:professional\s+|work\s+)?experience|or\s+equivalent\s+experience/i.test(text);
+  return Object.freeze({ level, field, equivalentExperience });
+}

package/src/hiring-skills.d.ts

@@ -0,0 +1,21 @@
+export interface SkillMeta {
+  category: string;
+  subcategory: string;
+}
+export interface SkillDefinition extends SkillMeta {
+  name: string;
+  aliases: string[];
+}
+export interface SkillDetail extends SkillMeta {
+  name: string;
+}
+export const SKILL_CATALOG: SkillDefinition[];
+export const SKILL_KEYWORDS: Readonly<Record<string, readonly string[]>>;
+export const SKILL_META: Readonly<Record<string, SkillMeta>>;
+export function normalizeSkillText(value: string): string;
+export function escapeRegex(value: string): string;
+export function buildSkillRegex(alias: string): RegExp;
+export function canonicalSkillName(value: string): string | undefined;
+export function extractSkillDetails(text: string): SkillDetail[];
+export function extractSkillNames(text: string): string[];
+export function getSkillMeta(name: string): SkillMeta | undefined;