@thxgg/steward 0.1.25 → 0.1.26

package/.output/server/node_modules/@pierre/diffs/dist/utils/parsePatchFiles.js

@@ -0,0 +1,211 @@
+import { ALTERNATE_FILE_NAMES_GIT, COMMIT_METADATA_SPLIT, FILENAME_HEADER_REGEX, FILENAME_HEADER_REGEX_GIT, FILE_CONTEXT_BLOB, FILE_MODE_FROM_INDEX, GIT_DIFF_FILE_BREAK_REGEX, HUNK_HEADER, SPLIT_WITH_NEWLINES, UNIFIED_DIFF_FILE_BREAK_REGEX } from "../constants.js";
+import { cleanLastNewline } from "./cleanLastNewline.js";
+import { parseLineType } from "./parseLineType.js";
+
+//#region src/utils/parsePatchFiles.ts
+function processPatch(data, cacheKeyPrefix) {
+	const isGitDiff = GIT_DIFF_FILE_BREAK_REGEX.test(data);
+	const rawFiles = data.split(isGitDiff ? GIT_DIFF_FILE_BREAK_REGEX : UNIFIED_DIFF_FILE_BREAK_REGEX);
+	let patchMetadata;
+	const files = [];
+	let currentFile;
+	for (const file of rawFiles) {
+		if (isGitDiff && !GIT_DIFF_FILE_BREAK_REGEX.test(file)) {
+			if (patchMetadata == null) patchMetadata = file;
+			else console.error("parsePatchContent: unknown file blob:", file);
+			continue;
+		} else if (!isGitDiff && !UNIFIED_DIFF_FILE_BREAK_REGEX.test(file)) {
+			if (patchMetadata == null) patchMetadata = file;
+			else console.error("parsePatchContent: unknown file blob:", file);
+			continue;
+		}
+		let lastHunkEnd = 0;
+		const hunks = file.split(FILE_CONTEXT_BLOB);
+		currentFile = void 0;
+		for (const hunk of hunks) {
+			const lines = hunk.split(SPLIT_WITH_NEWLINES);
+			const firstLine = lines.shift();
+			if (firstLine == null) {
+				console.error("parsePatchContent: invalid hunk", hunk);
+				continue;
+			}
+			const match = firstLine.match(HUNK_HEADER);
+			const hunkContent = [];
+			let additionLines = 0;
+			let deletionLines = 0;
+			if (match == null || currentFile == null) {
+				if (currentFile != null) {
+					console.error("parsePatchContent: Invalid hunk", hunk);
+					continue;
+				}
+				currentFile = {
+					name: "",
+					prevName: void 0,
+					type: "change",
+					hunks: [],
+					splitLineCount: 0,
+					unifiedLineCount: 0,
+					cacheKey: cacheKeyPrefix != null ? `${cacheKeyPrefix}-${files.length}` : void 0
+				};
+				lines.unshift(firstLine);
+				for (const line of lines) {
+					const filenameMatch = line.match(isGitDiff ? FILENAME_HEADER_REGEX_GIT : FILENAME_HEADER_REGEX);
+					if (line.startsWith("diff --git")) {
+						const [, , prevName, , name] = line.trim().match(ALTERNATE_FILE_NAMES_GIT) ?? [];
+						currentFile.name = name.trim();
+						if (prevName !== name) currentFile.prevName = prevName.trim();
+					} else if (filenameMatch != null) {
+						const [, type, fileName] = filenameMatch;
+						if (type === "---" && fileName !== "/dev/null") {
+							currentFile.prevName = fileName.trim();
+							currentFile.name = fileName.trim();
+						} else if (type === "+++" && fileName !== "/dev/null") currentFile.name = fileName.trim();
+					} else if (isGitDiff) {
+						if (line.startsWith("new mode ")) currentFile.mode = line.replace("new mode", "").trim();
+						if (line.startsWith("old mode ")) currentFile.oldMode = line.replace("old mode", "").trim();
+						if (line.startsWith("new file mode")) {
+							currentFile.type = "new";
+							currentFile.mode = line.replace("new file mode", "").trim();
+						}
+						if (line.startsWith("deleted file mode")) {
+							currentFile.type = "deleted";
+							currentFile.mode = line.replace("deleted file mode", "").trim();
+						}
+						if (line.startsWith("similarity index")) if (line.startsWith("similarity index 100%")) currentFile.type = "rename-pure";
+						else currentFile.type = "rename-changed";
+						if (line.startsWith("index ")) {
+							const [, mode] = line.trim().match(FILE_MODE_FROM_INDEX) ?? [];
+							if (mode != null) currentFile.mode = mode;
+						}
+						if (line.startsWith("rename from ")) currentFile.prevName = line.replace("rename from ", "");
+						if (line.startsWith("rename to ")) currentFile.name = line.replace("rename to ", "").trim();
+					}
+				}
+				continue;
+			} else {
+				let currentContent;
+				let lastLineType;
+				while (lines.length > 0 && (lines[lines.length - 1] === "\n" || lines[lines.length - 1] === "")) lines.pop();
+				for (const rawLine of lines) {
+					const parsedLine = parseLineType(rawLine);
+					if (parsedLine == null) continue;
+					const { type, line } = parsedLine;
+					if (type === "addition") {
+						if (currentContent == null || currentContent.type !== "change") {
+							currentContent = createContentGroup("change");
+							hunkContent.push(currentContent);
+						}
+						currentContent.additions.push(line);
+						additionLines++;
+						lastLineType = "addition";
+					} else if (type === "deletion") {
+						if (currentContent == null || currentContent.type !== "change") {
+							currentContent = createContentGroup("change");
+							hunkContent.push(currentContent);
+						}
+						currentContent.deletions.push(line);
+						deletionLines++;
+						lastLineType = "deletion";
+					} else if (type === "context") {
+						if (currentContent == null || currentContent.type !== "context") {
+							currentContent = createContentGroup("context");
+							hunkContent.push(currentContent);
+						}
+						currentContent.lines.push(line);
+						lastLineType = "context";
+					} else if (type === "metadata" && currentContent != null) {
+						if (currentContent.type === "context") currentContent.noEOFCR = true;
+						else if (lastLineType === "deletion") {
+							currentContent.noEOFCRDeletions = true;
+							const lastIndex = currentContent.deletions.length - 1;
+							if (lastIndex >= 0) currentContent.deletions[lastIndex] = cleanLastNewline(currentContent.deletions[lastIndex]);
+						} else if (lastLineType === "addition") {
+							currentContent.noEOFCRAdditions = true;
+							const lastIndex = currentContent.additions.length - 1;
+							if (lastIndex >= 0) currentContent.additions[lastIndex] = cleanLastNewline(currentContent.additions[lastIndex]);
+						}
+					}
+				}
+			}
+			const hunkData = {
+				collapsedBefore: 0,
+				splitLineCount: 0,
+				splitLineStart: 0,
+				unifiedLineCount: 0,
+				unifiedLineStart: 0,
+				additionCount: parseInt(match[4] ?? "1"),
+				additionStart: parseInt(match[3]),
+				additionLines,
+				deletionCount: parseInt(match[2] ?? "1"),
+				deletionStart: parseInt(match[1]),
+				deletionLines,
+				hunkContent,
+				hunkContext: match[5],
+				hunkSpecs: firstLine
+			};
+			if (isNaN(hunkData.additionCount) || isNaN(hunkData.deletionCount) || isNaN(hunkData.additionStart) || isNaN(hunkData.deletionStart)) {
+				console.error("parsePatchContent: invalid hunk metadata", hunkData);
+				continue;
+			}
+			hunkData.collapsedBefore = Math.max(hunkData.additionStart - 1 - lastHunkEnd, 0);
+			currentFile.hunks.push(hunkData);
+			lastHunkEnd = hunkData.additionStart + hunkData.additionCount - 1;
+			for (const content of hunkContent) if (content.type === "context") {
+				hunkData.splitLineCount += content.lines.length;
+				hunkData.unifiedLineCount += content.lines.length;
+			} else {
+				hunkData.splitLineCount += Math.max(content.additions.length, content.deletions.length);
+				hunkData.unifiedLineCount += content.deletions.length + content.additions.length;
+			}
+			hunkData.splitLineStart = currentFile.splitLineCount;
+			hunkData.unifiedLineStart = currentFile.unifiedLineCount;
+			currentFile.splitLineCount += hunkData.splitLineCount;
+			currentFile.unifiedLineCount += hunkData.unifiedLineCount;
+		}
+		if (currentFile != null) {
+			if (!isGitDiff && currentFile.prevName != null && currentFile.name !== currentFile.prevName) if (currentFile.hunks.length > 0) currentFile.type = "rename-changed";
+			else currentFile.type = "rename-pure";
+			if (currentFile.type !== "rename-pure" && currentFile.type !== "rename-changed") currentFile.prevName = void 0;
+			files.push(currentFile);
+		}
+	}
+	return {
+		patchMetadata,
+		files
+	};
+}
+/**
+* Parses a patch file string into an array of parsed patches.
+*
+* @param data - The raw patch file content (supports multi-commit patches)
+* @param cacheKeyPrefix - Optional prefix for generating cache keys. When provided,
+*   each file in the patch will get a cache key in the format `prefix-patchIndex-fileIndex`.
+*   This enables caching of rendered diff results in the worker pool.
+*/
+function parsePatchFiles(data, cacheKeyPrefix) {
+	const patches = [];
+	for (const patch of data.split(COMMIT_METADATA_SPLIT)) try {
+		patches.push(processPatch(patch, cacheKeyPrefix != null ? `${cacheKeyPrefix}-${patches.length}` : void 0));
+	} catch (error) {
+		console.error(error);
+	}
+	return patches;
+}
+function createContentGroup(type) {
+	if (type === "change") return {
+		type: "change",
+		additions: [],
+		deletions: [],
+		noEOFCRAdditions: false,
+		noEOFCRDeletions: false
+	};
+	return {
+		type: "context",
+		lines: [],
+		noEOFCR: false
+	};
+}
+
+//#endregion
+export { parsePatchFiles };
+//# sourceMappingURL=parsePatchFiles.js.map

