stream-monaco 0.0.1

package/dist/index.js

@@ -0,0 +1,2043 @@
+import { __export, __reExport } from "./chunk-CHLpw0oG.js";
+import * as _monaco from "monaco-editor";
+import { computed, effect, signal } from "alien-signals";
+import { shikiToMonaco } from "@shikijs/monaco";
+import { createHighlighter } from "shiki";
+
+//#region src/code.detect.ts
+/**
+* Language detection definitions
+*/
+const languages = [
+	[
+		"bash",
+		[/#!(\/usr)?\/bin\/bash/g, 500],
+		[/\b(if|elif|then|fi|echo)\b|\$/g, 10]
+	],
+	[
+		"html",
+		[/<\/?[a-z-][^\n>]*>/g, 10],
+		[/^\s+<!DOCTYPE\s+html/g, 500]
+	],
+	["http", [/^(GET|HEAD|POST|PUT|DELETE|PATCH|HTTP)\b/g, 500]],
+	["js", [/\b(console|await|async|function|export|import|this|class|for|let|const|map|join|require)\b/g, 10]],
+	["ts", [/\b(console|await|async|function|export|import|this|class|for|let|const|map|join|require|implements|interface|namespace)\b/g, 10]],
+	["py", [/\b(def|print|class|and|or|lambda)\b/g, 10]],
+	["sql", [/\b(SELECT|INSERT|FROM)\b/g, 50]],
+	[
+		"pl",
+		[/#!(\/usr)?\/bin\/perl/g, 500],
+		[/\b(use|print)\b|\$/g, 10]
+	],
+	["lua", [/#!(\/usr)?\/bin\/lua/g, 500]],
+	["make", [/\b(ifneq|endif|if|elif|then|fi|echo|.PHONY|^[a-z]+ ?:$)\b|\$/gm, 10]],
+	["uri", [/https?:|mailto:|tel:|ftp:/g, 30]],
+	["css", [/^(@import|@page|@media|(\.|#)[a-z]+)/gm, 20]],
+	[
+		"diff",
+		[/^[+><-]/gm, 10],
+		[/^@@[-+,0-9 ]+@@/gm, 25]
+	],
+	[
+		"md",
+		[/^(>|\t\*|\t\d+.|#{1,6} |-\s+|\*\s+)/gm, 25],
+		[/\[.*\](.*)/g, 10]
+	],
+	["docker", [/^(FROM|ENTRYPOINT|RUN)/gm, 500]],
+	[
+		"xml",
+		[/<\/?[a-z-][^\n>]*>/g, 10],
+		[/^<\?xml/g, 500]
+	],
+	["c", [/#include\b|\bprintf\s+\(/g, 100]],
+	["rs", [/^\s+(use|fn|mut|match)\b/gm, 100]],
+	["go", [/\b(func|fmt|package)\b/g, 100]],
+	["java", [/^import\s+java/gm, 500]],
+	["asm", [/^(section|global main|extern|\t(call|mov|ret))/gm, 100]],
+	["css", [/^(@import|@page|@media|(\.|#)[a-z]+)/gm, 20]],
+	["json", [/\b(true|false|null|\{\})\b|"[^"]+":/g, 10]],
+	["yaml", [/^(\s+)?[a-z][a-z0-9]*:/gim, 10]],
+	[
+		"toml",
+		[/^\s*\[.*\]\s*$/gm, 100],
+		[/^\s*[\w-]+ *= */gm, 20]
+	],
+	[
+		"mermaid",
+		[/^(graph|flowchart|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap)/gm, 500],
+		[/\b(-->|--o|--x|=>|\[\]|[{}])\b/g, 10]
+	]
+];
+/**
+* Try to find the language the given code belongs to
+*
+* @param {string} code The code to analyze
+* @param {LanguageDefinition[]} [additionalLanguages] Additional language definitions to supplement the built-in ones
+* @returns {CodeLanguage} The detected language of the code
+*/
+function detectLanguage(code, additionalLanguages) {
+	var _allLanguages$map$fil;
+	const allLanguages = additionalLanguages ? [...languages, ...additionalLanguages] : languages;
+	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";
+	if (/^(?:powershell|ps1?)/i.test(language)) return "powershell";
+	return language.split(":")[0];
+}
+/**
+* 使用示例:
+*
+* // 基本用法
+* const language1 = detectLanguage('console.log("hello")') // 'js'
+*
+* // 使用自定义语言检测规则
+* const customLanguages: LanguageDefinition[] = [
+*   ['vue', [/<template>/g, 100], [/<script>/g, 50], [/<style>/g, 50]],
+*   ['kotlin', [/\b(fun|class|val|var)\b/g, 20]]
+* ]
+*
+* const language2 = detectLanguage(`
+*   <template>
+*     <div>Hello Vue</div>
+*   </template>
+* `, customLanguages) // 'vue'
+*
+* const language3 = detectLanguage(`
+*   fun main() {
+*     val name = "Kotlin"
+*     println("Hello $name")
+*   }
+* `, customLanguages) // 'kotlin'
+*/
+
+//#endregion
+//#region src/constant.ts
+const defaultLanguages = [
+	"jsx",
+	"tsx",
+	"vue",
+	"csharp",
+	"python",
+	"java",
+	"c",
+	"cpp",
+	"rust",
+	"go",
+	"powershell",
+	"sql",
+	"json",
+	"html",
+	"javascript",
+	"typescript",
+	"css",
+	"markdown",
+	"xml",
+	"yaml",
+	"toml",
+	"dockerfile",
+	"kotlin",
+	"objective-c",
+	"objective-cpp",
+	"php",
+	"ruby",
+	"scala",
+	"svelte",
+	"swift",
+	"erlang",
+	"angular-html",
+	"angular-ts",
+	"dart",
+	"lua",
+	"mermaid",
+	"cmake",
+	"nginx"
+];
+const defaultThemes = ["vitesse-dark", "vitesse-light"];
+const defaultScrollbar = {
+	verticalScrollbarSize: 8,
+	horizontalScrollbarSize: 8,
+	handleMouseWheel: true,
+	alwaysConsumeMouseWheel: false
+};
+const padding = 16;
+const defaultRevealDebounceMs = 75;
+const defaultRevealBatchOnIdleMs = 200;
+const minimalEditMaxChars = 2e5;
+const minimalEditMaxChangeRatio = .5;
+
+//#endregion
+//#region src/minimalEdit.ts
+/**
+* Compute the minimal middle replacement between two UTF-16 strings.
+* Returns null when prev === next (no edits required).
+*/
+function computeMinimalEdit(prev, next) {
+	if (prev === next) return null;
+	let start = 0;
+	const minLen = Math.min(prev.length, next.length);
+	while (start < minLen && prev.charCodeAt(start) === next.charCodeAt(start)) start++;
+	let endPrev = prev.length - 1;
+	let endNext = next.length - 1;
+	while (endPrev >= start && endNext >= start && prev.charCodeAt(endPrev) === next.charCodeAt(endNext)) {
+		endPrev--;
+		endNext--;
+	}
+	return {
+		start,
+		endPrevIncl: endPrev,
+		endNextIncl: endNext,
+		replaceText: next.slice(start, endNext + 1)
+	};
+}
+
+//#endregion
+//#region src/monaco-shim.ts
+var monaco_shim_exports = {};
+__export(monaco_shim_exports, { default: () => monaco });
+import * as import_monaco_editor from "monaco-editor";
+__reExport(monaco_shim_exports, import_monaco_editor);
+const monaco = _monaco;
+
+//#endregion
+//#region src/utils/height.ts
+function createHeightManager(container, computeNext) {
+	let raf = null;
+	let lastApplied = -1;
+	let suppressed = false;
+	function apply() {
+		const next = computeNext();
+		if (next === lastApplied) return;
+		suppressed = true;
+		container.style.height = `${next}px`;
+		lastApplied = next;
+		queueMicrotask(() => {
+			suppressed = false;
+		});
+	}
+	function update() {
+		if (raf != null) return;
+		raf = requestAnimationFrame(() => {
+			raf = null;
+			apply();
+		});
+	}
+	function dispose() {
+		if (raf != null) {
+			cancelAnimationFrame(raf);
+			raf = null;
+		}
+	}
+	function isSuppressed() {
+		return suppressed;
+	}
+	function getLastApplied() {
+		return lastApplied;
+	}
+	return {
+		update,
+		dispose,
+		isSuppressed,
+		getLastApplied
+	};
+}
+
+//#endregion
+//#region src/utils/raf.ts
+/**
+* Create a per-instance RAF scheduler that coalesces tasks by "kind" within
+* the same instance. Instances are isolated so different editors won't
+* cancel each other's scheduled work.
+*/
+function createRafScheduler(timeSource) {
+	const ids = {};
+	const ts = timeSource ?? {
+		requestAnimationFrame: (cb) => requestAnimationFrame(cb),
+		cancelAnimationFrame: (id) => cancelAnimationFrame(id)
+	};
+	function schedule(kind, cb) {
+		const existing = ids[kind];
+		if (existing != null) ts.cancelAnimationFrame(existing);
+		ids[kind] = ts.requestAnimationFrame((t) => {
+			ids[kind] = null;
+			cb(t);
+		});
+	}
+	function cancel(kind) {
+		const id = ids[kind];
+		if (id != null) {
+			ts.cancelAnimationFrame(id);
+			ids[kind] = null;
+		}
+	}
+	return {
+		schedule,
+		cancel
+	};
+}
+
+//#endregion
+//#region src/utils/scroll.ts
+function createScrollWatcherForEditor(ed, opts) {
+	var _ed$getScrollTop, _ed$onDidScrollChange;
+	const initial = ((_ed$getScrollTop = ed.getScrollTop) === null || _ed$getScrollTop === void 0 ? void 0 : _ed$getScrollTop.call(ed)) ?? 0;
+	opts.setLast(initial);
+	const disp = ((_ed$onDidScrollChange = ed.onDidScrollChange) === null || _ed$onDidScrollChange === void 0 ? void 0 : _ed$onDidScrollChange.call(ed, (e) => {
+		var _ed$getScrollTop2;
+		const currentTop = e && typeof e.scrollTop === "number" ? e.scrollTop : ((_ed$getScrollTop2 = ed.getScrollTop) === null || _ed$getScrollTop2 === void 0 ? void 0 : _ed$getScrollTop2.call(ed)) ?? 0;
+		const delta = currentTop - opts.getLast();
+		opts.setLast(currentTop);
+		if (delta < 0) {
+			opts.onPause();
+			return;
+		}
+		opts.onMaybeResume();
+	})) ?? null;
+	return disp;
+}
+
+//#endregion
+//#region src/core/DiffEditorManager.ts
+var DiffEditorManager = class {
+	diffEditorView = null;
+	originalModel = null;
+	modifiedModel = null;
+	lastContainer = null;
+	lastKnownOriginalCode = null;
+	lastKnownModifiedCode = null;
+	lastKnownModifiedLineCount = null;
+	pendingDiffUpdate = null;
+	shouldAutoScrollDiff = true;
+	diffScrollWatcher = null;
+	lastScrollTopDiff = 0;
+	_hasScrollBar = false;
+	cachedScrollHeightDiff = null;
+	cachedLineHeightDiff = null;
+	cachedComputedHeightDiff = null;
+	lastKnownModifiedDirty = false;
+	measureViewportDiff() {
+		var _me$getLayoutInfo, _me$getScrollTop, _me$getScrollHeight;
+		if (!this.diffEditorView) return null;
+		const me = this.diffEditorView.getModifiedEditor();
+		const li = ((_me$getLayoutInfo = me.getLayoutInfo) === null || _me$getLayoutInfo === void 0 ? void 0 : _me$getLayoutInfo.call(me)) ?? null;
+		const lineHeight = this.cachedLineHeightDiff ?? me.getOption(monaco_shim_exports.editor.EditorOption.lineHeight);
+		const scrollTop = ((_me$getScrollTop = me.getScrollTop) === null || _me$getScrollTop === void 0 ? void 0 : _me$getScrollTop.call(me)) ?? this.lastScrollTopDiff ?? 0;
+		const scrollHeight = ((_me$getScrollHeight = me.getScrollHeight) === null || _me$getScrollHeight === void 0 ? void 0 : _me$getScrollHeight.call(me)) ?? this.cachedScrollHeightDiff ?? (li === null || li === void 0 ? void 0 : li.height) ?? 0;
+		const computedHeight = this.cachedComputedHeightDiff ?? this.computedHeight();
+		this.cachedLineHeightDiff = lineHeight;
+		this.cachedScrollHeightDiff = scrollHeight;
+		this.cachedComputedHeightDiff = computedHeight;
+		this.lastScrollTopDiff = scrollTop;
+		return {
+			me,
+			li,
+			lineHeight,
+			scrollTop,
+			scrollHeight,
+			computedHeight
+		};
+	}
+	lastRevealLineDiff = null;
+	revealDebounceIdDiff = null;
+	revealDebounceMs = defaultRevealDebounceMs;
+	revealIdleTimerIdDiff = null;
+	revealStrategyOption;
+	revealBatchOnIdleMsOption;
+	appendBufferDiff = [];
+	appendBufferDiffScheduled = false;
+	rafScheduler = createRafScheduler();
+	diffHeightManager = null;
+	constructor(options, maxHeightValue, maxHeightCSS, autoScrollOnUpdate, autoScrollInitial, autoScrollThresholdPx, autoScrollThresholdLines, diffAutoScroll, revealDebounceMsOption) {
+		this.options = options;
+		this.maxHeightValue = maxHeightValue;
+		this.maxHeightCSS = maxHeightCSS;
+		this.autoScrollOnUpdate = autoScrollOnUpdate;
+		this.autoScrollInitial = autoScrollInitial;
+		this.autoScrollThresholdPx = autoScrollThresholdPx;
+		this.autoScrollThresholdLines = autoScrollThresholdLines;
+		this.diffAutoScroll = diffAutoScroll;
+		this.revealDebounceMsOption = revealDebounceMsOption;
+	}
+	computedHeight() {
+		var _originalEditor$getMo, _modifiedEditor$getMo, _originalEditor$getSc, _modifiedEditor$getSc;
+		if (!this.diffEditorView) return Math.min(1 * 18 + padding, this.maxHeightValue);
+		const modifiedEditor = this.diffEditorView.getModifiedEditor();
+		const originalEditor = this.diffEditorView.getOriginalEditor();
+		const lineHeight = modifiedEditor.getOption(monaco_shim_exports.editor.EditorOption.lineHeight);
+		const oCount = ((_originalEditor$getMo = originalEditor.getModel()) === null || _originalEditor$getMo === void 0 ? void 0 : _originalEditor$getMo.getLineCount()) ?? 1;
+		const mCount = ((_modifiedEditor$getMo = modifiedEditor.getModel()) === null || _modifiedEditor$getMo === void 0 ? void 0 : _modifiedEditor$getMo.getLineCount()) ?? 1;
+		const lineCount = Math.max(oCount, mCount);
+		const fromLines = lineCount * lineHeight + padding;
+		const scrollH = Math.max(((_originalEditor$getSc = originalEditor.getScrollHeight) === null || _originalEditor$getSc === void 0 ? void 0 : _originalEditor$getSc.call(originalEditor)) ?? 0, ((_modifiedEditor$getSc = modifiedEditor.getScrollHeight) === null || _modifiedEditor$getSc === void 0 ? void 0 : _modifiedEditor$getSc.call(modifiedEditor)) ?? 0);
+		const desired = Math.max(fromLines, scrollH);
+		return Math.min(desired, this.maxHeightValue);
+	}
+	hasVerticalScrollbarModified() {
+		if (!this.diffEditorView) return false;
+		if (this._hasScrollBar) return true;
+		const m = this.measureViewportDiff();
+		if (!m) return false;
+		const epsilon = Math.max(2, Math.round(m.lineHeight / 8));
+		return this._hasScrollBar = m.scrollHeight > m.computedHeight + Math.max(padding / 2, epsilon);
+	}
+	userIsNearBottomDiff() {
+		if (!this.diffEditorView) return true;
+		const m = this.measureViewportDiff();
+		if (!m || !m.li) return true;
+		const lineThreshold = (this.autoScrollThresholdLines ?? 0) * m.lineHeight;
+		const threshold = Math.max(lineThreshold || 0, this.autoScrollThresholdPx || 0);
+		const distance = m.scrollHeight - (m.scrollTop + m.li.height);
+		return distance <= threshold;
+	}
+	maybeScrollDiffToBottom(targetLine, prevLineOverride) {
+		this.rafScheduler.schedule("maybe-scroll-diff", () => {
+			if (!this.diffEditorView) return;
+			if (!(this.diffAutoScroll && this.autoScrollOnUpdate && this.shouldAutoScrollDiff && this.hasVerticalScrollbarModified())) return;
+			const me = this.diffEditorView.getModifiedEditor();
+			const model = me.getModel();
+			const currentLine = (model === null || model === void 0 ? void 0 : model.getLineCount()) ?? 1;
+			const line = targetLine ?? currentLine;
+			const prevLine = typeof prevLineOverride === "number" ? prevLineOverride : this.lastKnownModifiedLineCount ?? -1;
+			if (prevLine !== -1 && prevLine === currentLine && line === currentLine) return;
+			if (this.lastRevealLineDiff !== null && this.lastRevealLineDiff === line) return;
+			const batchMs = this.revealBatchOnIdleMsOption ?? this.options.revealBatchOnIdleMs ?? defaultRevealBatchOnIdleMs;
+			if (typeof batchMs === "number" && batchMs > 0) {
+				if (this.revealIdleTimerIdDiff != null) clearTimeout(this.revealIdleTimerIdDiff);
+				this.revealIdleTimerIdDiff = setTimeout(() => {
+					this.revealIdleTimerIdDiff = null;
+					this.performRevealDiff(line);
+				}, batchMs);
+				return;
+			}
+			if (this.revealDebounceIdDiff != null) {
+				clearTimeout(this.revealDebounceIdDiff);
+				this.revealDebounceIdDiff = null;
+			}
+			const ms = typeof this.revealDebounceMs === "number" && this.revealDebounceMs > 0 ? this.revealDebounceMs : typeof this.revealDebounceMsOption === "number" && this.revealDebounceMsOption > 0 ? this.revealDebounceMsOption : this.revealDebounceMs;
+			this.revealDebounceIdDiff = setTimeout(() => {
+				this.revealDebounceIdDiff = null;
+				this.performRevealDiff(line);
+			}, ms);
+			this.lastKnownModifiedLineCount = currentLine;
+		});
+	}
+	performRevealDiff(line) {
+		this.rafScheduler.schedule("revealDiff", () => {
+			var _editor;
+			const strategy = this.revealStrategyOption ?? this.options.revealStrategy ?? "centerIfOutside";
+			const ScrollType = monaco_shim_exports.ScrollType || ((_editor = monaco_shim_exports.editor) === null || _editor === void 0 ? void 0 : _editor.ScrollType);
+			const smooth = ScrollType && typeof ScrollType.Smooth !== "undefined" ? ScrollType.Smooth : void 0;
+			try {
+				const me = this.diffEditorView.getModifiedEditor();
+				if (strategy === "bottom") if (typeof smooth !== "undefined") me.revealLine(line, smooth);
+				else me.revealLine(line);
+				else if (strategy === "center") if (typeof smooth !== "undefined") me.revealLineInCenter(line, smooth);
+				else me.revealLineInCenter(line);
+				else if (typeof smooth !== "undefined") me.revealLineInCenterIfOutsideViewport(line, smooth);
+				else me.revealLineInCenterIfOutsideViewport(line);
+			} catch {
+				try {
+					this.diffEditorView.getModifiedEditor().revealLine(line);
+				} catch {}
+			}
+			this.lastRevealLineDiff = line;
+		});
+	}
+	async createDiffEditor(container, originalCode, modifiedCode, language, currentTheme) {
+		var _me$getScrollHeight2, _me$getOption, _oEditor$onDidContent, _mEditor$onDidContent;
+		this.cleanup();
+		this.lastContainer = container;
+		container.style.overflow = "auto";
+		container.style.maxHeight = this.maxHeightCSS;
+		const lang = processedLanguage(language) || language;
+		this.originalModel = monaco_shim_exports.editor.createModel(originalCode, lang);
+		this.modifiedModel = monaco_shim_exports.editor.createModel(modifiedCode, lang);
+		this.diffEditorView = monaco_shim_exports.editor.createDiffEditor(container, {
+			automaticLayout: true,
+			scrollBeyondLastLine: false,
+			renderSideBySide: true,
+			originalEditable: false,
+			readOnly: this.options.readOnly ?? true,
+			minimap: { enabled: false },
+			theme: currentTheme,
+			contextmenu: false,
+			scrollbar: {
+				...defaultScrollbar,
+				...this.options.scrollbar || {}
+			},
+			...this.options
+		});
+		monaco_shim_exports.editor.setTheme(currentTheme);
+		this.diffEditorView.setModel({
+			original: this.originalModel,
+			modified: this.modifiedModel
+		});
+		this.lastKnownOriginalCode = originalCode;
+		this.lastKnownModifiedCode = modifiedCode;
+		this.shouldAutoScrollDiff = !!(this.autoScrollInitial && this.diffAutoScroll);
+		if (this.diffScrollWatcher) {
+			this.diffScrollWatcher.dispose();
+			this.diffScrollWatcher = null;
+		}
+		if (this.diffAutoScroll) {
+			const me$1 = this.diffEditorView.getModifiedEditor();
+			this.diffScrollWatcher = createScrollWatcherForEditor(me$1, {
+				onPause: () => {
+					this.shouldAutoScrollDiff = false;
+				},
+				onMaybeResume: () => {
+					this.rafScheduler.schedule("maybe-resume-diff", () => {
+						this.shouldAutoScrollDiff = this.userIsNearBottomDiff();
+					});
+				},
+				getLast: () => this.lastScrollTopDiff,
+				setLast: (v) => {
+					this.lastScrollTopDiff = v;
+				}
+			});
+		}
+		this.maybeScrollDiffToBottom(this.modifiedModel.getLineCount(), this.lastKnownModifiedLineCount ?? void 0);
+		if (this.diffHeightManager) {
+			this.diffHeightManager.dispose();
+			this.diffHeightManager = null;
+		}
+		this.diffHeightManager = createHeightManager(container, () => this.computedHeight());
+		this.diffHeightManager.update();
+		const me = this.diffEditorView.getModifiedEditor();
+		this.cachedScrollHeightDiff = ((_me$getScrollHeight2 = me.getScrollHeight) === null || _me$getScrollHeight2 === void 0 ? void 0 : _me$getScrollHeight2.call(me)) ?? null;
+		this.cachedLineHeightDiff = ((_me$getOption = me.getOption) === null || _me$getOption === void 0 ? void 0 : _me$getOption.call(me, monaco_shim_exports.editor.EditorOption.lineHeight)) ?? null;
+		this.cachedComputedHeightDiff = this.computedHeight();
+		const oEditor = this.diffEditorView.getOriginalEditor();
+		const mEditor = this.diffEditorView.getModifiedEditor();
+		(_oEditor$onDidContent = oEditor.onDidContentSizeChange) === null || _oEditor$onDidContent === void 0 || _oEditor$onDidContent.call(oEditor, () => {
+			this._hasScrollBar = false;
+			this.rafScheduler.schedule("content-size-change-diff", () => {
+				try {
+					var _oEditor$getScrollHei, _oEditor$getOption, _this$diffHeightManag, _this$diffHeightManag2;
+					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();
+				} catch {}
+			});
+		});
+		(_mEditor$onDidContent = mEditor.onDidContentSizeChange) === null || _mEditor$onDidContent === void 0 || _mEditor$onDidContent.call(mEditor, () => {
+			this._hasScrollBar = false;
+			this.rafScheduler.schedule("content-size-change-diff", () => {
+				try {
+					var _mEditor$getScrollHei, _mEditor$getOption, _this$diffHeightManag3, _this$diffHeightManag4;
+					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();
+				} catch {}
+			});
+		});
+		mEditor.onDidChangeModelContent(() => {
+			this.lastKnownModifiedDirty = true;
+			this.rafScheduler.schedule("sync-last-known-modified", () => this.syncLastKnownModified());
+		});
+		return this.diffEditorView;
+	}
+	updateDiff(originalCode, modifiedCode, codeLanguage) {
+		if (!this.diffEditorView || !this.originalModel || !this.modifiedModel) return;
+		const plang = codeLanguage ? processedLanguage(codeLanguage) : void 0;
+		if (plang && (this.originalModel.getLanguageId() !== plang || this.modifiedModel.getLanguageId() !== plang)) {
+			this.pendingDiffUpdate = {
+				original: originalCode,
+				modified: modifiedCode,
+				lang: codeLanguage
+			};
+			this.rafScheduler.schedule("diff", () => this.flushPendingDiffUpdate());
+			return;
+		}
+		if (this.lastKnownOriginalCode == null) this.lastKnownOriginalCode = this.originalModel.getValue();
+		if (this.lastKnownModifiedCode == null) this.lastKnownModifiedCode = this.modifiedModel.getValue();
+		const prevO = this.lastKnownOriginalCode;
+		const prevM = this.lastKnownModifiedCode;
+		let didImmediate = false;
+		if (originalCode !== prevO && originalCode.startsWith(prevO)) {
+			this.appendToModel(this.originalModel, originalCode.slice(prevO.length));
+			this.lastKnownOriginalCode = originalCode;
+			didImmediate = true;
+		}
+		if (modifiedCode !== prevM && modifiedCode.startsWith(prevM)) {
+			const prevLine = this.modifiedModel.getLineCount();
+			this.appendToModel(this.modifiedModel, modifiedCode.slice(prevM.length));
+			this.lastKnownModifiedCode = modifiedCode;
+			didImmediate = true;
+			this.maybeScrollDiffToBottom(this.modifiedModel.getLineCount(), prevLine);
+		}
+		if (originalCode !== this.lastKnownOriginalCode || modifiedCode !== this.lastKnownModifiedCode) {
+			this.pendingDiffUpdate = {
+				original: originalCode,
+				modified: modifiedCode
+			};
+			this.rafScheduler.schedule("diff", () => this.flushPendingDiffUpdate());
+		} else if (didImmediate) {}
+	}
+	updateOriginal(newCode, codeLanguage) {
+		if (!this.diffEditorView || !this.originalModel) return;
+		if (codeLanguage) {
+			const lang = processedLanguage(codeLanguage);
+			if (lang && this.originalModel.getLanguageId() !== lang) monaco_shim_exports.editor.setModelLanguage(this.originalModel, lang);
+		}
+		const prev = this.lastKnownOriginalCode ?? this.originalModel.getValue();
+		if (prev === newCode) return;
+		if (newCode.startsWith(prev) && prev.length < newCode.length) this.appendToModel(this.originalModel, newCode.slice(prev.length));
+		else this.applyMinimalEditToModel(this.originalModel, prev, newCode);
+		this.lastKnownOriginalCode = newCode;
+	}
+	updateModified(newCode, codeLanguage) {
+		if (!this.diffEditorView || !this.modifiedModel) return;
+		if (codeLanguage) {
+			const lang = processedLanguage(codeLanguage);
+			if (lang && this.modifiedModel.getLanguageId() !== lang) monaco_shim_exports.editor.setModelLanguage(this.modifiedModel, lang);
+		}
+		const prev = this.lastKnownModifiedCode ?? this.modifiedModel.getValue();
+		if (prev === newCode) return;
+		if (newCode.startsWith(prev) && prev.length < newCode.length) {
+			const prevLine = this.modifiedModel.getLineCount();
+			this.appendToModel(this.modifiedModel, newCode.slice(prev.length));
+			this.maybeScrollDiffToBottom(this.modifiedModel.getLineCount(), prevLine);
+		} else this.applyMinimalEditToModel(this.modifiedModel, prev, newCode);
+		this.lastKnownModifiedCode = newCode;
+	}
+	appendOriginal(appendText, codeLanguage) {
+		if (!this.diffEditorView || !this.originalModel || !appendText) return;
+		if (codeLanguage) {
+			const lang = processedLanguage(codeLanguage);
+			if (lang && this.originalModel.getLanguageId() !== lang) monaco_shim_exports.editor.setModelLanguage(this.originalModel, lang);
+		}
+		this.appendToModel(this.originalModel, appendText);
+		try {
+			this.lastKnownOriginalCode = this.originalModel.getValue();
+		} catch {}
+	}
+	appendModified(appendText, codeLanguage) {
+		if (!this.diffEditorView || !this.modifiedModel || !appendText) return;
+		if (codeLanguage) {
+			const lang = processedLanguage(codeLanguage);
+			if (lang && this.modifiedModel.getLanguageId() !== lang) monaco_shim_exports.editor.setModelLanguage(this.modifiedModel, lang);
+		}
+		this.appendBufferDiff.push(appendText);
+		if (!this.appendBufferDiffScheduled) {
+			this.appendBufferDiffScheduled = true;
+			this.rafScheduler.schedule("appendDiff", () => this.flushAppendBufferDiff());
+		}
+	}
+	setLanguage(language, languages$1) {
+		if (!languages$1.includes(language)) {
+			console.warn(`Language "${language}" is not registered. Available languages: ${languages$1.join(", ")}`);
+			return;
+		}
+		if (this.originalModel && this.originalModel.getLanguageId() !== language) monaco_shim_exports.editor.setModelLanguage(this.originalModel, language);
+		if (this.modifiedModel && this.modifiedModel.getLanguageId() !== language) monaco_shim_exports.editor.setModelLanguage(this.modifiedModel, language);
+	}
+	getDiffEditorView() {
+		return this.diffEditorView;
+	}
+	getDiffModels() {
+		return {
+			original: this.originalModel,
+			modified: this.modifiedModel
+		};
+	}
+	cleanup() {
+		this.rafScheduler.cancel("diff");
+		this.pendingDiffUpdate = null;
+		this.rafScheduler.cancel("appendDiff");
+		this.appendBufferDiffScheduled = false;
+		this.appendBufferDiff.length = 0;
+		this.rafScheduler.cancel("content-size-change-diff");
+		this.rafScheduler.cancel("sync-last-known-modified");
+		if (this.diffScrollWatcher) {
+			this.diffScrollWatcher.dispose();
+			this.diffScrollWatcher = null;
+		}
+		if (this.diffHeightManager) {
+			this.diffHeightManager.dispose();
+			this.diffHeightManager = null;
+		}
+		if (this.diffEditorView) {
+			this.diffEditorView.dispose();
+			this.diffEditorView = null;
+		}
+		if (this.originalModel) {
+			this.originalModel.dispose();
+			this.originalModel = null;
+		}
+		if (this.modifiedModel) {
+			this.modifiedModel.dispose();
+			this.modifiedModel = null;
+		}
+		this.lastKnownOriginalCode = null;
+		this.lastKnownModifiedCode = null;
+		if (this.lastContainer) {
+			this.lastContainer.innerHTML = "";
+			this.lastContainer = null;
+		}
+		if (this.revealDebounceIdDiff != null) {
+			clearTimeout(this.revealDebounceIdDiff);
+			this.revealDebounceIdDiff = null;
+		}
+		this.lastRevealLineDiff = null;
+	}
+	safeClean() {
+		this.rafScheduler.cancel("diff");
+		this.pendingDiffUpdate = null;
+		if (this.diffScrollWatcher) {
+			this.diffScrollWatcher.dispose();
+			this.diffScrollWatcher = null;
+		}
+		this._hasScrollBar = false;
+		this.shouldAutoScrollDiff = !!(this.autoScrollInitial && this.diffAutoScroll);
+		this.lastScrollTopDiff = 0;
+		if (this.diffHeightManager) {
+			this.diffHeightManager.dispose();
+			this.diffHeightManager = null;
+		}
+		if (this.revealDebounceIdDiff != null) {
+			clearTimeout(this.revealDebounceIdDiff);
+			this.revealDebounceIdDiff = null;
+		}
+		this.lastRevealLineDiff = null;
+		this.rafScheduler.cancel("content-size-change-diff");
+		this.rafScheduler.cancel("sync-last-known-modified");
+	}
+	syncLastKnownModified() {
+		if (!this.diffEditorView || !this.lastKnownModifiedDirty) return;
+		try {
+			const me = this.diffEditorView.getModifiedEditor();
+			const model = me.getModel();
+			if (model) {
+				this.lastKnownModifiedCode = model.getValue();
+				this.lastKnownModifiedLineCount = model.getLineCount();
+			}
+		} catch {} finally {
+			this.lastKnownModifiedDirty = false;
+		}
+	}
+	flushPendingDiffUpdate() {
+		if (!this.pendingDiffUpdate || !this.diffEditorView) return;
+		const o = this.originalModel;
+		const m = this.modifiedModel;
+		if (!o || !m) {
+			this.pendingDiffUpdate = null;
+			return;
+		}
+		const { original, modified, lang } = this.pendingDiffUpdate;
+		this.pendingDiffUpdate = null;
+		if (lang) {
+			const plang = processedLanguage(lang);
+			if (plang) {
+				if (o.getLanguageId() !== plang) {
+					monaco_shim_exports.editor.setModelLanguage(o, plang);
+					monaco_shim_exports.editor.setModelLanguage(m, plang);
+				}
+			}
+		}
+		if (this.lastKnownOriginalCode == null) this.lastKnownOriginalCode = o.getValue();
+		if (this.lastKnownModifiedCode == null) this.lastKnownModifiedCode = m.getValue();
+		const prevO = this.lastKnownOriginalCode;
+		if (prevO !== original) {
+			if (original.startsWith(prevO) && prevO.length < original.length) this.appendToModel(o, original.slice(prevO.length));
+			else this.applyMinimalEditToModel(o, prevO, original);
+			this.lastKnownOriginalCode = original;
+		}
+		const prevM = this.lastKnownModifiedCode;
+		const prevMLineCount = m.getLineCount();
+		if (prevM !== modified) {
+			if (modified.startsWith(prevM) && prevM.length < modified.length) this.appendToModel(m, modified.slice(prevM.length));
+			else this.applyMinimalEditToModel(m, prevM, modified);
+			this.lastKnownModifiedCode = modified;
+			const newMLineCount = m.getLineCount();
+			if (newMLineCount !== prevMLineCount) this.maybeScrollDiffToBottom(newMLineCount, prevMLineCount);
+		}
+	}
+	flushAppendBufferDiff() {
+		if (!this.diffEditorView) return;
+		if (this.appendBufferDiff.length === 0) return;
+		this.appendBufferDiffScheduled = false;
+		const me = this.diffEditorView.getModifiedEditor();
+		const model = me.getModel();
+		if (!model) {
+			this.appendBufferDiff.length = 0;
+			return;
+		}
+		const text = this.appendBufferDiff.join("");
+		this.appendBufferDiff.length = 0;
+		try {
+			const prevLine = model.getLineCount();
+			const lastColumn = model.getLineMaxColumn(prevLine);
+			const range = new monaco_shim_exports.Range(prevLine, lastColumn, prevLine, lastColumn);
+			model.applyEdits([{
+				range,
+				text,
+				forceMoveMarkers: true
+			}]);
+			try {
+				this.lastKnownModifiedCode = model.getValue();
+			} catch {}
+			const newLine = model.getLineCount();
+			this.maybeScrollDiffToBottom(newLine, prevLine);
+			this.lastKnownModifiedLineCount = newLine;
+		} catch {}
+	}
+	applyMinimalEditToModel(model, prev, next) {
+		try {
+			const maxChars = minimalEditMaxChars;
+			const ratio = minimalEditMaxChangeRatio;
+			const maxLen = Math.max(prev.length, next.length);
+			const changeRatio = maxLen > 0 ? Math.abs(next.length - prev.length) / maxLen : 0;
+			if (prev.length + next.length > maxChars || changeRatio > ratio) {
+				model.setValue(next);
+				try {
+					if (model === this.modifiedModel) this.lastKnownModifiedLineCount = model.getLineCount();
+				} catch {}
+				return;
+			}
+		} catch {}
+		const res = computeMinimalEdit(prev, next);
+		if (!res) return;
+		const { start, endPrevIncl, replaceText } = res;
+		const rangeStart = model.getPositionAt(start);
+		const rangeEnd = model.getPositionAt(endPrevIncl + 1);
+		const range = new monaco_shim_exports.Range(rangeStart.lineNumber, rangeStart.column, rangeEnd.lineNumber, rangeEnd.column);
+		model.applyEdits([{
+			range,
+			text: replaceText,
+			forceMoveMarkers: true
+		}]);
+		try {
+			if (model === this.modifiedModel) this.lastKnownModifiedLineCount = model.getLineCount();
+		} catch {}
+	}
+	appendToModel(model, appendText) {
+		if (!appendText) return;
+		const lastLine = model.getLineCount();
+		const lastColumn = model.getLineMaxColumn(lastLine);
+		const range = new monaco_shim_exports.Range(lastLine, lastColumn, lastLine, lastColumn);
+		model.applyEdits([{
+			range,
+			text: appendText,
+			forceMoveMarkers: true
+		}]);
+		try {
+			if (model === this.modifiedModel) this.lastKnownModifiedLineCount = model.getLineCount();
+		} catch {}
+	}
+};
+
+//#endregion
+//#region src/core/EditorManager.ts
+var EditorManager = class {
+	editorView = null;
+	lastContainer = null;
+	lastKnownCode = null;
+	pendingUpdate = null;
+	_hasScrollBar = false;
+	shouldAutoScroll = true;
+	scrollWatcher = null;
+	lastScrollTop = 0;
+	cachedScrollHeight = null;
+	cachedLineHeight = null;
+	cachedComputedHeight = null;
+	cachedLineCount = null;
+	lastKnownCodeDirty = false;
+	measureViewport() {
+		var _this$editorView$getL, _this$editorView, _this$editorView$getS, _this$editorView2, _this$editorView$getS2, _this$editorView3;
+		if (!this.editorView) return null;
+		const li = ((_this$editorView$getL = (_this$editorView = this.editorView).getLayoutInfo) === null || _this$editorView$getL === void 0 ? void 0 : _this$editorView$getL.call(_this$editorView)) ?? null;
+		const lineHeight = this.cachedLineHeight ?? this.editorView.getOption(monaco_shim_exports.editor.EditorOption.lineHeight);
+		const scrollTop = ((_this$editorView$getS = (_this$editorView2 = this.editorView).getScrollTop) === null || _this$editorView$getS === void 0 ? void 0 : _this$editorView$getS.call(_this$editorView2)) ?? this.lastScrollTop ?? 0;
+		const scrollHeight = ((_this$editorView$getS2 = (_this$editorView3 = this.editorView).getScrollHeight) === null || _this$editorView$getS2 === void 0 ? void 0 : _this$editorView$getS2.call(_this$editorView3)) ?? this.cachedScrollHeight ?? (li === null || li === void 0 ? void 0 : li.height) ?? 0;
+		const computedHeight = this.cachedComputedHeight ?? this.computedHeight(this.editorView);
+		this.cachedLineHeight = lineHeight;
+		this.cachedScrollHeight = scrollHeight;
+		this.cachedComputedHeight = computedHeight;
+		this.lastScrollTop = scrollTop;
+		return {
+			li,
+			lineHeight,
+			scrollTop,
+			scrollHeight,
+			computedHeight
+		};
+	}
+	appendBuffer = [];
+	appendBufferScheduled = false;
+	rafScheduler = createRafScheduler();
+	editorHeightManager = null;
+	revealDebounceId = null;
+	revealDebounceMs = defaultRevealDebounceMs;
+	revealIdleTimerId = null;
+	revealStrategyOption;
+	revealBatchOnIdleMsOption;
+	constructor(options, maxHeightValue, maxHeightCSS, autoScrollOnUpdate, autoScrollInitial, autoScrollThresholdPx, autoScrollThresholdLines, revealDebounceMsOption) {
+		this.options = options;
+		this.maxHeightValue = maxHeightValue;
+		this.maxHeightCSS = maxHeightCSS;
+		this.autoScrollOnUpdate = autoScrollOnUpdate;
+		this.autoScrollInitial = autoScrollInitial;
+		this.autoScrollThresholdPx = autoScrollThresholdPx;
+		this.autoScrollThresholdLines = autoScrollThresholdLines;
+		this.revealDebounceMsOption = revealDebounceMsOption;
+	}
+	hasVerticalScrollbar() {
+		if (!this.editorView) return false;
+		if (this._hasScrollBar) return true;
+		const m = this.measureViewport();
+		if (!m) return false;
+		return this._hasScrollBar = m.scrollHeight > m.computedHeight + padding / 2;
+	}
+	userIsNearBottom() {
+		if (!this.editorView) return true;
+		const m = this.measureViewport();
+		if (!m || !m.li) return true;
+		const lineThreshold = (this.autoScrollThresholdLines ?? 0) * m.lineHeight;
+		const threshold = Math.max(lineThreshold || 0, this.autoScrollThresholdPx || 0);
+		const distance = m.scrollHeight - (m.scrollTop + m.li.height);
+		return distance <= threshold;
+	}
+	computedHeight(editorView) {
+		var _editorView$getModel;
+		const lineCount = this.cachedLineCount ?? ((_editorView$getModel = editorView.getModel()) === null || _editorView$getModel === void 0 ? void 0 : _editorView$getModel.getLineCount()) ?? 1;
+		const lineHeight = editorView.getOption(monaco_shim_exports.editor.EditorOption.lineHeight);
+		const height = Math.min(lineCount * lineHeight + padding, this.maxHeightValue);
+		return height;
+	}
+	maybeScrollToBottom(targetLine) {
+		this.rafScheduler.schedule("maybe-scroll", () => {
+			if (!(this.autoScrollOnUpdate && this.shouldAutoScroll && this.hasVerticalScrollbar())) return;
+			const model = this.editorView.getModel();
+			const line = targetLine ?? (model === null || model === void 0 ? void 0 : model.getLineCount()) ?? 1;
+			const batchMs = this.revealBatchOnIdleMsOption ?? this.options.revealBatchOnIdleMs ?? defaultRevealBatchOnIdleMs;
+			if (typeof batchMs === "number" && batchMs > 0) {
+				if (this.revealIdleTimerId != null) clearTimeout(this.revealIdleTimerId);
+				this.revealIdleTimerId = setTimeout(() => {
+					this.revealIdleTimerId = null;
+					this.performReveal(line);
+				}, batchMs);
+				return;
+			}
+			if (this.revealDebounceId != null) {
+				clearTimeout(this.revealDebounceId);
+				this.revealDebounceId = null;
+			}
+			const ms = typeof this.revealDebounceMs === "number" && this.revealDebounceMs > 0 ? this.revealDebounceMs : typeof this.revealDebounceMsOption === "number" && this.revealDebounceMsOption > 0 ? this.revealDebounceMsOption : this.revealDebounceMs;
+			this.revealDebounceId = setTimeout(() => {
+				this.revealDebounceId = null;
+				this.performReveal(line);
+			}, ms);
+		});
+	}
+	performReveal(line) {
+		this.rafScheduler.schedule("reveal", () => {
+			var _editor;
+			const strategy = this.revealStrategyOption ?? this.options.revealStrategy ?? "centerIfOutside";
+			const ScrollType = monaco_shim_exports.ScrollType || ((_editor = monaco_shim_exports.editor) === null || _editor === void 0 ? void 0 : _editor.ScrollType);
+			const smooth = ScrollType && typeof ScrollType.Smooth !== "undefined" ? ScrollType.Smooth : void 0;
+			try {
+				if (strategy === "bottom") if (typeof smooth !== "undefined") this.editorView.revealLine(line, smooth);
+				else this.editorView.revealLine(line);
+				else if (strategy === "center") if (typeof smooth !== "undefined") this.editorView.revealLineInCenter(line, smooth);
+				else this.editorView.revealLineInCenter(line);
+				else if (typeof smooth !== "undefined") this.editorView.revealLineInCenterIfOutsideViewport(line, smooth);
+				else this.editorView.revealLineInCenterIfOutsideViewport(line);
+			} catch {
+				try {
+					this.editorView.revealLine(line);
+				} catch {}
+			}
+		});
+	}
+	async createEditor(container, code, language, currentTheme) {
+		var _this$editorView$getS3, _this$editorView4, _this$editorView$getO, _this$editorView5, _this$editorView$getM, _this$editorView$onDi, _this$editorView6;
+		this.cleanup();
+		this.lastContainer = container;
+		container.style.overflow = "auto";
+		container.style.maxHeight = this.maxHeightCSS;
+		this.editorView = monaco_shim_exports.editor.create(container, {
+			value: code,
+			language: processedLanguage(language) || language,
+			theme: currentTheme,
+			scrollBeyondLastLine: false,
+			minimap: { enabled: false },
+			automaticLayout: true,
+			readOnly: this.options.readOnly ?? true,
+			contextmenu: false,
+			scrollbar: {
+				...defaultScrollbar,
+				...this.options.scrollbar || {}
+			},
+			...this.options
+		});
+		monaco_shim_exports.editor.setTheme(currentTheme);
+		this.lastKnownCode = this.editorView.getValue();
+		if (this.editorHeightManager) {
+			try {
+				this.editorHeightManager.dispose();
+			} catch {}
+			this.editorHeightManager = null;
+		}
+		if (this.revealDebounceId != null) {
+			clearTimeout(this.revealDebounceId);
+			this.revealDebounceId = null;
+		}
+		if (this.revealIdleTimerId != null) clearTimeout(this.revealIdleTimerId);
+		this.revealIdleTimerId = null;
+		this.editorHeightManager = createHeightManager(container, () => this.computedHeight(this.editorView));
+		this.editorHeightManager.update();
+		this.cachedScrollHeight = ((_this$editorView$getS3 = (_this$editorView4 = this.editorView).getScrollHeight) === null || _this$editorView$getS3 === void 0 ? void 0 : _this$editorView$getS3.call(_this$editorView4)) ?? null;
+		this.cachedLineHeight = ((_this$editorView$getO = (_this$editorView5 = this.editorView).getOption) === null || _this$editorView$getO === void 0 ? void 0 : _this$editorView$getO.call(_this$editorView5, monaco_shim_exports.editor.EditorOption.lineHeight)) ?? null;
+		this.cachedComputedHeight = this.computedHeight(this.editorView);
+		this.cachedLineCount = ((_this$editorView$getM = this.editorView.getModel()) === null || _this$editorView$getM === void 0 ? void 0 : _this$editorView$getM.getLineCount()) ?? null;
+		(_this$editorView$onDi = (_this$editorView6 = this.editorView).onDidContentSizeChange) === null || _this$editorView$onDi === void 0 || _this$editorView$onDi.call(_this$editorView6, () => {
+			this._hasScrollBar = false;
+			this.rafScheduler.schedule("content-size-change", () => {
+				try {
+					var _this$editorView7, _this$editorHeightMan, _this$editorHeightMan2;
+					this.measureViewport();
+					this.cachedLineCount = ((_this$editorView7 = this.editorView) === null || _this$editorView7 === void 0 || (_this$editorView7 = _this$editorView7.getModel()) === null || _this$editorView7 === void 0 ? void 0 : _this$editorView7.getLineCount()) ?? this.cachedLineCount;
+					if ((_this$editorHeightMan = this.editorHeightManager) === null || _this$editorHeightMan === void 0 ? void 0 : _this$editorHeightMan.isSuppressed()) return;
+					(_this$editorHeightMan2 = this.editorHeightManager) === null || _this$editorHeightMan2 === void 0 || _this$editorHeightMan2.update();
+				} catch {}
+			});
+		});
+		this.editorView.onDidChangeModelContent(() => {
+			this.lastKnownCodeDirty = true;
+			this.rafScheduler.schedule("sync-last-known", () => this.syncLastKnownCode());
+		});
+		this.shouldAutoScroll = !!this.autoScrollInitial;
+		if (this.scrollWatcher) {
+			this.scrollWatcher.dispose();
+			this.scrollWatcher = null;
+		}
+		this.scrollWatcher = createScrollWatcherForEditor(this.editorView, {
+			onPause: () => {
+				this.shouldAutoScroll = false;
+			},
+			onMaybeResume: () => {
+				this.rafScheduler.schedule("maybe-resume", () => {
+					this.shouldAutoScroll = this.userIsNearBottom();
+				});
+			},
+			getLast: () => this.lastScrollTop,
+			setLast: (v) => {
+				this.lastScrollTop = v;
+			}
+		});
+		this.maybeScrollToBottom();
+		return this.editorView;
+	}
+	syncLastKnownCode() {
+		if (!this.editorView || !this.lastKnownCodeDirty) return;
+		try {
+			const model = this.editorView.getModel();
+			if (model) {
+				this.lastKnownCode = model.getValue();
+				this.cachedLineCount = model.getLineCount() ?? this.cachedLineCount;
+			}
+		} catch {} finally {
+			this.lastKnownCodeDirty = false;
+		}
+	}
+	updateCode(newCode, codeLanguage) {
+		this.pendingUpdate = {
+			code: newCode,
+			lang: codeLanguage
+		};
+		this.rafScheduler.schedule("update", () => this.flushPendingUpdate());
+	}
+	flushPendingUpdate() {
+		if (!this.pendingUpdate || !this.editorView) return;
+		const model = this.editorView.getModel();
+		if (!model) return;
+		const { code: newCode, lang: codeLanguage } = this.pendingUpdate;
+		this.pendingUpdate = null;
+		const processedCodeLanguage = processedLanguage(codeLanguage);
+		const languageId = model.getLanguageId();
+		if (languageId !== processedCodeLanguage) {
+			if (processedCodeLanguage) monaco_shim_exports.editor.setModelLanguage(model, processedCodeLanguage);
+			const prevLineCount$1 = model.getLineCount();
+			model.setValue(newCode);
+			this.lastKnownCode = newCode;
+			const newLineCount$1 = model.getLineCount();
+			this.cachedLineCount = newLineCount$1;
+			if (newLineCount$1 !== prevLineCount$1) this.maybeScrollToBottom(newLineCount$1);
+			return;
+		}
+		const prevCode = this.lastKnownCode ?? this.editorView.getValue();
+		if (prevCode === newCode) return;
+		if (newCode.startsWith(prevCode) && prevCode.length < newCode.length) {
+			const suffix = newCode.slice(prevCode.length);
+			if (suffix) this.appendCode(suffix, codeLanguage);
+			this.lastKnownCode = newCode;
+			return;
+		}
+		const prevLineCount = model.getLineCount();
+		this.applyMinimalEdit(prevCode, newCode);
+		this.lastKnownCode = newCode;
+		const newLineCount = model.getLineCount();
+		this.cachedLineCount = newLineCount;
+		if (newLineCount !== prevLineCount) this.maybeScrollToBottom(newLineCount);
+	}
+	appendCode(appendText, codeLanguage) {
+		if (!this.editorView) return;
+		const model = this.editorView.getModel();
+		if (!model) return;
+		const processedCodeLanguage = codeLanguage ? processedLanguage(codeLanguage) : model.getLanguageId();
+		if (processedCodeLanguage && model.getLanguageId() !== processedCodeLanguage) monaco_shim_exports.editor.setModelLanguage(model, processedCodeLanguage);
+		if (appendText) {
+			this.appendBuffer.push(appendText);
+			if (!this.appendBufferScheduled) {
+				this.appendBufferScheduled = true;
+				this.rafScheduler.schedule("append", () => this.flushAppendBuffer());
+			}
+		}
+	}
+	applyMinimalEdit(prev, next) {
+		if (!this.editorView) return;
+		const model = this.editorView.getModel();
+		if (!model) return;
+		try {
+			const maxChars = minimalEditMaxChars;
+			const ratio = minimalEditMaxChangeRatio;
+			const maxLen = Math.max(prev.length, next.length);
+			const changeRatio = maxLen > 0 ? Math.abs(next.length - prev.length) / maxLen : 0;
+			if (prev.length + next.length > maxChars || changeRatio > ratio) {
+				const prevLineCount = model.getLineCount();
+				model.setValue(next);
+				this.lastKnownCode = next;
+				const newLineCount = model.getLineCount();
+				this.cachedLineCount = newLineCount;
+				if (newLineCount !== prevLineCount) this.maybeScrollToBottom(newLineCount);
+				return;
+			}
+		} catch {}
+		const res = computeMinimalEdit(prev, next);
+		if (!res) return;
+		const { start, endPrevIncl, replaceText } = res;
+		const rangeStart = model.getPositionAt(start);
+		const rangeEnd = model.getPositionAt(endPrevIncl + 1);
+		const range = new monaco_shim_exports.Range(rangeStart.lineNumber, rangeStart.column, rangeEnd.lineNumber, rangeEnd.column);
+		const isReadOnly = this.editorView.getOption(monaco_shim_exports.editor.EditorOption.readOnly);
+		const edit = [{
+			range,
+			text: replaceText,
+			forceMoveMarkers: true
+		}];
+		if (isReadOnly) model.applyEdits(edit);
+		else this.editorView.executeEdits("minimal-replace", edit);
+	}
+	flushAppendBuffer() {
+		if (!this.editorView) return;
+		if (this.appendBuffer.length === 0) return;
+		this.appendBufferScheduled = false;
+		const model = this.editorView.getModel();
+		if (!model) {
+			this.appendBuffer.length = 0;
+			return;
+		}
+		const text = this.appendBuffer.join("");
+		this.appendBuffer.length = 0;
+		const lastLine = model.getLineCount();
+		const lastColumn = model.getLineMaxColumn(lastLine);
+		const range = new monaco_shim_exports.Range(lastLine, lastColumn, lastLine, lastColumn);
+		const isReadOnly = this.editorView.getOption(monaco_shim_exports.editor.EditorOption.readOnly);
+		if (isReadOnly) model.applyEdits([{
+			range,
+			text,
+			forceMoveMarkers: true
+		}]);
+		else this.editorView.executeEdits("append", [{
+			range,
+			text,
+			forceMoveMarkers: true
+		}]);
+		const newLineCount = model.getLineCount();
+		if (lastLine !== newLineCount) {
+			this.cachedLineCount = newLineCount;
+			this.maybeScrollToBottom(newLineCount);
+		}
+	}
+	setLanguage(language, languages$1) {
+		if (languages$1.includes(language)) {
+			if (this.editorView) {
+				const model = this.editorView.getModel();
+				if (model && model.getLanguageId() !== language) monaco_shim_exports.editor.setModelLanguage(model, language);
+			}
+		} else console.warn(`Language "${language}" is not registered. Available languages: ${languages$1.join(", ")}`);
+	}
+	getEditorView() {
+		return this.editorView;
+	}
+	cleanup() {
+		this.rafScheduler.cancel("update");
+		this.rafScheduler.cancel("sync-last-known");
+		this.rafScheduler.cancel("content-size-change");
+		this.pendingUpdate = null;
+		this.rafScheduler.cancel("append");
+		this.appendBufferScheduled = false;
+		this.appendBuffer.length = 0;
+		if (this.editorView) {
+			this.editorView.dispose();
+			this.editorView = null;
+		}
+		this.lastKnownCode = null;
+		if (this.lastContainer) {
+			this.lastContainer.innerHTML = "";
+			this.lastContainer = null;
+		}
+		if (this.scrollWatcher) {
+			this.scrollWatcher.dispose();
+			this.scrollWatcher = null;
+		}
+		if (this.editorHeightManager) {
+			this.editorHeightManager.dispose();
+			this.editorHeightManager = null;
+		}
+	}
+	safeClean() {
+		this.rafScheduler.cancel("update");
+		this.pendingUpdate = null;
+		this.rafScheduler.cancel("sync-last-known");
+		if (this.scrollWatcher) {
+			this.scrollWatcher.dispose();
+			this.scrollWatcher = null;
+		}
+		if (this.revealDebounceId != null) {
+			clearTimeout(this.revealDebounceId);
+			this.revealDebounceId = null;
+		}
+		this._hasScrollBar = false;
+		this.shouldAutoScroll = !!this.autoScrollInitial;
+		this.lastScrollTop = 0;
+		if (this.editorHeightManager) {
+			this.editorHeightManager.dispose();
+			this.editorHeightManager = null;
+		}
+	}
+};
+
+//#endregion
+//#region src/reactivity.ts
+function ref(initial) {
+	const s = signal(initial);
+	return Object.defineProperty({}, "value", {
+		get() {
+			return s();
+		},
+		set(v) {
+			s(v);
+		},
+		enumerable: true,
+		configurable: false
+	});
+}
+function computed$1(getter) {
+	const c = computed(() => getter());
+	return Object.defineProperty({}, "value", {
+		get() {
+			return c();
+		},
+		set(_) {},
+		enumerable: true,
+		configurable: false
+	});
+}
+function watch(source, cb, options = {}) {
+	let initialized = false;
+	let oldVal;
+	const stop = effect(() => {
+		const newVal = source();
+		if (!initialized) {
+			initialized = true;
+			if (options.immediate) if (options.flush === "post") queueMicrotask(() => cb(newVal, oldVal));
+			else cb(newVal, oldVal);
+		} else if (!Object.is(newVal, oldVal)) if (options.flush === "post") queueMicrotask(() => cb(newVal, oldVal));
+		else cb(newVal, oldVal);
+		oldVal = newVal;
+	});
+	return stop;
+}
+
+//#endregion
+//#region src/isDark.ts
+const isDark = ref(false);
+function computeIsDark() {
+	var _el$classList, _window$matchMedia, _window;
+	if (typeof window === "undefined" || typeof document === "undefined") return false;
+	const el = document.documentElement;
+	const hasClass = ((_el$classList = el.classList) === null || _el$classList === void 0 ? void 0 : _el$classList.contains("dark")) ?? false;
+	const mql = (_window$matchMedia = (_window = window).matchMedia) === null || _window$matchMedia === void 0 ? void 0 : _window$matchMedia.call(_window, "(prefers-color-scheme: dark)");
+	const prefersDark = !!(mql === null || mql === void 0 ? void 0 : mql.matches);
+	return hasClass || prefersDark;
+}
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+	var _window$matchMedia2, _window2;
+	const el = document.documentElement;
+	const mql = (_window$matchMedia2 = (_window2 = window).matchMedia) === null || _window$matchMedia2 === void 0 ? void 0 : _window$matchMedia2.call(_window2, "(prefers-color-scheme: dark)");
+	const update = () => {
+		isDark.value = computeIsDark();
+	};
+	update();
+	const onMqlChange = () => update();
+	if (mql) mql.addEventListener ? mql.addEventListener("change", onMqlChange) : mql.addListener(onMqlChange);
+	const mo = new MutationObserver(update);
+	mo.observe(el, {
+		attributes: true,
+		attributeFilter: ["class"]
+	});
+	const cleanup = () => {
+		if (mql) mql.removeEventListener ? mql.removeEventListener("change", onMqlChange) : mql.removeListener(onMqlChange);
+		mo.disconnect();
+		window.removeEventListener("pagehide", cleanup);
+		window.removeEventListener("beforeunload", cleanup);
+	};
+	window.addEventListener("pagehide", cleanup);
+	window.addEventListener("beforeunload", cleanup);
+}
+
+//#endregion
+//#region src/preloadMonacoWorkers.ts
+async function preloadMonacoWorkers() {
+	if (typeof window === "undefined" || typeof document === "undefined") return;
+	const workerUrlJson = new URL("monaco-editor/esm/vs/language/json/json.worker.js", import.meta.url);
+	const workerUrlCss = new URL("monaco-editor/esm/vs/language/css/css.worker.js", import.meta.url);
+	const workerUrlHtml = new URL("monaco-editor/esm/vs/language/html/html.worker.js", import.meta.url);
+	const workerUrlTs = new URL("monaco-editor/esm/vs/language/typescript/ts.worker.js", import.meta.url);
+	const workerUrlEditor = new URL("monaco-editor/esm/vs/editor/editor.worker.js", import.meta.url);
+	const unique = Array.from(new Set([
+		String(workerUrlJson),
+		String(workerUrlCss),
+		String(workerUrlHtml),
+		String(workerUrlTs),
+		String(workerUrlEditor)
+	]));
+	const workerUrlByLabel = {
+		json: workerUrlJson,
+		css: workerUrlCss,
+		scss: workerUrlCss,
+		less: workerUrlCss,
+		html: workerUrlHtml,
+		handlebars: workerUrlHtml,
+		razor: workerUrlHtml,
+		typescript: workerUrlTs,
+		javascript: workerUrlTs
+	};
+	try {
+		await Promise.all(unique.map((u) => fetch(u, {
+			method: "GET",
+			cache: "force-cache"
+		}).catch(() => void 0)));
+		self.MonacoEnvironment = { getWorker(_, label) {
+			const url = workerUrlByLabel[label] ?? workerUrlEditor;
+			return new Worker(url, { type: "module" });
+		} };
+	} catch {}
+}
+
+//#endregion
+//#region src/utils/arraysEqual.ts
+function arraysEqual(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+
+//#endregion
+//#region src/utils/registerMonacoThemes.ts
+let themesRegistered = false;
+let languagesRegistered = false;
+let currentThemes = [];
+let currentLanguages = [];
+let themeRegisterPromise = null;
+function setThemeRegisterPromise(p) {
+	return themeRegisterPromise = p;
+}
+const highlighterCache = /* @__PURE__ */ new Map();
+/**
+* Clear all cached shiki highlighters.
+*
+* Useful for long-running apps that dynamically create many theme combinations,
+* or in tests to ensure a clean state. Call this when you know the highlighters
+* are no longer needed (for example on app shutdown) to free memory.
+*/
+function clearHighlighterCache() {
+	highlighterCache.clear();
+}
+function serializeThemes(themes) {
+	return JSON.stringify(themes.map((t) => typeof t === "string" ? t : t.name ?? JSON.stringify(t)).sort());
+}
+async function getOrCreateHighlighter(themes, languages$1) {
+	const key = serializeThemes(themes);
+	const requestedSet = new Set(languages$1);
+	let existing = highlighterCache.get(key);
+	if (existing) {
+		let allIncluded = true;
+		for (const l of requestedSet) if (!existing.languages.has(l)) {
+			allIncluded = false;
+			break;
+		}
+		if (allIncluded) return existing.promise;
+		const prev = existing;
+		const current = highlighterCache.get(key);
+		if (current && current !== prev) {
+			let allIncludedCurrent = true;
+			for (const l of requestedSet) if (!current.languages.has(l)) {
+				allIncludedCurrent = false;
+				break;
+			}
+			if (allIncludedCurrent) return current.promise;
+			existing = current;
+		}
+		const union = new Set([...existing.languages, ...requestedSet]);
+		const langsArray = Array.from(union);
+		const p$1 = createHighlighter({
+			themes,
+			langs: langsArray
+		});
+		const newEntry = {
+			promise: p$1,
+			languages: union
+		};
+		highlighterCache.set(key, newEntry);
+		p$1.catch(() => {
+			if (highlighterCache.get(key) === newEntry && prev) highlighterCache.set(key, prev);
+		});
+		return p$1;
+	}
+	const p = createHighlighter({
+		themes,
+		langs: Array.from(requestedSet)
+	});
+	const entry = {
+		promise: p,
+		languages: requestedSet
+	};
+	highlighterCache.set(key, entry);
+	p.catch(() => {
+		if (highlighterCache.get(key) === entry) highlighterCache.delete(key);
+	});
+	return p;
+}
+/**
+* Update the theme used by the shiki highlighter for a given themes+languages
+* combination. Useful when Monaco themes are already registered (so switching
+* Monaco only requires `monaco.editor.setTheme`) but you also want shiki's
+* standalone renderer to use the new theme without recreating everything.
+*/
+async function registerMonacoThemes(themes, languages$1) {
+	registerMonacoLanguages(languages$1);
+	if (themesRegistered && arraysEqual(themes, currentThemes) && arraysEqual(languages$1, currentLanguages)) {
+		const existing = highlighterCache.get(serializeThemes(themes));
+		return existing ? existing.promise : Promise.resolve(null);
+	}
+	const p = (async () => {
+		const highlighter = await getOrCreateHighlighter(themes, languages$1);
+		shikiToMonaco(highlighter, monaco_shim_exports);
+		themesRegistered = true;
+		currentThemes = themes;
+		currentLanguages = languages$1;
+		return highlighter;
+	})();
+	setThemeRegisterPromise(p);
+	try {
+		const res = await p;
+		return res;
+	} catch (e) {
+		setThemeRegisterPromise(null);
+		throw e;
+	}
+}
+function registerMonacoLanguages(languages$1) {
+	if (languagesRegistered && arraysEqual(languages$1, currentLanguages)) return;
+	const existing = new Set(monaco_shim_exports.languages.getLanguages().map((l) => l.id));
+	for (const lang of languages$1) if (!existing.has(lang)) try {
+		monaco_shim_exports.languages.register({ id: lang });
+	} catch {}
+	languagesRegistered = true;
+	currentLanguages = languages$1;
+}
+
+//#endregion
+//#region src/type.ts
+let RevealStrategy = /* @__PURE__ */ function(RevealStrategy$1) {
+	RevealStrategy$1["Bottom"] = "bottom";
+	RevealStrategy$1["CenterIfOutside"] = "centerIfOutside";
+	RevealStrategy$1["Center"] = "center";
+	return RevealStrategy$1;
+}({});
+
+//#endregion
+//#region src/index.ts
+/**
+* useMonaco 组合式函数
+*
+* 提供 Monaco 编辑器的创建、销毁、内容/主题/语言更新等能力。
+* 支持主题自动切换、语言高亮、代码更新等功能。
+*
+* @param {MonacoOptions} [monacoOptions] - 编辑器初始化配置，支持 Monaco 原生配置及扩展项
+* @param {number | string} [monacoOptions.MAX_HEIGHT] - 编辑器最大高度，可以是数字（像素）或 CSS 字符串（如 '100%', 'calc(100vh - 100px)'）
+* @param {boolean} [monacoOptions.readOnly] - 是否为只读模式
+* @param {MonacoTheme[]} [monacoOptions.themes] - 主题数组，至少包含两个主题：[暗色主题, 亮色主题]
+* @param {MonacoLanguage[]} [monacoOptions.languages] - 支持的编程语言数组
+* @param {string} [monacoOptions.theme] - 初始主题名称
+* @param {boolean} [monacoOptions.isCleanOnBeforeCreate] - 是否在创建前清理之前注册的资源, 默认为 true
+* @param {(monaco: typeof import('monaco-editor')) => monaco.IDisposable[]} [monacoOptions.onBeforeCreate] - 编辑器创建前的钩子函数
+*
+* @returns {{
+*   createEditor: (container: HTMLElement, code: string, language: string) => Promise<monaco.editor.IStandaloneCodeEditor>,
+*   createDiffEditor: (
+*     container: HTMLElement,
+*     originalCode: string,
+*     modifiedCode: string,
+*     language: string,
+*   ) => Promise<monaco.editor.IStandaloneDiffEditor>,
+*   cleanupEditor: () => void,
+*   updateCode: (newCode: string, codeLanguage: string) => void,
+*   appendCode: (appendText: string, codeLanguage?: string) => void,
+*   updateDiff: (
+*     originalCode: string,
+*     modifiedCode: string,
+*     codeLanguage?: string,
+*   ) => void,
+*   updateOriginal: (newCode: string, codeLanguage?: string) => void,
+*   updateModified: (newCode: string, codeLanguage?: string) => void,
+*   appendOriginal: (appendText: string, codeLanguage?: string) => void,
+*   appendModified: (appendText: string, codeLanguage?: string) => void,
+*   setTheme: (theme: MonacoTheme) => Promise<void>,
+*   setLanguage: (language: MonacoLanguage) => void,
+*   getCurrentTheme: () => string,
+*   getEditor: () => typeof monaco.editor,
+*   getEditorView: () => monaco.editor.IStandaloneCodeEditor | null,
+*   getDiffEditorView: () => monaco.editor.IStandaloneDiffEditor | null,
+*   getDiffModels: () => { original: monaco.editor.ITextModel | null, modified: monaco.editor.ITextModel | null },
+* }} 返回对象包含以下方法和属性：
+*
+* @property {Function} createEditor - 创建并挂载 Monaco 编辑器到指定容器
+* @property {Function} cleanupEditor - 销毁编辑器并清理容器
+* @property {Function} updateCode - 更新编辑器内容和语言，必要时滚动到底部
+* @property {Function} appendCode - 在编辑器末尾追加文本，必要时滚动到底部
+* @property {Function} createDiffEditor - 创建并挂载 Diff 编辑器
+* @property {Function} updateDiff - 更新 Diff 编辑器的 original/modified 内容（RAF 合并、增量更新）
+* @property {Function} updateOriginal - 仅更新 Diff 的 original 内容（增量更新）
+* @property {Function} updateModified - 仅更新 Diff 的 modified 内容（增量更新）
+* @property {Function} appendOriginal - 在 Diff 的 original 末尾追加（显式流式场景）
+* @property {Function} appendModified - 在 Diff 的 modified 末尾追加（显式流式场景）
+* @property {Function} setTheme - 切换编辑器主题，返回 Promise，在主题应用完成时 resolve
+* @property {Function} setLanguage - 切换编辑器语言
+* @property {Function} getCurrentTheme - 获取当前主题名称
+* @property {Function} getEditor - 获取 Monaco 的静态 editor 对象（用于静态方法调用）
+* @property {Function} getEditorView - 获取当前编辑器实例
+* @property {Function} getDiffEditorView - 获取当前 Diff 编辑器实例
+* @property {Function} getDiffModels - 获取 Diff 的 original/modified 两个模型
+*
+* @throws {Error} 当主题数组不是数组或长度小于2时抛出错误
+*
+* @example
+* ```typescript
+* import { useMonaco } from 'stream-monaco'
+*
+* const { createEditor, updateCode, setTheme } = useMonaco({
+*   themes: ['vitesse-dark', 'vitesse-light'],
+*   languages: ['javascript', 'typescript'],
+*   readOnly: false
+* })
+*
+* // 创建编辑器
+* const editor = await createEditor(containerRef.value, 'console.log("hello")', 'javascript')
+*
+* // 更新代码
+* updateCode('console.log("world")', 'javascript')
+*
+* // 切换主题
+* setTheme('vitesse-light')
+* ```
+*/
+function useMonaco(monacoOptions = {}) {
+	var _monacoOptions$themes;
+	const disposals = [];
+	if (monacoOptions.isCleanOnBeforeCreate ?? true) disposals.forEach((d) => d.dispose());
+	if (monacoOptions.isCleanOnBeforeCreate ?? true) disposals.length = 0;
+	let editorView = null;
+	let editorMgr = null;
+	let diffEditorView = null;
+	let diffMgr = null;
+	let originalModel = null;
+	let modifiedModel = null;
+	let _hasScrollBar = false;
+	const themes = monacoOptions.themes && ((_monacoOptions$themes = monacoOptions.themes) === null || _monacoOptions$themes === void 0 ? void 0 : _monacoOptions$themes.length) ? monacoOptions.themes : defaultThemes;
+	if (!Array.isArray(themes) || themes.length < 2) throw new Error("Monaco themes must be an array with at least two themes: [darkTheme, lightTheme]");
+	const languages$1 = monacoOptions.languages ?? defaultLanguages;
+	const MAX_HEIGHT = monacoOptions.MAX_HEIGHT ?? 500;
+	const autoScrollOnUpdate = monacoOptions.autoScrollOnUpdate ?? true;
+	const autoScrollInitial = monacoOptions.autoScrollInitial ?? true;
+	const autoScrollThresholdPx = monacoOptions.autoScrollThresholdPx ?? 32;
+	const autoScrollThresholdLines = monacoOptions.autoScrollThresholdLines ?? 2;
+	const diffAutoScroll = monacoOptions.diffAutoScroll ?? true;
+	const getMaxHeightValue = () => {
+		if (typeof MAX_HEIGHT === "number") return MAX_HEIGHT;
+		const match = MAX_HEIGHT.match(/^(\d+(?:\.\d+)?)/);
+		return match ? Number.parseFloat(match[1]) : 500;
+	};
+	const getMaxHeightCSS = () => {
+		if (typeof MAX_HEIGHT === "number") return `${MAX_HEIGHT}px`;
+		return MAX_HEIGHT;
+	};
+	const maxHeightValue = getMaxHeightValue();
+	const maxHeightCSS = getMaxHeightCSS();
+	let lastContainer = null;
+	let lastKnownCode = null;
+	const minimalEditMaxCharsLocal = monacoOptions.minimalEditMaxChars ?? minimalEditMaxChars;
+	const minimalEditMaxChangeRatioLocal = monacoOptions.minimalEditMaxChangeRatio ?? minimalEditMaxChangeRatio;
+	let updateThrottleMs = monacoOptions.updateThrottleMs ?? 50;
+	let lastFlushTime = 0;
+	let updateThrottleTimer = null;
+	let pendingUpdate = null;
+	let shouldAutoScroll = true;
+	const cachedComputedHeight = null;
+	const appendBuffer = [];
+	let appendBufferScheduled = false;
+	let lastAppliedTheme = null;
+	const currentTheme = computed$1(() => monacoOptions.theme ?? (isDark.value ? typeof themes[0] === "string" ? themes[0] : themes[0].name : typeof themes[1] === "string" ? themes[1] : themes[1].name));
+	let themeWatcher = null;
+	const rafScheduler = createRafScheduler();
+	async function setThemeInternal(theme, force = false) {
+		const themeName = typeof theme === "string" ? theme : theme.name;
+		if (!force && themeName === lastAppliedTheme) return;
+		const _p = setThemeRegisterPromise(registerMonacoThemes(themes, languages$1));
+		if (_p) await _p.catch(() => void 0);
+		const availableNames = themes.map((t) => typeof t === "string" ? t : t.name);
+		if (!availableNames.includes(themeName)) try {
+			const extended = availableNames.concat(themeName);
+			const maybeHighlighter = await setThemeRegisterPromise(registerMonacoThemes(extended, languages$1));
+			if (maybeHighlighter && typeof maybeHighlighter.setTheme === "function") try {
+				await maybeHighlighter.setTheme(themeName);
+			} catch {}
+		} catch {
+			console.warn(`Theme "${themeName}" is not registered and automatic registration failed. Available themes: ${availableNames.join(", ")}`);
+			return;
+		}
+		try {
+			monaco_shim_exports.editor.setTheme(themeName);
+			lastAppliedTheme = themeName;
+		} catch {
+			try {
+				const maybeHighlighter = await registerMonacoThemes(themes, languages$1);
+				monaco_shim_exports.editor.setTheme(themeName);
+				lastAppliedTheme = themeName;
+				if (maybeHighlighter && typeof maybeHighlighter.setTheme === "function") await maybeHighlighter.setTheme(themeName).catch(() => void 0);
+			} catch (err2) {
+				console.warn(`Failed to set theme "${themeName}":`, err2);
+				return;
+			}
+		}
+		try {
+			if (typeof monacoOptions.onThemeChange === "function") await monacoOptions.onThemeChange(themeName);
+		} catch (err) {
+			console.warn("onThemeChange callback threw an error:", err);
+		}
+	}
+	function hasVerticalScrollbar() {
+		if (!editorView) return false;
+		if (_hasScrollBar) return true;
+		const ch = cachedComputedHeight ?? computedHeight(editorView);
+		return _hasScrollBar = editorView.getScrollHeight() > ch + padding / 2;
+	}
+	let revealDebounceId = null;
+	const revealDebounceMs = 75;
+	function maybeScrollToBottom(targetLine) {
+		if (autoScrollOnUpdate && shouldAutoScroll && hasVerticalScrollbar()) {
+			const model = editorView.getModel();
+			const line = targetLine ?? (model === null || model === void 0 ? void 0 : model.getLineCount()) ?? 1;
+			if (revealDebounceId != null) {
+				clearTimeout(revealDebounceId);
+				revealDebounceId = null;
+			}
+			revealDebounceId = setTimeout(() => {
+				revealDebounceId = null;
+				rafScheduler.schedule("reveal", () => {
+					try {
+						var _editor;
+						const ScrollType = monaco_shim_exports.ScrollType || ((_editor = monaco_shim_exports.editor) === null || _editor === void 0 ? void 0 : _editor.ScrollType);
+						if (ScrollType && typeof ScrollType.Smooth !== "undefined") editorView.revealLineInCenterIfOutsideViewport(line, ScrollType.Smooth);
+						else editorView.revealLineInCenterIfOutsideViewport(line);
+					} catch {}
+				});
+			}, revealDebounceMs);
+		}
+	}
+	async function createEditor(container, code, language) {
+		cleanupEditor();
+		lastContainer = container;
+		if (monacoOptions.isCleanOnBeforeCreate ?? true) {
+			disposals.forEach((d) => d.dispose());
+			disposals.length = 0;
+		}
+		if (monacoOptions.onBeforeCreate) {
+			const ds = monacoOptions.onBeforeCreate(monaco_shim_exports);
+			if (ds) disposals.push(...ds);
+		}
+		await setThemeRegisterPromise(registerMonacoThemes(themes, languages$1));
+		const initialThemeName = monacoOptions.theme ?? currentTheme.value;
+		lastAppliedTheme = initialThemeName;
+		editorMgr = new EditorManager(monacoOptions, maxHeightValue, maxHeightCSS, autoScrollOnUpdate, autoScrollInitial, autoScrollThresholdPx, autoScrollThresholdLines, monacoOptions.revealDebounceMs);
+		editorView = await editorMgr.createEditor(container, code, language, initialThemeName);
+		if (typeof monacoOptions.onThemeChange === "function") monacoOptions.onThemeChange(initialThemeName);
+		if (!monacoOptions.theme) themeWatcher = watch(() => isDark.value, () => {
+			const t = currentTheme.value;
+			if (t !== lastAppliedTheme) setThemeInternal(t);
+		}, {
+			flush: "post",
+			immediate: true
+		});
+		try {
+			if (editorView) lastKnownCode = editorView.getValue();
+		} catch {}
+		return editorView;
+	}
+	function computedHeight(editorView$1) {
+		var _getModel;
+		const lineCount = ((_getModel = editorView$1.getModel()) === null || _getModel === void 0 ? void 0 : _getModel.getLineCount()) ?? 1;
+		const lineHeight = editorView$1.getOption(monaco_shim_exports.editor.EditorOption.lineHeight);
+		const height = Math.min(lineCount * lineHeight + padding, maxHeightValue);
+		return height;
+	}
+	async function createDiffEditor(container, originalCode, modifiedCode, language) {
+		cleanupEditor();
+		lastContainer = container;
+		if (monacoOptions.isCleanOnBeforeCreate ?? true) {
+			disposals.forEach((d) => d.dispose());
+			disposals.length = 0;
+		}
+		if (monacoOptions.onBeforeCreate) {
+			const ds = monacoOptions.onBeforeCreate(monaco_shim_exports);
+			if (ds) disposals.push(...ds);
+		}
+		await setThemeRegisterPromise(registerMonacoThemes(themes, languages$1));
+		const initialThemeName = monacoOptions.theme ?? currentTheme.value;
+		try {
+			monaco_shim_exports.editor.setTheme(initialThemeName);
+			lastAppliedTheme = initialThemeName;
+		} catch {}
+		diffMgr = new DiffEditorManager(monacoOptions, maxHeightValue, maxHeightCSS, autoScrollOnUpdate, autoScrollInitial, autoScrollThresholdPx, autoScrollThresholdLines, diffAutoScroll, monacoOptions.revealDebounceMs);
+		diffEditorView = await diffMgr.createDiffEditor(container, originalCode, modifiedCode, language, initialThemeName);
+		if (typeof monacoOptions.onThemeChange === "function") monacoOptions.onThemeChange(initialThemeName);
+		if (!monacoOptions.theme) themeWatcher = watch(() => isDark.value, () => {
+			const t = currentTheme.value;
+			if (t !== lastAppliedTheme) setThemeInternal(t);
+		}, {
+			flush: "post",
+			immediate: true
+		});
+		const models = diffMgr.getDiffModels();
+		originalModel = models.original;
+		modifiedModel = models.modified;
+		return diffEditorView;
+	}
+	function cleanupEditor() {
+		if (editorMgr) {
+			editorMgr.cleanup();
+			editorMgr = null;
+		}
+		if (diffMgr) {
+			diffMgr.cleanup();
+			diffMgr = null;
+		}
+		rafScheduler.cancel("update");
+		pendingUpdate = null;
+		rafScheduler.cancel("append");
+		appendBufferScheduled = false;
+		appendBuffer.length = 0;
+		if (!editorMgr && editorView) {
+			editorView.dispose();
+			editorView = null;
+		}
+		lastKnownCode = null;
+		if (lastContainer) {
+			lastContainer.innerHTML = "";
+			lastContainer = null;
+		}
+		if (themeWatcher) {
+			themeWatcher();
+			themeWatcher = null;
+		}
+		if (updateThrottleTimer != null) {
+			clearTimeout(updateThrottleTimer);
+			updateThrottleTimer = null;
+		}
+		diffEditorView = null;
+		originalModel = null;
+		modifiedModel = null;
+	}
+	function appendCode(appendText, codeLanguage) {
+		if (editorMgr) editorMgr.appendCode(appendText, codeLanguage);
+		else {
+			if (!editorView) return;
+			const model = editorView.getModel();
+			if (!model) return;
+			const processedCodeLanguage = codeLanguage ? processedLanguage(codeLanguage) : model.getLanguageId();
+			if (processedCodeLanguage && model.getLanguageId() !== processedCodeLanguage) monaco_shim_exports.editor.setModelLanguage(model, processedCodeLanguage);
+			if (appendText && lastKnownCode != null) lastKnownCode = lastKnownCode + appendText;
+			if (appendText) {
+				appendBuffer.push(appendText);
+				if (!appendBufferScheduled) {
+					appendBufferScheduled = true;
+					rafScheduler.schedule("append", flushAppendBuffer);
+				}
+			}
+		}
+	}
+	function applyMinimalEdit(prev, next) {
+		if (!editorView) return;
+		const model = editorView.getModel();
+		if (!model) return;
+		try {
+			const maxChars = minimalEditMaxCharsLocal;
+			const ratio = minimalEditMaxChangeRatioLocal;
+			const maxLen = Math.max(prev.length, next.length);
+			const changeRatio = maxLen > 0 ? Math.abs(next.length - prev.length) / maxLen : 0;
+			if (prev.length + next.length > maxChars || changeRatio > ratio) {
+				const prevLineCount = model.getLineCount();
+				model.setValue(next);
+				lastKnownCode = next;
+				const newLineCount = model.getLineCount();
+				if (newLineCount !== prevLineCount) maybeScrollToBottom(newLineCount);
+				return;
+			}
+		} catch {}
+		const res = computeMinimalEdit(prev, next);
+		if (!res) return;
+		const { start, endPrevIncl, replaceText } = res;
+		const rangeStart = model.getPositionAt(start);
+		const rangeEnd = model.getPositionAt(endPrevIncl + 1);
+		const range = new monaco_shim_exports.Range(rangeStart.lineNumber, rangeStart.column, rangeEnd.lineNumber, rangeEnd.column);
+		const isReadOnly = editorView.getOption(monaco_shim_exports.editor.EditorOption.readOnly);
+		const edit = [{
+			range,
+			text: replaceText,
+			forceMoveMarkers: true
+		}];
+		if (isReadOnly) model.applyEdits(edit);
+		else editorView.executeEdits("minimal-replace", edit);
+	}
+	function flushPendingUpdate() {
+		if (!pendingUpdate) return;
+		lastFlushTime = Date.now();
+		if (!editorView) return;
+		const model = editorView.getModel();
+		if (!model) return;
+		const { code: newCode, lang: codeLanguage } = pendingUpdate;
+		pendingUpdate = null;
+		const processedCodeLanguage = processedLanguage(codeLanguage);
+		let prevCode = lastKnownCode;
+		if (prevCode == null) try {
+			prevCode = model.getValue();
+			lastKnownCode = prevCode;
+		} catch {
+			prevCode = "";
+		}
+		if (prevCode === newCode) return;
+		const languageId = model.getLanguageId();
+		if (languageId !== processedCodeLanguage) {
+			if (processedCodeLanguage) monaco_shim_exports.editor.setModelLanguage(model, processedCodeLanguage);
+			const prevLineCount = model.getLineCount();
+			model.setValue(newCode);
+			lastKnownCode = newCode;
+			const newLineCount = model.getLineCount();
+			if (newLineCount !== prevLineCount) maybeScrollToBottom(newLineCount);
+			return;
+		}
+		if (newCode.startsWith(prevCode) && prevCode.length < newCode.length) {
+			const suffix = newCode.slice(prevCode.length);
+			if (suffix) appendCode(suffix, codeLanguage);
+			lastKnownCode = newCode;
+			return;
+		}
+		try {
+			const maxChars = minimalEditMaxCharsLocal;
+			const ratio = minimalEditMaxChangeRatioLocal;
+			const maxLen = Math.max(prevCode.length, newCode.length);
+			const changeRatio = maxLen > 0 ? Math.abs(newCode.length - prevCode.length) / maxLen : 0;
+			if (prevCode.length + newCode.length > maxChars || changeRatio > ratio) {
+				const prevLineCount = model.getLineCount();
+				model.setValue(newCode);
+				lastKnownCode = newCode;
+				const newLineCount = model.getLineCount();
+				if (newLineCount !== prevLineCount) maybeScrollToBottom(newLineCount);
+				return;
+			}
+		} catch {}
+		try {
+			applyMinimalEdit(prevCode, newCode);
+			lastKnownCode = newCode;
+			const newLineCount = model.getLineCount();
+			const prevLineCount = (prevCode ? prevCode.split("\n").length : 0) || model.getLineCount();
+			if (newLineCount !== prevLineCount) maybeScrollToBottom(newLineCount);
+		} catch {
+			try {
+				const prevLineCount = model.getLineCount();
+				model.setValue(newCode);
+				lastKnownCode = newCode;
+				const newLineCount = model.getLineCount();
+				if (newLineCount !== prevLineCount) maybeScrollToBottom(newLineCount);
+			} catch {}
+		}
+	}
+	function flushAppendBuffer() {
+		if (!editorView) return;
+		if (appendBuffer.length === 0) return;
+		appendBufferScheduled = false;
+		const model = editorView.getModel();
+		if (!model) {
+			appendBuffer.length = 0;
+			return;
+		}
+		const text = appendBuffer.join("");
+		appendBuffer.length = 0;
+		try {
+			const lastLine = model.getLineCount();
+			const lastColumn = model.getLineMaxColumn(lastLine);
+			const range = new monaco_shim_exports.Range(lastLine, lastColumn, lastLine, lastColumn);
+			const isReadOnly = editorView.getOption(monaco_shim_exports.editor.EditorOption.readOnly);
+			if (isReadOnly) model.applyEdits([{
+				range,
+				text,
+				forceMoveMarkers: true
+			}]);
+			else editorView.executeEdits("append", [{
+				range,
+				text,
+				forceMoveMarkers: true
+			}]);
+			if (lastKnownCode != null) lastKnownCode = lastKnownCode + text;
+			try {
+				if (lastLine !== model.getLineCount()) maybeScrollToBottom(model.getLineCount());
+			} catch {}
+		} catch {}
+	}
+	function updateCode(newCode, codeLanguage) {
+		if (editorMgr) editorMgr.updateCode(newCode, codeLanguage);
+		else {
+			pendingUpdate = {
+				code: newCode,
+				lang: codeLanguage
+			};
+			rafScheduler.schedule("update", () => {
+				if (!updateThrottleMs) {
+					flushPendingUpdate();
+					return;
+				}
+				const now = Date.now();
+				const since = now - lastFlushTime;
+				if (since >= updateThrottleMs) {
+					flushPendingUpdate();
+					return;
+				}
+				if (updateThrottleTimer != null) return;
+				const wait = updateThrottleMs - since;
+				updateThrottleTimer = setTimeout(() => {
+					updateThrottleTimer = null;
+					rafScheduler.schedule("update", () => flushPendingUpdate());
+				}, wait);
+			});
+		}
+	}
+	function setUpdateThrottleMs(ms) {
+		updateThrottleMs = ms;
+	}
+	function getUpdateThrottleMs() {
+		return updateThrottleMs;
+	}
+	function updateDiff(originalCode, modifiedCode, codeLanguage) {
+		if (diffMgr) diffMgr.updateDiff(originalCode, modifiedCode, codeLanguage);
+	}
+	function updateOriginal(newCode, codeLanguage) {
+		if (diffMgr) diffMgr.updateOriginal(newCode, codeLanguage);
+	}
+	function updateModified(newCode, codeLanguage) {
+		if (diffMgr) diffMgr.updateModified(newCode, codeLanguage);
+	}
+	function appendOriginal(appendText, codeLanguage) {
+		if (diffMgr) diffMgr.appendOriginal(appendText, codeLanguage);
+	}
+	function appendModified(appendText, codeLanguage) {
+		if (diffMgr) diffMgr.appendModified(appendText, codeLanguage);
+	}
+	return {
+		createEditor,
+		createDiffEditor,
+		cleanupEditor,
+		safeClean() {
+			rafScheduler.cancel("update");
+			pendingUpdate = null;
+			if (editorMgr) try {
+				editorMgr.safeClean();
+			} catch {}
+			if (diffMgr) try {
+				diffMgr.safeClean();
+			} catch {}
+			_hasScrollBar = false;
+			shouldAutoScroll = !!autoScrollInitial;
+		},
+		updateCode,
+		appendCode,
+		updateDiff,
+		updateOriginal,
+		updateModified,
+		appendOriginal,
+		appendModified,
+		setTheme: setThemeInternal,
+		setLanguage(language) {
+			if (editorMgr) {
+				editorMgr.setLanguage(language, languages$1);
+				return;
+			}
+			if (diffMgr) {
+				diffMgr.setLanguage(language, languages$1);
+				return;
+			}
+			if (languages$1.includes(language)) {
+				if (editorView) {
+					const model = editorView.getModel();
+					if (model && model.getLanguageId() !== language) monaco_shim_exports.editor.setModelLanguage(model, language);
+				}
+				if (originalModel && originalModel.getLanguageId() !== language) monaco_shim_exports.editor.setModelLanguage(originalModel, language);
+				if (modifiedModel && modifiedModel.getLanguageId() !== language) monaco_shim_exports.editor.setModelLanguage(modifiedModel, language);
+			} else console.warn(`Language "${language}" is not registered. Available languages: ${languages$1.join(", ")}`);
+		},
+		getCurrentTheme() {
+			return currentTheme.value;
+		},
+		getEditor() {
+			return monaco_shim_exports.editor;
+		},
+		getEditorView() {
+			return editorView;
+		},
+		getDiffEditorView() {
+			return diffEditorView;
+		},
+		getDiffModels() {
+			return {
+				original: originalModel,
+				modified: modifiedModel
+			};
+		},
+		getMonacoInstance() {
+			return monaco_shim_exports;
+		},
+		setUpdateThrottleMs,
+		getUpdateThrottleMs
+	};
+}
+
+//#endregion
+export { RevealStrategy, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, isDark, preloadMonacoWorkers, registerMonacoThemes, useMonaco };