mmdfmt 0.1.0 → 0.2.0

package/lib/cli.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { readFile, stat, writeFile } from "node:fs/promises";
+import { a as kindOf, i as formatFile, n as endingsInWords } from "./format-file-DSbEElSV.mjs";
 import path from "node:path";
+import { getFileInfo } from "prettier";
+import { text } from "node:stream/consumers";
+import { readFile, stat, writeFile } from "node:fs/promises";
+import { styleText } from "node:util";
 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
 /**
@@ -21,451 +21,8 @@ function ignoreBrokenPipe(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: []
-	};
-}
+var version = "0.2.0";
+var description = "Formatter for Mermaid diagrams in .mmd files and in Markdown code blocks, which changes nothing else, as a command and as a function";
 //#endregion
 //#region src/patterns.ts
 /**
@@ -628,8 +185,6 @@ const exitCodes = {
 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;
@@ -638,18 +193,27 @@ async function main(args, io) {
 		args: {
 			write: {
 				type: "boolean",
-				description: "Rewrite the files that change, and list them",
-				conflicts: ["check", "stdinFilepath"]
+				short: "w",
+				negatable: true,
+				description: "Rewrite the files that change, and list each file with its time"
 			},
 			check: {
 				type: "boolean",
+				short: "c",
+				negatable: true,
+				description: "Check whether the files are formatted, and print a summary and the files that are not",
+				conflicts: ["listDifferent"]
+			},
+			listDifferent: {
+				type: "boolean",
+				short: "l",
+				negatable: true,
 				description: "List the files that --write would change",
-				conflicts: ["write", "stdinFilepath"]
+				conflicts: ["check"]
 			},
 			stdinFilepath: {
 				type: "string",
-				description: "Format standard input as the file at this path, and write the result to standard output",
-				conflicts: ["write", "check"]
+				description: "Format standard input as the file at this path, and write the result to standard output"
 			},
 			patterns: {
 				type: "positional",
@@ -667,13 +231,20 @@ async function main(args, io) {
 				code = exitCodes.error;
 				return;
 			}
-			const { write, check, stdinFilepath } = ctx.values;
+			const { write, check, listDifferent, 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);
+			if (stdinFilepath !== void 0) code = patterns.length > 0 ? argumentError(io, ["--stdin-filepath takes no patterns"]) : await formatStandardInput(stdinFilepath, {
+				write: Boolean(write),
+				listsDifference: Boolean(check) || Boolean(listDifferent)
+			}, 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);
+			else if (!write && !check && !listDifferent) code = argumentError(io, ["give --write, --check, or --list-different with the patterns"]);
+			else code = await formatFiles(patterns, {
+				write: Boolean(write),
+				check: Boolean(check),
+				listDifferent: Boolean(listDifferent)
+			}, io);
 		}
 	});
 	try {
@@ -692,45 +263,85 @@ async function main(args, io) {
 	return code;
 }
 /**
-* Formats the files that the patterns select. With `write`, a file that
-* changes is rewritten; with `check`, it is only listed.
+* Formats the files that the patterns select, following Prettier's counts
+* and reports for `write`, `check`, and `listDifferent`.
 */
 async function formatFiles(patterns, mode, io) {
+	if (mode.check) io.stdout("Checking formatting...\n");
 	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;
+	let failed = noSelectingPattern || unmatched.length > 0 || excluded.length > 0;
+	let numberOfUnformattedFilesFound = 0;
+	let numberOfFilesWithError = 0;
+	if (noSelectingPattern) 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"]);
 	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);
+		const name = displayName(file.path, io.cwd);
+		let text, result;
 		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");