package/.output/server/node_modules/@pierre/diffs/dist/utils/prerenderHTMLIfNecessary.js

@@ -0,0 +1,10 @@
+//#region src/utils/prerenderHTMLIfNecessary.ts
+function prerenderHTMLIfNecessary(element, html) {
+	if (html == null) return;
+	const shadowRoot = element.shadowRoot ?? element.attachShadow({ mode: "open" });
+	if (shadowRoot.innerHTML === "") shadowRoot.innerHTML = html;
+}
+
+//#endregion
+export { prerenderHTMLIfNecessary };
+//# sourceMappingURL=prerenderHTMLIfNecessary.js.map

package/.output/server/node_modules/@pierre/diffs/dist/utils/processLine.js

@@ -0,0 +1,42 @@
+import { createHastElement, createTextNodeElement } from "./hast_utils.js";
+
+//#region src/utils/processLine.ts
+function processLine(node, line, state) {
+	const lineInfo = typeof state.lineInfo === "function" ? state.lineInfo(line) : state.lineInfo[line];
+	if (lineInfo == null) {
+		console.error({
+			node,
+			line,
+			state
+		});
+		throw new Error(`processLine: line ${line}, contains no state.lineInfo`);
+	}
+	node.tagName = "span";
+	node.properties["data-column-content"] = "";
+	if (node.children.length === 0) node.children.push(createTextNodeElement("\n"));
+	return createHastElement({
+		tagName: "div",
+		children: [createHastElement({
+			tagName: "span",
+			children: [createHastElement({
+				tagName: "span",
+				children: [{
+					type: "text",
+					value: `${lineInfo.lineNumber}`
+				}],
+				properties: { "data-line-number-content": "" }
+			})],
+			properties: { "data-column-number": "" }
+		}), node],
+		properties: {
+			"data-line": lineInfo.lineNumber,
+			"data-alt-line": lineInfo.altLineNumber,
+			"data-line-type": lineInfo.type,
+			"data-line-index": lineInfo.lineIndex
+		}
+	});
+}
+
+//#endregion
+export { processLine };
+//# sourceMappingURL=processLine.js.map

