stream-monaco 0.0.17 → 0.0.19

package/dist/{preloadMonacoWorkers.shared-gUKedCzF.cjs → preloadMonacoWorkers.shared-DMvZ1HUs.cjs}

@@ -28,7 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const monaco_editor = __toESM(require("monaco-editor"));
+const monaco_editor_esm_vs_editor_editor_api = __toESM(require("monaco-editor/esm/vs/editor/editor.api"));
 const alien_signals = __toESM(require("alien-signals"));
 const __shikijs_monaco = __toESM(require("@shikijs/monaco"));
 const shiki = __toESM(require("shiki"));
@@ -110,7 +110,11 @@ function detectLanguage(code, additionalLanguages) {
 	return ((_allLanguages$map$fil = allLanguages.map(([lang, ...features]) => [lang, features.reduce((acc, [match, score]) => acc + [...code.matchAll(match)].length * score, 0)]).filter(([, score]) => score > 20).sort((a, b) => b[1] - a[1])[0]) === null || _allLanguages$map$fil === void 0 ? void 0 : _allLanguages$map$fil[0]) || "plain";
 }
 function processedLanguage(language) {
-	if (/^(?:shellscript|bash|sh|shell|zsh)/i.test(language)) return "shell";
+	try {
+		var _globalThis;
+		if (((_globalThis = globalThis) === null || _globalThis === void 0 ? void 0 : _globalThis.__streamMonacoLegacy__) && /^vue$/i.test(language)) return "html";
+	} catch {}
+	if (/^(?:shellscript|bash|sh|shell|zsh)/i.test(language)) return "shellscript";
 	if (/^(?:powershell|ps1?)/i.test(language)) return "powershell";
 	return language.split(":")[0];
 }
