@thxgg/steward 0.1.24 → 0.1.26

package/.output/server/node_modules/@pierre/diffs/dist/components/FileDiff.js

@@ -0,0 +1,395 @@
+import { DEFAULT_THEMES, DIFFS_TAG_NAME, HEADER_METADATA_SLOT_ID, UNSAFE_CSS_ATTRIBUTE } from "../constants.js";
+import { LineSelectionManager, pluckLineSelectionOptions } from "../managers/LineSelectionManager.js";
+import { MouseEventManager, pluckMouseEventOptions } from "../managers/MouseEventManager.js";
+import { ResizeManager } from "../managers/ResizeManager.js";
+import { getLineAnnotationName } from "../utils/getLineAnnotationName.js";
+import { SVGSpriteSheet } from "../sprite.js";
+import { areFilesEqual } from "../utils/areFilesEqual.js";
+import { createAnnotationWrapperNode } from "../utils/createAnnotationWrapperNode.js";
+import { createCodeNode } from "../utils/createCodeNode.js";
+import { createHoverContentNode } from "../utils/createHoverContentNode.js";
+import { createUnsafeCSSStyleNode } from "../utils/createUnsafeCSSStyleNode.js";
+import { wrapUnsafeCSS } from "../utils/cssWrappers.js";
+import { prerenderHTMLIfNecessary } from "../utils/prerenderHTMLIfNecessary.js";
+import { setPreNodeProperties } from "../utils/setWrapperNodeProps.js";
+import { DiffsContainerLoaded } from "./web-components.js";
+import { ScrollSyncManager } from "../managers/ScrollSyncManager.js";
+import { DiffHunksRenderer } from "../renderers/DiffHunksRenderer.js";
+import { parseDiffFromFile } from "../utils/parseDiffFromFile.js";
+import { toHtml } from "hast-util-to-html";
+
+//#region src/components/FileDiff.ts
+let instanceId = -1;
+var FileDiff = class {
+	static LoadedCustomComponent = DiffsContainerLoaded;
+	__id = ++instanceId;
+	fileContainer;
+	spriteSVG;
+	pre;
+	unsafeCSSStyle;
+	hoverContent;
+	headerElement;
+	headerMetadata;
+	customHunkElements = [];
+	errorWrapper;
+	hunksRenderer;
+	resizeManager;
+	scrollSyncManager;
+	mouseEventManager;
+	lineSelectionManager;
+	annotationElements = [];
+	lineAnnotations = [];
+	oldFile;
+	newFile;
+	fileDiff;
+	constructor(options = { theme: DEFAULT_THEMES }, workerManager, isContainerManaged = false) {
+		this.options = options;
+		this.workerManager = workerManager;
+		this.isContainerManaged = isContainerManaged;
+		this.hunksRenderer = new DiffHunksRenderer({
+			...options,
+			hunkSeparators: typeof options.hunkSeparators === "function" ? "custom" : options.hunkSeparators
+		}, this.handleHighlightRender, this.workerManager);
+		this.resizeManager = new ResizeManager();
+		this.scrollSyncManager = new ScrollSyncManager();
+		this.mouseEventManager = new MouseEventManager("diff", pluckMouseEventOptions(options, typeof options.hunkSeparators === "function" || (options.hunkSeparators ?? "line-info") === "line-info" ? this.handleExpandHunk : void 0));
+		this.lineSelectionManager = new LineSelectionManager(pluckLineSelectionOptions(options));
+		this.workerManager?.subscribeToThemeChanges(this);
+	}
+	handleHighlightRender = () => {
+		this.rerender();
+	};
+	setOptions(options) {
+		if (options == null) return;
+		this.options = options;
+		this.hunksRenderer.setOptions({
+			...this.options,
+			hunkSeparators: typeof options.hunkSeparators === "function" ? "custom" : options.hunkSeparators
+		});
+		this.mouseEventManager.setOptions(pluckMouseEventOptions(options, typeof options.hunkSeparators === "function" || (options.hunkSeparators ?? "line-info") === "line-info" ? this.handleExpandHunk : void 0));
+		this.lineSelectionManager.setOptions(pluckLineSelectionOptions(options));
+	}
+	mergeOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+	}
+	setThemeType(themeType) {
+		if ((this.options.themeType ?? "system") === themeType) return;
+		this.mergeOptions({ themeType });
+		this.hunksRenderer.setThemeType(themeType);
+		if (this.headerElement != null) if (themeType === "system") delete this.headerElement.dataset.themeType;
+		else this.headerElement.dataset.themeType = themeType;
+		if (this.pre != null) switch (themeType) {
+			case "system":
+				delete this.pre.dataset.themeType;
+				break;
+			case "light":
+			case "dark":
+				this.pre.dataset.themeType = themeType;
+				break;
+		}
+	}
+	getHoveredLine = () => {
+		return this.mouseEventManager.getHoveredLine();
+	};
+	setLineAnnotations(lineAnnotations) {
+		this.lineAnnotations = lineAnnotations;
+	}
+	setSelectedLines(range) {
+		this.lineSelectionManager.setSelection(range);
+	}
+	cleanUp() {
+		this.hunksRenderer.cleanUp();
+		this.resizeManager.cleanUp();
+		this.mouseEventManager.cleanUp();
+		this.scrollSyncManager.cleanUp();
+		this.lineSelectionManager.cleanUp();
+		this.workerManager?.unsubscribeToThemeChanges(this);
+		this.workerManager = void 0;
+		this.fileDiff = void 0;
+		this.oldFile = void 0;
+		this.newFile = void 0;
+		if (!this.isContainerManaged) this.fileContainer?.parentNode?.removeChild(this.fileContainer);
+		if (this.fileContainer?.shadowRoot != null) this.fileContainer.shadowRoot.innerHTML = "";
+		this.fileContainer = void 0;
+		this.pre = void 0;
+		this.headerElement = void 0;
+		this.errorWrapper = void 0;
+	}
+	hydrate(props) {
+		const { fileContainer, prerenderedHTML } = props;
+		prerenderHTMLIfNecessary(fileContainer, prerenderedHTML);
+		for (const element of Array.from(fileContainer.shadowRoot?.children ?? [])) {
+			if (element instanceof SVGElement) {
+				this.spriteSVG = element;
+				continue;
+			}
+			if (!(element instanceof HTMLElement)) continue;
+			if (element instanceof HTMLPreElement) {
+				this.pre = element;
+				continue;
+			}
+			if ("diffsHeader" in element.dataset) {
+				this.headerElement = element;
+				continue;
+			}
+			if (element instanceof HTMLStyleElement && element.hasAttribute(UNSAFE_CSS_ATTRIBUTE)) {
+				this.unsafeCSSStyle = element;
+				continue;
+			}
+		}
+		if (this.pre == null) this.render(props);
+		else {
+			const { lineAnnotations, oldFile, newFile, fileDiff } = props;
+			this.fileContainer = fileContainer;
+			delete this.pre.dataset.dehydrated;
+			this.lineAnnotations = lineAnnotations ?? this.lineAnnotations;
+			this.newFile = newFile;
+			this.oldFile = oldFile;
+			this.fileDiff = fileDiff ?? (oldFile != null && newFile != null ? parseDiffFromFile(oldFile, newFile) : void 0);
+			this.hunksRenderer.hydrate(this.fileDiff);
+			this.renderAnnotations();
+			this.renderHoverUtility();
+			this.injectUnsafeCSS();
+			this.mouseEventManager.setup(this.pre);
+			this.lineSelectionManager.setup(this.pre);
+			if ((this.options.overflow ?? "scroll") === "scroll") {
+				this.resizeManager.setup(this.pre);
+				if ((this.options.diffStyle ?? "split") === "split") this.scrollSyncManager.setup(this.pre);
+			}
+		}
+	}
+	rerender() {
+		if (this.fileDiff == null && this.newFile == null && this.oldFile == null) return;
+		this.render({
+			oldFile: this.oldFile,
+			newFile: this.newFile,
+			fileDiff: this.fileDiff,
+			forceRender: true
+		});
+	}
+	handleExpandHunk = (hunkIndex, direction) => {
+		this.expandHunk(hunkIndex, direction);
+	};
+	expandHunk(hunkIndex, direction) {
+		this.hunksRenderer.expandHunk(hunkIndex, direction);
+		this.rerender();
+	}
+	render({ oldFile, newFile, fileDiff, forceRender = false, lineAnnotations, fileContainer, containerWrapper }) {
+		const filesDidChange = oldFile != null && newFile != null && (!areFilesEqual(oldFile, this.oldFile) || !areFilesEqual(newFile, this.newFile));
+		const annotationsChanged = lineAnnotations != null && (lineAnnotations.length > 0 || this.lineAnnotations.length > 0) ? lineAnnotations !== this.lineAnnotations : false;
+		if (!forceRender && !annotationsChanged && (fileDiff != null && fileDiff === this.fileDiff || fileDiff == null && !filesDidChange)) return;
+		this.oldFile = oldFile;
+		this.newFile = newFile;
+		if (fileDiff != null) this.fileDiff = fileDiff;
+		else if (oldFile != null && newFile != null && filesDidChange) this.fileDiff = parseDiffFromFile(oldFile, newFile);
+		if (lineAnnotations != null) this.setLineAnnotations(lineAnnotations);
+		if (this.fileDiff == null) return;
+		this.hunksRenderer.setOptions({
+			...this.options,
+			hunkSeparators: typeof this.options.hunkSeparators === "function" ? "custom" : this.options.hunkSeparators
+		});
+		this.hunksRenderer.setLineAnnotations(this.lineAnnotations);
+		const { disableFileHeader = false, disableErrorHandling = false } = this.options;
+		if (disableFileHeader) {
+			if (this.headerElement != null) {
+				this.headerElement.parentNode?.removeChild(this.headerElement);
+				this.headerElement = void 0;
+			}
+		}
+		fileContainer = this.getOrCreateFileContainer(fileContainer, containerWrapper);
+		try {
+			const hunksResult = this.hunksRenderer.renderDiff(this.fileDiff);
+			if (hunksResult == null) {
+				if (this.workerManager != null && !this.workerManager.isInitialized()) this.workerManager.initialize().then(() => this.rerender());
+				return;
+			}
+			if (hunksResult.headerElement != null) this.applyHeaderToDOM(hunksResult.headerElement, fileContainer);
+			const pre = this.getOrCreatePreNode(fileContainer);
+			this.applyHunksToDOM(pre, hunksResult);
+			this.renderSeparators(hunksResult.hunkData);
+			this.renderAnnotations();
+			this.renderHoverUtility();
+		} catch (error) {
+			if (disableErrorHandling) throw error;
+			console.error(error);
+			if (error instanceof Error) this.applyErrorToDOM(error, fileContainer);
+		}
+	}
+	renderSeparators(hunkData) {
+		const { hunkSeparators } = this.options;
+		if (this.isContainerManaged || this.fileContainer == null || typeof hunkSeparators !== "function") return;
+		for (const element of this.customHunkElements) element.parentNode?.removeChild(element);
+		this.customHunkElements.length = 0;
+		for (const hunk of hunkData) {
+			const element = document.createElement("div");
+			element.style.display = "contents";
+			element.slot = hunk.slotName;
+			element.appendChild(hunkSeparators(hunk, this));
+			this.fileContainer.appendChild(element);
+			this.customHunkElements.push(element);
+		}
+	}
+	renderAnnotations() {
+		if (this.isContainerManaged || this.fileContainer == null) return;
+		for (const element of this.annotationElements) element.parentNode?.removeChild(element);
+		this.annotationElements.length = 0;
+		const { renderAnnotation } = this.options;
+		if (renderAnnotation != null && this.lineAnnotations.length > 0) for (const annotation of this.lineAnnotations) {
+			const content = renderAnnotation(annotation);
+			if (content == null) continue;
+			const el = createAnnotationWrapperNode(getLineAnnotationName(annotation));
+			el.appendChild(content);
+			this.annotationElements.push(el);
+			this.fileContainer.appendChild(el);
+		}
+	}
+	renderHoverUtility() {
+		const { renderHoverUtility } = this.options;
+		if (this.fileContainer == null || renderHoverUtility == null) return;
+		if (this.hoverContent == null) {
+			this.hoverContent = createHoverContentNode();
+			this.fileContainer.appendChild(this.hoverContent);
+		}
+		const element = renderHoverUtility(this.mouseEventManager.getHoveredLine);
+		this.hoverContent.innerHTML = "";
+		if (element != null) this.hoverContent.appendChild(element);
+	}
+	getOrCreateFileContainer(fileContainer, parentNode) {
+		this.fileContainer = fileContainer ?? this.fileContainer ?? document.createElement(DIFFS_TAG_NAME);
+		if (parentNode != null && this.fileContainer.parentNode !== parentNode) parentNode.appendChild(this.fileContainer);
+		if (this.spriteSVG == null) {
+			const fragment = document.createElement("div");
+			fragment.innerHTML = SVGSpriteSheet;
+			const firstChild = fragment.firstChild;
+			if (firstChild instanceof SVGElement) {
+				this.spriteSVG = firstChild;
+				this.fileContainer.shadowRoot?.appendChild(this.spriteSVG);
+			}
+		}
+		return this.fileContainer;
+	}
+	getFileContainer() {
+		return this.fileContainer;
+	}
+	getOrCreatePreNode(container) {
+		if (this.pre == null) {
+			this.pre = document.createElement("pre");
+			container.shadowRoot?.appendChild(this.pre);
+		} else if (this.pre.parentNode !== container) container.shadowRoot?.appendChild(this.pre);
+		return this.pre;
+	}
+	applyHeaderToDOM(headerAST, container) {
+		this.cleanupErrorWrapper();
+		const tempDiv = document.createElement("div");
+		tempDiv.innerHTML = toHtml(headerAST);
+		const newHeader = tempDiv.firstElementChild;
+		if (!(newHeader instanceof HTMLElement)) return;
+		if (this.headerElement != null) container.shadowRoot?.replaceChild(newHeader, this.headerElement);
+		else container.shadowRoot?.prepend(newHeader);
+		this.headerElement = newHeader;
+		if (this.isContainerManaged) return;
+		const { renderHeaderMetadata } = this.options;
+		if (this.headerMetadata != null) this.headerMetadata.parentNode?.removeChild(this.headerMetadata);
+		const content = renderHeaderMetadata?.({
+			oldFile: this.oldFile,
+			newFile: this.newFile,
+			fileDiff: this.fileDiff
+		}) ?? void 0;
+		if (content != null) {
+			this.headerMetadata = document.createElement("div");
+			this.headerMetadata.slot = HEADER_METADATA_SLOT_ID;
+			if (content instanceof Element) this.headerMetadata.appendChild(content);
+			else this.headerMetadata.innerText = `${content}`;
+			container.appendChild(this.headerMetadata);
+		}
+	}
+	injectUnsafeCSS() {
+		if (this.fileContainer?.shadowRoot == null) return;
+		const { unsafeCSS } = this.options;
+		if (unsafeCSS == null || unsafeCSS === "") return;
+		if (this.unsafeCSSStyle == null) {
+			this.unsafeCSSStyle = createUnsafeCSSStyleNode();
+			this.fileContainer.shadowRoot.appendChild(this.unsafeCSSStyle);
+		}
+		this.unsafeCSSStyle.innerText = wrapUnsafeCSS(unsafeCSS);
+	}
+	applyHunksToDOM(pre, result) {
+		this.cleanupErrorWrapper();
+		this.applyPreNodeAttributes(pre, result);
+		pre.innerHTML = "";
+		let codeDeletions;
+		let codeAdditions;
+		if (result.unifiedAST != null) {
+			const codeUnified = createCodeNode({ columnType: "unified" });
+			codeUnified.innerHTML = this.hunksRenderer.renderPartialHTML(result.unifiedAST);
+			pre.appendChild(codeUnified);
+		} else {
+			if (result.deletionsAST != null) {
+				codeDeletions = createCodeNode({ columnType: "deletions" });
+				codeDeletions.innerHTML = this.hunksRenderer.renderPartialHTML(result.deletionsAST);
+				pre.appendChild(codeDeletions);
+			}
+			if (result.additionsAST != null) {
+				codeAdditions = createCodeNode({ columnType: "additions" });
+				codeAdditions.innerHTML = this.hunksRenderer.renderPartialHTML(result.additionsAST);
+				pre.appendChild(codeAdditions);
+			}
+		}
+		this.injectUnsafeCSS();
+		this.mouseEventManager.setup(pre);
+		this.lineSelectionManager.setup(pre);
+		if ((this.options.overflow ?? "scroll") === "scroll") {
+			this.resizeManager.setup(pre);
+			if ((this.options.diffStyle ?? "split") === "split") this.scrollSyncManager.setup(pre, codeDeletions, codeAdditions);
+			else this.scrollSyncManager.cleanUp();
+		} else {
+			this.resizeManager.cleanUp();
+			this.scrollSyncManager.cleanUp();
+		}
+	}
+	applyPreNodeAttributes(pre, { themeStyles, baseThemeType, additionsAST, deletionsAST, totalLines }) {
+		const { diffIndicators = "bars", disableBackground = false, disableLineNumbers = false, overflow = "scroll", themeType = "system", diffStyle = "split" } = this.options;
+		setPreNodeProperties({
+			pre,
+			diffIndicators,
+			disableBackground,
+			disableLineNumbers,
+			overflow,
+			split: diffStyle === "unified" ? false : additionsAST != null && deletionsAST != null,
+			themeStyles,
+			themeType: baseThemeType ?? themeType,
+			totalLines
+		});
+	}
+	applyErrorToDOM(error, container) {
+		this.cleanupErrorWrapper();
+		const pre = this.getOrCreatePreNode(container);
+		pre.innerHTML = "";
+		pre.parentNode?.removeChild(pre);
+		this.pre = void 0;
+		const shadowRoot = container.shadowRoot ?? container.attachShadow({ mode: "open" });
+		this.errorWrapper ??= document.createElement("div");
+		this.errorWrapper.dataset.errorWrapper = "";
+		this.errorWrapper.innerHTML = "";
+		shadowRoot.appendChild(this.errorWrapper);
+		const errorMessage = document.createElement("div");
+		errorMessage.dataset.errorMessage = "";
+		errorMessage.innerText = error.message;
+		this.errorWrapper.appendChild(errorMessage);
+		const errorStack = document.createElement("pre");
+		errorStack.dataset.errorStack = "";
+		errorStack.innerText = error.stack ?? "No Error Stack";
+		this.errorWrapper.appendChild(errorStack);
+	}
+	cleanupErrorWrapper() {
+		this.errorWrapper?.parentNode?.removeChild(this.errorWrapper);
+		this.errorWrapper = void 0;
+	}
+};
+
+//#endregion
+export { FileDiff };
+//# sourceMappingURL=FileDiff.js.map