package/.output/server/node_modules/@pierre/diffs/dist/utils/renderDiffWithHighlighter.js

@@ -0,0 +1,339 @@
+import { DEFAULT_THEMES } from "../constants.js";
+import { getFiletypeFromFileName } from "./getFiletypeFromFileName.js";
+import { cleanLastNewline } from "./cleanLastNewline.js";
+import { createTransformerWithState } from "./createTransformerWithState.js";
+import { formatCSSVariablePrefix } from "./formatCSSVariablePrefix.js";
+import { getHighlighterThemeStyles } from "./getHighlighterThemeStyles.js";
+import { getLineNodes } from "./getLineNodes.js";
+import { createDiffSpanDecoration, pushOrJoinSpan } from "./parseDiffDecorations.js";
+import { diffChars, diffWordsWithSpace } from "diff";
+
+//#region src/utils/renderDiffWithHighlighter.ts
+function renderDiffWithHighlighter(diff, highlighter, options, forcePlainText = false) {
+	const baseThemeType = (() => {
+		const theme = options.theme ?? DEFAULT_THEMES;
+		if (typeof theme === "string") return highlighter.getTheme(theme).type;
+	})();
+	const themeStyles = getHighlighterThemeStyles({
+		theme: options.theme,
+		highlighter
+	});
+	if (diff.newLines != null && diff.oldLines != null) {
+		const { oldContent, newContent, oldInfo, newInfo, oldDecorations, newDecorations } = processLines({
+			hunks: diff.hunks,
+			oldLines: diff.oldLines,
+			newLines: diff.newLines,
+			lineDiffType: options.lineDiffType
+		});
+		return {
+			code: renderTwoFiles({
+				oldFile: {
+					name: diff.prevName ?? diff.name,
+					contents: oldContent
+				},
+				oldInfo,
+				oldDecorations,
+				newFile: {
+					name: diff.name,
+					contents: newContent
+				},
+				newInfo,
+				newDecorations,
+				highlighter,
+				options,
+				languageOverride: forcePlainText ? "text" : diff.lang
+			}),
+			themeStyles,
+			baseThemeType
+		};
+	}
+	const hunks = [];
+	let splitLineIndex = 0;
+	let unifiedLineIndex = 0;
+	for (const hunk of diff.hunks) {
+		const { oldContent, newContent, oldInfo, newInfo, oldDecorations, newDecorations, splitLineIndex: newSplitLineIndex, unifiedLineIndex: newUnifiedLineIndex } = processLines({
+			hunks: [hunk],
+			splitLineIndex,
+			unifiedLineIndex,
+			lineDiffType: options.lineDiffType
+		});
+		const oldFile = {
+			name: diff.prevName ?? diff.name,
+			contents: oldContent
+		};
+		const newFile = {
+			name: diff.name,
+			contents: newContent
+		};
+		hunks.push(renderTwoFiles({
+			oldFile,
+			oldInfo,
+			oldDecorations,
+			newFile,
+			newInfo,
+			newDecorations,
+			highlighter,
+			options,
+			languageOverride: forcePlainText ? "text" : diff.lang
+		}));
+		splitLineIndex = newSplitLineIndex;
+		unifiedLineIndex = newUnifiedLineIndex;
+	}
+	return {
+		code: (() => {
+			if (hunks.length <= 1) {
+				const hunk = hunks[0] ?? {
+					oldLines: [],
+					newLines: []
+				};
+				if (hunk.newLines.length === 0 || hunk.oldLines.length === 0) return hunk;
+			}
+			return { hunks };
+		})(),
+		themeStyles,
+		baseThemeType
+	};
+}
+function computeLineDiffDecorations({ oldLine, newLine, oldLineIndex, newLineIndex, oldDecorations, newDecorations, lineDiffType }) {
+	if (oldLine == null || newLine == null || lineDiffType === "none") return;
+	oldLine = cleanLastNewline(oldLine);
+	newLine = cleanLastNewline(newLine);
+	const lineDiff = lineDiffType === "char" ? diffChars(oldLine, newLine) : diffWordsWithSpace(oldLine, newLine);
+	const deletionSpans = [];
+	const additionSpans = [];
+	const enableJoin = lineDiffType === "word-alt";
+	for (const item of lineDiff) {
+		const isLastItem = item === lineDiff[lineDiff.length - 1];
+		if (!item.added && !item.removed) {
+			pushOrJoinSpan({
+				item,
+				arr: deletionSpans,
+				enableJoin,
+				isNeutral: true,
+				isLastItem
+			});
+			pushOrJoinSpan({
+				item,
+				arr: additionSpans,
+				enableJoin,
+				isNeutral: true,
+				isLastItem
+			});
+		} else if (item.removed) pushOrJoinSpan({
+			item,
+			arr: deletionSpans,
+			enableJoin,
+			isLastItem
+		});
+		else pushOrJoinSpan({
+			item,
+			arr: additionSpans,
+			enableJoin,
+			isLastItem
+		});
+	}
+	let spanIndex = 0;
+	for (const span of deletionSpans) {
+		if (span[0] === 1) oldDecorations.push(createDiffSpanDecoration({
+			line: oldLineIndex - 1,
+			spanStart: spanIndex,
+			spanLength: span[1].length
+		}));
+		spanIndex += span[1].length;
+	}
+	spanIndex = 0;
+	for (const span of additionSpans) {
+		if (span[0] === 1) newDecorations.push(createDiffSpanDecoration({
+			line: newLineIndex - 1,
+			spanStart: spanIndex,
+			spanLength: span[1].length
+		}));
+		spanIndex += span[1].length;
+	}
+}
+function processLines({ hunks, oldLines, newLines, splitLineIndex = 0, unifiedLineIndex = 0, lineDiffType }) {
+	const oldInfo = {};
+	const newInfo = {};
+	const oldDecorations = [];
+	const newDecorations = [];
+	let newLineIndex = 1;
+	let oldLineIndex = 1;
+	let newLineNumber = 1;
+	let oldLineNumber = 1;
+	let oldContent = "";
+	let newContent = "";
+	for (const hunk of hunks) {
+		while (oldLines != null && newLines != null && newLineIndex < hunk.additionStart && oldLineIndex < hunk.deletionStart) {
+			oldInfo[oldLineIndex] = {
+				type: "context-expanded",
+				lineNumber: oldLineNumber,
+				altLineNumber: newLineNumber,
+				lineIndex: `${unifiedLineIndex},${splitLineIndex}`
+			};
+			newInfo[newLineIndex] = {
+				type: "context-expanded",
+				lineNumber: newLineNumber,
+				altLineNumber: oldLineNumber,
+				lineIndex: `${unifiedLineIndex},${splitLineIndex}`
+			};
+			oldContent += oldLines[oldLineIndex - 1];
+			newContent += newLines[newLineIndex - 1];
+			oldLineIndex++;
+			newLineIndex++;
+			oldLineNumber++;
+			newLineNumber++;
+			splitLineIndex++;
+			unifiedLineIndex++;
+		}
+		oldLineNumber = hunk.deletionStart;
+		newLineNumber = hunk.additionStart;
+		for (const hunkContent of hunk.hunkContent) if (hunkContent.type === "context") for (const line of hunkContent.lines) {
+			oldInfo[oldLineIndex] = {
+				type: "context",
+				lineNumber: oldLineNumber,
+				altLineNumber: newLineNumber,
+				lineIndex: `${unifiedLineIndex},${splitLineIndex}`
+			};
+			newInfo[newLineIndex] = {
+				type: "context",
+				lineNumber: newLineNumber,
+				altLineNumber: oldLineNumber,
+				lineIndex: `${unifiedLineIndex},${splitLineIndex}`
+			};
+			oldContent += line;
+			newContent += line;
+			oldLineIndex++;
+			newLineIndex++;
+			newLineNumber++;
+			oldLineNumber++;
+			splitLineIndex++;
+			unifiedLineIndex++;
+		}
+		else {
+			const len = Math.max(hunkContent.additions.length, hunkContent.deletions.length);
+			let i = 0;
+			let _unifiedLineIndex = unifiedLineIndex;
+			while (i < len) {
+				const oldLine = hunkContent.deletions[i];
+				const newLine = hunkContent.additions[i];
+				computeLineDiffDecorations({
+					newLine,
+					oldLine,
+					oldLineIndex,
+					newLineIndex,
+					oldDecorations,
+					newDecorations,
+					lineDiffType
+				});
+				if (oldLine != null) {
+					oldInfo[oldLineIndex] = {
+						type: "change-deletion",
+						lineNumber: oldLineNumber,
+						lineIndex: `${_unifiedLineIndex},${splitLineIndex}`
+					};
+					oldContent += oldLine;
+					oldLineIndex++;
+					oldLineNumber++;
+				}
+				if (newLine != null) {
+					newInfo[newLineIndex] = {
+						type: "change-addition",
+						lineNumber: newLineNumber,
+						lineIndex: `${_unifiedLineIndex + hunkContent.deletions.length},${splitLineIndex}`
+					};
+					newContent += newLine;
+					newLineIndex++;
+					newLineNumber++;
+				}
+				splitLineIndex++;
+				_unifiedLineIndex++;
+				i++;
+			}
+			unifiedLineIndex += hunkContent.additions.length + hunkContent.deletions.length;
+		}
+		if (oldLines == null || newLines == null || hunk !== hunks[hunks.length - 1]) continue;
+		while (oldLineIndex <= oldLines.length || newLineIndex <= oldLines.length) {
+			const oldLine = oldLines[oldLineIndex - 1];
+			const newLine = newLines[newLineIndex - 1];
+			if (oldLine == null && newLine == null) break;
+			if (oldLine != null) {
+				oldInfo[oldLineIndex] = {
+					type: "context-expanded",
+					lineNumber: oldLineNumber,
+					altLineNumber: newLineNumber,
+					lineIndex: `${unifiedLineIndex},${splitLineIndex}`
+				};
+				oldContent += oldLine;
+				oldLineIndex++;
+				oldLineNumber++;
+			}
+			if (newLine != null) {
+				newInfo[newLineIndex] = {
+					type: "context-expanded",
+					lineNumber: newLineNumber,
+					altLineNumber: oldLineNumber,
+					lineIndex: `${unifiedLineIndex},${splitLineIndex}`
+				};
+				newContent += newLine;
+				newLineIndex++;
+				newLineNumber++;
+			}
+			splitLineIndex++;
+			unifiedLineIndex++;
+		}
+	}
+	return {
+		oldContent,
+		newContent,
+		oldInfo,
+		newInfo,
+		oldDecorations,
+		newDecorations,
+		splitLineIndex,
+		unifiedLineIndex
+	};
+}
+function renderTwoFiles({ oldFile, newFile, oldInfo, newInfo, highlighter, oldDecorations, newDecorations, languageOverride, options: { theme: themeOrThemes = DEFAULT_THEMES,...options } }) {
+	const oldLang = languageOverride ?? getFiletypeFromFileName(oldFile.name);
+	const newLang = languageOverride ?? getFiletypeFromFileName(newFile.name);
+	const { state, transformers } = createTransformerWithState();
+	const hastConfig = (() => {
+		return typeof themeOrThemes === "string" ? {
+			...options,
+			lang: "text",
+			theme: themeOrThemes,
+			transformers,
+			decorations: void 0,
+			defaultColor: false,
+			cssVariablePrefix: formatCSSVariablePrefix("token")
+		} : {
+			...options,
+			lang: "text",
+			themes: themeOrThemes,
+			transformers,
+			decorations: void 0,
+			defaultColor: false,
+			cssVariablePrefix: formatCSSVariablePrefix("token")
+		};
+	})();
+	return {
+		oldLines: (() => {
+			if (oldFile.contents === "") return [];
+			hastConfig.lang = oldLang;
+			state.lineInfo = oldInfo;
+			hastConfig.decorations = oldDecorations;
+			return getLineNodes(highlighter.codeToHast(cleanLastNewline(oldFile.contents), hastConfig));
+		})(),
+		newLines: (() => {
+			if (newFile.contents === "") return [];
+			hastConfig.lang = newLang;
+			hastConfig.decorations = newDecorations;
+			state.lineInfo = newInfo;
+			return getLineNodes(highlighter.codeToHast(cleanLastNewline(newFile.contents), hastConfig));
+		})()
+	};
+}
+
+//#endregion
+export { renderDiffWithHighlighter };
+//# sourceMappingURL=renderDiffWithHighlighter.js.map

