@pierre/diffs 1.2.5 → 1.3.0-beta.1

package/dist/editor/editor.js

@@ -0,0 +1,1323 @@
+import { getFiletypeFromFileName } from "../utils/getFiletypeFromFileName.js";
+import { isMoveCursorShortcut, isPrimaryModifier, isSafari } from "./platform.js";
+import { resolveEditorCommandFromKeyboardEvent } from "./command.js";
+import { editorCSS, editorGlobalCSS } from "./css.js";
+import { applyDocumentChangeToLineAnnotations } from "./lineAnnotations.js";
+import { DirectionBackward, DirectionForward, DirectionNone, applyDeleteHardLineForwardToSelections, applyTextChangeToSelections, applyTextReplaceToSelections, applyTransposeToSelections, comparePosition, convertSelection, createSelectionFrom, createSelectionFromAnchorAndFocusOffsets, expandCollapsedSelectionToWord, extendSelection, extendSelections, findNexMatch, getCaretPosition, getDocumentBoundarySelection, getDocumentFullSelection, getSelectionAnchor, getSelectionText, isCollapsedSelection, isLineEditable, mapCursorMove, mapSelectionShift, mergeOverlappingSelections, resolveIndentEdits, selectionIntersects } from "./selection.js";
+import { TextDocument } from "./textDocument.js";
+import { addEventListener, debounce, extend, h, round } from "./utils.js";
+import { QuickEditWidget } from "./quickEdit.js";
+import { SearchPanelWidget } from "./searchPanel.js";
+import { Metrics, getExpandedAsciiTextColumns, getUnicodeMeasurementOffsets, snapTextOffsetToUnicodeBoundary } from "./textMeasure.js";
+import { EditorTokenizer, renderLineTokens } from "./tokenzier.js";
+
+//#region src/editor/editor.ts
+function clampDomOffset(node, offset) {
+	if (node.nodeType === 3) {
+		const length = node.textContent?.length ?? 0;
+		return Math.max(0, Math.min(offset, length));
+	}
+	if (node.nodeType === 1) return Math.max(0, Math.min(offset, node.childNodes.length));
+	return 0;
+}
+var Editor = class {
+	#options;
+	#editMode = "simple";
+	#wrap = false;
+	#metrics = new Metrics();
+	#tokenizer;
+	#editorEventDisposes;
+	#globalEventDisposes;
+	#mouseUpDisposes;
+	#detach;
+	#component;
+	#fileContents;
+	#lineAnnotations;
+	#textDocument;
+	#renderRange;
+	#codePaddingTop = 0;
+	#gutterWidthCache;
+	#contentWidthCache;
+	#lineYCache = /* @__PURE__ */ new Map();
+	#wrapLineOffsetsCache = /* @__PURE__ */ new Map();
+	#lastCharX;
+	#globalStyleElement;
+	#editorStyleElement;
+	#themeStyleElement;
+	#componentContainer;
+	#contentElement;
+	#overlayElement;
+	#primaryCaretElement;
+	#selectionElements;
+	#quickEdit;
+	#searchPanel;
+	#resizeObserver;
+	#shouldIgnoreSelectionChange = false;
+	#isGutterMouseDown = false;
+	#isContentMouseDown = false;
+	#shiftKeyPressed = false;
+	#selectionStart;
+	#reservedSelections;
+	#selections;
+	#initSelections;
+	#scrollingToLine;
+	#scrollingToLineChar;
+	#retainSearchPanelFocus = false;
+	#emitChange = debounce((fileContents, lineAnnotations) => {
+		this.#options.onChange?.(fileContents, lineAnnotations);
+	}, 500);
+	#onDeferTokenize = (lines, themeType) => {
+		this.#component?.applyLineChange?.(lines, themeType);
+		if (this.#renderRange !== void 0 && this.#renderRange.totalLines !== Infinity) {
+			const { startingLine, totalLines } = this.#renderRange;
+			const endLine = Math.min(startingLine + totalLines, this.#textDocument?.lineCount ?? 0);
+			for (const [line, tokens] of lines) if (line >= startingLine && line < endLine) {
+				const lineElement = this.#getLineElement(line);
+				if (lineElement !== void 0) lineElement.replaceChildren(...renderLineTokens(tokens, themeType));
+			}
+		}
+	};
+	constructor(options = {}) {
+		this.#options = options;
+	}
+	edit(component) {
+		const { useTokenTransformer, enableGutterUtility, enableLineSelection, expandUnchanged, lineHoverHighlight,...rest } = component.options;
+		if (useTokenTransformer !== true || enableGutterUtility === true || enableLineSelection === true || expandUnchanged !== true && Object.hasOwn(component, "fileDiff") || lineHoverHighlight !== "disabled") {
+			component.setOptions({
+				...rest,
+				useTokenTransformer: true,
+				enableGutterUtility: false,
+				enableLineSelection: false,
+				expandUnchanged: true,
+				lineHoverHighlight: "disabled"
+			});
+			component.rerender();
+		}
+		this.#component = component;
+		this.#initialize();
+		this.#detach = component.attachEditor(this);
+		return () => this.cleanUp();
+	}
+	setSelections(selections) {
+		const textDocument = this.#textDocument;
+		if (textDocument !== void 0) {
+			const resolvedSelections = selections.map((selection) => {
+				const start = textDocument.normalizePosition(selection.start);
+				const end = textDocument.normalizePosition(selection.end);
+				return {
+					direction: selection.direction === "none" ? DirectionNone : selection.direction === "backward" ? DirectionBackward : DirectionForward,
+					start,
+					end
+				};
+			});
+			this.#updateSelections(resolvedSelections);
+			this.#scrollToPrimaryCaret();
+		} else this.#initSelections = selections;
+	}
+	focus(options) {
+		const preventScroll = options?.preventScroll ?? false;
+		const primarySelection = this.#selections?.at(-1);
+		if (primarySelection !== void 0) {
+			const pos = primarySelection.direction === DirectionBackward ? primarySelection.end : primarySelection.start;
+			this.#focus(pos, preventScroll);
+		} else this.#focus(void 0, preventScroll);
+	}
+	cleanUp() {
+		this.#tokenizer?.cleanUp();
+		this.#tokenizer = void 0;
+		this.#globalEventDisposes?.forEach((dispose) => dispose());
+		this.#globalEventDisposes = void 0;
+		this.#editorEventDisposes?.forEach((dispose) => dispose());
+		this.#editorEventDisposes = void 0;
+		this.#detach?.();
+		this.#detach = void 0;
+		this.#component?.setSelectedLines(null);
+		this.#component = void 0;
+		this.#fileContents = void 0;
+		this.#lineAnnotations = void 0;
+		this.#textDocument = void 0;
+		this.#renderRange = void 0;
+		this.#gutterWidthCache = void 0;
+		this.#contentWidthCache = void 0;
+		this.#lineYCache.clear();
+		this.#wrapLineOffsetsCache.clear();
+		this.#lastCharX = void 0;
+		this.#globalStyleElement?.remove();
+		this.#globalStyleElement = void 0;
+		this.#editorStyleElement?.remove();
+		this.#editorStyleElement = void 0;
+		this.#themeStyleElement?.remove();
+		this.#themeStyleElement = void 0;
+		this.#componentContainer = void 0;
+		this.#contentElement?.removeAttribute("contentEditable");
+		this.#contentElement = void 0;
+		this.#overlayElement?.remove();
+		this.#overlayElement = void 0;
+		this.#primaryCaretElement?.remove();
+		this.#primaryCaretElement = void 0;
+		this.#selectionElements?.forEach((el) => el.remove());
+		this.#selectionElements?.clear();
+		this.#selectionElements = void 0;
+		this.#searchPanel?.cleanup();
+		this.#searchPanel = void 0;
+		this.#quickEdit?.cleanup();
+		this.#quickEdit = void 0;
+		this.#resizeObserver?.disconnect();
+		this.#resizeObserver = void 0;
+		this.#shouldIgnoreSelectionChange = false;
+		this.#selectionStart = void 0;
+		this.#selections = void 0;
+		this.#reservedSelections = void 0;
+	}
+	syncWithRender(highlighter, fileContainer, fileContents, lineAnnotations, renderRange, editMode) {
+		const shadowRoot = fileContainer.shadowRoot;
+		if (shadowRoot == null) {
+			console.error("[editor] Could not find the shadow root.");
+			return;
+		}
+		let codeElement;
+		for (const el of shadowRoot.querySelectorAll("[data-code]")) if (el.dataset.deletions === void 0) {
+			codeElement = el;
+			break;
+		}
+		if (codeElement === void 0) return;
+		const contentEl = codeElement.children[1];
+		if (contentEl === void 0) return;
+		this.#editMode = editMode ?? "simple";
+		this.#wrap = this.#component?.options.overflow === "wrap";
+		if (editMode === "advanced" || (lineAnnotations?.length ?? 0) > 0) {
+			let startingLine;
+			let endLine;
+			for (const child of contentEl.children) {
+				const el = child;
+				const line = el.dataset.line;
+				const lineType = el.dataset.lineType;
+				if (line !== void 0) {
+					const lineIndex = Number(line) - 1;
+					startingLine ??= lineIndex;
+					endLine = lineIndex;
+				}
+				if (lineType === void 0 || !isLineEditable(lineType)) el.contentEditable = "false";
+			}
+			if (endLine !== void 0 && renderRange !== void 0) {
+				const { startingLine: startingLine$1, totalLines } = renderRange;
+				endLine = Math.max(endLine, startingLine$1 + totalLines);
+			}
+			if (startingLine !== void 0 && endLine !== void 0) renderRange = {
+				startingLine,
+				totalLines: endLine - startingLine,
+				bufferBefore: 0,
+				bufferAfter: 0
+			};
+		}
+		if (this.#componentContainer !== fileContainer) {
+			this.#componentContainer = fileContainer;
+			this.#codePaddingTop = Number(getComputedStyle(codeElement).paddingTop.slice(0, -2));
+			if (this.#globalStyleElement !== void 0) fileContainer.appendChild(this.#globalStyleElement);
+			if (this.#editorStyleElement !== void 0) shadowRoot.appendChild(this.#editorStyleElement);
+			if (this.#themeStyleElement !== void 0) shadowRoot.appendChild(this.#themeStyleElement);
+		}
+		if (this.#textDocument === void 0 || this.#fileContents === void 0 || this.#fileContents.name !== fileContents.name) {
+			const textDocument = new TextDocument(fileContents.name, fileContents.contents, fileContents.lang ?? getFiletypeFromFileName(fileContents.name));
+			this.#fileContents = fileContents;
+			this.#textDocument = textDocument;
+			this.#tokenizer?.cleanUp();
+			this.#tokenizer = new EditorTokenizer({
+				highlighter,
+				textDocument,
+				codeOptions: this.#component?.options ?? {},
+				onDeferTokenize: this.#onDeferTokenize,
+				setStyle: (css) => {
+					this.#themeStyleElement.textContent = css;
+				}
+			});
+			this.#shouldIgnoreSelectionChange = false;
+			this.#selectionElements?.forEach((el) => el.remove());
+			this.#selectionElements?.clear();
+			this.#component?.setSelectedLines(null);
+			this.#selectionElements = void 0;
+			this.#selections = void 0;
+			this.#scrollingToLine = void 0;
+			this.#reservedSelections = void 0;
+			this.#searchPanel?.cleanup();
+			this.#searchPanel = void 0;
+			this.#quickEdit?.cleanup();
+			this.#quickEdit = void 0;
+		}
+		if (this.#contentElement !== contentEl) {
+			const guttterEl = contentEl.previousElementSibling;
+			const targetIsContentElement = (e) => {
+				const target = e.composedPath()[0];
+				return target === contentEl || contentEl.contains(target);
+			};
+			this.#metrics.init(contentEl);
+			this.#contentElement = extend(contentEl, {
+				contentEditable: "true",
+				role: "textbox",
+				ariaMultiLine: "true",
+				autocapitalize: "off",
+				writingSuggestions: "off",
+				autocorrect: false,
+				spellcheck: false,
+				translate: false
+			});
+			if (this.#overlayElement !== void 0) contentEl.after(this.#overlayElement);
+			this.#editorEventDisposes?.forEach((dispose) => dispose());
+			this.#editorEventDisposes = [
+				addEventListener(contentEl, "pointerdown", (e) => {
+					if (e.pointerType !== "mouse") return;
+					if (isSafari() && this.#lineAnnotations !== void 0 && this.#lineAnnotations.length > 0) this.#mouseUpDisposes = [...contentEl.querySelectorAll("[data-line-annotation]")].map((el) => [addEventListener(el, "mouseenter", () => {
+						this.#shouldIgnoreSelectionChange = true;
+					}), addEventListener(el, "mouseleave", () => {
+						this.#shouldIgnoreSelectionChange = false;
+					})]).flat();
+					this.#isContentMouseDown = true;
+					this.#selectionStart = void 0;
+					if (e.button === 0 && isPrimaryModifier(e)) this.#reservedSelections = this.#selections?.map((selection) => ({ ...selection }));
+					if (e.shiftKey) {
+						const primarySelection = this.#selections?.at(-1);
+						if (primarySelection !== void 0) {
+							const pos = primarySelection.direction === DirectionBackward ? primarySelection.end : primarySelection.start;
+							this.#updateWindowSelection({
+								start: pos,
+								end: pos,
+								direction: DirectionNone
+							});
+						}
+						this.#shiftKeyPressed = true;
+					}
+				}, { passive: true }),
+				addEventListener(contentEl, "keydown", (e) => {
+					if (e.key === "Escape") {
+						e.preventDefault();
+						this.#searchPanel?.cleanup();
+						this.#searchPanel = void 0;
+						this.#retainSearchPanelFocus = false;
+						this.#quickEdit?.cleanup();
+						this.#quickEdit = void 0;
+						if (this.#selections !== void 0 && this.#selections.length > 0) {
+							const primarySelection = this.#selections.at(-1);
+							if (!isCollapsedSelection(primarySelection) || this.#selections.length > 1) {
+								const pos = getCaretPosition(primarySelection);
+								this.#updateSelections([{
+									start: pos,
+									end: pos,
+									direction: DirectionNone
+								}]);
+								this.#focus(pos);
+							}
+						}
+						return;
+					}
+					if (!targetIsContentElement(e)) return;
+					const mvShortcut = isMoveCursorShortcut(e);
+					const textDocument = this.#textDocument;
+					if (this.#selections !== void 0 && this.#selections.length > 0 && mvShortcut !== void 0 && textDocument !== void 0) {
+						if (e.shiftKey) this.#updateSelections(mapSelectionShift(textDocument, this.#selections, mvShortcut));
+						else this.#updateSelections(mapCursorMove(textDocument, this.#selections, mvShortcut));
+						this.#scrollToPrimaryCaret();
+						e.preventDefault();
+						return;
+					}
+					const command = resolveEditorCommandFromKeyboardEvent(e);
+					if (command !== void 0) {
+						e.preventDefault();
+						this.#runCommand(command);
+					}
+				}),
+				addEventListener(contentEl, "copy", (e) => {
+					if (!targetIsContentElement(e)) return;
+					e.preventDefault();
+					e.clipboardData?.setData("text", this.#getSelectionText());
+				}),
+				addEventListener(contentEl, "cut", (e) => {
+					if (!targetIsContentElement(e)) return;
+					e.preventDefault();
+					e.clipboardData?.setData("text", this.#getSelectionText());
+					this.#replaceSelectionText("");
+				}),
+				addEventListener(contentEl, "paste", (e) => {
+					if (!targetIsContentElement(e)) return;
+					e.preventDefault();
+					const text = e.clipboardData?.getData("text");
+					if (text !== void 0) this.#replaceSelectionText(text);
+				}),
+				addEventListener(contentEl, "beforeinput", (e) => {
+					if (!targetIsContentElement(e)) return;
+					e.preventDefault();
+					this.#handleInput(e.inputType, e.data);
+				}),
+				addEventListener(contentEl, "compositionstart", (e) => {
+					if (!targetIsContentElement(e)) return;
+					this.#shouldIgnoreSelectionChange = true;
+				}, { passive: true }),
+				addEventListener(contentEl, "compositionend", (e) => {
+					if (!targetIsContentElement(e)) return;
+					this.#shouldIgnoreSelectionChange = false;
+					this.#handleInput("insertText", e.data);
+				}, { passive: true })
+			];
+			if (guttterEl !== null && guttterEl.dataset.gutter !== void 0) this.#editorEventDisposes.push(addEventListener(guttterEl, "pointerdown", (e) => {
+				let target = e.composedPath()[0];
+				if (target?.dataset.lineNumberContent !== void 0) target = target.parentElement ?? void 0;
+				const textDocument = this.#textDocument;
+				if (target === void 0 || textDocument === void 0) return;
+				const lineNumber = target.dataset.columnNumber;
+				const lineType = target.dataset.lineType;
+				if (lineNumber === void 0 || lineType === void 0 || !isLineEditable(lineType)) return;
+				const lineIndex = Number(lineNumber) - 1;
+				const selection = {
+					start: {
+						line: lineIndex,
+						character: 0
+					},
+					end: {
+						line: lineIndex,
+						character: textDocument.getLineText(lineIndex).length
+					},
+					direction: DirectionForward
+				};
+				this.#isGutterMouseDown = true;
+				this.#selectionStart = selection;
+				this.#updateSelections([selection]);
+				this.#focus(selection.end);
+				this.#mouseUpDisposes = [addEventListener(document, "mousemove", (e$1) => {
+					let target$1 = e$1.composedPath()[0];
+					if (target$1?.dataset.lineNumberContent !== void 0) target$1 = target$1?.parentElement ?? void 0;
+					else if (target$1?.tagName === "SPAN") target$1 = target$1?.closest("[data-line]");
+					if (target$1 === void 0) return;
+					const lineNumber$1 = target$1.dataset.columnNumber ?? target$1.dataset.line;
+					const lineType$1 = target$1.dataset.lineType;
+					if (this.#isGutterMouseDown && this.#textDocument !== void 0 && lineNumber$1 !== void 0 && lineType$1 !== void 0 && isLineEditable(lineType$1)) {
+						const lineIndex$1 = Number(lineNumber$1) - 1;
+						let selection$1 = {
+							start: {
+								line: lineIndex$1,
+								character: 0
+							},
+							end: {
+								line: lineIndex$1,
+								character: this.#textDocument.getLineText(lineIndex$1).length
+							},
+							direction: DirectionForward
+						};
+						if (this.#selectionStart !== void 0) selection$1 = createSelectionFrom(this.#selectionStart, selection$1);
+						else this.#selectionStart = selection$1;
+						this.#updateSelections([selection$1]);
+						this.#focus(selection$1.end);
+					}
+				}, { passive: true })];
+			}, { passive: true }));
+			this.#resizeObserver?.disconnect();
+			this.#resizeObserver = new ResizeObserver(() => {
+				requestAnimationFrame(() => {
+					this.#handleLayoutResize();
+				});
+			});
+			this.#resizeObserver.observe(contentEl);
+			this.#resizeObserver.observe(contentEl.parentElement);
+		}
+		this.#lineYCache.clear();
+		this.#wrapLineOffsetsCache.clear();
+		this.#lastCharX = void 0;
+		this.#lineAnnotations = lineAnnotations;
+		this.#renderRange = renderRange;
+		this.#tokenizer?.prebuildStateStackMap(renderRange);
+		if (this.#initSelections !== void 0) {
+			this.setSelections(this.#initSelections);
+			this.#scrollToPrimaryCaret();
+			this.#initSelections = void 0;
+		} else if (this.#selections !== void 0 && this.#selections.length > 0) this.#updateSelections(this.#selections);
+		if (this.#options.__debug === true && renderRange !== void 0) {
+			const { startingLine, totalLines } = renderRange;
+			console.log("[diffs/editor] render file:", fileContents.name, "RenderRange:", startingLine + "-" + (startingLine + totalLines), "of", this.#textDocument.lineCount, "lines");
+		}
+		if (this.#scrollingToLine !== void 0) {
+			this.#scrollToLine(this.#scrollingToLine, this.#scrollingToLineChar);
+			this.#scrollingToLine = void 0;
+			this.#scrollingToLineChar = void 0;
+		} else if (this.#selections !== void 0 && this.#selections.length > 0) this.focus({ preventScroll: true });
+		if (this.#retainSearchPanelFocus) {
+			this.#retainSearchPanelFocus = false;
+			requestAnimationFrame(() => {
+				this.#searchPanel?.focus();
+			});
+		}
+		if (this.#quickEdit !== void 0 && this.#isLineVisible(this.#quickEdit.line) && this.#contentElement !== void 0) this.#quickEdit.render(this.#contentElement);
+	}
+	#initialize() {
+		this.#editorStyleElement = h("style", {
+			dataset: "editorCss",
+			textContent: editorCSS
+		});
+		this.#themeStyleElement = h("style", { dataset: "editorThemeCss" });
+		this.#globalStyleElement = h("style", {
+			dataset: "editorGlobalCss",
+			textContent: editorGlobalCSS
+		});
+		this.#overlayElement = h("div", { dataset: "editorOverlay" });
+		this.#globalEventDisposes = [
+			addEventListener(document, "selectionchange", () => {
+				const shadowRoot = this.#componentContainer?.shadowRoot;
+				if (this.#shouldIgnoreSelectionChange || shadowRoot == null) return;
+				const composedRange = document.getSelection()?.getComposedRanges({ shadowRoots: [shadowRoot] })?.[0];
+				if (composedRange === void 0 || !this.#rangeBelongsToEditor(composedRange)) return;
+				let selection = convertSelection(composedRange, DirectionNone);
+				if (selection === void 0) return;
+				if (this.#isContentMouseDown && this.#shiftKeyPressed && this.#selections !== void 0 && this.#selections.length > 0) {
+					const primarySelection = this.#selections.at(-1);
+					this.#updateSelections([extendSelection(primarySelection, selection)]);
+					return;
+				}
+				if (this.#isContentMouseDown) if (this.#selectionStart !== void 0) selection = createSelectionFrom(this.#selectionStart, selection);
+				else this.#selectionStart = selection;
+				else if (this.#selectionStart !== void 0) selection.direction = createSelectionFrom(this.#selectionStart, selection).direction;
+				if (this.#reservedSelections !== void 0) this.#updateSelections([...this.#reservedSelections.filter((reservedSelection) => !selectionIntersects(reservedSelection, selection)), selection]);
+				else this.#updateSelections([selection]);
+			}, { passive: true }),
+			addEventListener(document, "pointerup", (e) => {
+				if (e.pointerType !== "mouse") return;
+				this.#mouseUpDisposes?.forEach((dispose) => dispose());
+				this.#mouseUpDisposes = void 0;
+				if (this.#isGutterMouseDown) {
+					this.#isGutterMouseDown = false;
+					this.#focus();
+				}
+				this.#shouldIgnoreSelectionChange = false;
+				this.#isContentMouseDown = false;
+				this.#shiftKeyPressed = false;
+				this.#selectionStart = void 0;
+				this.#reservedSelections = void 0;
+				this.#selectionElements?.forEach((el, key) => {
+					if (key.startsWith("quickEditIcon-")) el.dataset.visible = "true";
+				});
+			}, { passive: true }),
+			addEventListener(document, "keydown", (e) => {
+				if (e.key === "Shift") this.#selectionStart = this.#selections?.at(-1);
+			}, { passive: true }),
+			addEventListener(document, "keyup", (e) => {
+				if (e.key === "Shift") this.#selectionStart = void 0;
+			}, { passive: true })
+		];
+	}
+	#runCommand(command) {
+		const textDocument = this.#textDocument;
+		if (textDocument === void 0) return;
+		switch (command) {
+			case "openSearchPanel":
+				this.#renderSearchPanel();
+				break;
+			case "findNextMatch": {
+				const selections = this.#selections;
+				const textDocument$1 = this.#textDocument;
+				if (selections === void 0 || textDocument$1 === void 0) break;
+				if (selections.some(isCollapsedSelection)) {
+					const expanded = selections.map((sel) => {
+						if (isCollapsedSelection(sel)) return expandCollapsedSelectionToWord(textDocument$1, sel);
+						return sel;
+					});
+					this.#updateSelections(expanded);
+					this.focus();
+				} else {
+					const nextMatch = findNexMatch(textDocument$1, selections);
+					if (nextMatch !== void 0) {
+						this.#updateSelections(nextMatch);
+						this.#scrollToPrimaryCaret();
+					}
+				}
+				break;
+			}
+			case "indent":
+			case "outdent":
+				if (this.#selections !== void 0) {
+					const edits = [];
+					const nextSelections = [];
+					for (const selection of this.#selections) {
+						const startLine = selection.start.line;
+						const outdent = command === "outdent";
+						if (startLine !== selection.end.line || outdent) {
+							const ret = resolveIndentEdits(textDocument, selection, this.#metrics.tabSize, outdent);
+							edits.push(...ret[0]);
+							nextSelections.push(ret[1]);
+						} else {
+							const lineChar0 = textDocument.charAt({
+								line: startLine,
+								character: 0
+							});
+							this.#replaceSelectionText(lineChar0 === "	" ? "	" : " ".repeat(this.#metrics.tabSize));
+						}
+					}
+					const change = textDocument.applyEdits(edits, true, this.#selections, nextSelections);
+					if (change !== void 0) this.#applyChange(change, nextSelections);
+				}
+				break;
+			case "selectAll":
+				this.#updateSelections([getDocumentFullSelection(textDocument)]);
+				this.focus();
+				break;
+			case "moveCursorToDocStart":
+			case "moveCursorToDocEnd":
+				{
+					const atEnd = command === "moveCursorToDocEnd";
+					this.#updateSelections([getDocumentBoundarySelection(textDocument, atEnd)]);
+					this.#scrollToPrimaryCaret();
+				}
+				break;
+			case "expandSelectionDocStart":
+			case "expandSelectionDocEnd":
+				{
+					const atEnd = command === "expandSelectionDocEnd";
+					const selections = this.#selections;
+					if (selections !== void 0) {
+						this.#updateSelections(extendSelections(selections, getDocumentBoundarySelection(textDocument, atEnd)));
+						this.#scrollToPrimaryCaret();
+					}
+				}
+				break;
+			case "undo":
+				if (this.#textDocument?.canUndo === true) {
+					const undoResult = this.#textDocument.undo();
+					if (undoResult !== void 0) this.#applyChange(...undoResult);
+				}
+				break;
+			case "redo":
+				if (this.#textDocument?.canRedo === true) {
+					const redoResult = this.#textDocument.redo();
+					if (redoResult !== void 0) this.#applyChange(...redoResult);
+				}
+				break;
+		}
+	}
+	#handleLayoutResize() {
+		const lineAnnotations = this.#lineAnnotations?.length ?? 0;
+		const prevGutterWidth = this.#gutterWidthCache;
+		const prevContentWidth = this.#contentWidthCache;
+		this.#gutterWidthCache = void 0;
+		this.#contentWidthCache = void 0;
+		const gutterWidthChanged = this.#getGutterWidth() !== prevGutterWidth;
+		const contentWidthChanged = this.#getContentWidth() !== prevContentWidth;
+		if (!gutterWidthChanged && !contentWidthChanged) return;
+		this.#lastCharX = void 0;
+		if (contentWidthChanged && (this.#wrap || lineAnnotations > 0)) {
+			this.#lineYCache.clear();
+			this.#wrapLineOffsetsCache.clear();
+		}
+		if (this.#selections !== void 0) {
+			this.#updateSelections(this.#selections);
+			this.focus();
+		}
+	}
+	#rerender(change, newLineAnnotations, renderRange = this.#renderRange, shouldUpdateBuffer) {
+		const tokenizer = this.#tokenizer;
+		const component = this.#component;
+		const fileContents = this.#fileContents;
+		const textDocument = this.#textDocument;
+		const contentEl = this.#contentElement;
+		const gutterEl = this.#contentElement?.previousElementSibling ?? void 0;
+		if (tokenizer === void 0 || component === void 0 || fileContents === void 0 || textDocument === void 0 || contentEl === void 0 || gutterEl === void 0 || !(gutterEl instanceof HTMLElement) || gutterEl.dataset.gutter === void 0) return;
+		tokenizer.stopBackgroundTokenize();
+		const t = performance.now();
+		const isAdvancedMode = this.#editMode === "advanced";
+		const dirtyLines = tokenizer.tokenize(change, renderRange);
+		const t2 = performance.now();
+		if (dirtyLines.size > 0) {
+			const children = contentEl.children;
+			const dirtyLineIndexes = new Set(dirtyLines.keys());
+			if (isAdvancedMode) for (const child of children) {
+				const el = child;
+				if (el.dataset.line !== void 0) {
+					const lineIndex = Number(el.dataset.line) - 1;
+					const tokens = dirtyLines.get(lineIndex);
+					if (tokens !== void 0) {
+						el.replaceChildren(...renderLineTokens(tokens, tokenizer.themeType));
+						dirtyLineIndexes.delete(lineIndex);
+						if (dirtyLineIndexes.size === 0) break;
+					}
+				}
+			}
+			else {
+				const startingLine = renderRange?.startingLine ?? 0;
+				for (let i = change.startLine - startingLine; i < children.length; i++) {
+					const child = children[i];
+					if (child?.dataset.line !== void 0) {
+						const lineIndex = Number(child.dataset.line) - 1;
+						if (dirtyLines.has(lineIndex)) {
+							const tokens = dirtyLines.get(lineIndex);
+							child.replaceChildren(...renderLineTokens(tokens, tokenizer.themeType));
+							dirtyLineIndexes.delete(lineIndex);
+							if (dirtyLineIndexes.size === 0) break;
+						}
+					}
+				}
+			}
+			if (dirtyLineIndexes.size > 0) for (const lineIndex of dirtyLineIndexes) {
+				const tokens = dirtyLines.get(lineIndex);
+				const lineNumber = String(lineIndex + 1);
+				h("div", {
+					dataset: {
+						line: lineNumber,
+						lineType: "context",
+						lineIndex: lineIndex.toString()
+					},
+					children: renderLineTokens(tokens, tokenizer.themeType)
+				}, contentEl);
+				h("div", {
+					dataset: {
+						lineType: "context",
+						columnNumber: lineNumber,
+						lineIndex: lineIndex.toString()
+					},
+					children: [h("span", {
+						dataset: { lineNumberContent: "" },
+						textContent: lineNumber
+					})]
+				}, gutterEl);
+			}
+		}
+		if (change.lineDelta < 0) for (const parent of [contentEl, gutterEl]) {
+			const children = parent.children;
+			for (let i = children.length - 1; i >= 0; i--) {
+				const child = children[i];
+				const { lineIndex, lineAnnotation } = child.dataset;
+				if (lineIndex !== void 0 || lineAnnotation !== void 0) {
+					if (Number(lineAnnotation !== void 0 ? lineAnnotation.split(",")[1] : lineIndex) < change.lineCount) break;
+					child.remove();
+				}
+			}
+		}
+		if (change.lineDelta !== 0) {
+			gutterEl.style.gridRow = "span " + gutterEl.children.length;
+			contentEl.style.gridRow = "span " + contentEl.children.length;
+		}
+		component.applyLineChange?.(dirtyLines, tokenizer.themeType);
+		if (change.lineDelta !== 0 || isAdvancedMode) component.applyLayoutChange(textDocument, newLineAnnotations, shouldUpdateBuffer);
+		if (this.#options.__debug === true) console.log(`[diffs/editor] re-render in: ${round(performance.now() - t2)}ms,`, `tokenize in: ${round(t2 - t)}ms (${dirtyLines.size} dirty lines)`);
+	}
+	#handleInput(inputType, data) {
+		switch (inputType) {
+			case "insertText":
+				this.#replaceSelectionText(data ?? "");
+				break;
+			case "insertParagraph":
+				this.#replaceSelectionText("\n");
+				break;
+			case "deleteContentBackward":
+				this.#deleteSelectionText();
+				break;
+			case "deleteContentForward":
+				this.#deleteSelectionText(true);
+				break;
+			case "deleteHardLineForward":
+				this.#deleteHardLineForward();
+				break;
+			case "insertTranspose":
+				this.#insertTranspose();
+				break;
+			default:
+				console.warn(`[diffs] Unknown input type: ${inputType}`);
+				break;
+		}
+	}
+	#updateSelections(selections) {
+		if (selections.length === 0) return;
+		const gutterBuffer = this.#contentElement?.previousElementSibling;
+		const normalizedSelections = mergeOverlappingSelections(selections);
+		const primarySelection = normalizedSelections.at(-1);
+		this.#selections = normalizedSelections;
+		this.#primaryCaretElement = void 0;
+		this.#component?.setSelectedLines(null);
+		gutterBuffer?.querySelectorAll("[data-active]").forEach((el) => el.removeAttribute("data-active"));
+		if (isCollapsedSelection(primarySelection)) {
+			const line = primarySelection.start.line + 1;
+			this.#component?.setSelectedLines({
+				start: line,
+				end: line
+			});
+		} else if (gutterBuffer !== void 0 && gutterBuffer instanceof HTMLElement) {
+			const pos = getCaretPosition(primarySelection);
+			gutterBuffer.querySelector(`[data-column-number="${pos.line + 1}"]`)?.setAttribute("data-active", "");
+		}
+		const fragment = document.createDocumentFragment();
+		const renderCtx = {
+			fragment,
+			elements: /* @__PURE__ */ new Map()
+		};
+		for (const selection of normalizedSelections) {
+			if (!isCollapsedSelection(selection)) this.#renderSelection(renderCtx, selection);
+			this.#renderCaret(renderCtx, selection, selection === primarySelection);
+		}
+		if (this.#options.enabledQuickEdit === true && !isCollapsedSelection(primarySelection)) this.#renderQuickEditIcon(renderCtx, primarySelection);
+		this.#overlayElement?.appendChild(fragment);
+		this.#selectionElements?.forEach((el) => el.remove());
+		this.#selectionElements?.clear();
+		this.#selectionElements = renderCtx.elements;
+	}
+	#updateWindowSelection(selection) {
+		const winSelection = window.getSelection();
+		if (winSelection === null) return;
+		let { start, end, direction } = selection;
+		if (comparePosition(start, end) > 0) [start, end] = [end, start];
+		const startLineElement = this.#getLineElement(start.line);
+		const endLineElement = this.#getLineElement(end.line);
+		if (startLineElement === void 0 || endLineElement === void 0) return;
+		let [anchorNode, anchorOffset] = getSelectionAnchor(startLineElement, start.character);
+		let [focusNode, focusOffset] = getSelectionAnchor(endLineElement, end.character);
+		if (direction === DirectionBackward) [anchorNode, anchorOffset, focusNode, focusOffset] = [
+			focusNode,
+			focusOffset,
+			anchorNode,
+			anchorOffset
+		];
+		try {
+			winSelection.setBaseAndExtent(anchorNode, clampDomOffset(anchorNode, anchorOffset), focusNode, clampDomOffset(focusNode, focusOffset));
+		} catch (err) {
+			console.error("[diffs/editor] failed to update window selection:", err);
+		}
+	}
+	#focus(position, preventScroll = true) {
+		if (position !== void 0) {
+			this.#shouldIgnoreSelectionChange = true;
+			this.#updateWindowSelection({
+				start: position,
+				end: position,
+				direction: DirectionNone
+			});
+			requestAnimationFrame(() => {
+				this.#contentElement?.focus({ preventScroll });
+				requestAnimationFrame(() => {
+					this.#shouldIgnoreSelectionChange = false;
+				});
+			});
+		} else requestAnimationFrame(() => {
+			this.#contentElement?.focus({ preventScroll });
+		});
+	}
+	#scrollToPrimaryCaret() {
+		const primaryCaretElement = this.#primaryCaretElement;
+		const primarySelection = this.#selections?.at(-1);
+		if (primarySelection === void 0) return;
+		if (primaryCaretElement !== void 0) {
+			primaryCaretElement.scrollIntoView({
+				block: "nearest",
+				inline: "nearest"
+			});
+			this.#focus(primarySelection.direction === DirectionBackward ? primarySelection.end : primarySelection.start);
+		} else {
+			const pos = getCaretPosition(primarySelection);
+			this.#scrollToLine(pos.line, pos.character);
+		}
+	}
+	#getScrollMargin() {
+		const componentTop = this.#component?.top ?? 0;
+		const top = this.#searchPanel !== void 0 ? 48 : 0;
+		const start = this.#getGutterWidth() + this.#metrics.ch;
+		const end = this.#metrics.ch;
+		return `${componentTop + top}px ${end}px 0 ${start}px`;
+	}
+	#scrollToLine(line, char = 0) {
+		const virtualCaret = h("div", { style: {
+			position: "absolute",
+			left: "0",
+			width: "2px",
+			height: this.#metrics.lineHeight + "px",
+			scrollMargin: this.#getScrollMargin()
+		} });
+		if (this.#getLineElement(line) !== void 0) {
+			const [left, wrapLine] = this.#getCharX(line, char);
+			const lineY = this.#getLineY(line) + wrapLine * this.#metrics.lineHeight;
+			virtualCaret.style.top = lineY + "px";
+			virtualCaret.style.left = left + "px";
+			this.#overlayElement?.appendChild(virtualCaret);
+			virtualCaret.scrollIntoView({
+				block: "center",
+				inline: "nearest"
+			});
+			this.#focus({
+				line,
+				character: char
+			});
+			requestAnimationFrame(() => virtualCaret.remove());
+		} else {
+			const approximateLineY = ((this.#lineAnnotations ?? []).filter((annotation) => annotation.lineNumber < line).length + line) * this.#metrics.lineHeight;
+			virtualCaret.style.top = approximateLineY + "px";
+			this.#componentContainer?.shadowRoot?.appendChild(virtualCaret);
+			this.#scrollingToLine = line;
+			this.#scrollingToLineChar = char;
+			virtualCaret.scrollIntoView({
+				block: "center",
+				inline: "nearest"
+			});
+			requestAnimationFrame(() => virtualCaret.remove());
+		}
+	}
+	#renderSelection(renderCtx, selection) {
+		if (this.#textDocument === void 0) return;
+		const { start, end } = selection;
+		for (let ln = start.line; ln <= end.line; ln++) {
+			if (!this.#isLineVisible(ln)) continue;
+			const lineText = this.#textDocument.getLineText(ln);
+			const startChar = ln === start.line ? start.character : 0;
+			const endChar = ln === end.line ? end.character : lineText.length;
+			if (this.#wrap) {
+				const paddingInline = this.#metrics.ch;
+				const contentWidth = this.#getContentWidth();
+				if (2 * paddingInline + this.#metrics.measureTextWidth(lineText) > contentWidth) {
+					this.#renderWrappedSelection(renderCtx, selection, ln, lineText, startChar, endChar, paddingInline);
+					continue;
+				}
+			}
+			let left = 0;
+			let width = 0;
+			if (startChar === endChar && startChar === 0) {
+				left = this.#getGutterWidth() + this.#metrics.ch;
+				width = ln === end.line ? 0 : this.#metrics.ch;
+			} else {
+				left = this.#getCharX(ln, startChar)[0];
+				width = endChar === startChar ? 0 : this.#getCharX(ln, endChar)[0] - left;
+			}
+			this.#renderSelectionRange(renderCtx, selection, ln, 0, startChar, endChar, width, left);
+		}
+	}
+	#renderWrappedSelection(renderCtx, selection, line, lineText, startChar, endChar, paddingInline) {
+		const wrapOffsets = this.#wrapLineText(line);
+		const segmentCount = wrapOffsets.length - 1;
+		const lastSegmentIndex = segmentCount - 1;
+		const offsetLeft = this.#getGutterWidth() + paddingInline;
+		for (let w = 0; w < segmentCount; w++) {
+			const segmentStart = wrapOffsets[w];
+			const segmentEnd = wrapOffsets[w + 1];
+			const wrapStartChar = Math.max(startChar, segmentStart);
+			const wrapEndChar = Math.min(endChar, segmentEnd);
+			if (wrapStartChar > wrapEndChar) continue;
+			if (wrapStartChar === wrapEndChar) {
+				const isAtLineStart = wrapStartChar === 0 && w === 0;
+				const isAtLineEnd = wrapEndChar === lineText.length && w === lastSegmentIndex;
+				if (!isAtLineStart && !isAtLineEnd) continue;
+			}
+			let segmentLeft;
+			let segmentWidth;
+			if (wrapStartChar === 0 && wrapEndChar === 0) {
+				segmentLeft = offsetLeft;
+				segmentWidth = line === selection.end.line ? 0 : paddingInline;
+			} else {
+				const prefixInSegment = lineText.slice(segmentStart, wrapStartChar);
+				const prefixAsciiColumns = getExpandedAsciiTextColumns(prefixInSegment, this.#metrics.tabSize);
+				segmentLeft = offsetLeft + (prefixAsciiColumns !== -1 ? prefixAsciiColumns * this.#metrics.ch : this.#metrics.measureTextWidth(prefixInSegment));
+				if (wrapStartChar === wrapEndChar) segmentWidth = 0;
+				else {
+					const selectionInSegment = lineText.slice(wrapStartChar, wrapEndChar);
+					const selectionAsciiWidth = getExpandedAsciiTextColumns(selectionInSegment, this.#metrics.tabSize);
+					segmentWidth = selectionAsciiWidth !== -1 ? selectionAsciiWidth * this.#metrics.ch : this.#metrics.measureTextWidth(selectionInSegment);
+				}
+			}
+			this.#renderSelectionRange(renderCtx, selection, line, w, wrapStartChar, wrapEndChar, segmentWidth, segmentLeft, w === lastSegmentIndex);
+		}
+	}
+	#renderSelectionRange(renderCtx, selection, ln, wrapLine, startChar, endChar, width, left, applyEolSpacing = true) {
+		const css = `width:${width + (!applyEolSpacing || selection.end.line === ln || startChar === endChar && ln !== selection.start.line ? 0 : this.#metrics.ch)}px;transform:translateY(${this.#getLineY(ln) + wrapLine * this.#metrics.lineHeight}px) translateX(${left}px);`;
+		const cacheKey = "selection-range-" + css;
+		const selectionEls = this.#selectionElements;
+		if (renderCtx.elements.has(cacheKey)) return;
+		let rangeEl;
+		if (selectionEls?.has(cacheKey) === true) {
+			rangeEl = selectionEls.get(cacheKey);
+			selectionEls.delete(cacheKey);
+		} else rangeEl = h("div", {
+			dataset: "selectionRange",
+			style: { cssText: css }
+		}, renderCtx.fragment);
+		renderCtx.elements.set(cacheKey, rangeEl);
+	}
+	#renderCaret(renderCtx, selection, isPrimary) {
+		const { line, character } = getCaretPosition(selection);
+		if (!this.#isLineVisible(line)) return;
+		const [left, wrapLine] = this.#getCharX(line, character);
+		const cacheKey = "caret-" + line + "(" + wrapLine + ")-" + character;
+		if (renderCtx.elements.has(cacheKey)) return;
+		const caretEl = h("div", {
+			dataset: "caret",
+			style: { transform: `translateY(${this.#getLineY(line) + wrapLine * this.#metrics.lineHeight}px) translateX(${left - 1}px)` }
+		}, renderCtx.fragment);
+		renderCtx.elements.set(cacheKey, caretEl);
+		if (isPrimary) {
+			caretEl.style.scrollMargin = this.#getScrollMargin();
+			this.#primaryCaretElement = caretEl;
+		}
+	}
+	#renderQuickEditIcon(renderCtx, selection) {
+		const line = getCaretPosition(selection).line;
+		if (!this.#isLineVisible(line)) return;
+		const [left, wrapLine] = this.#getCharX(line, 0);
+		const cacheKey = "quickEditIcon-" + line + "(" + wrapLine + ")";
+		if (renderCtx.elements.has(cacheKey)) return;
+		const quickEditIcon = QuickEditWidget.renderIcon(left, this.#getLineY(line) + wrapLine * this.#metrics.lineHeight, renderCtx.fragment, () => {
+			const cleanUpQuickEdit = () => {
+				this.#quickEdit?.cleanup();
+				this.#quickEdit = void 0;
+			};
+			const handleWidgetDomResize = () => {
+				this.#lineYCache.clear();
+				if (this.#selections !== void 0) this.#updateSelections(this.#selections);
+			};
+			cleanUpQuickEdit();
+			const textDocument = this.#textDocument;
+			const renderQuickEdit = this.#options.renderQuickEdit;
+			const fileContainer = this.#componentContainer;
+			if (textDocument === void 0 || renderQuickEdit === void 0 || fileContainer == null) return;
+			const line$1 = selection.end.line;
+			const lineText = textDocument.getLineText(line$1);
+			const quickEditElement = renderQuickEdit({
+				textDocument,
+				selection,
+				applyEdits: (edits) => {
+					const change = textDocument.applyEdits(edits, true, this.#selections);
+					if (change !== void 0) this.#applyChange(change);
+				},
+				getSelectionText: () => {
+					return this.#textDocument?.getText(selection) ?? "";
+				},
+				replaceSelectionText: (text) => {
+					this.#replaceSelectionText(text);
+				},
+				close: () => {
+					cleanUpQuickEdit();
+					handleWidgetDomResize();
+					this.#scrollToPrimaryCaret();
+				}
+			});
+			let leadingWhitespaces = 0;
+			for (let i = 0; i < lineText.length; i++) {
+				const charCode = lineText.charCodeAt(i);
+				if (charCode === 32) leadingWhitespaces++;
+				else if (charCode === 9) leadingWhitespaces += this.#metrics.tabSize;
+				else break;
+			}
+			this.#quickEdit = new QuickEditWidget(line$1, quickEditElement, fileContainer, leadingWhitespaces, handleWidgetDomResize);
+			this.#updateSelections([selection]);
+			if (this.#isLineVisible(line$1) && this.#contentElement !== void 0) this.#quickEdit.render(this.#contentElement);
+		});
+		renderCtx.elements.set(cacheKey, quickEditIcon);
+	}
+	#renderSearchPanel() {
+		this.#searchPanel?.cleanup();
+		const textDocument = this.#textDocument;
+		const preElement = this.#componentContainer?.shadowRoot?.querySelector("pre");
+		if (textDocument === void 0 || preElement == null) return;
+		let defaultQuery = "";
+		let initialMatch = void 0;
+		const selections = this.#selections;
+		if (selections !== void 0 && selections.length > 0) {
+			let primarySelection = selections.at(-1);
+			if (isCollapsedSelection(primarySelection)) {
+				primarySelection = expandCollapsedSelectionToWord(textDocument, primarySelection);
+				this.#updateSelections([...selections.slice(0, -1), primarySelection]);
+				const selectionText = textDocument.getText(primarySelection);
+				if (!selectionText.includes("\n")) {
+					defaultQuery = selectionText;
+					initialMatch = [textDocument.offsetAt(primarySelection.start), textDocument.offsetAt(primarySelection.end)];
+				}
+			}
+		}
+		this.#searchPanel = new SearchPanelWidget({
+			textDocument,
+			containerElement: preElement,
+			defaultQuery,
+			initialMatch,
+			getCurrentSearchRange: () => this.#selections?.at(-1),
+			postSearch: (kind, [startOffset, endOffset], retainFocus) => {
+				if (kind === "findNext" || kind === "findPrevious" || kind === "replace") {
+					const nextSelection = createSelectionFromAnchorAndFocusOffsets(textDocument, startOffset, endOffset);
+					this.#updateSelections([nextSelection]);
+					this.#scrollToPrimaryCaret();
+					if (retainFocus === true) {
+						this.#retainSearchPanelFocus = true;
+						requestAnimationFrame(() => {
+							this.#searchPanel?.focus();
+						});
+					}
+				} else if (kind === "findAll" || kind === "replaceAll") {
+					const { line, character } = textDocument.positionAt(startOffset);
+					this.#scrollToLine(line, character);
+				}
+			},
+			onClose: () => {
+				this.#searchPanel = void 0;
+				this.#retainSearchPanelFocus = false;
+			}
+		});
+		this.#retainSearchPanelFocus = false;
+	}
+	#getSelectionText() {
+		const textDocument = this.#textDocument;
+		const selections = this.#selections;
+		if (textDocument === void 0 || selections === void 0) return "";
+		return getSelectionText(textDocument, selections);
+	}
+	#replaceSelectionText(text) {
+		const selections = this.#selections;
+		if (selections === void 0) return;
+		const textDocument = this.#textDocument;
+		const primarySelection = selections.at(-1);
+		if (textDocument === void 0 || primarySelection === void 0) return;
+		const { nextSelections, change } = Array.isArray(text) && text.length === selections.length ? applyTextReplaceToSelections(textDocument, selections, text, this.#lineAnnotations) : applyTextChangeToSelections(textDocument, selections, {
+			start: textDocument.offsetAt(primarySelection.start),
+			end: textDocument.offsetAt(primarySelection.end),
+			text: Array.isArray(text) ? text.join("\n") : text
+		}, this.#lineAnnotations);
+		if (change !== void 0) this.#applyChange(change, nextSelections, this.#applyChangeToLineAnnotations(change));
+	}
+	#deleteSelectionText(forward = false) {
+		const selections = this.#selections;
+		const textDocument = this.#textDocument;
+		if (selections === void 0 || textDocument === void 0) return;
+		const primarySelection = selections.at(-1);
+		if (primarySelection === void 0) return;
+		const edit = isCollapsedSelection(primarySelection) ? (() => {
+			const offset = textDocument.offsetAt(primarySelection.start);
+			const nextOffset = forward ? Math.min(textDocument.getText().length, offset + 1) : Math.max(0, offset - 1);
+			return {
+				start: Math.min(offset, nextOffset),
+				end: Math.max(offset, nextOffset),
+				text: ""
+			};
+		})() : {
+			start: textDocument.offsetAt(primarySelection.start),
+			end: textDocument.offsetAt(primarySelection.end),
+			text: ""
+		};
+		this.#applyResolvedTextEdit(edit);
+	}
+	#deleteHardLineForward() {
+		const selections = this.#selections;
+		const textDocument = this.#textDocument;
+		if (selections === void 0 || textDocument === void 0) return;
+		const { nextSelections, change } = applyDeleteHardLineForwardToSelections(textDocument, selections, this.#lineAnnotations);
+		if (change !== void 0) this.#applyChange(change, nextSelections, this.#applyChangeToLineAnnotations(change));
+	}
+	#insertTranspose() {
+		const selections = this.#selections;
+		const textDocument = this.#textDocument;
+		if (selections === void 0 || textDocument === void 0) return;
+		const { nextSelections, change } = applyTransposeToSelections(textDocument, selections, this.#lineAnnotations);
+		if (change !== void 0) this.#applyChange(change, nextSelections, this.#applyChangeToLineAnnotations(change));
+	}
+	#applyResolvedTextEdit(edit) {
+		if (this.#selections === void 0 || this.#textDocument === void 0) return;
+		const { nextSelections, change } = applyTextChangeToSelections(this.#textDocument, this.#selections, edit, this.#lineAnnotations, this.#metrics.tabSize);
+		if (change !== void 0) this.#applyChange(change, nextSelections, this.#applyChangeToLineAnnotations(change));
+	}
+	#applyChange(change, selections, newLineAnnotations) {
+		const fileContents = this.#fileContents;
+		const textDocument = this.#textDocument;
+		const onChange = this.#options.onChange;
+		if (fileContents !== void 0 && textDocument !== void 0 && onChange !== void 0) {
+			const { contents: _,...file } = fileContents;
+			let contents;
+			Object.defineProperty(file, "contents", { get: () => contents ??= textDocument.getText() });
+			this.#emitChange(file, newLineAnnotations ?? this.#lineAnnotations);
+		}
+		if (change.lineDelta !== 0) {
+			for (const line of this.#lineYCache.keys()) if (line >= change.startLine) this.#lineYCache.delete(line);
+		}
+		if (this.#wrap) {
+			for (const line of this.#wrapLineOffsetsCache.keys()) if (line >= change.startLine) this.#wrapLineOffsetsCache.delete(line);
+		}
+		this.#lastCharX = void 0;
+		let renderRange = this.#renderRange;
+		let shouldUpdateBuffer;
+		if (renderRange !== void 0 && selections !== void 0 && selections.length > 0) {
+			const primarySelection = selections.at(-1);
+			const renderRangeEndLine = renderRange.startingLine + renderRange.totalLines;
+			if (primarySelection.end.line === renderRangeEndLine) renderRange = {
+				...renderRange,
+				totalLines: renderRange.totalLines + 1
+			};
+			else if (primarySelection.end.line > renderRangeEndLine) shouldUpdateBuffer = true;
+		}
+		this.#rerender(change, newLineAnnotations, renderRange, shouldUpdateBuffer);
+		if (selections !== void 0) {
+			this.#updateSelections(selections);
+			this.focus({ preventScroll: true });
+			requestAnimationFrame(() => {
+				if (this.#primaryCaretElement !== void 0) this.#primaryCaretElement.scrollIntoView({
+					block: "nearest",
+					inline: "nearest"
+				});
+				else if (selections.length > 0) {
+					const pos = getCaretPosition(selections.at(-1));
+					this.#scrollToLine(pos.line, pos.character);
+				}
+			});
+		}
+	}
+	#applyChangeToLineAnnotations(change) {
+		if (this.#lineAnnotations !== void 0) {
+			const nextLineAnnotations = applyDocumentChangeToLineAnnotations(change, this.#lineAnnotations);
+			if (nextLineAnnotations !== void 0) {
+				this.#textDocument?.setLastUndoLineAnnotations(this.#lineAnnotations, nextLineAnnotations);
+				return nextLineAnnotations;
+			}
+		}
+	}
+	#getLineElement(line) {
+		const contentElement = this.#contentElement;
+		if (contentElement === void 0) return;
+		if (this.#renderRange !== void 0 && this.#editMode === "simple") {
+			const { startingLine } = this.#renderRange;
+			const { children } = contentElement;
+			for (let i = line - startingLine; i <= children.length; i++) {
+				const child = children[i];
+				const lineNumber = child?.dataset.line;
+				const lineType = child?.dataset.lineType;
+				if (lineNumber !== void 0 && lineType !== void 0 && isLineEditable(lineType) && Number(lineNumber) === line + 1) return child;
+			}
+		}
+		if (this.#editMode === "advanced") return contentElement.querySelector(`[data-line="${line + 1}"]:not([data-line-type="change-deletion"])`) ?? void 0;
+		return contentElement.querySelector(`[data-line="${line + 1}"]`) ?? void 0;
+	}
+	#getGutterWidth() {
+		const gutterElement = this.#contentElement?.previousElementSibling;
+		if (gutterElement == null || !(gutterElement instanceof HTMLElement) || !gutterElement.hasAttribute("data-gutter")) return 0;
+		if (this.#gutterWidthCache === void 0) {
+			const diffsColumnNumberWidth = this.#contentElement?.parentElement?.style.getPropertyValue("--diffs-column-number-width");
+			if (diffsColumnNumberWidth !== void 0 && diffsColumnNumberWidth.length > 2 && diffsColumnNumberWidth.endsWith("px")) this.#gutterWidthCache = Number(diffsColumnNumberWidth.slice(0, -2));
+			else this.#gutterWidthCache = gutterElement.offsetWidth;
+		}
+		return this.#gutterWidthCache;
+	}
+	#getContentWidth() {
+		if (this.#contentElement === void 0) return 0;
+		if (this.#contentWidthCache === void 0) {
+			const diffsColumnContentWidth = this.#contentElement.parentElement?.style.getPropertyValue("--diffs-column-content-width");
+			if (diffsColumnContentWidth !== void 0 && diffsColumnContentWidth.length > 2 && diffsColumnContentWidth.endsWith("px")) this.#contentWidthCache = Number(diffsColumnContentWidth.slice(0, -2));
+			else this.#contentWidthCache = this.#contentElement.offsetWidth;
+		}
+		return this.#contentWidthCache;
+	}
+	#getLineY(line) {
+		const cachedY = this.#lineYCache.get(line);
+		if (cachedY !== void 0) return cachedY;
+		const lineElement = this.#getLineElement(line);
+		if (lineElement === void 0) return -1;
+		const y = lineElement.offsetTop + this.#codePaddingTop;
+		this.#lineYCache.set(line, y);
+		return y;
+	}
+	#getCharX(line, char) {
+		if (this.#lastCharX !== void 0 && this.#lastCharX[0] === line && this.#lastCharX[1] === char) return [this.#lastCharX[2], this.#lastCharX[3]];
+		const lineText = this.#textDocument?.getLineText(line);
+		const offsetLeft = this.#getGutterWidth() + this.#metrics.ch;
+		if (lineText === void 0 || lineText.length === 0 || char <= 0) return [offsetLeft, 0];
+		const boundedCharacter = snapTextOffsetToUnicodeBoundary(lineText, Math.min(char, lineText.length));
+		const textBeforeCharacter = lineText.slice(0, boundedCharacter);
+		const asciiColumns = getExpandedAsciiTextColumns(textBeforeCharacter, this.#metrics.tabSize);
+		let left = 0;
+		let wrapLine = 0;
+		if (asciiColumns !== -1) left = offsetLeft + asciiColumns * this.#metrics.ch;
+		else left = offsetLeft + this.#metrics.measureTextWidth(textBeforeCharacter);
+		if (this.#wrap) {
+			const contentWidth = this.#getContentWidth();
+			if (2 * this.#metrics.ch + this.#metrics.measureTextWidth(lineText) > contentWidth) {
+				const wrapOffsets = this.#wrapLineText(line);
+				for (let w = 0; w + 1 < wrapOffsets.length; w++) {
+					const segmentStart = wrapOffsets[w];
+					if (boundedCharacter <= wrapOffsets[w + 1]) {
+						wrapLine = w;
+						const prefixInSegment = lineText.slice(segmentStart, boundedCharacter);
+						const segmentAsciiColumns = getExpandedAsciiTextColumns(prefixInSegment, this.#metrics.tabSize);
+						if (segmentAsciiColumns !== -1) left = offsetLeft + segmentAsciiColumns * this.#metrics.ch;
+						else left = offsetLeft + this.#metrics.measureTextWidth(prefixInSegment);
+						break;
+					}
+				}
+			}
+		}
+		if (this.#lastCharX !== void 0) {
+			this.#lastCharX[0] = line;
+			this.#lastCharX[1] = char;
+			this.#lastCharX[2] = left;
+			this.#lastCharX[3] = wrapLine;
+		} else this.#lastCharX = [
+			line,
+			char,
+			left,
+			wrapLine
+		];
+		return [left, wrapLine];
+	}
+	#wrapLineText(line) {
+		const cachedOffsets = this.#wrapLineOffsetsCache.get(line);
+		if (cachedOffsets !== void 0) return cachedOffsets;
+		const lineText = this.#textDocument?.getLineText(line);
+		if (lineText === void 0 || lineText.length === 0) {
+			const offsets = new Uint32Array([0]);
+			this.#wrapLineOffsetsCache.set(line, offsets);
+			return offsets;
+		}
+		const div = h("div", {
+			style: {
+				position: "absolute",
+				top: "0",
+				left: "0",
+				width: "100%",
+				boxSizing: "border-box",
+				visibility: "hidden",
+				pointerEvents: "none",
+				whiteSpace: "pre-wrap",
+				wordBreak: "break-word",
+				font: "inherit",
+				paddingInline: "1ch",
+				tabSize: this.#metrics.tabSize.toString()
+			},
+			textContent: lineText
+		}, this.#contentElement);
+		const textNode = div.firstChild;
+		const range = document.createRange();
+		const starts = [];
+		try {
+			const unicodeOffsets = getUnicodeMeasurementOffsets(lineText);
+			const wrapLineStartLeft = div.getBoundingClientRect().left + this.#metrics.ch;
+			let previousOffset = 0;
+			let lastTop = Number.NEGATIVE_INFINITY;
+			for (let i = 0, offsetIndex = 0; i < lineText.length;) {
+				const nextOffset = unicodeOffsets === void 0 ? i + 1 : unicodeOffsets[offsetIndex + 1];
+				range.setStart(textNode, i);
+				range.setEnd(textNode, nextOffset);
+				const { left, top } = range.getBoundingClientRect();
+				if (top > lastTop) {
+					const startsPastLineStart = isSafari() && starts.length > 0 && left - wrapLineStartLeft > this.#metrics.ch / 2;
+					starts.push(startsPastLineStart ? previousOffset : i);
+					lastTop = top;
+				}
+				previousOffset = i;
+				i = nextOffset;
+				offsetIndex++;
+			}
+			const offsets = new Uint32Array(starts.length + 1);
+			for (let i = 0; i < starts.length; i++) offsets[i] = starts[i];
+			offsets[starts.length] = lineText.length;
+			this.#wrapLineOffsetsCache.set(line, offsets);
+			return offsets;
+		} finally {
+			div.remove();
+		}
+	}
+	#rangeBelongsToEditor({ startContainer, endContainer }) {
+		const contentEl = this.#contentElement;
+		if (contentEl === void 0) return false;
+		return contentEl.contains(startContainer) && contentEl.contains(endContainer);
+	}
+	#isLineVisible(line) {
+		const lineCount = this.#textDocument?.lineCount ?? 0;
+		if (line < 0 || line >= lineCount) return false;
+		if (this.#renderRange === void 0) return true;
+		const { startingLine, totalLines } = this.#renderRange;
+		if (line < startingLine) return false;
+		if (totalLines === Infinity) return true;
+		return line < startingLine + totalLines;
+	}
+};
+
+//#endregion
+export { Editor };
+//# sourceMappingURL=editor.js.map