@thxgg/steward 0.1.24 → 0.1.26

package/.output/server/node_modules/@pierre/diffs/dist/managers/LineSelectionManager.js

@@ -0,0 +1,282 @@
+import { areSelectionsEqual } from "../utils/areSelectionsEqual.js";
+
+//#region src/managers/LineSelectionManager.ts
+/**
+* Manages line selection state and interactions for code/diff viewers.
+* Handles:
+* - Click and drag selection
+* - Shift-click to extend selection
+* - DOM attribute updates (data-selected-line)
+*/
+var LineSelectionManager = class {
+	pre;
+	selectedRange = null;
+	renderedSelectionRange;
+	anchor;
+	_queuedRender;
+	constructor(options = {}) {
+		this.options = options;
+	}
+	setOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		this.removeEventListeners();
+		if (this.options.enableLineSelection === true) this.attachEventListeners();
+	}
+	cleanUp() {
+		this.removeEventListeners();
+		if (this._queuedRender != null) {
+			cancelAnimationFrame(this._queuedRender);
+			this._queuedRender = void 0;
+		}
+		if (this.pre != null) delete this.pre.dataset.interactiveLineNumbers;
+		this.pre = void 0;
+	}
+	setup(pre) {
+		this.setDirty();
+		if (this.pre !== pre) this.cleanUp();
+		this.pre = pre;
+		const { enableLineSelection = false } = this.options;
+		if (enableLineSelection) {
+			this.pre.dataset.interactiveLineNumbers = "";
+			this.attachEventListeners();
+		} else {
+			this.removeEventListeners();
+			delete this.pre.dataset.interactiveLineNumbers;
+		}
+		this.setSelection(this.selectedRange);
+	}
+	setDirty() {
+		this.renderedSelectionRange = void 0;
+	}
+	isDirty() {
+		return this.renderedSelectionRange === void 0;
+	}
+	setSelection(range) {
+		const isRangeChange = !(range === this.selectedRange || areSelectionsEqual(range ?? void 0, this.selectedRange ?? void 0));
+		if (!this.isDirty() && !isRangeChange) return;
+		this.selectedRange = range;
+		this.renderSelection();
+		if (isRangeChange) this.notifySelectionChange();
+	}
+	getSelection() {
+		return this.selectedRange;
+	}
+	attachEventListeners() {
+		if (this.pre == null) return;
+		this.removeEventListeners();
+		this.pre.addEventListener("pointerdown", this.handleMouseDown);
+	}
+	removeEventListeners() {
+		if (this.pre == null) return;
+		this.pre.removeEventListener("pointerdown", this.handleMouseDown);
+		document.removeEventListener("pointermove", this.handleMouseMove);
+		document.removeEventListener("pointerup", this.handleMouseUp);
+	}
+	handleMouseDown = (event) => {
+		const mouseEventData = event.button === 0 ? this.getMouseEventDataForPath(event.composedPath(), "click") : void 0;
+		if (mouseEventData == null) return;
+		event.preventDefault();
+		const { lineNumber, eventSide, lineIndex } = mouseEventData;
+		if (event.shiftKey && this.selectedRange != null) {
+			const range = this.deriveRowRangeFromDOM(this.selectedRange, this.pre?.dataset.type === "split");
+			if (range == null) return;
+			const useStart = range.start <= range.end ? lineIndex >= range.start : lineIndex <= range.end;
+			this.anchor = {
+				line: useStart ? this.selectedRange.start : this.selectedRange.end,
+				side: (useStart ? this.selectedRange.side : this.selectedRange.endSide ?? this.selectedRange.side) ?? "additions"
+			};
+			this.updateSelection(lineNumber, eventSide);
+			this.notifySelectionStart(this.selectedRange);
+		} else {
+			if (this.selectedRange?.start === lineNumber && this.selectedRange?.end === lineNumber) {
+				this.updateSelection(null);
+				this.notifySelectionEnd(null);
+				this.notifySelectionChange();
+				return;
+			}
+			this.selectedRange = null;
+			this.anchor = {
+				line: lineNumber,
+				side: eventSide
+			};
+			this.updateSelection(lineNumber, eventSide);
+			this.notifySelectionStart(this.selectedRange);
+		}
+		document.addEventListener("pointermove", this.handleMouseMove);
+		document.addEventListener("pointerup", this.handleMouseUp);
+	};
+	handleMouseMove = (event) => {
+		const mouseEventData = this.getMouseEventDataForPath(event.composedPath(), "move");
+		if (mouseEventData == null || this.anchor == null) return;
+		const { lineNumber, eventSide } = mouseEventData;
+		this.updateSelection(lineNumber, eventSide);
+	};
+	handleMouseUp = () => {
+		this.anchor = void 0;
+		document.removeEventListener("pointermove", this.handleMouseMove);
+		document.removeEventListener("pointerup", this.handleMouseUp);
+		this.notifySelectionEnd(this.selectedRange);
+		this.notifySelectionChange();
+	};
+	updateSelection(currentLine, side) {
+		if (currentLine == null) this.selectedRange = null;
+		else {
+			const anchorSide = this.anchor?.side ?? side;
+			this.selectedRange = {
+				start: this.anchor?.line ?? currentLine,
+				end: currentLine,
+				side: anchorSide,
+				endSide: anchorSide !== side ? side : void 0
+			};
+		}
+		this._queuedRender ??= requestAnimationFrame(this.renderSelection);
+	}
+	renderSelection = () => {
+		if (this._queuedRender != null) {
+			cancelAnimationFrame(this._queuedRender);
+			this._queuedRender = void 0;
+		}
+		if (this.pre == null || this.renderedSelectionRange === this.selectedRange) return;
+		const allSelected = this.pre.querySelectorAll("[data-selected-line]");
+		for (const element of allSelected) element.removeAttribute("data-selected-line");
+		this.renderedSelectionRange = this.selectedRange;
+		if (this.selectedRange == null) return;
+		const codeElements = this.pre.querySelectorAll("[data-code]");
+		if (codeElements.length === 0) return;
+		if (codeElements.length > 2) {
+			console.error(codeElements);
+			throw new Error("LineSelectionManager.applySelectionToDOM: Somehow there are more than 2 code elements...");
+		}
+		const split = this.pre.dataset.type === "split";
+		const rowRange = this.deriveRowRangeFromDOM(this.selectedRange, split);
+		if (rowRange == null) {
+			console.error({
+				rowRange,
+				selectedRange: this.selectedRange
+			});
+			throw new Error("LineSelectionManager.renderSelection: No valid rowRange");
+		}
+		const isSingle = rowRange.start === rowRange.end;
+		const first = Math.min(rowRange.start, rowRange.end);
+		const last = Math.max(rowRange.start, rowRange.end);
+		for (const code of codeElements) for (const element of code.children) {
+			if (!(element instanceof HTMLElement)) continue;
+			const lineIndex = this.getLineIndex(element, split);
+			if ((lineIndex ?? 0) > last) break;
+			if (lineIndex == null || lineIndex < first) continue;
+			let attributeValue = isSingle ? "single" : lineIndex === first ? "first" : lineIndex === last ? "last" : "";
+			element.setAttribute("data-selected-line", attributeValue);
+			if (element.nextSibling instanceof HTMLElement && element.nextSibling.hasAttribute("data-line-annotation")) {
+				if (isSingle) {
+					attributeValue = "last";
+					element.setAttribute("data-selected-line", "first");
+				} else if (lineIndex === first) attributeValue = "";
+				else if (lineIndex === last) element.setAttribute("data-selected-line", "");
+				element.nextSibling.setAttribute("data-selected-line", attributeValue);
+			}
+		}
+	};
+	deriveRowRangeFromDOM(range, split) {
+		if (range == null) return void 0;
+		const start = this.findRowIndexForLineNumber(range.start, range.side, split);
+		const end = range.end === range.start && (range.endSide == null || range.endSide === range.side) ? start : this.findRowIndexForLineNumber(range.end, range.endSide ?? range.side, split);
+		return start != null && end != null ? {
+			start,
+			end
+		} : void 0;
+	}
+	findRowIndexForLineNumber(lineNumber, targetSide = "additions", split) {
+		if (this.pre == null) return void 0;
+		const elements = Array.from(this.pre.querySelectorAll(`[data-line="${lineNumber}"]`));
+		elements.push(...Array.from(this.pre.querySelectorAll(`[data-alt-line="${lineNumber}"]`)));
+		if (elements.length === 0) return void 0;
+		for (const element of elements) {
+			if (!(element instanceof HTMLElement)) continue;
+			if (this.getLineSideFromElement(element) === targetSide) return this.getLineIndex(element, split);
+			else if (parseInt(element.dataset.altLine ?? "") === lineNumber) return this.getLineIndex(element, split);
+		}
+		console.error("LineSelectionManager.findRowIndexForLineNumber: Invalid selection", lineNumber, targetSide);
+	}
+	notifySelectionChange() {
+		const { onLineSelected } = this.options;
+		if (onLineSelected == null) return;
+		onLineSelected(this.selectedRange ?? null);
+	}
+	notifySelectionStart(range) {
+		const { onLineSelectionStart } = this.options;
+		if (onLineSelectionStart == null) return;
+		onLineSelectionStart(range);
+	}
+	notifySelectionEnd(range) {
+		const { onLineSelectionEnd } = this.options;
+		if (onLineSelectionEnd == null) return;
+		onLineSelectionEnd(range);
+	}
+	getMouseEventDataForPath(path, eventType) {
+		let lineNumber;
+		let lineIndex;
+		let isNumberColumn = false;
+		let eventSide;
+		for (const element of path) {
+			if (!(element instanceof HTMLElement)) continue;
+			if (element.hasAttribute("data-column-number")) {
+				isNumberColumn = true;
+				continue;
+			}
+			if (element.hasAttribute("data-line")) {
+				lineNumber = this.getLineNumber(element);
+				lineIndex = this.getLineIndex(element, this.pre?.dataset.type === "split");
+				if (element.dataset.lineType === "change-deletion") eventSide = "deletions";
+				else if (element.dataset.lineType === "change-additions") eventSide = "additions";
+				if (lineIndex == null || lineNumber == null) {
+					lineIndex = void 0;
+					lineNumber = void 0;
+					break;
+				}
+				if (eventSide != null) break;
+				continue;
+			}
+			if (element.hasAttribute("data-code")) {
+				eventSide ??= element.hasAttribute("data-deletions") ? "deletions" : "additions";
+				break;
+			}
+		}
+		if (eventType === "click" && !isNumberColumn || lineIndex == null || lineNumber == null) return;
+		return {
+			lineIndex,
+			lineNumber,
+			eventSide: eventSide ?? "additions"
+		};
+	}
+	getLineNumber(element) {
+		const lineNumber = parseInt(element.dataset.line ?? "", 10);
+		return !Number.isNaN(lineNumber) ? lineNumber : void 0;
+	}
+	getLineIndex(element, split) {
+		const lineIndexes = (element.dataset.lineIndex ?? "").split(",").map((value) => parseInt(value)).filter((value) => !Number.isNaN(value));
+		if (split && lineIndexes.length === 2) return lineIndexes[1];
+		else if (!split) return lineIndexes[0];
+	}
+	getLineSideFromElement(element) {
+		if (element.dataset.lineType === "change-deletion") return "deletions";
+		if (element.dataset.lineType === "change-addition") return "additions";
+		const parent = element.closest("[data-code]");
+		if (!(parent instanceof HTMLElement)) return "additions";
+		return parent.hasAttribute("data-deletions") ? "deletions" : "additions";
+	}
+};
+function pluckLineSelectionOptions({ enableLineSelection, onLineSelected, onLineSelectionStart, onLineSelectionEnd }) {
+	return {
+		enableLineSelection,
+		onLineSelected,
+		onLineSelectionStart,
+		onLineSelectionEnd
+	};
+}
+
+//#endregion
+export { LineSelectionManager, pluckLineSelectionOptions };
+//# sourceMappingURL=LineSelectionManager.js.map