package/.output/server/node_modules/@pierre/diffs/dist/utils/renderFileWithHighlighter.js

@@ -0,0 +1,52 @@
+import { DEFAULT_THEMES } from "../constants.js";
+import { getFiletypeFromFileName } from "./getFiletypeFromFileName.js";
+import { cleanLastNewline } from "./cleanLastNewline.js";
+import { createTransformerWithState } from "./createTransformerWithState.js";
+import { formatCSSVariablePrefix } from "./formatCSSVariablePrefix.js";
+import { getHighlighterThemeStyles } from "./getHighlighterThemeStyles.js";
+import { getLineNodes } from "./getLineNodes.js";
+
+//#region src/utils/renderFileWithHighlighter.ts
+function renderFileWithHighlighter(file, highlighter, { theme = DEFAULT_THEMES, tokenizeMaxLineLength }, forcePlainText = false) {
+	const { state, transformers } = createTransformerWithState();
+	const lang = forcePlainText ? "text" : file.lang ?? getFiletypeFromFileName(file.name);
+	const baseThemeType = (() => {
+		if (typeof theme === "string") return highlighter.getTheme(theme).type;
+	})();
+	const themeStyles = getHighlighterThemeStyles({
+		theme,
+		highlighter
+	});
+	state.lineInfo = (shikiLineNumber) => ({
+		type: "context",
+		lineIndex: shikiLineNumber - 1,
+		lineNumber: shikiLineNumber
+	});
+	const hastConfig = (() => {
+		if (typeof theme === "string") return {
+			lang,
+			theme,
+			transformers,
+			defaultColor: false,
+			cssVariablePrefix: formatCSSVariablePrefix("token"),
+			tokenizeMaxLineLength
+		};
+		return {
+			lang,
+			themes: theme,
+			transformers,
+			defaultColor: false,
+			cssVariablePrefix: formatCSSVariablePrefix("token"),
+			tokenizeMaxLineLength
+		};
+	})();
+	return {
+		code: getLineNodes(highlighter.codeToHast(cleanLastNewline(file.contents), hastConfig)),
+		themeStyles,
+		baseThemeType
+	};
+}
+
+//#endregion
+export { renderFileWithHighlighter };
+//# sourceMappingURL=renderFileWithHighlighter.js.map