package/.output/server/node_modules/@pierre/diffs/dist/components/FileStream.js

@@ -0,0 +1,161 @@
+import { DEFAULT_THEMES, DIFFS_TAG_NAME } from "../constants.js";
+import { getSharedHighlighter } from "../highlighter/shared_highlighter.js";
+import { getHighlighterOptions } from "../utils/getHighlighterOptions.js";
+import { formatCSSVariablePrefix } from "../utils/formatCSSVariablePrefix.js";
+import { getHighlighterThemeStyles } from "../utils/getHighlighterThemeStyles.js";
+import { createCodeNode } from "../utils/createCodeNode.js";
+import { setPreNodeProperties } from "../utils/setWrapperNodeProps.js";
+import { queueRender } from "../managers/UniversalRenderingManager.js";
+import { CodeToTokenTransformStream } from "../shiki-stream/stream.js";
+import { createRowNodes } from "../utils/createRowNodes.js";
+import { createSpanFromToken } from "../utils/createSpanNodeFromToken.js";
+
+//#region src/components/FileStream.ts
+var FileStream = class {
+	highlighter;
+	stream;
+	abortController;
+	fileContainer;
+	pre;
+	code;
+	constructor(options = { theme: DEFAULT_THEMES }) {
+		this.options = options;
+		this.currentLineIndex = this.options.startingLineIndex ?? 1;
+	}
+	cleanUp() {
+		this.abortController?.abort();
+		this.abortController = void 0;
+	}
+	setThemeType(themeType) {
+		if ((this.options.themeType ?? "system") === themeType) return;
+		this.options = {
+			...this.options,
+			themeType
+		};
+		if (this.pre != null) switch (themeType) {
+			case "system":
+				delete this.pre.dataset.themeType;
+				break;
+			case "light":
+			case "dark":
+				this.pre.dataset.themeType = themeType;
+				break;
+		}
+	}
+	async initializeHighlighter() {
+		this.highlighter = await getSharedHighlighter(getHighlighterOptions(this.options.lang, this.options));
+		return this.highlighter;
+	}
+	queuedSetupArgs;
+	async setup(_source, _wrapper) {
+		const isSettingUp = this.queuedSetupArgs != null;
+		this.queuedSetupArgs = [_source, _wrapper];
+		if (isSettingUp) return;
+		this.highlighter ??= await this.initializeHighlighter();
+		const [source, wrapper] = this.queuedSetupArgs;
+		this.queuedSetupArgs = void 0;
+		const stream = source;
+		this.setupStream(stream, wrapper, this.highlighter);
+	}
+	setupStream(stream, wrapper, highlighter) {
+		const { disableLineNumbers = false, overflow = "scroll", theme = DEFAULT_THEMES, themeType = "system" } = this.options;
+		const fileContainer = this.getOrCreateFileContainer();
+		if (fileContainer.parentElement == null) wrapper.appendChild(fileContainer);
+		this.pre ??= document.createElement("pre");
+		if (this.pre.parentElement == null) fileContainer.shadowRoot?.appendChild(this.pre);
+		const themeStyles = getHighlighterThemeStyles({
+			theme,
+			highlighter
+		});
+		const baseThemeType = typeof theme === "string" ? highlighter.getTheme(theme).type : void 0;
+		const pre = setPreNodeProperties({
+			diffIndicators: "none",
+			disableBackground: true,
+			disableLineNumbers,
+			overflow,
+			pre: this.pre,
+			split: false,
+			themeType: baseThemeType ?? themeType,
+			themeStyles,
+			totalLines: 0
+		});
+		pre.innerHTML = "";
+		this.pre = pre;
+		this.code = createCodeNode({ pre });
+		this.abortController?.abort();
+		this.abortController = new AbortController();
+		const { onStreamStart, onStreamClose, onStreamAbort } = this.options;
+		this.stream = stream;
+		this.stream.pipeThrough(typeof theme === "string" ? new CodeToTokenTransformStream({
+			...this.options,
+			theme,
+			highlighter,
+			allowRecalls: true,
+			defaultColor: false,
+			cssVariablePrefix: formatCSSVariablePrefix("token")
+		}) : new CodeToTokenTransformStream({
+			...this.options,
+			themes: theme,
+			highlighter,
+			allowRecalls: true,
+			defaultColor: false,
+			cssVariablePrefix: formatCSSVariablePrefix("token")
+		})).pipeTo(new WritableStream({
+			start(controller) {
+				onStreamStart?.(controller);
+			},
+			close() {
+				onStreamClose?.();
+			},
+			abort(reason) {
+				onStreamAbort?.(reason);
+			},
+			write: this.handleWrite
+		}), { signal: this.abortController.signal }).catch((error) => {
+			if (error.name !== "AbortError") console.error("FileStream pipe error:", error);
+		});
+	}
+	queuedTokens = [];
+	handleWrite = (token) => {
+		if ("recall" in token && this.queuedTokens.length >= token.recall) this.queuedTokens.length = this.queuedTokens.length - token.recall;
+		else this.queuedTokens.push(token);
+		queueRender(this.render);
+		this.options.onStreamWrite?.(token);
+	};
+	currentLineIndex;
+	currentLineElement;
+	render = () => {
+		this.options.onPreRender?.(this);
+		const linesToAppend = [];
+		for (const token of this.queuedTokens) if ("recall" in token) {
+			if (this.currentLineElement == null) throw new Error("FileStream.render: no current line element, shouldnt be possible to get here");
+			if (token.recall > this.currentLineElement.childNodes.length) throw new Error(`FileStream.render: Token recall exceed the current line, there's probably a bug...`);
+			for (let i = 0; i < token.recall; i++) this.currentLineElement.lastChild?.remove();
+		} else {
+			const span = createSpanFromToken(token);
+			if (this.currentLineElement == null) linesToAppend.push(this.createLine());
+			this.currentLineElement?.appendChild(span);
+			if (token.content === "\n") {
+				this.currentLineIndex++;
+				linesToAppend.push(this.createLine());
+			}
+		}
+		for (const line of linesToAppend) this.code?.appendChild(line);
+		this.queuedTokens.length = 0;
+		this.options.onPostRender?.(this);
+	};
+	createLine() {
+		const { row, content } = createRowNodes(this.currentLineIndex);
+		this.currentLineElement = content;
+		return row;
+	}
+	getOrCreateFileContainer(fileContainer) {
+		if (fileContainer != null && fileContainer === this.fileContainer || fileContainer == null && this.fileContainer != null) return this.fileContainer;
+		this.fileContainer = fileContainer ?? document.createElement(DIFFS_TAG_NAME);
+		return this.fileContainer;
+	}
+};
+
+//#endregion
+export { FileStream };
+//# sourceMappingURL=FileStream.js.map

