@pranavraut033/ats-checker 1.2.0 → 1.3.2

package/README.md

@@ -17,7 +17,13 @@ Zero-dependency TypeScript library that scores a resume against a job descriptio
 
 - **Deterministic** — same input always produces the same score; pin it with `referenceDate` to freeze "Present" date math
 - **Explainable** — breakdown by category (skills / experience / keywords / education) plus matched and missing skill/keyword lists
-- **Configurable** — adjust weights, add skill aliases, define custom penalty rules
+- **Categorized keywords** — every keyword/alias belongs to a category (technical, tool, concept, soft, marketing, domain); results are grouped by category
+- **Weighted keyword scoring** — JD keywords are weighted by where they appear (required > preferred > body) and how often, so a missing "required" keyword costs more than a missing body-only one
+- **Alias-aware suggestions** — flags resume terms that should be reworded to match the JD's own wording (e.g. "js" → "JavaScript")
+- **Achievement strength** — classifies resume experience bullets as strong/weak (verb + quantified impact) and suggests rewrites
+- **Multi-language keyword packs** — `/en` and `/de` subpaths ship categorized keyword registries; install more by passing your own `keywordRegistry`
+- **Language proficiency matching** — detects spoken-language requirements in the JD (CEFR `A1`–`C2` or words like "fluent"/"native") and flags resume gaps below the required level
+- **Configurable** — adjust weights, add skill aliases or a custom keyword registry, define custom penalty rules
 - **Zero dependencies** — core library has no runtime deps; ships ESM + CJS
 - **PDF input** — optional `/pdf` subpath extracts resume text from a PDF buffer (requires `pdfjs-dist` peer dep)
 - **Built-in profiles** — software engineer, data scientist, product manager out of the box
