@ws-ui/code-editor 0.2.24 → 0.2.26

package/dist/studio/assets/html.worker.bundle.js

@@ -339,6 +339,7 @@
   };
 
   // node_modules/vscode/vscode/src/vs/base/common/collections.js
+  var _a;
   function groupBy(data, groupFn) {
     const result = /* @__PURE__ */ Object.create(null);
     for (const element of data) {
@@ -351,9 +352,58 @@
     }
     return result;
   }
+  var SetWithKey = class {
+    static {
+      _a = Symbol.toStringTag;
+    }
+    constructor(values, toKey) {
+      this.toKey = toKey;
+      this._map = /* @__PURE__ */ new Map();
+      this[_a] = "SetWithKey";
+      for (const value of values) {
+        this.add(value);
+      }
+    }
+    get size() {
+      return this._map.size;
+    }
+    add(value) {
+      const key = this.toKey(value);
+      this._map.set(key, value);
+      return this;
+    }
+    delete(value) {
+      return this._map.delete(this.toKey(value));
+    }
+    has(value) {
+      return this._map.has(this.toKey(value));
+    }
+    *entries() {
+      for (const entry of this._map.values()) {
+        yield [entry, entry];
+      }
+    }
+    keys() {
+      return this.values();
+    }
+    *values() {
+      for (const entry of this._map.values()) {
+        yield entry;
+      }
+    }
+    clear() {
+      this._map.clear();
+    }
+    forEach(callbackfn, thisArg) {
+      this._map.forEach((entry) => callbackfn.call(thisArg, entry, entry, this));
+    }
+    [Symbol.iterator]() {
+      return this.values();
+    }
+  };
 
   // node_modules/vscode/vscode/src/vs/base/common/map.js
-  var _a;
+  var _a2;
   var _b;
   var _c;
   var ResourceMapEntry = class {
@@ -370,7 +420,7 @@
       this.defaultToKey = (resource) => resource.toString();
     }
     constructor(arg, toKey) {
-      this[_a] = "ResourceMap";
+      this[_a2] = "ResourceMap";
       if (arg instanceof _ResourceMap) {
         this.map = new Map(arg.map);
         this.toKey = toKey ?? _ResourceMap.defaultToKey;
@@ -427,7 +477,7 @@
         yield [entry.uri, entry.value];
       }
     }