+			text = await readFile(file.path, "utf8");
+		} catch (error) {
+			io.stderr(`${name}: error: ${messageOf(error)}\n`);
+			failed = true;
+			continue;
+		}
+		const start = performance.now();
+		try {
+			result = await formatFile(text, file.path, file.kind, mode.write ? "output" : "input");
 			report(io, name, result.diagnostics);
 			if (result.diagnostics.some(isError)) {
 				failed = true;
+				numberOfFilesWithError += 1;
 				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;
+			numberOfFilesWithError += 1;
+			continue;
+		}
+		const listsTimes = mode.write && !mode.check && !mode.listDifferent;
+		const time = `${Math.round(performance.now() - start)}ms`;
+		if (result.text === text) {
+			if (listsTimes) io.stdout(`${style(io.stdoutStream, "gray", name)} ${time} (unchanged)\n`);
+			continue;
+		}
+		if (mode.write) {
+			if (listsTimes) io.stdout(`${name} ${time}\n`);
+			try {
+				await writeFile(file.path, result.text);
+			} catch (error) {
+				io.stderr(`${name}: error: ${messageOf(error)}\n`);
+				failed = true;
+			}
+		}
+		if (mode.check) warn(io, name);
+		else if (mode.listDifferent) io.stdout(`${name}\n`);
+		numberOfUnformattedFilesFound += 1;
+	}
+	if (mode.check) {
+		if (numberOfFilesWithError > 0) {
+			const filesDescription = numberOfFilesWithError === 1 ? "the above file" : `${numberOfFilesWithError} files`;
+			io.stdout(`Error occurred when checking code style in ${filesDescription}.\n`);
+		} else if (numberOfUnformattedFilesFound === 0) io.stdout("All diagrams in the matched files use Prettier code style!\n");
+		else {
+			const filesDescription = numberOfUnformattedFilesFound === 1 ? "the above file" : `${numberOfUnformattedFilesFound} files`;
+			warn(io, mode.write ? `Code style issues fixed in ${filesDescription}.` : `Code style issues found in ${filesDescription}. Run mmdfmt with --write to fix.`);
 		}
 	}
 	if (failed) return exitCodes.error;
-	return mode === "check" && changed ? exitCodes.changed : exitCodes.ok;
+	return numberOfUnformattedFilesFound > 0 && !mode.write ? 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.
+* rejected diagram file gets nothing. With `listsDifference` (`--check` or
+* `--list-different`), the result is not written: `(stdin)` is listed when it
+* differs from the input, unless `write` is given too, as Prettier lists it.
+* `write` alone changes nothing: no file is written.
 */
-async function formatStandardInput(filepath, io) {
+async function formatStandardInput(filepath, mode, io) {
 	const file = path.resolve(io.cwd, filepath);
 	const kind = kindOf(file);
 	if (kind === void 0) {
@@ -743,16 +354,45 @@ async function formatStandardInput(filepath, io) {
 			io.stdout(text);
 			return exitCodes.ok;
 		}
-		const result = await formatFile(text, file, kind, "output");
+		const result = await formatFile(text, file, kind, mode.listsDifference ? "input" : "output");
 		report(io, filepath, result.diagnostics);
 		if (result.diagnostics.some(isError)) return exitCodes.error;
-		io.stdout(result.text);
-		return exitCodes.ok;
+		if (!mode.listsDifference) {
+			io.stdout(result.text);
+			return exitCodes.ok;
+		}
+		if (result.text === text || mode.write) return exitCodes.ok;
+		io.stdout("(stdin)\n");
+		return exitCodes.changed;
 	} catch (error) {
 		io.stderr(`${filepath}: error: ${messageOf(error)}\n`);
 		return exitCodes.error;
 	}
 }
+/**
+* Writes a warning of `--check` to standard error, as Prettier's logger
+* writes one: `[warn] ` before the text, with the word `warn` in yellow where
+* the stream shows colors.
+*/
+function warn(io, text) {
+	io.stderr(`[${style(io.stderrStream, "yellow", "warn")}] ${text}\n`);
+}
+/**
+* `text` in `color` where Node's `util.styleText` colors text for `stream`,
+* and as it is without a stream.
+*/
+function style(stream, color, text) {
+	return stream === void 0 ? text : styleText(color, text, { stream });
+}
+/**
+* The name of a file in what the tool prints: its path relative to `cwd`, with
+* `/` between its parts on every system, as Prettier's CLI writes the name of a
+* file (README, Usage). `pathOf` is `node:path` of the system the tool runs on;
+* a test gives `path.win32` or `path.posix`.
+*/
+function displayName(file, cwd, pathOf = path) {
+	return pathOf.relative(cwd, file).replaceAll(pathOf.sep, "/");
+}
 /** 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`);
@@ -774,21 +414,20 @@ function messageOf(error) {
 //#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;
+	return text(process.stdin.setEncoding("utf8"));
 }
 process.stdout.on("error", ignoreBrokenPipe);
 process.exitCode = await main(process.argv.slice(2), {
 	cwd: process.cwd(),
 	readStdin,
-	stdout: (text) => {
-		process.stdout.write(text);
+	stdout: (output) => {
+		process.stdout.write(output);
 	},
-	stderr: (text) => {
-		process.stderr.write(text);
-	}
+	stderr: (output) => {
+		process.stderr.write(output);
+	},
+	stdoutStream: process.stdout,
+	stderrStream: process.stderr
 });
 //#endregion
 export {};