@ndp-software/lit-md 0.3.0

package/dist/cli.js

@@ -0,0 +1,1273 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync } from "node:fs";
+import { join as join5, dirname as dirname2, basename, extname as extname2, resolve as resolve2 } from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+
+// src/parser.ts
+import ts from "typescript";
+import { spawnSync } from "node:child_process";
+import { writeFileSync, mkdtempSync, rmSync, readFileSync } from "node:fs";
+import { join, isAbsolute } from "node:path";
+import { tmpdir } from "node:os";
+function parse(src, lang = "typescript") {
+  if (!src.trim()) return [];
+  const sf = ts.createSourceFile("input.ts", src, ts.ScriptTarget.Latest, true);
+  const nodes = [];
+  const processedCommentRanges = /* @__PURE__ */ new Set();
+  let pendingFileLabel = void 0;
+  let lastCommentEnd = 0;
+  let pendingNewParagraph = false;
+  function extractLeadingComments(pos) {
+    const ranges = ts.getLeadingCommentRanges(src, pos) ?? [];
+    for (const r of ranges) {
+      if (processedCommentRanges.has(r.pos)) continue;
+      processedCommentRanges.add(r.pos);
+      const raw = src.slice(r.pos, r.end);
+      const gap = lastCommentEnd > 0 ? src.slice(lastCommentEnd, r.pos) : "";
+      const hasBlankLineBefore = gap !== "" && /^[ \t\n]*$/.test(gap) && /\n[ \t]*\n/.test(gap);
+      lastCommentEnd = r.end;
+      if (r.kind === ts.SyntaxKind.SingleLineCommentTrivia) {
+        const fileMatch = raw.match(/^\/\/\s*file:\s*(.+)$/);
+        if (fileMatch) {
+          pendingFileLabel = fileMatch[1].trim();
+          continue;
+        }
+      }
+      const prose = commentToProse(raw, r.kind);
+      if (prose !== null) {
+        if (hasBlankLineBefore && prose === "") {
+          pendingNewParagraph = true;
+        } else if ((hasBlankLineBefore || pendingNewParagraph) && prose !== "") {
+          nodes.push({ kind: "prose", text: prose });
+          pendingNewParagraph = false;
+        } else {
+          mergeOrPushProse(nodes, prose);
+        }
+      }
+    }
+  }
+  function visitStatements(statements, depth = 0, parentBlock) {
+    for (const stmt of statements) {
+      extractLeadingComments(stmt.getFullStart());
+      processStatement(stmt, depth);
+    }
+    if (statements.length > 0 && parentBlock) {
+      const lastStatement = statements[statements.length - 1];
+      extractLeadingComments(lastStatement.end);
+    }
+  }
+  function processStatement(stmt, depth = 0) {
+    const fullStmt = getFullStatement(stmt, src);
+    if (fullStmt !== null) {
+      const title = pendingFileLabel;
+      pendingFileLabel = void 0;
+      mergeOrPushCode(nodes, fullStmt, lang, title);
+      return;
+    }
+    const lineText = getStatementLine(stmt, src);
+    if (lineText !== null && hasKeepComment(lineText)) {
+      const title = pendingFileLabel;
+      pendingFileLabel = void 0;
+      const cleanedLine = lineText.replace(/\s*\/\/\s*keep\b.*$/, "");
+      mergeOrPushCode(nodes, cleanedLine, lang, title);
+      return;
+    }
+    if (ts.isImportDeclaration(stmt)) {
+      return;
+    }
+    if (ts.isExpressionStatement(stmt)) {
+      const expr = stmt.expression;
+      if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
+        const name = expr.expression.text;
+        if (name === "test" || name === "it" || name === "example") {
+          const testName = getStringArg(expr, 0);
+          const body = getFnBody(expr, 1);
+          if (body) {
+            const code = extractBodyCode(src, body);
+            if (code.trim()) {
+              const title = pendingFileLabel;
+              pendingFileLabel = void 0;
+              let proseNodeIdx = -1;
+              for (let i = nodes.length - 1; i >= 0; i--) {
+                if (nodes[i].kind === "prose") {
+                  proseNodeIdx = i;
+                  break;
+                } else if (nodes[i].kind !== "describe") {
+                  break;
+                }
+              }
+              if (proseNodeIdx >= 0) {
+                const proseNode = nodes[proseNodeIdx];
+                const fenceMatch = extractTrailingFence(proseNode.text);
+                if (fenceMatch) {
+                  proseNode.text = fenceMatch.prose;
+                  proseNode.noBlankAfter = true;
+                  nodes.splice(proseNodeIdx + 1);
+                  const mergedCode = fenceMatch.fenceCode + "\n" + code;
+                  nodes.push(codeNode(lang, mergedCode, title));
+                } else if (proseNodeIdx === nodes.length - 1) {
+                  proseNode.noBlankAfter = true;
+                  nodes.push(codeNode(lang, code, title));
+                } else {
+                  nodes.push(codeNode(lang, code, title));
+                }
+              } else {
+                nodes.push(codeNode(lang, code, title));
+              }
+            } else if (body && !ts.isBlock(body)) {
+              const lines = src.slice(body.getFullStart(), body.getEnd()).split("\n").length;
+              if (lines > 2) {
+                console.warn(`\u26A0 Warning: ${name}('${testName}') expression body (${lines} lines) did not produce output`);
+              }
+            }
+            return;
+          }
+        }
+        if (name === "describe") {
+          const descName = getStringArg(expr, 0);
+          const body = getFnBody(expr, 1);
+          if (body && ts.isBlock(body) && descName !== null) {
+            nodes.push({ kind: "describe", name: descName, depth });
+            visitStatements(body.statements, depth + 1, body);
+            return;
+          }
+        }
+        if (name === "metaExample") {
+          const body = getFnBody(expr, 1);
+          if (body) {
+            const code = extractBodyCode(src, body);
+            if (code.trim()) {
+              const title = pendingFileLabel;
+              pendingFileLabel = void 0;
+              const rawCall = dedentCallSource(src.slice(expr.getStart(), expr.getEnd())).replace(/^metaExample\b/, "example");
+              nodes.push(codeNode(lang, rawCall, title));
+              nodes.push({ kind: "prose", text: "becomes", noBlankBefore: true, noBlankAfter: true });
+              const langAlias = lang === "typescript" ? "ts" : lang === "javascript" ? "js" : lang;
+              const innerFence = `\`\`\`${langAlias}
+${code}
+\`\`\``;
+              nodes.push(codeNode("md", innerFence));
+            }
+          }
+          return;
+        }
+        if (name === "shellExample") {
+          const cmd = getStringArg(expr, 0);
+          if (cmd !== null) {
+            const title = pendingFileLabel;
+            pendingFileLabel = void 0;
+            const optsArg = expr.arguments[1];
+            const opts = optsArg && ts.isObjectLiteralExpression(optsArg) ? optsArg : void 0;
+            const metaProp = opts ? getProp(opts, "meta") : void 0;
+            const hasMeta = metaProp && metaProp.initializer.kind === ts.SyntaxKind.TrueKeyword;
+            if (hasMeta) {
+              const reconstructed = reconstructShellExampleWithoutMeta(src, expr, cmd, opts);
+              nodes.push(codeNode("ts", reconstructed));
+              nodes.push({ kind: "prose", text: "becomes", noBlankBefore: true, noBlankAfter: true });
+            }
+            if (opts) processShellExampleInputFiles(opts, nodes);
+            const inputFiles = opts ? extractStaticInputFiles(opts) : [];
+            const exitCodeProp = opts ? getProp(opts, "exitCode") : void 0;
+            const expectedExitCode = exitCodeProp && ts.isNumericLiteral(exitCodeProp.initializer) ? parseInt(exitCodeProp.initializer.text, 10) : 0;
+            let execution = null;
+            if (opts && isExecutionNeeded(opts)) {
+              const outputPaths = extractOutputFilePaths(opts);
+              execution = executeShellCommand(cmd, inputFiles, outputPaths, expectedExitCode);
+            }
+            const displayCommand = opts ? readBoolOption(getProp(opts, "displayCommand")) : true;
+            const lines = displayCommand ? [`$ ${cmd}`] : [];
+            if (opts) appendShellExampleAnnotations(opts, lines, execution);
+            if (lines.length > 0) {
+              nodes.push(codeNode("sh", lines.join("\n"), title));
+            }
+            if (opts) processShellExampleOutputFiles(src, opts, nodes, cmd, inputFiles, execution);
+          }
+          return;
+        }
+      }
+    }
+  }
+  visitStatements(sf.statements);
+  extractLeadingComments(sf.endOfFileToken.getFullStart());
+  return nodes;
+}
+function getProp(obj, name) {
+  return obj.properties.find(
+    (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === name
+  );
+}
+function readBoolOption(prop) {
+  if (!prop) return true;
+  const init = prop.initializer;
+  if (init.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (ts.isStringLiteralLike(init) && init.text === "hidden") return false;
+  return true;
+}
+function readFlag(prop) {
+  if (!prop) return true;
+  return prop.initializer.kind !== ts.SyntaxKind.FalseKeyword;
+}
+function escapeForSingleQuotedString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+function reconstructShellExampleWithoutMeta(src, expr, cmd, opts) {
+  const escapedCmd = escapeForSingleQuotedString(cmd);
+  if (!opts) {
+    return `shellExample('${escapedCmd}')`;
+  }
+  const optsText = src.slice(opts.getStart(), opts.getEnd());
+  let cleanedOpts = optsText.replace(/,?\s*meta:\s*true\s*,?/g, ",").replace(/^\{\s*,/, "{").replace(/,\s*\}$/, "}");
+  return `shellExample('${escapedCmd}'${cleanedOpts !== "{}" ? `, ${cleanedOpts}` : ""})`;
+}
+function codeNode(lang, text, title) {
+  return title !== void 0 ? { kind: "code", lang, text, title } : { kind: "code", lang, text };
+}
+function getStringArg(call, index) {
+  const arg = call.arguments[index];
+  if (arg && ts.isStringLiteralLike(arg)) return arg.text;
+  return null;
+}
+function getFnBody(call, index) {
+  const arg = call.arguments[index];
+  if (!arg) return null;
+  if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+    return arg.body;
+  }
+  return null;
+}
+function extractBodyCode(src, bodyOrBlock) {
+  if (!ts.isBlock(bodyOrBlock)) {
+    return src.slice(bodyOrBlock.getFullStart(), bodyOrBlock.getEnd()).trim();
+  }
+  const stmts = bodyOrBlock.statements;
+  if (!stmts.length) return "";
+  const firstStart = stmts[0].getStart();
+  const lineStart = src.lastIndexOf("\n", firstStart - 1) + 1;
+  const indent = firstStart - lineStart;
+  const lastStmt = stmts[stmts.length - 1];
+  const lastEnd = lastStmt.getEnd();
+  const lastLineEnd = src.indexOf("\n", lastEnd);
+  const textAfterLast = src.slice(lastEnd, lastLineEnd === -1 ? src.length : lastLineEnd);
+  const extractEnd = /^\s*\/\//.test(textAfterLast) ? lastLineEnd === -1 ? src.length : lastLineEnd : lastEnd;
+  const base = stmts[0].getFullStart();
+  let raw = src.slice(base, extractEnd);
+  const replacements = [];
+  for (const stmt of stmts) {
+    const rewritten = tryRewriteAssertion(src, stmt, indent);
+    if (rewritten !== null) {
+      replacements.push({ start: stmt.getStart() - base, end: stmt.getEnd() - base, text: rewritten });
+    }
+  }
+  replacements.sort((a, b) => b.start - a.start);
+  for (const r of replacements) {
+    raw = raw.slice(0, r.start) + r.text + raw.slice(r.end);
+  }
+  let result = raw.split("\n").map((line) => line.length >= indent && line.slice(0, indent).trim() === "" ? line.slice(indent) : line).join("\n").trim();
+  result = result.replace(/\n\n\n+/g, "\n\n");
+  result = transformNestedAssertOk(result);
+  return result;
+}
+function dedentCallSource(callText) {
+  const lines = callText.split("\n");
+  if (lines.length <= 1) return callText;
+  const lastLine = lines[lines.length - 1];
+  const closingIndent = lastLine.length - lastLine.trimStart().length;
+  if (closingIndent === 0) return callText;
+  return lines.map((line, i) => {
+    if (i === 0) return line;
+    return line.length >= closingIndent && line.slice(0, closingIndent).trim() === "" ? line.slice(closingIndent) : line;
+  }).join("\n");
+}
+function commentToProse(raw, kind) {
+  if (kind === ts.SyntaxKind.SingleLineCommentTrivia) {
+    return raw.replace(/^\/\/\s?/, "");
+  }
+  if (kind === ts.SyntaxKind.MultiLineCommentTrivia) {
+    const inner = raw.replace(/^\/\*+/, "").replace(/\*+\/$/, "").split("\n").map((l) => l.replace(/^\s*\*\s?/, "")).join("\n").trim();
+    return inner || null;
+  }
+  return null;
+}
+function hasKeepComment(text) {
+  return /\/\/\s*keep\b/.test(text);
+}
+function isFullKeep(text) {
+  return /\/\/\s*keep:full\b/.test(text);
+}
+function getStatementLine(stmt, src) {
+  const lineEnd = src.indexOf("\n", stmt.getEnd());
+  const lineText = src.slice(stmt.getStart(), lineEnd === -1 ? src.length : lineEnd).trimEnd();
+  const lines = lineText.split("\n");
+  if (lines.length > 1) {
+    return null;
+  }
+  return lineText;
+}
+function getFullStatement(stmt, src) {
+  const stmtStart = stmt.getStart();
+  const stmtEnd = stmt.getEnd();
+  const firstLineEnd = src.indexOf("\n", stmtStart);
+  const firstLine = src.slice(stmtStart, firstLineEnd === -1 ? src.length : firstLineEnd);
+  if (!isFullKeep(firstLine)) {
+    return null;
+  }
+  const stmtText = src.slice(stmtStart, stmtEnd);
+  const firstLineMatch = stmtText.match(/^(\s*)/);
+  const baseIndent = firstLineMatch ? firstLineMatch[1].length : 0;
+  const dedented = stmtText.split("\n").map((line) => {
+    if (line.length >= baseIndent && line.slice(0, baseIndent).trim() === "") {
+      return line.slice(baseIndent);
+    }
+    return line;
+  }).join("\n").trimEnd();
+  const cleaned = dedented.replace(/\s*\/\/\s*keep:full\b.*$/gm, "");
+  return cleaned;
+}
+function tryRewriteAssertion(src, stmt, bodyIndent) {
+  if (!ts.isExpressionStatement(stmt)) return null;
+  const expr = stmt.expression;
+  if (!ts.isCallExpression(expr)) return null;
+  if (!ts.isPropertyAccessExpression(expr.expression)) return null;
+  const obj = expr.expression.expression;
+  const method = expr.expression.name.text;
+  if (!ts.isIdentifier(obj) || obj.text !== "assert") return null;
+  if (method === "ok") {
+    return "";
+  }
+  if (method === "throws") {
+    const fn = expr.arguments[0];
+    if (!fn) return null;
+    if (ts.isArrowFunction(fn) && !ts.isBlock(fn.body)) {
+      const exprText = src.slice(fn.body.getStart(), fn.body.getEnd());
+      const patternArg = expr.arguments[1];
+      const patternText = patternArg ? src.slice(patternArg.getStart(), patternArg.getEnd()) : null;
+      return patternText ? `${exprText} // throws ${patternText}` : `${exprText} // throws`;
+    }
+    return null;
+  }
+  const [actual, expected] = expr.arguments;
+  if (!actual || !expected) return null;
+  if (["equal", "strictEqual", "deepEqual", "deepStrictEqual"].includes(method)) {
+    return formatComparison(src, actual, expected, "=>", bodyIndent);
+  }
+  if (["notEqual", "notStrictEqual", "notDeepEqual", "notDeepStrictEqual"].includes(method)) {
+    return formatComparison(src, actual, expected, "!=", bodyIndent);
+  }
+  return null;
+}
+function formatComparison(src, actual, expected, op, bodyIndent) {
+  const actualText = src.slice(actual.getStart(), actual.getEnd());
+  const expectedRaw = src.slice(expected.getStart(), expected.getEnd());
+  const expectedText = dedentContinuationLines(expectedRaw);
+  const lines = expectedText.split("\n");
+  if (lines.length === 1) {
+    return `${actualText} // ${op} ${expectedText}`;
+  }
+  const first = lines[0];
+  const indent = " ".repeat(actualText.length + 1 + bodyIndent);
+  const rest = lines.slice(1).map((l) => `${indent}// ${l}`);
+  return [`${actualText} // ${op} ${first}`, ...rest].join("\n");
+}
+function dedentContinuationLines(text) {
+  const lines = text.split("\n");
+  if (lines.length === 1) return text;
+  const contLines = lines.slice(1).filter((l) => l.trim().length > 0);
+  if (!contLines.length) return text;
+  const minInd = Math.min(...contLines.map((l) => l.length - l.trimStart().length));
+  if (minInd === 0) return text;
+  return [
+    lines[0],
+    ...lines.slice(1).map((l) => l.length >= minInd && l.slice(0, minInd).trim() === "" ? l.slice(minInd) : l)
+  ].join("\n");
+}
+function extractTrailingFence(prose) {
+  const match = prose.match(/^([\s\S]*?)\n?```[^\n]*\n([\s\S]*?)```\s*$/);
+  if (!match) return null;
+  return {
+    prose: match[1].trimEnd(),
+    fenceCode: match[2].trimEnd()
+  };
+}
+function mergeOrPushCode(nodes, text, lang, title) {
+  const last = nodes[nodes.length - 1];
+  if (last?.kind === "code" && last.title === void 0 && title === void 0) {
+    last.text = last.text + "\n" + text;
+  } else {
+    nodes.push(codeNode(lang, text, title));
+  }
+}
+function mergeOrPushProse(nodes, text) {
+  const last = nodes[nodes.length - 1];
+  if (last?.kind === "prose" && !last.terminal) {
+    last.text = last.text + "\n" + text;
+  } else {
+    nodes.push({ kind: "prose", text });
+  }
+}
+function transformNestedAssertOk(code) {
+  return code.replace(/assert\.ok\(([^)]+)\)/g, "$1 // OK");
+}
+function getLanguageFromExtension(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() || "";
+  const langMap = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    json: "json",
+    md: "markdown",
+    yaml: "yaml",
+    yml: "yaml",
+    sh: "sh",
+    bash: "bash",
+    py: "python",
+    rs: "rust",
+    go: "go",
+    java: "java",
+    cs: "csharp",
+    rb: "ruby",
+    php: "php",
+    html: "html",
+    css: "css",
+    xml: "xml",
+    txt: "text"
+  };
+  return langMap[ext] || ext || "text";
+}
+function supportsCStyleComments(lang) {
+  const cStyleLangs = /* @__PURE__ */ new Set([
+    "typescript",
+    "javascript",
+    "java",
+    "csharp",
+    "go",
+    "rust",
+    "cpp",
+    "c",
+    "objc",
+    "swift",
+    "kotlin",
+    "scala",
+    "groovy"
+  ]);
+  return cStyleLangs.has(lang);
+}
+function processShellExampleInputFiles(opts, nodes) {
+  const inputFilesProp = getProp(opts, "inputFiles");
+  if (!inputFilesProp || !ts.isArrayLiteralExpression(inputFilesProp.initializer)) {
+    return;
+  }
+  for (const el of inputFilesProp.initializer.elements) {
+    if (!ts.isObjectLiteralExpression(el)) continue;
+    const pathProp = getProp(el, "path");
+    const contentProp = getProp(el, "content");
+    const displayPathProp = getProp(el, "displayPath");
+    const summaryProp = getProp(el, "summary");
+    const displayProp = getProp(el, "display");
+    const displayContent = readBoolOption(displayProp);
+    if (!pathProp || !ts.isStringLiteralLike(pathProp.initializer)) continue;
+    const filePath = pathProp.initializer.text;
+    const displayPath = readBoolOption(displayPathProp);
+    const summary = readFlag(summaryProp);
+    if (contentProp && displayContent && ts.isStringLiteralLike(contentProp.initializer)) {
+      const content = contentProp.initializer.text;
+      const lang = getLanguageFromExtension(filePath);
+      if (!supportsCStyleComments(lang) && displayPath && summary) {
+        nodes.push({ kind: "prose", text: `With input file \`${filePath}\`:`, noBlankAfter: true });
+      }
+      let blockText = content;
+      if (supportsCStyleComments(lang) && displayPath && summary) {
+        blockText = `// Input file "${filePath}":
+${content}`;
+      }
+      nodes.push({ kind: "code", lang, text: blockText });
+    }
+  }
+}
+var OUTPUT_FILE_INLINE_LIMIT = 60;
+function processShellExampleOutputFiles(src, opts, nodes, cmd, inputFiles, execution) {
+  const outputFilesProp = getProp(opts, "outputFiles");
+  if (!outputFilesProp || !ts.isArrayLiteralExpression(outputFilesProp.initializer)) {
+    return;
+  }
+  for (const el of outputFilesProp.initializer.elements) {
+    if (!ts.isObjectLiteralExpression(el)) continue;
+    const pathProp = getProp(el, "path");
+    const containsProp = getProp(el, "contains");
+    const matchesProp = getProp(el, "matches");
+    const displayProp = getProp(el, "display");
+    const displayPathProp = getProp(el, "displayPath");
+    const summaryProp = getProp(el, "summary");
+    const display = displayProp && ts.isStringLiteralLike(displayProp.initializer) ? displayProp.initializer.text : void 0;
+    if (!pathProp || !ts.isStringLiteralLike(pathProp.initializer)) continue;
+    const filePath = pathProp.initializer.text;
+    const lang = getLanguageFromExtension(filePath);
+    const displayPath = readBoolOption(displayPathProp);
+    const summary = readFlag(summaryProp);
+    let emitDisplayNode = display !== "none";
+    if (matchesProp && ts.isRegularExpressionLiteral(matchesProp.initializer)) {
+      if (summary) {
+        const regexText = src.slice(matchesProp.initializer.getStart(), matchesProp.initializer.getEnd());
+        const proseText = displayPath ? `Output file \`${filePath}\` matches \`${regexText}\`.` : `Matches \`${regexText}\`.`;
+        nodes.push({ kind: "prose", text: proseText, terminal: true });
+      }
+    } else if (containsProp && ts.isStringLiteralLike(containsProp.initializer)) {
+      const text = containsProp.initializer.text;
+      const isMultiLine = text.includes("\n");
+      if (!isMultiLine && text.length < OUTPUT_FILE_INLINE_LIMIT) {
+        if (summary) {
+          const proseText = displayPath ? `Output file \`${filePath}\` contains \`${text}\`.` : `Contains \`${text}\`.`;
+          nodes.push({ kind: "prose", text: proseText, terminal: true });
+        }
+      } else {
+        const firstNewline = text.indexOf("\n");
+        const truncateAt = isMultiLine ? Math.min(firstNewline, OUTPUT_FILE_INLINE_LIMIT) : OUTPUT_FILE_INLINE_LIMIT;
+        const truncated = text.slice(0, truncateAt);
+        if (isMultiLine) {
+          if (summary) {
+            const proseText = displayPath ? `Output file \`${filePath}\` contains ${truncated}...:` : `Contains ${truncated}...:`;
+            nodes.push({ kind: "prose", text: proseText, terminal: true, noBlankAfter: true });
+          }
+          nodes.push({ kind: "code", lang, text: `...
+${text}
+...` });
+          emitDisplayNode = false;
+        } else {
+          if (summary) {
+            const proseText = displayPath ? `Output file \`${filePath}\` contains ${truncated}....` : `Contains ${truncated}....`;
+            nodes.push({ kind: "prose", text: proseText, terminal: true });
+          }
+        }
+      }
+    } else {
+      if (summary) {
+        const proseText = displayPath ? `Output file \`${filePath}\`:` : `Output:`;
+        nodes.push({ kind: "prose", text: proseText, terminal: true, noBlankAfter: true });
+      }
+      emitDisplayNode = true;
+    }
+    if (emitDisplayNode) {
+      const node = { kind: "output-file-display", path: filePath, lang, cmd, inputFiles };
+      if (execution) {
+        node.execution = execution;
+      }
+      nodes.push(node);
+    }
+  }
+}
+function extractStaticInputFiles(opts) {
+  const inputFilesProp = getProp(opts, "inputFiles");
+  if (!inputFilesProp || !ts.isArrayLiteralExpression(inputFilesProp.initializer)) return [];
+  const result = [];
+  for (const el of inputFilesProp.initializer.elements) {
+    if (!ts.isObjectLiteralExpression(el)) continue;
+    const pathProp = getProp(el, "path");
+    const contentProp = getProp(el, "content");
+    if (!pathProp || !ts.isStringLiteralLike(pathProp.initializer)) continue;
+    if (!contentProp || !ts.isStringLiteralLike(contentProp.initializer)) continue;
+    result.push({ path: pathProp.initializer.text, content: contentProp.initializer.text });
+  }
+  return result;
+}
+function isExecutionNeeded(opts) {
+  const stdoutProp = getProp(opts, "stdout");
+  if (stdoutProp && ts.isObjectLiteralExpression(stdoutProp.initializer)) {
+    const displayProp = getProp(stdoutProp.initializer, "display");
+    if (displayProp && displayProp.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+      return true;
+    }
+  }
+  const outputFilesProp = getProp(opts, "outputFiles");
+  if (!outputFilesProp || !ts.isArrayLiteralExpression(outputFilesProp.initializer)) {
+    return false;
+  }
+  for (const el of outputFilesProp.initializer.elements) {
+    if (!ts.isObjectLiteralExpression(el)) continue;
+    const displayProp = getProp(el, "display");
+    const containsProp = getProp(el, "contains");
+    const matchesProp = getProp(el, "matches");
+    const display = displayProp && ts.isStringLiteralLike(displayProp.initializer) ? displayProp.initializer.text : void 0;
+    if (display !== "none") {
+      const hasMatches = matchesProp && ts.isRegularExpressionLiteral(matchesProp.initializer);
+      if (!containsProp && !hasMatches) {
+        return true;
+      }
+      if (containsProp && ts.isStringLiteralLike(containsProp.initializer)) {
+        const text = containsProp.initializer.text;
+        if (text.includes("\n") || text.length >= OUTPUT_FILE_INLINE_LIMIT) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function extractOutputFilePaths(opts) {
+  const outputFilesProp = getProp(opts, "outputFiles");
+  if (!outputFilesProp || !ts.isArrayLiteralExpression(outputFilesProp.initializer)) {
+    return [];
+  }
+  const paths = [];
+  for (const el of outputFilesProp.initializer.elements) {
+    if (!ts.isObjectLiteralExpression(el)) continue;
+    const pathProp = getProp(el, "path");
+    if (pathProp && ts.isStringLiteralLike(pathProp.initializer)) {
+      paths.push(pathProp.initializer.text);
+    }
+  }
+  return paths;
+}
+function executeShellCommand(cmd, inputFiles, outputFilePaths, expectedExitCode = 0) {
+  const tmpDir = mkdtempSync(join(tmpdir(), "lit-md-exec-"));
+  const resolvePath = (p) => isAbsolute(p) ? p : join(tmpDir, p);
+  try {
+    for (const f of inputFiles) {
+      writeFileSync(resolvePath(f.path), f.content, "utf8");
+    }
+    const result = spawnSync(cmd, { shell: true, encoding: "utf8", cwd: tmpDir });
+    const outputFiles = /* @__PURE__ */ new Map();
+    if ((result.status ?? 1) === expectedExitCode) {
+      for (const filePath of outputFilePaths) {
+        try {
+          const content = readFileSync(resolvePath(filePath), "utf8");
+          outputFiles.set(filePath, content);
+        } catch {
+        }
+      }
+    }
+    return {
+      stdout: result.stdout.trimEnd(),
+      outputFiles,
+      exitCode: result.status ?? 1
+    };
+  } catch (e) {
+    return null;
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+function appendShellExampleAnnotations(opts, lines, execution) {
+  for (const prop of opts.properties) {
+    if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+    const key = prop.name.text;
+    if (key === "exitCode" && ts.isNumericLiteral(prop.initializer)) {
+      const code = parseInt(prop.initializer.text, 10);
+      if (code !== 0) {
+        lines.push(`# exits: ${code}`);
+      }
+    }
+    if (key === "stdout" && ts.isObjectLiteralExpression(prop.initializer)) {
+      const containsProp = getProp(prop.initializer, "contains");
+      const displayProp = getProp(prop.initializer, "display");
+      if (displayProp && displayProp.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+        if (execution && execution.exitCode === 0) {
+          lines.push(execution.stdout);
+        }
+      } else if (containsProp && ts.isStringLiteralLike(containsProp.initializer)) {
+        lines.push(containsProp.initializer.text);
+      }
+    }
+    if (key === "inputFiles" && ts.isArrayLiteralExpression(prop.initializer)) {
+      for (const el of prop.initializer.elements) {
+        if (!ts.isObjectLiteralExpression(el)) continue;
+        const pathProp = getProp(el, "path");
+        const contentProp = getProp(el, "content");
+        const displayPathProp = getProp(el, "displayPath");
+        const summaryProp = getProp(el, "summary");
+        if (!pathProp || !ts.isStringLiteralLike(pathProp.initializer)) continue;
+        const filePath = pathProp.initializer.text;
+        const displayPath = readBoolOption(displayPathProp);
+        const summary = readFlag(summaryProp);
+        if (contentProp && ts.isStringLiteralLike(contentProp.initializer)) {
+          const content = contentProp.initializer.text;
+          const lang = getLanguageFromExtension(filePath);
+          if (!content.includes("\n") && supportsCStyleComments(lang) && displayPath && summary) {
+            lines.push(`# Input file \`${filePath}\` contains \`${content}\``);
+          }
+        }
+      }
+    }
+  }
+}
+
+// src/renderer.ts
+var langAliases = {
+  typescript: "ts",
+  javascript: "js"
+};
+function mergeConsecutiveCodeBlocks(nodes) {
+  if (nodes.length === 0) return nodes;
+  const result = [];
+  let currentCodeBlock = null;
+  for (const node of nodes) {
+    if (node.kind === "code") {
+      if (currentCodeBlock && currentCodeBlock.lang === node.lang && !currentCodeBlock.title && !node.title) {
+        currentCodeBlock.text += "\n\n" + node.text;
+      } else {
+        if (currentCodeBlock) result.push(currentCodeBlock);
+        currentCodeBlock = { ...node };
+      }
+    } else {
+      if (currentCodeBlock) {
+        result.push(currentCodeBlock);
+        currentCodeBlock = null;
+      }
+      result.push(node);
+    }
+  }
+  if (currentCodeBlock) result.push(currentCodeBlock);
+  return result;
+}
+function render(nodes, describeFormat2 = "hidden") {
+  const merged = mergeConsecutiveCodeBlocks(nodes.filter((n) => n.kind !== "output-file-display"));
+  if (!merged.length) return "";
+  let out = "";
+  let lastHeaderLevel = 0;
+  for (let i = 0; i < merged.length; i++) {
+    if (i > 0) {
+      const prev = merged[i - 1];
+      const curr = merged[i];
+      const noBlank = prev.kind === "prose" && prev.noBlankAfter || curr.kind === "prose" && curr.noBlankBefore;
+      out += noBlank ? "\n" : "\n\n";
+    }
+    const rendered = renderNode(merged[i], describeFormat2, lastHeaderLevel);
+    out += rendered;
+    const node = merged[i];
+    if (node.kind === "describe" && describeFormat2 !== "hidden") {
+      const baseLevel = describeFormat2 === "auto" ? lastHeaderLevel : describeFormat2.length;
+      lastHeaderLevel = baseLevel + node.depth;
+      lastHeaderLevel = Math.min(lastHeaderLevel, 6);
+    } else if (node.kind === "prose") {
+      const proseHeaderLevel = getMaxHeaderLevelInProse(node.text);
+      if (proseHeaderLevel > 0) {
+        lastHeaderLevel = proseHeaderLevel;
+      }
+    }
+  }
+  return out;
+}
+function renderNode(node, describeFormat2 = "hidden", lastHeaderLevel = 0) {
+  if (node.kind === "prose") return node.text;
+  if (node.kind === "output-file-display") return "";
+  if (node.kind === "describe") {
+    if (describeFormat2 === "hidden") return "";
+    let baseLevel;
+    if (describeFormat2 === "auto") {
+      baseLevel = lastHeaderLevel === 0 ? 1 : lastHeaderLevel + 1;
+    } else {
+      baseLevel = describeFormat2.length > 0 ? describeFormat2.length : 1;
+    }
+    const level = baseLevel + node.depth;
+    const hashes = "#".repeat(Math.min(level, 6));
+    return `${hashes} ${node.name}`;
+  }
+  const lang = langAliases[node.lang] ?? node.lang;
+  const info = lang === "text" ? node.title ?? "" : node.title ? `${lang} ${node.title}` : lang;
+  const maxBackticks = findMaxBacktickSequence(node.text);
+  const fenceLength = Math.max(3, maxBackticks + 1);
+  const fence = "`".repeat(fenceLength);
+  return `${fence}${info}
+${node.text}
+${fence}`;
+}
+function findMaxBacktickSequence(text) {
+  let maxSeq = 0;
+  let currentSeq = 0;
+  for (const char of text) {
+    if (char === "`") {
+      currentSeq++;
+      maxSeq = Math.max(maxSeq, currentSeq);
+    } else {
+      currentSeq = 0;
+    }
+  }
+  return maxSeq;
+}
+function getMaxHeaderLevelInProse(text) {
+  let maxLevel = 0;
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^(#+)\s/);
+    if (match) {
+      const level = match[1].length;
+      maxLevel = Math.max(maxLevel, Math.min(level, 6));
+    }
+  }
+  return maxLevel;
+}
+
+// src/typecheck.ts
+import ts2 from "typescript";
+import { join as join2 } from "path";
+function typecheck(files) {
+  const tsConfigPath = join2(process.cwd(), "tsconfig.json");
+  const configPath = ts2.sys.fileExists(tsConfigPath) ? tsConfigPath : void 0;
+  let compilerOptions;
+  if (configPath) {
+    const configFile = ts2.readConfigFile(configPath, ts2.sys.readFile);
+    if (configFile.error) {
+      return { ok: false, messages: [ts2.flattenDiagnosticMessageText(configFile.error.messageText, "\n")] };
+    }
+    const parsed = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, ts2.sys.getCurrentDirectory());
+    compilerOptions = { ...parsed.options, noEmit: true };
+  } else {
+    compilerOptions = {
+      strict: true,
+      noEmit: true,
+      module: ts2.ModuleKind.NodeNext,
+      moduleResolution: ts2.ModuleResolutionKind.NodeNext,
+      target: ts2.ScriptTarget.ESNext,
+      allowImportingTsExtensions: true
+    };
+  }
+  const program = ts2.createProgram(files, compilerOptions);
+  const diagnostics = ts2.getPreEmitDiagnostics(program);
+  if (!diagnostics.length) return { ok: true, messages: [] };
+  const formatted = ts2.formatDiagnosticsWithColorAndContext(diagnostics, {
+    getCanonicalFileName: (fileName) => fileName,
+    getCurrentDirectory: () => process.cwd(),
+    getNewLine: () => "\n"
+  });
+  return { ok: false, messages: [formatted] };
+}
+
+// src/shell.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, mkdtempSync as mkdtempSync2, rmSync as rmSync2, existsSync } from "node:fs";
+import { isAbsolute as isAbsolute2, resolve, join as join3, dirname } from "node:path";
+import { test } from "node:test";
+import { test as test2, test as test3, describe as describe2 } from "node:test";
+function stripTypesFlag() {
+  const parts = process.versions.node.split(".");
+  const major = parseInt(parts[0] ?? "0", 10);
+  const minor = parseInt(parts[1] ?? "0", 10);
+  if (major === 22 && minor >= 6) return "--experimental-strip-types";
+  if (major === 23 && minor < 6) return "--experimental-strip-types";
+  return "";
+}
+function extractImportPaths(filePath, baseDir) {
+  const importedPaths = /* @__PURE__ */ new Set();
+  try {
+    const content = readFileSync2(filePath, "utf8");
+    const importRegex = /import\s+(?:(?:{[^}]*})|(?:\*\s+as\s+\w+)|(?:\w+))?(?:\s*,\s*(?:{[^}]*}|\*\s+as\s+\w+|\w+))*\s+from\s+['"]([^'"]+)['"]/g;
+    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath && !importPath.startsWith(".") && !importPath.startsWith("/")) {
+        continue;
+      }
+      const resolved = resolveImportPath(importPath, baseDir);
+      if (resolved) importedPaths.add(resolved);
+    }
+    while ((match = requireRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath && !importPath.startsWith(".") && !importPath.startsWith("/")) {
+        continue;
+      }
+      const resolved = resolveImportPath(importPath, baseDir);
+      if (resolved) importedPaths.add(resolved);
+    }
+  } catch {
+  }
+  return importedPaths;
+}
+function resolveImportPath(importPath, baseDir) {
+  const basePath = resolve(baseDir, importPath);
+  if (existsSync(basePath)) return basePath;
+  for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+    if (existsSync(basePath + ext)) {
+      return basePath + ext;
+    }
+  }
+  for (const indexFile of ["index.ts", "index.tsx", "index.js", "index.jsx"]) {
+    const indexPath = join3(basePath, indexFile);
+    if (existsSync(indexPath)) {
+      return indexPath;
+    }
+  }
+  return null;
+}
+function collectAllDependencies(inputPaths2, visited = /* @__PURE__ */ new Set()) {
+  const allDeps = new Set(inputPaths2.map((p) => resolve(p)));
+  const toProcess = [...inputPaths2];
+  while (toProcess.length > 0) {
+    const current = toProcess.shift();
+    const resolvedCurrent = resolve(current);
+    if (visited.has(resolvedCurrent)) continue;
+    visited.add(resolvedCurrent);
+    const deps = extractImportPaths(resolvedCurrent, dirname(resolvedCurrent));
+    for (const dep of deps) {
+      allDeps.add(dep);
+      if (!visited.has(dep)) {
+        toProcess.push(dep);
+      }
+    }
+  }
+  return allDeps;
+}
+async function watchFilesAndWait(inputPaths2) {
+  if (!process.stdin.isTTY) {
+    return "spacebar";
+  }
+  const { watch } = await import("node:fs");
+  let lastChangeTime = 0;
+  const DEBOUNCE_MS = 300;
+  let changeDetected = false;
+  const filesToWatch = collectAllDependencies(inputPaths2);
+  const watchers = Array.from(filesToWatch).map((filePath) => {
+    return watch(filePath, (eventType) => {
+      const now = Date.now();
+      if (now - lastChangeTime >= DEBOUNCE_MS) {
+        lastChangeTime = now;
+        changeDetected = true;
+      }
+    });
+  });
+  const exitHandler = () => {
+    watchers.forEach((w) => w.close());
+    process.stdin.setRawMode(false);
+    process.exit(0);
+  };
+  process.on("SIGINT", exitHandler);
+  process.on("SIGTERM", exitHandler);
+  console.error("Press space to regenerate, q to quit...");
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  return new Promise((resolve3) => {
+    const onData = (data) => {
+      const char = data[0];
+      if (char === 32) {
+        cleanup();
+        resolve3("spacebar");
+      } else if (char === 3 || char === 113 || char === 120 || char === 27) {
+        cleanup();
+        process.exit(0);
+      }
+    };
+    const checkForChanges = setInterval(() => {
+      if (changeDetected) {
+        cleanup();
+        console.error("Files changed, regenerating...");
+        resolve3("filechange");
+      }
+    }, 50);
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      clearInterval(checkForChanges);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.removeListener("SIGINT", exitHandler);
+      process.removeListener("SIGTERM", exitHandler);
+      watchers.forEach((w) => w.close());
+    };
+    process.stdin.on("data", onData);
+  });
+}
+
+// src/resolver.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdtempSync as mkdtempSync3, rmSync as rmSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+function resolveOutputFiles(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    if (node.kind !== "output-file-display") {
+      result.push(node);
+      continue;
+    }
+    const content = runAndCapture(node);
+    if (content !== null) {
+      const prev = result[result.length - 1];
+      if (content.trim()) {
+        if (prev?.kind === "prose" && prev.text.endsWith(".")) {
+          result[result.length - 1] = { ...prev, text: prev.text.slice(0, -1) + ":", noBlankAfter: true };
+        }
+        result.push({ kind: "code", lang: node.lang, text: content.trimEnd() });
+      } else {
+        if (prev?.kind === "prose" && (prev.text.endsWith(":") || prev.text.endsWith("."))) {
+          result[result.length - 1] = { ...prev, text: prev.text.slice(0, -1) + " is empty." };
+        }
+      }
+    }
+  }
+  return result;
+}
+function runAndCapture(node) {
+  if (node.execution) {
+    if (node.execution.exitCode !== 0) return null;
+    const content = node.execution.outputFiles.get(node.path);
+    return content ?? null;
+  }
+  const tmpDir = mkdtempSync3(join4(tmpdir2(), "lit-md-cap-"));
+  try {
+    for (const f of node.inputFiles) {
+      writeFileSync3(join4(tmpDir, f.path), f.content, "utf8");
+    }
+    const result = spawnSync2(node.cmd, { shell: true, encoding: "utf8", cwd: tmpDir });
+    if (result.status !== 0) return null;
+    try {
+      return readFileSync3(join4(tmpDir, node.path), "utf8");
+    } catch {
+      return null;
+    }
+  } finally {
+    rmSync3(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// src/describe-format.ts
+var overrideFormat = void 0;
+function resetDescribeFormat() {
+  overrideFormat = void 0;
+}
+function resolveDescribeFormat(cliFormat) {
+  return overrideFormat ?? cliFormat;
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+function extractFlag(flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1) return false;
+  args.splice(idx, 1);
+  return true;
+}
+function extractFlagValue(flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1) {
+    const eqIdx = args.findIndex((arg) => arg.startsWith(flag + "="));
+    if (eqIdx === -1) return void 0;
+    const value2 = args[eqIdx].slice(flag.length + 1);
+    args.splice(eqIdx, 1);
+    return value2;
+  }
+  const value = args[idx + 1];
+  args.splice(idx, 2);
+  return value;
+}
+var showHelp = extractFlag("--help") || extractFlag("-h");
+var dryrun = extractFlag("--dryrun");
+var runTests = extractFlag("--test");
+var runTypecheck = extractFlag("--typecheck");
+var updateSnapshots = extractFlag("--update-snapshots") || extractFlag("-u");
+var wait = extractFlag("--wait");
+var outFlag = extractFlagValue("--out");
+var outputDir = extractFlagValue("--outDir");
+var describeFormat = extractFlagValue("--describe") || "##";
+function parseTestSummary(output) {
+  const lines = output.split("\n");
+  let stats = { passed: 0, failed: 0, total: 0, hasFailed: false };
+  for (const line of lines) {
+    if (line.includes("\u2139 pass")) {
+      const match = line.match(/pass\s+(\d+)/);
+      if (match) stats.passed = parseInt(match[1]);
+    }
+    if (line.includes("\u2139 fail")) {
+      const match = line.match(/fail\s+(\d+)/);
+      if (match) stats.failed = parseInt(match[1]);
+    }
+    if (line.includes("\u2139 tests")) {
+      const match = line.match(/tests\s+(\d+)/);
+      if (match) stats.total = parseInt(match[1]);
+    }
+  }
+  stats.hasFailed = stats.failed > 0;
+  return stats;
+}
+var unknownOptions = args.filter((a) => a.startsWith("--") || a.startsWith("-") && a.length > 1 && a !== "-");
+if (unknownOptions.length > 0) {
+  console.error(`error: unknown option${unknownOptions.length > 1 ? "s" : ""}: ${unknownOptions.join(", ")}`);
+  process.exit(1);
+}
+var inputPaths = args.filter((a) => !a.startsWith("--"));
+function getOutputFileName(inputPath) {
+  const base = basename(inputPath);
+  if (base.endsWith(".lit-md.ts") || base.endsWith(".lit-md.js")) {
+    return base.slice(0, -(base.endsWith(".lit-md.ts") ? ".lit-md.ts".length : ".lit-md.js".length)) + ".md";
+  }
+  return basename(inputPath, extname2(inputPath)) + ".md";
+}
+if (showHelp) {
+  console.log(`lit-md - Generate markdown documentation from test files
+
+Usage: lit-md [options] <file.ts|js> [file2 ...]
+
+Options:
+  --help, -h                Show this help message
+  --test                    Run tests before generating markdown
+  --typecheck               Run type checking before generating markdown
+  --dryrun                  Show what would be written without writing files
+  -u, --update-snapshots    Update snapshot files instead of generating markdown
+  --wait                    After generating, keep the process alive and watch for file
+                             changes. Press space to manually regenerate, Ctrl+C to exit.
+                             Works with --test and --typecheck (reruns on each change).
+  --out <output.md>         Write to a specific output file (requires single input)
+  --outDir <dir>           Write generated markdown files to this directory
+  --describe <format>       Control describe() block rendering (default: ##)
+                            Formats:
+                              hidden  - Omit describes
+                              #       - Render as h1 headers, nested as h2, h3, etc.
+                              ##      - Render as h2 headers, nested as h3, h4, etc. (default)
+                              ###     - Render as h3 headers, nested as h4, h5, etc.
+                              ####    - Render as h4 headers, nested as h5, h6, etc.
+                              auto    - Dynamically determine level based on document structure
+                                        (h1 if no headers exist, else one level deeper than last header)
+
+By default, output is written to stdout. Use --out or --outDir to write to files.
+
+Examples:
+  lit-md README.md.test.ts                                  # outputs to stdout
+  lit-md --test --typecheck README.md.test.ts               # outputs to stdout after testing
+  lit-md --wait README.md.test.ts                           # outputs to stdout, then waits for changes
+  lit-md --out /tmp/docs.md README.md.test.ts               # writes to file
+  lit-md --outDir ./docs src/**/*.md.test.ts                # writes to directory
+  lit-md --describe="#" README.md.test.ts                   # outputs to stdout with custom format
+  lit-md --describe="auto" README.md.test.ts                # outputs to stdout with auto format
+`);
+  process.exit(0);
+}
+if (!inputPaths.length) {
+  console.error("Usage: lit-md [--test] [--typecheck] [--dryrun] [-u|--update-snapshots] [--out <output.md>] [--outDir <dir>] <file.ts|js> [file2 ...]");
+  process.exit(1);
+}
+var validDescribeFormats = ["hidden", "auto", "#", "##", "###", "####"];
+if (!validDescribeFormats.includes(describeFormat)) {
+  console.error(`error: invalid --describe format: ${describeFormat}. Valid formats: ${validDescribeFormats.join(", ")}`);
+  process.exit(1);
+}
+if (outFlag && outputDir) {
+  console.error("error: --out and --outDir are mutually exclusive");
+  process.exit(1);
+}
+if (outFlag && inputPaths.length > 1) {
+  console.error("error: --out can only be used with a single input file");
+  process.exit(1);
+}
+if (runTypecheck) {
+  const jsFiles = inputPaths.filter((f) => extname2(f) === ".js");
+  if (jsFiles.length) {
+    console.error(`error: --typecheck requires .ts files; received: ${jsFiles.join(", ")}`);
+    process.exit(1);
+  }
+}
+async function generateMarkdown() {
+  let filesGenerated = 0;
+  for (const inputPath of inputPaths) {
+    resetDescribeFormat();
+    const absolutePath = resolve2(inputPath);
+    try {
+      const origStdoutWrite = process.stdout.write;
+      const origStderrWrite = process.stderr.write;
+      const origLog = console.log;
+      const origInfo = console.info;
+      const origWarn = console.warn;
+      try {
+        process.stdout.write = () => true;
+        process.stderr.write = () => true;
+        console.log = () => {
+        };
+        console.info = () => {
+        };
+        console.warn = () => {
+        };
+        await import(absolutePath);
+        await new Promise((resolve3) => setTimeout(resolve3, 100));
+      } finally {
+        process.stdout.write = origStdoutWrite;
+        process.stderr.write = origStderrWrite;
+        console.log = origLog;
+        console.info = origInfo;
+        console.warn = origWarn;
+      }
+    } catch {
+    }
+    const src = readFileSync4(inputPath, "utf8");
+    const lang = extname2(inputPath) === ".js" ? "javascript" : "typescript";
+    let nodes = parse(src, lang);
+    if (!dryrun) {
+      nodes = resolveOutputFiles(nodes);
+    }
+    const finalDescribeFormat = resolveDescribeFormat(describeFormat);
+    const md = render(nodes, finalDescribeFormat);
+    let outPath = null;
+    let isStdout = false;
+    if (updateSnapshots) {
+      const outputFileName = getOutputFileName(inputPath);
+      const fileNameWithoutMd = outputFileName.slice(0, -3);
+      outPath = join5(dirname2(resolve2(inputPath)), `${fileNameWithoutMd}.snapshot.md`);
+    } else if (outFlag) {
+      outPath = outFlag;
+    } else if (outputDir) {
+      mkdirSync(outputDir, { recursive: true });
+      outPath = join5(outputDir, getOutputFileName(inputPath));
+    } else {
+      isStdout = true;
+    }
+    if (dryrun) {
+      if (isStdout) {
+        console.error(`dry run: would write to stdout`);
+      } else {
+        console.error(`dry run: would write ${outPath}`);
+      }
+    } else if (isStdout) {
+      process.stdout.write(md + "\n");
+    } else {
+      writeFileSync4(outPath, md + "\n", "utf8");
+      filesGenerated++;
+    }
+  }
+  if (!dryrun && filesGenerated > 0) {
+    const fileWord = filesGenerated === 1 ? "file" : "files";
+    console.error(`\u2705 Generated ${filesGenerated} ${fileWord}`);
+  }
+}
+async function executeTasks() {
+  if (runTypecheck) {
+    const result = typecheck(inputPaths.map((p) => resolve2(p)));
+    if (!result.ok) {
+      for (const msg of result.messages) console.error(msg);
+      console.error("\u274C Typecheck failed");
+      if (!wait) process.exit(1);
+    } else {
+      console.error("\u2705 Typecheck passed");
+    }
+  }
+  if (runTests) {
+    const stripFlag = stripTypesFlag();
+    const nodeArgs = ["--test", ...stripFlag ? [stripFlag] : [], ...inputPaths.map((p) => resolve2(p))];
+    const spawnOptions = wait ? { encoding: "utf-8" } : { stdio: "inherit", env: process.env };
+    const result = spawnSync3(process.execPath, nodeArgs, spawnOptions);
+    if (wait && result.stdout) {
+      const output = result.stdout.toString();
+      const stats = parseTestSummary(output);
+      if (stats.hasFailed) {
+        const failureStart = output.indexOf("\u2716 failing tests");
+        if (failureStart !== -1) {
+          const failureSection = output.substring(failureStart);
+          console.error(failureSection);
+        }
+        console.error(`
+\u274C Tests failed: ${stats.failed}/${stats.total} failed`);
+      } else {
+        console.log(`\u2705 Tests passed: ${stats.passed} passed`);
+      }
+    }
+    if (result.status !== 0) {
+      if (!wait) process.exit(result.status ?? 1);
+    }
+  }
+  await generateMarkdown();
+}
+(async () => {
+  await executeTasks();
+  if (wait && process.stdin.isTTY) {
+    while (true) {
+      const trigger = await watchFilesAndWait(inputPaths);
+      await executeTasks();
+    }
+  }
+})();
+//# sourceMappingURL=cli.js.map