-    *[(_a = Symbol.toStringTag, Symbol.iterator)]() {
+    *[(_a2 = Symbol.toStringTag, Symbol.iterator)]() {
       for (const [, entry] of this.map) {
         yield [entry.uri, entry.value];
       }
@@ -949,8 +999,9 @@
     }
     Iterable2.first = first;
     function some(iterable, predicate) {
+      let i = 0;
       for (const element of iterable) {
-        if (predicate(element)) {
+        if (predicate(element, i++)) {
           return true;
         }
       }
@@ -981,6 +1032,13 @@
       }
     }
     Iterable2.map = map;
+    function* flatMap(iterable, fn) {
+      let index = 0;
+      for (const element of iterable) {
+        yield* fn(element, index++);
+      }
+    }
+    Iterable2.flatMap = flatMap;
     function* concat(...iterables) {
       for (const iterable of iterables) {
         yield* iterable;
@@ -1814,6 +1872,10 @@ ${stackTraceFormattedLines.join("\n")}
       return result.event;
     }
     Event2.fromPromise = fromPromise;
+    function forward(from, to) {
+      return from((e) => to.fire(e));
+    }
+    Event2.forward = forward;
     function runAndSubscribe(event, handler, initial) {
       handler(initial);
       return event((e) => handler(e));
@@ -1932,8 +1994,11 @@ ${stackTraceFormattedLines.join("\n")}
     }
   };
   var _globalLeakWarningThreshold = -1;
-  var LeakageMonitor = class {
-    constructor(_errorHandler, threshold, name = Math.random().toString(18).slice(2, 5)) {
+  var LeakageMonitor = class _LeakageMonitor {
+    static {
+      this._idPool = 1;
+    }
+    constructor(_errorHandler, threshold, name = (_LeakageMonitor._idPool++).toString(16).padStart(3, "0")) {
       this._errorHandler = _errorHandler;
       this.threshold = threshold;
       this.name = name;
@@ -2226,43 +2291,6 @@ ${stackTraceFormattedLines.join("\n")}
     return result;
   }
 
-  // node_modules/vscode/vscode/src/vs/nls.js
-  var isPseudo = typeof document !== "undefined" && document.location && document.location.hash.indexOf("pseudo=true") >= 0;
-  function _format(message, args) {
-    let result;
-    if (args.length === 0) {
-      result = message;
-    } else {
-      result = message.replace(/\{(\d+)\}/g, (match, rest) => {
-        const index = rest[0];
-        const arg = args[index];
-        let result2 = match;
-        if (typeof arg === "string") {
-          result2 = arg;
-        } else if (typeof arg === "number" || typeof arg === "boolean" || arg === void 0 || arg === null) {
-          result2 = String(arg);
-        }
-        return result2;
-      });
-    }
-    if (isPseudo) {
-      result = "\uFF3B" + result.replace(/[aouei]/g, "$&$&") + "\uFF3D";
-    }
-    return result;
-  }
-  var initialized = false;
-  var locale = void 0;
-  var translations = {};
-  function localizeWithPath(path, data, defaultMessage, ...args) {
-    initialized = true;
-    const key = typeof data === "object" ? data.key : data;
-    const message = (translations[path] ?? {})[key] ?? defaultMessage;
-    return _format(message, args);
-  }
-  function getConfiguredDefaultLocale(_) {
-    return locale;
-  }
-
   // node_modules/vscode/vscode/src/vs/base/common/platform.js
   var LANGUAGE_DEFAULT = "en";
   var _isWindows = false;
@@ -2277,6 +2305,7 @@ ${stackTraceFormattedLines.join("\n")}
   var _locale = void 0;
   var _language = LANGUAGE_DEFAULT;
   var _platformLocale = LANGUAGE_DEFAULT;
+  var _translationsConfigFile = void 0;
   var _userAgent = void 0;
   var $globalThis = globalThis;
   var nodeProcess = void 0;
@@ -2299,10 +2328,10 @@ ${stackTraceFormattedLines.join("\n")}
     if (rawNlsConfig) {
       try {
         const nlsConfig = JSON.parse(rawNlsConfig);
-        const resolved = nlsConfig.availableLanguages["*"];
-        _locale = nlsConfig.locale;
+        _locale = nlsConfig.userLocale;
         _platformLocale = nlsConfig.osLocale;
-        _language = resolved ? resolved : LANGUAGE_DEFAULT;
+        _language = nlsConfig.resolvedLanguage || LANGUAGE_DEFAULT;
+        _translationsConfigFile = nlsConfig.languagePack?.translationsConfigFile;
       } catch (e) {
       }
     }
@@ -2315,10 +2344,9 @@ ${stackTraceFormattedLines.join("\n")}
     _isLinux = _userAgent.indexOf("Linux") >= 0;
     _isMobile = _userAgent?.indexOf("Mobi") >= 0;
     _isWeb = true;
-    const configuredLocale = getConfiguredDefaultLocale();
-    _locale = configuredLocale || LANGUAGE_DEFAULT;
-    _language = _locale;
-    _platformLocale = navigator.language;
+    _language = globalThis._VSCODE_NLS_LANGUAGE || LANGUAGE_DEFAULT;
+    _locale = navigator.language.toLowerCase();
+    _platformLocale = _locale;
   } else {
     console.error("Unable to resolve platform.");
   }
@@ -3042,8 +3070,8 @@ ${stackTraceFormattedLines.join("\n")}
           filteredLocales = ["_default"];
         }
         let languageSpecificMap = void 0;
-        for (const locale2 of filteredLocales) {
-          const map2 = arrayToMap(data[locale2]);
+        for (const locale of filteredLocales) {
+          const map2 = arrayToMap(data[locale]);
           languageSpecificMap = intersectMaps(languageSpecificMap, map2);
         }
         const commonMap = arrayToMap(data["_common"]);
@@ -4333,7 +4361,7 @@ ${stackTraceFormattedLines.join("\n")}
         return sandboxProcess.cwd();
       }
     };
-  } else if (typeof process !== "undefined") {
+  } else if (typeof process !== "undefined" && typeof process?.versions?.node === "string") {
     safeProcess = {
       get platform() {
         return process.platform;
@@ -4476,10 +4504,13 @@ ${stackTraceFormattedLines.join("\n")}
     }
     return res;
   }
-  function _format2(sep2, pathObject) {
+  function formatExt(ext) {
+    return ext ? `${ext[0] === "." ? "" : "."}${ext}` : "";
+  }
+  function _format(sep2, pathObject) {
     validateObject(pathObject, "pathObject");
     const dir = pathObject.dir || pathObject.root;
-    const base = pathObject.base || `${pathObject.name || ""}${pathObject.ext || ""}`;
+    const base = pathObject.base || `${pathObject.name || ""}${formatExt(pathObject.ext)}`;
     if (!dir) {
       return base;
     }
@@ -4494,7 +4525,7 @@ ${stackTraceFormattedLines.join("\n")}
         let path;
         if (i >= 0) {
           path = pathSegments[i];
-          validateString(path, "path");
+          validateString(path, `paths[${i}]`);
           if (path.length === 0) {
             continue;
           }
@@ -4862,9 +4893,9 @@ ${stackTraceFormattedLines.join("\n")}
       }
       return path.slice(0, end);
     },
-    basename(path, ext) {
-      if (ext !== void 0) {
-        validateString(ext, "ext");
+    basename(path, suffix) {
+      if (suffix !== void 0) {
+        validateString(suffix, "suffix");
       }
       validateString(path, "path");
       let start = 0;
@@ -4874,11 +4905,11 @@ ${stackTraceFormattedLines.join("\n")}
       if (path.length >= 2 && isWindowsDeviceRoot(path.charCodeAt(0)) && path.charCodeAt(1) === CHAR_COLON) {
         start = 2;
       }
-      if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
-        if (ext === path) {
+      if (suffix !== void 0 && suffix.length > 0 && suffix.length <= path.length) {
+        if (suffix === path) {
           return "";
         }
-        let extIdx = ext.length - 1;
+        let extIdx = suffix.length - 1;
         let firstNonSlashEnd = -1;
         for (i = path.length - 1; i >= start; --i) {
           const code = path.charCodeAt(i);
@@ -4893,7 +4924,7 @@ ${stackTraceFormattedLines.join("\n")}
               firstNonSlashEnd = i + 1;
             }
             if (extIdx >= 0) {
-              if (code === ext.charCodeAt(extIdx)) {
+              if (code === suffix.charCodeAt(extIdx)) {
                 if (--extIdx === -1) {
                   end = i;
                 }
@@ -4966,7 +4997,7 @@ ${stackTraceFormattedLines.join("\n")}
       }
       return path.slice(startDot, end);
     },
-    format: _format2.bind(null, "\\"),
+    format: _format.bind(null, "\\"),
     parse(path) {
       validateString(path, "path");
       const ret = { root: "", dir: "", base: "", ext: "", name: "" };
@@ -5093,7 +5124,7 @@ ${stackTraceFormattedLines.join("\n")}
       let resolvedAbsolute = false;
       for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
         const path = i >= 0 ? pathSegments[i] : posixCwd();
-        validateString(path, "path");
+        validateString(path, `paths[${i}]`);
         if (path.length === 0) {
           continue;
         }
@@ -5230,20 +5261,20 @@ ${stackTraceFormattedLines.join("\n")}
       }
       return path.slice(0, end);
     },
-    basename(path, ext) {
-      if (ext !== void 0) {
-        validateString(ext, "ext");
+    basename(path, suffix) {
+      if (suffix !== void 0) {
+        validateString(suffix, "ext");
       }
       validateString(path, "path");
       let start = 0;
       let end = -1;
       let matchedSlash = true;
       let i;
-      if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
-        if (ext === path) {
+      if (suffix !== void 0 && suffix.length > 0 && suffix.length <= path.length) {
+        if (suffix === path) {
           return "";
         }
-        let extIdx = ext.length - 1;
+        let extIdx = suffix.length - 1;
         let firstNonSlashEnd = -1;
         for (i = path.length - 1; i >= 0; --i) {
           const code = path.charCodeAt(i);
@@ -5258,7 +5289,7 @@ ${stackTraceFormattedLines.join("\n")}
               firstNonSlashEnd = i + 1;
             }
             if (extIdx >= 0) {
-              if (code === ext.charCodeAt(extIdx)) {
+              if (code === suffix.charCodeAt(extIdx)) {
                 if (--extIdx === -1) {
                   end = i;
                 }
@@ -5327,7 +5358,7 @@ ${stackTraceFormattedLines.join("\n")}
       }
       return path.slice(startDot, end);
     },
-    format: _format2.bind(null, "/"),
+    format: _format.bind(null, "/"),
     parse(path) {
       validateString(path, "path");
       const ret = { root: "", dir: "", base: "", ext: "", name: "" };
@@ -5595,6 +5626,9 @@ ${stackTraceFormattedLines.join("\n")}
         return result;
       }
     }
+    [Symbol.for("debug.description")]() {
+      return `URI(${this.toString()})`;
+    }
   };
   var _pathSepMarker = isWindows ? 1 : void 0;
   var Uri = class extends URI {
@@ -8471,8 +8505,50 @@ ${stackTraceFormattedLines.join("\n")}
     }
   };
 
+  // node_modules/vscode/vscode/src/vs/nls.js
+  var isPseudo = globalThis._VSCODE_NLS_LANGUAGE === "pseudo" || typeof document !== "undefined" && document.location && document.location.hash.indexOf("pseudo=true") >= 0;
+  function _format2(message, args) {
+    let result;
+    if (args.length === 0) {
+      result = message;
+    } else {
+      result = message.replace(/\{(\d+)\}/g, (match, rest) => {
+        const index = rest[0];
+        const arg = args[index];
+        let result2 = match;
+        if (typeof arg === "string") {
+          result2 = arg;
+        } else if (typeof arg === "number" || typeof arg === "boolean" || arg === void 0 || arg === null) {
+          result2 = String(arg);
+        }
+        return result2;
+      });
+    }
+    if (isPseudo) {
+      result = "\uFF3B" + result.replace(/[aouei]/g, "$&$&") + "\uFF3D";
+    }
+    return result;
+  }
+  var initialized = false;
+  function localize(data, message, ...args) {
+    if (typeof data === "number") {
+      return _format2(lookupMessage(data, message), args);
+    }
+    return _format2(message, args);
+  }
+  function lookupMessage(index, fallback) {
+    initialized = true;
+    const message = globalThis._VSCODE_NLS_MESSAGES?.[index];
+    if (typeof message !== "string") {
+      if (typeof fallback === "string") {
+        return fallback;
+      }
+      throw new Error(`!!! NLS MISSING: ${index} !!!`);
+    }
+    return message;
+  }
+
   // node_modules/vscode/vscode/src/vs/editor/common/languages.js
-  var _moduleId = "vs/editor/common/languages";
   var Token = class {
     constructor(offset, type, language2) {
       this.offset = offset;
@@ -8680,32 +8756,32 @@ ${stackTraceFormattedLines.join("\n")}
     SymbolKind4[SymbolKind4["TypeParameter"] = 25] = "TypeParameter";
   })(SymbolKind || (SymbolKind = {}));
   var symbolKindNames = {
-    [SymbolKind.Array]: localizeWithPath(_moduleId, 0, "array"),
-    [SymbolKind.Boolean]: localizeWithPath(_moduleId, 1, "boolean"),
-    [SymbolKind.Class]: localizeWithPath(_moduleId, 2, "class"),
-    [SymbolKind.Constant]: localizeWithPath(_moduleId, 3, "constant"),
-    [SymbolKind.Constructor]: localizeWithPath(_moduleId, 4, "constructor"),
-    [SymbolKind.Enum]: localizeWithPath(_moduleId, 5, "enumeration"),
-    [SymbolKind.EnumMember]: localizeWithPath(_moduleId, 6, "enumeration member"),
-    [SymbolKind.Event]: localizeWithPath(_moduleId, 7, "event"),
-    [SymbolKind.Field]: localizeWithPath(_moduleId, 8, "field"),
-    [SymbolKind.File]: localizeWithPath(_moduleId, 9, "file"),
-    [SymbolKind.Function]: localizeWithPath(_moduleId, 10, "function"),
-    [SymbolKind.Interface]: localizeWithPath(_moduleId, 11, "interface"),
-    [SymbolKind.Key]: localizeWithPath(_moduleId, 12, "key"),
-    [SymbolKind.Method]: localizeWithPath(_moduleId, 13, "method"),
-    [SymbolKind.Module]: localizeWithPath(_moduleId, 14, "module"),
-    [SymbolKind.Namespace]: localizeWithPath(_moduleId, 15, "namespace"),
-    [SymbolKind.Null]: localizeWithPath(_moduleId, 16, "null"),
-    [SymbolKind.Number]: localizeWithPath(_moduleId, 17, "number"),
-    [SymbolKind.Object]: localizeWithPath(_moduleId, 18, "object"),
-    [SymbolKind.Operator]: localizeWithPath(_moduleId, 19, "operator"),
-    [SymbolKind.Package]: localizeWithPath(_moduleId, 20, "package"),
-    [SymbolKind.Property]: localizeWithPath(_moduleId, 21, "property"),
-    [SymbolKind.String]: localizeWithPath(_moduleId, 22, "string"),
-    [SymbolKind.Struct]: localizeWithPath(_moduleId, 23, "struct"),
-    [SymbolKind.TypeParameter]: localizeWithPath(_moduleId, 24, "type parameter"),
-    [SymbolKind.Variable]: localizeWithPath(_moduleId, 25, "variable")
+    [SymbolKind.Array]: localize(1658, "array"),
+    [SymbolKind.Boolean]: localize(1659, "boolean"),
+    [SymbolKind.Class]: localize(1660, "class"),
+    [SymbolKind.Constant]: localize(1661, "constant"),
+    [SymbolKind.Constructor]: localize(1662, "constructor"),
+    [SymbolKind.Enum]: localize(1663, "enumeration"),
+    [SymbolKind.EnumMember]: localize(1664, "enumeration member"),
+    [SymbolKind.Event]: localize(1665, "event"),
+    [SymbolKind.Field]: localize(1666, "field"),
+    [SymbolKind.File]: localize(1667, "file"),
+    [SymbolKind.Function]: localize(1668, "function"),
+    [SymbolKind.Interface]: localize(1669, "interface"),
+    [SymbolKind.Key]: localize(1670, "key"),
+    [SymbolKind.Method]: localize(1671, "method"),
+    [SymbolKind.Module]: localize(1672, "module"),
+    [SymbolKind.Namespace]: localize(1673, "namespace"),
+    [SymbolKind.Null]: localize(1674, "null"),
+    [SymbolKind.Number]: localize(1675, "number"),
+    [SymbolKind.Object]: localize(1676, "object"),
+    [SymbolKind.Operator]: localize(1677, "operator"),
+    [SymbolKind.Package]: localize(1678, "package"),
+    [SymbolKind.Property]: localize(1679, "property"),
+    [SymbolKind.String]: localize(1680, "string"),
+    [SymbolKind.Struct]: localize(1681, "struct"),
+    [SymbolKind.TypeParameter]: localize(1682, "type parameter"),
+    [SymbolKind.Variable]: localize(1683, "variable")
   };
   var SymbolTag;
   (function(SymbolTag4) {
@@ -9017,68 +9093,69 @@ ${stackTraceFormattedLines.join("\n")}
     EditorOption2[EditorOption2["pasteAs"] = 85] = "pasteAs";
     EditorOption2[EditorOption2["parameterHints"] = 86] = "parameterHints";
     EditorOption2[EditorOption2["peekWidgetDefaultFocus"] = 87] = "peekWidgetDefaultFocus";
-    EditorOption2[EditorOption2["definitionLinkOpensInPeek"] = 88] = "definitionLinkOpensInPeek";
-    EditorOption2[EditorOption2["quickSuggestions"] = 89] = "quickSuggestions";
-    EditorOption2[EditorOption2["quickSuggestionsDelay"] = 90] = "quickSuggestionsDelay";
-    EditorOption2[EditorOption2["readOnly"] = 91] = "readOnly";
-    EditorOption2[EditorOption2["readOnlyMessage"] = 92] = "readOnlyMessage";
-    EditorOption2[EditorOption2["renameOnType"] = 93] = "renameOnType";
-    EditorOption2[EditorOption2["renderControlCharacters"] = 94] = "renderControlCharacters";
-    EditorOption2[EditorOption2["renderFinalNewline"] = 95] = "renderFinalNewline";
-    EditorOption2[EditorOption2["renderLineHighlight"] = 96] = "renderLineHighlight";
-    EditorOption2[EditorOption2["renderLineHighlightOnlyWhenFocus"] = 97] = "renderLineHighlightOnlyWhenFocus";
-    EditorOption2[EditorOption2["renderValidationDecorations"] = 98] = "renderValidationDecorations";
-    EditorOption2[EditorOption2["renderWhitespace"] = 99] = "renderWhitespace";
-    EditorOption2[EditorOption2["revealHorizontalRightPadding"] = 100] = "revealHorizontalRightPadding";
-    EditorOption2[EditorOption2["roundedSelection"] = 101] = "roundedSelection";
-    EditorOption2[EditorOption2["rulers"] = 102] = "rulers";
-    EditorOption2[EditorOption2["scrollbar"] = 103] = "scrollbar";
-    EditorOption2[EditorOption2["scrollBeyondLastColumn"] = 104] = "scrollBeyondLastColumn";
-    EditorOption2[EditorOption2["scrollBeyondLastLine"] = 105] = "scrollBeyondLastLine";
-    EditorOption2[EditorOption2["scrollPredominantAxis"] = 106] = "scrollPredominantAxis";
-    EditorOption2[EditorOption2["selectionClipboard"] = 107] = "selectionClipboard";
-    EditorOption2[EditorOption2["selectionHighlight"] = 108] = "selectionHighlight";
-    EditorOption2[EditorOption2["selectOnLineNumbers"] = 109] = "selectOnLineNumbers";
-    EditorOption2[EditorOption2["showFoldingControls"] = 110] = "showFoldingControls";
-    EditorOption2[EditorOption2["showUnused"] = 111] = "showUnused";
-    EditorOption2[EditorOption2["snippetSuggestions"] = 112] = "snippetSuggestions";
-    EditorOption2[EditorOption2["smartSelect"] = 113] = "smartSelect";
-    EditorOption2[EditorOption2["smoothScrolling"] = 114] = "smoothScrolling";
-    EditorOption2[EditorOption2["stickyScroll"] = 115] = "stickyScroll";
-    EditorOption2[EditorOption2["stickyTabStops"] = 116] = "stickyTabStops";
-    EditorOption2[EditorOption2["stopRenderingLineAfter"] = 117] = "stopRenderingLineAfter";
-    EditorOption2[EditorOption2["suggest"] = 118] = "suggest";
-    EditorOption2[EditorOption2["suggestFontSize"] = 119] = "suggestFontSize";
-    EditorOption2[EditorOption2["suggestLineHeight"] = 120] = "suggestLineHeight";
-    EditorOption2[EditorOption2["suggestOnTriggerCharacters"] = 121] = "suggestOnTriggerCharacters";
-    EditorOption2[EditorOption2["suggestSelection"] = 122] = "suggestSelection";
-    EditorOption2[EditorOption2["tabCompletion"] = 123] = "tabCompletion";
-    EditorOption2[EditorOption2["tabIndex"] = 124] = "tabIndex";
-    EditorOption2[EditorOption2["unicodeHighlighting"] = 125] = "unicodeHighlighting";
-    EditorOption2[EditorOption2["unusualLineTerminators"] = 126] = "unusualLineTerminators";
-    EditorOption2[EditorOption2["useShadowDOM"] = 127] = "useShadowDOM";
-    EditorOption2[EditorOption2["useTabStops"] = 128] = "useTabStops";
-    EditorOption2[EditorOption2["wordBreak"] = 129] = "wordBreak";
-    EditorOption2[EditorOption2["wordSegmenterLocales"] = 130] = "wordSegmenterLocales";
-    EditorOption2[EditorOption2["wordSeparators"] = 131] = "wordSeparators";
-    EditorOption2[EditorOption2["wordWrap"] = 132] = "wordWrap";
-    EditorOption2[EditorOption2["wordWrapBreakAfterCharacters"] = 133] = "wordWrapBreakAfterCharacters";
-    EditorOption2[EditorOption2["wordWrapBreakBeforeCharacters"] = 134] = "wordWrapBreakBeforeCharacters";
-    EditorOption2[EditorOption2["wordWrapColumn"] = 135] = "wordWrapColumn";
-    EditorOption2[EditorOption2["wordWrapOverride1"] = 136] = "wordWrapOverride1";
-    EditorOption2[EditorOption2["wordWrapOverride2"] = 137] = "wordWrapOverride2";
-    EditorOption2[EditorOption2["wrappingIndent"] = 138] = "wrappingIndent";
-    EditorOption2[EditorOption2["wrappingStrategy"] = 139] = "wrappingStrategy";
-    EditorOption2[EditorOption2["showDeprecated"] = 140] = "showDeprecated";
-    EditorOption2[EditorOption2["inlayHints"] = 141] = "inlayHints";
-    EditorOption2[EditorOption2["editorClassName"] = 142] = "editorClassName";
-    EditorOption2[EditorOption2["pixelRatio"] = 143] = "pixelRatio";
-    EditorOption2[EditorOption2["tabFocusMode"] = 144] = "tabFocusMode";
-    EditorOption2[EditorOption2["layoutInfo"] = 145] = "layoutInfo";
-    EditorOption2[EditorOption2["wrappingInfo"] = 146] = "wrappingInfo";
-    EditorOption2[EditorOption2["defaultColorDecorators"] = 147] = "defaultColorDecorators";
-    EditorOption2[EditorOption2["colorDecoratorsActivatedOn"] = 148] = "colorDecoratorsActivatedOn";
-    EditorOption2[EditorOption2["inlineCompletionsAccessibilityVerbose"] = 149] = "inlineCompletionsAccessibilityVerbose";
+    EditorOption2[EditorOption2["placeholder"] = 88] = "placeholder";
+    EditorOption2[EditorOption2["definitionLinkOpensInPeek"] = 89] = "definitionLinkOpensInPeek";
+    EditorOption2[EditorOption2["quickSuggestions"] = 90] = "quickSuggestions";
+    EditorOption2[EditorOption2["quickSuggestionsDelay"] = 91] = "quickSuggestionsDelay";
+    EditorOption2[EditorOption2["readOnly"] = 92] = "readOnly";
+    EditorOption2[EditorOption2["readOnlyMessage"] = 93] = "readOnlyMessage";
+    EditorOption2[EditorOption2["renameOnType"] = 94] = "renameOnType";
+    EditorOption2[EditorOption2["renderControlCharacters"] = 95] = "renderControlCharacters";
+    EditorOption2[EditorOption2["renderFinalNewline"] = 96] = "renderFinalNewline";
+    EditorOption2[EditorOption2["renderLineHighlight"] = 97] = "renderLineHighlight";
+    EditorOption2[EditorOption2["renderLineHighlightOnlyWhenFocus"] = 98] = "renderLineHighlightOnlyWhenFocus";
+    EditorOption2[EditorOption2["renderValidationDecorations"] = 99] = "renderValidationDecorations";
+    EditorOption2[EditorOption2["renderWhitespace"] = 100] = "renderWhitespace";
+    EditorOption2[EditorOption2["revealHorizontalRightPadding"] = 101] = "revealHorizontalRightPadding";
+    EditorOption2[EditorOption2["roundedSelection"] = 102] = "roundedSelection";
+    EditorOption2[EditorOption2["rulers"] = 103] = "rulers";
+    EditorOption2[EditorOption2["scrollbar"] = 104] = "scrollbar";
+    EditorOption2[EditorOption2["scrollBeyondLastColumn"] = 105] = "scrollBeyondLastColumn";
+    EditorOption2[EditorOption2["scrollBeyondLastLine"] = 106] = "scrollBeyondLastLine";
+    EditorOption2[EditorOption2["scrollPredominantAxis"] = 107] = "scrollPredominantAxis";
+    EditorOption2[EditorOption2["selectionClipboard"] = 108] = "selectionClipboard";
+    EditorOption2[EditorOption2["selectionHighlight"] = 109] = "selectionHighlight";
+    EditorOption2[EditorOption2["selectOnLineNumbers"] = 110] = "selectOnLineNumbers";
+    EditorOption2[EditorOption2["showFoldingControls"] = 111] = "showFoldingControls";
+    EditorOption2[EditorOption2["showUnused"] = 112] = "showUnused";
+    EditorOption2[EditorOption2["snippetSuggestions"] = 113] = "snippetSuggestions";
+    EditorOption2[EditorOption2["smartSelect"] = 114] = "smartSelect";
+    EditorOption2[EditorOption2["smoothScrolling"] = 115] = "smoothScrolling";
+    EditorOption2[EditorOption2["stickyScroll"] = 116] = "stickyScroll";
+    EditorOption2[EditorOption2["stickyTabStops"] = 117] = "stickyTabStops";
+    EditorOption2[EditorOption2["stopRenderingLineAfter"] = 118] = "stopRenderingLineAfter";
+    EditorOption2[EditorOption2["suggest"] = 119] = "suggest";
+    EditorOption2[EditorOption2["suggestFontSize"] = 120] = "suggestFontSize";
+    EditorOption2[EditorOption2["suggestLineHeight"] = 121] = "suggestLineHeight";
+    EditorOption2[EditorOption2["suggestOnTriggerCharacters"] = 122] = "suggestOnTriggerCharacters";
+    EditorOption2[EditorOption2["suggestSelection"] = 123] = "suggestSelection";
+    EditorOption2[EditorOption2["tabCompletion"] = 124] = "tabCompletion";
+    EditorOption2[EditorOption2["tabIndex"] = 125] = "tabIndex";
+    EditorOption2[EditorOption2["unicodeHighlighting"] = 126] = "unicodeHighlighting";
+    EditorOption2[EditorOption2["unusualLineTerminators"] = 127] = "unusualLineTerminators";
+    EditorOption2[EditorOption2["useShadowDOM"] = 128] = "useShadowDOM";
+    EditorOption2[EditorOption2["useTabStops"] = 129] = "useTabStops";
+    EditorOption2[EditorOption2["wordBreak"] = 130] = "wordBreak";
+    EditorOption2[EditorOption2["wordSegmenterLocales"] = 131] = "wordSegmenterLocales";
+    EditorOption2[EditorOption2["wordSeparators"] = 132] = "wordSeparators";
+    EditorOption2[EditorOption2["wordWrap"] = 133] = "wordWrap";
+    EditorOption2[EditorOption2["wordWrapBreakAfterCharacters"] = 134] = "wordWrapBreakAfterCharacters";
+    EditorOption2[EditorOption2["wordWrapBreakBeforeCharacters"] = 135] = "wordWrapBreakBeforeCharacters";
+    EditorOption2[EditorOption2["wordWrapColumn"] = 136] = "wordWrapColumn";
+    EditorOption2[EditorOption2["wordWrapOverride1"] = 137] = "wordWrapOverride1";
+    EditorOption2[EditorOption2["wordWrapOverride2"] = 138] = "wordWrapOverride2";
+    EditorOption2[EditorOption2["wrappingIndent"] = 139] = "wrappingIndent";
+    EditorOption2[EditorOption2["wrappingStrategy"] = 140] = "wrappingStrategy";
+    EditorOption2[EditorOption2["showDeprecated"] = 141] = "showDeprecated";
+    EditorOption2[EditorOption2["inlayHints"] = 142] = "inlayHints";
+    EditorOption2[EditorOption2["editorClassName"] = 143] = "editorClassName";
+    EditorOption2[EditorOption2["pixelRatio"] = 144] = "pixelRatio";
+    EditorOption2[EditorOption2["tabFocusMode"] = 145] = "tabFocusMode";
+    EditorOption2[EditorOption2["layoutInfo"] = 146] = "layoutInfo";
+    EditorOption2[EditorOption2["wrappingInfo"] = 147] = "wrappingInfo";
+    EditorOption2[EditorOption2["defaultColorDecorators"] = 148] = "defaultColorDecorators";
+    EditorOption2[EditorOption2["colorDecoratorsActivatedOn"] = 149] = "colorDecoratorsActivatedOn";
+    EditorOption2[EditorOption2["inlineCompletionsAccessibilityVerbose"] = 150] = "inlineCompletionsAccessibilityVerbose";
   })(EditorOption || (EditorOption = {}));
   var EndOfLinePreference;
   (function(EndOfLinePreference3) {
@@ -10478,7 +10555,35 @@ ${stackTraceFormattedLines.join("\n")}
         ));
       }
     }
+    toRangeMapping2(original, modified) {
+      if (isValidLineNumber(this.original.endLineNumberExclusive, original) && isValidLineNumber(this.modified.endLineNumberExclusive, modified)) {
+        return new RangeMapping(new Range(this.original.startLineNumber, 1, this.original.endLineNumberExclusive, 1), new Range(this.modified.startLineNumber, 1, this.modified.endLineNumberExclusive, 1));
+      }
+      if (!this.original.isEmpty && !this.modified.isEmpty) {
+        return new RangeMapping(Range.fromPositions(new Position(this.original.startLineNumber, 1), normalizePosition(new Position(this.original.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER), original)), Range.fromPositions(new Position(this.modified.startLineNumber, 1), normalizePosition(new Position(this.modified.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER), modified)));
+      }
+      if (this.original.startLineNumber > 1 && this.modified.startLineNumber > 1) {
+        return new RangeMapping(Range.fromPositions(normalizePosition(new Position(this.original.startLineNumber - 1, Number.MAX_SAFE_INTEGER), original), normalizePosition(new Position(this.original.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER), original)), Range.fromPositions(normalizePosition(new Position(this.modified.startLineNumber - 1, Number.MAX_SAFE_INTEGER), modified), normalizePosition(new Position(this.modified.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER), modified)));
+      }
+      throw new BugIndicatingError();
+    }
   };
+  function normalizePosition(position, content) {
+    if (position.lineNumber < 1) {
+      return new Position(1, 1);
+    }
+    if (position.lineNumber > content.length) {
+      return new Position(content.length, content[content.length - 1].length + 1);
+    }
+    const line = content[position.lineNumber - 1];
+    if (position.column > line.length + 1) {
+      return new Position(position.lineNumber, line.length + 1);
+    }
+    return position;
+  }
+  function isValidLineNumber(lineNumber, lines) {
+    return lineNumber >= 1 && lineNumber <= lines.length;
+  }
   var DetailedLineRangeMapping = class _DetailedLineRangeMapping extends LineRangeMapping {
     static fromRangeMappings(rangeMappings) {
       const originalRange = LineRange.join(rangeMappings.map((r) => LineRange.fromRangeInclusive(r.originalRange)));
@@ -10497,6 +10602,15 @@ ${stackTraceFormattedLines.join("\n")}
     }
   };
   var RangeMapping = class _RangeMapping {
+    static assertSorted(rangeMappings) {
+      for (let i = 1; i < rangeMappings.length; i++) {
+        const previous = rangeMappings[i - 1];
+        const current = rangeMappings[i];
+        if (!(previous.originalRange.getEndPosition().isBeforeOrEqual(current.originalRange.getStartPosition()) && previous.modifiedRange.getEndPosition().isBeforeOrEqual(current.modifiedRange.getStartPosition()))) {
+          throw new BugIndicatingError("Range mappings must be sorted");
+        }
+      }
+    }
     constructor(originalRange, modifiedRange) {
       this.originalRange = originalRange;
       this.modifiedRange = modifiedRange;
@@ -11022,6 +11136,17 @@ ${stackTraceFormattedLines.join("\n")}
     static fromOffsetPairs(start, endExclusive) {
       return new _SequenceDiff(new OffsetRange(start.offset1, endExclusive.offset1), new OffsetRange(start.offset2, endExclusive.offset2));
     }
+    static assertSorted(sequenceDiffs) {
+      let last = void 0;
+      for (const cur of sequenceDiffs) {
+        if (last) {
+          if (!(last.seq1Range.endExclusive <= cur.seq1Range.start && last.seq2Range.endExclusive <= cur.seq2Range.start)) {
+            throw new BugIndicatingError("Sequence diffs must be sorted");
+          }
+        }
+        last = cur;
+      }
+    }
     constructor(seq1Range, seq2Range) {
       this.seq1Range = seq1Range;
       this.seq2Range = seq2Range;
@@ -11395,41 +11520,39 @@ ${stackTraceFormattedLines.join("\n")}
 
   // node_modules/vscode/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.js
   var LinesSliceCharSequence = class {
-    constructor(lines, lineRange, considerWhitespaceChanges) {
+    constructor(lines, range, considerWhitespaceChanges) {
       this.lines = lines;
+      this.range = range;
       this.considerWhitespaceChanges = considerWhitespaceChanges;
       this.elements = [];
-      this.firstCharOffsetByLine = [];
-      this.additionalOffsetByLine = [];
-      let trimFirstLineFully = false;
-      if (lineRange.start > 0 && lineRange.endExclusive >= lines.length) {
-        lineRange = new OffsetRange(lineRange.start - 1, lineRange.endExclusive);
-        trimFirstLineFully = true;
-      }
-      this.lineRange = lineRange;
-      this.firstCharOffsetByLine[0] = 0;
-      for (let i = this.lineRange.start; i < this.lineRange.endExclusive; i++) {
-        let line = lines[i];
-        let offset = 0;
-        if (trimFirstLineFully) {
-          offset = line.length;
-          line = "";
-          trimFirstLineFully = false;
-        } else if (!considerWhitespaceChanges) {
+      this.firstElementOffsetByLineIdx = [];
+      this.lineStartOffsets = [];
+      this.trimmedWsLengthsByLineIdx = [];
+      this.firstElementOffsetByLineIdx.push(0);
+      for (let lineNumber = this.range.startLineNumber; lineNumber <= this.range.endLineNumber; lineNumber++) {
+        let line = lines[lineNumber - 1];
+        let lineStartOffset = 0;
+        if (lineNumber === this.range.startLineNumber && this.range.startColumn > 1) {
+          lineStartOffset = this.range.startColumn - 1;
+          line = line.substring(lineStartOffset);
+        }
+        this.lineStartOffsets.push(lineStartOffset);
+        let trimmedWsLength = 0;
+        if (!considerWhitespaceChanges) {
           const trimmedStartLine = line.trimStart();
-          offset = line.length - trimmedStartLine.length;
+          trimmedWsLength = line.length - trimmedStartLine.length;
           line = trimmedStartLine.trimEnd();
         }
-        this.additionalOffsetByLine.push(offset);
-        for (let i2 = 0; i2 < line.length; i2++) {
-          this.elements.push(line.charCodeAt(i2));
+        this.trimmedWsLengthsByLineIdx.push(trimmedWsLength);
+        const lineLength = lineNumber === this.range.endLineNumber ? Math.min(this.range.endColumn - 1 - lineStartOffset - trimmedWsLength, line.length) : line.length;
+        for (let i = 0; i < lineLength; i++) {
+          this.elements.push(line.charCodeAt(i));
         }
-        if (i < lines.length - 1) {
+        if (lineNumber < this.range.endLineNumber) {
           this.elements.push("\n".charCodeAt(0));
-          this.firstCharOffsetByLine[i - this.lineRange.start + 1] = this.elements.length;
+          this.firstElementOffsetByLineIdx.push(this.elements.length);
         }
       }
-      this.additionalOffsetByLine.push(0);
     }
     toString() {
       return `Slice: "${this.text}"`;
@@ -11466,18 +11589,21 @@ ${stackTraceFormattedLines.join("\n")}
       score2 += getCategoryBoundaryScore(nextCategory);
       return score2;
     }
-    translateOffset(offset) {
-      if (this.lineRange.isEmpty) {
-        return new Position(this.lineRange.start + 1, 1);
-      }
-      const i = findLastIdxMonotonous(this.firstCharOffsetByLine, (value) => value <= offset);
+    translateOffset(offset, preference = "right") {
+      const i = findLastIdxMonotonous(this.firstElementOffsetByLineIdx, (value) => value <= offset);
+      const lineOffset = offset - this.firstElementOffsetByLineIdx[i];
       return new Position(
-        this.lineRange.start + i + 1,
-        offset - this.firstCharOffsetByLine[i] + this.additionalOffsetByLine[i] + 1
+        this.range.startLineNumber + i,
+        1 + this.lineStartOffsets[i] + lineOffset + (lineOffset === 0 && preference === "left" ? 0 : this.trimmedWsLengthsByLineIdx[i])
       );
     }
     translateRange(range) {
-      return Range.fromPositions(this.translateOffset(range.start), this.translateOffset(range.endExclusive));
+      const pos1 = this.translateOffset(range.start, "right");
+      const pos2 = this.translateOffset(range.endExclusive, "left");
+      if (pos2.isBefore(pos1)) {
+        return Range.fromPositions(pos2, pos2);
+      }
+      return Range.fromPositions(pos1, pos2);
     }
     findWordContaining(offset) {
       if (offset < 0 || offset >= this.elements.length) {
@@ -11503,8 +11629,8 @@ ${stackTraceFormattedLines.join("\n")}
       return this.elements[offset1] === this.elements[offset2];
     }
     extendToFullLines(range) {
-      const start = findLastMonotonous(this.firstCharOffsetByLine, (x) => x <= range.start) ?? 0;
-      const end = findFirstMonotonous(this.firstCharOffsetByLine, (x) => range.endExclusive <= x) ?? this.elements.length;
+      const start = findLastMonotonous(this.firstElementOffsetByLineIdx, (x) => x <= range.start) ?? 0;
+      const end = findFirstMonotonous(this.firstElementOffsetByLineIdx, (x) => range.endExclusive <= x) ?? this.elements.length;
       return new OffsetRange(start, end);
     }
   };
@@ -11749,7 +11875,7 @@ ${stackTraceFormattedLines.join("\n")}
       return false;
     }
     const myersDiffingAlgorithm = new MyersDiffAlgorithm();
-    const result = myersDiffingAlgorithm.compute(new LinesSliceCharSequence([line1], new OffsetRange(0, 1), false), new LinesSliceCharSequence([line2], new OffsetRange(0, 1), false), timeout);
+    const result = myersDiffingAlgorithm.compute(new LinesSliceCharSequence([line1], new Range(1, 1, 1, line1.length), false), new LinesSliceCharSequence([line2], new Range(1, 1, 1, line2.length), false), timeout);
     let commonNonSpaceCharCount = 0;
     const inverted = SequenceDiff.invert(result.diffs, line1.length);
     for (const seq of inverted) {
@@ -12290,8 +12416,10 @@ ${stackTraceFormattedLines.join("\n")}
       return movesWithDiffs;
     }
     refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges) {
-      const slice1 = new LinesSliceCharSequence(originalLines, diff.seq1Range, considerWhitespaceChanges);
-      const slice2 = new LinesSliceCharSequence(modifiedLines, diff.seq2Range, considerWhitespaceChanges);
+      const lineRangeMapping = toLineRangeMapping(diff);
+      const rangeMapping = lineRangeMapping.toRangeMapping2(originalLines, modifiedLines);
+      const slice1 = new LinesSliceCharSequence(originalLines, rangeMapping.originalRange, considerWhitespaceChanges);
+      const slice2 = new LinesSliceCharSequence(modifiedLines, rangeMapping.modifiedRange, considerWhitespaceChanges);
       const diffResult = slice1.length + slice2.length < 500 ? this.dynamicProgrammingDiffing.compute(slice1, slice2, timeout) : this.myersDiffingAlgorithm.compute(slice1, slice2, timeout);
       let diffs = diffResult.diffs;
       diffs = optimizeSequenceDiffs(slice1, slice2, diffs);
@@ -12348,6 +12476,9 @@ ${stackTraceFormattedLines.join("\n")}
     );
     return new DetailedLineRangeMapping(originalLineRange, modifiedLineRange, [rangeMapping]);
   }
+  function toLineRangeMapping(sequenceDiff) {
+    return new LineRangeMapping(new LineRange(sequenceDiff.seq1Range.start + 1, sequenceDiff.seq1Range.endExclusive + 1), new LineRange(sequenceDiff.seq2Range.start + 1, sequenceDiff.seq2Range.endExclusive + 1));
+  }
 
   // node_modules/vscode/vscode/src/vs/editor/common/diff/linesDiffComputers.js
   var linesDiffComputers = {
@@ -17950,7 +18081,7 @@ ${stackTraceFormattedLines.join("\n")}
     }
     return s;
   }
-  var _a2 = "a".charCodeAt(0);
+  var _a3 = "a".charCodeAt(0);
   var _z = "z".charCodeAt(0);
   var _A = "A".charCodeAt(0);
   var _Z = "Z".charCodeAt(0);
@@ -17958,7 +18089,7 @@ ${stackTraceFormattedLines.join("\n")}
   var _9 = "9".charCodeAt(0);
   function isLetterOrDigit(text, index) {
     const c = text.charCodeAt(index);
-    return _a2 <= c && c <= _z || _A <= c && c <= _Z || _0 <= c && c <= _9;
+    return _a3 <= c && c <= _z || _A <= c && c <= _Z || _0 <= c && c <= _9;
   }
   function isDefined(obj) {
     return typeof obj !== "undefined";
@@ -29750,7 +29881,7 @@ ${stackTraceFormattedLines.join("\n")}
 @codingame/monaco-vscode-standalone-html-language-features/worker.js:
   (*!-----------------------------------------------------------------------------
    * Copyright (c) Microsoft Corporation. All rights reserved.
-   * Version: 0.50.0(undefined)
+   * Version: 0.51.0(undefined)
    * Released under the MIT license
    * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
    *-----------------------------------------------------------------------------*)