md-2-ats 0.1.0

package/dist/cli.js

@@ -0,0 +1,935 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync, realpathSync } from "fs";
+import { extname, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// src/generate.ts
+import { readFile, writeFile } from "fs/promises";
+
+// src/validator/index.ts
+import { marked as marked2 } from "marked";
+
+// src/parser/index.ts
+import { marked } from "marked";
+function parseMarkdown(markdown) {
+  const tokens = marked.lexer(markdown);
+  const blocks = [];
+  for (const token of tokens) {
+    const block = parseBlock(token);
+    if (block) {
+      blocks.push(block);
+    }
+  }
+  return { blocks };
+}
+function parseBlock(token) {
+  switch (token.type) {
+    case "heading": {
+      const heading = token;
+      const level = clampHeadingLevel(heading.depth);
+      return { type: "heading", level, children: parseInline(heading.tokens) };
+    }
+    case "paragraph":
+      return { type: "paragraph", children: parseInline(token.tokens ?? []) };
+    case "list":
+      return parseList(token);
+    case "hr":
+      return { type: "thematicBreak" };
+    case "blockquote":
+      return parseBlockquote(token);
+    case "space":
+      return null;
+    default:
+      return null;
+  }
+}
+function parseBlockquote(token) {
+  const children = [];
+  for (const block of token.tokens ?? []) {
+    if (block.type === "paragraph") {
+      if (children.length > 0) {
+        children.push({ type: "text", text: " " });
+      }
+      children.push(...parseInline(block.tokens ?? []));
+    }
+  }
+  return { type: "blockquote", children };
+}
+function parseList(token) {
+  return {
+    type: "list",
+    ordered: token.ordered,
+    items: token.items.map(parseListItem)
+  };
+}
+function parseListItem(item) {
+  const children = [];
+  const nested = [];
+  for (const block of item.tokens ?? []) {
+    if (block.type === "list") {
+      nested.push(parseList(block));
+    } else if ("tokens" in block && block.tokens) {
+      children.push(...parseInline(block.tokens));
+    }
+  }
+  return { children, ...nested.length > 0 ? { nested } : {} };
+}
+function clampHeadingLevel(depth) {
+  return Math.min(Math.max(depth, 1), 3);
+}
+function parseInline(tokens) {
+  const nodes = [];
+  for (const token of tokens) {
+    switch (token.type) {
+      case "text": {
+        const text = token;
+        nodes.push({ type: "text", text: text.text });
+        break;
+      }
+      case "strong": {
+        const strong = token;
+        nodes.push({ type: "strong", children: parseInline(strong.tokens) });
+        break;
+      }
+      case "em": {
+        const em = token;
+        nodes.push({ type: "emphasis", children: parseInline(em.tokens) });
+        break;
+      }
+      case "link": {
+        const link = token;
+        nodes.push({ type: "link", text: link.text, href: link.href });
+        break;
+      }
+      case "image": {
+        const image = token;
+        nodes.push({ type: "image", href: image.href });
+        break;
+      }
+      case "codespan": {
+        const codespan = token;
+        nodes.push({ type: "text", text: codespan.text });
+        break;
+      }
+    }
+  }
+  return nodes;
+}
+
+// src/validator/index.ts
+var EMAIL_REGEX = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i;
+var RAW_EMAIL_REGEX = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i;
+function validateCV(markdown) {
+  const doc = parseMarkdown(markdown);
+  if (doc.blocks.length === 0) {
+    return { issues: [{ severity: "error", message: "Document is empty." }], valid: false };
+  }
+  const issues = [];
+  const hasName = doc.blocks.some((b) => b.type === "heading" && b.level === 1);
+  if (!hasName) {
+    issues.push({
+      severity: "error",
+      message: 'Missing a level-1 heading. Add "# Your Name" for the candidate name.'
+    });
+  }
+  validateContact(doc, issues);
+  validateHierarchy(doc, issues);
+  validateSection(doc, "experience", issues);
+  validateSection(doc, "education", issues);
+  detectUnsupported(markdown, issues);
+  return { issues, valid: issues.every((i) => i.severity !== "error") };
+}
+function validateContact(doc, issues) {
+  const texts = flattenText(doc);
+  const links = flattenLinks(doc);
+  const emails = /* @__PURE__ */ new Set();
+  for (const t of texts) {
+    const m = t.match(RAW_EMAIL_REGEX);
+    if (m) emails.add(m[0]);
+  }
+  for (const href of links) {
+    if (href.startsWith("mailto:")) emails.add(href.slice("mailto:".length).split("?")[0] ?? "");
+  }
+  const validEmails = [...emails].filter((e) => EMAIL_REGEX.test(e));
+  const hasContactLink = links.some((href) => {
+    const lower = href.toLowerCase();
+    return /mailto:|github\.com|linkedin\.com|twitter\.com|x\.com|dev\.to|t\.me/.test(lower);
+  });
+  if (validEmails.length === 0 && !hasContactLink) {
+    issues.push({
+      severity: "warning",
+      message: "No contact info found. Add an email or a contact link (e.g. mailto:, github, linkedin)."
+    });
+  }
+  if ([...emails].some((e) => !EMAIL_REGEX.test(e))) {
+    issues.push({
+      severity: "warning",
+      message: `Invalid email address found: "${[...emails].filter((e) => !EMAIL_REGEX.test(e)).join(", ")}".`
+    });
+  }
+}
+function validateHierarchy(doc, issues) {
+  let prevLevel = 0;
+  doc.blocks.forEach((block, index) => {
+    if (block.type !== "heading") return;
+    if (prevLevel !== 0 && block.level > prevLevel + 1) {
+      issues.push({
+        severity: "warning",
+        blockIndex: index,
+        message: `Heading level skipped from H${prevLevel} to H${block.level}. Prefer H1 \u2192 H2 \u2192 H3 order.`
+      });
+    }
+    prevLevel = block.level;
+  });
+}
+function validateSection(doc, sectionName, issues) {
+  const headings = [];
+  doc.blocks.forEach((block, index) => {
+    if (block.type === "heading") headings.push({ block, index });
+  });
+  const target = headings.find(
+    ({ block }) => block.level === 2 && headingText(block).toLowerCase() === sectionName
+  );
+  if (!target) {
+    issues.push({
+      severity: "warning",
+      message: `Section "${sectionName}" not found. Add "## ${sectionName}" heading.`
+    });
+    return;
+  }
+  const body = [];
+  const nextSection = doc.blocks.slice(target.index + 1).findIndex((b) => b.type === "heading" && b.level === 2);
+  const end = nextSection === -1 ? doc.blocks.length : target.index + 1 + nextSection;
+  for (let k = target.index + 1; k < end; k++) {
+    const block = doc.blocks[k];
+    if (block) body.push({ block, index: k });
+  }
+  const hasBody = body.some(({ block }) => block.type !== "heading" && block.type !== "thematicBreak");
+  if (!hasBody) {
+    issues.push({
+      severity: "warning",
+      blockIndex: target.index,
+      message: `Section "${sectionName}" has no content below its heading.`
+    });
+    return;
+  }
+  const entries = body.filter(
+    (s) => s.block.type === "heading" && s.block.level === 3
+  );
+  entries.forEach(({ block, index }) => {
+    const hasContent = body.filter((s) => s.index > index).some(({ block: b }) => b.type !== "heading" && b.type !== "thematicBreak");
+    if (!hasContent) {
+      issues.push({
+        severity: "warning",
+        blockIndex: index,
+        message: `Entry "${headingText(block)}" in "${sectionName}" has no content below it.`
+      });
+    }
+  });
+}
+function detectUnsupported(markdown, issues) {
+  const supported = /* @__PURE__ */ new Set(["space", "heading", "paragraph", "list", "hr", "blockquote"]);
+  for (const token of marked2.lexer(markdown)) {
+    if (!supported.has(token.type)) {
+      issues.push({
+        severity: "warning",
+        message: `Unsupported Markdown ignored: "${token.type}".`
+      });
+    }
+  }
+}
+function headingText(block) {
+  return inlineText(block.children);
+}
+function inlineText(nodes) {
+  let out = "";
+  for (const node of nodes) {
+    switch (node.type) {
+      case "text":
+        out += node.text;
+        break;
+      case "strong":
+      case "emphasis":
+        out += inlineText(node.children);
+        break;
+      case "link":
+        out += node.text;
+        break;
+      case "image":
+        break;
+    }
+  }
+  return out;
+}
+function flattenText(doc) {
+  const out = [];
+  for (const block of doc.blocks) {
+    if (block.type === "paragraph") out.push(inlineText(block.children));
+    else if (block.type === "heading") out.push(inlineText(block.children));
+  }
+  return out;
+}
+function flattenLinks(doc) {
+  const out = [];
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.type === "link") out.push(node.href);
+      else if (node.type === "strong" || node.type === "emphasis") walk(node.children);
+    }
+  };
+  for (const block of doc.blocks) {
+    if (block.type === "paragraph") walk(block.children);
+    else if (block.type === "heading") walk(block.children);
+  }
+  return out;
+}
+
+// src/renderer/index.ts
+import { PDFDocument as PDFDocument2 } from "pdf-lib";
+
+// src/theme/default.ts
+function createDefaultTheme() {
+  return {
+    name: "ats-simple",
+    text: {
+      name: { family: "Helvetica", size: 22, weight: "bold" },
+      section: { family: "Helvetica", size: 13, weight: "bold" },
+      entryTitle: { family: "Helvetica", size: 11, weight: "bold" },
+      body: { family: "Helvetica", size: 10, weight: "normal" }
+    },
+    color: {
+      ink: { r: 0.1, g: 0.1, b: 0.1 },
+      accent: { r: 0.05, g: 0.15, b: 0.4 },
+      muted: { r: 0.35, g: 0.35, b: 0.35 }
+    },
+    spacing: {
+      sectionGap: 6,
+      entryGap: 6,
+      entrySpacing: 8,
+      lineHeight: 1.35,
+      columnGap: 8,
+      headerGap: 8
+    }
+  };
+}
+
+// src/renderer/render.ts
+import { StandardFonts, rgb } from "pdf-lib";
+import fontkit from "@pdf-lib/fontkit";
+
+// src/page/config.ts
+var A4 = Object.freeze({ width: 595.28, height: 841.89 });
+function contentWidth(page) {
+  return page.size.width - page.margin.left - page.margin.right;
+}
+function contentHeight(page) {
+  return page.size.height - page.margin.top - page.margin.bottom;
+}
+function createA4(margin = {}) {
+  const marginValue = {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...margin
+  };
+  return { size: { ...A4 }, margin: marginValue };
+}
+
+// src/page/flow.ts
+function createFlow(page) {
+  const cursor = { x: 0, y: 0 };
+  let pageNumber = 0;
+  return {
+    get page() {
+      return page;
+    },
+    get cursor() {
+      return cursor;
+    },
+    get pageNumber() {
+      return pageNumber;
+    },
+    contentWidth: () => contentWidth(page),
+    contentHeight: () => contentHeight(page),
+    isLastPageEmpty: () => cursor.y === 0,
+    needNewPage: (dy) => cursor.y + dy >= contentHeight(page),
+    newPage: () => {
+      pageNumber += 1;
+      cursor.x = 0;
+      cursor.y = 0;
+    },
+    advance: (dy) => {
+      cursor.y += dy;
+    }
+  };
+}
+
+// src/renderer/measure.ts
+function measureWidth(run) {
+  return run.style.font.widthOfTextAtSize(run.text, run.style.size);
+}
+function wrapRuns(runs, maxWidth) {
+  if (runs.length === 0) return [];
+  const words = [];
+  for (const run of runs) {
+    const parts = run.text.split(/(\s+)/);
+    for (const part of parts) {
+      if (part === "" || /^\s+$/.test(part)) continue;
+      words.push({ text: part, style: run.style });
+    }
+  }
+  const lines = [];
+  let current = [];
+  let currentWidth = 0;
+  for (const word of words) {
+    const w = measureWidth(word);
+    const gapWidth = current.length === 0 ? 0 : measureWidth({ text: " ", style: word.style });
+    if (current.length > 0 && currentWidth + gapWidth + w > maxWidth) {
+      lines.push(current);
+      current = [{ ...word }];
+      currentWidth = w;
+      continue;
+    }
+    if (current.length > 0) {
+      current.push({ text: " ", style: word.style });
+      currentWidth += gapWidth;
+    }
+    current.push({ ...word });
+    currentWidth += w;
+  }
+  if (current.length > 0) lines.push(current);
+  return lines;
+}
+
+// src/renderer/sanitize.ts
+var CP1252_SPECIALS = /* @__PURE__ */ new Set([
+  8364,
+  8218,
+  402,
+  8222,
+  8230,
+  8224,
+  8225,
+  710,
+  8240,
+  352,
+  8249,
+  338,
+  381,
+  8216,
+  8217,
+  8220,
+  8221,
+  8226,
+  8211,
+  8212,
+  732,
+  8482,
+  353,
+  8250,
+  339,
+  382,
+  376
+]);
+var FALLBACKS = {
+  12539: "\xB7",
+  // ・ -> ·
+  12289: ",",
+  // 、-> ,
+  65292: ",",
+  // ，-> ,
+  12290: ".",
+  // 。-> .
+  65311: "?",
+  // ？-> ?
+  65281: "!",
+  // ！-> !
+  8220: '"',
+  // " -> "
+  8221: '"',
+  // " -> "
+  8216: "'",
+  // ' -> '
+  8217: "'"
+  // ' -> '
+};
+function isWinAnsi(code) {
+  if (code >= 32 && code <= 126) return true;
+  if (code >= 160 && code <= 255) return true;
+  return CP1252_SPECIALS.has(code);
+}
+function sanitizeText(text) {
+  let out = "";
+  for (const ch of text) {
+    const code = ch.codePointAt(0);
+    if (isWinAnsi(code)) {
+      out += ch;
+      continue;
+    }
+    const fallback = FALLBACKS[code];
+    if (fallback) out += fallback;
+  }
+  return out;
+}
+
+// src/renderer/render.ts
+var ASCENT = 0.72;
+var STANDARD_FONTS = {
+  helvetica: {
+    regular: StandardFonts.Helvetica,
+    bold: StandardFonts.HelveticaBold,
+    italic: StandardFonts.HelveticaOblique
+  },
+  times: {
+    regular: StandardFonts.TimesRoman,
+    bold: StandardFonts.TimesRomanBold,
+    italic: StandardFonts.TimesRomanItalic
+  },
+  courier: {
+    regular: StandardFonts.Courier,
+    bold: StandardFonts.CourierBold,
+    italic: StandardFonts.CourierOblique
+  }
+};
+function resolveStandardFamily(family) {
+  const key = (family ?? "helvetica").toLowerCase();
+  return STANDARD_FONTS[key] ?? STANDARD_FONTS.helvetica;
+}
+async function renderDocument(doc, document, opts = {}) {
+  const theme = opts.theme;
+  if (!theme) throw new Error("renderDocument requires a theme");
+  const page = opts.page ?? createA4({ top: 40, right: 40, bottom: 40, left: 40 });
+  const flow = createFlow(page);
+  createPage(doc, page);
+  if (opts.fonts) doc.registerFontkit(fontkit);
+  const standard = resolveStandardFamily(theme.text.body.family);
+  const font = opts.fonts?.regular ? await doc.embedFont(opts.fonts.regular, { subset: true }) : await doc.embedFont(standard.regular);
+  const bold = opts.fonts?.bold ? await doc.embedFont(opts.fonts.bold, { subset: true }) : opts.fonts?.regular ? font : await doc.embedFont(standard.bold);
+  const italic = opts.fonts?.italic ? await doc.embedFont(opts.fonts.italic, { subset: true }) : opts.fonts?.regular ? font : await doc.embedFont(standard.italic);
+  const profile = opts.profile ? {
+    image: await embedImage(doc, opts.profile.bytes),
+    size: opts.profile.size ?? 96,
+    position: opts.profile.position ?? "right"
+  } : null;
+  const sanitize = !opts.fonts?.regular;
+  const ctx = { doc, flow, page, theme, font, bold, italic, profile, sanitize };
+  renderProfile(ctx);
+  for (const block of document.blocks) {
+    renderBlock(ctx, block);
+  }
+}
+function renderBlock(ctx, block) {
+  switch (block.type) {
+    case "heading":
+      renderHeading(ctx, block);
+      break;
+    case "paragraph":
+      renderParagraph(ctx, block.children, specToStyle(ctx, ctx.theme.text.body));
+      break;
+    case "list":
+      renderList(ctx, block);
+      break;
+    case "thematicBreak":
+      renderThematicBreak(ctx);
+      break;
+    case "blockquote":
+      renderBlockquote(ctx, block);
+      break;
+  }
+}
+function specToStyle(ctx, spec) {
+  const weight = spec.weight === "bold" ? "bold" : "normal";
+  return { font: weight === "bold" ? ctx.bold : ctx.font, size: spec.size };
+}
+function lineHeightFor(ctx, size) {
+  return size * ctx.theme.spacing.lineHeight;
+}
+function gap(ctx, pts) {
+  if (pts <= 0) return;
+  if (ctx.flow.needNewPage(pts)) ensurePage(ctx);
+  ctx.flow.advance(pts);
+}
+function renderHeading(ctx, block) {
+  const spacing = ctx.theme.spacing;
+  if (block.level === 2) gap(ctx, spacing.sectionGap);
+  else if (block.level === 3) gap(ctx, spacing.entrySpacing);
+  const spec = block.level === 1 ? ctx.theme.text.name : block.level === 2 ? ctx.theme.text.section : ctx.theme.text.entryTitle;
+  const color = block.level === 2 ? ctx.theme.color.accent : ctx.theme.color.ink;
+  const style = specToStyle(ctx, spec);
+  renderLines(ctx, block.children, style, color);
+  if (block.level === 1) gap(ctx, spacing.headerGap);
+  else gap(ctx, spacing.entryGap);
+}
+function renderParagraph(ctx, nodes, spec) {
+  const spacing = ctx.theme.spacing;
+  renderLines(ctx, nodes, spec, ctx.theme.color.ink);
+  gap(ctx, spacing.entryGap);
+}
+function renderProfile(ctx) {
+  if (!ctx.profile) return;
+  const { image, size, position } = ctx.profile;
+  const pdfPage = currentPdfPage(ctx);
+  const contentWidth2 = ctx.flow.contentWidth();
+  let x;
+  if (position === "left") x = marginLeft(ctx);
+  else if (position === "center") x = marginLeft(ctx) + (contentWidth2 - size) / 2;
+  else x = marginLeft(ctx) + contentWidth2 - size;
+  const y = yToPdf(ctx, size);
+  pdfPage.drawImage(image, { x, y, width: size, height: size });
+}
+function renderBlockquote(ctx, block) {
+  const spacing = ctx.theme.spacing;
+  const spec = specToStyle(ctx, ctx.theme.text.body);
+  renderLines(ctx, block.children, spec, ctx.theme.color.muted);
+  gap(ctx, spacing.entryGap);
+}
+function renderLines(ctx, nodes, spec, color) {
+  const runs = nodesToRuns(ctx, nodes, spec);
+  const maxWidth = ctx.flow.contentWidth();
+  const lines = wrapRuns(runs, maxWidth);
+  const lineHeight = lineHeightFor(ctx, spec.size);
+  for (const line of lines) {
+    if (ctx.flow.needNewPage(lineHeight)) ensurePage(ctx);
+    drawLine(ctx, line, color);
+    ctx.flow.advance(lineHeight);
+  }
+}
+function renderList(ctx, block) {
+  const spacing = ctx.theme.spacing;
+  const spec = specToStyle(ctx, ctx.theme.text.body);
+  const lineHeight = lineHeightFor(ctx, spec.size);
+  const indent = spec.size * 1.2;
+  for (const item of block.items) {
+    const bullet = block.ordered ? `${block.items.indexOf(item) + 1}. ` : "\u2022 ";
+    const runs = [{ text: bullet, style: spec }];
+    const wrapped = wrapRuns([...runs, ...nodesToRuns(ctx, item.children, spec)], ctx.flow.contentWidth() - indent);
+    wrapped.forEach((line, i) => {
+      const padded = i === 0 ? line : padRuns(line, indent, spec);
+      if (ctx.flow.needNewPage(lineHeight)) ensurePage(ctx);
+      drawLine(ctx, padded, ctx.theme.color.ink);
+      ctx.flow.advance(lineHeight);
+    });
+    if (item.nested) {
+      for (const sub of item.nested) {
+        renderNestedList(ctx, sub, indent);
+      }
+    }
+  }
+  gap(ctx, spacing.entryGap);
+}
+function renderNestedList(ctx, block, baseIndent) {
+  const spec = specToStyle(ctx, ctx.theme.text.body);
+  const lineHeight = lineHeightFor(ctx, spec.size);
+  const indent = baseIndent + spec.size * 1.2;
+  for (const item of block.items) {
+    const bullet = block.ordered ? `${block.items.indexOf(item) + 1}. ` : "\u2022 ";
+    const runs = [{ text: bullet, style: spec }];
+    const wrapped = wrapRuns([...runs, ...nodesToRuns(ctx, item.children, spec)], ctx.flow.contentWidth() - indent);
+    wrapped.forEach((line, i) => {
+      const padded = i === 0 ? padRuns(line, baseIndent, spec) : padRuns(line, indent, spec);
+      if (ctx.flow.needNewPage(lineHeight)) ensurePage(ctx);
+      drawLine(ctx, padded, ctx.theme.color.ink);
+      ctx.flow.advance(lineHeight);
+    });
+    if (item.nested) {
+      for (const sub of item.nested) {
+        renderNestedList(ctx, sub, indent);
+      }
+    }
+  }
+}
+function renderThematicBreak(ctx) {
+  const spacing = ctx.theme.spacing;
+  const y = ctx.flow.cursor.y;
+  const h = 0.75;
+  if (ctx.flow.needNewPage(spacing.entryGap + h)) ensurePage(ctx);
+  const pdfPage = currentPdfPage(ctx);
+  pdfPage.drawRectangle({
+    x: marginLeft(ctx),
+    y: yToPdf(ctx, y + spacing.entryGap + h),
+    width: ctx.flow.contentWidth(),
+    height: h,
+    color: toColor(ctx.theme.color.muted)
+  });
+  ctx.flow.advance(spacing.entryGap * 2 + h);
+}
+function nodesToRuns(ctx, nodes, base) {
+  const runs = [];
+  const walk = (list, style) => {
+    for (const node of list) {
+      switch (node.type) {
+        case "text":
+          if (node.text) runs.push({ text: ctx.sanitize ? sanitizeText(node.text) : node.text, style });
+          break;
+        case "strong":
+          walk(node.children, { font: ctx.bold, size: style.size });
+          break;
+        case "emphasis":
+          walk(node.children, { font: ctx.italic, size: style.size });
+          break;
+        case "link":
+          runs.push({ text: ctx.sanitize ? sanitizeText(node.text) : node.text, style });
+          break;
+        case "image":
+          break;
+      }
+    }
+  };
+  walk(nodes, base);
+  return runs;
+}
+function padRuns(runs, pad, spec) {
+  if (pad <= 0) return runs;
+  return [{ text: " ".repeat(Math.max(1, Math.round(pad / (spec.size * 0.5)))), style: spec }, ...runs];
+}
+function drawLine(ctx, line, color) {
+  const pdfPage = currentPdfPage(ctx);
+  const size = Math.max(...line.map((r) => r.style.size));
+  const baseline = ctx.flow.cursor.y + size * ASCENT;
+  let x = marginLeft(ctx);
+  for (const run of line) {
+    pdfPage.drawText(run.text, {
+      x,
+      y: yToPdf(ctx, baseline),
+      size: run.style.size,
+      font: run.style.font,
+      color: toColor(color)
+    });
+    x += measureWidth(run);
+  }
+}
+function marginLeft(ctx) {
+  return ctx.page.margin.left;
+}
+function yToPdf(ctx, y) {
+  return ctx.page.size.height - ctx.page.margin.top - y;
+}
+function toColor(c) {
+  return rgb(c.r, c.g, c.b);
+}
+function createPage(doc, page) {
+  doc.addPage([page.size.width, page.size.height]);
+}
+async function embedImage(doc, bytes) {
+  const isPng = bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
+  const isJpeg = bytes[0] === 255 && bytes[1] === 216;
+  if (isPng) return doc.embedPng(bytes);
+  if (isJpeg) return doc.embedJpg(bytes);
+  throw new Error("Unsupported image format: only PNG and JPEG are supported.");
+}
+function ensurePage(ctx) {
+  ctx.flow.newPage();
+  ctx.doc.addPage([ctx.page.size.width, ctx.page.size.height]);
+}
+function currentPdfPage(ctx) {
+  return ctx.doc.getPage(ctx.flow.pageNumber);
+}
+
+// src/renderer/index.ts
+async function renderMarkdownToPdf(markdown, opts = {}) {
+  const doc = await PDFDocument2.create();
+  const theme = opts.theme ?? createDefaultTheme();
+  await renderDocument(doc, parseMarkdown(markdown), {
+    theme,
+    page: opts.page,
+    profile: opts.profile,
+    fonts: opts.fonts
+  });
+  return doc.save();
+}
+
+// src/generate.ts
+async function generateCV(options) {
+  const markdown = await readFile(options.input, "utf8");
+  const validation = validateCV(markdown);
+  const errors = validation.issues.filter((i) => i.severity === "error");
+  if (errors.length > 0) {
+    const summary = errors.map((e) => `- ${e.message}`).join("\n");
+    throw new Error(`CV validation failed:
+${summary}`);
+  }
+  const theme = options.theme ?? createDefaultTheme();
+  const bytes = await renderMarkdownToPdf(markdown, {
+    theme,
+    page: options.page,
+    profile: options.profile,
+    fonts: options.fonts
+  });
+  await writeFile(options.output, bytes);
+  return {
+    issues: validation.issues,
+    output: options.output
+  };
+}
+
+// src/cli.ts
+var HELP = `md-2-ats - render an ATS-friendly PDF from a Markdown resume
+
+Usage:
+  md-2-ats <input.md> [options]
+
+Options:
+  -o, --output <path>            Output PDF path (default: input with .pdf)
+  -p, --profile <path>           Profile photo (PNG or JPEG)
+      --profile-size <points>    Profile photo side length (default: 96)
+      --profile-position <pos>   left | center | right (default: right)
+      --font-regular <path>      Custom TTF regular font
+      --font-bold <path>         Custom TTF bold font
+      --font-italic <path>       Custom TTF italic font
+  -h, --help                     Show this help
+  -v, --version                  Show version
+
+Examples:
+  md-2-ats cv.md
+  md-2-ats cv.md -o out.pdf -p photo.png
+  md-2-ats cv.md --font-regular NotoSansSC-Regular.ttf`;
+function parseArgs(argv) {
+  const opts = { help: false, version: false };
+  const value = (flag, i) => {
+    const v = argv[i + 1];
+    if (v === void 0 || v.startsWith("-")) {
+      throw new Error(`Missing value for ${flag}`);
+    }
+    return v;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "-h":
+      case "--help":
+        opts.help = true;
+        break;
+      case "-v":
+      case "--version":
+        opts.version = true;
+        break;
+      case "-o":
+      case "--output":
+        opts.output = value(arg, i);
+        i++;
+        break;
+      case "-p":
+      case "--profile":
+        opts.profile = value(arg, i);
+        i++;
+        break;
+      case "--profile-size": {
+        const raw = value(arg, i);
+        i++;
+        const n = Number(raw);
+        if (!Number.isFinite(n) || n <= 0) throw new Error(`Invalid --profile-size: "${raw}"`);
+        opts.profileSize = n;
+        break;
+      }
+      case "--profile-position": {
+        const raw = value(arg, i);
+        i++;
+        if (raw !== "left" && raw !== "center" && raw !== "right") {
+          throw new Error(`Invalid --profile-position: "${raw}" (use left, center, or right)`);
+        }
+        opts.profilePosition = raw;
+        break;
+      }
+      case "--font-regular":
+        opts.fontRegular = value(arg, i);
+        i++;
+        break;
+      case "--font-bold":
+        opts.fontBold = value(arg, i);
+        i++;
+        break;
+      case "--font-italic":
+        opts.fontItalic = value(arg, i);
+        i++;
+        break;
+      default:
+        if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+        if (opts.input !== void 0) throw new Error(`Unexpected argument: ${arg}`);
+        opts.input = arg;
+    }
+  }
+  return opts;
+}
+async function readVersion() {
+  try {
+    const url = new URL("../package.json", import.meta.url);
+    const pkg = JSON.parse(await readFile2(url, "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function runCli(argv) {
+  let opts;
+  try {
+    opts = parseArgs(argv);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    console.error(`Run "md-2-ats --help" for usage.`);
+    return 1;
+  }
+  if (opts.help) {
+    console.log(HELP);
+    return 0;
+  }
+  if (opts.version) {
+    console.log(await readVersion());
+    return 0;
+  }
+  if (!opts.input) {
+    console.error("Error: missing input Markdown file.");
+    console.error(`Run "md-2-ats --help" for usage.`);
+    return 1;
+  }
+  if (!existsSync(opts.input)) {
+    console.error(`Error: input file not found: ${opts.input}`);
+    return 1;
+  }
+  const output = opts.output ?? `${opts.input.slice(0, opts.input.length - extname(opts.input).length)}.pdf`;
+  if ((opts.fontBold || opts.fontItalic) && !opts.fontRegular) {
+    console.error("Error: --font-regular is required when specifying custom fonts.");
+    return 1;
+  }
+  try {
+    const profile = opts.profile ? {
+      bytes: await readFile2(opts.profile),
+      ...opts.profileSize !== void 0 ? { size: opts.profileSize } : {},
+      ...opts.profilePosition !== void 0 ? { position: opts.profilePosition } : {}
+    } : void 0;
+    const fonts = opts.fontRegular ? {
+      regular: await readFile2(opts.fontRegular),
+      ...opts.fontBold ? { bold: await readFile2(opts.fontBold) } : {},
+      ...opts.fontItalic ? { italic: await readFile2(opts.fontItalic) } : {}
+    } : void 0;
+    const result = await generateCV({
+      input: opts.input,
+      output,
+      ...profile ? { profile } : {},
+      ...fonts ? { fonts } : {}
+    });
+    for (const issue of result.issues) {
+      console.warn(`warning: ${issue.message}`);
+    }
+    console.log(`Generated ${resolve(result.output)}`);
+    return 0;
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    return 1;
+  }
+}
+var entry = process.argv[1];
+var isMain = entry !== void 0 && existsSync(entry) && realpathSync(fileURLToPath(import.meta.url)) === realpathSync(entry);
+if (isMain) {
+  void runCli(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+  });
+}
+export {
+  parseArgs,
+  runCli
+};
+//# sourceMappingURL=cli.js.map