markdownly.js 1.1.0

package/dist/cli.js

@@ -0,0 +1,741 @@
+#!/usr/bin/env node
+
+// src/parser.ts
+function parse(markdown) {
+  const lines = markdown.split(`
+`);
+  const tokens = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    if (line.match(/^```/)) {
+      const lang = line.slice(3).trim();
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].match(/^```/)) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      tokens.push({
+        type: "code_block",
+        content: codeLines.join(`
+`),
+        meta: { lang }
+      });
+      i++;
+      continue;
+    }
+    if (line.match(/^    /)) {
+      const codeLines = [];
+      while (i < lines.length && (lines[i].match(/^    /) || lines[i].trim() === "")) {
+        codeLines.push(lines[i].replace(/^    /, ""));
+        i++;
+      }
+      tokens.push({
+        type: "code_block",
+        content: codeLines.join(`
+`).trim(),
+        meta: { lang: "" }
+      });
+      continue;
+    }
+    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headerMatch) {
+      const level = headerMatch[1].length;
+      tokens.push({
+        type: `h${level}`,
+        content: headerMatch[2],
+        children: parseInline(headerMatch[2])
+      });
+      i++;
+      continue;
+    }
+    if (line.match(/^(\*{3,}|-{3,}|_{3,})$/)) {
+      tokens.push({ type: "hr", content: "" });
+      i++;
+      continue;
+    }
+    const alertMatch = line.match(/^>\s*\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]/);
+    if (alertMatch) {
+      const alertType = alertMatch[1].toLowerCase();
+      const alertLines = [];
+      i++;
+      while (i < lines.length && lines[i].match(/^>/)) {
+        alertLines.push(lines[i].replace(/^>\s?/, ""));
+        i++;
+      }
+      tokens.push({
+        type: "alert",
+        content: alertLines.join(`
+`),
+        meta: { alertType },
+        children: parseInline(alertLines.join(`
+`))
+      });
+      continue;
+    }
+    if (line.match(/^>/)) {
+      const quoteLines = [];
+      while (i < lines.length && lines[i].match(/^>/)) {
+        quoteLines.push(lines[i].replace(/^>\s?/, ""));
+        i++;
+      }
+      tokens.push({
+        type: "blockquote",
+        content: quoteLines.join(`
+`),
+        children: parse(quoteLines.join(`
+`))
+      });
+      continue;
+    }
+    if (i + 1 < lines.length && lines[i + 1].match(/^\|?[\s\-:|]+\|?$/)) {
+      const tableLines = [];
+      while (i < lines.length && lines[i].includes("|")) {
+        tableLines.push(lines[i]);
+        i++;
+      }
+      tokens.push({
+        type: "table",
+        content: "",
+        meta: { rows: parseTable(tableLines) }
+      });
+      continue;
+    }
+    const listMatch = line.match(/^(\s*)([*+-]|\d+\.)\s/);
+    if (listMatch) {
+      const { items, endIndex } = parseList(lines, i);
+      tokens.push({
+        type: "list",
+        content: "",
+        children: items
+      });
+      i = endIndex;
+      continue;
+    }
+    const paraLines = [];
+    while (i < lines.length && lines[i].trim() !== "" && !lines[i].match(/^(#{1,6}\s|```|>|\*{3,}|-{3,}|_{3,}|(\s*)([*+-]|\d+\.)\s|\|)/)) {
+      paraLines.push(lines[i]);
+      i++;
+    }
+    if (paraLines.length > 0) {
+      const content = paraLines.join(`
+`);
+      tokens.push({
+        type: "paragraph",
+        content,
+        children: parseInline(content)
+      });
+    }
+  }
+  return tokens;
+}
+function parseList(lines, startIndex) {
+  const items = [];
+  let i = startIndex;
+  while (i < lines.length) {
+    const line = lines[i];
+    const match = line.match(/^(\s*)([*+-]|\d+\.)\s(.*)$/);
+    if (!match && line.trim() === "") {
+      i++;
+      continue;
+    }
+    if (!match)
+      break;
+    const [, indent, marker, content] = match;
+    const ordered = /\d+\./.test(marker);
+    const checked = content.match(/^\[([ xX])\]\s*(.*)$/);
+    let itemContent = checked ? checked[2] : content;
+    const isChecked = checked ? checked[1].toLowerCase() === "x" : undefined;
+    i++;
+    while (i < lines.length) {
+      const nextLine = lines[i];
+      if (nextLine.trim() === "") {
+        i++;
+        continue;
+      }
+      if (nextLine.match(/^(\s*)([*+-]|\d+\.)\s/))
+        break;
+      if (nextLine.match(/^\s{2,}/)) {
+        itemContent += `
+` + nextLine.trim();
+        i++;
+      } else {
+        break;
+      }
+    }
+    items.push({
+      type: "list_item",
+      content: itemContent,
+      children: parseInline(itemContent),
+      meta: { ordered, checked: isChecked }
+    });
+  }
+  return { items, endIndex: i };
+}
+function parseTable(lines) {
+  const parseRow = (line) => line.split("|").map((c) => c.trim()).filter((_, i, arr) => i > 0 && i < arr.length - 1 || arr.length <= 2);
+  const headers = parseRow(lines[0]);
+  const alignLine = lines[1];
+  const alignments = parseRow(alignLine).map((cell) => {
+    if (cell.startsWith(":") && cell.endsWith(":"))
+      return "center";
+    if (cell.endsWith(":"))
+      return "right";
+    return "left";
+  });
+  const rows = lines.slice(2).map(parseRow);
+  return { headers, alignments, rows };
+}
+function parseInline(text) {
+  const tokens = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    let matched = false;
+    const imgMatch = remaining.match(/^!\[([^\]]*)\]\(([^)]+)\)/);
+    if (imgMatch) {
+      tokens.push({
+        type: "image",
+        content: imgMatch[1] || "Image",
+        meta: { url: imgMatch[2] }
+      });
+      remaining = remaining.slice(imgMatch[0].length);
+      matched = true;
+      continue;
+    }
+    const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/);
+    if (linkMatch) {
+      tokens.push({
+        type: "link",
+        content: linkMatch[1],
+        meta: { url: linkMatch[2] }
+      });
+      remaining = remaining.slice(linkMatch[0].length);
+      matched = true;
+      continue;
+    }
+    const codeMatch = remaining.match(/^`([^`]+)`/);
+    if (codeMatch) {
+      tokens.push({ type: "code_inline", content: codeMatch[1] });
+      remaining = remaining.slice(codeMatch[0].length);
+      matched = true;
+      continue;
+    }
+    const boldMatch = remaining.match(/^(\*\*|__)([^*_]+)\1/);
+    if (boldMatch) {
+      tokens.push({
+        type: "bold",
+        content: boldMatch[2],
+        children: parseInline(boldMatch[2])
+      });
+      remaining = remaining.slice(boldMatch[0].length);
+      matched = true;
+      continue;
+    }
+    const italicMatch = remaining.match(/^(\*|_)([^*_]+)\1/);
+    if (italicMatch) {
+      tokens.push({
+        type: "italic",
+        content: italicMatch[2],
+        children: parseInline(italicMatch[2])
+      });
+      remaining = remaining.slice(italicMatch[0].length);
+      matched = true;
+      continue;
+    }
+    const strikeMatch = remaining.match(/^~~([^~]+)~~/);
+    if (strikeMatch) {
+      tokens.push({ type: "strikethrough", content: strikeMatch[1] });
+      remaining = remaining.slice(strikeMatch[0].length);
+      matched = true;
+      continue;
+    }
+    const markMatch = remaining.match(/^==([^=]+)==/);
+    if (markMatch) {
+      tokens.push({ type: "mark", content: markMatch[1] });
+      remaining = remaining.slice(markMatch[0].length);
+      matched = true;
+      continue;
+    }
+    const insMatch = remaining.match(/^\+\+([^+]+)\+\+/);
+    if (insMatch) {
+      tokens.push({ type: "ins", content: insMatch[1] });
+      remaining = remaining.slice(insMatch[0].length);
+      matched = true;
+      continue;
+    }
+    const supMatch = remaining.match(/^\^([^^]+)\^/);
+    if (supMatch) {
+      tokens.push({ type: "sup", content: supMatch[1] });
+      remaining = remaining.slice(supMatch[0].length);
+      matched = true;
+      continue;
+    }
+    const subMatch = remaining.match(/^~([^~]+)~/);
+    if (subMatch) {
+      tokens.push({ type: "sub", content: subMatch[1] });
+      remaining = remaining.slice(subMatch[0].length);
+      matched = true;
+      continue;
+    }
+    if (remaining.startsWith(`
+`)) {
+      tokens.push({ type: "br", content: `
+` });
+      remaining = remaining.slice(1);
+      matched = true;
+      continue;
+    }
+    if (!matched) {
+      const nextSpecial = remaining.slice(1).search(/[*_`~\[!\^=+\n]/);
+      const end = nextSpecial === -1 ? remaining.length : nextSpecial + 1;
+      tokens.push({ type: "text", content: remaining.slice(0, end) });
+      remaining = remaining.slice(end);
+    }
+  }
+  return tokens;
+}
+
+// src/ansi.ts
+var ESC = "\x1B[";
+var RESET = `${ESC}0m`;
+var wrap = (open, close) => (s) => `${ESC}${open}m${s}${ESC}${close}m`;
+var red = wrap("31", "39");
+var green = wrap("32", "39");
+var yellow = wrap("33", "39");
+var blue = wrap("34", "39");
+var magenta = wrap("35", "39");
+var cyan = wrap("36", "39");
+var grey = wrap("90", "39");
+var white = wrap("37", "39");
+var black = wrap("30", "39");
+var redBright = wrap("91", "39");
+var greenBright = wrap("92", "39");
+var yellowBright = wrap("93", "39");
+var blueBright = wrap("94", "39");
+var magentaBright = wrap("95", "39");
+var cyanBright = wrap("96", "39");
+var bgBlack = wrap("40", "49");
+var bgRed = wrap("41", "49");
+var bgGreen = wrap("42", "49");
+var bgYellow = wrap("43", "49");
+var bgBlue = wrap("44", "49");
+var bgMagenta = wrap("45", "49");
+var bgCyan = wrap("46", "49");
+var bgWhite = wrap("47", "49");
+var bold = wrap("1", "22");
+var dim = wrap("2", "22");
+var italic = wrap("3", "23");
+var underline = wrap("4", "24");
+var strikethrough = wrap("9", "29");
+var compose = (...fns) => (s) => fns.filter(Boolean).reduce((acc, fn) => fn(acc), s);
+var getTerminalWidth = () => {
+  try {
+    return process.stdout.columns || 80;
+  } catch {
+    return 80;
+  }
+};
+
+// src/highlight.ts
+function highlight(code, lang) {
+  const l = lang.toLowerCase();
+  if (["js", "javascript", "ts", "typescript", "jsx", "tsx"].includes(l)) {
+    return highlightJS(code);
+  }
+  if (["go", "golang"].includes(l)) {
+    return highlightGo(code);
+  }
+  if (["py", "python"].includes(l)) {
+    return highlightPython(code);
+  }
+  if (["sh", "bash", "shell", "zsh"].includes(l)) {
+    return highlightBash(code);
+  }
+  if (["json"].includes(l)) {
+    return highlightJSON(code);
+  }
+  if (["yaml", "yml"].includes(l)) {
+    return highlightYAML(code);
+  }
+  if (["html", "xml"].includes(l)) {
+    return highlightHTML(code);
+  }
+  if (["css", "scss", "less"].includes(l)) {
+    return highlightCSS(code);
+  }
+  return yellowBright(code);
+}
+function highlightJS(code) {
+  const keywords = /\b(const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|this|class|extends|import|export|from|default|async|await|try|catch|finally|throw|typeof|instanceof|in|of|null|undefined|true|false|void|delete|yield)\b/g;
+  const strings = /(["'`])(?:(?!\1)[^\\]|\\.)*\1/g;
+  const comments = /(\/\/.*$|\/\*[\s\S]*?\*\/)/gm;
+  const numbers = /\b(\d+\.?\d*)\b/g;
+  const funcs = /\b([a-zA-Z_]\w*)\s*\(/g;
+  const tokens = [];
+  let m;
+  while ((m = comments.exec(code)) !== null) {
+    tokens.push({ start: m.index, end: m.index + m[0].length, style: grey });
+  }
+  while ((m = strings.exec(code)) !== null) {
+    tokens.push({ start: m.index, end: m.index + m[0].length, style: green });
+  }
+  tokens.sort((a, b) => a.start - b.start);
+  let result = "";
+  let pos = 0;
+  for (const t of tokens) {
+    if (t.start < pos)
+      continue;
+    result += applyInlineStyles(code.slice(pos, t.start), keywords, numbers, funcs);
+    result += t.style(code.slice(t.start, t.end));
+    pos = t.end;
+  }
+  result += applyInlineStyles(code.slice(pos), keywords, numbers, funcs);
+  return result;
+}
+function applyInlineStyles(text, keywords, numbers, funcs) {
+  return text.replace(funcs, (match, name) => blue(name) + "(").replace(keywords, magenta("$1")).replace(numbers, yellow("$1"));
+}
+function highlightGo(code) {
+  const keywords = /\b(package|import|func|return|if|else|for|range|switch|case|break|continue|go|defer|select|chan|map|struct|interface|type|const|var|nil|true|false|make|new|len|cap|append|copy|delete|panic|recover)\b/g;
+  const strings = /(["'`])(?:(?!\1)[^\\]|\\.)*\1/g;
+  const comments = /(\/\/.*$|\/\*[\s\S]*?\*\/)/gm;
+  const numbers = /\b(\d+\.?\d*)\b/g;
+  const tokens = [];
+  let m;
+  while ((m = comments.exec(code)) !== null) {
+    tokens.push({ start: m.index, end: m.index + m[0].length, style: grey });
+  }
+  while ((m = strings.exec(code)) !== null) {
+    tokens.push({ start: m.index, end: m.index + m[0].length, style: green });
+  }
+  tokens.sort((a, b) => a.start - b.start);
+  let result = "";
+  let pos = 0;
+  for (const t of tokens) {
+    if (t.start < pos)
+      continue;
+    result += code.slice(pos, t.start).replace(keywords, magenta("$1")).replace(numbers, yellow("$1"));
+    result += t.style(code.slice(t.start, t.end));
+    pos = t.end;
+  }
+  result += code.slice(pos).replace(keywords, magenta("$1")).replace(numbers, yellow("$1"));
+  return result;
+}
+function highlightPython(code) {
+  const keywords = /\b(def|class|return|if|elif|else|for|while|break|continue|import|from|as|try|except|finally|raise|with|lambda|yield|global|nonlocal|pass|None|True|False|and|or|not|in|is)\b/g;
+  const strings = /("""[\s\S]*?"""|'''[\s\S]*?'''|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g;
+  const comments = /(#.*$)/gm;
+  const numbers = /\b(\d+\.?\d*)\b/g;
+  const tokens = [];
+  let m;
+  while ((m = comments.exec(code)) !== null) {
+    tokens.push({ start: m.index, end: m.index + m[0].length, style: grey });
+  }
+  while ((m = strings.exec(code)) !== null) {
+    tokens.push({ start: m.index, end: m.index + m[0].length, style: green });
+  }
+  tokens.sort((a, b) => a.start - b.start);
+  let result = "";
+  let pos = 0;
+  for (const t of tokens) {
+    if (t.start < pos)
+      continue;
+    result += code.slice(pos, t.start).replace(keywords, magenta("$1")).replace(numbers, yellow("$1"));
+    result += t.style(code.slice(t.start, t.end));
+    pos = t.end;
+  }
+  result += code.slice(pos).replace(keywords, magenta("$1")).replace(numbers, yellow("$1"));
+  return result;
+}
+function highlightBash(code) {
+  const keywords = /\b(if|then|else|elif|fi|for|while|do|done|case|esac|function|return|exit|echo|cd|ls|rm|cp|mv|mkdir|cat|grep|sed|awk|export|source|local)\b/g;
+  const strings = /("(?:[^"\\]|\\.)*"|'[^']*')/g;
+  const comments = /(#.*$)/gm;
+  const vars = /(\$\{?[a-zA-Z_]\w*\}?)/g;
+  return code.replace(comments, grey("$1")).replace(strings, green("$1")).replace(vars, cyan("$1")).replace(keywords, magenta("$1"));
+}
+function highlightJSON(code) {
+  const keys = /("(?:[^"\\]|\\.)*")\s*:/g;
+  const strings = /:\s*("(?:[^"\\]|\\.)*")/g;
+  const numbers = /:\s*(\d+\.?\d*)/g;
+  const bools = /\b(true|false|null)\b/g;
+  return code.replace(keys, cyan("$1") + ":").replace(strings, ": " + green("$1")).replace(numbers, ": " + yellow("$1")).replace(bools, magenta("$1"));
+}
+function highlightYAML(code) {
+  const keys = /^(\s*[a-zA-Z_-][a-zA-Z0-9_-]*):/gm;
+  const strings = /:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g;
+  const comments = /(#.*$)/gm;
+  const bools = /\b(true|false|null|yes|no)\b/gi;
+  return code.replace(comments, grey("$1")).replace(keys, cyan("$1") + ":").replace(strings, ": " + green("$1")).replace(bools, magenta("$1"));
+}
+function highlightHTML(code) {
+  const comments = /(<!--[\s\S]*?-->)/g;
+  const tags = /(<\/?[a-zA-Z][a-zA-Z0-9]*)/g;
+  const attrs = /(\s[a-zA-Z-]+)=/g;
+  const strings = /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/g;
+  return code.replace(comments, grey("$1")).replace(tags, blue("$1")).replace(attrs, cyan("$1") + "=").replace(strings, green("$1"));
+}
+function highlightCSS(code) {
+  const comments = /(\/\*[\s\S]*?\*\/)/g;
+  const selectors = /([.#]?[a-zA-Z_-][a-zA-Z0-9_-]*)\s*\{/g;
+  const props = /([a-zA-Z-]+)\s*:/g;
+  const values = /(#[0-9a-fA-F]{3,8}|\d+\.?\d*(px|em|rem|%|vh|vw)?)/g;
+  return code.replace(comments, grey("$1")).replace(selectors, blue("$1") + " {").replace(props, cyan("$1") + ":").replace(values, yellow("$1"));
+}
+
+// src/renderer.ts
+var getWidth = () => Math.min(120, getTerminalWidth() - 2);
+function render(tokens) {
+  const lines = [];
+  const width = getWidth();
+  for (const token of tokens) {
+    const rendered = renderToken(token, { width, indent: "" });
+    if (rendered)
+      lines.push(rendered);
+  }
+  return `
+` + lines.join(`
+
+`) + `
+
+`;
+}
+function renderToken(token, ctx) {
+  switch (token.type) {
+    case "h1":
+      return `${compose(red, bold)("#")} ${renderInline(token.children || [])}`;
+    case "h2":
+      return `${compose(blue, bold)("##")} ${renderInline(token.children || [])}`;
+    case "h3":
+      return `${compose(blue, bold)("###")} ${renderInline(token.children || [])}`;
+    case "h4":
+      return `${compose(cyan, bold)("####")} ${renderInline(token.children || [])}`;
+    case "h5":
+      return `${cyan("#####")} ${renderInline(token.children || [])}`;
+    case "h6":
+      return `${cyan("######")} ${renderInline(token.children || [])}`;
+    case "paragraph":
+      return wrapText(renderInline(token.children || []), ctx.width);
+    case "hr":
+      return grey("─".repeat(ctx.width));
+    case "blockquote":
+      return renderBlockquote(token, ctx);
+    case "alert":
+      return renderAlert(token, ctx);
+    case "code_block":
+      return renderCodeBlock(token, ctx);
+    case "list":
+      return renderList(token, ctx);
+    case "table":
+      return renderTable(token, ctx);
+    default:
+      return token.content;
+  }
+}
+function renderInline(tokens) {
+  return tokens.map((t) => {
+    switch (t.type) {
+      case "text":
+        return t.content;
+      case "bold":
+        return bold(renderInline(t.children || [{ type: "text", content: t.content }]));
+      case "italic":
+        return italic(renderInline(t.children || [{ type: "text", content: t.content }]));
+      case "strikethrough":
+        return strikethrough(t.content);
+      case "code_inline":
+        return compose(bgBlack, yellowBright)(t.content);
+      case "link":
+        return compose(blue, underline)(t.content);
+      case "image":
+        return cyan("!") + grey("[") + cyan(t.content) + grey("]");
+      case "mark":
+        return compose(bgYellow, black)(t.content);
+      case "ins":
+        return compose(bgGreen, black)(t.content);
+      case "sup":
+      case "sub":
+        return t.content;
+      case "br":
+        return `
+`;
+      default:
+        return t.content;
+    }
+  }).join("");
+}
+function renderBlockquote(token, ctx) {
+  const innerCtx = { ...ctx, width: ctx.width - 2 };
+  const content = token.children ? token.children.map((t) => renderToken(t, innerCtx)).join(`
+
+`) : token.content;
+  return content.split(`
+`).map((line) => grey("│ ") + line).join(`
+`);
+}
+function renderAlert(token, ctx) {
+  const alertType = token.meta?.alertType || "note";
+  const colors = {
+    note: blue,
+    tip: green,
+    important: red,
+    warning: yellow,
+    caution: magenta
+  };
+  const color = colors[alertType] || blue;
+  const title = alertType.charAt(0).toUpperCase() + alertType.slice(1);
+  const innerCtx = { ...ctx, width: ctx.width - 2 };
+  const content = wrapText(renderInline(token.children || []), innerCtx.width);
+  const lines = [
+    color("│ ") + color(`• ${title}`),
+    ...content.split(`
+`).map((line) => color("│ ") + line)
+  ];
+  return lines.join(`
+`);
+}
+function renderCodeBlock(token, ctx) {
+  const lang = token.meta?.lang || "";
+  const code = token.content;
+  const highlighted = lang ? highlight(code, lang) : yellowBright(code);
+  const lines = highlighted.split(`
+`);
+  const numWidth = String(lines.length).length;
+  return lines.map((line, i) => {
+    const num = compose(grey, dim)(String(i + 1).padStart(numWidth));
+    return ` ${num} ${line}`;
+  }).join(`
+`);
+}
+function renderList(token, ctx) {
+  const items = token.children || [];
+  let orderedNum = 1;
+  return items.map((item) => {
+    const ordered = item.meta?.ordered;
+    const checked = item.meta?.checked;
+    let bullet;
+    if (checked !== undefined) {
+      const check = checked ? green("✓") : " ";
+      bullet = grey("[") + check + grey("]");
+    } else if (ordered) {
+      bullet = blueBright(`${orderedNum++}.`);
+    } else {
+      bullet = redBright("•");
+    }
+    const content = renderInline(item.children || []);
+    const wrapped = wrapText(content, ctx.width - 4);
+    const indented = wrapped.split(`
+`).map((line, i) => i === 0 ? `${bullet} ${line}` : `    ${line}`).join(`
+`);
+    return indented;
+  }).join(`
+`);
+}
+function renderTable(token, ctx) {
+  const { headers, alignments, rows } = token.meta?.rows || { headers: [], alignments: [], rows: [] };
+  if (!headers.length)
+    return "";
+  const colWidths = headers.map((h, i) => {
+    const cellWidths = [h.length, ...rows.map((r) => (r[i] || "").length)];
+    return Math.max(...cellWidths);
+  });
+  const pad = (s, w, align) => {
+    const diff = w - s.length;
+    if (diff <= 0)
+      return s;
+    if (align === "center") {
+      const left = Math.floor(diff / 2);
+      return " ".repeat(left) + s + " ".repeat(diff - left);
+    }
+    if (align === "right")
+      return " ".repeat(diff) + s;
+    return s + " ".repeat(diff);
+  };
+  const renderRow = (cells, isHeader = false) => {
+    const styled = cells.map((cell, i) => {
+      const padded = pad(cell, colWidths[i], alignments[i] || "left");
+      return isHeader ? compose(bold, red)(padded) : padded;
+    });
+    return "│ " + styled.join(" │ ") + " │";
+  };
+  const separator = "├" + colWidths.map((w) => "─".repeat(w + 2)).join("┼") + "┤";
+  const top = "┌" + colWidths.map((w) => "─".repeat(w + 2)).join("┬") + "┐";
+  const bottom = "└" + colWidths.map((w) => "─".repeat(w + 2)).join("┴") + "┘";
+  const tableLines = [
+    top,
+    renderRow(headers, true),
+    separator,
+    ...rows.map((r) => renderRow(r)),
+    bottom
+  ];
+  return tableLines.join(`
+`);
+}
+function wrapText(text, width) {
+  if (width <= 0)
+    return text;
+  const lines = [];
+  for (const paragraph of text.split(`
+`)) {
+    if (stripAnsi(paragraph).length <= width) {
+      lines.push(paragraph);
+      continue;
+    }
+    const words = paragraph.split(" ");
+    let current = "";
+    for (const word of words) {
+      const test = current ? current + " " + word : word;
+      if (stripAnsi(test).length <= width) {
+        current = test;
+      } else {
+        if (current)
+          lines.push(current);
+        current = word;
+      }
+    }
+    if (current)
+      lines.push(current);
+  }
+  return lines.join(`
+`);
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// src/index.ts
+function markdown(input) {
+  const tokens = parse(input);
+  return render(tokens);
+}
+
+// src/cli.ts
+import { readFileSync } from "fs";
+async function main() {
+  const args = process.argv.slice(2);
+  let input;
+  if (args.length > 0) {
+    try {
+      input = readFileSync(args[0], "utf-8");
+    } catch {
+      console.error(`File not found: ${args[0]}`);
+      process.exit(1);
+    }
+  } else {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(Buffer.from(chunk));
+    }
+    input = Buffer.concat(chunks).toString("utf-8");
+  }
+  process.stdout.write(markdown(input));
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});