stream-monaco 0.0.17 → 0.0.19

package/README.md

@@ -1,4 +1,4 @@
-## stream-monaco
+# stream-monaco
 
 [![NPM version](https://img.shields.io/npm/v/stream-monaco?color=a1b858&label=)](https://www.npmjs.com/package/stream-monaco)
 [![中文版](https://img.shields.io/badge/docs-中文文档-blue)](README.zh-CN.md)
@@ -6,6 +6,8 @@
 [![Bundle size](https://img.shields.io/bundlephobia/minzip/stream-monaco)](https://bundlephobia.com/package/stream-monaco)
 [![License](https://img.shields.io/npm/l/stream-monaco)](./LICENSE)
 
+Streaming Monaco Editor integration with Shiki syntax highlighting. Framework-agnostic core for Vue, React, Svelte, Solid, Preact, and Vanilla JS.
+
 ### Introduction
 
 stream-monaco provides a framework-agnostic core for integrating Monaco Editor with Shiki syntax highlighting, optimized for streaming updates and efficient highlighting. It works great without Vue, while also offering a Vue-friendly API and examples.
@@ -362,6 +364,10 @@ const {
   languages: ['javascript', 'typescript'],
   readOnly: true,
   MAX_HEIGHT: 500,
+  // Collapse long unchanged regions automatically.
+  diffHideUnchangedRegions: true,
+  // Hover a changed hunk to show split upper/lower Revert/Stage actions.
+  diffHunkActionsOnHover: true,
 })
 
 const original = `export function add(a: number, b: number) {\n  return a + b\n}`
@@ -378,6 +384,61 @@ onMounted(async () => {
 </template>
 ```
 
+Diff UX options:
+
+- `diffHideUnchangedRegions` (default `true`): fold unchanged ranges (can pass Monaco `hideUnchangedRegions` object).
+- `diffHunkActionsOnHover` (default `false`): explicitly set `true` to enable split upper/lower `Revert` and `Stage` on hunk hover.
+- `onDiffHunkAction(context)` (optional): return `false` to intercept and skip built-in model edits.
+
+Example 1: enable unchanged folding + hover Revert/Stage
+
+```ts
+const { createDiffEditor } = useMonaco({
+  themes: ['vitesse-dark', 'vitesse-light'],
+  languages: ['typescript'],
+  readOnly: true,
+  diffHideUnchangedRegions: {
+    enabled: true,
+    contextLineCount: 2,
+    minimumLineCount: 4,
+    revealLineCount: 2,
+  },
+  diffHunkActionsOnHover: true,
+})
+
+await createDiffEditor(container, original, modified, 'typescript')
+```
+
+Example 2: fully intercept Revert/Stage and handle your own stash/patch flow
+
+```ts
+useMonaco({
+  diffHideUnchangedRegions: true,
+  diffHunkActionsOnHover: true,
+  onDiffHunkAction: async (ctx) => {
+    const {
+      action, // 'revert' | 'stage'
+      side, // 'upper' | 'lower'
+      lineChange,
+      originalModel,
+      modifiedModel,
+    } = ctx
+
+    await saveHunkAction({
+      action,
+      side,
+      range: lineChange,
+      original: originalModel.getValue(),
+      modified: modifiedModel.getValue(),
+    })
+
+    // false => skip built-in edit, fully controlled by user code
+    // true/undefined => continue built-in edit
+    return false
+  },
+})
+```
+
 ### Shiki highlighter (advanced)
 
 If you also render Shiki snippets outside Monaco:

package/README.zh-CN.md

@@ -1,4 +1,4 @@
-## stream-monaco
+# stream-monaco
 
 [![NPM version](https://img.shields.io/npm/v/stream-monaco?color=a1b858&label=)](https://www.npmjs.com/package/stream-monaco)
 [![English Docs](https://img.shields.io/badge/docs-English-blue)](README.md)
@@ -6,6 +6,8 @@
 [![Bundle size](https://img.shields.io/bundlephobia/minzip/stream-monaco)](https://bundlephobia.com/package/stream-monaco)
 [![License](https://img.shields.io/npm/l/stream-monaco)](./LICENSE)
 
+流式更新版 Monaco Editor + Shiki 语法高亮，提供框架无关内核，适配 Vue、React、Svelte、Solid、Preact 与 Vanilla JS。
+
 ### 项目简介
 
 `stream-monaco` 提供一个与框架无关的内核来集成 Monaco 编辑器与 Shiki 语法高亮，针对流式更新与高效高亮做了优化；可在无 Vue 的环境下使用，同时也提供对 Vue 3 的友好支持与示例。
@@ -378,6 +380,10 @@ const {
   languages: ['javascript', 'typescript'],
   readOnly: true,
   MAX_HEIGHT: 500,
+  // 自动折叠大段未改动区域
+  diffHideUnchangedRegions: true,
+  // hover 变更块时显示上下分区的局部 Revert / Stage 操作
+  diffHunkActionsOnHover: true,
 })
 
 const original = `export function add(a: number, b: number) {\n  return a + b\n}`
@@ -390,6 +396,62 @@ onMounted(async () => {
 })
 ```
 
+Diff 体验增强相关配置：
+
+- `diffHideUnchangedRegions`（默认 `true`）：折叠未改动区块；也支持直接传 Monaco 的 `hideUnchangedRegions` 对象。
+- `diffHunkActionsOnHover`（默认 `false`）：仅在显式传 `true` 时，hover 变更 hunk 才会显示上下分区的 `Revert` / `Stage`。
+- `onDiffHunkAction(context)`（可选）：返回 `false` 可拦截并跳过内置模型编辑逻辑。
+
+示例 1：开启 hidden 区折叠 + hover Revert/Stage（可理解为局部回退与暂存）
+
+```ts
+const { createDiffEditor } = useMonaco({
+  themes: ['vitesse-dark', 'vitesse-light'],
+  languages: ['typescript'],
+  readOnly: true,
+  diffHideUnchangedRegions: {
+    enabled: true,
+    contextLineCount: 2,
+    minimumLineCount: 4,
+    revealLineCount: 2,
+  },
+  diffHunkActionsOnHover: true,
+})
+
+await createDiffEditor(container, original, modified, 'typescript')
+```
+
+示例 2：完全接管 Revert/Stage 事件（接你自己的 stash / patch API）
+
+```ts
+useMonaco({
+  diffHideUnchangedRegions: true,
+  diffHunkActionsOnHover: true,
+  onDiffHunkAction: async (ctx) => {
+    const {
+      action, // 'revert' | 'stage'
+      side, // 'upper' | 'lower'
+      lineChange,
+      originalModel,
+      modifiedModel,
+    } = ctx
+
+    // 这里接你的服务端逻辑，例如提交到 stash / patch 队列
+    await saveHunkAction({
+      action,
+      side,
+      range: lineChange,
+      original: originalModel.getValue(),
+      modified: modifiedModel.getValue(),
+    })
+
+    // 返回 false: 拦截内置编辑（由你完全接管）
+    // 返回 true/undefined: 继续执行内置编辑
+    return false
+  },
+})
+```
+
 ### Shiki 高亮器（高级说明）
 
 如果你在页面上除了 Monaco 编辑器外还使用 Shiki 的 highlighter 单独渲染代码片段（例如静态 HTML 片段），推荐的做法是：
@@ -641,6 +703,10 @@ modified?.onDidChangeContent?.(() => { /* ... */ })
 | `autoScrollThresholdPx` | `number`           | `32`                                | 自动滚动的像素阈值             |
 | `autoScrollThresholdLines` | `number`        | `2`                                 | 自动滚动的行数阈值             |
 | `diffAutoScroll`        | `boolean`          | `true`                              | 是否启用 Diff modified 侧自动滚动 |
+| `diffHideUnchangedRegions` | `boolean \| object` | `true`                           | 是否折叠 Diff 中未改动区块（支持传 Monaco 配置对象） |
+| `diffHunkActionsOnHover` | `boolean`         | `false`                             | 是否启用 hover hunk 的上下分区局部 Revert / Stage（需显式开启） |
+| `diffHunkHoverHideDelayMs` | `number`        | `160`                               | hover 操作浮层离开后的隐藏延迟（毫秒） |
+| `onDiffHunkAction`      | `function`         | -                                   | hunk 操作回调（返回 `false` 可阻止默认编辑） |
 
 ##### 返回值
 

package/dist/{index.base-D0jPJkA_.d.cts → index.base-9QTN8hPV.d.cts}

@@ -1,7 +1,7 @@
 import * as monaco_editor0 from "monaco-editor";
 import * as monaco$1 from "monaco-editor";
-import * as _monaco from "monaco-editor";
 import { Highlighter, SpecialTheme, ThemeInput } from "shiki";
+import * as _monaco from "monaco-editor/esm/vs/editor/editor.api";
 
 //#region rolldown:runtime
 //#endregion
@@ -45,6 +45,31 @@ interface MonacoOptions extends monaco$1.editor.IStandaloneEditorConstructionOpt
    * 默认 true（与单编辑器体验保持一致）。
    */
   diffAutoScroll?: boolean;
+  /**
+   * Controls Monaco's diff unchanged-region folding behavior.
+   * - `true`: use stream-monaco defaults (enabled with compact context lines)
+   * - `false`: disable unchanged-region folding
+   * - object: forward to Monaco `hideUnchangedRegions`
+   *
+   * Default: `true`
+   */
+  diffHideUnchangedRegions?: boolean | NonNullable<monaco$1.editor.IDiffEditorConstructionOptions['hideUnchangedRegions']>;
+  /**
+   * Enable hover actions for each diff hunk split part (upper/lower):
+   * local `revert` and `stage`.
+   * Default: `false` (must be explicitly enabled).
+   */
+  diffHunkActionsOnHover?: boolean;
+  /**
+   * Hide delay (ms) for diff hunk hover action widgets after mouse leaves.
+   * Default: `160`.
+   */
+  diffHunkHoverHideDelayMs?: number;
+  /**
+   * Optional interception callback for hunk hover actions.
+   * Return `false` to prevent the built-in model edit behavior.
+   */
+  onDiffHunkAction?: (context: DiffHunkActionContext) => void | boolean;
   /**
    * Debounce time (ms) to coalesce multiple reveal requests into a single
    * reveal. Useful for streaming/append scenarios. Default: 75
@@ -105,6 +130,15 @@ declare enum RevealStrategy {
   CenterIfOutside = "centerIfOutside",
   Center = "center",
 }
+type DiffHunkActionKind = 'revert' | 'stage';
+type DiffHunkSide = 'upper' | 'lower';
+interface DiffHunkActionContext {
+  action: DiffHunkActionKind;
+  side: DiffHunkSide;
+  lineChange: monaco$1.editor.ILineChange;
+  originalModel: monaco$1.editor.ITextModel;
+  modifiedModel: monaco$1.editor.ITextModel;
+}
 //#endregion
 //#region src/code.detect.d.ts
 /**
@@ -141,8 +175,8 @@ declare const defaultRevealDebounceMs = 75;
 declare namespace monaco_shim_d_exports {
   export { monaco as default };
 }
-import * as import_monaco_editor from "monaco-editor";
-__reExport(monaco_shim_d_exports, import_monaco_editor);
+import * as import_monaco_editor_esm_vs_editor_editor_api from "monaco-editor/esm/vs/editor/editor.api";
+__reExport(monaco_shim_d_exports, import_monaco_editor_esm_vs_editor_editor_api);
 declare const monaco: typeof _monaco;
 //#endregion
 //#region src/utils/registerMonacoThemes.d.ts
@@ -286,4 +320,4 @@ declare function useMonaco(monacoOptions?: MonacoOptions): {
   } | null;
 };
 //#endregion
-export { MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco };
+export { DiffHunkActionContext, DiffHunkActionKind, DiffHunkSide, MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco };

package/dist/{index.base-BaAqAXUs.d.ts → index.base-D0lzInae.d.ts}

@@ -1,8 +1,8 @@
 import { __export, __reExport } from "./chunk-CHLpw0oG.js";
+import * as _monaco from "monaco-editor/esm/vs/editor/editor.api";
+import { Highlighter, SpecialTheme, ThemeInput } from "shiki";
 import * as monaco_editor0 from "monaco-editor";
 import * as monaco$1 from "monaco-editor";
-import * as _monaco from "monaco-editor";
-import { Highlighter, SpecialTheme, ThemeInput } from "shiki";
 
 //#region src/type.d.ts
 type ShikiHighlighter = Highlighter | any;
@@ -44,6 +44,31 @@ interface MonacoOptions extends monaco$1.editor.IStandaloneEditorConstructionOpt
    * 默认 true（与单编辑器体验保持一致）。
    */
   diffAutoScroll?: boolean;
+  /**
+   * Controls Monaco's diff unchanged-region folding behavior.
+   * - `true`: use stream-monaco defaults (enabled with compact context lines)
+   * - `false`: disable unchanged-region folding
+   * - object: forward to Monaco `hideUnchangedRegions`
+   *
+   * Default: `true`
+   */
+  diffHideUnchangedRegions?: boolean | NonNullable<monaco$1.editor.IDiffEditorConstructionOptions['hideUnchangedRegions']>;
+  /**
+   * Enable hover actions for each diff hunk split part (upper/lower):
+   * local `revert` and `stage`.
+   * Default: `false` (must be explicitly enabled).
+   */
+  diffHunkActionsOnHover?: boolean;
+  /**
+   * Hide delay (ms) for diff hunk hover action widgets after mouse leaves.
+   * Default: `160`.
+   */
+  diffHunkHoverHideDelayMs?: number;
+  /**
+   * Optional interception callback for hunk hover actions.
+   * Return `false` to prevent the built-in model edit behavior.
+   */
+  onDiffHunkAction?: (context: DiffHunkActionContext) => void | boolean;
   /**
    * Debounce time (ms) to coalesce multiple reveal requests into a single
    * reveal. Useful for streaming/append scenarios. Default: 75
@@ -104,6 +129,15 @@ declare enum RevealStrategy {
   CenterIfOutside = "centerIfOutside",
   Center = "center",
 }
+type DiffHunkActionKind = 'revert' | 'stage';
+type DiffHunkSide = 'upper' | 'lower';
+interface DiffHunkActionContext {
+  action: DiffHunkActionKind;
+  side: DiffHunkSide;
+  lineChange: monaco$1.editor.ILineChange;
+  originalModel: monaco$1.editor.ITextModel;
+  modifiedModel: monaco$1.editor.ITextModel;
+}
 //#endregion
 //#region src/code.detect.d.ts
 /**
@@ -140,8 +174,8 @@ declare const defaultRevealDebounceMs = 75;
 declare namespace monaco_shim_d_exports {
   export { monaco as default };
 }
-import * as import_monaco_editor from "monaco-editor";
-__reExport(monaco_shim_d_exports, import_monaco_editor);
+import * as import_monaco_editor_esm_vs_editor_editor_api from "monaco-editor/esm/vs/editor/editor.api";
+__reExport(monaco_shim_d_exports, import_monaco_editor_esm_vs_editor_editor_api);
 declare const monaco: typeof _monaco;
 //#endregion
 //#region src/utils/registerMonacoThemes.d.ts
@@ -285,4 +319,4 @@ declare function useMonaco(monacoOptions?: MonacoOptions): {
   } | null;
 };
 //#endregion
-export { MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco };
+export { DiffHunkActionContext, DiffHunkActionKind, DiffHunkSide, MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco };

package/dist/index.cjs

@@ -1,4 +1,4 @@
-const require_preloadMonacoWorkers_shared = require('./preloadMonacoWorkers.shared-gUKedCzF.cjs');
+const require_preloadMonacoWorkers_shared = require('./preloadMonacoWorkers.shared-DMvZ1HUs.cjs');
 
 //#region src/ensureMonacoWorkers.ts
 function ensureMonacoWorkers() {

package/dist/index.d.cts

@@ -1,9 +1,9 @@
-import { MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco } from "./index.base-D0jPJkA_.cjs";
+import { DiffHunkActionContext, DiffHunkActionKind, DiffHunkSide, MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco } from "./index.base-9QTN8hPV.cjs";
 
-//#region src/preloadMonacoWorkers.d.ts
-declare function preloadMonacoWorkers(): Promise<void>;
-//#endregion
 //#region src/ensureMonacoWorkers.d.ts
 declare function ensureMonacoWorkers(): void;
 //#endregion
-export { MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, ensureMonacoWorkers, getOrCreateHighlighter, preloadMonacoWorkers, registerMonacoThemes, useMonaco };
+//#region src/preloadMonacoWorkers.d.ts
+declare function preloadMonacoWorkers(): Promise<void>;
+//#endregion
+export { DiffHunkActionContext, DiffHunkActionKind, DiffHunkSide, MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, ensureMonacoWorkers, getOrCreateHighlighter, preloadMonacoWorkers, registerMonacoThemes, useMonaco };

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco } from "./index.base-BaAqAXUs.js";
+import { DiffHunkActionContext, DiffHunkActionKind, DiffHunkSide, MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco } from "./index.base-D0lzInae.js";
 
-//#region src/preloadMonacoWorkers.d.ts
-declare function preloadMonacoWorkers(): Promise<void>;
-//#endregion
 //#region src/ensureMonacoWorkers.d.ts
 declare function ensureMonacoWorkers(): void;
 //#endregion
-export { MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, ensureMonacoWorkers, getOrCreateHighlighter, preloadMonacoWorkers, registerMonacoThemes, useMonaco };
+//#region src/preloadMonacoWorkers.d.ts
+declare function preloadMonacoWorkers(): Promise<void>;
+//#endregion
+export { DiffHunkActionContext, DiffHunkActionKind, DiffHunkSide, MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, ensureMonacoWorkers, getOrCreateHighlighter, preloadMonacoWorkers, registerMonacoThemes, useMonaco };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { RevealStrategy, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, editorWorkerPath, getOrCreateHighlighter, registerMonacoThemes, uniqueWorkerPaths, useMonaco, workerPathByLabel } from "./preloadMonacoWorkers.shared-C62vOlc9.js";
+import { RevealStrategy, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, editorWorkerPath, getOrCreateHighlighter, registerMonacoThemes, uniqueWorkerPaths, useMonaco, workerPathByLabel } from "./preloadMonacoWorkers.shared-DQ17-Bwz.js";
 
 //#region src/ensureMonacoWorkers.ts
 function ensureMonacoWorkers() {

package/dist/index.legacy.cjs

@@ -1,4 +1,22 @@
-const require_preloadMonacoWorkers_shared = require('./preloadMonacoWorkers.shared-gUKedCzF.cjs');
+const require_preloadMonacoWorkers_shared = require('./preloadMonacoWorkers.shared-DMvZ1HUs.cjs');
+const monaco_editor_esm_vs_basic_languages_cpp_cpp = require_preloadMonacoWorkers_shared.__toESM(require("monaco-editor/esm/vs/basic-languages/cpp/cpp"));
+const monaco_editor_esm_vs_basic_languages_javascript_javascript = require_preloadMonacoWorkers_shared.__toESM(require("monaco-editor/esm/vs/basic-languages/javascript/javascript"));
+const monaco_editor_esm_vs_basic_languages_powershell_powershell = require_preloadMonacoWorkers_shared.__toESM(require("monaco-editor/esm/vs/basic-languages/powershell/powershell"));
+const monaco_editor_esm_vs_basic_languages_python_python = require_preloadMonacoWorkers_shared.__toESM(require("monaco-editor/esm/vs/basic-languages/python/python"));
+const monaco_editor_esm_vs_basic_languages_shell_shell = require_preloadMonacoWorkers_shared.__toESM(require("monaco-editor/esm/vs/basic-languages/shell/shell"));
+const monaco_editor_esm_vs_basic_languages_typescript_typescript = require_preloadMonacoWorkers_shared.__toESM(require("monaco-editor/esm/vs/basic-languages/typescript/typescript"));
+require("monaco-editor/esm/vs/editor/contrib/documentSymbols/browser/outlineModel");
+require("monaco-editor/esm/vs/editor/contrib/suggest/browser/suggestMemory");
+require("monaco-editor/esm/vs/basic-languages/javascript/javascript.contribution");
+require("monaco-editor/esm/vs/basic-languages/typescript/typescript.contribution");
+require("monaco-editor/esm/vs/basic-languages/python/python.contribution");
+require("monaco-editor/esm/vs/basic-languages/cpp/cpp.contribution");
+require("monaco-editor/esm/vs/basic-languages/shell/shell.contribution");
+require("monaco-editor/esm/vs/basic-languages/powershell/powershell.contribution");
+require("monaco-editor/esm/vs/language/json/monaco.contribution");
+require("monaco-editor/esm/vs/language/typescript/monaco.contribution");
+require("monaco-editor/esm/vs/language/html/monaco.contribution");
+require("monaco-editor/esm/vs/language/css/monaco.contribution");
 
 //#region src/ensureMonacoWorkers.legacy.ts
 function normalizeBaseUrl(baseUrl) {
@@ -18,7 +36,7 @@ function detectMonacoBaseUrlFromScripts() {
 	for (const script of scripts) {
 		const src = script.getAttribute("src") || "";
 		if (!src) continue;
-		const loaderMatch = src.match(/^(.*)\/vs\/loader\.js(?:\\?.*)?$/);
+		const loaderMatch = src.match(/^(.*)\/vs\/loader\.js.*$/);
 		if (loaderMatch) return normalizeBaseUrl(loaderMatch[1]);
 		const vsIndex = src.indexOf("/vs/");
 		if (vsIndex > 0) return normalizeBaseUrl(src.slice(0, vsIndex));
@@ -85,7 +103,7 @@ function ensureMonacoWorkersLegacy(options) {
 		if (!baseUrl) return;
 		const workerUrl = makeWorkerUrl(baseUrl);
 		if (!workerUrl) return;
-		self.MonacoEnvironment = { getWorkerUrl() {
+		globalThis.MonacoEnvironment = { getWorkerUrl() {
 			return workerUrl;
 		} };
 	} catch {}
@@ -118,6 +136,127 @@ async function preloadMonacoWorkers() {
 
 //#endregion
 //#region src/index.legacy.ts
+const LEGACY_ONIG_INIT_KEY = "__streamMonacoLegacyOnigurumaInit__";
+const LEGACY_ENGINE_KEY = "__streamMonacoLegacyShikiEngine__";
+const LEGACY_ERROR_FILTER_KEY = "__streamMonacoLegacyMonacoErrorFilterInstalled__";
+const LEGACY_FLAG_KEY = "__streamMonacoLegacy__";
+const LEGACY_MONACO_LANGS_INIT_KEY = "__streamMonacoLegacyMonacoLangsInit__";
+const LEGACY_TOKENS_PROVIDER_GUARD_KEY = "__streamMonacoLegacyTokensProviderGuardInstalled__";
+function ensureLegacyOnigurumaInit() {
+	if (typeof globalThis === "undefined") return;
+	const g = globalThis;
+	if (g[LEGACY_ONIG_INIT_KEY]) return;
+	const init = (async () => {
+		try {
+			const shiki = await import("shiki");
+			if (typeof shiki.createJavaScriptRegexEngine === "function") return shiki.createJavaScriptRegexEngine();
+			return null;
+		} catch {
+			return null;
+		}
+	})();
+	g[LEGACY_ONIG_INIT_KEY] = init.then(() => true, () => false);
+	g[LEGACY_ENGINE_KEY] = init;
+}
+function ensureLegacyMonacoLanguageContributions() {
+	if (typeof globalThis === "undefined") return;
+	const g = globalThis;
+	if (g[LEGACY_MONACO_LANGS_INIT_KEY]) return;
+	const init = Promise.resolve().then(() => {
+		try {
+			const langs = require_preloadMonacoWorkers_shared.monaco_shim_exports.languages;
+			if (typeof (langs === null || langs === void 0 ? void 0 : langs.setMonarchTokensProvider) === "function") {
+				var _langs$setLanguageCon, _langs$setLanguageCon2, _langs$setLanguageCon3, _langs$setLanguageCon4, _langs$setLanguageCon5, _langs$setLanguageCon6;
+				langs.setMonarchTokensProvider("javascript", monaco_editor_esm_vs_basic_languages_javascript_javascript.language);
+				(_langs$setLanguageCon = langs.setLanguageConfiguration) === null || _langs$setLanguageCon === void 0 || _langs$setLanguageCon.call(langs, "javascript", monaco_editor_esm_vs_basic_languages_javascript_javascript.conf);
+				langs.setMonarchTokensProvider("typescript", monaco_editor_esm_vs_basic_languages_typescript_typescript.language);
+				(_langs$setLanguageCon2 = langs.setLanguageConfiguration) === null || _langs$setLanguageCon2 === void 0 || _langs$setLanguageCon2.call(langs, "typescript", monaco_editor_esm_vs_basic_languages_typescript_typescript.conf);
+				langs.setMonarchTokensProvider("python", monaco_editor_esm_vs_basic_languages_python_python.language);
+				(_langs$setLanguageCon3 = langs.setLanguageConfiguration) === null || _langs$setLanguageCon3 === void 0 || _langs$setLanguageCon3.call(langs, "python", monaco_editor_esm_vs_basic_languages_python_python.conf);
+				langs.setMonarchTokensProvider("cpp", monaco_editor_esm_vs_basic_languages_cpp_cpp.language);
+				(_langs$setLanguageCon4 = langs.setLanguageConfiguration) === null || _langs$setLanguageCon4 === void 0 || _langs$setLanguageCon4.call(langs, "cpp", monaco_editor_esm_vs_basic_languages_cpp_cpp.conf);
+				langs.setMonarchTokensProvider("shell", monaco_editor_esm_vs_basic_languages_shell_shell.language);
+				(_langs$setLanguageCon5 = langs.setLanguageConfiguration) === null || _langs$setLanguageCon5 === void 0 || _langs$setLanguageCon5.call(langs, "shell", monaco_editor_esm_vs_basic_languages_shell_shell.conf);
+				langs.setMonarchTokensProvider("powershell", monaco_editor_esm_vs_basic_languages_powershell_powershell.language);
+				(_langs$setLanguageCon6 = langs.setLanguageConfiguration) === null || _langs$setLanguageCon6 === void 0 || _langs$setLanguageCon6.call(langs, "powershell", monaco_editor_esm_vs_basic_languages_powershell_powershell.conf);
+			}
+		} catch {}
+		try {
+			for (const model of require_preloadMonacoWorkers_shared.monaco_shim_exports.editor.getModels()) {
+				const current = model.getLanguageId();
+				const next = require_preloadMonacoWorkers_shared.processedLanguage(current) || current;
+				if (next !== current) require_preloadMonacoWorkers_shared.monaco_shim_exports.editor.setModelLanguage(model, next);
+				else require_preloadMonacoWorkers_shared.monaco_shim_exports.editor.setModelLanguage(model, current);
+			}
+		} catch {}
+	});
+	g[LEGACY_MONACO_LANGS_INIT_KEY] = init;
+}
+function ensureLegacyTokensProviderGuard() {
+	if (typeof globalThis === "undefined") return;
+	const g = globalThis;
+	if (g[LEGACY_TOKENS_PROVIDER_GUARD_KEY]) return;
+	g[LEGACY_TOKENS_PROVIDER_GUARD_KEY] = true;
+	try {
+		const langs = require_preloadMonacoWorkers_shared.monaco_shim_exports.languages;
+		const setTokensProvider = typeof (langs === null || langs === void 0 ? void 0 : langs.setTokensProvider) === "function" ? langs.setTokensProvider.bind(langs) : null;
+		if (!setTokensProvider) return;
+		langs.setTokensProvider = (lang, provider) => {
+			if (provider && typeof provider.tokenize === "function") {
+				const originalTokenize = provider.tokenize.bind(provider);
+				const getInitialState = typeof provider.getInitialState === "function" ? provider.getInitialState.bind(provider) : null;
+				const wrappedProvider = {
+					...provider,
+					tokenize(line, state) {
+						try {
+							return originalTokenize(line, state);
+						} catch {
+							return {
+								endState: state,
+								tokens: [{
+									startIndex: 0,
+									scopes: ""
+								}]
+							};
+						}
+					}
+				};
+				try {
+					const st = getInitialState ? getInitialState() : null;
+					wrappedProvider.tokenize("const a = 1", st);
+				} catch {
+					return { dispose() {} };
+				}
+				return setTokensProvider(lang, wrappedProvider);
+			}
+			return setTokensProvider(lang, provider);
+		};
+	} catch {}
+}
+function ensureLegacyMonacoErrorFilter() {
+	if (typeof globalThis === "undefined") return;
+	const g = globalThis;
+	if (g[LEGACY_ERROR_FILTER_KEY]) return;
+	g[LEGACY_ERROR_FILTER_KEY] = true;
+	(async () => {
+		try {
+			const mod = await import("monaco-editor/esm/vs/base/common/errors.js");
+			const handler = mod === null || mod === void 0 ? void 0 : mod.errorHandler;
+			if (!handler || typeof handler.unexpectedErrorHandler !== "function") return;
+			const prev = handler.unexpectedErrorHandler.bind(handler);
+			handler.unexpectedErrorHandler = (err) => {
+				const msg = (err === null || err === void 0 ? void 0 : err.message) ? String(err.message) : String(err);
+				if (msg.includes("compileAG") || msg.includes("Cannot read properties of null (reading")) return;
+				return prev(err);
+			};
+		} catch {}
+	})();
+}
+ensureLegacyOnigurumaInit();
+globalThis[LEGACY_FLAG_KEY] = true;
+ensureLegacyMonacoLanguageContributions();
+ensureLegacyTokensProviderGuard();
+ensureLegacyMonacoErrorFilter();
 ensureMonacoWorkersLegacy();
 
 //#endregion

package/dist/index.legacy.d.cts

@@ -1,11 +1,11 @@
-import { MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco } from "./index.base-D0jPJkA_.cjs";
+import { DiffHunkActionContext, DiffHunkActionKind, DiffHunkSide, MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco } from "./index.base-9QTN8hPV.cjs";
 
-//#region src/preloadMonacoWorkers.legacy.d.ts
-declare function preloadMonacoWorkers(): Promise<void>;
-//#endregion
 //#region src/ensureMonacoWorkers.legacy.d.ts
 declare function ensureMonacoWorkersLegacy(options?: {
   baseUrl?: string;
 }): void;
 //#endregion
-export { MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, ensureMonacoWorkersLegacy, getOrCreateHighlighter, preloadMonacoWorkers, registerMonacoThemes, useMonaco };
+//#region src/preloadMonacoWorkers.legacy.d.ts
+declare function preloadMonacoWorkers(): Promise<void>;
+//#endregion
+export { DiffHunkActionContext, DiffHunkActionKind, DiffHunkSide, MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, ensureMonacoWorkersLegacy, getOrCreateHighlighter, preloadMonacoWorkers, registerMonacoThemes, useMonaco };

package/dist/index.legacy.d.ts

@@ -1,11 +1,21 @@
-import { MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco } from "./index.base-BaAqAXUs.js";
+import { DiffHunkActionContext, DiffHunkActionKind, DiffHunkSide, MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, getOrCreateHighlighter, registerMonacoThemes, useMonaco } from "./index.base-D0lzInae.js";
+import "monaco-editor/esm/vs/basic-languages/javascript/javascript.contribution";
+import "monaco-editor/esm/vs/basic-languages/typescript/typescript.contribution";
+import "monaco-editor/esm/vs/basic-languages/python/python.contribution";
+import "monaco-editor/esm/vs/basic-languages/cpp/cpp.contribution";
+import "monaco-editor/esm/vs/basic-languages/shell/shell.contribution";
+import "monaco-editor/esm/vs/basic-languages/powershell/powershell.contribution";
+import "monaco-editor/esm/vs/language/json/monaco.contribution";
+import "monaco-editor/esm/vs/language/typescript/monaco.contribution";
+import "monaco-editor/esm/vs/language/html/monaco.contribution";
+import "monaco-editor/esm/vs/language/css/monaco.contribution";
 
-//#region src/preloadMonacoWorkers.legacy.d.ts
-declare function preloadMonacoWorkers(): Promise<void>;
-//#endregion
 //#region src/ensureMonacoWorkers.legacy.d.ts
 declare function ensureMonacoWorkersLegacy(options?: {
   baseUrl?: string;
 }): void;
 //#endregion
-export { MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, ensureMonacoWorkersLegacy, getOrCreateHighlighter, preloadMonacoWorkers, registerMonacoThemes, useMonaco };
+//#region src/preloadMonacoWorkers.legacy.d.ts
+declare function preloadMonacoWorkers(): Promise<void>;
+//#endregion
+export { DiffHunkActionContext, DiffHunkActionKind, DiffHunkSide, MonacoDiffEditorInstance, MonacoEditorInstance, MonacoLanguage, MonacoOptions, MonacoTheme, RevealStrategy, ShikiHighlighter, clearHighlighterCache, defaultRevealDebounceMs, detectLanguage, ensureMonacoWorkersLegacy, getOrCreateHighlighter, preloadMonacoWorkers, registerMonacoThemes, useMonaco };