mmdfmt 0.1.0 → 0.2.0

package/lib/format-file-DSbEElSV.mjs

@@ -0,0 +1,545 @@
+import path from "node:path";
+import { clearConfigCache, format, getSupportInfo, resolveConfig, util } from "prettier";
+import plugin, { languages } from "prettier-plugin-mmd";
+import { parsers } from "prettier/plugins/markdown";
+//#region src/diagram.ts
+/** The default of a Prettier option that is a number, as Prettier states it. */
+async function defaultNumberOption(name) {
+	const { options } = await getSupportInfo();
+	const option = options.find((candidate) => candidate.name === name);
+	if (typeof option?.default !== "number") throw new Error(`Prettier states no numeric default for ${name}`);
+	return option.default;
+}
+/**
+* The line width left for the lines of a diagram that the tool writes after
+* `prefix`, which stands before each of them in a Markdown code block (README,
+* Code blocks in detail). Prettier formats a diagram in a list or a block quote
+* inside the container, so the width of what stands before the diagram is no
+* longer left; here the diagram is formatted alone and the prefix is put in
+* front of its lines. The width of the prefix is counted as Prettier counts the
+* indentation that stands before a range it formats (`util.getAlignmentSize`),
+* a tab reaching the next multiple of `tabWidth`; where `tabWidth` is 0, which
+* `util.getAlignmentSize` turns into NaN for a tab, a tab has no width. The
+* width is at least 1. Prettier refuses a `printWidth` or a `tabWidth` that is
+* not an integer; then `printWidth` is given as it is, so that Prettier
+* refuses the value that was written, as it does for a diagram with no prefix.
+*/
+async function printWidthAfter(prefix, options) {
+	if (prefix === "") return options.printWidth;
+	const tabWidth = options.tabWidth ?? await defaultNumberOption("tabWidth");
+	const printWidth = options.printWidth ?? await defaultNumberOption("printWidth");
+	if (!Number.isInteger(tabWidth) || !Number.isInteger(printWidth)) return options.printWidth;
+	const used = tabWidth === 0 ? prefix.replaceAll("	", "").length : util.getAlignmentSize(prefix, tabWidth);
+	return Math.max(1, printWidth - used);
+}
+/** Prettier's name of each line ending. */
+const endOfLineOptions = {
+	"\n": "lf",
+	"\r\n": "crlf",
+	"\r": "cr"
+};
+/**
+* Formats the text of a diagram as {@link formatDiagramText} does, and gives
+* a text that the plugin rejects as the message and the offset of its syntax
+* error.
+*/
+async function formatDiagram(text, options, lineEnding) {
+	try {
+		return {
+			kind: "formatted",
+			text: await formatDiagramText(text, options, lineEnding)
+		};
+	} catch (error) {
+		return {
+			kind: "rejected",
+			...rejectionOf(error)
+		};
+	}
+}
+/**
+* Formats the text of a diagram with Prettier and prettier-plugin-mmd, as
+* Prettier formats a `.mmd` file with the plugin, and throws what Prettier
+* throws for a text that the plugin rejects. `options` are the options that
+* the tool reads of the Prettier configuration of the file (README,
+* Configuration), given to Prettier together with the three that the tool sets
+* itself: the parser, the plugins, and the line endings. 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`.
+*/
+async function formatDiagramText(text, options, lineEnding) {
+	return format(text, {
+		...options,
+		parser: "mermaid",
+		plugins: [plugin],
+		endOfLine: endOfLineOptions[lineEnding]
+	});
+}
+/**
+* The message and the offset of the syntax error of a text that the plugin
+* rejected, from the error that formatting it threw. That error keeps the
+* parser's error as its `cause`, which gives the message without Prettier's
+* code frame and the offset in the text that was formatted. Any other error is
+* thrown again.
+*/
+function rejectionOf(error) {
+	const cause = error instanceof Error ? error.cause : void 0;
+	if (!isParseError(cause)) throw error;
+	return {
+		message: cause.message,
+		offset: cause.range[0]
+	};
+}
+/**
+* Whether a value is the parser's syntax error. It is checked by name, as the
+* plugin checks it, so that the check also holds when two copies of the parser
+* are installed.
+*/
+function isParseError(error) {
+	return error instanceof Error && error.name === "ParseError";
+}
+//#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. Prettier compares them case-sensitively. It
+* also matches the language's name in lower case and its extensions without the
+* dot, which for this plugin are among its aliases;
+* `tests/plugin-blocks.test.ts` compares the blocks with those Prettier formats.
+*/
+const diagramLanguages = new Set(languages.flatMap((language) => language.aliases ?? []));
+/**
+* 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, options, 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, options, 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, options, 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 fenceLine = lines[start - 1];
+	const prefix = newLinePrefixOf(fenceLine.text.slice(0, block.position.start.column - 1));
+	const result = await formatDiagram(text, {
+		...options,
+		printWidth: await printWidthAfter(prefix, options)
+	}, "\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 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) {
+	return util.skipSpaces(text, 0) === text.length;
+}
+/**
+* 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/options.ts
+/**
+* The options that the tool reads of a configuration that Prettier resolved for
+* a file, in `config`; the others, such as the range, the pragmas, and the
+* options of other languages, are not read. An option that the configuration
+* lacks is not in the result, as in what Prettier resolves, so that a caller
+* can spread the result over its own defaults.
+*/
+function readOptions(config) {
+	const named = {
+		printWidth: config.printWidth,
+		tabWidth: config.tabWidth,
+		useTabs: config.useTabs,
+		embeddedLanguageFormatting: config.embeddedLanguageFormatting,
+		singleQuote: config.singleQuote,
+		bracketSpacing: config.bracketSpacing,
+		proseWrap: config.proseWrap,
+		trailingComma: config.trailingComma
+	};
+	return Object.fromEntries(Object.entries(named).filter(([, value]) => value !== void 0));
+}
+//#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. */
+const fileEndings = [...fileKinds.keys()];
+/** The endings of the files that the tool formats, as a message names them. */
+const endingsInWords = [...fileEndings.slice(0, -1), `or ${fileEndings.at(-1)}`].join(", ");
+/** How the tool reads a file, or `undefined` for a file it does not format. */
+function kindOf(file) {
+	return fileKinds.get(path.extname(file));
+}
+/**
+* Resolves the configuration of a path or a file URL as the command does,
+* `.editorconfig` included, and returns the options that the command reads
+* from it (README, Configuration), or `null` when no configuration applies
+* (README, From a script).
+*/
+async function resolveConfig$1(fileUrlOrPath) {
+	const config = await resolveConfig(fileUrlOrPath, { editorconfig: true });
+	return config === null ? null : readOptions(config);
+}
+/**
+* Forgets the configuration files that `resolveConfig` has read, so that the
+* next call reads them again: Prettier keeps them for the life of the process
+* (README, From a script).
+*/
+async function clearConfigCache$1() {
+	await clearConfigCache();
+}
+/**
+* Formats a file of the given kind, with the options that `resolveConfig`
+* returns for it. The diagnostics give their positions in the text that
+* `positionsIn` names.
+*/
+async function formatFile(text, file, kind, positionsIn) {
+	const options = await resolveConfig$1(file) ?? {};
+	return kind === "diagram" ? formatDiagramFile(text, options) : formatMarkdown(text, options, 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. The lines
+* end as the first line of the source does. A failure throws Prettier's error.
+*/
+async function formatDiagramSource(text, options) {
+	const { byteOrderMark, normalized } = readText(text);
+	return byteOrderMark + await formatDiagramText(normalized, options, lineEndingOf(text));
+}
+/**
+* Formats a diagram file for the command. A rejected diagram leaves the text
+* as it was read, so its position is the same before and after formatting.
+*/
+async function formatDiagramFile(text, options) {
+	try {
+		return {
+			text: await formatDiagramSource(text, options),
+			diagnostics: []
+		};
+	} catch (error) {
+		const { normalized } = readText(text);
+		const rejection = rejectionOf(error);
+		return {
+			text,
+			diagnostics: [{
+				severity: "error",
+				message: rejection.message,
+				position: positionIn(normalized, rejection.offset)
+			}]
+		};
+	}
+}
+//#endregion
+export { kindOf as a, formatMarkdown as c, formatFile as i, endingsInWords as n, resolveConfig$1 as o, formatDiagramSource as r, readOptions as s, clearConfigCache$1 as t };

package/lib/index.d.mts

@@ -0,0 +1,72 @@
+import "prettier";
+//#region src/options.d.ts
+/**
+ * The Prettier options that the tool reads, and the only ones that it gives to
+ * Prettier from a configuration (README, Configuration). An option that
+ * Prettier adds is not read until it is written here. The types are the tool's
+ * own: where the types of Prettier gain a value for one of these options, as
+ * they may in a later version, the type checker fails in `readOptions` until
+ * the type here is widened on purpose.
+ */
+interface ReadOptions {
+  /**
+   * The line width: whether a data block `@{ … }` on one line is printed on
+   * several lines, whether the colons of the tasks of a Gantt section are lined
+   * up, and where Prettier breaks the YAML of the frontmatter.
+   */
+  readonly printWidth?: number;
+  /** The width of one level of indentation, and of a tab. */
+  readonly tabWidth?: number;
+  /** Whether a level of indentation is a tab. */
+  readonly useTabs?: boolean;
+  /** `"off"` leaves the YAML of the frontmatter as written. */
+  readonly embeddedLanguageFormatting?: "auto" | "off";
+  /** The quotes of the strings in the YAML of the frontmatter. */
+  readonly singleQuote?: boolean;
+  /** The spaces inside the braces of a flow mapping in the frontmatter. */
+  readonly bracketSpacing?: boolean;
+  /** Whether Prettier wraps a long text in the YAML of the frontmatter. */
+  readonly proseWrap?: "always" | "never" | "preserve";
+  /** The comma after the last entry of a flow collection that breaks. */
+  readonly trailingComma?: "all" | "es5" | "none";
+}
+//#endregion
+//#region src/format-file.d.ts
+/**
+ * Resolves the configuration of a path or a file URL as the command does,
+ * `.editorconfig` included, and returns the options that the command reads
+ * from it (README, Configuration), or `null` when no configuration applies
+ * (README, From a script).
+ */
+export declare function resolveConfig(fileUrlOrPath: string | URL): Promise<ReadOptions | null>;
+/**
+ * Forgets the configuration files that `resolveConfig` has read, so that the
+ * next call reads them again: Prettier keeps them for the life of the process
+ * (README, From a script).
+ */
+export declare function clearConfigCache(): Promise<void>;
+//#endregion
+//#region src/index.d.ts
+/**
+ * The options of `format`: the options that `resolveConfig` returns, and the
+ * path of the file, whose ending says whether the text is a diagram or
+ * Markdown.
+ */
+export interface FormatOptions extends ReadOptions {
+  readonly filepath: string;
+}
+/**
+ * Formats a text as Prettier's `format` does, except that in Markdown only the
+ * Mermaid code blocks are formatted and the rest stays as written. Like
+ * Prettier's `format`, it reads no file and no configuration: the caller
+ * passes what `resolveConfig` returns for `filepath`, with `printWidth` in
+ * Markdown the width of the lines of the file (README, Code blocks in detail).
+ * The line endings and a byte order mark stay as they are in the text. A `.mmd`
+ * or `.mermaid` diagram that mermaid.js rejects throws the `SyntaxError` that
+ * Prettier throws for it with prettier-plugin-mmd; in Markdown, a rejected
+ * diagram stays as written, as Prettier leaves an embedded code block that it
+ * cannot format. No path is skipped (README, From a script).
+ */
+export declare function format(source: string, options: FormatOptions): Promise<string>;
+//#endregion
+export type { ReadOptions };

package/lib/index.mjs

@@ -0,0 +1,22 @@
+import { a as kindOf, c as formatMarkdown, n as endingsInWords, o as resolveConfig, r as formatDiagramSource, s as readOptions, t as clearConfigCache } from "./format-file-DSbEElSV.mjs";
+//#region src/index.ts
+/**
+* Formats a text as Prettier's `format` does, except that in Markdown only the
+* Mermaid code blocks are formatted and the rest stays as written. Like
+* Prettier's `format`, it reads no file and no configuration: the caller
+* passes what `resolveConfig` returns for `filepath`, with `printWidth` in
+* Markdown the width of the lines of the file (README, Code blocks in detail).
+* The line endings and a byte order mark stay as they are in the text. A `.mmd`
+* or `.mermaid` diagram that mermaid.js rejects throws the `SyntaxError` that
+* Prettier throws for it with prettier-plugin-mmd; in Markdown, a rejected
+* diagram stays as written, as Prettier leaves an embedded code block that it
+* cannot format. No path is skipped (README, From a script).
+*/
+async function format(source, options) {
+	const kind = kindOf(options.filepath);
+	if (kind === void 0) throw new Error(`the path does not end in ${endingsInWords}: ${JSON.stringify(options.filepath)}`);
+	const read = readOptions({ ...options });
+	return kind === "diagram" ? formatDiagramSource(source, read) : (await formatMarkdown(source, read, "output")).text;
+}
+//#endregion
+export { clearConfigCache, format, resolveConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mmdfmt",
-  "version": "0.1.0",
-  "description": "Command-line formatter for Mermaid diagrams in .mmd files and in Markdown code blocks, which changes nothing else",
+  "version": "0.2.0",
+  "description": "Formatter for Mermaid diagrams in .mmd files and in Markdown code blocks, which changes nothing else, as a command and as a function",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,6 +17,10 @@
     "mmdfmt": "./lib/cli.mjs"
   },
   "exports": {
+    ".": {
+      "types": "./lib/index.d.mts",
+      "default": "./lib/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -33,10 +37,9 @@
     "cli"
   ],
   "dependencies": {
-    "@mmd-toolkit/parser": "^0.3.1",
     "gunshi": "^0.37.3",
     "prettier": "^3.9.0",
-    "prettier-plugin-mmd": "^0.6.0",
+    "prettier-plugin-mmd": "^0.7.0",
     "tinyglobby": "^0.2.17"
   },
   "publishConfig": {