package/.output/server/node_modules/@pierre/diffs/dist/components/web-components.js

@@ -0,0 +1,25 @@
+import { DIFFS_TAG_NAME } from "../constants.js";
+import style_default from "../style.js";
+
+//#region src/components/web-components.ts
+if (typeof HTMLElement !== "undefined" && customElements.get(DIFFS_TAG_NAME) == null) {
+	let sheet;
+	class FileDiffContainer extends HTMLElement {
+		constructor() {
+			super();
+			if (this.shadowRoot != null) return;
+			const shadowRoot = this.attachShadow({ mode: "open" });
+			if (sheet == null) {
+				sheet = new CSSStyleSheet();
+				sheet.replaceSync(style_default);
+			}
+			shadowRoot.adoptedStyleSheets = [sheet];
+		}
+	}
+	customElements.define(DIFFS_TAG_NAME, FileDiffContainer);
+}
+const DiffsContainerLoaded = true;
+
+//#endregion
+export { DiffsContainerLoaded };
+//# sourceMappingURL=web-components.js.map

package/.output/server/node_modules/@pierre/diffs/dist/constants.js

@@ -0,0 +1,23 @@
+//#region src/constants.ts
+const DIFFS_TAG_NAME = "diffs-container";
+const COMMIT_METADATA_SPLIT = /(?=^From [a-f0-9]+ .+$)/m;
+const GIT_DIFF_FILE_BREAK_REGEX = /(?=^diff --git)/gm;
+const UNIFIED_DIFF_FILE_BREAK_REGEX = /(?=^---\s+\S)/gm;
+const FILE_CONTEXT_BLOB = /(?=^@@ )/gm;
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?: (.*))?/m;
+const SPLIT_WITH_NEWLINES = /(?<=\n)/;
+const FILENAME_HEADER_REGEX = /^(---|\+\+\+)\s+([^\t\r\n]+)/;
+const FILENAME_HEADER_REGEX_GIT = /^(---|\+\+\+)\s+[ab]\/([^\t\r\n]+)/;
+const ALTERNATE_FILE_NAMES_GIT = /^diff --git (?:"a\/(.+?)"|a\/(.+?)) (?:"b\/(.+?)"|b\/(.+?))$/;
+const FILE_MODE_FROM_INDEX = /^index (?:[0-9a-f]+)\.\.(?:[0-9a-f]+)(?: (\d+))?/;
+const HEADER_METADATA_SLOT_ID = "header-metadata";
+const DEFAULT_THEMES = {
+	dark: "pierre-dark",
+	light: "pierre-light"
+};
+const UNSAFE_CSS_ATTRIBUTE = "data-unsafe-css";
+const CORE_CSS_ATTRIBUTE = "data-core-css";
+
+//#endregion
+export { ALTERNATE_FILE_NAMES_GIT, COMMIT_METADATA_SPLIT, CORE_CSS_ATTRIBUTE, DEFAULT_THEMES, DIFFS_TAG_NAME, FILENAME_HEADER_REGEX, FILENAME_HEADER_REGEX_GIT, FILE_CONTEXT_BLOB, FILE_MODE_FROM_INDEX, GIT_DIFF_FILE_BREAK_REGEX, HEADER_METADATA_SLOT_ID, HUNK_HEADER, SPLIT_WITH_NEWLINES, UNIFIED_DIFF_FILE_BREAK_REGEX, UNSAFE_CSS_ATTRIBUTE };
+//# sourceMappingURL=constants.js.map

