prettier-plugin-razor2 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert Macfie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+# prettier-plugin-razor2
+
+## Table of Contents
+
+- [Getting Started](#getting-started)
+- [Known limitations](#known-limitations)
+- [Composing with other plugins](#composing-with-other-plugins)
+- [Configuration](#configuration)
+- [Development](#development)
+
+## Description
+
+An opinionated formatter plugin for [Prettier](https://prettier.io) that adds
+support for Razor files — `.razor` (Blazor components) and `.cshtml` (MVC views
+and Razor Pages).
+
+It formats the HTML in a Razor file by delegating to Prettier's own HTML
+formatter, and the C# in `@code`/`@functions`/`@{ }` blocks by delegating to
+[CSharpier](https://csharpier.com). Control-flow blocks (`@if`, `@foreach`, …)
+are re-indented in Allman style. Please try it out and provide feedback.
+
+# Getting Started
+
+Install the plugin and Prettier itself.
+
+```sh
+npm install --save-dev prettier prettier-plugin-razor2
+```
+
+Add to your Prettier config file:
+
+```json
+{
+  "plugins": ["prettier-plugin-razor2"]
+}
+```
+
+Optionally, disable the CSharpier integration to only format the HTML parts.
+
+```json
+{
+  "plugins": ["prettier-plugin-razor2"],
+  "csharpierEnabled": false
+}
+```
+
+## C# formatting
+
+C# formatting requires the [CSharpier](https://csharpier.com) CLI on your `PATH`
+(`dotnet tool install csharpier`, invoked as `dotnet csharpier`). If it is not
+available, C# is left untouched and a one-time warning is printed. Set
+`csharpierEnabled: false` to disable C# formatting (and silence the warning), or
+override the command with `csharpierCommand`.
+
+# Known limitations
+
+- `@switch` blocks with several cases: the bare `case X:` / `break;` lines are
+  plain text to the HTML formatter, so consecutive arms can end up glued onto
+  one line (`break; case Y:`). The output is stable and nothing is lost — it
+  just isn't pretty yet.
+- Templated Razor delegates (`.cshtml`), e.g.
+  `@Repeat(items, @<li>@item.Name</li>)`, are preserved but not reformatted.
+
+# Composing with other plugins
+
+The HTML in your Razor files is formatted by Prettier's own HTML formatter, so
+other plugins that hook the `html` parser work on it too — including inside
+control blocks. For example,
+[prettier-plugin-tailwindcss](https://github.com/tailwindlabs/prettier-plugin-tailwindcss)
+sorts `class="…"` attributes. List both plugins (Tailwind last, per its docs):
+
+```json
+{ "plugins": ["prettier-plugin-razor2", "prettier-plugin-tailwindcss"] }
+```
+
+This applies only to the HTML: classes written inside C# (a `@code`/`@{ }` block
+or a dynamic `class="@GetCss()"` value) are not sorted.
+
+# Configuration
+
+This library follows the same configuration format as Prettier, which is
+documented [here](https://prettier.io/docs/en/configuration.html). It adds two
+options:
+
+| Option             | Default              | Description                                                           |
+| ------------------ | -------------------- | --------------------------------------------------------------------- |
+| `csharpierEnabled` | `true`               | Format embedded C# with CSharpier. When `false`, C# is kept verbatim. |
+| `csharpierCommand` | `"dotnet csharpier"` | Command used to invoke the CSharpier CLI.                             |
+
+# Development
+
+The plugin is written in TypeScript in `src/` and published as a single
+[tsdown](https://tsdown.dev)-bundled file in `dist/`.
+
+    pnpm install        # install dependencies
+    pnpm test           # run the test suite (node --test)
+    pnpm typecheck      # type-check without emitting
+    pnpm build          # bundle src/ to dist/ with tsdown
+
+Tests run the TypeScript sources directly via Node's native type stripping, so
+no build step is required to develop or test. The C# tests need the CSharpier
+CLI (`dotnet tool restore`); they skip automatically when it isn't available.
+
+Releases: bump `version` in package.json, commit, tag `vX.Y.Z`, and
+`git push --follow-tags` — GitHub Actions runs the checks and publishes to npm.
+
+> **Fork notice** This project started as a fork of
+> [prettier-plugin-razor](https://github.com/KristinaPlusPlus/prettier-plugin-razor),
+> but has since been mostly rewritten.

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { Parser, Plugin, Printer, SupportLanguage } from "prettier";
+
+//#region src/index.d.ts
+/** Trivial AST: the whole document is formatted in one embedded pass. */
+interface RazorRoot {
+  type: 'razor-root';
+  source: string;
+}
+declare const languages: SupportLanguage[];
+declare const parsers: Record<string, Parser<RazorRoot>>;
+declare const options: Plugin['options'];
+declare const printers: Record<string, Printer<RazorRoot>>;
+//#endregion
+export { languages, options, parsers, printers };

package/dist/index.js

@@ -0,0 +1,715 @@
+import { doc } from "prettier";
+import { spawn } from "node:child_process";
+import * as path from "node:path";
+/** Build the block-level placeholder element for block index `n`. */
+function blockPlaceholderFor(n) {
+	return `<div data-razor="${n}"></div>`;
+}
+/**
+* Matcher for {@link blockPlaceholderFor} output in formatted HTML; group 1 is
+* the preceding indentation, group 2 the block index. Constructed fresh per
+* call \u2014 restore recurses, so a shared /g regex's lastIndex would clash.
+*/
+function blockPlaceholderRE() {
+	return /([ \t]*)<div data-razor="(\d+)"><\/div>/g;
+}
+const HTML_ELEMENTS = new Set("a abbr address area article aside audio b base bdi bdo blockquote body br button canvas caption cite code col colgroup data datalist dd del details dfn dialog div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hgroup hr html i iframe img input ins kbd label legend li link main map mark menu meta meter nav noscript object ol optgroup option output p param picture pre progress q rp rt ruby s samp script search section select slot small source span strong style sub summary sup table tbody td template textarea tfoot th thead time title tr track u ul var video wbr".split(" "));
+const DIRECTIVES = /* @__PURE__ */ new Set([
+	"page",
+	"using",
+	"inject",
+	"inherits",
+	"namespace",
+	"implements",
+	"attribute",
+	"layout",
+	"typeparam",
+	"model",
+	"rendermode",
+	"addTagHelper",
+	"removeTagHelper",
+	"tagHelperPrefix",
+	"preservewhitespace"
+]);
+const CONTROL = /* @__PURE__ */ new Set([
+	"if",
+	"for",
+	"foreach",
+	"while",
+	"switch",
+	"using",
+	"lock",
+	"do",
+	"try",
+	"section"
+]);
+const isWs = (c) => c === " " || c === "	" || c === "\r" || c === "\n";
+const isLetter = (c) => c !== void 0 && /[A-Za-z]/.test(c);
+function skipWs(src, i) {
+	while (i < src.length && isWs(src[i])) i++;
+	return i;
+}
+function readIdent(src, i) {
+	let j = i;
+	while (j < src.length && isLetter(src[j])) j++;
+	return src.slice(i, j);
+}
+function readTagName(src, i) {
+	let j = i;
+	while (j < src.length && /[A-Za-z0-9]/.test(src[j])) j++;
+	return src.slice(i, j);
+}
+function atLineStart(src, i) {
+	let j = i - 1;
+	while (j >= 0 && (src[j] === " " || src[j] === "	")) j--;
+	return j < 0 || src[j] === "\n";
+}
+function skipUntil(src, from, needle) {
+	const idx = src.indexOf(needle, from);
+	return idx === -1 ? src.length : idx + needle.length;
+}
+function skipCSharpToken(src, i) {
+	const c = src[i];
+	if (c === "\"" && src[i + 1] === "\"" && src[i + 2] === "\"") {
+		let openLen = 0;
+		while (src[i + openLen] === "\"") openLen++;
+		let j = i + openLen;
+		while (j < src.length) {
+			if (src[j] !== "\"") {
+				j++;
+				continue;
+			}
+			let runLen = 0;
+			while (src[j + runLen] === "\"") runLen++;
+			if (runLen >= openLen) return j + openLen;
+			j += runLen;
+		}
+		return src.length;
+	}
+	if (c === "@" && src[i + 1] === "\"") {
+		let j = i + 2;
+		while (j < src.length) {
+			if (src[j] === "\"") {
+				if (src[j + 1] === "\"") {
+					j += 2;
+					continue;
+				}
+				return j + 1;
+			}
+			j++;
+		}
+		return src.length;
+	}
+	if (c === "\"" || c === "'") {
+		let j = i + 1;
+		while (j < src.length) {
+			if (src[j] === "\\") {
+				j += 2;
+				continue;
+			}
+			if (src[j] === c) return j + 1;
+			j++;
+		}
+		return src.length;
+	}
+	if (c === "/" && src[i + 1] === "/") {
+		let j = i + 2;
+		while (j < src.length && src[j] !== "\n") j++;
+		return j;
+	}
+	if (c === "/" && src[i + 1] === "*") return skipUntil(src, i + 2, "*/");
+	return -1;
+}
+/**
+* 0-based indices of the lines in `text` that _start inside_ a multi-line C#
+* string literal (verbatim or raw). Their leading whitespace is string content,
+* so re-indentation must leave them untouched. Multi-line comments are not
+* protected — shifting their interior is cosmetic, not a content change.
+*/
+function linesInsideCSharpStrings(text) {
+	const inside = /* @__PURE__ */ new Set();
+	let line = 0;
+	let i = 0;
+	while (i < text.length) {
+		if (text[i] === "\n") {
+			line++;
+			i++;
+			continue;
+		}
+		const end = skipCSharpToken(text, i);
+		if (end === -1) {
+			i++;
+			continue;
+		}
+		const isString = text[i] === "\"" || text[i] === "'" || text[i] === "@" && text[i + 1] === "\"";
+		for (let j = i; j < end; j++) if (text[j] === "\n") {
+			line++;
+			if (isString) inside.add(line);
+		}
+		i = end;
+	}
+	return inside;
+}
+function matchDelimited(src, i, open, close) {
+	let depth = 0;
+	let j = i;
+	while (j < src.length) {
+		const skipped = skipCSharpToken(src, j);
+		if (skipped !== -1) {
+			j = skipped;
+			continue;
+		}
+		const c = src[j];
+		if (c === open) depth++;
+		else if (c === close && --depth === 0) return j + 1;
+		j++;
+	}
+	return src.length;
+}
+const matchBraceCSharp = (src, i) => matchDelimited(src, i, "{", "}");
+const matchParen = (src, i) => matchDelimited(src, i, "(", ")");
+function skipMarkupQuote(src, i) {
+	const q = src[i];
+	let j = i + 1;
+	while (j < src.length && src[j] !== q) j++;
+	return j < src.length ? j + 1 : src.length;
+}
+function matchBraceMarkup(src, i) {
+	let depth = 0;
+	let j = i;
+	while (j < src.length) {
+		if (src[j] === "@" && src[j + 1] === "*") {
+			j = skipUntil(src, j + 2, "*@");
+			continue;
+		}
+		if (src.startsWith("<!--", j)) {
+			j = skipUntil(src, j + 4, "-->");
+			continue;
+		}
+		if (src[j] === "@" && src[j + 1] === "{") {
+			j = matchBraceCSharp(src, j + 1);
+			continue;
+		}
+		if (src[j] === "@" && src[j + 1] === "(") {
+			j = matchParen(src, j + 1);
+			continue;
+		}
+		if (src[j] === "\"" || src[j] === "'") {
+			j = skipMarkupQuote(src, j);
+			continue;
+		}
+		const c = src[j];
+		if (c === "{") depth++;
+		else if (c === "}" && --depth === 0) return j + 1;
+		j++;
+	}
+	return src.length;
+}
+function parseClause(src, headerStart, afterKeyword, hasCondition, requireCondition) {
+	let pos = skipWs(src, afterKeyword);
+	if (hasCondition) if (src[pos] !== "(") {
+		if (requireCondition) return null;
+	} else {
+		pos = matchParen(src, pos);
+		pos = skipWs(src, pos);
+	}
+	if (src[pos] !== "{") return null;
+	const bodyEnd = matchBraceMarkup(src, pos);
+	return {
+		clause: {
+			header: src.slice(headerStart, pos).trimEnd(),
+			body: src.slice(pos + 1, bodyEnd - 1)
+		},
+		end: bodyEnd
+	};
+}
+function parseControl(src, at, keyword) {
+	const afterKw = at + 1 + keyword.length;
+	if (keyword === "section") {
+		let pos = skipWs(src, afterKw);
+		pos += readIdent(src, pos).length;
+		pos = skipWs(src, pos);
+		if (src[pos] !== "{") return null;
+		const bodyEnd = matchBraceMarkup(src, pos);
+		return {
+			block: {
+				kind: "control",
+				clauses: [{
+					header: src.slice(at, pos).trimEnd(),
+					body: src.slice(pos + 1, bodyEnd - 1)
+				}]
+			},
+			end: bodyEnd
+		};
+	}
+	const first = parseClause(src, at, afterKw, keyword !== "do" && keyword !== "try", keyword !== "using" && keyword !== "lock");
+	if (!first) return null;
+	const clauses = [first.clause];
+	let end = first.end;
+	if (keyword === "do") {
+		let pos = skipWs(src, end);
+		if (readIdent(src, pos) === "while") {
+			pos = skipWs(src, pos + 5);
+			if (src[pos] === "(") {
+				pos = matchParen(src, pos);
+				let trailer = src.slice(skipWs(src, first.end), pos);
+				if (src[pos] === ";") {
+					pos++;
+					trailer += ";";
+				}
+				return {
+					block: {
+						kind: "control",
+						clauses,
+						trailer
+					},
+					end: pos
+				};
+			}
+		}
+		return {
+			block: {
+				kind: "control",
+				clauses
+			},
+			end
+		};
+	}
+	const chained = keyword === "if" ? ["else"] : keyword === "try" ? ["catch", "finally"] : [];
+	for (;;) {
+		const pos = skipWs(src, end);
+		const next = readIdent(src, pos);
+		if (!chained.includes(next)) break;
+		if (next === "else") {
+			const afterElse = skipWs(src, pos + 4);
+			if (readIdent(src, afterElse) === "if") {
+				const arm = parseClause(src, pos, afterElse + 2, true, true);
+				if (!arm) break;
+				clauses.push(arm.clause);
+				end = arm.end;
+				continue;
+			}
+			const arm = parseClause(src, pos, pos + 4, false, false);
+			if (!arm) break;
+			clauses.push(arm.clause);
+			end = arm.end;
+			break;
+		}
+		const arm = parseClause(src, pos, pos + next.length, next === "catch", false);
+		if (!arm) break;
+		clauses.push(arm.clause);
+		end = arm.end;
+	}
+	return {
+		block: {
+			kind: "control",
+			clauses
+		},
+		end
+	};
+}
+/** Replace Razor block constructs with placeholders; see {@link MaskResult}. */
+function mask(src) {
+	const blocks = [];
+	const tagAliases = [];
+	const blockPlaceholder = (block) => blockPlaceholderFor(blocks.push(block) - 1);
+	const inlinePlaceholder = (block) => `${blocks.push(block) - 1}`;
+	let out = "";
+	let i = 0;
+	const n = src.length;
+	while (i < n) {
+		const c = src[i];
+		if (c === "<" && !src.startsWith("<!--", i)) {
+			const nameStart = src[i + 1] === "/" ? i + 2 : i + 1;
+			const name = readTagName(src, nameStart);
+			const after = src[nameStart + name.length];
+			const nameEnds = after === void 0 || after === ">" || after === "/" || isWs(after);
+			if (name !== "" && nameEnds && /^[A-Z]/.test(name) && HTML_ELEMENTS.has(name.toLowerCase())) {
+				let idx = tagAliases.indexOf(name);
+				if (idx === -1) idx = tagAliases.push(name) - 1;
+				out += src.slice(i, nameStart) + `rz-${idx}`;
+				i = nameStart + name.length;
+				continue;
+			}
+		}
+		if (c === "@" && src[i + 1] === "*") {
+			const end = skipUntil(src, i + 2, "*@");
+			out += inlinePlaceholder({
+				kind: "inline",
+				text: src.slice(i, end)
+			});
+			i = end;
+			continue;
+		}
+		if (src.startsWith("<!--", i)) {
+			const end = skipUntil(src, i + 4, "-->");
+			out += src.slice(i, end);
+			i = end;
+			continue;
+		}
+		if (c !== "@") {
+			out += c;
+			i++;
+			continue;
+		}
+		if (src[i + 1] === "@") {
+			out += "@@";
+			i += 2;
+			continue;
+		}
+		if (src[i + 1] === "(") {
+			const end = matchParen(src, i + 1);
+			out += inlinePlaceholder({
+				kind: "inline",
+				text: src.slice(i, end)
+			});
+			i = end;
+			continue;
+		}
+		if (src[i + 1] === "{") {
+			const end = matchBraceCSharp(src, i + 1);
+			out += blockPlaceholder({
+				kind: "verbatim",
+				opener: "@{",
+				body: src.slice(i + 2, end - 1),
+				csharp: "statements",
+				raw: src.slice(i, end)
+			});
+			i = end;
+			continue;
+		}
+		const kw = readIdent(src, i + 1);
+		if (kw === "code" || kw === "functions") {
+			const bracePos = skipWs(src, i + 1 + kw.length);
+			if (src[bracePos] === "{") {
+				const end = matchBraceCSharp(src, bracePos);
+				out += blockPlaceholder({
+					kind: "verbatim",
+					opener: `@${kw} {`,
+					body: src.slice(bracePos + 1, end - 1),
+					csharp: "members",
+					raw: src.slice(i, end)
+				});
+				i = end;
+				continue;
+			}
+		}
+		if (CONTROL.has(kw)) {
+			const parsed = parseControl(src, i, kw);
+			if (parsed) {
+				out += blockPlaceholder(parsed.block);
+				i = parsed.end;
+				continue;
+			}
+		}
+		if (DIRECTIVES.has(kw) && atLineStart(src, i) && src[i + 1 + kw.length] !== "=") {
+			let end = src.indexOf("\n", i);
+			if (end === -1) end = n;
+			out += blockPlaceholder({
+				kind: "directive",
+				text: src.slice(i, end).trimEnd()
+			});
+			i = end;
+			continue;
+		}
+		out += c;
+		i++;
+	}
+	return {
+		masked: out,
+		blocks,
+		tagAliases
+	};
+}
+//#endregion
+//#region src/csharp.ts
+const DEFAULT_COMMAND = "dotnet csharpier";
+const WRAPPER = "__CSharpierWrapper__";
+const EOT = "";
+const REQUEST_TIMEOUT_MS = 1e4;
+/**
+* A persistent `csharpier pipe-files` process. Spawning `dotnet csharpier`
+* costs ~200 ms (runtime + Roslyn startup); keeping one warm process reduces
+* every call after the first to a couple of milliseconds. Requests are
+* serialized (the protocol is sequential over one pipe), and the child is
+* unref'ed while idle so it never keeps the Node process alive.
+*/
+var CSharpierServer = class {
+	command;
+	child = null;
+	available = true;
+	stdoutBuf = "";
+	pendingResolve = null;
+	queue = Promise.resolve();
+	constructor(command) {
+		this.command = command;
+	}
+	/** Format one snippet; null when unavailable or the input was rejected. */
+	format(filePath, content) {
+		const task = this.queue.then(() => this.request(filePath, content));
+		this.queue = task.catch(() => null);
+		return task;
+	}
+	spawnChild() {
+		const parts = this.command.split(/\s+/);
+		const child = spawn(parts[0], [...parts.slice(1), "pipe-files"], { stdio: "pipe" });
+		this.child = child;
+		this.stdoutBuf = "";
+		child.stdout.on("data", (chunk) => {
+			this.stdoutBuf += chunk;
+			const end = this.stdoutBuf.indexOf(EOT);
+			if (end !== -1 && this.pendingResolve) {
+				const payload = this.stdoutBuf.slice(0, end);
+				this.stdoutBuf = this.stdoutBuf.slice(end + 1);
+				this.settle(payload === "" ? null : payload);
+			}
+		});
+		child.stderr.on("data", () => {});
+		child.stdin.on("error", () => {});
+		child.on("error", () => {
+			this.available = false;
+			this.child = null;
+			warnUnavailable(this.command);
+			this.settle(null);
+		});
+		child.on("close", () => {
+			this.child = null;
+			this.settle(null);
+		});
+		this.idle();
+		process.on("exit", () => child.kill());
+	}
+	request(filePath, content) {
+		if (!this.available) return Promise.resolve(null);
+		if (!this.child) this.spawnChild();
+		const child = this.child;
+		if (!child || !this.available) return Promise.resolve(null);
+		return new Promise((resolve) => {
+			this.pendingResolve = resolve;
+			this.busy();
+			const timeout = setTimeout(() => {
+				child.kill();
+			}, REQUEST_TIMEOUT_MS);
+			timeout.unref();
+			const done = (payload) => {
+				clearTimeout(timeout);
+				resolve(payload);
+			};
+			this.pendingResolve = done;
+			child.stdin.write(filePath + EOT + content + EOT);
+		});
+	}
+	settle(payload) {
+		const resolve = this.pendingResolve;
+		this.pendingResolve = null;
+		this.idle();
+		if (resolve) resolve(payload);
+	}
+	setLoopHold(hold) {
+		const child = this.child;
+		if (!child) return;
+		const handles = [
+			child,
+			child.stdout,
+			child.stdin,
+			child.stderr
+		];
+		for (const handle of handles) if (hold) handle.ref?.();
+		else handle.unref?.();
+	}
+	busy() {
+		this.setLoopHold(true);
+	}
+	idle() {
+		this.setLoopHold(false);
+	}
+};
+const servers = /* @__PURE__ */ new Map();
+function serverFor(command) {
+	let server = servers.get(command);
+	if (!server) {
+		server = new CSharpierServer(command);
+		servers.set(command, server);
+	}
+	return server;
+}
+const warnedCommands = /* @__PURE__ */ new Set();
+function warnUnavailable(command) {
+	if (warnedCommands.has(command)) return;
+	warnedCommands.add(command);
+	console.warn(`[prettier-plugin-razor2] Could not run CSharpier ("${command}"); leaving embedded C# unformatted. Install it (\`dotnet tool install csharpier\`) or set the "csharpierEnabled" option to false to disable C# formatting and silence this warning.`);
+}
+function detectIndentUnit(text) {
+	for (const line of text.split("\n")) {
+		const m = /^([ \t]+)\S/.exec(line);
+		if (m) return m[1];
+	}
+	return "  ";
+}
+function resolveCommand(options) {
+	if (options.csharpierEnabled === false) return null;
+	const command = (options.csharpierCommand ?? DEFAULT_COMMAND).trim();
+	return command === "" ? null : command;
+}
+async function runCSharpier(code, options) {
+	const command = resolveCommand(options);
+	if (command === null) return null;
+	const dir = options.filepath ? path.resolve(path.dirname(options.filepath)) : process.cwd();
+	return serverFor(command).format(path.join(dir, "__csharpier__.cs"), code);
+}
+/**
+* Format a C# snippet. Returns the formatted code (indented from column zero),
+* or `null` if CSharpier is unavailable/disabled or the code can't be parsed.
+*/
+async function formatCSharp(code, kind, options) {
+	const trimmed = code.trim();
+	if (trimmed === "") return "";
+	if (kind === "statements") {
+		const out = await runCSharpier(trimmed, options);
+		return out === null ? null : out.replace(/\s+$/, "");
+	}
+	const out = await runCSharpier(`class ${WRAPPER}\n{\n${trimmed}\n}\n`, options);
+	if (out === null) return null;
+	const trimmedOut = out.replace(/\n+$/, "");
+	const lines = trimmedOut.split("\n");
+	const open = lines.findIndex((line, i) => i > 0 && line.trim() === "{");
+	if (open === -1) return null;
+	let close = lines.length - 1;
+	while (close > open && lines[close].trim() !== "}") close--;
+	const insideString = linesInsideCSharpStrings(trimmedOut);
+	const unit = detectIndentUnit(out);
+	const body = lines.slice(open + 1, close).map((line, k) => !insideString.has(open + 1 + k) && line.startsWith(unit) ? line.slice(unit.length) : line);
+	while (body.length && body[0].trim() === "") body.shift();
+	while (body.length && body[body.length - 1].trim() === "") body.pop();
+	return body.join("\n");
+}
+//#endregion
+//#region src/format.ts
+const inlineRE = () => new RegExp(`(\\d+)`, "g");
+function indentUnit(options) {
+	return options.useTabs ? "	" : " ".repeat(options.tabWidth ?? 2);
+}
+function indentLines(text, prefix) {
+	return text.split("\n").map((line) => line === "" ? "" : prefix + line).join("\n");
+}
+function indentCSharpLines(text, prefix) {
+	const insideString = linesInsideCSharpStrings(text);
+	return text.split("\n").map((line, i) => line === "" || insideString.has(i) ? line : prefix + line).join("\n");
+}
+function reindentVerbatim(text, indent) {
+	if (indent === "") return text;
+	return indentCSharpLines(text, indent);
+}
+async function renderBlock(block, indent, textToDoc, options) {
+	switch (block.kind) {
+		case "inline": return indent + block.text;
+		case "directive": return indent + block.text;
+		case "verbatim": {
+			const formatted = await formatCSharp(block.body, block.csharp, options);
+			if (formatted === null) return reindentVerbatim(block.raw, indent);
+			if (formatted === "") return `${indent}${block.opener}\n${indent}}`;
+			const body = indentCSharpLines(formatted, indent + indentUnit(options));
+			return `${indent}${block.opener}\n${body}\n${indent}}`;
+		}
+		case "control": {
+			const inner = indent + indentUnit(options);
+			const parts = [];
+			for (const clause of block.clauses) {
+				parts.push(indent + clause.header);
+				parts.push(indent + "{");
+				const body = (await formatDocument(clause.body, textToDoc, options)).trimEnd();
+				if (body !== "") parts.push(indentLines(body, inner));
+				parts.push(indent + "}");
+			}
+			let result = parts.join("\n");
+			if (block.trailer) result += "\n" + indent + block.trailer;
+			return result;
+		}
+	}
+}
+async function restore(html, blocks, textToDoc, options) {
+	const re = blockPlaceholderRE();
+	let out = "";
+	let last = 0;
+	let m;
+	while ((m = re.exec(html)) !== null) {
+		out += html.slice(last, m.index);
+		out += await renderBlock(blocks[Number(m[2])], m[1], textToDoc, options);
+		last = m.index + m[0].length;
+	}
+	out += html.slice(last);
+	return out;
+}
+/**
+* Format Razor source into a formatted string: mask the Razor constructs,
+* delegate the remaining markup to Prettier's HTML printer, then restore the
+* constructs (recursing into control-block bodies).
+*/
+async function formatDocument(source, textToDoc, options) {
+	if (source.trim() === "") return "";
+	const { masked, blocks, tagAliases } = mask(source);
+	const htmlDoc = await textToDoc(masked, { parser: "html" });
+	let html = doc.printer.printDocToString(htmlDoc, {
+		printWidth: options.printWidth ?? 80,
+		tabWidth: options.tabWidth ?? 2,
+		useTabs: options.useTabs ?? false
+	}).formatted;
+	if (blocks.length > 0) {
+		html = await restore(html, blocks, textToDoc, options);
+		html = resolveInline(html, blocks);
+	}
+	return restoreTagAliases(html, tagAliases);
+}
+function restoreTagAliases(html, tagAliases) {
+	if (tagAliases.length === 0) return html;
+	return html.replace(/(<\/?)rz-(\d+)/g, (whole, open, id) => open + (tagAliases[Number(id)] ?? whole));
+}
+function resolveInline(text, blocks) {
+	return text.replace(inlineRE(), (whole, id) => {
+		const block = blocks[Number(id)];
+		return block?.kind === "inline" ? block.text : whole;
+	});
+}
+//#endregion
+//#region src/index.ts
+const languages = [{
+	name: "Razor",
+	parsers: ["razor"],
+	extensions: [".razor", ".cshtml"],
+	vscodeLanguageIds: ["razor", "aspnetcorerazor"]
+}];
+const parsers = { razor: {
+	parse: (text) => ({
+		type: "razor-root",
+		source: text
+	}),
+	astFormat: "razor-ast",
+	locStart: () => 0,
+	locEnd: () => 0
+} };
+const options = {
+	csharpierEnabled: {
+		type: "boolean",
+		category: "Razor",
+		default: true,
+		description: "Format embedded C# (@code/@functions/@{ } blocks) with CSharpier. When false, C# is kept verbatim."
+	},
+	csharpierCommand: {
+		type: "string",
+		category: "Razor",
+		default: "dotnet csharpier",
+		description: "Command used to invoke the CSharpier CLI."
+	}
+};
+const printers = { "razor-ast": {
+	print: () => "",
+	embed(path) {
+		const node = path.node;
+		if (node.type !== "razor-root") return null;
+		return async (textToDoc, _print, _embedPath, options) => {
+			return (await formatDocument(node.source, textToDoc, options)).replace(/\s+$/, "") + "\n";
+		};
+	}
+} };
+//#endregion
+export { languages, options, parsers, printers };

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "prettier-plugin-razor2",
+  "version": "0.1.0",
+  "description": "Prettier plugin for Razor (Blazor) files — a fork of prettier-plugin-razor",
+  "keywords": [
+    "prettier",
+    "razor",
+    "blazor",
+    "plugin"
+  ],
+  "homepage": "https://github.com/rmacfie/prettier-plugin-razor2#readme",
+  "bugs": {
+    "url": "https://github.com/rmacfie/prettier-plugin-razor2/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rmacfie/prettier-plugin-razor2.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Robert Macfie",
+    "email": "robert@macfie.se"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "26.1.0",
+    "prettier": "3.9.4",
+    "prettier-plugin-jsdoc": "1.8.1",
+    "prettier-plugin-packagejson": "3.0.2",
+    "tsdown": "^0.22.3",
+    "typescript": "6.0.3",
+    "node": "runtime:26.4.0"
+  },
+  "peerDependencies": {
+    "prettier": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": "26.4.0",
+      "onFail": "download"
+    },
+    "packageManager": {
+      "name": "pnpm",
+      "version": "11.9.0",
+      "onFail": "download"
+    }
+  },
+  "scripts": {
+    "bench": "node bench/bench.ts",
+    "build": "tsdown",
+    "clean": "rm -rf dist",
+    "csharpier": "dotnet csharpier",
+    "format": "prettier --write .",
+    "node": "node",
+    "test": "node --test \"tests/**/*.test.ts\"",
+    "typecheck": "tsc"
+  }
+}