package/.output/server/node_modules/@pierre/diffs/dist/managers/MouseEventManager.js

@@ -0,0 +1,244 @@
+//#region src/managers/MouseEventManager.ts
+function isLineEventData(data, mode) {
+	if (data == null) return false;
+	if (mode === "file") return data.type === "line";
+	else return data.type === "diff-line";
+}
+function isExpandoEventData(data) {
+	return data?.type === "line-info";
+}
+var MouseEventManager = class {
+	hoveredLine;
+	pre;
+	hoverSlot;
+	constructor(mode, options) {
+		this.mode = mode;
+		this.options = options;
+	}
+	setOptions(options) {
+		this.options = options;
+	}
+	cleanUp() {
+		this.pre?.removeEventListener("click", this.handleMouseClick);
+		this.pre?.removeEventListener("pointermove", this.handleMouseMove);
+		this.pre?.removeEventListener("pointerout", this.handleMouseLeave);
+		delete this.pre?.dataset.interactiveLines;
+		delete this.pre?.dataset.interactiveLineNumbers;
+		this.pre = void 0;
+	}
+	setup(pre) {
+		const { __debugMouseEvents, onLineClick, onLineNumberClick, onLineEnter, onLineLeave, onHunkExpand, enableHoverUtility = false } = this.options;
+		this.cleanUp();
+		this.pre = pre;
+		if (enableHoverUtility && this.hoverSlot == null) {
+			this.hoverSlot = document.createElement("div");
+			this.hoverSlot.dataset.hoverSlot = "";
+			const slotElement = document.createElement("slot");
+			slotElement.name = "hover-slot";
+			this.hoverSlot.appendChild(slotElement);
+		} else if (!enableHoverUtility && this.hoverSlot != null) {
+			this.hoverSlot.parentNode?.removeChild(this.hoverSlot);
+			this.hoverSlot = void 0;
+		}
+		if (onLineClick != null || onLineNumberClick != null || onHunkExpand != null) {
+			pre.addEventListener("click", this.handleMouseClick);
+			if (onLineClick != null) pre.dataset.interactiveLines = "";
+			else if (onLineNumberClick != null) pre.dataset.interactiveLineNumbers = "";
+			debugLogIfEnabled(__debugMouseEvents, "click", "FileDiff.DEBUG.attachEventListeners: Attaching click events for:", (() => {
+				const reasons = [];
+				if (__debugMouseEvents === "both" || __debugMouseEvents === "click") {
+					if (onLineClick != null) reasons.push("onLineClick");
+					if (onLineNumberClick != null) reasons.push("onLineNumberClick");
+					if (onHunkExpand != null) reasons.push("expandable hunk separators");
+				}
+				return reasons;
+			})());
+		}
+		if (onLineEnter != null || onLineLeave != null || enableHoverUtility) {
+			pre.addEventListener("pointermove", this.handleMouseMove);
+			debugLogIfEnabled(__debugMouseEvents, "move", "FileDiff.DEBUG.attachEventListeners: Attaching pointer move event");
+			pre.addEventListener("pointerleave", this.handleMouseLeave);
+			debugLogIfEnabled(__debugMouseEvents, "move", "FileDiff.DEBUG.attachEventListeners: Attaching pointer leave event");
+		}
+	}
+	getHoveredLine = () => {
+		if (this.hoveredLine != null) {
+			if (this.mode === "diff" && this.hoveredLine.type === "diff-line") return {
+				lineNumber: this.hoveredLine.lineNumber,
+				side: this.hoveredLine.annotationSide
+			};
+			if (this.mode === "file" && this.hoveredLine.type === "line") return { lineNumber: this.hoveredLine.lineNumber };
+		}
+	};
+	handleMouseClick = (event) => {
+		debugLogIfEnabled(this.options.__debugMouseEvents, "click", "FileDiff.DEBUG.handleMouseClick:", event);
+		this.handleMouseEvent({
+			eventType: "click",
+			event
+		});
+	};
+	handleMouseMove = (event) => {
+		debugLogIfEnabled(this.options.__debugMouseEvents, "move", "FileDiff.DEBUG.handleMouseMove:", event);
+		this.handleMouseEvent({
+			eventType: "move",
+			event
+		});
+	};
+	handleMouseLeave = (event) => {
+		const { __debugMouseEvents } = this.options;
+		debugLogIfEnabled(__debugMouseEvents, "move", "FileDiff.DEBUG.handleMouseLeave: no event");
+		if (this.hoveredLine == null) {
+			debugLogIfEnabled(__debugMouseEvents, "move", "FileDiff.DEBUG.handleMouseLeave: returned early, no .hoveredLine");
+			return;
+		}
+		this.hoverSlot?.parentElement?.removeChild(this.hoverSlot);
+		this.options.onLineLeave?.({
+			...this.hoveredLine,
+			event
+		});
+		this.hoveredLine = void 0;
+	};
+	handleMouseEvent({ eventType, event }) {
+		const { __debugMouseEvents } = this.options;
+		const composedPath = event.composedPath();
+		debugLogIfEnabled(__debugMouseEvents, eventType, "FileDiff.DEBUG.handleMouseEvent:", {
+			eventType,
+			composedPath
+		});
+		const data = this.getLineData(composedPath);
+		debugLogIfEnabled(__debugMouseEvents, eventType, "FileDiff.DEBUG.handleMouseEvent: getLineData result:", data);
+		const { onLineClick, onLineNumberClick, onLineEnter, onLineLeave, onHunkExpand } = this.options;
+		switch (eventType) {
+			case "move":
+				if (isLineEventData(data, this.mode) && this.hoveredLine?.lineElement === data.lineElement) {
+					debugLogIfEnabled(__debugMouseEvents, "move", "FileDiff.DEBUG.handleMouseEvent: switch, 'move', returned early because same line");
+					break;
+				}
+				if (this.hoveredLine != null) {
+					debugLogIfEnabled(__debugMouseEvents, "move", "FileDiff.DEBUG.handleMouseEvent: switch, 'move', clearing an existing hovered line and firing onLineLeave");
+					this.hoverSlot?.parentElement?.removeChild(this.hoverSlot);
+					onLineLeave?.({
+						...this.hoveredLine,
+						event
+					});
+					this.hoveredLine = void 0;
+				}
+				if (isLineEventData(data, this.mode)) {
+					debugLogIfEnabled(__debugMouseEvents, "move", "FileDiff.DEBUG.handleMouseEvent: switch, 'move', setting up a new hoveredLine and firing onLineEnter");
+					this.hoveredLine = data;
+					if (this.hoverSlot != null) data.numberElement?.appendChild(this.hoverSlot);
+					onLineEnter?.({
+						...this.hoveredLine,
+						event
+					});
+				}
+				break;
+			case "click":
+				debugLogIfEnabled(__debugMouseEvents, "click", "FileDiff.DEBUG.handleMouseEvent: switch, 'click', with data:", data);
+				if (data == null) break;
+				if (isExpandoEventData(data) && onHunkExpand != null) {
+					debugLogIfEnabled(__debugMouseEvents, "click", "FileDiff.DEBUG.handleMouseEvent: switch, 'click', expanding a hunk");
+					onHunkExpand(data.hunkIndex, data.direction);
+					break;
+				}
+				if (isLineEventData(data, this.mode)) if (onLineNumberClick != null && data.numberColumn) {
+					debugLogIfEnabled(__debugMouseEvents, "click", "FileDiff.DEBUG.handleMouseEvent: switch, 'click', firing 'onLineNumberClick'");
+					onLineNumberClick({
+						...data,
+						event
+					});
+				} else if (onLineClick != null) {
+					debugLogIfEnabled(__debugMouseEvents, "click", "FileDiff.DEBUG.handleMouseEvent: switch, 'click', firing 'onLineClick'");
+					onLineClick({
+						...data,
+						event
+					});
+				} else debugLogIfEnabled(__debugMouseEvents, "click", "FileDiff.DEBUG.handleMouseEvent: switch, 'click', fell through, no event to fire");
+				break;
+		}
+	}
+	getLineData(path) {
+		let numberColumn = false;
+		const lineElement = path.find((element) => {
+			if (!(element instanceof HTMLElement)) return false;
+			numberColumn = numberColumn || "columnNumber" in element.dataset;
+			return "line" in element.dataset || "expandIndex" in element.dataset;
+		});
+		if (!(lineElement instanceof HTMLElement)) return void 0;
+		if (lineElement.dataset.expandIndex != null) {
+			const hunkIndex = parseInt(lineElement.dataset.expandIndex);
+			if (isNaN(hunkIndex)) return;
+			let direction;
+			for (const element of path) {
+				if (element === lineElement) break;
+				if (element instanceof HTMLElement) {
+					direction = direction ?? ("expandUp" in element.dataset ? "up" : void 0) ?? ("expandDown" in element.dataset ? "down" : void 0) ?? ("expandBoth" in element.dataset ? "both" : void 0);
+					if (direction != null) break;
+				}
+			}
+			return direction != null ? {
+				type: "line-info",
+				hunkIndex,
+				direction
+			} : void 0;
+		}
+		const lineNumber = parseInt(lineElement.dataset.line ?? "");
+		if (isNaN(lineNumber)) return;
+		const lineType = lineElement.dataset.lineType;
+		if (lineType !== "context" && lineType !== "context-expanded" && lineType !== "change-deletion" && lineType !== "change-addition") return;
+		const numberElement = (() => {
+			const numberElement$1 = lineElement.children[0];
+			return numberElement$1 instanceof HTMLElement && numberElement$1.dataset.columnNumber != null ? numberElement$1 : void 0;
+		})();
+		if (this.mode === "file") return {
+			type: "line",
+			lineElement,
+			lineNumber,
+			numberElement,
+			numberColumn
+		};
+		return {
+			type: "diff-line",
+			annotationSide: (() => {
+				if (lineType === "change-deletion") return "deletions";
+				if (lineType === "change-addition") return "additions";
+				const parent = lineElement.closest("[data-code]");
+				if (!(parent instanceof HTMLElement)) return "additions";
+				return "deletions" in parent.dataset ? "deletions" : "additions";
+			})(),
+			lineType,
+			lineElement,
+			numberElement,
+			lineNumber,
+			numberColumn
+		};
+	}
+};
+function debugLogIfEnabled(debugLogType = "none", logIfType, ...args) {
+	switch (debugLogType) {
+		case "none": return;
+		case "both": break;
+		case "click":
+			if (logIfType !== "click") return;
+			break;
+		case "move":
+			if (logIfType !== "move") return;
+			break;
+	}
+	console.log(...args);
+}
+function pluckMouseEventOptions({ onLineClick, onLineNumberClick, onLineEnter, onLineLeave, enableHoverUtility, __debugMouseEvents }, onHunkExpand) {
+	return {
+		onLineClick,
+		onLineNumberClick,
+		onLineEnter,
+		onLineLeave,
+		enableHoverUtility,
+		__debugMouseEvents,
+		onHunkExpand
+	};
+}
+
+//#endregion
+export { MouseEventManager, pluckMouseEventOptions };
+//# sourceMappingURL=MouseEventManager.js.map