@@ -46,9 +52,12 @@ import { analyzeResume } from "@pranavraut033/ats-checker";
 const result = analyzeResume({
   resumeText: `
     Software Engineer with 5 years of experience.
-    Skills: JavaScript, TypeScript, React, Node.js, SQL
-    Experience: Senior Engineer at ExampleCorp (Jan 2020 - Present)
-    Education: B.S. Computer Science
+    Skills
+    JavaScript, TypeScript, React, Node.js, SQL
+    Experience
+    Senior Engineer at ExampleCorp (Jan 2020 - Present)
+    Education
+    B.S. Computer Science
   `,
   jobDescription: `
     Frontend engineer role. Must have React, TypeScript, accessibility best practices.
@@ -57,11 +66,11 @@ const result = analyzeResume({
   config: { referenceDate: "2026-01-01" }, // freeze clock for reproducible scores
 });
 
-console.log(result.score);            // e.g. 72.45
+console.log(result.score);            // 44.44
 console.log(result.matchedSkills);    // ["javascript", "node", "react", "typescript"]
-console.log(result.missingSkills);    // ["accessibility best practices", "graphql"]
+console.log(result.missingSkills);    // ["accessibility", "frontend", "graphql"]
 console.log(result.experienceGap);    // 0 (requirement met)
-console.log(result.suggestions);      // ["Add GraphQL to your skills section", ...]
+console.log(result.suggestions);      // ["Highlight these required skills: accessibility, frontend, graphql", ...]
 ```
 
 ---
@@ -79,6 +88,11 @@ console.log(result.suggestions);      // ["Add GraphQL to your skills section",
 | `matchedKeywords` | `string[]` | JD keywords present in the resume (sorted) |
 | `missingKeywords` | `string[]` | JD keywords absent from the resume (sorted) |
 | `overusedKeywords` | `string[]` | Keywords exceeding density threshold (sorted) |
+| `keywordsByCategory` | `Record<KeywordCategory, {matched, missing}>` | Matched/missing keywords grouped by category |
+| `keywordWeights` | `KeywordWeight[]` | Per-keyword JD importance (`jdWeight`) and resume usage (`resumeWeight`) |
+| `achievementStrength` | `{ strong: number; weak: number }` | Count of resume bullets classified as strong vs weak achievement statements |
+| `matchedLanguages` | `ParsedLanguage[]` | JD-required languages the resume meets or exceeds in proficiency |
+| `missingLanguages` | `ParsedLanguage[]` | JD-required languages absent or below the required proficiency |
 | `suggestions` | `string[]` | Deterministic improvement recommendations |
 | `warnings` | `string[]` | Parse warnings and section alerts |
 | `experienceGap` | `number` | Years below JD minimum; `0` when met |
@@ -89,6 +103,12 @@ console.log(result.suggestions);      // ["Add GraphQL to your skills section",
 **Scoring formula:**  
 `score = skills×0.30 + experience×0.30 + keywords×0.25 + education×0.15` → clamped to 0–100 → rule penalties subtracted.
 
+The `keywords` sub-score is a **weighted** coverage ratio, not a flat count: each JD keyword gets a weight from its location (required > preferred > body text) and frequency, so missing a required keyword drops the score more than missing one mentioned once in the body.
+
+> **Caveat — malformed/copy-pasted JD text:** required/preferred detection scans each line for literal trigger phrases (`required`, `must`, `nice to have`, `preferred`). Job postings copy-pasted from a wrapped/columned source sometimes split words across line breaks (e.g. `"Nice to\n\nhaveExperience..."`), which breaks these phrases across two lines and silently drops them into the unweighted body-keyword bucket instead of required/preferred. Skill keywords themselves (e.g. `react`, `python/fastapi`) are still picked up via the whole-text token scan and unaffected. If a JD looks oddly broken, paste it through a plain-text cleanup pass first, or expect required/preferred weighting to under-count.
+
+The `education` sub-score normalizes degree abbreviations on both sides to a canonical level (`bachelor`, `master`, `phd`, `mba`, `associate`) before comparing — so a resume listing "B.S. Computer Science" satisfies a JD requiring "Bachelor's degree".
+
 ---
 
 ## Configuration
@@ -106,6 +126,9 @@ const result = analyzeResume({
     // Additional skill synonyms merged over built-in defaults
     skillAliases: { javascript: ["js", "ecmascript"] },
 
+    // Categorized keyword/alias entries; merges over the default registry by canonical term
+    keywordRegistry: [{ canonical: "rust", aliases: ["rustlang"], category: "technical" }],
+
     // Industry profile: sets mandatory/optional skills and minExperience
     profile: {
       mandatorySkills: ["javascript", "react"],
@@ -156,15 +179,69 @@ See [Configuration docs](https://pranavraut033.github.io/ats-checker/docs/config
 
 ---
 
-## Built-in Skill Aliases
+## Keyword Registry, Categories & Aliases
 
-Common tech synonyms are pre-loaded so `js` matches `javascript`, `k8s` matches `kubernetes`, etc. Extend or override via `config.skillAliases`.
+Every built-in keyword/skill belongs to a `KeywordRegistry` entry — a canonical term, its aliases, and a category (`technical` | `tool` | `concept` | `soft` | `marketing` | `domain`). Common tech synonyms are pre-loaded so `js` matches `javascript`, `k8s` matches `kubernetes`, etc.
 
 ```typescript
-import { defaultSkillAliases } from "@pranavraut033/ats-checker";
-// { javascript: ["js"], node: ["node.js", "nodejs"], typescript: ["ts"], ... }
+import { defaultKeywordRegistry, defaultSkillAliases } from "@pranavraut033/ats-checker";
+// defaultKeywordRegistry: [{ canonical: "javascript", aliases: ["js"], category: "technical" }, ...]
+// defaultSkillAliases: { javascript: ["js"], node: ["node.js", "nodejs"], ... }  (derived, back-compat)
 ```
 
+Extend or override the registry via `config.keywordRegistry` — entries merge over the defaults by canonical term:
+
+```typescript
+const result = analyzeResume({
+  resumeText: "...",
+  jobDescription: "...",
+  config: {
+    keywordRegistry: [
+      { canonical: "rust", aliases: ["rustlang"], category: "technical" },
+      { canonical: "javascript", aliases: ["js", "ecmascript"], category: "technical" }, // overrides default
+    ],
+  },
+});
+
+console.log(result.keywordsByCategory.technical); // { matched: [...], missing: [...] }
+console.log(result.keywordWeights);                // [{ term, category, jdWeight, resumeWeight, importance }, ...]
+```
+
+You can still pass `config.skillAliases` for a flat override — it merges on top of the registry-derived aliases.
+
+## Multi-language Keyword Packs
+
+Categorized keyword registries ship as installable subpaths, one per language. Canonical terms stay in English (so scoring/profiles keep working); the pack supplies localized aliases.
+
+```typescript
+import de from "@pranavraut033/ats-checker/de";
+import { analyzeResume } from "@pranavraut033/ats-checker";
+
+const result = analyzeResume({
+  resumeText: "...", // e.g. a German-language resume
+  jobDescription: "...",
+  config: { keywordRegistry: de },
+});
+```
+
+Available packs: `/en` (the default registry) and `/de` (seed set — grows on demand). Each default-exports a `KeywordRegistry`.
+
+## Language Requirements
+
+The JD parser scans for spoken-language mentions — CEFR codes (`A1`–`C2`) or descriptive words (`basic`, `conversational`, `professional`, `fluent`, `native`) — and the resume parser does the same. Any language found in the JD is treated as required; the resume must mention it at an equal or higher level to count as matched.
+
+```typescript
+const result = analyzeResume({
+  resumeText: "Languages: German (C1), English (native)",
+  jobDescription: "German (B2) required for this role.",
+});
+
+console.log(result.matchedLanguages); // [{ name: "german", level: "b2", levelRank: 4 }]
+console.log(result.missingLanguages); // []
+```
+
+A missing or under-leveled language surfaces both in `result.missingLanguages` and as a suggestion (`"Mention your proficiency in: german (b2)"`). This is informational/suggestion-only — it does not change `score` or `breakdown`.
+
 ---
 
 ## Built-in Profiles
@@ -218,6 +295,23 @@ if (result.warnings.length) {
 }
 ```
 
+### OCR fallback for scanned PDFs
+
+`extractTextFromPDF` accepts an optional `ocrFallback` that's only invoked when the text layer comes back too short (default threshold: 100 chars). The OCR engine and its dependency are entirely your choice — the core library never bundles one:
+
+```typescript
+const resumeText = await extractTextFromPDF(bytes, {
+  ocrFallback: async (data) => {
+    // bring your own OCR engine, e.g. tesseract.js or a cloud OCR API
+    const { recognize } = await import("tesseract.js");
+    const { data: { text } } = await recognize(data, "eng");
+    return text;
+  },
+});
+```
+
+If `ocrFallback` throws or returns text that isn't longer than the text-layer result, `extractTextFromPDF` silently keeps the original result — OCR failures never break the deterministic extraction path.
+
 ---
 
 ## LLM Integration (deprecated)

package/dist/chunk-ZJ5E4H7Z.mjs

@@ -0,0 +1,446 @@
+// src/utils/text.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  // articles / prepositions / conjunctions
+  "the",
+  "and",
+  "or",
+  "a",
+  "an",
+  "of",
+  "for",
+  "to",
+  "with",
+  "in",
+  "on",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "onto",
+  "upon",
+  "via",
+  "per",
+  "plus",
+  // verbs / modals
+  "is",
+  "are",
+  "be",
+  "was",
+  "were",
+  "will",
+  "can",
+  "should",
+  "must",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "get",
+  "give",
+  "go",
+  "use",
+  "see",
+  "help",
+  "work",
+  "build",
+  "show",
+  "need",
+  "want",
+  "make",
+  "let",
+  // pronouns / determiners
+  "it",
+  "its",
+  "this",
+  "that",
+  "these",
+  "those",
+  "we",
+  "our",
+  "you",
+  "your",
+  "they",
+  "their",
+  "us",
+  "who",
+  "what",
+  "which",
+  "how",
+  // common English fillers that leak into JDs
+  "no",
+  "not",
+  "all",
+  "any",
+  "also",
+  "more",
+  "well",
+  "very",
+  "highly",
+  "across",
+  "over",
+  "under",
+  "within",
+  "about",
+  "out",
+  "up",
+  "down",
+  "new",
+  "if",
+  "so",
+  "such",
+  "both",
+  "each",
+  "one",
+  "many",
+  "only",
+  // JD/HR boilerplate — never skills
+  "years",
+  "year",
+  "experience",
+  "required",
+  "requirement",
+  "requirements",
+  "preferred",
+  "role",
+  "degree",
+  "practices",
+  "best",
+  "skills",
+  "team",
+  "field",
+  "related",
+  "relevant",
+  "desired",
+  "strong",
+  "solid",
+  "good",
+  "first",
+  "based",
+  "day",
+  "week",
+  "month",
+  "time",
+  "fast",
+  "open",
+  "dynamic"
+]);
+function normalizeWhitespace(text) {
+  return text.replace(/\r\n?/g, "\n").replace(/\s+/g, " ").trim();
+}
+function normalizeForComparison(text) {
+  return normalizeWhitespace(text).normalize("NFKC").toLowerCase();
+}
+function splitLines(text) {
+  return text.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean);
+}
+var TECH_TOKEN_RE = /[a-z0-9][a-z0-9.#+\-/]*[a-z0-9#+]/g;
+function tokenize(text) {
+  const normalized = normalizeForComparison(text);
+  return (normalized.match(TECH_TOKEN_RE) ?? []).filter(
+    (t) => /[a-z]/.test(t) && !STOP_WORDS.has(t)
+  );
+}
+function escapeRegExp(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function unique(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const output = [];
+  for (const value of values) {
+    const lower = value.toLowerCase();
+    if (!seen.has(lower)) {
+      seen.add(lower);
+      output.push(value);
+    }
+  }
+  return output;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function countFrequencies(values) {
+  const counts = {};
+  for (const value of values) {
+    counts[value] = (counts[value] ?? 0) + 1;
+  }
+  return counts;
+}
+function containsTableLikeStructure(text) {
+  const lines = splitLines(text);
+  let tableLines = 0;
+  for (const line of lines) {
+    const hasPipeColumns = line.includes("|") && line.split("|").length >= 3;
+    const hasTabColumns = /\t.+\t/.test(line);
+    const hasAlignedSpaces = /( {3,})(\S+)( {3,}\S+)/.test(line);
+    if (hasPipeColumns || hasTabColumns || hasAlignedSpaces) {
+      tableLines += 1;
+    }
+  }
+  return tableLines >= 2;
+}
+
+// src/utils/skills.ts
+var aliasIndexCache = /* @__PURE__ */ new WeakMap();
+function getAliasIndex(aliases) {
+  let index = aliasIndexCache.get(aliases);
+  if (!index) {
+    index = /* @__PURE__ */ new Map();
+    for (const [canonical, aliasList] of Object.entries(aliases)) {
+      const lower = canonical.toLowerCase();
+      index.set(lower, lower);
+      for (const alias of aliasList) {
+        index.set(alias.toLowerCase(), lower);
+      }
+    }
+    aliasIndexCache.set(aliases, index);
+  }
+  return index;
+}
+function normalizeSkill(skill, aliases) {
+  const normalized = skill.trim().toLowerCase();
+  return getAliasIndex(aliases).get(normalized) ?? normalized;
+}
+function normalizeSkills(skills, aliases) {
+  return unique(skills.map((skill) => normalizeSkill(skill, aliases)));
+}
+function deriveSkillAliases(registry) {
+  const aliases = {};
+  for (const entry of registry) {
+    aliases[entry.canonical] = entry.aliases;
+  }
+  return aliases;
+}
+function buildCategoryIndex(registry) {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of registry) {
+    index.set(entry.canonical.toLowerCase(), entry.category);
+  }
+  return index;
+}
+function mergeKeywordRegistries(base, overrides) {
+  const byCanonical = /* @__PURE__ */ new Map();
+  for (const entry of base) byCanonical.set(entry.canonical.toLowerCase(), entry);
+  for (const entry of overrides) byCanonical.set(entry.canonical.toLowerCase(), entry);
+  return [...byCanonical.values()];
+}
+
+// src/profiles/index.ts
+var defaultKeywordRegistry = [
+  // languages / frameworks
+  // ponytail: "node" split from javascript — Node.js runtime !== JS language
+  { canonical: "javascript", aliases: ["js"], category: "technical" },
+  { canonical: "node", aliases: ["node.js", "nodejs"], category: "technical" },
+  { canonical: "typescript", aliases: ["ts"], category: "technical" },
+  { canonical: "react", aliases: ["reactjs", "react.js"], category: "technical" },
+  { canonical: "angular", aliases: ["angularjs"], category: "technical" },
+  { canonical: "vue", aliases: ["vue.js", "vuejs"], category: "technical" },
+  { canonical: "svelte", aliases: [], category: "technical" },
+  { canonical: "next.js", aliases: ["nextjs"], category: "technical" },
+  { canonical: "c++", aliases: ["cpp"], category: "technical" },
+  { canonical: "c#", aliases: ["csharp", ".net"], category: "technical" },
+  { canonical: "java", aliases: [], category: "technical" },
+  { canonical: "python", aliases: ["py"], category: "technical" },
+  { canonical: "go", aliases: ["golang"], category: "technical" },
+  { canonical: "rust", aliases: [], category: "technical" },
+  { canonical: "ruby", aliases: ["ruby on rails", "rails"], category: "technical" },
+  { canonical: "php", aliases: [], category: "technical" },
+  { canonical: "swift", aliases: [], category: "technical" },
+  { canonical: "kotlin", aliases: [], category: "technical" },
+  { canonical: "scala", aliases: [], category: "technical" },
+  { canonical: "html", aliases: ["html5"], category: "technical" },
+  { canonical: "css", aliases: ["css3"], category: "technical" },
+  { canonical: "ios development", aliases: ["ios"], category: "technical" },
+  { canonical: "android development", aliases: ["android"], category: "technical" },
+  { canonical: "react native", aliases: [], category: "technical" },
+  { canonical: "flutter", aliases: [], category: "technical" },
+  { canonical: "machine learning", aliases: ["ml"], category: "technical" },
+  { canonical: "deep learning", aliases: [], category: "technical" },
+  { canonical: "natural language processing", aliases: ["nlp"], category: "technical" },
+  // tools / platforms / infra
+  { canonical: "sql", aliases: ["postgres", "mysql", "sqlite"], category: "tool" },
+  { canonical: "graphql", aliases: ["gql"], category: "tool" },
+  { canonical: "aws", aliases: ["amazon web services"], category: "tool" },
+  { canonical: "azure", aliases: ["microsoft azure"], category: "tool" },
+  { canonical: "gcp", aliases: ["google cloud", "google cloud platform"], category: "tool" },
+  { canonical: "docker", aliases: ["containers"], category: "tool" },
+  { canonical: "kubernetes", aliases: ["k8s"], category: "tool" },
+  { canonical: "terraform", aliases: [], category: "tool" },
+  { canonical: "ansible", aliases: [], category: "tool" },
+  { canonical: "jenkins", aliases: [], category: "tool" },
+  { canonical: "git", aliases: ["github", "gitlab"], category: "tool" },
+  { canonical: "jira", aliases: [], category: "tool" },
+  { canonical: "confluence", aliases: [], category: "tool" },
+  { canonical: "pytorch", aliases: ["torch"], category: "tool" },
+  { canonical: "tensorflow", aliases: ["tf"], category: "tool" },
+  { canonical: "scikit-learn", aliases: ["sklearn"], category: "tool" },
+  { canonical: "pandas", aliases: [], category: "tool" },
+  { canonical: "numpy", aliases: [], category: "tool" },
+  { canonical: "fastapi", aliases: [], category: "tool" },
+  { canonical: "flask", aliases: [], category: "tool" },
+  { canonical: "django", aliases: [], category: "tool" },
+  { canonical: "kafka", aliases: [], category: "tool" },
+  { canonical: "redis", aliases: [], category: "tool" },
+  { canonical: "elasticsearch", aliases: ["elastic"], category: "tool" },
+  { canonical: "spark", aliases: ["apache spark"], category: "tool" },
+  { canonical: "tableau", aliases: [], category: "tool" },
+  { canonical: "power bi", aliases: ["powerbi"], category: "tool" },
+  { canonical: "excel", aliases: ["microsoft excel", "ms excel"], category: "tool" },
+  { canonical: "salesforce", aliases: [], category: "tool" },
+  { canonical: "hubspot", aliases: [], category: "tool" },
+  { canonical: "sap", aliases: [], category: "tool" },
+  { canonical: "quickbooks", aliases: [], category: "tool" },
+  { canonical: "workday", aliases: [], category: "tool" },
+  { canonical: "zendesk", aliases: [], category: "tool" },
+  { canonical: "servicenow", aliases: [], category: "tool" },
+  { canonical: "figma", aliases: [], category: "tool" },
+  { canonical: "photoshop", aliases: ["adobe photoshop"], category: "tool" },
+  { canonical: "illustrator", aliases: ["adobe illustrator"], category: "tool" },
+  { canonical: "autocad", aliases: [], category: "tool" },
+  // engineering concepts
+  { canonical: "accessibility", aliases: ["a11y"], category: "concept" },
+  { canonical: "frontend", aliases: ["front-end"], category: "concept" },
+  { canonical: "backend", aliases: ["back-end"], category: "concept" },
+  { canonical: "security", aliases: ["cybersecurity"], category: "concept" },
+  { canonical: "testing", aliases: ["unittest", "pytest"], category: "concept" },
+  { canonical: "microservices", aliases: [], category: "concept" },
+  { canonical: "agile", aliases: ["scrum"], category: "concept" },
+  { canonical: "kanban", aliases: [], category: "concept" },
+  { canonical: "blockchain", aliases: [], category: "concept" },
+  { canonical: "devops", aliases: [], category: "concept" },
+  { canonical: "ci/cd", aliases: ["continuous integration", "continuous deployment"], category: "concept" },
+  { canonical: "rest api", aliases: ["restful api", "rest apis"], category: "concept" },
+  { canonical: "design patterns", aliases: [], category: "concept" },
+  { canonical: "data structures", aliases: [], category: "concept" },
+  { canonical: "algorithms", aliases: [], category: "concept" },
+  { canonical: "cloud computing", aliases: [], category: "concept" },
+  { canonical: "system design", aliases: [], category: "concept" },
+  { canonical: "tdd", aliases: ["test driven development", "test-driven development"], category: "concept" },
+  { canonical: "ux design", aliases: ["user experience"], category: "concept" },
+  { canonical: "ui design", aliases: ["user interface design"], category: "concept" },
+  { canonical: "project management", aliases: [], category: "concept" },
+  { canonical: "change management", aliases: [], category: "concept" },
+  { canonical: "risk management", aliases: [], category: "concept" },
+  { canonical: "quality assurance", aliases: ["qa"], category: "concept" },
+  // product / data domain
+  { canonical: "roadmap", aliases: [], category: "domain" },
+  { canonical: "stakeholder management", aliases: [], category: "domain" },
+  { canonical: "prioritization", aliases: [], category: "domain" },
+  { canonical: "a/b testing", aliases: ["ab testing"], category: "domain" },
+  { canonical: "analytics", aliases: [], category: "domain" },
+  { canonical: "statistics", aliases: ["stats"], category: "domain" },
+  { canonical: "data visualization", aliases: [], category: "domain" },
+  // finance / accounting domain
+  { canonical: "financial analysis", aliases: [], category: "domain" },
+  { canonical: "budgeting", aliases: [], category: "domain" },
+  { canonical: "forecasting", aliases: [], category: "domain" },
+  { canonical: "bookkeeping", aliases: [], category: "domain" },
+  { canonical: "accounts payable", aliases: ["ap"], category: "domain" },
+  { canonical: "accounts receivable", aliases: ["ar"], category: "domain" },
+  { canonical: "payroll", aliases: [], category: "domain" },
+  { canonical: "auditing", aliases: ["audit"], category: "domain" },
+  { canonical: "tax preparation", aliases: [], category: "domain" },
+  { canonical: "gaap", aliases: [], category: "domain" },
+  // sales / account management domain
+  { canonical: "lead generation", aliases: [], category: "domain" },
+  { canonical: "account management", aliases: [], category: "domain" },
+  { canonical: "crm", aliases: ["customer relationship management"], category: "domain" },
+  { canonical: "sales pipeline", aliases: [], category: "domain" },
+  { canonical: "cold calling", aliases: [], category: "domain" },
+  { canonical: "upselling", aliases: ["cross-selling"], category: "domain" },
+  { canonical: "customer retention", aliases: [], category: "domain" },
+  // human resources domain
+  { canonical: "recruiting", aliases: ["talent acquisition"], category: "domain" },
+  { canonical: "onboarding", aliases: [], category: "domain" },
+  { canonical: "employee relations", aliases: [], category: "domain" },
+  { canonical: "benefits administration", aliases: [], category: "domain" },
+  { canonical: "performance management", aliases: [], category: "domain" },
+  // healthcare domain
+  { canonical: "patient care", aliases: [], category: "domain" },
+  { canonical: "clinical documentation", aliases: [], category: "domain" },
+  { canonical: "hipaa", aliases: [], category: "domain" },
+  { canonical: "electronic health records", aliases: ["ehr", "emr"], category: "domain" },
+  { canonical: "medical billing", aliases: [], category: "domain" },
+  // legal domain
+  { canonical: "contract review", aliases: [], category: "domain" },
+  { canonical: "legal research", aliases: [], category: "domain" },
+  { canonical: "litigation", aliases: [], category: "domain" },
+  { canonical: "regulatory compliance", aliases: ["compliance"], category: "domain" },
+  { canonical: "due diligence", aliases: [], category: "domain" },
+  // education domain
+  { canonical: "curriculum development", aliases: [], category: "domain" },
+  { canonical: "lesson planning", aliases: [], category: "domain" },
+  { canonical: "classroom management", aliases: [], category: "domain" },
+  { canonical: "instructional design", aliases: [], category: "domain" },
+  // operations / supply chain domain
+  { canonical: "supply chain management", aliases: ["supply chain"], category: "domain" },
+  { canonical: "inventory management", aliases: [], category: "domain" },
+  { canonical: "procurement", aliases: [], category: "domain" },
+  { canonical: "vendor management", aliases: [], category: "domain" },
+  { canonical: "logistics", aliases: [], category: "domain" },
+  // customer service domain
+  { canonical: "customer support", aliases: ["customer service"], category: "domain" },
+  { canonical: "technical support", aliases: [], category: "domain" },
+  { canonical: "conflict resolution", aliases: [], category: "domain" },
+  // soft skills
+  { canonical: "communication", aliases: [], category: "soft" },
+  { canonical: "leadership", aliases: [], category: "soft" },
+  { canonical: "teamwork", aliases: ["collaboration"], category: "soft" },
+  { canonical: "problem solving", aliases: ["problem-solving"], category: "soft" },
+  { canonical: "adaptability", aliases: ["flexibility"], category: "soft" },
+  { canonical: "time management", aliases: [], category: "soft" },
+  { canonical: "critical thinking", aliases: [], category: "soft" },
+  { canonical: "creativity", aliases: [], category: "soft" },
+  { canonical: "attention to detail", aliases: [], category: "soft" },
+  { canonical: "decision making", aliases: ["decision-making"], category: "soft" },
+  { canonical: "emotional intelligence", aliases: [], category: "soft" },
+  { canonical: "negotiation", aliases: [], category: "soft" },
+  { canonical: "organization", aliases: ["organizational skills"], category: "soft" },
+  { canonical: "public speaking", aliases: ["presentation skills"], category: "soft" },
+  { canonical: "mentoring", aliases: ["coaching"], category: "soft" },
+  { canonical: "interpersonal skills", aliases: [], category: "soft" },
+  { canonical: "work ethic", aliases: [], category: "soft" },
+  // marketing
+  { canonical: "seo", aliases: ["search engine optimization"], category: "marketing" },
+  { canonical: "branding", aliases: ["brand strategy"], category: "marketing" },
+  { canonical: "campaign management", aliases: [], category: "marketing" },
+  { canonical: "content marketing", aliases: [], category: "marketing" },
+  { canonical: "social media marketing", aliases: ["social media"], category: "marketing" },
+  { canonical: "email marketing", aliases: [], category: "marketing" },
+  { canonical: "digital marketing", aliases: [], category: "marketing" },
+  { canonical: "copywriting", aliases: [], category: "marketing" },
+  { canonical: "market research", aliases: [], category: "marketing" },
+  { canonical: "ppc", aliases: ["pay-per-click", "google ads"], category: "marketing" },
+  { canonical: "conversion rate optimization", aliases: ["cro"], category: "marketing" },
+  { canonical: "public relations", aliases: ["pr"], category: "marketing" }
+];
+var defaultSkillAliases = deriveSkillAliases(defaultKeywordRegistry);
+var softwareEngineerProfile = {
+  name: "software-engineer",
+  mandatorySkills: ["javascript", "typescript", "react", "node"],
+  optionalSkills: ["graphql", "sql", "docker"],
+  minExperience: 3
+};
+var dataScientistProfile = {
+  name: "data-scientist",
+  mandatorySkills: ["python", "sql", "statistics"],
+  optionalSkills: ["pandas", "numpy", "pytorch", "tensorflow"],
+  minExperience: 2
+};
+var productManagerProfile = {
+  name: "product-manager",
+  mandatorySkills: ["roadmap", "stakeholder management", "prioritization"],
+  optionalSkills: ["a/b testing", "analytics", "sql"],
+  minExperience: 3
+};
+var defaultProfiles = [
+  softwareEngineerProfile,
+  dataScientistProfile,
+  productManagerProfile
+];
+
+export { STOP_WORDS, buildCategoryIndex, clamp, containsTableLikeStructure, countFrequencies, defaultKeywordRegistry, defaultProfiles, defaultSkillAliases, deriveSkillAliases, escapeRegExp, mergeKeywordRegistries, normalizeForComparison, normalizeSkill, normalizeSkills, normalizeWhitespace, softwareEngineerProfile, splitLines, tokenize, unique };
+//# sourceMappingURL=chunk-ZJ5E4H7Z.mjs.map
+//# sourceMappingURL=chunk-ZJ5E4H7Z.mjs.map