@@ -140,6 +144,13 @@ function processedLanguage(language) {
 * `, customLanguages) // 'kotlin'
 */
 
+//#endregion
+//#region src/monaco-shim.ts
+var monaco_shim_exports = {};
+__export(monaco_shim_exports, { default: () => monaco });
+__reExport(monaco_shim_exports, require("monaco-editor/esm/vs/editor/editor.api"));
+const monaco = monaco_editor_esm_vs_editor_editor_api;
+
 //#endregion
 //#region src/constant.ts
 const defaultLanguages = [
@@ -153,6 +164,8 @@ const defaultLanguages = [
 	"cpp",
 	"rust",
 	"go",
+	"shell",
+	"shellscript",
 	"powershell",
 	"sql",
 	"json",
@@ -220,13 +233,6 @@ function computeMinimalEdit(prev, next) {
 	};
 }
 
-//#endregion
-//#region src/monaco-shim.ts
-var monaco_shim_exports = {};
-__export(monaco_shim_exports, { default: () => monaco });
-__reExport(monaco_shim_exports, require("monaco-editor"));
-const monaco = monaco_editor;
-
 //#endregion
 //#region src/utils/logger.ts
 let seq = 0;
@@ -468,7 +474,8 @@ function createScrollWatcherForEditor(ed, opts) {
 
 //#endregion
 //#region src/core/DiffEditorManager.ts
-var DiffEditorManager = class {
+var DiffEditorManager = class DiffEditorManager {
+	static diffUiStyleId = "stream-monaco-diff-ui-style";
 	diffEditorView = null;
 	originalModel = null;
 	modifiedModel = null;
@@ -524,7 +531,21 @@ var DiffEditorManager = class {
 	appendFlushThrottleTimerDiff = null;
 	rafScheduler = createRafScheduler();
 	diffHeightManager = null;
-	constructor(options, maxHeightValue, maxHeightCSS, autoScrollOnUpdate, autoScrollInitial, autoScrollThresholdPx, autoScrollThresholdLines, diffAutoScroll, revealDebounceMsOption) {
+	diffHunkDisposables = [];
+	diffHunkOverlay = null;
+	diffHunkUpperNode = null;
+	diffHunkLowerNode = null;
+	diffHunkActiveChange = null;
+	diffHunkLineChanges = [];
+	diffHunkFallbackLineChanges = [];
+	diffHunkFallbackVersions = null;
+	diffHunkHideTimer = null;
+	diffUnchangedRegionDisposables = [];
+	diffUnchangedRegionObserver = null;
+	diffUnchangedBridgeOverlay = null;
+	diffUnchangedBridgeDisposables = [];
+	diffPersistedUnchangedModelState = null;
+	constructor(options, maxHeightValue, maxHeightCSS, autoScrollOnUpdate, autoScrollInitial, autoScrollThresholdPx, autoScrollThresholdLines, diffAutoScroll, revealDebounceMsOption, diffUpdateThrottleMsOption) {
 		this.options = options;
 		this.maxHeightValue = maxHeightValue;
 		this.maxHeightCSS = maxHeightCSS;
@@ -534,6 +555,1111 @@ var DiffEditorManager = class {
 		this.autoScrollThresholdLines = autoScrollThresholdLines;
 		this.diffAutoScroll = diffAutoScroll;
 		this.revealDebounceMsOption = revealDebounceMsOption;
+		this.diffUpdateThrottleMsOption = diffUpdateThrottleMsOption;
+	}
+	resolveDiffHideUnchangedRegionsOption() {
+		const normalize = (value) => {
+			if (typeof value === "boolean") return { enabled: value };
+			if (value && typeof value === "object") {
+				const raw = value;
+				return {
+					enabled: raw.enabled ?? true,
+					...raw
+				};
+			}
+			return { enabled: false };
+		};
+		const direct = this.options.hideUnchangedRegions;
+		if (typeof direct !== "undefined") return normalize(direct);
+		const viaOption = this.options.diffHideUnchangedRegions;
+		if (typeof viaOption !== "undefined") return normalize(viaOption);
+		return {
+			enabled: true,
+			contextLineCount: 3,
+			minimumLineCount: 3,
+			revealLineCount: 3
+		};
+	}
+	disposeDiffHunkInteractions() {
+		if (this.diffHunkHideTimer != null) {
+			clearTimeout(this.diffHunkHideTimer);
+			this.diffHunkHideTimer = null;
+		}
+		this.diffHunkActiveChange = null;
+		this.diffHunkLineChanges = [];
+		this.diffHunkFallbackLineChanges = [];
+		this.diffHunkFallbackVersions = null;
+		if (this.diffHunkDisposables.length > 0) {
+			for (const d of this.diffHunkDisposables) try {
+				d.dispose();
+			} catch {}
+			this.diffHunkDisposables.length = 0;
+		}
+		if (this.diffHunkOverlay) {
+			this.diffHunkOverlay.remove();
+			this.diffHunkOverlay = null;
+		}
+		this.diffHunkUpperNode = null;
+		this.diffHunkLowerNode = null;
+	}
+	computeLineChangesFallback(originalModel, modifiedModel) {
+		const original = originalModel.getValue().split(/\r?\n/);
+		const modified = modifiedModel.getValue().split(/\r?\n/);
+		const n = original.length;
+		const m = modified.length;
+		if (n === 0 && m === 0) return [];
+		const maxCells = 15e5;
+		if ((n + 1) * (m + 1) > maxCells) return originalModel.getValue() === modifiedModel.getValue() ? [] : [{
+			originalStartLineNumber: 1,
+			originalEndLineNumber: n,
+			modifiedStartLineNumber: 1,
+			modifiedEndLineNumber: m,
+			charChanges: []
+		}];
+		const cols = m + 1;
+		const dp = new Uint32Array((n + 1) * (m + 1));
+		for (let i$1 = 1; i$1 <= n; i$1++) for (let j$1 = 1; j$1 <= m; j$1++) {
+			const idx = i$1 * cols + j$1;
+			if (original[i$1 - 1] === modified[j$1 - 1]) dp[idx] = dp[(i$1 - 1) * cols + (j$1 - 1)] + 1;
+			else {
+				const top = dp[(i$1 - 1) * cols + j$1];
+				const left = dp[i$1 * cols + (j$1 - 1)];
+				dp[idx] = top >= left ? top : left;
+			}
+		}
+		const matches = [];
+		let i = n;
+		let j = m;
+		while (i > 0 && j > 0) if (original[i - 1] === modified[j - 1]) {
+			matches.push({
+				o: i,
+				m: j
+			});
+			i--;
+			j--;
+		} else {
+			const top = dp[(i - 1) * cols + j];
+			const left = dp[i * cols + (j - 1)];
+			if (top >= left) i--;
+			else j--;
+		}
+		matches.reverse();
+		matches.push({
+			o: n + 1,
+			m: m + 1
+		});
+		const lineChanges = [];
+		let prevO = 1;
+		let prevM = 1;
+		for (const match of matches) {
+			const oStart = prevO;
+			const oEnd = match.o - 1;
+			const mStart = prevM;
+			const mEnd = match.m - 1;
+			const hasOriginal = oStart <= oEnd;
+			const hasModified = mStart <= mEnd;
+			if (hasOriginal || hasModified) lineChanges.push({
+				originalStartLineNumber: hasOriginal ? oStart : oStart,
+				originalEndLineNumber: hasOriginal ? oEnd : oStart - 1,
+				modifiedStartLineNumber: hasModified ? mStart : mStart,
+				modifiedEndLineNumber: hasModified ? mEnd : mStart - 1,
+				charChanges: []
+			});
+			prevO = match.o + 1;
+			prevM = match.m + 1;
+		}
+		return lineChanges;
+	}
+	getEffectiveLineChanges() {
+		if (!this.diffEditorView) return [];
+		const nativeLineChanges = this.diffEditorView.getLineChanges();
+		if (nativeLineChanges) {
+			this.diffHunkFallbackLineChanges = [];
+			this.diffHunkFallbackVersions = null;
+			return nativeLineChanges;
+		}
+		if (!this.originalModel || !this.modifiedModel) return [];
+		const versions = {
+			original: this.originalModel.getAlternativeVersionId(),
+			modified: this.modifiedModel.getAlternativeVersionId()
+		};
+		if (this.diffHunkFallbackVersions && this.diffHunkFallbackVersions.original === versions.original && this.diffHunkFallbackVersions.modified === versions.modified) return this.diffHunkFallbackLineChanges;
+		this.diffHunkFallbackLineChanges = this.computeLineChangesFallback(this.originalModel, this.modifiedModel);
+		this.diffHunkFallbackVersions = versions;
+		return this.diffHunkFallbackLineChanges;
+	}
+	ensureDiffUiStyle() {
+		if (typeof document === "undefined") return;
+		if (document.getElementById(DiffEditorManager.diffUiStyleId)) return;
+		const style = document.createElement("style");
+		style.id = DiffEditorManager.diffUiStyleId;
+		style.textContent = `
+.stream-monaco-diff-root {
+  --stream-monaco-unchanged-fg: var(--vscode-diffEditor-unchangedRegionForeground, var(--vscode-editor-foreground, currentColor));
+  --stream-monaco-unchanged-bg: var(--vscode-diffEditor-unchangedRegionBackground, transparent);
+  --stream-monaco-editor-bg: var(--vscode-editor-background, #fff);
+  --stream-monaco-widget-shadow: var(--vscode-widget-shadow, rgb(0 0 0 / 30%));
+  --stream-monaco-focus: var(--vscode-focusBorder, var(--stream-monaco-unchanged-fg));
+  --stream-monaco-surface: color-mix(in srgb, var(--stream-monaco-unchanged-bg) 82%, var(--stream-monaco-editor-bg) 18%);
+  --stream-monaco-surface-hover: color-mix(in srgb, var(--stream-monaco-unchanged-bg) 72%, var(--stream-monaco-editor-bg) 28%);
+  --stream-monaco-surface-soft: color-mix(in srgb, var(--stream-monaco-unchanged-bg) 55%, transparent);
+  --stream-monaco-border: color-mix(in srgb, var(--stream-monaco-unchanged-fg) 20%, transparent);
+  --stream-monaco-border-strong: color-mix(in srgb, var(--stream-monaco-unchanged-fg) 34%, transparent);
+  --stream-monaco-muted: color-mix(in srgb, var(--stream-monaco-unchanged-fg) 72%, transparent);
+  --stream-monaco-accent-soft: color-mix(in srgb, var(--stream-monaco-focus) 18%, transparent);
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines-widget {
+  pointer-events: auto;
+  box-sizing: border-box;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines {
+  height: auto;
+  width: 100%;
+  transform: translateY(-10px);
+  padding: 4px 4px 6px;
+  box-sizing: border-box;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .top,
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .bottom {
+  display: none !important;
+  pointer-events: none !important;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center {
+  align-items: center;
+  gap: 10px;
+  max-width: calc(100% - 6px);
+  min-height: 32px;
+  margin: 0 auto;
+  padding: 4px 10px 4px 8px;
+  border-radius: 14px;
+  border: 1px solid var(--stream-monaco-border);
+  background: linear-gradient(180deg, var(--stream-monaco-surface) 0%, color-mix(in srgb, var(--stream-monaco-surface) 92%, var(--stream-monaco-editor-bg) 8%) 100%);
+  box-shadow: 0 14px 26px -22px var(--stream-monaco-widget-shadow);
+  box-sizing: border-box;
+  overflow: hidden;
+  transition: background-color 0.16s ease, border-color 0.16s ease, box-shadow 0.16s ease, transform 0.16s ease;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center.stream-monaco-clickable {
+  cursor: pointer;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center.stream-monaco-unchanged-bridge-source {
+  opacity: 0;
+  pointer-events: none;
+  border-color: transparent;
+  background: transparent;
+  box-shadow: none;
+  transform: none !important;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center.stream-monaco-unchanged-bridge-source > * {
+  visibility: hidden;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center.stream-monaco-unchanged-merged-secondary {
+  padding-left: 10px;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center:hover,
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center.stream-monaco-focus-within {
+  background: linear-gradient(180deg, var(--stream-monaco-surface-hover) 0%, color-mix(in srgb, var(--stream-monaco-surface-hover) 92%, var(--stream-monaco-editor-bg) 8%) 100%);
+  border-color: var(--stream-monaco-border-strong);
+  box-shadow: 0 18px 30px -24px var(--stream-monaco-widget-shadow);
+  transform: translateY(-1px);
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center.stream-monaco-unchanged-merged-secondary .stream-monaco-unchanged-primary {
+  display: none !important;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-primary,
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-primary {
+  display: flex;
+  align-items: center;
+  flex: 0 0 auto;
+  width: auto !important;
+  min-width: max-content;
+  overflow: visible;
+  justify-content: flex-start !important;
+}
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-primary {
+  width: 100% !important;
+  justify-content: center !important;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-expand,
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-expand {
+  appearance: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  min-height: 24px;
+  padding: 0 10px;
+  border-radius: 999px;
+  text-decoration: none;
+  color: inherit;
+  background: color-mix(in srgb, var(--stream-monaco-unchanged-fg) 12%, transparent);
+  border: 1px solid color-mix(in srgb, var(--stream-monaco-unchanged-fg) 10%, transparent);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.01em;
+  white-space: nowrap;
+  transition: background-color 0.14s ease, border-color 0.14s ease, transform 0.14s ease;
+}
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-expand {
+  min-height: 0;
+  padding: 0;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  box-shadow: none;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-expand::after,
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-expand::after {
+  content: attr(data-stream-monaco-label);
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-expand:hover,
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-expand:focus-visible,
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-expand:hover {
+  background: color-mix(in srgb, var(--stream-monaco-unchanged-fg) 18%, transparent);
+  border-color: color-mix(in srgb, var(--stream-monaco-unchanged-fg) 22%, transparent);
+  transform: translateY(-1px);
+}
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-expand:hover {
+  background: transparent;
+  border-color: transparent;
+  transform: none;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-meta,
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-meta {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+  flex: 1 1 auto;
+  overflow: hidden;
+  color: var(--stream-monaco-muted);
+  white-space: nowrap;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center.stream-monaco-unchanged-merged-secondary .stream-monaco-unchanged-meta {
+  justify-content: center;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-count,
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-count {
+  display: inline-flex;
+  align-items: center;
+  flex: 0 0 auto;
+  padding: 2px 8px;
+  border-radius: 999px;
+  background: var(--stream-monaco-surface-soft);
+  color: var(--stream-monaco-unchanged-fg);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.01em;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-separator {
+  flex: 0 0 auto;
+  opacity: 0.35;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-breadcrumb,
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .breadcrumb-item {
+  min-width: 0;
+  max-width: 100%;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-breadcrumb {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  border-radius: 6px;
+  padding: 2px 6px;
+  transition: background-color 0.14s ease, color 0.14s ease;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center .stream-monaco-unchanged-breadcrumb:hover {
+  background: color-mix(in srgb, var(--stream-monaco-unchanged-fg) 10%, transparent);
+  color: var(--stream-monaco-unchanged-fg);
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center.stream-monaco-unchanged-merged-secondary .stream-monaco-unchanged-separator,
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center.stream-monaco-unchanged-merged-secondary .stream-monaco-unchanged-breadcrumb {
+  display: none;
+}
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-overlay {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  z-index: 12;
+}
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge {
+  position: absolute;
+  display: grid;
+  grid-template-columns: minmax(max-content, 1fr) auto minmax(max-content, 1fr);
+  align-items: center;
+  column-gap: 12px;
+  min-height: 32px;
+  padding: 4px 12px 4px 10px;
+  border-radius: 14px;
+  border: 1px solid color-mix(in srgb, var(--stream-monaco-unchanged-fg) 24%, transparent);
+  background: linear-gradient(180deg, color-mix(in srgb, var(--stream-monaco-editor-bg) 88%, var(--stream-monaco-unchanged-fg) 12%) 0%, color-mix(in srgb, var(--stream-monaco-editor-bg) 94%, var(--stream-monaco-unchanged-fg) 6%) 100%);
+  box-shadow: 0 14px 26px -22px var(--stream-monaco-widget-shadow);
+  box-sizing: border-box;
+  overflow: hidden;
+  pointer-events: auto;
+  transition: background-color 0.16s ease, border-color 0.16s ease, box-shadow 0.16s ease, transform 0.16s ease;
+}
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge:hover,
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge.stream-monaco-focus-visible {
+  background: linear-gradient(180deg, color-mix(in srgb, var(--stream-monaco-editor-bg) 84%, var(--stream-monaco-unchanged-fg) 16%) 0%, color-mix(in srgb, var(--stream-monaco-editor-bg) 92%, var(--stream-monaco-unchanged-fg) 8%) 100%);
+  border-color: color-mix(in srgb, var(--stream-monaco-unchanged-fg) 32%, transparent);
+  box-shadow: 0 18px 30px -24px var(--stream-monaco-widget-shadow);
+  transform: translateY(-1px);
+}
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge:focus {
+  outline: none;
+}
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-meta {
+  justify-self: center;
+  justify-content: center;
+}
+.stream-monaco-diff-root .stream-monaco-diff-unchanged-bridge .stream-monaco-unchanged-spacer {
+  display: block;
+  visibility: hidden;
+  width: 100%;
+  height: 1px;
+  flex: 0 0 auto;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines-compact {
+  align-items: center;
+  gap: 6px;
+  height: 16px;
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines-compact .text {
+  padding: 0 6px;
+  border-radius: 999px;
+  background: var(--stream-monaco-surface-soft);
+  color: var(--stream-monaco-unchanged-fg);
+}
+.stream-monaco-diff-root .monaco-editor .fold-unchanged {
+  display: flex !important;
+  align-items: center;
+  justify-content: center;
+  width: 18px !important;
+  height: 18px !important;
+  margin-left: 4px;
+  border-radius: 999px;
+  color: var(--stream-monaco-unchanged-fg);
+  background: var(--stream-monaco-surface);
+  border: 1px solid var(--stream-monaco-border);
+  box-shadow: 0 10px 18px -18px var(--stream-monaco-widget-shadow);
+  opacity: 0.88 !important;
+  transition: background-color 0.14s ease, border-color 0.14s ease, transform 0.14s ease, opacity 0.14s ease, box-shadow 0.14s ease;
+}
+.stream-monaco-diff-root .monaco-editor .fold-unchanged:hover,
+.stream-monaco-diff-root .monaco-editor .fold-unchanged.stream-monaco-focus-visible {
+  opacity: 1 !important;
+  transform: translateY(-1px);
+  background: var(--stream-monaco-surface-hover);
+  border-color: var(--stream-monaco-border-strong);
+  box-shadow: 0 14px 24px -18px var(--stream-monaco-widget-shadow);
+}
+.stream-monaco-diff-root .monaco-editor .diff-hidden-lines .center:focus,
+.stream-monaco-diff-root .monaco-editor .fold-unchanged:focus {
+  outline: none;
+}
+.stream-monaco-diff-hunk-overlay {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  z-index: 20;
+}
+.stream-monaco-diff-hunk-actions {
+  position: absolute;
+  left: 0;
+  top: 0;
+  display: none;
+  gap: 6px;
+  pointer-events: auto;
+  padding: 4px;
+  border-radius: 999px;
+  background: color-mix(in srgb, #f8f8f8 92%, #000 8%);
+  border: 1px solid color-mix(in srgb, #ddd 88%, #000 12%);
+  box-shadow: 0 2px 12px rgb(0 0 0 / 10%);
+}
+.stream-monaco-diff-hunk-actions button {
+  appearance: none;
+  border: 0;
+  border-radius: 999px;
+  padding: 3px 9px;
+  font-size: 11px;
+  line-height: 1.35;
+  background: white;
+  color: #222;
+  cursor: pointer;
+}
+.stream-monaco-diff-hunk-actions button:hover {
+  background: #f1f1f1;
+}
+.stream-monaco-diff-hunk-actions button:disabled {
+  opacity: 0.45;
+  cursor: default;
+}
+`;
+		document.head.append(style);
+	}
+	createDomDisposable(bucket, el, eventName, listener) {
+		el.addEventListener(eventName, listener);
+		bucket.push({ dispose: () => el.removeEventListener(eventName, listener) });
+	}
+	createDiffHunkActionNode(side) {
+		const node = document.createElement("div");
+		node.className = "stream-monaco-diff-hunk-actions";
+		node.dataset.side = side;
+		const createButton = (action, label) => {
+			const button = document.createElement("button");
+			button.type = "button";
+			button.textContent = label;
+			button.dataset.action = action;
+			button.addEventListener("click", (event) => {
+				event.preventDefault();
+				event.stopPropagation();
+				this.applyDiffHunkAction(side, action);
+			});
+			return button;
+		};
+		node.append(createButton("revert", "Revert"), createButton("stage", "Stage"));
+		this.createDomDisposable(this.diffHunkDisposables, node, "mouseenter", () => this.cancelScheduledHideDiffHunkActions());
+		this.createDomDisposable(this.diffHunkDisposables, node, "mouseleave", () => this.scheduleHideDiffHunkActions());
+		return node;
+	}
+	cloneSerializableValue(value) {
+		if (typeof structuredClone === "function") return structuredClone(value);
+		return JSON.parse(JSON.stringify(value));
+	}
+	capturePersistedDiffUnchangedState() {
+		if (!this.diffEditorView) return;
+		const state = this.diffEditorView.saveViewState();
+		if (!(state === null || state === void 0 ? void 0 : state.modelState)) {
+			this.diffPersistedUnchangedModelState = null;
+			return;
+		}
+		this.diffPersistedUnchangedModelState = this.cloneSerializableValue(state.modelState);
+	}
+	scheduleCapturePersistedDiffUnchangedState(frames = 1) {
+		this.rafScheduler.schedule("capture-diff-unchanged-state", () => {
+			let remaining = Math.max(0, frames);
+			const step = () => {
+				if (remaining > 0) {
+					remaining--;
+					requestAnimationFrame(step);
+					return;
+				}
+				this.capturePersistedDiffUnchangedState();
+			};
+			step();
+		});
+	}
+	restorePersistedDiffUnchangedState() {
+		if (!this.diffEditorView || !this.diffPersistedUnchangedModelState) return;
+		const current = this.diffEditorView.saveViewState();
+		if (!current) return;
+		this.diffEditorView.restoreViewState({
+			original: current.original,
+			modified: current.modified,
+			modelState: this.cloneSerializableValue(this.diffPersistedUnchangedModelState)
+		});
+	}
+	scheduleRestorePersistedDiffUnchangedState() {
+		if (!this.diffPersistedUnchangedModelState) return;
+		this.rafScheduler.schedule("restore-diff-unchanged-state", () => {
+			requestAnimationFrame(() => {
+				this.restorePersistedDiffUnchangedState();
+			});
+		});
+	}
+	bindPersistOnMouseRelease(bucket, node) {
+		this.createDomDisposable(bucket, node, "mousedown", (event) => {
+			const mouseEvent = event;
+			if (mouseEvent.button !== 0) return;
+			const view = node.ownerDocument.defaultView;
+			if (!view) return;
+			const handleMouseUp = () => {
+				view.removeEventListener("mouseup", handleMouseUp);
+				this.scheduleCapturePersistedDiffUnchangedState(1);
+			};
+			view.addEventListener("mouseup", handleMouseUp, { once: true });
+		});
+	}
+	disposeDiffUnchangedRegionEnhancements() {
+		if (this.diffUnchangedRegionObserver) {
+			this.diffUnchangedRegionObserver.disconnect();
+			this.diffUnchangedRegionObserver = null;
+		}
+		this.clearDiffUnchangedBridgeOverlay();
+		if (this.diffUnchangedRegionDisposables.length > 0) {
+			for (const d of this.diffUnchangedRegionDisposables) try {
+				d.dispose();
+			} catch {}
+			this.diffUnchangedRegionDisposables.length = 0;
+		}
+		this.rafScheduler.cancel("patch-diff-unchanged-regions");
+		this.rafScheduler.cancel("capture-diff-unchanged-state");
+		this.rafScheduler.cancel("restore-diff-unchanged-state");
+	}
+	bindFocusVisibleClass(bucket, node) {
+		this.createDomDisposable(bucket, node, "focus", () => node.classList.add("stream-monaco-focus-visible"));
+		this.createDomDisposable(bucket, node, "blur", () => node.classList.remove("stream-monaco-focus-visible"));
+	}
+	bindFocusWithinClass(bucket, node, className) {
+		this.createDomDisposable(bucket, node, "focusin", () => node.classList.add(className));
+		this.createDomDisposable(bucket, node, "focusout", () => {
+			requestAnimationFrame(() => {
+				if (node.matches(":focus-within")) return;
+				node.classList.remove(className);
+			});
+		});
+	}
+	clearDiffUnchangedBridgeOverlay(removeContainer = true) {
+		var _this$diffUnchangedBr;
+		if (this.lastContainer) {
+			const bridgedCenters = this.lastContainer.querySelectorAll(".stream-monaco-unchanged-bridge-source");
+			bridgedCenters.forEach((node) => node.classList.remove("stream-monaco-unchanged-bridge-source"));
+		}
+		if (this.diffUnchangedBridgeOverlay) this.diffUnchangedBridgeOverlay.replaceChildren();
+		if (this.diffUnchangedBridgeDisposables.length > 0) {
+			for (const d of this.diffUnchangedBridgeDisposables) try {
+				d.dispose();
+			} catch {}
+			this.diffUnchangedBridgeDisposables.length = 0;
+		}
+		if (removeContainer && ((_this$diffUnchangedBr = this.diffUnchangedBridgeOverlay) === null || _this$diffUnchangedBr === void 0 ? void 0 : _this$diffUnchangedBr.parentElement)) this.diffUnchangedBridgeOverlay.remove();
+		if (removeContainer) this.diffUnchangedBridgeOverlay = null;
+	}
+	ensureDiffUnchangedBridgeOverlay() {
+		if (!this.lastContainer) return null;
+		if (!this.diffUnchangedBridgeOverlay) {
+			const overlay = document.createElement("div");
+			overlay.className = "stream-monaco-diff-unchanged-overlay";
+			this.lastContainer.append(overlay);
+			this.diffUnchangedBridgeOverlay = overlay;
+		}
+		return this.diffUnchangedBridgeOverlay;
+	}
+	dispatchSyntheticMouseDown(node) {
+		const view = node.ownerDocument.defaultView;
+		if (!view) return;
+		const rect = node.getBoundingClientRect();
+		node.dispatchEvent(new view.MouseEvent("mousedown", {
+			bubbles: true,
+			cancelable: true,
+			button: 0,
+			clientX: rect.left + rect.width / 2,
+			clientY: rect.top + rect.height / 2
+		}));
+	}
+	resolveDiffUnchangedMergeRole(node) {
+		var _this$diffEditorView, _this$diffEditorView$, _this$diffEditorView$2, _this$diffEditorView2, _this$diffEditorView3, _this$diffEditorView4;
+		const diffRoot = node.closest(".monaco-diff-editor.side-by-side");
+		if (!(diffRoot instanceof HTMLElement)) return "none";
+		const nodeRect = node.getBoundingClientRect();
+		const nodeCenter = nodeRect.left + nodeRect.width / 2;
+		const originalHost = (_this$diffEditorView = this.diffEditorView) === null || _this$diffEditorView === void 0 || (_this$diffEditorView$2 = (_this$diffEditorView$ = _this$diffEditorView.getOriginalEditor()).getContainerDomNode) === null || _this$diffEditorView$2 === void 0 ? void 0 : _this$diffEditorView$2.call(_this$diffEditorView$);
+		const modifiedHost = (_this$diffEditorView2 = this.diffEditorView) === null || _this$diffEditorView2 === void 0 || (_this$diffEditorView4 = (_this$diffEditorView3 = _this$diffEditorView2.getModifiedEditor()).getContainerDomNode) === null || _this$diffEditorView4 === void 0 ? void 0 : _this$diffEditorView4.call(_this$diffEditorView3);
+		if (originalHost instanceof HTMLElement && modifiedHost instanceof HTMLElement) {
+			const originalRect = originalHost.getBoundingClientRect();
+			const modifiedRect = modifiedHost.getBoundingClientRect();
+			const originalCenter = originalRect.left + originalRect.width / 2;
+			const modifiedCenter = modifiedRect.left + modifiedRect.width / 2;
+			return Math.abs(nodeCenter - originalCenter) <= Math.abs(nodeCenter - modifiedCenter) ? "secondary" : "primary";
+		}
+		const diffRect = diffRoot.getBoundingClientRect();
+		return nodeCenter < diffRect.left + diffRect.width / 2 ? "secondary" : "primary";
+	}
+	patchDiffUnchangedCenter(node) {
+		node.classList.add("stream-monaco-clickable");
+		node.title = "Click to expand all hidden unchanged lines";
+		const mergeRole = this.resolveDiffUnchangedMergeRole(node);
+		const shouldUseMergedSecondary = mergeRole === "secondary";
+		node.classList.toggle("stream-monaco-unchanged-merged-secondary", shouldUseMergedSecondary);
+		node.classList.toggle("stream-monaco-unchanged-merged-primary", mergeRole === "primary");
+		const primary = node.children.item(0);
+		const meta = node.children.item(1);
+		if (primary instanceof HTMLElement) primary.classList.add("stream-monaco-unchanged-primary");
+		if (meta instanceof HTMLElement) {
+			meta.classList.add("stream-monaco-unchanged-meta");
+			const metaChildren = Array.from(meta.children);
+			metaChildren.forEach((child, index) => {
+				if (!(child instanceof HTMLElement)) return;
+				child.classList.remove("stream-monaco-unchanged-count", "stream-monaco-unchanged-separator", "stream-monaco-unchanged-breadcrumb");
+				if (index === 0) child.classList.add("stream-monaco-unchanged-count");
+				else if (child.classList.contains("breadcrumb-item")) child.classList.add("stream-monaco-unchanged-breadcrumb");
+				else child.classList.add("stream-monaco-unchanged-separator");
+			});
+		}
+		const action = node.querySelector("a");
+		if (action instanceof HTMLElement) {
+			action.classList.add("stream-monaco-unchanged-expand");
+			action.dataset.streamMonacoLabel = "Expand all";
+			action.title = "Expand all hidden lines";
+			action.setAttribute("aria-label", "Expand all hidden lines");
+			action.toggleAttribute("aria-hidden", shouldUseMergedSecondary);
+			action.tabIndex = shouldUseMergedSecondary ? -1 : 0;
+			if (action.dataset.streamMonacoExpandPatched !== "true") {
+				action.dataset.streamMonacoExpandPatched = "true";
+				this.createDomDisposable(this.diffUnchangedRegionDisposables, action, "click", () => {
+					this.scheduleCapturePersistedDiffUnchangedState(1);
+				});
+			}
+		}
+		if (node.dataset.streamMonacoCenterPatched !== "true") {
+			node.dataset.streamMonacoCenterPatched = "true";
+			this.bindFocusWithinClass(this.diffUnchangedRegionDisposables, node, "stream-monaco-focus-within");
+			const activate = () => {
+				const action$1 = node.querySelector("a");
+				if (action$1 instanceof HTMLElement) action$1.click();
+			};
+			this.createDomDisposable(this.diffUnchangedRegionDisposables, node, "click", (event) => {
+				const mouseEvent = event;
+				if (mouseEvent.button !== 0) return;
+				const target = event.target instanceof HTMLElement ? event.target : null;
+				if (target === null || target === void 0 ? void 0 : target.closest("a, .breadcrumb-item")) return;
+				event.preventDefault();
+				activate();
+				this.scheduleCapturePersistedDiffUnchangedState(1);
+			});
+		}
+	}
+	renderMergedDiffUnchangedBridge(secondaryNode, primaryNode) {
+		var _countSource$textCont;
+		if (!this.lastContainer) return;
+		const overlay = this.ensureDiffUnchangedBridgeOverlay();
+		if (!overlay) return;
+		const containerRect = this.lastContainer.getBoundingClientRect();
+		const secondaryRect = secondaryNode.getBoundingClientRect();
+		const primaryRect = primaryNode.getBoundingClientRect();
+		const primaryStyle = globalThis.getComputedStyle(primaryNode);
+		const primaryAction = primaryNode.querySelector(".stream-monaco-unchanged-expand");
+		const primaryActionRect = primaryAction === null || primaryAction === void 0 ? void 0 : primaryAction.getBoundingClientRect();
+		const countSource = primaryNode.querySelector(".stream-monaco-unchanged-count") ?? secondaryNode.querySelector(".stream-monaco-unchanged-count");
+		const countText = (countSource === null || countSource === void 0 || (_countSource$textCont = countSource.textContent) === null || _countSource$textCont === void 0 ? void 0 : _countSource$textCont.trim()) || "Hidden lines";
+		const editorSurface = primaryNode.closest(".monaco-editor") ?? primaryNode;
+		const editorSurfaceStyle = globalThis.getComputedStyle(editorSurface);
+		secondaryNode.classList.add("stream-monaco-unchanged-bridge-source");
+		primaryNode.classList.add("stream-monaco-unchanged-bridge-source");
+		const bridge = document.createElement("div");
+		bridge.className = "stream-monaco-diff-unchanged-bridge";
+		bridge.tabIndex = 0;
+		bridge.setAttribute("role", "button");
+		bridge.setAttribute("aria-label", `${countText}. Expand all hidden lines`);
+		bridge.title = "Expand all hidden lines";
+		bridge.style.left = `${secondaryRect.left - containerRect.left}px`;
+		bridge.style.top = `${primaryRect.top - containerRect.top}px`;
+		bridge.style.width = `${primaryRect.right - secondaryRect.left}px`;
+		bridge.style.height = `${Math.max(secondaryRect.height, primaryRect.height)}px`;
+		bridge.style.color = primaryStyle.color;
+		bridge.style.fontFamily = primaryStyle.fontFamily;
+		bridge.style.fontSize = primaryStyle.fontSize;
+		bridge.style.lineHeight = primaryStyle.lineHeight;
+		bridge.style.setProperty("--stream-monaco-unchanged-fg", primaryStyle.color);
+		bridge.style.setProperty("--stream-monaco-editor-bg", editorSurfaceStyle.backgroundColor);
+		const visualPrimary = document.createElement("span");
+		visualPrimary.className = "stream-monaco-unchanged-primary";
+		const visualAction = document.createElement("span");
+		visualAction.className = "stream-monaco-unchanged-expand";
+		visualAction.dataset.streamMonacoLabel = "Expand all";
+		visualAction.setAttribute("aria-hidden", "true");
+		visualAction.innerHTML = "<span class=\"codicon codicon-unfold\"></span>";
+		visualPrimary.append(visualAction);
+		const visualMeta = document.createElement("div");
+		visualMeta.className = "stream-monaco-unchanged-meta";
+		const visualCount = document.createElement("span");
+		visualCount.className = "stream-monaco-unchanged-count";
+		visualCount.textContent = countText;
+		visualMeta.append(visualCount);
+		const spacer = document.createElement("span");
+		spacer.className = "stream-monaco-unchanged-spacer";
+		spacer.style.width = `${(primaryActionRect === null || primaryActionRect === void 0 ? void 0 : primaryActionRect.width) ?? 102}px`;
+		bridge.append(visualPrimary, visualMeta, spacer);
+		overlay.append(bridge);
+		this.bindFocusVisibleClass(this.diffUnchangedBridgeDisposables, bridge);
+		const activate = () => {
+			const action = primaryNode.querySelector("a, button") ?? secondaryNode.querySelector("a, button");
+			if (action instanceof HTMLElement) {
+				action.click();
+				this.scheduleCapturePersistedDiffUnchangedState(1);
+			}
+		};
+		this.createDomDisposable(this.diffUnchangedBridgeDisposables, bridge, "click", (event) => {
+			const mouseEvent = event;
+			if (mouseEvent.button !== 0) return;
+			event.preventDefault();
+			activate();
+		});
+		this.createDomDisposable(this.diffUnchangedBridgeDisposables, bridge, "keydown", (event) => {
+			const keyboardEvent = event;
+			if (keyboardEvent.key !== "Enter" && keyboardEvent.key !== " ") return;
+			keyboardEvent.preventDefault();
+			activate();
+		});
+	}
+	patchDiffUnchangedFoldGlyph(node) {
+		if (node.dataset.streamMonacoFoldGlyphPatched === "true") return;
+		node.dataset.streamMonacoFoldGlyphPatched = "true";
+		node.tabIndex = 0;
+		node.setAttribute("role", "button");
+		node.setAttribute("aria-label", "Collapse unchanged lines");
+		node.title = node.title || "Collapse unchanged lines";
+		this.bindFocusVisibleClass(this.diffUnchangedRegionDisposables, node);
+		this.bindPersistOnMouseRelease(this.diffUnchangedRegionDisposables, node);
+		this.createDomDisposable(this.diffUnchangedRegionDisposables, node, "keydown", (event) => {
+			const keyboardEvent = event;
+			if (keyboardEvent.key !== "Enter" && keyboardEvent.key !== " ") return;
+			keyboardEvent.preventDefault();
+			this.dispatchSyntheticMouseDown(node);
+			this.scheduleCapturePersistedDiffUnchangedState(1);
+		});
+	}
+	scanAndPatchDiffUnchangedRegions() {
+		if (!this.lastContainer) return;
+		const centers = this.lastContainer.querySelectorAll(".diff-hidden-lines .center");
+		centers.forEach((node) => this.patchDiffUnchangedCenter(node));
+		const partialRevealHandles = this.lastContainer.querySelectorAll(".diff-hidden-lines .top, .diff-hidden-lines .bottom");
+		partialRevealHandles.forEach((node) => {
+			node.removeAttribute("title");
+			node.removeAttribute("aria-label");
+			node.removeAttribute("role");
+			node.removeAttribute("tabindex");
+		});
+		this.clearDiffUnchangedBridgeOverlay(false);
+		const secondaryCenters = Array.from(centers).filter((node) => node.classList.contains("stream-monaco-unchanged-merged-secondary")).sort((a, b) => a.getBoundingClientRect().top - b.getBoundingClientRect().top);
+		const primaryCenters = Array.from(centers).filter((node) => node.classList.contains("stream-monaco-unchanged-merged-primary")).sort((a, b) => a.getBoundingClientRect().top - b.getBoundingClientRect().top);
+		const pairCount = Math.min(secondaryCenters.length, primaryCenters.length);
+		for (let i = 0; i < pairCount; i++) {
+			const secondaryNode = secondaryCenters[i];
+			const primaryNode = primaryCenters[i];
+			const topDelta = Math.abs(secondaryNode.getBoundingClientRect().top - primaryNode.getBoundingClientRect().top);
+			if (topDelta > 6) continue;
+			this.renderMergedDiffUnchangedBridge(secondaryNode, primaryNode);
+		}
+		const foldGlyphs = this.lastContainer.querySelectorAll(".fold-unchanged");
+		foldGlyphs.forEach((node) => this.patchDiffUnchangedFoldGlyph(node));
+	}
+	schedulePatchDiffUnchangedRegions() {
+		this.rafScheduler.schedule("patch-diff-unchanged-regions", () => {
+			this.scanAndPatchDiffUnchangedRegions();
+		});
+	}
+	setupDiffUnchangedRegionEnhancements() {
+		var _globalThis$getComput, _globalThis;
+		this.disposeDiffUnchangedRegionEnhancements();
+		if (!this.diffEditorView || !this.lastContainer) return;
+		if (typeof document === "undefined") return;
+		this.ensureDiffUiStyle();
+		const containerStyle = (_globalThis$getComput = (_globalThis = globalThis).getComputedStyle) === null || _globalThis$getComput === void 0 ? void 0 : _globalThis$getComput.call(_globalThis, this.lastContainer);
+		if (!containerStyle || containerStyle.position === "static") this.lastContainer.style.position = "relative";
+		this.lastContainer.classList.add("stream-monaco-diff-root");
+		this.schedulePatchDiffUnchangedRegions();
+		if (typeof MutationObserver !== "undefined") {
+			this.diffUnchangedRegionObserver = new MutationObserver((mutations) => {
+				const shouldRepatch = mutations.some((mutation) => {
+					const target = mutation.target instanceof HTMLElement ? mutation.target : null;
+					if (target === null || target === void 0 ? void 0 : target.closest(".stream-monaco-diff-unchanged-overlay")) return false;
+					const changedNodes = [...mutation.addedNodes, ...mutation.removedNodes];
+					if (changedNodes.length > 0 && changedNodes.every((node) => {
+						return node instanceof HTMLElement && node.classList.contains("stream-monaco-diff-unchanged-overlay");
+					})) return false;
+					return true;
+				});
+				if (shouldRepatch) this.schedulePatchDiffUnchangedRegions();
+			});
+			this.diffUnchangedRegionObserver.observe(this.lastContainer, {
+				childList: true,
+				subtree: true
+			});
+		}
+		const originalEditor = this.diffEditorView.getOriginalEditor();
+		const modifiedEditor = this.diffEditorView.getModifiedEditor();
+		const repatch = () => this.schedulePatchDiffUnchangedRegions();
+		this.diffUnchangedRegionDisposables.push(this.diffEditorView.onDidUpdateDiff(() => {
+			repatch();
+			this.scheduleRestorePersistedDiffUnchangedState();
+		}));
+		this.diffUnchangedRegionDisposables.push(originalEditor.onDidLayoutChange(repatch));
+		this.diffUnchangedRegionDisposables.push(modifiedEditor.onDidLayoutChange(repatch));
+		this.diffUnchangedRegionDisposables.push(originalEditor.onDidScrollChange(repatch));
+		this.diffUnchangedRegionDisposables.push(modifiedEditor.onDidScrollChange(repatch));
+	}
+	setupDiffHunkInteractions() {
+		var _globalThis$getComput2, _globalThis2;
+		this.disposeDiffHunkInteractions();
+		if (!this.diffEditorView || !this.lastContainer) return;
+		if (this.options.diffHunkActionsOnHover !== true) return;
+		if (typeof document === "undefined") return;
+		this.ensureDiffUiStyle();
+		const containerStyle = (_globalThis$getComput2 = (_globalThis2 = globalThis).getComputedStyle) === null || _globalThis$getComput2 === void 0 ? void 0 : _globalThis$getComput2.call(_globalThis2, this.lastContainer);
+		if (!containerStyle || containerStyle.position === "static") this.lastContainer.style.position = "relative";
+		const overlay = document.createElement("div");
+		overlay.className = "stream-monaco-diff-hunk-overlay";
+		this.diffHunkOverlay = overlay;
+		this.lastContainer.append(overlay);
+		this.diffHunkUpperNode = this.createDiffHunkActionNode("upper");
+		this.diffHunkLowerNode = this.createDiffHunkActionNode("lower");
+		overlay.append(this.diffHunkUpperNode, this.diffHunkLowerNode);
+		const originalEditor = this.diffEditorView.getOriginalEditor();
+		const modifiedEditor = this.diffEditorView.getModifiedEditor();
+		const bindHover = (editor, side) => {
+			this.diffHunkDisposables.push(editor.onMouseMove((event) => {
+				this.handleDiffHunkMouseMove(side, event);
+			}));
+			this.diffHunkDisposables.push(editor.onMouseLeave(() => this.scheduleHideDiffHunkActions()));
+			this.diffHunkDisposables.push(editor.onDidScrollChange(() => this.repositionDiffHunkNodes()));
+			this.diffHunkDisposables.push(editor.onDidLayoutChange(() => this.repositionDiffHunkNodes()));
+		};
+		bindHover(originalEditor, "original");
+		bindHover(modifiedEditor, "modified");
+		this.diffHunkDisposables.push(this.diffEditorView.onDidUpdateDiff(() => {
+			this.diffHunkLineChanges = this.getEffectiveLineChanges();
+			if (this.diffHunkActiveChange) this.hideDiffHunkActions();
+		}));
+		this.diffHunkLineChanges = this.getEffectiveLineChanges();
+	}
+	cancelScheduledHideDiffHunkActions() {
+		if (this.diffHunkHideTimer != null) {
+			clearTimeout(this.diffHunkHideTimer);
+			this.diffHunkHideTimer = null;
+		}
+	}
+	scheduleHideDiffHunkActions(delayMs = this.options.diffHunkHoverHideDelayMs ?? 160) {
+		this.cancelScheduledHideDiffHunkActions();
+		this.diffHunkHideTimer = setTimeout(() => {
+			this.diffHunkHideTimer = null;
+			this.hideDiffHunkActions();
+		}, delayMs);
+	}
+	hideDiffHunkActions() {
+		this.diffHunkActiveChange = null;
+		if (this.diffHunkUpperNode) this.diffHunkUpperNode.style.display = "none";
+		if (this.diffHunkLowerNode) this.diffHunkLowerNode.style.display = "none";
+	}
+	hasOriginalLines(change) {
+		return change.originalStartLineNumber > 0 && change.originalEndLineNumber >= change.originalStartLineNumber;
+	}
+	hasModifiedLines(change) {
+		return change.modifiedStartLineNumber > 0 && change.modifiedEndLineNumber >= change.modifiedStartLineNumber;
+	}
+	distanceToLineChange(side, change, line) {
+		const hasRange = side === "original" ? this.hasOriginalLines(change) : this.hasModifiedLines(change);
+		const start = side === "original" ? change.originalStartLineNumber : change.modifiedStartLineNumber;
+		const end = side === "original" ? change.originalEndLineNumber : change.modifiedEndLineNumber;
+		if (hasRange) {
+			if (line < start) return start - line;
+			if (line > end) return line - end;
+			return 0;
+		}
+		const fallbackAnchor = Math.max(1, start || end || 1);
+		return Math.abs(line - fallbackAnchor);
+	}
+	findLineChangeByHoverLine(side, line) {
+		if (this.diffHunkLineChanges.length === 0) return null;
+		let best = null;
+		let bestDistance = Number.POSITIVE_INFINITY;
+		for (const change of this.diffHunkLineChanges) {
+			const distance = this.distanceToLineChange(side, change, line);
+			if (distance < bestDistance) {
+				bestDistance = distance;
+				best = change;
+				if (distance === 0) break;
+			}
+		}
+		if (bestDistance > 2) return null;
+		return best;
+	}
+	handleDiffHunkMouseMove(side, event) {
+		var _event$target$positio;
+		const line = (_event$target$positio = event.target.position) === null || _event$target$positio === void 0 ? void 0 : _event$target$positio.lineNumber;
+		if (!line) {
+			this.scheduleHideDiffHunkActions(120);
+			return;
+		}
+		const change = this.findLineChangeByHoverLine(side, line);
+		if (!change) {
+			this.scheduleHideDiffHunkActions(120);
+			return;
+		}
+		this.cancelScheduledHideDiffHunkActions();
+		this.diffHunkActiveChange = change;
+		this.repositionDiffHunkNodes();
+	}
+	isOriginalEditorCollapsed() {
+		var _this$diffEditorView$3, _this$diffEditorView$4;
+		if (!this.diffEditorView) return true;
+		const info = (_this$diffEditorView$3 = (_this$diffEditorView$4 = this.diffEditorView.getOriginalEditor()).getLayoutInfo) === null || _this$diffEditorView$3 === void 0 ? void 0 : _this$diffEditorView$3.call(_this$diffEditorView$4);
+		return !info || info.width < 24;
+	}
+	getEditorBySide(side) {
+		if (!this.diffEditorView) return null;
+		return side === "original" ? this.diffEditorView.getOriginalEditor() : this.diffEditorView.getModifiedEditor();
+	}
+	getFullLineRange(model, startLine, endLine) {
+		if (endLine < startLine) return null;
+		const lineCount = model.getLineCount();
+		if (lineCount < 1) return null;
+		const start = Math.max(1, Math.min(startLine, lineCount));
+		const end = Math.max(start, Math.min(endLine, lineCount));
+		if (end < lineCount) return new monaco_shim_exports.Range(start, 1, end + 1, 1);
+		return new monaco_shim_exports.Range(start, 1, end, model.getLineMaxColumn(end));
+	}
+	getLinesText(model, startLine, endLine) {
+		const range = this.getFullLineRange(model, startLine, endLine);
+		if (!range) return "";
+		return model.getValueInRange(range);
+	}
+	getInsertRangeBeforeLine(model, lineNumber) {
+		const lineCount = model.getLineCount();
+		if (lineNumber <= 1) return new monaco_shim_exports.Range(1, 1, 1, 1);
+		if (lineNumber <= lineCount) return new monaco_shim_exports.Range(lineNumber, 1, lineNumber, 1);
+		const lastLine = lineCount;
+		const lastColumn = model.getLineMaxColumn(lastLine);
+		return new monaco_shim_exports.Range(lastLine, lastColumn, lastLine, lastColumn);
+	}
+	getInsertRangeAfterLine(model, lineNumber) {
+		const lineCount = model.getLineCount();
+		if (lineNumber < 1) return new monaco_shim_exports.Range(1, 1, 1, 1);
+		if (lineNumber < lineCount) return new monaco_shim_exports.Range(lineNumber + 1, 1, lineNumber + 1, 1);
+		const lastLine = lineCount;
+		const lastColumn = model.getLineMaxColumn(lastLine);
+		return new monaco_shim_exports.Range(lastLine, lastColumn, lastLine, lastColumn);
+	}
+	syncDiffKnownValues() {
+		var _this$diffEditorView5, _this$diffEditorView6, _this$diffEditorView7, _this$diffHeightManag;
+		if (this.originalModel) this.lastKnownOriginalCode = this.originalModel.getValue();
+		if (this.modifiedModel) {
+			this.lastKnownModifiedCode = this.modifiedModel.getValue();
+			this.lastKnownModifiedLineCount = this.modifiedModel.getLineCount();
+		}
+		this.lastKnownModifiedDirty = false;
+		this._hasScrollBar = false;
+		this.cachedComputedHeightDiff = this.computedHeight();
+		this.cachedScrollHeightDiff = ((_this$diffEditorView5 = this.diffEditorView) === null || _this$diffEditorView5 === void 0 || (_this$diffEditorView7 = (_this$diffEditorView6 = _this$diffEditorView5.getModifiedEditor()).getScrollHeight) === null || _this$diffEditorView7 === void 0 ? void 0 : _this$diffEditorView7.call(_this$diffEditorView6)) ?? this.cachedScrollHeightDiff;
+		(_this$diffHeightManag = this.diffHeightManager) === null || _this$diffHeightManag === void 0 || _this$diffHeightManag.update();
+	}
+	applyDefaultDiffHunkAction(context) {
+		const { action, side, lineChange } = context;
+		if (!this.originalModel || !this.modifiedModel) return;
+		const hasOriginal = this.hasOriginalLines(lineChange);
+		const hasModified = this.hasModifiedLines(lineChange);
+		if (action === "revert" && side === "upper") {
+			if (!hasOriginal) return;
+			const text = this.getLinesText(this.originalModel, lineChange.originalStartLineNumber, lineChange.originalEndLineNumber);
+			if (!text) return;
+			const anchor = hasModified ? lineChange.modifiedStartLineNumber : Math.max(1, lineChange.modifiedStartLineNumber || lineChange.modifiedEndLineNumber || this.modifiedModel.getLineCount());
+			const range = this.getInsertRangeBeforeLine(this.modifiedModel, anchor);
+			this.modifiedModel.applyEdits([{
+				range,
+				text,
+				forceMoveMarkers: true
+			}]);
+			return;
+		}
+		if (action === "revert" && side === "lower") {
+			if (!hasModified) return;
+			const range = this.getFullLineRange(this.modifiedModel, lineChange.modifiedStartLineNumber, lineChange.modifiedEndLineNumber);
+			if (!range) return;
+			this.modifiedModel.applyEdits([{
+				range,
+				text: "",
+				forceMoveMarkers: true
+			}]);
+			return;
+		}
+		if (action === "stage" && side === "upper") {
+			if (!hasOriginal) return;
+			const range = this.getFullLineRange(this.originalModel, lineChange.originalStartLineNumber, lineChange.originalEndLineNumber);
+			if (!range) return;
+			this.originalModel.applyEdits([{
+				range,
+				text: "",
+				forceMoveMarkers: true
+			}]);
+			return;
+		}
+		if (action === "stage" && side === "lower") {
+			if (!hasModified) return;
+			const text = this.getLinesText(this.modifiedModel, lineChange.modifiedStartLineNumber, lineChange.modifiedEndLineNumber);
+			if (!text) return;
+			const anchor = hasOriginal ? lineChange.originalEndLineNumber : Math.max(0, lineChange.originalStartLineNumber - 1);
+			const range = this.getInsertRangeAfterLine(this.originalModel, anchor);
+			this.originalModel.applyEdits([{
+				range,
+				text,
+				forceMoveMarkers: true
+			}]);
+		}
+	}
+	applyDiffHunkAction(side, action) {
+		if (!this.diffHunkActiveChange || !this.originalModel || !this.modifiedModel) return;
+		this.flushOriginalAppendBufferSync();
+		this.flushModifiedAppendBufferSync();
+		const context = {
+			action,
+			side,
+			lineChange: this.diffHunkActiveChange,
+			originalModel: this.originalModel,
+			modifiedModel: this.modifiedModel
+		};
+		let allowDefault = true;
+		if (typeof this.options.onDiffHunkAction === "function") try {
+			allowDefault = this.options.onDiffHunkAction(context) !== false;
+		} catch (error$1) {
+			console.warn("onDiffHunkAction callback threw an error:", error$1);
+		}
+		if (allowDefault) this.applyDefaultDiffHunkAction(context);
+		this.syncDiffKnownValues();
+		this.hideDiffHunkActions();
+	}
+	setDiffHunkNodeEnabled(node, enabled) {
+		if (!node) return;
+		const buttons = node.querySelectorAll("button");
+		buttons.forEach((button) => {
+			button.disabled = !enabled;
+		});
+	}
+	positionDiffHunkNode(node, side, anchorLine, extraOffsetY = 0) {
+		var _editor$getScrollTop;
+		if (!this.diffHunkOverlay) return;
+		const editor = this.getEditorBySide(side);
+		if (!editor) return;
+		const host = editor.getContainerDomNode();
+		const line = Math.max(1, anchorLine);
+		const rawTop = editor.getTopForLineNumber(line) - (((_editor$getScrollTop = editor.getScrollTop) === null || _editor$getScrollTop === void 0 ? void 0 : _editor$getScrollTop.call(editor)) ?? 0);
+		const lineHeight = editor.getOption(monaco_shim_exports.editor.EditorOption.lineHeight);
+		const nodeWidth = node.offsetWidth || 130;
+		const nodeHeight = node.offsetHeight || 30;
+		const left = host.offsetLeft + Math.max(6, host.clientWidth - nodeWidth - 10);
+		const hostTop = host.offsetTop;
+		const minTop = hostTop + 4;
+		const maxTop = hostTop + Math.max(4, host.clientHeight - nodeHeight - 4);
+		const top = Math.min(maxTop, Math.max(minTop, hostTop + rawTop + Math.round(lineHeight * .2) + extraOffsetY));
+		node.style.transform = `translate(${Math.round(left)}px, ${Math.round(top)}px)`;
+		node.style.display = "flex";
+	}
+	repositionDiffHunkNodes() {
+		if (!this.diffHunkActiveChange) {
+			this.hideDiffHunkActions();
+			return;
+		}
+		if (!this.diffHunkUpperNode || !this.diffHunkLowerNode) return;
+		if (!this.diffEditorView) return;
+		const change = this.diffHunkActiveChange;
+		const hasOriginal = this.hasOriginalLines(change);
+		const hasModified = this.hasModifiedLines(change);
+		this.setDiffHunkNodeEnabled(this.diffHunkUpperNode, hasOriginal);
+		this.setDiffHunkNodeEnabled(this.diffHunkLowerNode, hasModified);
+		const originalCollapsed = this.isOriginalEditorCollapsed();
+		if (hasOriginal) {
+			const upperSide = originalCollapsed ? "modified" : "original";
+			const upperAnchor = originalCollapsed ? Math.max(1, change.modifiedStartLineNumber || change.modifiedEndLineNumber || 1) : change.originalStartLineNumber;
+			this.positionDiffHunkNode(this.diffHunkUpperNode, upperSide, upperAnchor);
+		} else this.diffHunkUpperNode.style.display = "none";
+		if (hasModified) {
+			const samePane = originalCollapsed;
+			const lowerAnchor = change.modifiedStartLineNumber;
+			this.positionDiffHunkNode(this.diffHunkLowerNode, "modified", lowerAnchor, samePane ? 32 : 0);
+		} else this.diffHunkLowerNode.style.display = "none";
 	}
 	scheduleFlushAppendBufferDiff() {
 		if (this.appendBufferDiffScheduled) return;
@@ -730,9 +1856,9 @@ var DiffEditorManager = class {
 				lastRevealLineDiff: this.lastRevealLineDiff
 			});
 			try {
-				var _this$diffEditorView, _this$diffEditorView$, _this$diffEditorView$2;
+				var _this$diffEditorView8, _this$diffEditorView9, _this$diffEditorView10;
 				this.shouldAutoScrollDiff = true;
-				this.lastScrollTopDiff = ((_this$diffEditorView = this.diffEditorView) === null || _this$diffEditorView === void 0 || (_this$diffEditorView$2 = (_this$diffEditorView$ = _this$diffEditorView.getModifiedEditor()).getScrollTop) === null || _this$diffEditorView$2 === void 0 ? void 0 : _this$diffEditorView$2.call(_this$diffEditorView$)) ?? this.lastScrollTopDiff;
+				this.lastScrollTopDiff = ((_this$diffEditorView8 = this.diffEditorView) === null || _this$diffEditorView8 === void 0 || (_this$diffEditorView10 = (_this$diffEditorView9 = _this$diffEditorView8.getModifiedEditor()).getScrollTop) === null || _this$diffEditorView10 === void 0 ? void 0 : _this$diffEditorView10.call(_this$diffEditorView9)) ?? this.lastScrollTopDiff;
 			} catch {}
 		});
 	}
@@ -751,9 +1877,9 @@ var DiffEditorManager = class {
 			ticket
 		});
 		try {
-			var _this$diffEditorView2, _this$diffEditorView3, _this$diffEditorView4;
+			var _this$diffEditorView11, _this$diffEditorView12, _this$diffEditorView13;
 			this.shouldAutoScrollDiff = true;
-			this.lastScrollTopDiff = ((_this$diffEditorView2 = this.diffEditorView) === null || _this$diffEditorView2 === void 0 || (_this$diffEditorView4 = (_this$diffEditorView3 = _this$diffEditorView2.getModifiedEditor()).getScrollTop) === null || _this$diffEditorView4 === void 0 ? void 0 : _this$diffEditorView4.call(_this$diffEditorView3)) ?? this.lastScrollTopDiff;
+			this.lastScrollTopDiff = ((_this$diffEditorView11 = this.diffEditorView) === null || _this$diffEditorView11 === void 0 || (_this$diffEditorView13 = (_this$diffEditorView12 = _this$diffEditorView11.getModifiedEditor()).getScrollTop) === null || _this$diffEditorView13 === void 0 ? void 0 : _this$diffEditorView13.call(_this$diffEditorView12)) ?? this.lastScrollTopDiff;
 		} catch {}
 	}
 	scheduleImmediateRevealAfterLayoutDiff(line) {
@@ -794,6 +1920,7 @@ var DiffEditorManager = class {
 		const lang = processedLanguage(language) || language;
 		this.originalModel = monaco_shim_exports.editor.createModel(originalCode, lang);
 		this.modifiedModel = monaco_shim_exports.editor.createModel(modifiedCode, lang);
+		const hideUnchangedRegions = this.resolveDiffHideUnchangedRegionsOption();
 		this.diffEditorView = monaco_shim_exports.editor.createDiffEditor(container, {
 			automaticLayout: true,
 			scrollBeyondLastLine: false,
@@ -807,7 +1934,8 @@ var DiffEditorManager = class {
 				...defaultScrollbar,
 				...this.options.scrollbar || {}
 			},
-			...this.options
+			...this.options,
+			hideUnchangedRegions
 		});
 		monaco_shim_exports.editor.setTheme(currentTheme);
 		this.diffEditorView.setModel({
@@ -816,7 +1944,7 @@ var DiffEditorManager = class {
 		});
 		this.lastKnownOriginalCode = originalCode;
 		this.lastKnownModifiedCode = modifiedCode;
-		this.diffUpdateThrottleMs = this.options.diffUpdateThrottleMs ?? 50;
+		this.diffUpdateThrottleMs = this.diffUpdateThrottleMsOption ?? this.options.diffUpdateThrottleMs ?? 50;
 		this.shouldAutoScrollDiff = !!(this.autoScrollInitial && this.diffAutoScroll);
 		if (this.diffScrollWatcher) {
 			this.diffScrollWatcher.dispose();
@@ -865,12 +1993,12 @@ var DiffEditorManager = class {
 		(_oEditor$onDidContent = oEditor.onDidContentSizeChange) === null || _oEditor$onDidContent === void 0 || _oEditor$onDidContent.call(oEditor, () => {
 			this._hasScrollBar = false;
 			this.rafScheduler.schedule("content-size-change-diff", () => {
-				var _oEditor$getScrollHei, _oEditor$getOption, _this$diffHeightManag, _this$diffHeightManag2;
+				var _oEditor$getScrollHei, _oEditor$getOption, _this$diffHeightManag2, _this$diffHeightManag3;
 				this.cachedScrollHeightDiff = ((_oEditor$getScrollHei = oEditor.getScrollHeight) === null || _oEditor$getScrollHei === void 0 ? void 0 : _oEditor$getScrollHei.call(oEditor)) ?? this.cachedScrollHeightDiff;
 				this.cachedLineHeightDiff = ((_oEditor$getOption = oEditor.getOption) === null || _oEditor$getOption === void 0 ? void 0 : _oEditor$getOption.call(oEditor, monaco_shim_exports.editor.EditorOption.lineHeight)) ?? this.cachedLineHeightDiff;
 				this.cachedComputedHeightDiff = this.computedHeight();
-				if ((_this$diffHeightManag = this.diffHeightManager) === null || _this$diffHeightManag === void 0 ? void 0 : _this$diffHeightManag.isSuppressed()) return;
-				(_this$diffHeightManag2 = this.diffHeightManager) === null || _this$diffHeightManag2 === void 0 || _this$diffHeightManag2.update();
+				if ((_this$diffHeightManag2 = this.diffHeightManager) === null || _this$diffHeightManag2 === void 0 ? void 0 : _this$diffHeightManag2.isSuppressed()) return;
+				(_this$diffHeightManag3 = this.diffHeightManager) === null || _this$diffHeightManag3 === void 0 || _this$diffHeightManag3.update();
 				const computed$1 = this.computedHeight();
 				if (this.lastContainer) {
 					const prevOverflow = this.lastContainer.style.overflow;
@@ -888,12 +2016,12 @@ var DiffEditorManager = class {
 		(_mEditor$onDidContent = mEditor.onDidContentSizeChange) === null || _mEditor$onDidContent === void 0 || _mEditor$onDidContent.call(mEditor, () => {
 			this._hasScrollBar = false;
 			this.rafScheduler.schedule("content-size-change-diff", () => {
-				var _mEditor$getScrollHei, _mEditor$getOption, _this$diffHeightManag3, _this$diffHeightManag4;
+				var _mEditor$getScrollHei, _mEditor$getOption, _this$diffHeightManag4, _this$diffHeightManag5;
 				this.cachedScrollHeightDiff = ((_mEditor$getScrollHei = mEditor.getScrollHeight) === null || _mEditor$getScrollHei === void 0 ? void 0 : _mEditor$getScrollHei.call(mEditor)) ?? this.cachedScrollHeightDiff;
 				this.cachedLineHeightDiff = ((_mEditor$getOption = mEditor.getOption) === null || _mEditor$getOption === void 0 ? void 0 : _mEditor$getOption.call(mEditor, monaco_shim_exports.editor.EditorOption.lineHeight)) ?? this.cachedLineHeightDiff;
 				this.cachedComputedHeightDiff = this.computedHeight();
-				if ((_this$diffHeightManag3 = this.diffHeightManager) === null || _this$diffHeightManag3 === void 0 ? void 0 : _this$diffHeightManag3.isSuppressed()) return;
-				(_this$diffHeightManag4 = this.diffHeightManager) === null || _this$diffHeightManag4 === void 0 || _this$diffHeightManag4.update();
+				if ((_this$diffHeightManag4 = this.diffHeightManager) === null || _this$diffHeightManag4 === void 0 ? void 0 : _this$diffHeightManag4.isSuppressed()) return;
+				(_this$diffHeightManag5 = this.diffHeightManager) === null || _this$diffHeightManag5 === void 0 || _this$diffHeightManag5.update();
 				const computed$1 = this.computedHeight();
 				if (this.lastContainer) {
 					const prevOverflow = this.lastContainer.style.overflow;
@@ -913,6 +2041,8 @@ var DiffEditorManager = class {
 			this.rafScheduler.schedule("sync-last-known-modified", () => this.syncLastKnownModified());
 		});
 		this.maybeScrollDiffToBottom(this.modifiedModel.getLineCount(), this.lastKnownModifiedLineCount ?? void 0);
+		this.setupDiffUnchangedRegionEnhancements();
+		this.setupDiffHunkInteractions();
 		return this.diffEditorView;
 	}
 	updateDiff(originalCode, modifiedCode, codeLanguage) {
@@ -1054,6 +2184,8 @@ var DiffEditorManager = class {
 		}
 		this.rafScheduler.cancel("content-size-change-diff");
 		this.rafScheduler.cancel("sync-last-known-modified");
+		this.disposeDiffHunkInteractions();
+		this.disposeDiffUnchangedRegionEnhancements();
 		if (this.diffScrollWatcher) {
 			this.diffScrollWatcher.dispose();
 			this.diffScrollWatcher = null;
@@ -1077,6 +2209,7 @@ var DiffEditorManager = class {
 		this.lastKnownOriginalCode = null;
 		this.lastKnownModifiedCode = null;
 		if (this.lastContainer) {
+			this.lastContainer.classList.remove("stream-monaco-diff-root");
 			this.lastContainer.innerHTML = "";
 			this.lastContainer = null;
 		}
@@ -1094,6 +2227,7 @@ var DiffEditorManager = class {
 		}
 		this.revealTicketDiff = 0;
 		this.lastRevealLineDiff = null;
+		this.diffPersistedUnchangedModelState = null;
 	}
 	safeClean() {
 		this.rafScheduler.cancel("diff");
@@ -1106,6 +2240,9 @@ var DiffEditorManager = class {
 			clearTimeout(this.appendFlushThrottleTimerDiff);
 			this.appendFlushThrottleTimerDiff = null;
 		}
+		this.hideDiffHunkActions();
+		this.cancelScheduledHideDiffHunkActions();
+		this.disposeDiffUnchangedRegionEnhancements();
 		if (this.diffScrollWatcher) {
 			this.diffScrollWatcher.dispose();
 			this.diffScrollWatcher = null;
@@ -1131,6 +2268,7 @@ var DiffEditorManager = class {
 		}
 		this.revealTicketDiff = 0;
 		this.lastRevealLineDiff = null;
+		this.diffPersistedUnchangedModelState = null;
 		this.rafScheduler.cancel("content-size-change-diff");
 		this.rafScheduler.cancel("sync-last-known-modified");
 	}
@@ -1329,9 +2467,9 @@ var DiffEditorManager = class {
 		} catch {}
 		if (suppressedByFlush) watcherApi.setSuppressed(false);
 		try {
-			var _this$diffEditorView5, _this$diffEditorView6, _this$diffEditorView7;
+			var _this$diffEditorView14, _this$diffEditorView15, _this$diffEditorView16;
 			this.shouldAutoScrollDiff = true;
-			this.lastScrollTopDiff = ((_this$diffEditorView5 = this.diffEditorView) === null || _this$diffEditorView5 === void 0 || (_this$diffEditorView7 = (_this$diffEditorView6 = _this$diffEditorView5.getModifiedEditor()).getScrollTop) === null || _this$diffEditorView7 === void 0 ? void 0 : _this$diffEditorView7.call(_this$diffEditorView6)) ?? this.lastScrollTopDiff;
+			this.lastScrollTopDiff = ((_this$diffEditorView14 = this.diffEditorView) === null || _this$diffEditorView14 === void 0 || (_this$diffEditorView16 = (_this$diffEditorView15 = _this$diffEditorView14.getModifiedEditor()).getScrollTop) === null || _this$diffEditorView16 === void 0 ? void 0 : _this$diffEditorView16.call(_this$diffEditorView15)) ?? this.lastScrollTopDiff;
 		} catch {}
 	}
 	applyMinimalEditToModel(model, prev, next) {
@@ -2015,6 +3153,41 @@ function arraysEqual(a, b) {
 
 //#endregion
 //#region src/utils/registerMonacoThemes.ts
+const LEGACY_ONIG_INIT_KEY = "__streamMonacoLegacyOnigurumaInit__";
+const LEGACY_ENGINE_KEY = "__streamMonacoLegacyShikiEngine__";
+const LEGACY_MONACO_LANGS_INIT_KEY = "__streamMonacoLegacyMonacoLangsInit__";
+async function awaitLegacyOnigurumaInitIfPresent() {
+	try {
+		var _globalThis;
+		const p = (_globalThis = globalThis) === null || _globalThis === void 0 ? void 0 : _globalThis[LEGACY_ONIG_INIT_KEY];
+		if (p && typeof p.then === "function") await p;
+	} catch {}
+}
+async function awaitLegacyMonacoLanguageContributionsIfPresent() {
+	try {
+		var _globalThis2;
+		const p = (_globalThis2 = globalThis) === null || _globalThis2 === void 0 ? void 0 : _globalThis2[LEGACY_MONACO_LANGS_INIT_KEY];
+		if (p && typeof p.then === "function") await p;
+	} catch {}
+}
+async function getLegacyShikiEngineIfPresent() {
+	try {
+		var _globalThis3;
+		const p = (_globalThis3 = globalThis) === null || _globalThis3 === void 0 ? void 0 : _globalThis3[LEGACY_ENGINE_KEY];
+		if (p && typeof p.then === "function") return await p;
+	} catch {}
+	return null;
+}
+async function createHighlighterWithLegacyEngineIfNeeded(options) {
+	await awaitLegacyOnigurumaInitIfPresent();
+	await awaitLegacyMonacoLanguageContributionsIfPresent();
+	const engine = await getLegacyShikiEngineIfPresent();
+	if (engine) return (0, shiki.createHighlighter)({
+		...options,
+		engine
+	});
+	return (0, shiki.createHighlighter)(options);
+}
 let languagesRegistered = false;
 let currentLanguages = [];
 let themeRegisterPromise = null;
@@ -2030,6 +3203,7 @@ function setThemeRegisterPromise(p) {
 const highlighterCache = /* @__PURE__ */ new Map();
 let monacoHighlighterPromise = null;
 let lastPatchedHighlighter = null;
+let lastPatchedLanguages = /* @__PURE__ */ new Set();
 const monacoThemeByKey = /* @__PURE__ */ new Map();
 const monacoLanguageSet = /* @__PURE__ */ new Set();
 function themeKey(t) {
@@ -2041,7 +3215,7 @@ async function ensureMonacoHighlighter(themes, languages$1) {
 	if (!monacoHighlighterPromise) {
 		const initialThemes = Array.from(monacoThemeByKey.values());
 		const initialLangs = Array.from(monacoLanguageSet.values());
-		monacoHighlighterPromise = (0, shiki.createHighlighter)({
+		monacoHighlighterPromise = createHighlighterWithLegacyEngineIfNeeded({
 			themes: initialThemes,
 			langs: initialLangs
 		}).then((h$1) => h$1);
@@ -2069,7 +3243,7 @@ async function ensureMonacoHighlighter(themes, languages$1) {
 		}
 		return h;
 	}
-	const p = (0, shiki.createHighlighter)({
+	const p = createHighlighterWithLegacyEngineIfNeeded({
 		themes: wantsThemes,
 		langs: wantsLangs
 	}).then((hh) => hh);
@@ -2113,7 +3287,7 @@ async function getOrCreateHighlighter(themes, languages$1) {
 		}
 		const union = new Set([...existing.languages, ...requestedSet]);
 		const langsArray = Array.from(union);
-		const p$1 = (0, shiki.createHighlighter)({
+		const p$1 = createHighlighterWithLegacyEngineIfNeeded({
 			themes,
 			langs: langsArray
 		});
@@ -2127,7 +3301,7 @@ async function getOrCreateHighlighter(themes, languages$1) {
 		});
 		return p$1;
 	}
-	const p = (0, shiki.createHighlighter)({
+	const p = createHighlighterWithLegacyEngineIfNeeded({
 		themes,
 		langs: Array.from(requestedSet)
 	});
@@ -2152,9 +3326,47 @@ async function registerMonacoThemes(themes, languages$1) {
 		registerMonacoLanguages(languages$1);
 		const p = (async () => {
 			const highlighter = await ensureMonacoHighlighter(themes, languages$1);
-			if (lastPatchedHighlighter !== highlighter) {
-				(0, __shikijs_monaco.shikiToMonaco)(highlighter, monaco_shim_exports);
+			const wantsLangs = Array.from(monacoLanguageSet.values());
+			const needsLanguagePatch = lastPatchedHighlighter !== highlighter || wantsLangs.some((l) => !lastPatchedLanguages.has(l));
+			if (needsLanguagePatch) {
+				if (lastPatchedHighlighter !== highlighter) lastPatchedLanguages = /* @__PURE__ */ new Set();
+				const realLanguages = monaco_shim_exports.languages;
+				const realEditor = monaco_shim_exports.editor;
+				const setTokensProvider = typeof (realLanguages === null || realLanguages === void 0 ? void 0 : realLanguages.setTokensProvider) === "function" ? realLanguages.setTokensProvider.bind(realLanguages) : null;
+				const getLanguages = typeof (realLanguages === null || realLanguages === void 0 ? void 0 : realLanguages.getLanguages) === "function" ? realLanguages.getLanguages.bind(realLanguages) : null;
+				const monacoProxy = {
+					__proto__: monaco_shim_exports,
+					editor: realEditor,
+					languages: {
+						__proto__: realLanguages,
+						getLanguages,
+						setTokensProvider(lang, provider) {
+							if (provider && typeof provider.tokenize === "function") {
+								const originalTokenize = provider.tokenize.bind(provider);
+								provider = {
+									...provider,
+									tokenize(line, state) {
+										try {
+											return originalTokenize(line, state);
+										} catch {
+											return {
+												endState: state,
+												tokens: [{
+													startIndex: 0,
+													scopes: ""
+												}]
+											};
+										}
+									}
+								};
+							}
+							return setTokensProvider === null || setTokensProvider === void 0 ? void 0 : setTokensProvider(lang, provider);
+						}
+					}
+				};
+				(0, __shikijs_monaco.shikiToMonaco)(highlighter, monacoProxy);
 				lastPatchedHighlighter = highlighter;
+				lastPatchedLanguages = new Set(wantsLangs);
 			}
 			currentLanguages = languages$1.slice();
 			return highlighter;
@@ -2822,6 +4034,12 @@ Object.defineProperty(exports, 'RevealStrategy', {
     return RevealStrategy;
   }
 });
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
 Object.defineProperty(exports, 'clearHighlighterCache', {
   enumerable: true,
   get: function () {
@@ -2852,6 +4070,18 @@ Object.defineProperty(exports, 'getOrCreateHighlighter', {
     return getOrCreateHighlighter;
   }
 });
+Object.defineProperty(exports, 'monaco_shim_exports', {
+  enumerable: true,
+  get: function () {
+    return monaco_shim_exports;
+  }
+});
+Object.defineProperty(exports, 'processedLanguage', {
+  enumerable: true,
+  get: function () {
+    return processedLanguage;
+  }
+});
 Object.defineProperty(exports, 'registerMonacoThemes', {
   enumerable: true,
   get: function () {