resuml 1.3.0 → 1.4.1

package/dist/{index.js → index.cjs}

@@ -39,7 +39,7 @@ var getImportMetaUrl, importMetaUrl;
 var init_cjs_shims = __esm({
   "node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
-    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
     importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
   }
 });
@@ -181,7 +181,7 @@ var require_brace_expansion = __commonJS({
         var isSequence = isNumericSequence || isAlphaSequence;
         var isOptions = m.body.indexOf(",") >= 0;
         if (!isSequence && !isOptions) {
-          if (m.post.match(/,(?!,).*\}/)) {
+          if (m.post.match(/,.*\}/)) {
             str = m.pre + "{" + m.body + escClose + m.post;
             return expand2(str);
           }
@@ -258,6 +258,7 @@ var require_brace_expansion = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  analyzeAts: () => analyzeAts,
   loadResumeFiles: () => loadResumeFiles,
   loadTheme: () => loadTheme,
   processResumeData: () => processResumeData,
@@ -267,17 +268,18 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 init_cjs_shims();
 var import_commander = require("commander");
-var import_path3 = __toESM(require("path"));
-var import_fs7 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"), 1);
+var import_fs8 = __toESM(require("fs"), 1);
 var import_url = require("url");
 
 // src/commands/validate.ts
 init_cjs_shims();
+var import_fs2 = __toESM(require("fs"), 1);
 
 // src/core.ts
 init_cjs_shims();
 var import_yaml = require("yaml");
-var import_lodash = __toESM(require("lodash.merge"));
+var import_lodash = __toESM(require("lodash.merge"), 1);
 var import_schema = require("@jsonresume/schema");
 async function processResumeData(yamlContents) {
   if (yamlContents.length === 0) {
@@ -316,13 +318,13 @@ async function processResumeData(yamlContents) {
 
 // src/utils/loadResume.ts
 init_cjs_shims();
-var import_promises3 = __toESM(require("fs/promises"));
-var import_yaml2 = __toESM(require("yaml"));
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_yaml2 = __toESM(require("yaml"), 1);
 
 // src/utils/fileUtils.ts
 init_cjs_shims();
-var import_promises2 = __toESM(require("fs/promises"));
-var import_path = __toESM(require("path"));
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_path = __toESM(require("path"), 1);
 
 // node_modules/glob/dist/esm/index.js
 init_cjs_shims();
@@ -1012,7 +1014,7 @@ var path = {
 };
 var sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
 minimatch.sep = sep;
-var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
+var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
 var qmark2 = "[^/]";
 var star2 = qmark2 + "*?";
@@ -1717,6 +1719,7 @@ if (typeof AC === "undefined") {
   };
 }
 var shouldWarn = (code) => !warned.has(code);
+var TYPE = Symbol("type");
 var isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
 var getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
 var ZeroArray = class extends Array {
@@ -3061,37 +3064,37 @@ var isStream = (s) => !!s && typeof s === "object" && (s instanceof Minipass ||
 var isReadable = (s) => !!s && typeof s === "object" && s instanceof import_node_events.EventEmitter && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws
 s.pipe !== import_node_stream.default.Writable.prototype.pipe;
 var isWritable = (s) => !!s && typeof s === "object" && s instanceof import_node_events.EventEmitter && typeof s.write === "function" && typeof s.end === "function";
-var EOF = /* @__PURE__ */ Symbol("EOF");
-var MAYBE_EMIT_END = /* @__PURE__ */ Symbol("maybeEmitEnd");
-var EMITTED_END = /* @__PURE__ */ Symbol("emittedEnd");
-var EMITTING_END = /* @__PURE__ */ Symbol("emittingEnd");
-var EMITTED_ERROR = /* @__PURE__ */ Symbol("emittedError");
-var CLOSED = /* @__PURE__ */ Symbol("closed");
-var READ = /* @__PURE__ */ Symbol("read");
-var FLUSH = /* @__PURE__ */ Symbol("flush");
-var FLUSHCHUNK = /* @__PURE__ */ Symbol("flushChunk");
-var ENCODING = /* @__PURE__ */ Symbol("encoding");
-var DECODER = /* @__PURE__ */ Symbol("decoder");
-var FLOWING = /* @__PURE__ */ Symbol("flowing");
-var PAUSED = /* @__PURE__ */ Symbol("paused");
-var RESUME = /* @__PURE__ */ Symbol("resume");
-var BUFFER = /* @__PURE__ */ Symbol("buffer");
-var PIPES = /* @__PURE__ */ Symbol("pipes");
-var BUFFERLENGTH = /* @__PURE__ */ Symbol("bufferLength");
-var BUFFERPUSH = /* @__PURE__ */ Symbol("bufferPush");
-var BUFFERSHIFT = /* @__PURE__ */ Symbol("bufferShift");
-var OBJECTMODE = /* @__PURE__ */ Symbol("objectMode");
-var DESTROYED = /* @__PURE__ */ Symbol("destroyed");
-var ERROR = /* @__PURE__ */ Symbol("error");
-var EMITDATA = /* @__PURE__ */ Symbol("emitData");
-var EMITEND = /* @__PURE__ */ Symbol("emitEnd");
-var EMITEND2 = /* @__PURE__ */ Symbol("emitEnd2");
-var ASYNC = /* @__PURE__ */ Symbol("async");
-var ABORT = /* @__PURE__ */ Symbol("abort");
-var ABORTED = /* @__PURE__ */ Symbol("aborted");
-var SIGNAL = /* @__PURE__ */ Symbol("signal");
-var DATALISTENERS = /* @__PURE__ */ Symbol("dataListeners");
-var DISCARDED = /* @__PURE__ */ Symbol("discarded");
+var EOF = Symbol("EOF");
+var MAYBE_EMIT_END = Symbol("maybeEmitEnd");
+var EMITTED_END = Symbol("emittedEnd");
+var EMITTING_END = Symbol("emittingEnd");
+var EMITTED_ERROR = Symbol("emittedError");
+var CLOSED = Symbol("closed");
+var READ = Symbol("read");
+var FLUSH = Symbol("flush");
+var FLUSHCHUNK = Symbol("flushChunk");
+var ENCODING = Symbol("encoding");
+var DECODER = Symbol("decoder");
+var FLOWING = Symbol("flowing");
+var PAUSED = Symbol("paused");
+var RESUME = Symbol("resume");
+var BUFFER = Symbol("buffer");
+var PIPES = Symbol("pipes");
+var BUFFERLENGTH = Symbol("bufferLength");
+var BUFFERPUSH = Symbol("bufferPush");
+var BUFFERSHIFT = Symbol("bufferShift");
+var OBJECTMODE = Symbol("objectMode");
+var DESTROYED = Symbol("destroyed");
+var ERROR = Symbol("error");
+var EMITDATA = Symbol("emitData");
+var EMITEND = Symbol("emitEnd");
+var EMITEND2 = Symbol("emitEnd2");
+var ASYNC = Symbol("async");
+var ABORT = Symbol("abort");
+var ABORTED = Symbol("aborted");
+var SIGNAL = Symbol("signal");
+var DATALISTENERS = Symbol("dataListeners");
+var DISCARDED = Symbol("discarded");
 var defer = (fn) => Promise.resolve().then(fn);
 var nodefer = (fn) => fn();
 var isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
@@ -3130,7 +3133,7 @@ var PipeProxyErrors = class extends Pipe {
   }
   constructor(src, dest, opts) {
     super(src, dest, opts);
-    this.proxyErrors = (er) => dest.emit("error", er);
+    this.proxyErrors = (er) => this.dest.emit("error", er);
     src.on("error", this.proxyErrors);
   }
 };
@@ -3844,6 +3847,8 @@ var Minipass = class extends import_node_events.EventEmitter {
       return: stop,
       [Symbol.asyncIterator]() {
         return this;
+      },
+      [Symbol.asyncDispose]: async () => {
       }
     };
   }
@@ -3879,6 +3884,8 @@ var Minipass = class extends import_node_events.EventEmitter {
       return: stop,
       [Symbol.iterator]() {
         return this;
+      },
+      [Symbol.dispose]: () => {
       }
     };
   }
@@ -4004,7 +4011,7 @@ var ChildrenCache = class extends LRUCache {
     });
   }
 };