package/.output/server/node_modules/@pierre/diffs/dist/highlighter/languages/areLanguagesAttached.js

@@ -0,0 +1,11 @@
+import { AttachedLanguages } from "./constants.js";
+
+//#region src/highlighter/languages/areLanguagesAttached.ts
+function areLanguagesAttached(languages) {
+	for (const language of Array.isArray(languages) ? languages : [languages]) if (!AttachedLanguages.has(language)) return false;
+	return true;
+}
+
+//#endregion
+export { areLanguagesAttached };
+//# sourceMappingURL=areLanguagesAttached.js.map

package/.output/server/node_modules/@pierre/diffs/dist/highlighter/languages/attachResolvedLanguages.js

@@ -0,0 +1,20 @@
+import { AttachedLanguages, ResolvedLanguages } from "./constants.js";
+
+//#region src/highlighter/languages/attachResolvedLanguages.ts
+function attachResolvedLanguages(resolvedLanguages, highlighter) {
+	resolvedLanguages = Array.isArray(resolvedLanguages) ? resolvedLanguages : [resolvedLanguages];
+	for (const resolvedLang of resolvedLanguages) {
+		if (AttachedLanguages.has(resolvedLang.name)) continue;
+		let lang = ResolvedLanguages.get(resolvedLang.name);
+		if (lang == null) {
+			lang = resolvedLang;
+			ResolvedLanguages.set(resolvedLang.name, lang);
+		}
+		AttachedLanguages.add(lang.name);
+		highlighter.loadLanguageSync(lang.data);
+	}
+}
+
+//#endregion
+export { attachResolvedLanguages };
+//# sourceMappingURL=attachResolvedLanguages.js.map

