mmdfmt 0.0.0-stage → 0.1.0

package/lib/cli.mjs

@@ -0,0 +1,794 @@
+#!/usr/bin/env node
+import { readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { cli, define, isArgsValidationError } from "gunshi";
+import { format, getFileInfo, resolveConfig } from "prettier";
+import { ParseError, parse } from "@mmd-toolkit/parser";
+import plugin from "prettier-plugin-mmd";
+import { parsers } from "prettier/plugins/markdown";
+import { convertPathToPattern, glob } from "tinyglobby";
+//#region src/broken-pipe.ts
+/**
+* The listener of the errors of standard output. When the reader of standard
+* output goes away, as `head` does once it has its lines, writing fails with
+* `EPIPE`. Other command-line tools then end without a word; so does this
+* tool, and it finishes the run, so that `--write` still rewrites every file
+* and the exit code still tells the result (README, Usage). Any other error is
+* thrown, as Node.js throws it when the stream has no listener.
+*/
+function ignoreBrokenPipe(error) {
+	if (error.code !== "EPIPE") throw error;
+}
+//#endregion
+//#region package.json
+var version = "0.1.0";
+var description = "Command-line formatter for Mermaid diagrams in .mmd files and in Markdown code blocks, which changes nothing else";
+//#endregion
+//#region src/diagram.ts
+/** Prettier's name of each line ending. */
+const endOfLineOptions = {
+	"\n": "lf",
+	"\r\n": "crlf",
+	"\r": "cr"
+};
+/**
+* Formats the text of a diagram with Prettier and prettier-plugin-mmd, as
+* Prettier formats a `.mmd` file with the plugin. The text has no byte order
+* mark and its lines end with `\n`, as Prettier leaves a text before parsing
+* it; the lines of the result end with `lineEnding`.
+*
+* A text that the plugin rejects is parsed again with the parser that the
+* plugin uses, for the message and the offset of the syntax error: the error
+* that Prettier throws has a line and a column counted for Prettier's code
+* frame, which also ends lines at U+2028 and U+2029, and no offset.
+*/
+async function formatDiagram(text, indentation, lineEnding) {
+	try {
+		return {
+			kind: "formatted",
+			text: await format(text, {
+				parser: "mermaid",
+				plugins: [plugin],
+				tabWidth: indentation.tabWidth,
+				useTabs: indentation.useTabs,
+				endOfLine: endOfLineOptions[lineEnding]
+			})
+		};
+	} catch (error) {
+		const syntaxError = syntaxErrorOf(text);
+		if (syntaxError === void 0) throw error;
+		return {
+			kind: "rejected",
+			message: syntaxError.message,
+			offset: syntaxError.range[0]
+		};
+	}
+}
+/** The syntax error of a text, or `undefined` when the parser accepts it. */
+function syntaxErrorOf(text) {
+	try {
+		parse(text);
+	} catch (error) {
+		if (error instanceof ParseError) return error;
+		throw error;
+	}
+}
+//#endregion
+//#region src/lines.ts
+const byteOrderMark = "";
+/** Reads a text into its byte order mark, its lines, and its normalized form. */
+function readText(text) {
+	const mark = text.startsWith(byteOrderMark) ? byteOrderMark : "";
+	const lines = splitLines(text.slice(mark.length));
+	return {
+		byteOrderMark: mark,
+		lines,
+		normalized: lines.map((line) => line.text).join("\n")
+	};
+}
+/**
+* Splits a text into lines at `\n`, `\r\n`, and `\r`. Joining the lines with
+* their endings gives the text back; the last line is `""` when the text ends
+* with a line terminator.
+*/
+function splitLines(text) {
+	const lines = [];
+	let start = 0;
+	for (let index = 0; index < text.length; index++) {
+		const character = text[index];
+		if (character !== "\n" && character !== "\r") continue;
+		const ending = character === "\r" && text[index + 1] === "\n" ? "\r\n" : character;
+		lines.push({
+			text: text.slice(start, index),
+			ending
+		});
+		index += ending.length - 1;
+		start = index + 1;
+	}
+	lines.push({
+		text: text.slice(start),
+		ending: ""
+	});
+	return lines;
+}
+/**
+* The line ending that the tool writes in a file: the first line ending of the
+* file, or `\n` in a file without one (README, Code blocks in detail).
+*/
+function lineEndingOf(text) {
+	for (let index = 0; index < text.length; index++) {
+		if (text[index] === "\n") return "\n";
+		if (text[index] === "\r") return text[index + 1] === "\n" ? "\r\n" : "\r";
+	}
+	return "\n";
+}
+/** The position of an offset in a text whose lines end with `\n`. */
+function positionIn(text, offset) {
+	let line = 1;
+	let lineStart = 0;
+	for (let index = 0; index < offset; index++) if (text[index] === "\n") {
+		line++;
+		lineStart = index + 1;
+	}
+	return {
+		line,
+		column: offset - lineStart + 1
+	};
+}
+//#endregion
+//#region src/markdown.ts
+/**
+* The first words of an info string that mark a diagram: the `aliases` of the
+* language of prettier-plugin-mmd, which are the code blocks that Prettier
+* formats with the plugin. Prettier compares them case-sensitively.
+*/
+const diagramLanguages = /* @__PURE__ */ new Set(["mermaid", "mmd"]);
+/**
+* Formats the diagrams in the code blocks of a Markdown file and changes
+* nothing else (README, Code blocks in detail). The warnings give their
+* positions in the text that `positionsIn` names.
+*/
+async function formatMarkdown(text, indentation, positionsIn) {
+	const { byteOrderMark, lines, normalized } = readText(text);
+	const lineEnding = lineEndingOf(text);
+	const diagnostics = [];
+	let output = byteOrderMark;
+	let next = 0;
+	let addedLines = 0;
+	for (const block of diagramBlocksOf(await parseMarkdown(normalized))) {
+		const result = await formatBlock(block, lines, indentation, lineEnding);
+		if (result.kind === "warning") {
+			const { diagnostic } = result;
+			const { line, column } = diagnostic.position;
+			diagnostics.push(positionsIn === "input" ? diagnostic : {
+				...diagnostic,
+				position: {
+					line: line + addedLines,
+					column
+				}
+			});
+			continue;
+		}
+		if (result.kind === "unchanged") continue;
+		output += joinLines(lines.slice(next, result.start)) + result.text;
+		next = result.start + result.count;
+		addedLines += result.textLineCount - result.count;
+	}
+	output += joinLines(lines.slice(next));
+	return {
+		text: output,
+		diagnostics
+	};
+}
+/**
+* Parses Markdown with Prettier's Markdown parser, so that the tool finds the
+* code blocks that Prettier finds. Its `parse` reads only the text (it takes
+* one parameter), so it is called without Prettier's options.
+*/
+async function parseMarkdown(text) {
+	const parse = parsers.markdown.parse;
+	return parse(text);
+}
+/**
+* The code blocks of diagrams in a Markdown tree, in the order of the file,
+* without those that Prettier leaves as written for a `prettier-ignore`
+* comment (README, Excluding files): the node right after
+* `<!-- prettier-ignore -->` among the children of any node, and the nodes
+* between `<!-- prettier-ignore-start -->` and the next
+* `<!-- prettier-ignore-end -->` among the children of the root.
+*/
+function diagramBlocksOf(root) {
+	const blocks = [];
+	/** Collects the blocks of a node and of its descendants. */
+	function visit(node, footnoteLines) {
+		if (node.type === "code" && typeof node.lang === "string" && diagramLanguages.has(node.lang) && typeof node.value === "string") {
+			blocks.push({
+				value: node.value,
+				position: node.position,
+				followsFootnoteLabel: footnoteLines.includes(node.position.start.line)
+			});
+			return;
+		}
+		const lines = node.type === "footnoteDefinition" ? [...footnoteLines, node.position.start.line] : footnoteLines;
+		const children = node.children ?? [];
+		const ignored = node === root ? nodesInIgnoredRanges(children) : /* @__PURE__ */ new Set();
+		for (const [index, child] of children.entries()) {
+			if (ignored.has(child)) continue;
+			if (index > 0 && prettierIgnoreOf(children[index - 1]) === "next") continue;
+			visit(child, lines);
+		}
+	}
+	visit(root, []);
+	return blocks;
+}
+/**
+* The nodes between a `prettier-ignore-start` comment and the next
+* `prettier-ignore-end` comment, as Prettier finds them among the children of
+* the root: a start without an end leaves nothing as written.
+*/
+function nodesInIgnoredRanges(children) {
+	const ignored = /* @__PURE__ */ new Set();
+	let start;
+	for (const [index, child] of children.entries()) {
+		const ignore = prettierIgnoreOf(child);
+		if (ignore === "start" && start === void 0) start = index;
+		else if (ignore === "end" && start !== void 0) {
+			for (const node of children.slice(start + 1, index)) ignored.add(node);
+			start = void 0;
+		}
+	}
+	return ignored;
+}
+/**
+* What a node asks as a `prettier-ignore` comment, as Prettier's Markdown
+* printer reads it: an HTML node of `<!--`, `prettier-ignore` with
+* `-start` or `-end` or nothing, and `-->`, with whitespace around the word.
+*/
+function prettierIgnoreOf(node) {
+	const { value } = node;
+	if (node.type !== "html" || value === void 0 || !value.startsWith("<!--") || !value.endsWith("-->")) return;
+	switch (value.slice(4, -3).trim()) {
+		case "prettier-ignore": return "next";
+		case "prettier-ignore-start": return "start";
+		case "prettier-ignore-end": return "end";
+		default: return;
+	}
+}
+/**
+* Formats the diagram of a code block. Only the content lines change: the
+* lines between the opening fence and the closing fence, or the end of the
+* block, without its blank lines there, when it is not closed. The line of the
+* opening fence keeps its text, and its line ending too unless the diagram
+* becomes empty.
+*/
+async function formatBlock(block, lines, indentation, lineEnding) {
+	const start = block.position.start.line;
+	if (block.followsFootnoteLabel) return {
+		kind: "warning",
+		diagnostic: {
+			severity: "warning",
+			message: "not formatted: the opening fence stands on the line of a footnote label",
+			position: {
+				line: start,
+				column: block.position.start.column
+			}
+		}
+	};
+	const contentValues = valueLinesOf(block, lines);
+	const values = isClosed(block, lines, contentValues.length) ? contentValues : withoutTrailingBlankLines(contentValues);
+	const prefixes = [];
+	for (const [index, value] of values.entries()) {
+		const line = lines[start + index].text;
+		if (!line.endsWith(value)) return {
+			kind: "warning",
+			diagnostic: {
+				severity: "warning",
+				message: "not formatted: a tab in the indentation of this line is read partly as the text of the diagram",
+				position: {
+					line: start + index + 1,
+					column: line.length - commonSuffixLength(line, value)
+				}
+			}
+		};
+		prefixes.push(line.slice(0, line.length - value.length));
+	}
+	const endsWithLineEnding = values.length > 0 && lines[start + values.length - 1].ending !== "";
+	const text = values.join("\n") + (endsWithLineEnding ? "\n" : "");
+	const result = await formatDiagram(text, indentation, "\n");
+	if (result.kind === "rejected") {
+		const { line, column } = positionIn(text, result.offset);
+		return {
+			kind: "warning",
+			diagnostic: {
+				severity: "warning",
+				message: result.message,
+				position: {
+					line: start + line,
+					column: (prefixes[line - 1]?.length ?? 0) + column
+				}
+			}
+		};
+	}
+	const formatted = !endsWithLineEnding && result.text.endsWith("\n") ? result.text.slice(0, -1) : result.text;
+	if (formatted === text) return { kind: "unchanged" };
+	const fenceLine = lines[start - 1];
+	const prefix = newLinePrefixOf(fenceLine.text.slice(0, block.position.start.column - 1));
+	const written = [fenceLine];
+	for (const line of splitLines(formatted)) {
+		if (line.ending === "" && line.text === "") break;
+		written.push({
+			text: line.text === "" ? prefix.trimEnd() : prefix + line.text,
+			ending: lineEnding
+		});
+	}
+	const last = written.length - 1;
+	written[last] = {
+		text: written[last].text,
+		ending: lines[start + values.length - 1].ending
+	};
+	return {
+		kind: "replaced",
+		start: start - 1,
+		count: values.length + 1,
+		text: joinLines(written),
+		textLineCount: written.length
+	};
+}
+/**
+* The lines of the text of a block, one for each content line. The parser
+* joins the content lines with `\n`, without a line ending after the last, so
+* that the text `""` stands both for no content line and for one empty
+* content line; see {@link hasOneEmptyLine}.
+*/
+function valueLinesOf(block, lines) {
+	if (block.value !== "") return block.value.split("\n");
+	return hasOneEmptyLine(block, lines) ? [""] : [];
+}
+/**
+* Whether a block whose text is `""` has one content line. The line after the
+* opening fence is then that line, which the block reaches into and which
+* holds only the indentation and the `>` of the block's container. Otherwise
+* that line is the closing fence, which holds the characters of a fence, or it
+* is outside the block.
+*/
+function hasOneEmptyLine(block, lines) {
+	const next = block.position.start.line;
+	const { end } = block.position;
+	if (!(end.line - 1 > next || end.line - 1 === next && end.column > 1)) return false;
+	const line = lines[next].text;
+	return !line.includes("`") && !line.includes("~");
+}
+/**
+* Whether a block has a closing fence: the line after its content lines, which
+* the block reaches into with the characters of a fence. A block that is not
+* closed ends where its container or the file ends, on its last content line,
+* or on the next line with no more of it than the indentation and the `>` of
+* its container.
+*/
+function isClosed(block, lines, contentLineCount) {
+	const next = block.position.start.line + contentLineCount;
+	const { end } = block.position;
+	if (end.line - 1 !== next) return false;
+	const reached = lines[next].text.slice(0, end.column - 1);
+	return reached.includes("`") || reached.includes("~");
+}
+/**
+* The lines without the lines at their end that are blank as Markdown reads
+* them: empty, or of only spaces and tabs.
+*/
+function withoutTrailingBlankLines(values) {
+	let count = values.length;
+	while (count > 0 && isBlank(values[count - 1])) count--;
+	return values.slice(0, count);
+}
+/** Whether a line is empty or holds only spaces and tabs. */
+function isBlank(text) {
+	for (const character of text) if (character !== " " && character !== "	") return false;
+	return true;
+}
+/**
+* What starts a new content line of a block: what stands before the opening
+* fence on its line, with the characters of a list marker turned into spaces,
+* so that the line takes the indentation and the `>` of the block's container
+* and the indentation of the fence (README, Code blocks in detail). Tabs stay as
+* written, and with them the columns. A prefix that ends with `>` takes a
+* space: a block quote reads one space after its `>` as part of its marker, so
+* without it a line of the diagram that starts with a space would lose it.
+*/
+function newLinePrefixOf(beforeFence) {
+	let prefix = "";
+	for (const character of beforeFence) prefix += character === " " || character === "	" || character === ">" ? character : " ";
+	return prefix.endsWith(">") ? `${prefix} ` : prefix;
+}
+/** The number of characters at the end of `a` that `b` ends with too. */
+function commonSuffixLength(a, b) {
+	let length = 0;
+	while (length < a.length && length < b.length && a[a.length - 1 - length] === b[b.length - 1 - length]) length++;
+	return length;
+}
+/** Joins lines with their own line endings. */
+function joinLines(lines) {
+	let text = "";
+	for (const line of lines) text += line.text + line.ending;
+	return text;
+}
+//#endregion
+//#region src/format-file.ts
+/**
+* The files that the tool formats, by the ending of their names (README,
+* Patterns).
+*/
+const fileKinds = /* @__PURE__ */ new Map([
+	[".md", "markdown"],
+	[".markdown", "markdown"],
+	[".mmd", "diagram"],
+	[".mermaid", "diagram"]
+]);
+/** The endings of the names of the files that the tool formats, for messages. */
+const fileEndings = [...fileKinds.keys()];
+/** How the tool reads a file, or `undefined` for a file it does not format. */
+function kindOf(file) {
+	return fileKinds.get(path.extname(file));
+}
+/**
+* Formats a file of the given kind. The indentation comes from the Prettier
+* configuration of the file, found as Prettier's CLI finds it,
+* `.editorconfig` included (README, Indentation). The diagnostics give their
+* positions in the text that `positionsIn` names.
+*/
+async function formatFile(text, file, kind, positionsIn) {
+	const config = await resolveConfig(file, { editorconfig: true });
+	const indentation = {
+		tabWidth: config?.tabWidth,
+		useTabs: config?.useTabs
+	};
+	return kind === "diagram" ? formatDiagramFile(text, indentation) : formatMarkdown(text, indentation, positionsIn);
+}
+/**
+* Formats a `.mmd` or `.mermaid` file as a whole. Prettier keeps a byte order
+* mark apart from the text it formats and puts it back; so does this. A
+* rejected diagram leaves the text as it was read, so its position is the same
+* in the text as read and after formatting.
+*/
+async function formatDiagramFile(text, indentation) {
+	const { byteOrderMark, normalized } = readText(text);
+	const result = await formatDiagram(normalized, indentation, lineEndingOf(text));
+	if (result.kind === "rejected") return {
+		text,
+		diagnostics: [{
+			severity: "error",
+			message: result.message,
+			position: positionIn(normalized, result.offset)
+		}]
+	};
+	return {
+		text: byteOrderMark + result.text,
+		diagnostics: []
+	};
+}
+//#endregion
+//#region src/patterns.ts
+/**
+* The directories whose files are skipped, those that Prettier's CLI skips
+* (README, Excluding files).
+*/
+const skippedDirectories = [
+	"node_modules",
+	".git",
+	".hg",
+	".jj",
+	".sl",
+	".svn"
+];
+/** The globs of the files under the skipped directories. */
+const skippedDirectoryGlobs = skippedDirectories.map((directory) => `**/${directory}/**`);
+/**
+* Selects the files that the patterns name, of those the tool formats, as
+* Prettier's CLI reads the patterns (README, Patterns). A pattern that names a
+* path in a skipped directory, a file, a directory, or a glob, is skipped. A
+* pattern is then first the path of a file or of a directory. Otherwise, a
+* pattern that starts with `!` excludes the files that the glob after it
+* matches from what every other pattern selects, and any other pattern is a
+* glob.
+*/
+async function selectFiles(patterns, cwd) {
+	const selecting = [];
+	const excluding = [];
+	const skipped = [];
+	for (const pattern of patterns) {
+		const target = path.resolve(cwd, pattern);
+		if (passesSkippedDirectory(target, cwd)) {
+			skipped.push(pattern);
+			continue;
+		}
+		const stats = await stat(target).catch(() => void 0);
+		if (stats?.isFile()) selecting.push({
+			kind: "file",
+			text: pattern,
+			path: target
+		});
+		else if (stats?.isDirectory()) selecting.push({
+			kind: "directory",
+			text: pattern,
+			path: target
+		});
+		else if (pattern.startsWith("!")) excluding.push(globOf(pattern.slice(1)));
+		else selecting.push({
+			kind: "glob",
+			text: pattern
+		});
+	}
+	const files = /* @__PURE__ */ new Map();
+	const unmatched = [];
+	const excluded = [];
+	for (const pattern of selecting) {
+		if (pattern.kind === "file" && await isExcluded(pattern.path, cwd, excluding)) {
+			excluded.push(pattern.text);
+			continue;
+		}
+		const selected = [];
+		for (const file of (await filesOf(pattern, cwd, excluding)).sort()) {
+			const kind = kindOf(file);
+			if (kind !== void 0) selected.push({
+				path: file,
+				kind
+			});
+		}
+		if (selected.length === 0) unmatched.push(pattern.text);
+		for (const file of selected) if (!files.has(file.path)) files.set(file.path, file);
+	}
+	return {
+		files: [...files.values()],
+		noSelectingPattern: selecting.length === 0,
+		skipped,
+		unmatched,
+		excluded
+	};
+}
+/**
+* A pattern as a glob. On Windows, Prettier's CLI reads a `\` of a glob as
+* `/`, the separator of globs; so does this (README, Patterns).
+*/
+function globOf(pattern) {
+	return process.platform === "win32" ? pattern.replaceAll("\\", "/") : pattern;
+}
+/**
+* Whether the globs of the excluding patterns match a file, given by its
+* absolute path. As in Prettier's CLI, they are matched against its path from
+* `cwd`.
+*/
+async function isExcluded(file, cwd, excluding) {
+	return (await globFiles(convertPathToPattern(path.relative(cwd, file)), cwd, excluding)).length === 0;
+}
+/**
+* The files that a pattern names, as absolute paths, apart from those that the
+* globs of the excluding patterns match. The path of a file names the file
+* wherever it is; a directory or a glob names no file under a skipped
+* directory, as Prettier's CLI does not look into one.
+*/
+async function filesOf(pattern, cwd, excluding) {
+	if (pattern.kind === "file") return [pattern.path];
+	const ignore = [...skippedDirectoryGlobs, ...excluding];
+	return (pattern.kind === "directory" ? await globFiles(`${convertPathToPattern(path.relative(cwd, pattern.path) || ".")}/**/*`, cwd, ignore) : await globFiles(globOf(pattern.text), cwd, ignore)).filter((file) => !isUnderSkippedDirectory(file, cwd));
+}
+/**
+* The files that a glob matches from `cwd`, as absolute paths, apart from
+* those that the globs of `ignore` match. Like Prettier's CLI, it matches names
+* that start with a dot and follows no symbolic link.
+*/
+async function globFiles(pattern, cwd, ignore) {
+	return (await glob(pattern, {
+		cwd,
+		absolute: true,
+		dot: true,
+		expandDirectories: false,
+		followSymbolicLinks: false,
+		ignore: [...ignore]
+	})).map((file) => path.resolve(file));
+}
+/**
+* Whether a path, taken from `cwd`, is one of the skipped directories or passes
+* through one, as Prettier's CLI decides it for a pattern.
+*/
+function passesSkippedDirectory(target, cwd) {
+	return path.relative(cwd, target).split(path.sep).some((name) => skippedDirectories.includes(name));
+}
+/** Whether a file is under one of the skipped directories of `cwd`. */
+function isUnderSkippedDirectory(file, cwd) {
+	return passesSkippedDirectory(path.dirname(file), cwd);
+}
+/**
+* Whether a file is skipped: it is under one of the skipped directories, or
+* the `.gitignore` of the current directory lists it (README, Excluding files).
+*
+* Unlike Prettier's CLI, the tool does not read `.prettierignore`. It is used
+* where Prettier does not format the Markdown, and the `.prettierignore` there
+* often lists the Markdown files: reading it would leave their diagrams
+* unformatted without a word. If users ask for a way to keep files from this
+* tool alone, other than a pattern that starts with `!`, read a file of its
+* own, such as `.mmdfmtignore`, not `.prettierignore`.
+*/
+async function isSkipped(file, cwd) {
+	if (isUnderSkippedDirectory(file, cwd)) return true;
+	const { ignored } = await getFileInfo(file, {
+		ignorePath: path.join(cwd, ".gitignore"),
+		resolveConfig: false
+	});
+	return ignored;
+}
+//#endregion
+//#region src/main.ts
+/** The exit codes (README, Errors and exit codes). */
+const exitCodes = {
+	ok: 0,
+	changed: 1,
+	error: 2
+};
+/** The examples in the usage, one on a line (README, Usage). */
+const examples = `mmdfmt --write "**/*.{md,mmd,mermaid}"
+mmdfmt --check "**/*.{md,mmd,mermaid}"
+mmdfmt --stdin-filepath diagram.mmd < diagram.mmd`;
+/** The endings of the files that the tool formats, as a message names them. */
+const endingsInWords = `${fileEndings.slice(0, -1).join(", ")}, or ${fileEndings.at(-1)}`;
+/** Runs the tool with its arguments, and returns the exit code (README, Usage). */
+async function main(args, io) {
+	let code = exitCodes.ok;
+	const command = define({
+		toKebab: true,
+		args: {
+			write: {
+				type: "boolean",
+				description: "Rewrite the files that change, and list them",
+				conflicts: ["check", "stdinFilepath"]
+			},
+			check: {
+				type: "boolean",
+				description: "List the files that --write would change",
+				conflicts: ["write", "stdinFilepath"]
+			},
+			stdinFilepath: {
+				type: "string",
+				description: "Format standard input as the file at this path, and write the result to standard output",
+				conflicts: ["write", "check"]
+			},
+			patterns: {
+				type: "positional",
+				multiple: true,
+				required: false,
+				description: "The files, directories, or globs of the files to format"
+			}
+		},
+		examples,
+		/** Runs the mode that the arguments select, and keeps its exit code. */
+		async run(ctx) {
+			if (args.length === 0) {
+				const usage = await ctx.env.renderUsage?.(ctx);
+				io.stderr(usage ?? "");
+				code = exitCodes.error;
+				return;
+			}
+			const { write, check, stdinFilepath } = ctx.values;
+			const patterns = [...ctx.values.patterns ?? [], ...ctx.rest];
+			if (stdinFilepath !== void 0) code = patterns.length > 0 ? argumentError(io, ["--stdin-filepath takes no patterns"]) : await formatStandardInput(stdinFilepath, io);
+			else if (ctx.explicit.stdinFilepath) code = argumentError(io, ["--stdin-filepath needs a path"]);
+			else if (patterns.length === 0) code = argumentError(io, ["no patterns of the files to format"]);
+			else if (!write && !check) code = argumentError(io, ["give --write or --check with the patterns"]);
+			else code = await formatFiles(patterns, write ? "write" : "check", io);
+		}
+	});
+	try {
+		const printed = await cli([...args], command, {
+			name: "mmdfmt",
+			version,
+			description,
+			strict: true,
+			usageSilent: true
+		});
+		if (printed !== void 0) io.stdout(printed.endsWith("\n") ? printed : `${printed}\n`);
+	} catch (error) {
+		if (error instanceof AggregateError && error.errors.every(isArgsValidationError)) return argumentError(io, error.errors.map(messageOf));
+		throw error;
+	}
+	return code;
+}
+/**
+* Formats the files that the patterns select. With `write`, a file that
+* changes is rewritten; with `check`, it is only listed.
+*/
+async function formatFiles(patterns, mode, io) {
+	const { files, noSelectingPattern, skipped, unmatched, excluded } = await selectFiles(patterns, io.cwd);
+	if (noSelectingPattern) return argumentError(io, [skipped.length > 0 ? "no patterns of the files to format; a pattern in node_modules or a directory of version control is skipped" : "no patterns of the files to format; a pattern that starts with ! only excludes files"]);
+	let failed = unmatched.length > 0 || excluded.length > 0;
+	let changed = false;
+	for (const pattern of unmatched) io.stderr(`mmdfmt: error: no file ending in ${endingsInWords} matches ${JSON.stringify(pattern)}\n`);
+	for (const pattern of excluded) io.stderr(`mmdfmt: error: a pattern that starts with ! excludes the file ${JSON.stringify(pattern)}\n`);
+	for (const file of files) {
+		const name = path.relative(io.cwd, file.path);
+		try {
+			if (await isSkipped(file.path, io.cwd)) continue;
+			const text = await readFile(file.path, "utf8");
+			const result = await formatFile(text, file.path, file.kind, mode === "write" ? "output" : "input");
+			report(io, name, result.diagnostics);
+			if (result.diagnostics.some(isError)) {
+				failed = true;
+				continue;
+			}
+			if (result.text === text) continue;
+			if (mode === "write") await writeFile(file.path, result.text);
+			changed = true;
+			io.stdout(`${name}\n`);
+		} catch (error) {
+			io.stderr(`${name}: error: ${messageOf(error)}\n`);
+			failed = true;
+		}
+	}
+	if (failed) return exitCodes.error;
+	return mode === "check" && changed ? exitCodes.changed : exitCodes.ok;
+}
+/**
+* Formats standard input as the file at `filepath`, and writes the result to
+* standard output. A skipped path gets its input back unchanged, and a
+* rejected diagram file gets nothing.
+*/
+async function formatStandardInput(filepath, io) {
+	const file = path.resolve(io.cwd, filepath);
+	const kind = kindOf(file);
+	if (kind === void 0) {
+		io.stderr(`mmdfmt: error: the path of --stdin-filepath does not end in ${endingsInWords}: ${JSON.stringify(filepath)}\n`);
+		return exitCodes.error;
+	}
+	const text = await io.readStdin();
+	try {
+		if (await isSkipped(file, io.cwd)) {
+			io.stdout(text);
+			return exitCodes.ok;
+		}
+		const result = await formatFile(text, file, kind, "output");
+		report(io, filepath, result.diagnostics);
+		if (result.diagnostics.some(isError)) return exitCodes.error;
+		io.stdout(result.text);
+		return exitCodes.ok;
+	} catch (error) {
+		io.stderr(`${filepath}: error: ${messageOf(error)}\n`);
+		return exitCodes.error;
+	}
+}
+/** Writes the diagnostics of a file to standard error. */
+function report(io, name, diagnostics) {
+	for (const { severity, message, position } of diagnostics) io.stderr(`${name}:${position.line}:${position.column}: ${severity}: ${message}\n`);
+}
+/** Whether a diagnostic makes the run fail. */
+function isError(diagnostic) {
+	return diagnostic.severity === "error";
+}
+/** Reports wrong uses of the arguments, and returns 2 (README, Usage). */
+function argumentError(io, messages) {
+	for (const message of messages) io.stderr(`mmdfmt: error: ${message}\n`);
+	return exitCodes.error;
+}
+/** The message of a thrown value. */
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/cli.ts
+/** Reads standard input to its end, as UTF-8. */
+async function readStdin() {
+	process.stdin.setEncoding("utf8");
+	let text = "";
+	for await (const chunk of process.stdin) text += chunk;
+	return text;
+}
+process.stdout.on("error", ignoreBrokenPipe);
+process.exitCode = await main(process.argv.slice(2), {
+	cwd: process.cwd(),
+	readStdin,
+	stdout: (text) => {
+		process.stdout.write(text);
+	},
+	stderr: (text) => {
+		process.stderr.write(text);
+	}
+});
+//#endregion
+export {};