@purestack/ts-format 0.0.0-stage → 1.1.25

package/dist/files.mjs

@@ -0,0 +1,1076 @@
+/*! @purestack/ts-format v1.1.25 | (c) 2026 Ahmed Yasin Koculu | MIT License */
+
+import { execFile } from "node:child_process";
+import { lstat, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import htmlPlugin from "prettier/plugins/html";
+import postcssPlugin from "prettier/plugins/postcss";
+import prettier from "prettier/standalone";
+import ts from "typescript-parser";
+
+//#region packages/ts-format/src/markup.ts
+const VOID_HTML_TAG_NAMES = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+function scanTagTokens(markup) {
+	const tokens = [];
+	for (let index = 0; index < markup.length; index++) {
+		if (markup[index] !== "<") continue;
+		if (markup.startsWith("<!--", index)) {
+			const commentEnd = markup.indexOf("-->", index + 4);
+			if (commentEnd === -1) break;
+			index = commentEnd + 2;
+			continue;
+		}
+		const isClosing = markup[index + 1] === "/";
+		const nameStart = skipWhitespace(markup, index + (isClosing ? 2 : 1));
+		const nameEnd = readTagNameEnd(markup, nameStart);
+		if (nameEnd === nameStart) continue;
+		const tagEnd = findTagEnd(markup, nameEnd);
+		if (tagEnd === -1) break;
+		const name = markup.slice(nameStart, nameEnd);
+		const trailing = markup.slice(nameEnd, tagEnd);
+		tokens.push({
+			start: index,
+			end: tagEnd + 1,
+			kind: isClosing ? "closing" : "opening",
+			name,
+			nameStart,
+			nameEnd,
+			selfClosing: !isClosing && /\/\s*$/.test(trailing)
+		});
+		index = tagEnd;
+	}
+	return tokens;
+}
+function isMdxExpressionStart(source, index) {
+	return source[index] === "{" && source[index - 1] !== "{" && source[index + 1] !== "{";
+}
+function findMdxExpressionEnd(source, startIndex) {
+	let braceDepth = 0;
+	let quote;
+	for (let index = startIndex; index < source.length; index++) {
+		const current = source[index];
+		const previous = source[index - 1];
+		if (quote) {
+			if (current === quote && previous !== "\\") quote = void 0;
+			else if (quote === "`" && current === "$" && source[index + 1] === "{") {
+				const templateExpressionEnd = findMdxExpressionEnd(source, index + 1);
+				if (templateExpressionEnd === -1) return -1;
+				index = templateExpressionEnd - 1;
+			}
+			continue;
+		}
+		if (current === "\"" || current === "'" || current === "`") {
+			quote = current;
+			continue;
+		}
+		if (current === "{") {
+			braceDepth++;
+			continue;
+		}
+		if (current !== "}") continue;
+		braceDepth--;
+		if (braceDepth === 0) return index + 1;
+		if (braceDepth < 0) return -1;
+	}
+	return -1;
+}
+function findTagEnd(markup, startIndex) {
+	let quote;
+	for (let index = startIndex; index < markup.length; index++) {
+		const current = markup[index];
+		if (quote) {
+			if (current === quote && markup[index - 1] !== "\\") quote = void 0;
+			continue;
+		}
+		if (current === "\"" || current === "'") {
+			quote = current;
+			continue;
+		}
+		if (current === ">") return index;
+	}
+	return -1;
+}
+function skipWhitespace(markup, startIndex) {
+	let index = startIndex;
+	while (index < markup.length && /\s/.test(markup[index])) index++;
+	return index;
+}
+function readTagNameEnd(markup, startIndex) {
+	let index = startIndex;
+	while (index < markup.length && /[A-Za-z0-9._:$-]/.test(markup[index])) index++;
+	return index;
+}
+
+//#endregion
+//#region packages/ts-format/src/expressions.ts
+/**
+* Protects Regor {{ ... }} expressions while the surrounding markup is
+* formatted as HTML. The expression source is restored byte-for-byte.
+*/
+function maskRegorExpressions(source) {
+	const expressions = [];
+	let placeholderContent = "";
+	let cursor = 0;
+	while (cursor < source.length) {
+		const start = source.indexOf("{{", cursor);
+		if (start === -1) {
+			placeholderContent += source.slice(cursor);
+			break;
+		}
+		placeholderContent += source.slice(cursor, start);
+		const end = findRegorExpressionEnd(source, start);
+		if (end === -1) {
+			placeholderContent += source.slice(start);
+			break;
+		}
+		const placeholder = createPlaceholder(source, expressions.length);
+		expressions.push({
+			placeholder,
+			source: source.slice(start, end)
+		});
+		placeholderContent += placeholder;
+		cursor = end;
+	}
+	return {
+		expressions,
+		placeholderContent
+	};
+}
+function restoreRegorExpressions(formatted, expressions) {
+	let restored = formatted;
+	for (const expression of expressions) restored = restored.split(expression.placeholder).join(expression.source);
+	return restored;
+}
+function findRegorExpressionEnd(source, start) {
+	const end = findMdxExpressionEnd(source, start);
+	if (end === -1) return -1;
+	return source.slice(end - 2, end) === "}}" ? end : -1;
+}
+function createPlaceholder(source, index) {
+	let placeholder = `__PURESTACK_REGOR_EXPR_${index}__`;
+	while (source.includes(placeholder)) placeholder = `_${placeholder}_`;
+	return placeholder;
+}
+
+//#endregion
+//#region packages/ts-format/src/source.ts
+function intersects(left, right) {
+	return left.start <= right.end && right.start <= left.end;
+}
+/** Immutable source snapshot. All edit offsets refer to this text. */
+var SourceText = class {
+	text;
+	filePath;
+	options;
+	diagnostics = [];
+	lines = [];
+	eol;
+	constructor(text, options = {}) {
+		this.text = text;
+		this.filePath = options.filePath ?? "source.mdx";
+		this.options = {
+			printWidth: options.printWidth ?? 80,
+			tabSize: options.tabSize ?? 2,
+			useTabs: options.useTabs ?? false
+		};
+		for (const value of [this.options.printWidth, this.options.tabSize]) if (!Number.isInteger(value) || value < 1) throw new Error("Print width and tab size must be positive integers.");
+		this.eol = /\r\n/.test(text) ? "\r\n" : "\n";
+		let start = 0;
+		for (const line of text.split("\n")) {
+			const content = line.endsWith("\r") ? line.slice(0, -1) : line;
+			this.lines.push({
+				text: content,
+				range: {
+					start,
+					end: start + content.length
+				}
+			});
+			start += line.length + 1;
+		}
+	}
+	get lineCount() {
+		return this.lines.length;
+	}
+	lineAt(line) {
+		return this.lines[line];
+	}
+	positionAt(offset) {
+		const bounded = Math.max(0, Math.min(offset, this.text.length));
+		let low = 0;
+		let high = this.lines.length - 1;
+		while (low < high) {
+			const middle = Math.ceil((low + high) / 2);
+			if (this.lines[middle].range.start > bounded) high = middle - 1;
+			else low = middle;
+		}
+		const line = this.lines[low];
+		return {
+			line: low,
+			character: Math.min(bounded, line.range.end) - line.range.start
+		};
+	}
+	offsetAt(position) {
+		const line = this.lines[Math.max(0, Math.min(position.line, this.lines.length - 1))];
+		return Math.min(line.range.end, line.range.start + Math.max(0, position.character));
+	}
+	preserveEol(text) {
+		return text.replace(/\r?\n/g, this.eol);
+	}
+	report(range, error) {
+		this.diagnostics.push({
+			...range,
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+};
+/** Apply non-overlapping edits against their original snapshot. */
+function applySourceEdits(source, edits) {
+	const ordered = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+	let cursor = 0;
+	const parts = [];
+	for (const edit of ordered) {
+		if (edit.start < cursor || edit.end < edit.start || edit.end > source.length) throw new Error("Formatter returned overlapping or invalid source edits.");
+		parts.push(source.slice(cursor, edit.start), edit.newText);
+		cursor = edit.end;
+	}
+	parts.push(source.slice(cursor));
+	return parts.join("");
+}
+
+//#endregion
+//#region packages/ts-format/src/fences.ts
+function buildMdxFenceDelimiterEdits(document, excludedRanges, options = {}) {
+	const edits = [];
+	let activeFence;
+	let frontmatterHandled = false;
+	let inFrontmatter = false;
+	for (let lineIndex = 0; lineIndex < document.lineCount; lineIndex++) {
+		const line = document.lineAt(lineIndex);
+		const lineText = line.text;
+		const trimmed = lineText.trim();
+		if (!frontmatterHandled && lineIndex === 0 && trimmed === "---") {
+			frontmatterHandled = true;
+			inFrontmatter = true;
+			continue;
+		}
+		if (inFrontmatter) {
+			if (trimmed === "---") inFrontmatter = false;
+			continue;
+		}
+		if (isLineInsideAnyRange(line.range, excludedRanges)) continue;
+		if (options.onlyWithinRange && !intersects(line.range, options.onlyWithinRange)) continue;
+		if (!activeFence) {
+			const splitLine = splitLineBeforeInlineMdxFenceOpener(lineText);
+			if (splitLine) {
+				const replacement = [...splitAdjacentMarkupTags(splitLine.before), splitLine.fenceLine].join("\n");
+				pushLineReplacement(edits, line.range, lineText, replacement);
+				const delimiter = parseMdxFenceDelimiter(splitLine.fenceLine.trim());
+				activeFence = delimiter ? {
+					length: delimiter.length,
+					marker: delimiter.marker
+				} : void 0;
+				continue;
+			}
+			const delimiter = parseMdxFenceDelimiter(trimmed);
+			if (!delimiter) continue;
+			pushLineReplacement(edits, line.range, lineText, trimLineStartIndent(lineText));
+			activeFence = {
+				length: delimiter.length,
+				marker: delimiter.marker
+			};
+			continue;
+		}
+		const splitClosingPrefix = splitLineAfterInlineMdxFenceCloser(lineText, activeFence);
+		if (splitClosingPrefix) {
+			const replacement = [trimLineStartIndent(splitClosingPrefix.fenceLine), splitClosingPrefix.after].join("\n");
+			pushLineReplacement(edits, line.range, lineText, replacement);
+			activeFence = void 0;
+			continue;
+		}
+		const splitClosingSuffix = splitLineBeforeInlineMdxFenceCloser(lineText, activeFence);
+		if (splitClosingSuffix) {
+			const replacement = [splitClosingSuffix.before, trimLineStartIndent(splitClosingSuffix.fenceLine)].join("\n");
+			pushLineReplacement(edits, line.range, lineText, replacement);
+			activeFence = void 0;
+			continue;
+		}
+		const delimiter = parseMdxFenceDelimiter(trimmed);
+		if (!delimiter || !isMdxFenceClosingDelimiter(delimiter, activeFence)) continue;
+		pushLineReplacement(edits, line.range, lineText, trimLineStartIndent(lineText));
+		activeFence = void 0;
+	}
+	return edits.map((edit) => ({
+		...edit,
+		newText: document.preserveEol(edit.newText)
+	}));
+}
+function maskMdxFencedRegions(source) {
+	const fences = [];
+	const lines = splitInlineMdxFenceDelimiters(source).split("\n");
+	const placeholderLines = [];
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+		const openingDelimiter = parseMdxFenceDelimiter(lines[lineIndex].trim());
+		if (!openingDelimiter) {
+			placeholderLines.push(lines[lineIndex]);
+			continue;
+		}
+		let closingLineIndex = -1;
+		for (let candidateLineIndex = lineIndex + 1; candidateLineIndex < lines.length; candidateLineIndex++) {
+			const closingDelimiter = parseMdxFenceDelimiter(lines[candidateLineIndex].trim());
+			if (closingDelimiter && isMdxFenceClosingDelimiter(closingDelimiter, openingDelimiter)) {
+				closingLineIndex = candidateLineIndex;
+				break;
+			}
+		}
+		if (closingLineIndex === -1) {
+			placeholderLines.push(lines[lineIndex]);
+			continue;
+		}
+		const placeholder = `<!--PURESTACK_MDX_FENCE_${fences.length}-->`;
+		fences.push({
+			placeholder,
+			source: normalizeMdxFenceDelimiterIndent(lines.slice(lineIndex, closingLineIndex + 1))
+		});
+		placeholderLines.push(placeholder);
+		lineIndex = closingLineIndex;
+	}
+	return {
+		fences,
+		placeholderContent: placeholderLines.join("\n")
+	};
+}
+function restoreMdxFencedRegions(formatted, fences) {
+	let restored = formatted;
+	for (const fence of fences) {
+		const standalonePlaceholderPattern = new RegExp(`^[\\t ]*${escapeRegExp$1(fence.placeholder)}$`, "gm");
+		if (standalonePlaceholderPattern.test(restored)) {
+			restored = restored.replace(standalonePlaceholderPattern, fence.source);
+			continue;
+		}
+		restored = restored.split(fence.placeholder).join(fence.source);
+	}
+	return restored;
+}
+function parseMdxFenceDelimiter(trimmed) {
+	const match = /^(`{3,}|~{3,})(.*)$/.exec(trimmed);
+	if (!match) return void 0;
+	return {
+		length: match[1].length,
+		marker: match[1].startsWith("`") ? "`" : "~",
+		suffix: match[2]
+	};
+}
+function parseInlineMdxFenceOpener(trimmed) {
+	const splitLine = splitLineBeforeInlineMdxFenceOpener(trimmed);
+	if (!splitLine) return void 0;
+	return parseMdxFenceDelimiter(splitLine.fenceLine.trim());
+}
+function parseInlineMdxFenceCloser(trimmed, activeFence) {
+	const splitLine = splitLineAfterInlineMdxFenceCloser(trimmed, activeFence);
+	if (splitLine) return parseMdxFenceDelimiter(splitLine.fenceLine.trim());
+	const trailingSplitLine = splitLineBeforeInlineMdxFenceCloser(trimmed, activeFence);
+	if (!trailingSplitLine) return void 0;
+	return parseMdxFenceDelimiter(trailingSplitLine.fenceLine.trim());
+}
+function isMdxFenceClosingDelimiter(delimiter, activeFence) {
+	return delimiter.marker === activeFence.marker && delimiter.length >= activeFence.length && delimiter.suffix.trim().length === 0;
+}
+function splitInlineMdxFenceDelimiters(source) {
+	const lines = source.split("\n");
+	const splitLines = [];
+	let activeFence;
+	for (const line of lines) {
+		if (!activeFence) {
+			const splitLine = splitLineBeforeInlineMdxFenceOpener(line);
+			if (splitLine) {
+				splitLines.push(...splitAdjacentMarkupTags(splitLine.before), splitLine.fenceLine);
+				const delimiter = parseMdxFenceDelimiter(splitLine.fenceLine.trim());
+				activeFence = delimiter ? {
+					length: delimiter.length,
+					marker: delimiter.marker
+				} : void 0;
+				continue;
+			}
+			splitLines.push(line);
+			const delimiter = parseMdxFenceDelimiter(line.trim());
+			if (!delimiter) continue;
+			activeFence = {
+				length: delimiter.length,
+				marker: delimiter.marker
+			};
+			continue;
+		}
+		const splitClosingLine = splitLineAfterInlineMdxFenceCloser(line, activeFence);
+		if (splitClosingLine) {
+			splitLines.push(splitClosingLine.fenceLine, splitClosingLine.after);
+			activeFence = void 0;
+			continue;
+		}
+		const splitTrailingClosingLine = splitLineBeforeInlineMdxFenceCloser(line, activeFence);
+		if (splitTrailingClosingLine) {
+			splitLines.push(splitTrailingClosingLine.before, splitTrailingClosingLine.fenceLine);
+			activeFence = void 0;
+			continue;
+		}
+		splitLines.push(line);
+		const delimiter = parseMdxFenceDelimiter(line.trim());
+		if (!delimiter) continue;
+		if (isMdxFenceClosingDelimiter(delimiter, activeFence)) activeFence = void 0;
+	}
+	return splitLines.join("\n");
+}
+function splitLineBeforeInlineMdxFenceOpener(line) {
+	if (parseMdxFenceDelimiter(line.trim())) return void 0;
+	const match = /`{3}|~{3}/.exec(line);
+	if (!match) return void 0;
+	const before = line.slice(0, match.index).trimEnd();
+	if (before.trim().length === 0) return void 0;
+	return {
+		before,
+		fenceLine: line.slice(match.index)
+	};
+}
+function splitAdjacentMarkupTags(line) {
+	const tokens = scanTagTokens(line);
+	if (tokens.length < 2) return [line];
+	let cursor = 0;
+	const lines = [];
+	const indent = /^\s*/.exec(line)?.[0] ?? "";
+	for (const token of tokens) {
+		if (line.slice(cursor, token.start).trim().length > 0) return [line];
+		const tag = line.slice(token.start, token.end);
+		lines.push(lines.length === 0 ? `${indent}${tag}` : tag);
+		cursor = token.end;
+	}
+	if (line.slice(cursor).trim().length > 0) return [line];
+	return lines;
+}
+function splitLineBeforeInlineMdxFenceCloser(line, activeFence) {
+	let end = line.length;
+	while (end > 0 && (line[end - 1] === "	" || line[end - 1] === " ")) end--;
+	let start = end;
+	while (start > 0 && line[start - 1] === activeFence.marker) start--;
+	if (end - start < activeFence.length) return void 0;
+	const before = line.slice(0, start).trimEnd();
+	if (before.trim().length === 0) return void 0;
+	return {
+		before,
+		fenceLine: line.slice(start, end)
+	};
+}
+function splitLineAfterInlineMdxFenceCloser(line, activeFence) {
+	const match = new RegExp(`^([\\t ]*${escapeRegExp$1(activeFence.marker.repeat(activeFence.length))}${escapeRegExp$1(activeFence.marker)}*)(.*)$`).exec(line);
+	if (!match || match[2].trim().length === 0) return void 0;
+	const closingDelimiter = parseMdxFenceDelimiter(match[1].trim());
+	if (!closingDelimiter) return void 0;
+	if (!isMdxFenceClosingDelimiter(closingDelimiter, activeFence)) return;
+	return {
+		fenceLine: match[1],
+		after: match[2]
+	};
+}
+function normalizeMdxFenceDelimiterIndent(lines) {
+	if (lines.length < 2) return lines.join("\n");
+	const normalizedLines = [...lines];
+	normalizedLines[0] = trimLineStartIndent(normalizedLines[0]);
+	normalizedLines[normalizedLines.length - 1] = trimLineStartIndent(normalizedLines[normalizedLines.length - 1]);
+	return normalizedLines.join("\n");
+}
+function trimLineStartIndent(line) {
+	return line.replace(/^[\t ]+/, "");
+}
+function pushLineReplacement(edits, range, oldText, newText) {
+	if (newText === oldText) return;
+	edits.push({
+		...range,
+		newText
+	});
+}
+function isLineInsideAnyRange(line, ranges) {
+	return ranges.some((range) => line.start >= range.start && line.end <= range.end);
+}
+function escapeRegExp$1(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+//#endregion
+//#region packages/ts-format/src/html.ts
+const RAW_TEXT_TAG = "script|style|textarea|title|xmp|iframe|noembed|noframes|plaintext";
+const TAG_BODY = `(?:"[^"]*"|'[^']*'|[^"'>])*>`;
+/**
+* Skips comments, raw text and opening tags; captures closing tags broken before `>`.
+* Case-sensitive so PascalCase components such as `<Title>` are not raw text.
+*/
+const BROKEN_CLOSING_TAG = new RegExp([
+	String.raw`<!--[\s\S]*?-->`,
+	String.raw`<(${RAW_TEXT_TAG})\b${TAG_BODY}[\s\S]*?</\1\s*>`,
+	`<[A-Za-z]${TAG_BODY}`,
+	String.raw`(</[^\s>]+)\s*\n\s*>`
+].join("|"), "g");
+async function formatHtmlFragment(source, options) {
+	return normalizeClosingTagSpacing(await prettier.format(source, {
+		htmlWhitespaceSensitivity: "css",
+		parser: "html",
+		plugins: [htmlPlugin, postcssPlugin],
+		printWidth: options.printWidth,
+		tabWidth: options.tabSize,
+		useTabs: options.useTabs
+	}));
+}
+/** Keep closing tags readable without inserting whitespace into inline content. */
+function normalizeClosingTagSpacing(source) {
+	return source.replace(BROKEN_CLOSING_TAG, (match, _rawTextTag, closingTag) => closingTag ? `${closingTag}>` : match);
+}
+function normalizeSelfClosingTagSpacing(formatted) {
+	return formatted.replace(/\s+/g, (whitespace, offset) => formatted.startsWith("/>", offset + whitespace.length) ? "" : whitespace);
+}
+
+//#endregion
+//#region packages/ts-format/src/mdx.ts
+async function buildMdxFormattingEdits(document, request = {}) {
+	const blocks = getMdxMarkupBlocks(document, { includeIncomplete: true }).filter((block) => request.onlyWithinRange ? intersects(block.range, request.onlyWithinRange) : true);
+	const edits = [];
+	const blockRanges = blocks.map((block) => block.range);
+	for (const block of blocks) {
+		const formatted = await formatMdxMarkupBlock(document, block);
+		if (!formatted || formatted === block.content) continue;
+		edits.push({
+			...block.range,
+			newText: document.preserveEol(formatted)
+		});
+	}
+	edits.push(...buildMdxFenceDelimiterEdits(document, blockRanges, { onlyWithinRange: request.onlyWithinRange }));
+	return edits;
+}
+function getMdxMarkupBlocks(document, options = {}) {
+	const blocks = [];
+	const state = {
+		activeEndLine: void 0,
+		activeLines: [],
+		frontmatterHandled: false,
+		inFence: false,
+		inFrontmatter: false
+	};
+	for (let lineIndex = 0; lineIndex < document.lineCount; lineIndex++) {
+		const lineText = document.lineAt(lineIndex).text;
+		const trimmed = lineText.trim();
+		if (startMdxFrontmatter(lineIndex, trimmed, state)) continue;
+		if (closeMdxFrontmatter(trimmed, state)) continue;
+		collectActiveMarkupBlock(blocks, document, lineIndex, lineText, trimmed, state);
+	}
+	if (options.includeIncomplete && state.activeStartLine !== void 0 && state.activeEndLine !== void 0) pushActiveBlock(blocks, document, state.activeStartLine, state.activeEndLine, state.activeLines);
+	return blocks;
+}
+function pushActiveBlock(blocks, document, startLine, endLine, lines) {
+	const start = document.lineAt(startLine).range.start;
+	const end = document.lineAt(endLine).range.end;
+	blocks.push({
+		content: lines.join("\n"),
+		range: {
+			start,
+			end
+		}
+	});
+}
+function looksLikeMarkupBlockStart(trimmedLine) {
+	return /^<[A-Za-z][A-Za-z0-9._:$-]*/.test(trimmedLine);
+}
+function isCompleteMarkupBlock(markup) {
+	const { placeholderContent } = maskMdxFencedRegions(markup);
+	if (!placeholderContent.includes("<")) return false;
+	if (hasUnterminatedTag(placeholderContent)) return false;
+	return getUnclosedTagNames(placeholderContent).length === 0;
+}
+async function formatMdxMarkupBlock(document, block) {
+	const formattingOptions = document.options;
+	const { fences, placeholderContent: fencePlaceholderContent } = maskMdxFencedRegions(block.content.trim());
+	const { inlineCodeSpans, placeholderContent: inlineCodePlaceholderContent } = maskMdxInlineCodeSpans(fencePlaceholderContent);
+	const { expressions: regorExpressions, placeholderContent: regorPlaceholderContent } = maskRegorExpressions(inlineCodePlaceholderContent);
+	const { expressions, placeholderContent } = maskMdxExpressions(regorPlaceholderContent);
+	if (!placeholderContent.includes("<")) return void 0;
+	let formatted;
+	try {
+		formatted = await formatHtmlFragment(placeholderContent, formattingOptions);
+	} catch (error) {
+		document.report(block.range, error);
+		return;
+	}
+	const restoredExpressions = restoreMdxExpressions(normalizeSelfClosingTagSpacing(formatted.trim()), expressions);
+	const restoredInlineCode = restoreMdxInlineCodeSpans(restoreRegorExpressions(restoredExpressions, regorExpressions), inlineCodeSpans);
+	return restoreMdxFencedRegions(restoredInlineCode, fences);
+}
+function maskMdxInlineCodeSpans(source) {
+	const inlineCodeSpans = [];
+	return {
+		inlineCodeSpans,
+		placeholderContent: source.split("\n").map((line) => maskMdxInlineCodeSpansInLine(line, inlineCodeSpans)).join("\n")
+	};
+}
+function maskMdxInlineCodeSpansInLine(line, inlineCodeSpans) {
+	let placeholderLine = "";
+	for (let index = 0; index < line.length;) {
+		const start = line.indexOf("`", index);
+		if (start === -1) {
+			placeholderLine += line.slice(index);
+			break;
+		}
+		const tickCount = countRepeatedChar(line, start, "`");
+		if (tickCount !== 1) {
+			placeholderLine += line.slice(index, start + tickCount);
+			index = start + tickCount;
+			continue;
+		}
+		const end = findMdxInlineCodeEnd(line, start + 1);
+		if (end === -1) {
+			placeholderLine += line.slice(index);
+			break;
+		}
+		const source = line.slice(start, end + 1);
+		const placeholder = createMdxInlineCodePlaceholder(inlineCodeSpans.length, line, start, end + 1);
+		inlineCodeSpans.push({
+			placeholder,
+			source
+		});
+		placeholderLine += line.slice(index, start);
+		placeholderLine += placeholder;
+		index = end + 1;
+	}
+	return placeholderLine;
+}
+function createMdxInlineCodePlaceholder(index, line, start, end) {
+	const lineBefore = line.slice(0, start);
+	const lineAfter = line.slice(end);
+	if (lineBefore.trim().length === 0 && lineAfter.trim().length === 0) return `<!--PURESTACK_MDX_INLINE_CODE_${index}-->`;
+	return `PURESTACK_MDX_INLINE_CODE_${index}`;
+}
+function restoreMdxInlineCodeSpans(formatted, inlineCodeSpans) {
+	let restored = formatted;
+	for (const inlineCodeSpan of sortLongestPlaceholderFirst(inlineCodeSpans)) restored = restored.split(inlineCodeSpan.placeholder).join(inlineCodeSpan.source);
+	return restored;
+}
+function maskMdxExpressions(source) {
+	const expressions = [];
+	let placeholderContent = "";
+	for (let index = 0; index < source.length;) {
+		const rawTextEnd = findRawTextElementEnd(source, index);
+		if (rawTextEnd !== void 0) {
+			placeholderContent += source.slice(index, rawTextEnd);
+			index = rawTextEnd;
+			continue;
+		}
+		if (!isMdxExpressionStart(source, index)) {
+			placeholderContent += source[index];
+			index++;
+			continue;
+		}
+		const expressionEnd = findMdxExpressionEnd(source, index);
+		if (expressionEnd === -1) {
+			placeholderContent += source[index];
+			index++;
+			continue;
+		}
+		const placeholder = `PURESTACK_MDX_EXPR_${expressions.length}`;
+		expressions.push({
+			placeholder,
+			source: source.slice(index, expressionEnd)
+		});
+		placeholderContent += placeholder;
+		index = expressionEnd;
+	}
+	return {
+		expressions,
+		placeholderContent
+	};
+}
+function restoreMdxExpressions(formatted, expressions) {
+	let restored = formatted;
+	for (const expression of sortLongestPlaceholderFirst(expressions)) restored = restored.split(expression.placeholder).join(expression.source);
+	return restored;
+}
+function hasUnterminatedTag(markup) {
+	for (let index = 0; index < markup.length; index++) {
+		if (markup[index] !== "<") continue;
+		if (markup.startsWith("<!--", index)) {
+			const commentEnd = markup.indexOf("-->", index + 4);
+			if (commentEnd === -1) return true;
+			index = commentEnd + 2;
+			continue;
+		}
+		const nextTagEnd = findTagEnd(markup, index + 1);
+		if (nextTagEnd === -1) return true;
+		index = nextTagEnd;
+	}
+	return false;
+}
+function startMdxFrontmatter(lineIndex, trimmed, state) {
+	if (state.frontmatterHandled || lineIndex !== 0 || trimmed !== "---") return false;
+	state.inFrontmatter = true;
+	state.frontmatterHandled = true;
+	return true;
+}
+function closeMdxFrontmatter(trimmed, state) {
+	if (!state.inFrontmatter) return false;
+	if (trimmed === "---") state.inFrontmatter = false;
+	return true;
+}
+function updateMdxFenceState(trimmed, state) {
+	const activeFence = state.fenceMarker && state.fenceLength ? {
+		length: state.fenceLength,
+		marker: state.fenceMarker
+	} : void 0;
+	const delimiter = state.inFence && activeFence ? parseInlineMdxFenceCloser(trimmed, activeFence) ?? parseMdxFenceDelimiter(trimmed) : parseMdxFenceDelimiter(trimmed) ?? parseInlineMdxFenceOpener(trimmed);
+	if (!delimiter) return state.inFence;
+	if (!state.inFence) {
+		state.inFence = true;
+		state.fenceLength = delimiter.length;
+		state.fenceMarker = delimiter.marker;
+		return true;
+	}
+	if (state.fenceMarker && state.fenceLength && isMdxFenceClosingDelimiter(delimiter, {
+		length: state.fenceLength,
+		marker: state.fenceMarker
+	})) {
+		state.inFence = false;
+		state.fenceLength = void 0;
+		state.fenceMarker = void 0;
+	}
+	return true;
+}
+function collectActiveMarkupBlock(blocks, document, lineIndex, lineText, trimmed, state) {
+	if (state.activeStartLine === void 0) {
+		if (state.inFence) {
+			updateMdxFenceState(trimmed, state);
+			return;
+		}
+		if (!looksLikeMarkupBlockStart(trimmed)) {
+			if (updateMdxFenceState(trimmed, state)) return;
+			return;
+		}
+		state.activeStartLine = lineIndex;
+		state.activeEndLine = lineIndex;
+		state.activeLines = [lineText];
+	} else {
+		state.activeEndLine = lineIndex;
+		state.activeLines.push(lineText);
+	}
+	updateMdxFenceState(trimmed, state);
+	if (state.inFence) return;
+	if (!isCompleteMarkupBlock(state.activeLines.join("\n"))) return;
+	pushActiveBlock(blocks, document, state.activeStartLine, state.activeEndLine ?? lineIndex, state.activeLines);
+	state.activeEndLine = void 0;
+	state.activeStartLine = void 0;
+	state.activeLines = [];
+}
+function getUnclosedTagNames(markup) {
+	const stack = [];
+	for (const token of scanTagTokens(markup)) {
+		if (token.kind === "opening") {
+			if (isSelfContainedTag(token.name, token.selfClosing)) continue;
+			stack.push(token.name);
+			continue;
+		}
+		closeMatchingTag(stack, token.name);
+	}
+	return stack;
+}
+function isSelfContainedTag(tagName, selfClosing) {
+	return selfClosing || VOID_HTML_TAG_NAMES.has(tagName.toLowerCase());
+}
+function closeMatchingTag(stack, tagName) {
+	for (let index = stack.length - 1; index >= 0; index--) {
+		if (stack[index] !== tagName) continue;
+		stack.splice(index);
+		return;
+	}
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function sortLongestPlaceholderFirst(placeholders) {
+	return [...placeholders].sort((left, right) => right.placeholder.length - left.placeholder.length);
+}
+function findMdxInlineCodeEnd(line, startIndex) {
+	for (let index = startIndex; index < line.length; index++) if (line[index] === "`") return index;
+	return -1;
+}
+function countRepeatedChar(line, startIndex, char) {
+	let count = 0;
+	while (line[startIndex + count] === char) count++;
+	return count;
+}
+function findRawTextElementEnd(source, startIndex) {
+	if (source[startIndex] !== "<" || source[startIndex + 1] === "/") return;
+	const tagEnd = findTagEnd(source, startIndex + 1);
+	if (tagEnd === -1) return void 0;
+	const openingTag = source.slice(startIndex, tagEnd + 1);
+	const tagName = /^<\s*(script|style)\b/i.exec(openingTag)?.[1];
+	if (!tagName) return void 0;
+	const closingTagMatch = new RegExp(`<\\/\\s*${escapeRegExp(tagName)}\\s*>`, "i").exec(source.slice(tagEnd + 1));
+	if (!closingTagMatch) return void 0;
+	return tagEnd + 1 + closingTagMatch.index + closingTagMatch[0].length;
+}
+
+//#endregion
+//#region packages/ts-format/src/templates.ts
+const SUPPORTED_TEMPLATE_TAG_NAMES = ["html", "svg"];
+async function buildTemplateFormattingEdits(document, request = {}) {
+	const templates = getSupportedTaggedTemplates(document).filter((template) => request.onlyWithinRange ? intersects(template.contentRange, request.onlyWithinRange) : true);
+	if (templates.length === 0) return [];
+	const edits = [];
+	for (const template of templates) {
+		const formatted = await formatTaggedTemplate(document, template);
+		if (!formatted || formatted === template.content) continue;
+		edits.push({
+			...template.contentRange,
+			newText: document.preserveEol(formatted)
+		});
+	}
+	return edits;
+}
+function getSupportedTaggedTemplates(document) {
+	const sourceText = document.text;
+	const sourceFile = ts.createSourceFile(document.filePath, sourceText, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+	const templates = [];
+	visitNode(sourceFile);
+	return templates;
+	function visitNode(node) {
+		if (ts.isTaggedTemplateExpression(node)) {
+			const template = createSupportedTaggedTemplate(node, sourceFile);
+			if (template) {
+				templates.push(template);
+				return;
+			}
+		}
+		ts.forEachChild(node, visitNode);
+	}
+}
+function createSupportedTaggedTemplate(node, sourceFile) {
+	const tagName = getSupportedTemplateTagName(node.tag.getText(sourceFile));
+	if (!tagName) return void 0;
+	const template = node.template;
+	if (isLikelyPrematureRawBacktickClose(sourceFile.text, template)) return;
+	const innerStart = template.getStart(sourceFile) + 1;
+	const innerEnd = template.getEnd() - 1;
+	if (innerEnd < innerStart) return void 0;
+	const contentRange = {
+		start: innerStart,
+		end: innerEnd
+	};
+	if (ts.isNoSubstitutionTemplateLiteral(template)) {
+		const content = sourceFile.text.slice(innerStart, innerEnd);
+		return {
+			content,
+			contentRange,
+			expressions: [],
+			interpolationRanges: [],
+			placeholderContent: content,
+			tagName
+		};
+	}
+	const expressions = [];
+	const interpolationRanges = [];
+	let placeholderContent = sliceTemplateHeadContent(template.head, sourceFile);
+	let currentContentOffset = placeholderContent.length;
+	template.templateSpans.forEach((span, index) => {
+		const placeholder = `PURESTACK_EXPR_${index}_${tagName.toUpperCase()}`;
+		const interpolationEnd = span.literal.getStart(sourceFile) - innerStart + 1;
+		expressions.push({
+			placeholder,
+			source: sourceFile.text.slice(span.expression.getStart(sourceFile), span.expression.getEnd())
+		});
+		interpolationRanges.push({
+			start: currentContentOffset,
+			end: interpolationEnd
+		});
+		placeholderContent += placeholder;
+		const literalContent = sliceTemplateSpanLiteralContent(span.literal, sourceFile);
+		placeholderContent += literalContent;
+		currentContentOffset = interpolationEnd + literalContent.length;
+	});
+	return {
+		content: sourceFile.text.slice(innerStart, innerEnd),
+		contentRange,
+		expressions,
+		interpolationRanges,
+		placeholderContent,
+		tagName
+	};
+}
+function getSupportedTemplateTagName(tagText) {
+	const normalizedTag = tagText.trim();
+	for (const tagName of SUPPORTED_TEMPLATE_TAG_NAMES) if (normalizedTag === tagName || normalizedTag.endsWith(`.${tagName}`)) return tagName;
+}
+function isLikelyPrematureRawBacktickClose(sourceText, template) {
+	return sourceText.startsWith("``", template.getEnd());
+}
+function sliceTemplateHeadContent(head, sourceFile) {
+	return sourceFile.text.slice(head.getStart(sourceFile) + 1, head.getEnd() - 2);
+}
+function sliceTemplateSpanLiteralContent(literal, sourceFile) {
+	const endOffset = ts.isTemplateTail(literal) ? 1 : 2;
+	return sourceFile.text.slice(literal.getStart(sourceFile) + 1, literal.getEnd() - endOffset);
+}
+async function formatTaggedTemplate(document, template) {
+	const formattingOptions = document.options;
+	const source = template.placeholderContent.trim();
+	const { expressions: regorExpressions, placeholderContent } = maskRegorExpressions(source);
+	if (!placeholderContent.includes("<")) return void 0;
+	let formatted;
+	try {
+		formatted = await formatHtmlFragment(placeholderContent, formattingOptions);
+	} catch (error) {
+		document.report(template.contentRange, error);
+		return;
+	}
+	const restoredTemplateExpressions = restoreTemplateExpressions(normalizeSelfClosingTagSpacing(formatted.trim()), template.expressions);
+	return restoreRegorExpressions(restoredTemplateExpressions, regorExpressions);
+}
+function restoreTemplateExpressions(formatted, expressions) {
+	let restored = formatted;
+	for (const expression of expressions) restored = restored.split(expression.placeholder).join(`\${${expression.source}}`);
+	return restored;
+}
+
+//#endregion
+//#region packages/ts-format/src/index.ts
+/** Formats only component markup and html/svg tagged template contents. */
+async function formatSource(text, options = {}) {
+	const source = new SourceText(text, options);
+	const edits = await ((options.language ?? (/\.[cm]?tsx?$/i.test(source.filePath) ? "typescript" : "mdx")) === "typescript" ? buildTemplateFormattingEdits(source, options) : buildMdxFormattingEdits(source, options));
+	const code = applySourceEdits(text, edits);
+	return {
+		code,
+		edits,
+		diagnostics: source.diagnostics,
+		changed: code !== text
+	};
+}
+
+//#endregion
+//#region packages/ts-format/src/files.ts
+const exec = promisify(execFile);
+const caseInsensitivePaths = process.platform === "win32" || process.platform === "darwin";
+const comparablePath = (value) => caseInsensitivePaths ? value.toLowerCase() : value;
+const extensions = /\.(?:[cm]?ts|mdx|rmdx)$/i;
+const ignoredDirectories = /* @__PURE__ */ new Set([
+	".git",
+	".yarn",
+	".tmp",
+	".ts-ssg",
+	".cache",
+	"node_modules",
+	"dist",
+	"out",
+	"coverage",
+	"artifacts"
+]);
+/** Discover source files, honor Git ignores in repositories, and collect all failures. */
+async function formatFiles(inputs = ["."], options = {}) {
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	const excluded = (options.exclude ?? []).map((entry) => comparablePath(path.resolve(cwd, entry)));
+	const files = /* @__PURE__ */ new Set();
+	const errors = [];
+	const changed = [];
+	function isExcluded(file) {
+		const comparable = comparablePath(file);
+		return path.relative(cwd, file).split(path.sep).some((part) => ignoredDirectories.has(comparablePath(part))) || excluded.some((entry) => comparable === entry || comparable.startsWith(`${entry}${path.sep}`));
+	}
+	function addFile(file) {
+		if (extensions.test(file) && !isExcluded(file)) files.add(file);
+	}
+	async function walk(directory) {
+		if (isExcluded(directory)) return;
+		for (const entry of await readdir(directory, { withFileTypes: true })) {
+			const file = path.join(directory, entry.name);
+			if (entry.isSymbolicLink()) continue;
+			if (entry.isDirectory()) await walk(file);
+			else if (entry.isFile()) addFile(file);
+		}
+	}
+	for (const input of inputs) {
+		const target = path.resolve(cwd, input);
+		try {
+			const entry = await lstat(target);
+			if (entry.isSymbolicLink()) continue;
+			if (entry.isFile()) {
+				addFile(target);
+				continue;
+			}
+			if (!entry.isDirectory() || isExcluded(target)) continue;
+			let gitFiles;
+			try {
+				const { stdout } = await exec("git", [
+					"-C",
+					target,
+					"ls-files",
+					"--cached",
+					"--others",
+					"--exclude-standard",
+					"-z",
+					"--",
+					"."
+				], { maxBuffer: 33554432 });
+				gitFiles = stdout.split("\0").filter(Boolean).map((file) => path.resolve(target, file));
+			} catch {}
+			if (gitFiles) for (const file of gitFiles) addFile(file);
+			else await walk(target);
+		} catch (error) {
+			errors.push({
+				filePath: target,
+				message: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	for (const filePath of [...files].sort()) try {
+		const entry = await lstat(filePath).catch(() => void 0);
+		if (!entry?.isFile() || entry.isSymbolicLink()) continue;
+		const text = await readFile(filePath, "utf8");
+		const result = await formatSource(text, {
+			...options,
+			filePath
+		});
+		if (result.diagnostics.length) {
+			for (const diagnostic of result.diagnostics) errors.push({
+				filePath,
+				message: diagnostic.message
+			});
+			continue;
+		}
+		if (!result.changed) continue;
+		if (options.write) {
+			if (await readFile(filePath, "utf8") !== text) throw new Error("File changed during formatting; skipped to preserve your edits.");
+			await writeFile(filePath, result.code, "utf8");
+		}
+		changed.push(filePath);
+	} catch (error) {
+		errors.push({
+			filePath,
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return {
+		checked: files.size,
+		changed,
+		errors
+	};
+}
+
+//#endregion
+export { formatFiles };
+//# sourceMappingURL=files.mjs.map