package/.output/server/node_modules/@pierre/diffs/dist/utils/setLanguageOverride.js

@@ -0,0 +1,11 @@
+//#region src/utils/setLanguageOverride.ts
+function setLanguageOverride(fileOrDiff, lang) {
+	return {
+		...fileOrDiff,
+		lang
+	};
+}
+
+//#endregion
+export { setLanguageOverride };
+//# sourceMappingURL=setLanguageOverride.js.map

package/.output/server/node_modules/@pierre/diffs/dist/utils/setWrapperNodeProps.js

@@ -0,0 +1,29 @@
+//#region src/utils/setWrapperNodeProps.ts
+function setPreNodeProperties({ diffIndicators, disableBackground, disableLineNumbers, overflow, pre, split, themeStyles, themeType, totalLines }) {
+	if (themeType === "system") delete pre.dataset.themeType;
+	else pre.dataset.themeType = themeType;
+	switch (diffIndicators) {
+		case "bars":
+		case "classic":
+			pre.dataset.indicators = diffIndicators;
+			break;
+		case "none":
+			delete pre.dataset.indicators;
+			break;
+	}
+	if (disableLineNumbers) pre.dataset.disableLineNumbers = "";
+	else delete pre.dataset.disableLineNumbers;
+	if (disableBackground) delete pre.dataset.background;
+	else pre.dataset.background = "";
+	pre.dataset.type = split ? "split" : "file";
+	pre.dataset.overflow = overflow;
+	pre.dataset.diffs = "";
+	pre.tabIndex = 0;
+	pre.style = themeStyles;
+	pre.style.setProperty("--diffs-min-number-column-width-default", `${`${totalLines}`.length}ch`);
+	return pre;
+}
+
+//#endregion
+export { setPreNodeProperties };
+//# sourceMappingURL=setWrapperNodeProps.js.map