package/.output/server/node_modules/@pierre/diffs/dist/highlighter/languages/cleanUpResolvedLanguages.js

@@ -0,0 +1,11 @@
+import { AttachedLanguages, ResolvedLanguages } from "./constants.js";
+
+//#region src/highlighter/languages/cleanUpResolvedLanguages.ts
+function cleanUpResolvedLanguages() {
+	ResolvedLanguages.clear();
+	AttachedLanguages.clear();
+}
+
+//#endregion
+export { cleanUpResolvedLanguages };
+//# sourceMappingURL=cleanUpResolvedLanguages.js.map

package/.output/server/node_modules/@pierre/diffs/dist/highlighter/languages/constants.js

@@ -0,0 +1,8 @@
+//#region src/highlighter/languages/constants.ts
+const ResolvedLanguages = /* @__PURE__ */ new Map();
+const ResolvingLanguages = /* @__PURE__ */ new Map();
+const AttachedLanguages = /* @__PURE__ */ new Set();
+
+//#endregion
+export { AttachedLanguages, ResolvedLanguages, ResolvingLanguages };
+//# sourceMappingURL=constants.js.map

package/.output/server/node_modules/@pierre/diffs/dist/highlighter/languages/getResolvedLanguages.js

@@ -0,0 +1,16 @@
+import { ResolvedLanguages } from "./constants.js";
+
+//#region src/highlighter/languages/getResolvedLanguages.ts
+function getResolvedLanguages(languages) {
+	const resolvedLanguages = [];
+	for (const language of languages) {
+		const resolvedLanguage = ResolvedLanguages.get(language);
+		if (resolvedLanguage == null) throw new Error(`getResolvedLanguages: ${language} is not resolved. Please resolve languages before calling getResolvedLanguages`);
+		resolvedLanguages.push(resolvedLanguage);
+	}
+	return resolvedLanguages;
+}
+
+//#endregion
+export { getResolvedLanguages };
+//# sourceMappingURL=getResolvedLanguages.js.map