-var setAsCwd = /* @__PURE__ */ Symbol("PathScurry setAsCwd");
+var setAsCwd = Symbol("PathScurry setAsCwd");
 var PathBase = class {
   /**
    * the basename of this path
@@ -5044,8 +5051,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs9 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs9);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs10 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs10);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = (0, import_node_url.fileURLToPath)(cwd);
     }
@@ -5603,8 +5610,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs9) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs9 });
+  newRoot(fs10) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs10 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -5632,8 +5639,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs9) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs9 });
+  newRoot(fs10) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs10 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -6816,12 +6823,1011 @@ function handleCommandError(error, command, debug = false) {
       }
     }
   }
-  if (process.env.NODE_ENV !== "test") {
+  if (process.env["NODE_ENV"] !== "test") {
     process.exit(1);
   }
 }
 
+// src/ats/index.ts
+init_cjs_shims();
+
+// src/ats/genericChecks.ts
+init_cjs_shims();
+
+// src/ats/i18n/index.ts
+init_cjs_shims();
+
+// src/ats/i18n/en.ts
+init_cjs_shims();
+var en = {
+  actionVerbs: [
+    // Leadership & Management
+    "achieved",
+    "administered",
+    "advanced",
+    "allocated",
+    "approved",
+    "assigned",
+    "authorized",
+    "chaired",
+    "consolidated",
+    "coordinated",
+    "delegated",
+    "directed",
+    "established",
+    "executed",
+    "headed",
+    "hired",
+    "hosted",
+    "led",
+    "managed",
+    "mentored",
+    "motivated",
+    "orchestrated",
+    "organized",
+    "oversaw",
+    "planned",
+    "presided",
+    "prioritized",
+    "produced",
+    "recruited",
+    "spearheaded",
+    "supervised",
+    // Technical & Engineering
+    "architected",
+    "automated",
+    "built",
+    "coded",
+    "configured",
+    "debugged",
+    "deployed",
+    "designed",
+    "developed",
+    "devised",
+    "engineered",
+    "implemented",
+    "installed",
+    "integrated",
+    "launched",
+    "maintained",
+    "migrated",
+    "modernized",
+    "optimized",
+    "overhauled",
+    "programmed",
+    "prototyped",
+    "refactored",
+    "reengineered",
+    "resolved",
+    "restructured",
+    "revamped",
+    "scaled",
+    "standardized",
+    "streamlined",
+    "tested",
+    "troubleshot",
+    "upgraded",
+    // Achievement & Impact
+    "accelerated",
+    "accomplished",
+    "boosted",
+    "completed",
+    "contributed",
+    "converted",
+    "decreased",
+    "delivered",
+    "doubled",
+    "earned",
+    "eliminated",
+    "exceeded",
+    "expanded",
+    "expedited",
+    "generated",
+    "grew",
+    "improved",
+    "increased",
+    "maximized",
+    "minimized",
+    "outperformed",
+    "pioneered",
+    "recovered",
+    "reduced",
+    "saved",
+    "simplified",
+    "solved",
+    "surpassed",
+    "transformed",
+    "tripled",
+    // Communication & Collaboration
+    "advised",
+    "advocated",
+    "briefed",
+    "collaborated",
+    "communicated",
+    "consulted",
+    "convinced",
+    "counseled",
+    "defined",
+    "demonstrated",
+    "documented",
+    "educated",
+    "facilitated",
+    "guided",
+    "influenced",
+    "informed",
+    "instructed",
+    "liaised",
+    "negotiated",
+    "partnered",
+    "persuaded",
+    "presented",
+    "promoted",
+    "proposed",
+    "published",
+    "recommended",
+    "represented",
+    "trained",
+    // Analysis & Research
+    "analyzed",
+    "assessed",
+    "audited",
+    "benchmarked",
+    "calculated",
+    "compared",
+    "compiled",
+    "conducted",
+    "discovered",
+    "evaluated",
+    "examined",
+    "explored",
+    "forecasted",
+    "identified",
+    "inspected",
+    "interpreted",
+    "investigated",
+    "mapped",
+    "measured",
+    "modeled",
+    "monitored",
+    "quantified",
+    "researched",
+    "reviewed",
+    "surveyed",
+    "synthesized",
+    "tracked",
+    "validated",
+    "verified",
+    // Creation & Innovation
+    "conceptualized",
+    "crafted",
+    "created",
+    "customized",
+    "formulated",
+    "founded",
+    "initiated",
+    "innovated",
+    "introduced",
+    "invented",
+    "originated",
+    "shaped"
+  ],
+  pronouns: ["i", "me", "my", "mine", "myself", "we", "our", "ours"],
+  stopWords: [
+    "a",
+    "an",
+    "the",
+    "and",
+    "or",
+    "but",
+    "in",
+    "on",
+    "at",
+    "to",
+    "for",
+    "of",
+    "with",
+    "by",
+    "from",
+    "is",
+    "was",
+    "are",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "shall",
+    "can",
+    "this",
+    "that",
+    "these",
+    "those",
+    "it",
+    "its",
+    "as",
+    "if",
+    "not",
+    "no",
+    "so",
+    "up",
+    "out",
+    "about",
+    "into",
+    "over",
+    "after",
+    "before",
+    "between",
+    "under",
+    "above",
+    "below",
+    "all",
+    "each",
+    "every",
+    "both",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "than",
+    "too",
+    "very"
+  ]
+};
+var en_default = en;
+
+// src/ats/i18n/de.ts
+init_cjs_shims();
+var de = {
+  actionVerbs: [
+    // Führung & Management
+    "geleitet",
+    "gef\xFChrt",
+    "koordiniert",
+    "organisiert",
+    "verwaltet",
+    "delegiert",
+    "beaufsichtigt",
+    "betreut",
+    "eingestellt",
+    "motiviert",
+    "verantwortet",
+    "gesteuert",
+    "\xFCberwacht",
+    "priorisiert",
+    "geplant",
+    // Technik & Entwicklung
+    "entwickelt",
+    "implementiert",
+    "programmiert",
+    "konfiguriert",
+    "automatisiert",
+    "deployt",
+    "gebaut",
+    "entworfen",
+    "integriert",
+    "migriert",
+    "modernisiert",
+    "optimiert",
+    "refaktoriert",
+    "skaliert",
+    "standardisiert",
+    "getestet",
+    "aufgebaut",
+    "eingef\xFChrt",
+    "bereitgestellt",
+    "umgesetzt",
+    // Leistung & Ergebnisse
+    "verbessert",
+    "gesteigert",
+    "reduziert",
+    "beschleunigt",
+    "erreicht",
+    "\xFCbertroffen",
+    "erweitert",
+    "vereinfacht",
+    "gel\xF6st",
+    "transformiert",
+    "erh\xF6ht",
+    "verdoppelt",
+    "verdreifacht",
+    "generiert",
+    "gespart",
+    "maximiert",
+    "minimiert",
+    "eliminiert",
+    "geliefert",
+    "abgeschlossen",
+    // Kommunikation & Zusammenarbeit
+    "beraten",
+    "pr\xE4sentiert",
+    "dokumentiert",
+    "geschult",
+    "trainiert",
+    "vermittelt",
+    "kommuniziert",
+    "verhandelt",
+    "zusammengearbeitet",
+    "unterst\xFCtzt",
+    "gef\xF6rdert",
+    "empfohlen",
+    "vorgestellt",
+    "publiziert",
+    // Analyse & Forschung
+    "analysiert",
+    "bewertet",
+    "evaluiert",
+    "untersucht",
+    "erforscht",
+    "identifiziert",
+    "gemessen",
+    "\xFCberwacht",
+    "validiert",
+    "verifiziert",
+    "gepr\xFCft",
+    "verglichen",
+    "recherchiert",
+    "quantifiziert",
+    // Kreation & Innovation
+    "konzipiert",
+    "erstellt",
+    "gestaltet",
+    "initiiert",
+    "innoviert",
+    "eingef\xFChrt",
+    "gegr\xFCndet",
+    "formuliert"
+  ],
+  pronouns: ["ich", "mich", "mir", "mein", "meine", "meinem", "meiner", "meines", "wir", "unser", "unsere"],
+  stopWords: [
+    "ein",
+    "eine",
+    "einer",
+    "eines",
+    "einem",
+    "der",
+    "die",
+    "das",
+    "den",
+    "dem",
+    "des",
+    "und",
+    "oder",
+    "aber",
+    "in",
+    "an",
+    "auf",
+    "zu",
+    "f\xFCr",
+    "von",
+    "mit",
+    "bei",
+    "aus",
+    "ist",
+    "war",
+    "sind",
+    "waren",
+    "wird",
+    "wurde",
+    "werden",
+    "hat",
+    "hatte",
+    "haben",
+    "hatten",
+    "sein",
+    "kann",
+    "k\xF6nnte",
+    "soll",
+    "sollte",
+    "muss",
+    "musste",
+    "darf",
+    "diese",
+    "dieser",
+    "dieses",
+    "diesem",
+    "diesen",
+    "als",
+    "wenn",
+    "nicht",
+    "kein",
+    "keine",
+    "so",
+    "auch",
+    "noch",
+    "schon",
+    "nach",
+    "vor",
+    "\xFCber",
+    "unter",
+    "zwischen",
+    "durch",
+    "ohne",
+    "um",
+    "bis",
+    "alle",
+    "jede",
+    "jeder",
+    "jedes",
+    "mehr",
+    "viel",
+    "sehr"
+  ]
+};
+var de_default = de;
+
+// src/ats/i18n/index.ts
+var languages = { en: en_default, de: de_default };
+function getLanguageData(language) {
+  return languages[language] ?? languages["en"] ?? en_default;
+}
+
+// src/ats/genericChecks.ts
+function wordCount(text) {
+  return text.trim().split(/\s+/).filter(Boolean).length;
+}
+function getFirstWord(text) {
+  return text.trim().split(/\s+/)[0]?.toLowerCase().replace(/[^a-zA-ZäöüßÄÖÜàáâãéèêëíìîïóòôõúùûüñç]/g, "") || "";
+}
+var contactComplete = (resume) => {
+  const b = resume.basics;
+  const hasName = !!b?.name;
+  const hasEmail = !!b?.email;
+  const hasPhone = !!b?.phone;
+  const hasCity = !!b?.location?.city;
+  const fields = [hasName, hasEmail, hasPhone, hasCity];
+  const presentCount = fields.filter(Boolean).length;
+  const passed = presentCount === fields.length;
+  const missing = [];
+  if (!hasName) missing.push("name");
+  if (!hasEmail) missing.push("email");
+  if (!hasPhone) missing.push("phone");
+  if (!hasCity) missing.push("location.city");
+  return {
+    id: "contact-complete",
+    category: "contact",
+    weight: "high",
+    passed,
+    score: Math.round(presentCount / fields.length * 100),
+    message: passed ? "Contact information is complete." : `Missing contact fields: ${missing.join(", ")}.`,
+    suggestion: passed ? void 0 : `Add the following to your basics section: ${missing.join(", ")}.`
+  };
+};
+var hasSummary = (resume) => {
+  const summary = resume.basics?.summary?.trim();
+  if (!summary) {
+    return {
+      id: "has-summary",
+      category: "content",
+      weight: "high",
+      passed: false,
+      score: 0,
+      message: "No professional summary found.",
+      suggestion: "Add a 2-4 sentence professional summary to your basics section highlighting your experience and key skills."
+    };
+  }
+  const words = wordCount(summary);
+  const tooShort = words < 15;
+  const tooLong = words > 100;
+  const passed = !tooShort && !tooLong;
+  let score = 100;
+  if (tooShort) score = Math.round(words / 15 * 60);
+  if (tooLong) score = Math.max(60, 100 - (words - 100));
+  return {
+    id: "has-summary",
+    category: "content",
+    weight: "high",
+    passed,
+    score,
+    message: tooShort ? `Summary is too short (${words} words). Aim for 15-100 words.` : tooLong ? `Summary is too long (${words} words). Aim for 15-100 words.` : `Summary length is good (${words} words).`,
+    suggestion: tooShort ? "Expand your summary to describe your experience, expertise, and career goals in 15-100 words." : tooLong ? "Shorten your summary to the most impactful 15-100 words. Focus on key achievements and expertise." : void 0
+  };
+};
+var hasLinkedin = (resume) => {
+  const profiles = resume.basics?.profiles || [];
+  const linkedin = profiles.find(
+    (p) => p.network?.toLowerCase() === "linkedin" || p.url?.toLowerCase().includes("linkedin.com")
+  );
+  return {
+    id: "has-linkedin",
+    category: "contact",
+    weight: "medium",
+    passed: !!linkedin,
+    score: linkedin ? 100 : 0,
+    message: linkedin ? "LinkedIn profile found." : "No LinkedIn profile found.",
+    suggestion: linkedin ? void 0 : "Add a LinkedIn profile to your basics.profiles section."
+  };
+};
+var workHighlights = (resume) => {
+  const work = resume.work || [];
+  if (work.length === 0) {
+    return {
+      id: "work-highlights",
+      category: "content",
+      weight: "high",
+      passed: false,
+      score: 0,
+      message: "No work experience entries found.",
+      suggestion: "Add work experience entries with highlights describing your accomplishments."
+    };
+  }
+  const minHighlights = 2;
+  const entriesWithEnough = work.filter((w) => (w.highlights?.length || 0) >= minHighlights);
+  const passed = entriesWithEnough.length === work.length;
+  const score = Math.round(entriesWithEnough.length / work.length * 100);
+  const lacking = work.filter((w) => (w.highlights?.length || 0) < minHighlights).map((w) => `"${w.position || "Unknown"} at ${w.name || "Unknown"}" (${w.highlights?.length || 0} highlights)`);
+  return {
+    id: "work-highlights",
+    category: "content",
+    weight: "high",
+    passed,
+    score,
+    message: passed ? "All work entries have sufficient highlights." : `Some work entries need more highlights: ${lacking.join("; ")}.`,
+    suggestion: passed ? void 0 : `Add at least ${minHighlights} bullet-point highlights to each work entry describing specific accomplishments.`
+  };
+};
+var actionVerbs = (resume, language) => {
+  const langData = getLanguageData(language);
+  const verbs = new Set(langData.actionVerbs);
+  const allHighlights = [];
+  for (const w of resume.work || []) {
+    for (const h of w.highlights || []) {
+      allHighlights.push({ text: h, source: `${w.position || ""} at ${w.name || ""}` });
+    }
+  }
+  for (const p of resume.projects || []) {
+    for (const h of p.highlights || []) {
+      allHighlights.push({ text: h, source: `project "${p.name || ""}"` });
+    }
+  }
+  for (const v of resume.volunteer || []) {
+    for (const h of v.highlights || []) {
+      allHighlights.push({ text: h, source: `volunteer at ${v.organization || ""}` });
+    }
+  }
+  if (allHighlights.length === 0) {
+    return {
+      id: "action-verbs",
+      category: "content",
+      weight: "high",
+      passed: false,
+      score: 0,
+      message: "No highlights found to check for action verbs.",
+      suggestion: "Add highlights to your work, project, or volunteer entries starting with strong action verbs."
+    };
+  }
+  const withActionVerb = allHighlights.filter((h) => verbs.has(getFirstWord(h.text)));
+  const withoutActionVerb = allHighlights.filter((h) => !verbs.has(getFirstWord(h.text)));
+  const passed = withoutActionVerb.length === 0;
+  const score = Math.round(withActionVerb.length / allHighlights.length * 100);
+  const examples = withoutActionVerb.slice(0, 3).map(
+    (h) => `"${h.text.substring(0, 60)}${h.text.length > 60 ? "..." : ""}" (${h.source})`
+  );
+  return {
+    id: "action-verbs",
+    category: "content",
+    weight: "high",
+    passed,
+    score,
+    message: passed ? "All highlights start with action verbs." : `${withoutActionVerb.length} of ${allHighlights.length} highlights don't start with an action verb.`,
+    suggestion: passed ? void 0 : `Start each highlight with a strong action verb (e.g., "Developed", "Implemented", "Led"). Fix: ${examples.join("; ")}.`
+  };
+};
+var quantifiedImpact = (resume) => {
+  const quantPattern = /\d+%?|\$[\d,]+|[\d,]+\+?\s*(users|clients|customers|people|team|members|projects|applications|servers|services|endpoints|requests|transactions)/i;
+  const allHighlights = [];
+  for (const w of resume.work || []) {
+    allHighlights.push(...w.highlights || []);
+  }
+  for (const p of resume.projects || []) {
+    allHighlights.push(...p.highlights || []);
+  }
+  if (allHighlights.length === 0) {
+    return {
+      id: "quantified-impact",
+      category: "content",
+      weight: "medium",
+      passed: false,
+      score: 0,
+      message: "No highlights found to check for quantified impact.",
+      suggestion: 'Add measurable results to your highlights (e.g., "Reduced load time by 40%", "Managed team of 8").'
+    };
+  }
+  const quantified = allHighlights.filter((h) => quantPattern.test(h));
+  const ratio = quantified.length / allHighlights.length;
+  const passed = ratio >= 0.5;
+  const score = Math.min(100, Math.round(ratio * 200));
+  return {
+    id: "quantified-impact",
+    category: "content",
+    weight: "medium",
+    passed,
+    score,
+    message: passed ? `${quantified.length} of ${allHighlights.length} highlights include quantified results.` : `Only ${quantified.length} of ${allHighlights.length} highlights include numbers or metrics.`,
+    suggestion: passed ? void 0 : 'Add specific numbers, percentages, or metrics to your highlights (e.g., "Improved performance by 30%", "Managed $2M budget").'
+  };
+};
+var dateConsistency = (resume) => {
+  const work = resume.work || [];
+  if (work.length < 2) {
+    return {
+      id: "date-consistency",
+      category: "structure",
+      weight: "medium",
+      passed: true,
+      score: 100,
+      message: "Date consistency check passed (fewer than 2 work entries)."
+    };
+  }
+  const issues = [];
+  for (const w of work) {
+    if (!w.startDate) {
+      issues.push(`"${w.position || "Unknown"} at ${w.name || "Unknown"}" is missing a start date.`);
+    }
+  }
+  const sorted = [...work].filter((w) => Boolean(w.startDate)).sort((a, b) => a.startDate > b.startDate ? 1 : -1);
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const current = sorted[i];
+    const next = sorted[i + 1];
+    const endDate = current.endDate ?? current.startDate;
+    const gapMs = new Date(next.startDate).getTime() - new Date(endDate).getTime();
+    const gapMonths = gapMs / (1e3 * 60 * 60 * 24 * 30);
+    if (gapMonths > 6) {
+      issues.push(
+        `Gap of ~${Math.round(gapMonths)} months between "${current.name ?? "Unknown"}" (ended ${endDate}) and "${next.name ?? "Unknown"}" (started ${next.startDate}).`
+      );
+    }
+  }
+  const passed = issues.length === 0;
+  return {
+    id: "date-consistency",
+    category: "structure",
+    weight: "medium",
+    passed,
+    score: passed ? 100 : Math.max(0, 100 - issues.length * 25),
+    message: passed ? "Work experience dates are consistent with no major gaps." : `Date issues found: ${issues.join(" ")}`,
+    suggestion: passed ? void 0 : "Ensure all work entries have start dates. If there are employment gaps, consider adding freelance, volunteer, or education entries to fill them."
+  };
+};
+var skillsPopulated = (resume) => {
+  const skills = resume.skills || [];
+  const minCategories = 3;
+  const categoriesWithKeywords = skills.filter((s) => s.keywords && s.keywords.length > 0);
+  const passed = categoriesWithKeywords.length >= minCategories;
+  const score = Math.min(100, Math.round(categoriesWithKeywords.length / minCategories * 100));
+  return {
+    id: "skills-populated",
+    category: "structure",
+    weight: "medium",
+    passed,
+    score,
+    message: passed ? `${categoriesWithKeywords.length} skill categories with keywords found.` : `Only ${categoriesWithKeywords.length} skill categories with keywords found (need at least ${minCategories}).`,
+    suggestion: passed ? void 0 : `Add at least ${minCategories} skill categories with specific keywords (e.g., "Languages: TypeScript, Python", "Frameworks: React, Node.js").`
+  };
+};
+var educationComplete = (resume) => {
+  const education = resume.education || [];
+  if (education.length === 0) {
+    return {
+      id: "education-complete",
+      category: "structure",
+      weight: "low",
+      passed: false,
+      score: 0,
+      message: "No education entries found.",
+      suggestion: "Add at least one education entry with institution, area, and studyType."
+    };
+  }
+  const complete = education.filter((e) => e.institution && e.area && e.studyType);
+  const passed = complete.length === education.length;
+  const score = Math.round(complete.length / education.length * 100);
+  const incomplete = education.filter((e) => !e.institution || !e.area || !e.studyType).map((e) => {
+    const missing = [];
+    if (!e.institution) missing.push("institution");
+    if (!e.area) missing.push("area");
+    if (!e.studyType) missing.push("studyType");
+    return `"${e.institution || "Unknown"}" missing: ${missing.join(", ")}`;
+  });
+  return {
+    id: "education-complete",
+    category: "structure",
+    weight: "low",
+    passed,
+    score,
+    message: passed ? "All education entries are complete." : `Incomplete education entries: ${incomplete.join("; ")}.`,
+    suggestion: passed ? void 0 : "Ensure each education entry has institution, area (field of study), and studyType (degree type)."
+  };
+};
+var noPronouns = (resume, language) => {
+  const langData = getLanguageData(language);
+  const pronounSet = new Set(langData.pronouns);
+  const textBlocks = [];
+  if (resume.basics?.summary) {
+    textBlocks.push({ text: resume.basics.summary, source: "summary" });
+  }
+  for (const w of resume.work || []) {
+    if (w.summary) textBlocks.push({ text: w.summary, source: `work summary (${w.name || "Unknown"})` });
+    for (const h of w.highlights || []) {
+      textBlocks.push({ text: h, source: `work highlight (${w.name || "Unknown"})` });
+    }
+  }
+  for (const p of resume.projects || []) {
+    if (p.description) textBlocks.push({ text: p.description, source: `project (${p.name || "Unknown"})` });
+    for (const h of p.highlights || []) {
+      textBlocks.push({ text: h, source: `project highlight (${p.name || "Unknown"})` });
+    }
+  }
+  const found = [];
+  for (const block of textBlocks) {
+    const words = block.text.toLowerCase().split(/\s+/);
+    for (const word of words) {
+      const clean = word.replace(/[^a-zA-ZäöüßÄÖÜ]/g, "");
+      if (pronounSet.has(clean)) {
+        found.push({ pronoun: clean, source: block.source });
+      }
+    }
+  }
+  const passed = found.length === 0;
+  const uniquePronouns = [...new Set(found.map((f) => f.pronoun))];
+  const examples = found.slice(0, 3).map((f) => `"${f.pronoun}" in ${f.source}`);
+  return {
+    id: "no-pronouns",
+    category: "content",
+    weight: "medium",
+    passed,
+    score: passed ? 100 : Math.max(0, 100 - found.length * 15),
+    message: passed ? "No first-person pronouns found in resume content." : `Found ${found.length} first-person pronoun(s): ${uniquePronouns.join(", ")}.`,
+    suggestion: passed ? void 0 : `Remove first-person pronouns from your resume. Instead of "I managed a team", write "Managed a team". Found: ${examples.join("; ")}.`
+  };
+};
+var sectionCompleteness = (resume) => {
+  const required = ["basics", "work", "education", "skills"];
+  const present = required.filter((section) => {
+    const value = resume[section];
+    if (Array.isArray(value)) return value.length > 0;
+    return value !== void 0;
+  });
+  const missing = required.filter((s) => !present.includes(s));
+  const passed = missing.length === 0;
+  return {
+    id: "section-completeness",
+    category: "structure",
+    weight: "low",
+    passed,
+    score: Math.round(present.length / required.length * 100),
+    message: passed ? "All essential resume sections are present." : `Missing essential sections: ${missing.join(", ")}.`,
+    suggestion: passed ? void 0 : `Add the following sections to your resume: ${missing.join(", ")}.`
+  };
+};
+var allChecks = [
+  contactComplete,
+  hasSummary,
+  hasLinkedin,
+  workHighlights,
+  actionVerbs,
+  quantifiedImpact,
+  dateConsistency,
+  skillsPopulated,
+  educationComplete,
+  noPronouns,
+  sectionCompleteness
+];
+function runGenericChecks(resume, language) {
+  return allChecks.map((check) => check(resume, language));
+}
+
+// src/ats/jdMatcher.ts
+init_cjs_shims();
+function tokenize(text, stopWords) {
+  return text.toLowerCase().replace(/[^a-zA-Z0-9äöüßÄÖÜàáâãéèêëíìîïóòôõúùûüñç\s-]/g, " ").split(/\s+/).filter((word) => word.length > 2 && !stopWords.has(word));
+}
+function simpleStem(word, language) {
+  if (language === "de") {
+    return word.replace(/(ung|heit|keit|schaft|lich|isch|iert|ieren|tion|ment)$/, "").replace(/(en|er|es|em|te|st)$/, "");
+  }
+  return word.replace(/(ment|ness|tion|sion|ance|ence|ity|ing|ous|ive|able|ible|ful|less)$/, "").replace(/(ies)$/, "y").replace(/(es|ed|s)$/, "");
+}
+function extractResumeText(resume) {
+  const parts = [];
+  if (resume.basics?.summary) parts.push(resume.basics.summary);
+  if (resume.basics?.label) parts.push(resume.basics.label);
+  for (const w of resume.work || []) {
+    if (w.position) parts.push(w.position);
+    if (w.summary) parts.push(w.summary);
+    parts.push(...w.highlights || []);
+  }
+  for (const s of resume.skills || []) {
+    if (s.name) parts.push(s.name);
+    parts.push(...s.keywords || []);
+  }
+  for (const p of resume.projects || []) {
+    if (p.name) parts.push(p.name);
+    if (p.description) parts.push(p.description);
+    parts.push(...p.highlights || []);
+  }
+  for (const e of resume.education || []) {
+    if (e.area) parts.push(e.area);
+    if (e.studyType) parts.push(e.studyType);
+    parts.push(...e.courses || []);
+  }
+  for (const c of resume.certificates || []) {
+    if (c.name) parts.push(c.name);
+  }
+  return parts.join(" ");
+}
+function buildTfMap(tokens) {
+  const tf = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    tf.set(token, (tf.get(token) || 0) + 1);
+  }
+  return tf;
+}
+function extractKeywords(text, language, maxKeywords = 30) {
+  const langData = getLanguageData(language);
+  const stopWords = new Set(langData.stopWords);
+  const tokens = tokenize(text, stopWords);
+  const stemmed = tokens.map((t) => simpleStem(t, language));
+  const tf = buildTfMap(stemmed);
+  const stemToOriginal = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tokens.length; i++) {
+    const stem = stemmed[i] ?? "";
+    if (!stemToOriginal.has(stem)) {
+      stemToOriginal.set(stem, tokens[i] ?? "");
+    }
+  }
+  return [...tf.entries()].filter(([stem]) => stem.length > 2).sort((a, b) => b[1] - a[1]).slice(0, maxKeywords).map(([stem]) => stemToOriginal.get(stem) || stem);
+}
+function matchJobDescription(resume, jobDescription, language = "en") {
+  const langData = getLanguageData(language);
+  const stopWords = new Set(langData.stopWords);
+  const jdKeywords = extractKeywords(jobDescription, language);
+  const resumeText = extractResumeText(resume);
+  const resumeTokens = tokenize(resumeText, stopWords);
+  const resumeStems = new Set(resumeTokens.map((t) => simpleStem(t, language)));
+  const resumeTokenSet = new Set(resumeTokens);
+  const matched = [];
+  const missing = [];
+  for (const keyword of jdKeywords) {
+    const stem = simpleStem(keyword, language);
+    if (resumeStems.has(stem) || resumeTokenSet.has(keyword.toLowerCase())) {
+      matched.push(keyword);
+    } else {
+      missing.push(keyword);
+    }
+  }
+  const matchPercentage = jdKeywords.length > 0 ? Math.round(matched.length / jdKeywords.length * 100) : 0;
+  return { matched, missing, matchPercentage };
+}
+
+// src/ats/scoring.ts
+init_cjs_shims();
+var weightMultiplier = {
+  high: 3,
+  medium: 2,
+  low: 1
+};
+function calculateScore(checks) {
+  if (checks.length === 0) return 0;
+  let weightedSum = 0;
+  let totalWeight = 0;
+  for (const check of checks) {
+    const mult = weightMultiplier[check.weight] || 1;
+    weightedSum += check.score * mult;
+    totalWeight += 100 * mult;
+  }
+  return totalWeight > 0 ? Math.round(weightedSum / totalWeight * 100) : 0;
+}
+function calculateCombinedScore(genericScore, jdMatchPercentage) {
+  if (jdMatchPercentage === void 0) return genericScore;
+  return Math.round(genericScore * 0.6 + jdMatchPercentage * 0.4);
+}
+function scoreToRating(score) {
+  if (score >= 90) return "excellent";
+  if (score >= 75) return "good";
+  if (score >= 60) return "needs-work";
+  return "poor";
+}
+function generateSummary(score, rating, hasJd) {
+  const ratingLabel = {
+    excellent: "Excellent",
+    good: "Good",
+    "needs-work": "Needs Work",
+    poor: "Poor"
+  }[rating];
+  const base = `ATS Score: ${score}/100 (${ratingLabel})`;
+  if (hasJd) {
+    return `${base} \u2014 includes job description keyword matching.`;
+  }
+  return `${base} \u2014 based on resume structure and content best practices.`;
+}
+
+// src/ats/index.ts
+function analyzeAts(resume, options = {}) {
+  const language = options.language || "en";
+  const checks = runGenericChecks(resume, language);
+  const genericScore = calculateScore(checks);
+  let keywords;
+  if (options.jobDescription) {
+    keywords = matchJobDescription(resume, options.jobDescription, language);
+  }
+  const finalScore = calculateCombinedScore(genericScore, keywords?.matchPercentage);
+  const rating = scoreToRating(finalScore);
+  const summary = generateSummary(finalScore, rating, !!keywords);
+  return {
+    score: finalScore,
+    rating,
+    checks,
+    keywords,
+    summary
+  };
+}
+
 // src/commands/validate.ts
+function formatAtsReport(result, debug, chalk6) {
+  const scoreColor = result.score >= 75 ? chalk6.green : result.score >= 60 ? chalk6.yellow : chalk6.red;
+  console.log("");
+  console.log(chalk6.bold("\u2550\u2550\u2550 ATS Analysis Report \u2550\u2550\u2550"));
+  console.log("");
+  console.log(`  Score: ${scoreColor(chalk6.bold(`${result.score}/100`))} (${result.rating.replace("-", " ")})`);
+  console.log(`  ${result.summary}`);
+  console.log("");
+  const categories = {};
+  for (const check of result.checks) {
+    const list = categories[check.category];
+    if (!list) {
+      categories[check.category] = [check];
+    } else {
+      list.push(check);
+    }
+  }
+  const categoryLabels = {
+    contact: "Contact Information",
+    content: "Content Quality",
+    structure: "Resume Structure",
+    keywords: "Keywords"
+  };
+  for (const [cat, checks] of Object.entries(categories)) {
+    const label = categoryLabels[cat] || cat;
+    console.log(chalk6.bold(`  ${label}`));
+    for (const check of checks) {
+      if (!debug && check.passed) continue;
+      const icon = check.passed ? chalk6.green("\u2713") : chalk6.red("\u2717");
+      const scoreText = chalk6.dim(`[${check.score}]`);
+      console.log(`    ${icon} ${check.message} ${scoreText}`);
+      if (!check.passed && check.suggestion) {
+        console.log(chalk6.dim(`      \u2192 ${check.suggestion}`));
+      }
+    }
+    console.log("");
+  }
+  if (result.keywords) {
+    console.log(chalk6.bold("  Job Description Match"));
+    const kw = result.keywords;
+    const matchColor = kw.matchPercentage >= 70 ? chalk6.green : kw.matchPercentage >= 50 ? chalk6.yellow : chalk6.red;
+    console.log(`    Match: ${matchColor(`${kw.matchPercentage}%`)} (${kw.matched.length}/${kw.matched.length + kw.missing.length} keywords)`);
+    if (kw.matched.length > 0) {
+      console.log(chalk6.green(`    \u2713 Matched: ${kw.matched.join(", ")}`));
+    }
+    if (kw.missing.length > 0) {
+      console.log(chalk6.red(`    \u2717 Missing: ${kw.missing.join(", ")}`));
+      console.log(chalk6.dim("      \u2192 Consider incorporating these keywords into your resume where relevant."));
+    }
+    console.log("");
+  }
+  console.log(chalk6.dim("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+}
 async function validateAction(options) {
   const chalk6 = (await import("chalk")).default;
   console.log(chalk6.blue("Starting resuml validate..."));
@@ -6829,13 +7835,41 @@ async function validateAction(options) {
     const inputPath = options.resume;
     const { yamlContents } = await loadResumeFiles(inputPath);
     console.log(chalk6.blue("Validating resume data..."));
+    let resumeData;
     try {
-      await processResumeData(yamlContents);
+      resumeData = await processResumeData(yamlContents);
       console.log(chalk6.green("\u2713 Resume data is valid against the schema!"));
     } catch (error) {
       handleCommandError(error, "validate", options.debug);
       return;
     }
+    if (options.ats) {
+      console.log(chalk6.blue("Running ATS analysis..."));
+      let jobDescription;
+      if (options.jd) {
+        try {
+          jobDescription = import_fs2.default.readFileSync(options.jd, "utf8");
+        } catch {
+          console.error(chalk6.red(`Failed to read job description file: ${options.jd}`));
+          return;
+        }
+      }
+      const result = analyzeAts(resumeData, {
+        language: "en",
+        jobDescription
+      });
+      if (options.format === "json") {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        formatAtsReport(result, !!options.debug, chalk6);
+      }
+      const threshold = options.atsThreshold ? parseInt(options.atsThreshold, 10) : void 0;
+      if (threshold !== void 0 && result.score < threshold) {
+        console.error(chalk6.red(`
+ATS score ${result.score} is below threshold ${threshold}.`));
+        process.exit(1);
+      }
+    }
   } catch (error) {
     handleCommandError(error, "validate", options.debug);
   }
@@ -6843,7 +7877,7 @@ async function validateAction(options) {
 
 // src/commands/tojson.ts
 init_cjs_shims();
-var import_fs2 = __toESM(require("fs"));
+var import_fs3 = __toESM(require("fs"), 1);
 async function toJsonAction(options) {
   const chalk6 = (await import("chalk")).default;
   console.log(chalk6.blue("Starting resuml tojson..."));
@@ -6854,7 +7888,7 @@ async function toJsonAction(options) {
     const resumeData = await processResumeData(yamlContents);
     console.log(chalk6.green("Processing and validation successful!"));
     const jsonOutput = JSON.stringify(resumeData, null, 2);
-    import_fs2.default.writeFileSync(options.output, jsonOutput, "utf8");
+    import_fs3.default.writeFileSync(options.output, jsonOutput, "utf8");
     console.log(chalk6.green(`Successfully wrote output to ${options.output}`));
   } catch (error) {
     handleCommandError(error, "tojson", options.debug);
@@ -6863,15 +7897,15 @@ async function toJsonAction(options) {
 
 // src/commands/render.ts
 init_cjs_shims();
-var import_fs3 = __toESM(require("fs"));
-var import_node_path2 = __toESM(require("path"));
+var import_fs4 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 
 // src/utils/themeLoader.ts
 init_cjs_shims();
 var import_child_process = require("child_process");
 var import_module = require("module");
 var require2 = (0, import_module.createRequire)(importMetaUrl);
-async function installTheme(packageName) {
+function installTheme(packageName) {
   try {
     (0, import_child_process.execFileSync)("npm", ["install", packageName], {
       stdio: ["inherit", "pipe", "pipe"],
@@ -6881,7 +7915,7 @@ async function installTheme(packageName) {
     throw new Error(`Failed to install ${packageName}: ${error.message}`);
   }
 }
-async function loadTheme(themeName, options) {
+function loadTheme(themeName, options) {
   let jsonResumeThemeName;
   let nativeThemeName;
   const autoInstall = options?.autoInstall !== false;
@@ -6902,7 +7936,7 @@ Please install the theme package manually.`
         }
         console.log(`\u{1F4E6} Theme ${jsonResumeThemeName} not found. Installing...`);
         try {
-          await installTheme(jsonResumeThemeName);
+          installTheme(jsonResumeThemeName);
           console.log(`\u2705 Successfully installed ${jsonResumeThemeName}`);
           return require2(jsonResumeThemeName);
         } catch (installError) {
@@ -6921,7 +7955,7 @@ Please install the theme package manually.`
 }
 
 // src/commands/render.ts
-var import_chalk = __toESM(require("chalk"));
+var import_chalk = __toESM(require("chalk"), 1);
 async function renderAction(options) {
   if (!options.theme) {
     throw new Error(
@@ -6935,15 +7969,39 @@ async function renderAction(options) {
     console.log(import_chalk.default.blue("Processing and validating resume data..."));
     const resumeData = await processResumeData(yamlContents);
     console.log(import_chalk.default.green("Resume data processing and validation successful!"));
-    const theme = await loadTheme(options.theme);
+    const theme = loadTheme(options.theme);
     const htmlOutput = await theme.render(resumeData, {
       locale: options.language
     });
-    const outputHtmlPath = options.output || "resume.html";
-    console.log(import_chalk.default.blue(`Writing HTML output to ${outputHtmlPath}...`));
-    import_fs3.default.mkdirSync(import_node_path2.default.dirname(outputHtmlPath), { recursive: true });
-    import_fs3.default.writeFileSync(outputHtmlPath, htmlOutput, "utf8");
-    console.log(import_chalk.default.green(`Successfully wrote HTML output to ${outputHtmlPath}`));
+    const defaultExtension = options.format;
+    const defaultFilename = `resume.${defaultExtension}`;
+    const outputPath = options.output || defaultFilename;
+    if (options.format === "pdf") {
+      console.log(import_chalk.default.blue(`Generating PDF output at ${outputPath}...`));
+      const { chromium } = await import("playwright");
+      const browser = await chromium.launch();
+      const page = await browser.newPage();
+      await page.setContent(htmlOutput, { waitUntil: "networkidle" });
+      const pdfBuffer = await page.pdf({
+        path: outputPath,
+        format: "A4",
+        printBackground: true,
+        margin: {
+          top: "1cm",
+          right: "1cm",
+          bottom: "1cm",
+          left: "1cm"
+        }
+      });
+      await browser.close();
+      import_fs4.default.writeFileSync(outputPath, pdfBuffer);
+      console.log(import_chalk.default.green(`Successfully wrote PDF output to ${outputPath}`));
+    } else {
+      console.log(import_chalk.default.blue(`Writing HTML output to ${outputPath}...`));
+      import_fs4.default.mkdirSync(import_node_path2.default.dirname(outputPath), { recursive: true });
+      import_fs4.default.writeFileSync(outputPath, htmlOutput, "utf8");
+      console.log(import_chalk.default.green(`Successfully wrote HTML output to ${outputPath}`));
+    }
   } catch (error) {
     handleCommandError(error, "render", options.debug);
   }
@@ -6951,9 +8009,9 @@ async function renderAction(options) {
 
 // src/commands/dev.ts
 init_cjs_shims();
-var import_fs4 = __toESM(require("fs"));
-var import_node_path3 = __toESM(require("path"));
-var import_chalk2 = __toESM(require("chalk"));
+var import_fs5 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_chalk2 = __toESM(require("chalk"), 1);
 async function devAction(options) {
   if (!options.theme) {
     throw new Error(
@@ -6970,10 +8028,14 @@ async function devAction(options) {
     await renderResume(options);
     console.log(import_chalk2.default.green(`\u{1F680} Development server running at http://localhost:${port}`));
     console.log(import_chalk2.default.blue("Watching for file changes..."));
-    if (import_fs4.default.existsSync(inputPath) && import_fs4.default.statSync(inputPath).isDirectory()) {
-      watchDirectory(inputPath, () => renderResume(options));
-    } else if (import_fs4.default.existsSync(inputPath)) {
-      watchFile(inputPath, () => renderResume(options));
+    if (import_fs5.default.existsSync(inputPath) && import_fs5.default.statSync(inputPath).isDirectory()) {
+      watchDirectory(inputPath, () => {
+        void renderResume(options);
+      });
+    } else if (import_fs5.default.existsSync(inputPath)) {
+      watchFile(inputPath, () => {
+        void renderResume(options);
+      });
     }
     await startDevServer(port);
   } catch (error) {
@@ -6989,20 +8051,20 @@ async function renderResume(options) {
     const { yamlContents } = await loadResumeFiles(inputPath);
     console.log(import_chalk2.default.blue("\u{1F504} Processing resume data..."));
     const resumeData = await processResumeData(yamlContents);
-    const theme = await loadTheme(options.theme);
+    const theme = loadTheme(options.theme ?? "stackoverflow");
     const htmlOutput = await theme.render(resumeData, {
       locale: options.language
     });
     const outputPath = import_node_path3.default.join(process.cwd(), ".resuml-dev", "index.html");
-    import_fs4.default.mkdirSync(import_node_path3.default.dirname(outputPath), { recursive: true });
-    import_fs4.default.writeFileSync(outputPath, htmlOutput, "utf8");
+    import_fs5.default.mkdirSync(import_node_path3.default.dirname(outputPath), { recursive: true });
+    import_fs5.default.writeFileSync(outputPath, htmlOutput, "utf8");
     console.log(import_chalk2.default.green("\u2705 Resume updated!"));
   } catch (error) {
     console.error(import_chalk2.default.red("\u274C Error rendering resume:"), error.message);
   }
 }
 function watchDirectory(dirPath, callback) {
-  import_fs4.default.watch(dirPath, { recursive: true }, (eventType, filename) => {
+  import_fs5.default.watch(dirPath, { recursive: true }, (_eventType, filename) => {
     if (filename && (filename.endsWith(".yaml") || filename.endsWith(".yml"))) {
       console.log(import_chalk2.default.blue(`\u{1F4C1} File changed: ${filename}`));
       callback();
@@ -7010,7 +8072,7 @@ function watchDirectory(dirPath, callback) {
   });
 }
 function watchFile(filePath, callback) {
-  import_fs4.default.watch(filePath, (eventType) => {
+  import_fs5.default.watch(filePath, (eventType) => {
     if (eventType === "change") {
       console.log(import_chalk2.default.blue(`\u{1F4C4} File changed: ${import_node_path3.default.basename(filePath)}`));
       callback();
@@ -7025,8 +8087,8 @@ async function startDevServer(port) {
     const pathname = parsedUrl.pathname || "/";
     if (pathname === "/" || pathname === "/index.html") {
       const htmlPath = import_node_path3.default.join(process.cwd(), ".resuml-dev", "index.html");
-      if (import_fs4.default.existsSync(htmlPath)) {
-        const html = import_fs4.default.readFileSync(htmlPath, "utf8");
+      if (import_fs5.default.existsSync(htmlPath)) {
+        const html = import_fs5.default.readFileSync(htmlPath, "utf8");
         const liveReloadScript = `
           <script>
             setInterval(() => {
@@ -7060,10 +8122,10 @@ async function startDevServer(port) {
 
 // src/commands/init.ts
 init_cjs_shims();
-var import_fs5 = __toESM(require("fs"));
-var import_path2 = __toESM(require("path"));
-var import_readline = __toESM(require("readline"));
-var import_chalk3 = __toESM(require("chalk"));
+var import_fs6 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var import_readline = __toESM(require("readline"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
 function createReadlineInterface() {
   return import_readline.default.createInterface({
     input: process.stdin,
@@ -7221,7 +8283,7 @@ async function initAction(options) {
   const fullPath = import_path2.default.resolve(outputPath);
   const rl = createReadlineInterface();
   try {
-    if (import_fs5.default.existsSync(fullPath)) {
+    if (import_fs6.default.existsSync(fullPath)) {
       const overwrite = await ask(
         rl,
         `${import_chalk3.default.yellow("\u26A0")}  ${outputPath} already exists. Overwrite? (y/N)`,
@@ -7237,8 +8299,8 @@ async function initAction(options) {
     const email = await ask(rl, "Email address", "john@example.com");
     const label = await ask(rl, "Professional title/label", "Software Engineer");
     const yaml = generateResumeYaml(name, email, label);
-    import_fs5.default.mkdirSync(import_path2.default.dirname(fullPath), { recursive: true });
-    import_fs5.default.writeFileSync(fullPath, yaml, "utf8");
+    import_fs6.default.mkdirSync(import_path2.default.dirname(fullPath), { recursive: true });
+    import_fs6.default.writeFileSync(fullPath, yaml, "utf8");
     console.log(import_chalk3.default.green(`
 \u2705 Created ${outputPath}`));
     console.log(import_chalk3.default.blue("\nNext steps:"));
@@ -7252,18 +8314,17 @@ async function initAction(options) {
 
 // src/commands/pdf.ts
 init_cjs_shims();
-var import_fs6 = __toESM(require("fs"));
-var import_node_path4 = __toESM(require("path"));
-var import_chalk4 = __toESM(require("chalk"));
-async function loadPuppeteer() {
+var import_fs7 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_chalk4 = __toESM(require("chalk"), 1);
+async function loadPlaywright() {
   try {
-    const puppeteer = await import("puppeteer");
-    return puppeteer.default || puppeteer;
+    const { chromium } = await import("playwright");
+    return chromium;
   } catch {
     throw new Error(
-      `Puppeteer is required for PDF export but is not installed.
-Install it with: ${import_chalk4.default.cyan("npm install puppeteer")}
-Or for a smaller download: ${import_chalk4.default.cyan("npm install puppeteer-core")}`
+      `Playwright is required for PDF export but is not installed.
+Install it with: ${import_chalk4.default.cyan("npm install playwright")}`
     );
   }
 }
@@ -7271,13 +8332,13 @@ function parseMargin(margin) {
   const defaultMargin = { top: "10mm", right: "10mm", bottom: "10mm", left: "10mm" };
   if (!margin) return defaultMargin;
   const parts = margin.split(",").map((s) => s.trim());
-  if (parts.length === 1) {
+  if (parts.length === 1 && parts[0]) {
     return { top: parts[0], right: parts[0], bottom: parts[0], left: parts[0] };
   }
-  if (parts.length === 2) {
+  if (parts.length === 2 && parts[0] && parts[1]) {
     return { top: parts[0], right: parts[1], bottom: parts[0], left: parts[1] };
   }
-  if (parts.length === 4) {
+  if (parts.length === 4 && parts[0] && parts[1] && parts[2] && parts[3]) {
     return { top: parts[0], right: parts[1], bottom: parts[2], left: parts[3] };
   }
   return defaultMargin;
@@ -7295,28 +8356,28 @@ async function pdfAction(options) {
     console.log(import_chalk4.default.blue("Processing and validating resume data..."));
     const resumeData = await processResumeData(yamlContents);
     console.log(import_chalk4.default.green("Resume data processing and validation successful!"));
-    const theme = await loadTheme(options.theme);
+    const theme = loadTheme(options.theme);
     const htmlOutput = await theme.render(resumeData, {
       locale: options.language
     });
-    console.log(import_chalk4.default.blue("Loading Puppeteer..."));
-    const puppeteer = await loadPuppeteer();
+    console.log(import_chalk4.default.blue("Loading Playwright..."));
+    const chromium = await loadPlaywright();
     const outputPath = options.output || "resume.pdf";
     const format = options.format === "Letter" ? "Letter" : "A4";
     const margin = parseMargin(options.margin);
     console.log(import_chalk4.default.blue(`Generating PDF (${format} format)...`));
-    const browser = await puppeteer.launch({ headless: true });
+    const browser = await chromium.launch({ headless: true });
     try {
       const page = await browser.newPage();
-      await page.setContent(htmlOutput, { waitUntil: "networkidle0" });
+      await page.setContent(htmlOutput, { waitUntil: "networkidle" });
       const pdfBuffer = await page.pdf({
         format,
         margin,
         printBackground: true,
         preferCSSPageSize: true
       });
-      import_fs6.default.mkdirSync(import_node_path4.default.dirname(import_node_path4.default.resolve(outputPath)), { recursive: true });
-      import_fs6.default.writeFileSync(outputPath, pdfBuffer);
+      import_fs7.default.mkdirSync(import_node_path4.default.dirname(import_node_path4.default.resolve(outputPath)), { recursive: true });
+      import_fs7.default.writeFileSync(outputPath, pdfBuffer);
       console.log(import_chalk4.default.green(`\u2705 Successfully generated ${outputPath}`));
     } finally {
       await browser.close();
@@ -7328,7 +8389,7 @@ async function pdfAction(options) {
 
 // src/commands/themes.ts
 init_cjs_shims();
-var import_chalk5 = __toESM(require("chalk"));
+var import_chalk5 = __toESM(require("chalk"), 1);
 var import_child_process2 = require("child_process");
 var import_module2 = require("module");
 var KNOWN_THEMES = [
@@ -7358,7 +8419,7 @@ function getInstalledVersion(pkg) {
   try {
     const require3 = (0, import_module2.createRequire)(process.cwd() + "/");
     const pkgJson = require3(`${pkg}/package.json`);
-    return pkgJson.version || null;
+    return pkgJson.version ?? null;
   } catch {
     return null;
   }
@@ -7407,7 +8468,7 @@ Use it with: ${import_chalk5.default.cyan(`resuml render --theme ${known?.name |
 `));
   }
 }
-async function themesAction(options) {
+function themesAction(options) {
   if (options.install) {
     installTheme2(options.install);
   } else {
@@ -7472,10 +8533,10 @@ function injectCss(html, css) {
 var currentDir = import_path3.default.dirname((0, import_url.fileURLToPath)(importMetaUrl));
 function getCliVersion() {
   const packageJsonPath = import_path3.default.resolve(currentDir, "../package.json");
-  if (import_fs7.default.existsSync(packageJsonPath)) {
+  if (import_fs8.default.existsSync(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(import_fs7.default.readFileSync(packageJsonPath, "utf8"));
-      return packageJson.version || "0.0.0";
+      const packageJson = JSON.parse(import_fs8.default.readFileSync(packageJsonPath, "utf8"));
+      return packageJson.version ?? "0.0.0";
     } catch {
       return "0.0.0";
     }
@@ -7484,29 +8545,30 @@ function getCliVersion() {
 }
 var program = new import_commander.Command();
 program.name("resuml").description("CLI tool for managing resuml resume files.").version(getCliVersion());
-program.command("validate").description("Validates resume data against the schema.").option("-r, --resume <path>", "Input YAML file, directory, or glob pattern.").option("--debug", "Show detailed validation errors.").action(validateAction);
+program.command("validate").description("Validates resume data against the schema.").option("-r, --resume <path>", "Input YAML file, directory, or glob pattern.").option("--debug", "Show detailed validation errors.").option("--ats", "Run ATS (Applicant Tracking System) compatibility analysis.").option("--jd <path>", "Path to a job description file for keyword matching (requires --ats).").option("--ats-threshold <score>", "Minimum ATS score (0-100). Exit with code 1 if below threshold.").option("--format <type>", "Output format for ATS results (text or json).", "text").action(validateAction);
 program.command("tojson").description("Converts YAML resume data to JSON format.").option("-r, --resume <path>", "Input YAML file, directory, or glob pattern.").option("-o, --output <file>", "Output JSON file path.", "resume.json").option("--debug", "Show detailed validation and processing information.").action(toJsonAction);
-program.command("render").description("Renders the resume data using a specified theme.").option("-r, --resume <path>", "Input YAML file, directory, or glob pattern.").option("-t, --theme <name>", "Theme name (e.g., stackoverflow, react).").option("-o, --output <file>", "Output HTML file path (defaults to resume.html).").option("--language <code>", "Language code for localization.", "en").option("--debug", "Show detailed validation and processing information.").action(renderAction);
+program.command("render").description("Renders the resume data using a specified theme.").option("-r, --resume <path>", "Input YAML file, directory, or glob pattern.").option("-t, --theme <name>", "Theme name (e.g., stackoverflow, react).").option("-o, --output <file>", "Output file path.").option("--format <type>", "Output format (html or pdf).", "html").option("--language <code>", "Language code for localization.", "en").option("--debug", "Show detailed validation and processing information.").action(renderAction);
 program.command("dev").description("Start development server with hot-reload.").option("-r, --resume <path>", "Input YAML file, directory, or glob pattern.").option("-t, --theme <name>", "Theme name (e.g., stackoverflow, react).").option("--port <number>", "Port for development server.", "3000").option("--language <code>", "Language code for localization.", "en").option("--debug", "Show detailed validation and processing information.").action(devAction);
 program.command("init").description("Scaffold a starter resume.yaml file with all sections.").option("-o, --output <file>", "Output YAML file path.", "resume.yaml").action(initAction);
-program.command("pdf").description("Export resume as PDF using Puppeteer.").option("-r, --resume <path>", "Input YAML file, directory, or glob pattern.").option("-t, --theme <name>", "Theme name (e.g., stackoverflow, react).").option("-o, --output <file>", "Output PDF file path.", "resume.pdf").option("--language <code>", "Language code for localization.", "en").option("--format <size>", "Page format: A4 or Letter.", "A4").option("--margin <values>", 'Page margins (e.g., "10mm" or "10mm,15mm,10mm,15mm").').option("--debug", "Show detailed validation and processing information.").action(pdfAction);
+program.command("pdf").description("Export resume as PDF using Playwright.").option("-r, --resume <path>", "Input YAML file, directory, or glob pattern.").option("-t, --theme <name>", "Theme name (e.g., stackoverflow, react).").option("-o, --output <file>", "Output PDF file path.", "resume.pdf").option("--language <code>", "Language code for localization.", "en").option("--format <size>", "Page format: A4 or Letter.", "A4").option("--margin <values>", 'Page margins (e.g., "10mm" or "10mm,15mm,10mm,15mm").').option("--debug", "Show detailed validation and processing information.").action(pdfAction);
 program.command("themes").description("List available JSON Resume themes and install them.").option("--install <name>", "Install a theme by name (e.g., stackoverflow, elegant).").action(themesAction);
-if (process.env.NODE_ENV !== "test") {
-  (async () => {
+if (process.env["NODE_ENV"] !== "test") {
+  void (async () => {
     try {
       await program.parseAsync(process.argv);
     } catch (e) {
-      console.error("Command line error:", e?.message);
+      console.error("Command line error:", e.message);
       process.exit(1);
     }
   })();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  analyzeAts,
   loadResumeFiles,
   loadTheme,
   processResumeData,
   program,
   themeRender
 });
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.cjs.map