package/.output/server/node_modules/@pierre/diffs/dist/managers/ResizeManager.js

@@ -0,0 +1,132 @@
+//#region src/managers/ResizeManager.ts
+var ResizeManager = class {
+	observedNodes = /* @__PURE__ */ new Map();
+	cleanUp() {
+		this.resizeObserver?.disconnect();
+		this.observedNodes.clear();
+	}
+	resizeObserver;
+	setup(pre) {
+		this.cleanUp();
+		const annotationElements = pre.querySelectorAll("[data-line-annotation*=\",\"]");
+		this.resizeObserver ??= new ResizeObserver(this.handleResizeObserver);
+		const codeElements = pre.querySelectorAll("code");
+		for (const codeElement of codeElements) {
+			let numberElement = codeElement.querySelector("[data-column-number]");
+			if (!(numberElement instanceof HTMLElement)) numberElement = null;
+			const item = {
+				type: "code",
+				codeElement,
+				numberElement,
+				codeWidth: "auto",
+				numberWidth: 0
+			};
+			this.observedNodes.set(codeElement, item);
+			this.resizeObserver.observe(codeElement);
+			if (numberElement != null) {
+				this.observedNodes.set(numberElement, item);
+				this.resizeObserver.observe(numberElement);
+			}
+		}
+		if (codeElements.length <= 1) return;
+		const elementMap = /* @__PURE__ */ new Map();
+		for (const element of annotationElements) {
+			if (!(element instanceof HTMLElement)) continue;
+			const { lineAnnotation = "" } = element.dataset;
+			if (!/^\d+,\d+$/.test(lineAnnotation)) {
+				console.error("DiffFileRenderer.setupResizeObserver: Invalid element or annotation", {
+					lineAnnotation,
+					element
+				});
+				continue;
+			}
+			let pairs = elementMap.get(lineAnnotation);
+			if (pairs == null) {
+				pairs = [];
+				elementMap.set(lineAnnotation, pairs);
+			}
+			pairs.push(element);
+		}
+		for (const [key, pair] of elementMap) {
+			if (pair.length !== 2) {
+				console.error("DiffFileRenderer.setupResizeObserver: Bad Pair", key, pair);
+				continue;
+			}
+			const [container1, container2] = pair;
+			const child1 = container1.firstElementChild;
+			const child2 = container2.firstElementChild;
+			if (!(container1 instanceof HTMLElement) || !(container2 instanceof HTMLElement) || !(child1 instanceof HTMLElement) || !(child2 instanceof HTMLElement)) continue;
+			const item = {
+				type: "annotations",
+				column1: {
+					container: container1,
+					child: child1,
+					childHeight: 0
+				},
+				column2: {
+					container: container2,
+					child: child2,
+					childHeight: 0
+				},
+				currentHeight: "auto"
+			};
+			this.observedNodes.set(child1, item);
+			this.observedNodes.set(child2, item);
+			this.resizeObserver.observe(child1);
+			this.resizeObserver.observe(child2);
+		}
+	}
+	handleResizeObserver = (entries) => {
+		for (const entry of entries) {
+			const { target, borderBoxSize } = entry;
+			if (!(target instanceof HTMLElement)) {
+				console.error("FileDiff.handleResizeObserver: Invalid element for ResizeObserver", entry);
+				continue;
+			}
+			const item = this.observedNodes.get(target);
+			if (item == null) {
+				console.error("FileDiff.handleResizeObserver: Not a valid observed node", entry);
+				continue;
+			}
+			const specs = borderBoxSize[0];
+			if (item.type === "annotations") {
+				const column = (() => {
+					if (target === item.column1.child) return item.column1;
+					if (target === item.column2.child) return item.column2;
+				})();
+				if (column == null) {
+					console.error(`FileDiff.handleResizeObserver: Couldn't find a column for`, {
+						item,
+						target
+					});
+					continue;
+				}
+				column.childHeight = specs.blockSize;
+				const newHeight = Math.max(item.column1.childHeight, item.column2.childHeight);
+				if (newHeight !== item.currentHeight) {
+					item.currentHeight = Math.max(newHeight, 0);
+					item.column1.container.style.setProperty("--diffs-annotation-min-height", `${item.currentHeight}px`);
+					item.column2.container.style.setProperty("--diffs-annotation-min-height", `${item.currentHeight}px`);
+				}
+			} else if (item.type === "code") {
+				if (target === item.codeElement) {
+					if (specs.inlineSize !== item.codeWidth) {
+						item.codeWidth = specs.inlineSize;
+						item.codeElement.style.setProperty("--diffs-column-content-width", `${Math.max(item.codeWidth - item.numberWidth, 0)}px`);
+						item.codeElement.style.setProperty("--diffs-column-width", `${item.codeWidth}px`);
+					}
+				} else if (target === item.numberElement) {
+					if (specs.inlineSize !== item.numberWidth) {
+						item.numberWidth = specs.inlineSize;
+						item.codeElement.style.setProperty("--diffs-column-number-width", `${item.numberWidth}px`);
+						if (item.codeWidth !== "auto") item.codeElement.style.setProperty("--diffs-column-content-width", `${Math.max(item.codeWidth - item.numberWidth, 0)}px`);
+					}
+				}
+			}
+		}
+	};
+};
+
+//#endregion
+export { ResizeManager };
+//# sourceMappingURL=ResizeManager.js.map