@codingame/monaco-editor-wrapper 1.14.8 → 2.0.0

package/dist/main.js

@@ -5,6 +5,8 @@ import onigFile from 'vscode-oniguruma/release/onig.wasm';
 import { loadWASM, createOnigScanner, createOnigString } from 'vscode-oniguruma';
 import { e as extensions, g as getConfiguration$1, o as onConfigurationChanged } from './index.js';
 export { g as getConfiguration, o as onConfigurationChanged, r as registerConfigurations, a as registerDefaultConfigurations, u as updateUserConfiguration } from './index.js';
+import getModelEditorServiceOverride from 'vscode/service-override/modelEditor';
+import getMessageServiceOverride from 'vscode/service-override/messages';
 import './worker.js';
 import 'monaco-editor/esm/vs/editor/editor.all';
 import 'monaco-editor/esm/vs/editor/standalone/browser/accessibilityHelp/accessibilityHelp';
@@ -490,6 +492,7 @@ var rawGrammars = [
       "meta.embedded.block.javascript": "javascript",
       "meta.embedded.block.json": "json",
       "meta.embedded.block.jsonc": "jsonc",
+      "meta.embedded.block.latex": "latex",
       "meta.embedded.block.less": "less",
       "meta.embedded.block.objc": "objc",
       "meta.embedded.block.scss": "scss",
@@ -585,6 +588,13 @@ var rawGrammars = [
   {
     "language": "typescript",
     "scopeName": "source.ts",
+    "unbalancedBracketScopes": [
+      "keyword.operator.relational",
+      "storage.type.function.arrow",
+      "keyword.operator.bitwise.shift",
+      "meta.brace.angle",
+      "punctuation.definition.tag"
+    ],
     "tokenTypes": {
       "meta.template.expression": "other",
       "meta.template.expression string": "string",
@@ -598,6 +608,12 @@ var rawGrammars = [
   {
     "language": "typescriptreact",
     "scopeName": "source.tsx",
+    "unbalancedBracketScopes": [
+      "keyword.operator.relational",
+      "storage.type.function.arrow",
+      "keyword.operator.bitwise.shift",
+      "punctuation.definition.tag"
+    ],
     "embeddedLanguages": {
       "meta.tag.tsx": "jsx-tags",
       "meta.tag.without-attributes.tsx": "jsx-tags",
@@ -1001,6 +1017,144 @@ var rawGrammars = [
   {
     "language": "solidity",
     "scopeName": "source.solidity"
+  },
+  {
+    "language": "vue",
+    "scopeName": "source.vue",
+    "embeddedLanguages": {
+      "text.html.basic": "html",
+      "text.html.vue-html": "vue-html",
+      "text.jade.slm": "slm",
+      "text.pug": "jade",
+      "text.haml": "haml",
+      "text.slim": "slim",
+      "text.html.liquid": "liquid",
+      "source.css": "css",
+      "source.css.scss": "scss",
+      "source.css.less": "less",
+      "source.css.postcss": "vue-postcss",
+      "source.css.sugarss": "vue-sugarss",
+      "source.sass": "sass",
+      "source.stylus": "stylus",
+      "source.js": "javascript",
+      "source.ts": "typescript",
+      "source.coffee": "coffeescript",
+      "text.html.markdown": "md",
+      "source.yaml": "yaml",
+      "source.json": "json",
+      "source.php": "php",
+      "source.graphql": "graphql"
+    }
+  },
+  {
+    "language": "vue-postcss",
+    "scopeName": "source.css.postcss"
+  },
+  {
+    "language": "vue-sugarss",
+    "scopeName": "source.css.sugarss"
+  },
+  {
+    "language": "vue-html",
+    "scopeName": "text.html.vue-html",
+    "embeddedLanguages": {
+      "source.js": "javascript"
+    }
+  },
+  {
+    "scopeName": "vue.pug.directives",
+    "injectTo": [
+      "source.vue"
+    ]
+  },
+  {
+    "scopeName": "vue.pug.interpolations",
+    "injectTo": [
+      "source.vue"
+    ]
+  },
+  {
+    "scopeName": "markdown.vue.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.vue": "vue"
+    }
+  },
+  {
+    "language": "svelte",
+    "scopeName": "source.svelte",
+    "embeddedLanguages": {
+      "text.html.basic": "html",
+      "text.html.markdown": "markdown",
+      "text.pug": "jade",
+      "source.css": "css",
+      "source.css.less": "less",
+      "source.css.scss": "scss",
+      "source.css.postcss": "postcss",
+      "source.sass": "sass",
+      "source.stylus": "stylus",
+      "source.js": "javascript",
+      "source.ts": "typescript",
+      "source.coffee": "coffeescript"
+    }
+  },
+  {
+    "scopeName": "svelte.pug",
+    "injectTo": [
+      "source.svelte"
+    ],
+    "embeddedLanguages": {
+      "source.ts": "typescript",
+      "text.pug": "jade"
+    }
+  },
+  {
+    "scopeName": "svelte.pug.tags",
+    "injectTo": [
+      "source.svelte"
+    ],
+    "embeddedLanguages": {
+      "source.ts": "typescript",
+      "text.pug": "jade"
+    }
+  },
+  {
+    "scopeName": "svelte.pug.dotblock",
+    "injectTo": [
+      "source.svelte"
+    ],
+    "embeddedLanguages": {
+      "source.ts": "typescript"
+    }
+  },
+  {
+    "scopeName": "markdown.svelte.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.svelte": "svelte"
+    }
+  },
+  {
+    "scopeName": "markdown.svelte.codeblock.script",
+    "injectTo": [
+      "text.html.markdown"
+    ]
+  },
+  {
+    "scopeName": "markdown.svelte.codeblock.style",
+    "injectTo": [
+      "text.html.markdown"
+    ]
+  },
+  {
+    "scopeName": "source.css.postcss",
+    "injectTo": [
+      "source.svelte"
+    ]
   }
 ];
 
@@ -1497,7 +1651,77 @@ const loader$3 = {
   /* webpackChunkName: "grammar-source-solidity" */
 
   /* webpackMode: "lazy" */
-  './solidity2.js').then(module => module)).default
+  './solidity2.js').then(module => module)).default,
+  'source.vue': async () => (await import(
+  /* webpackChunkName: "grammar-source-vue" */
+
+  /* webpackMode: "lazy" */
+  './vue-generated.js').then(module => module)).default,
+  'source.css.postcss': async () => (await import(
+  /* webpackChunkName: "grammar-source-css-postcss" */
+
+  /* webpackMode: "lazy" */
+  './postcss.src.yaml.js').then(module => module)).default,
+  'source.css.sugarss': async () => (await import(
+  /* webpackChunkName: "grammar-source-css-sugarss" */
+
+  /* webpackMode: "lazy" */
+  './vue-sugarss2.js').then(module => module)).default,
+  'text.html.vue-html': async () => (await import(
+  /* webpackChunkName: "grammar-text-html-vue-html" */
+
+  /* webpackMode: "lazy" */
+  './vue-html.tmLanguage.js').then(module => module)).default,
+  'vue.pug.directives': async () => (await import(
+  /* webpackChunkName: "grammar-vue-pug-directives" */
+
+  /* webpackMode: "lazy" */
+  './directives.tmLanguage.js').then(module => module)).default,
+  'vue.pug.interpolations': async () => (await import(
+  /* webpackChunkName: "grammar-vue-pug-interpolations" */
+
+  /* webpackMode: "lazy" */
+  './interpolations.tmLanguage.js').then(module => module)).default,
+  'markdown.vue.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-vue-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './markdown-vue.js').then(module => module)).default,
+  'source.svelte': async () => (await import(
+  /* webpackChunkName: "grammar-source-svelte" */
+
+  /* webpackMode: "lazy" */
+  './svelte.tmLanguage.src.yaml.js').then(module => module)).default,
+  'svelte.pug': async () => (await import(
+  /* webpackChunkName: "grammar-svelte-pug" */
+
+  /* webpackMode: "lazy" */
+  './pug-svelte.js').then(module => module)).default,
+  'svelte.pug.tags': async () => (await import(
+  /* webpackChunkName: "grammar-svelte-pug-tags" */
+
+  /* webpackMode: "lazy" */
+  './pug-svelte-tags.js').then(module => module)).default,
+  'svelte.pug.dotblock': async () => (await import(
+  /* webpackChunkName: "grammar-svelte-pug-dotblock" */
+
+  /* webpackMode: "lazy" */
+  './pug-svelte-dotblock.js').then(module => module)).default,
+  'markdown.svelte.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-svelte-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './markdown-svelte.js').then(module => module)).default,
+  'markdown.svelte.codeblock.script': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-svelte-codeblock-script" */
+
+  /* webpackMode: "lazy" */
+  './markdown-svelte-js.js').then(module => module)).default,
+  'markdown.svelte.codeblock.style': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-svelte-codeblock-style" */
+
+  /* webpackMode: "lazy" */
+  './markdown-svelte-css.js').then(module => module)).default
 };
 
 // Inpired by https://github.com/microsoft/vscode/blob/94c9ea46838a9a619aeafb7e8afd1170c967bb55/src/vs/workbench/services/themes/common/tokenClassificationExtensionPoint.ts
@@ -2833,6 +3057,54 @@ var textMateLanguages = [
     "extensions": [
       ".sol"
     ]
+  },
+  {
+    "id": "vue",
+    "aliases": [
+      "Vue",
+      "vue"
+    ],
+    "extensions": [
+      ".vue"
+    ]
+  },
+  {
+    "id": "vue-html",
+    "aliases": [
+      "Vue-html"
+    ]
+  },
+  {
+    "id": "vue-postcss",
+    "aliases": [
+      "Vue-PostCSS",
+      "Vue-POSTCSS",
+      "vue-postcss"
+    ]
+  },
+  {
+    "id": "vue-sugarss",
+    "aliases": [
+      "Vue-SugarSS",
+      "Vue-SUGARSS",
+      "vue-sugarss"
+    ]
+  },
+  {
+    "id": "svelte",
+    "aliases": [
+      "Svelte",
+      "svelte"
+    ],
+    "extensions": [
+      ".svelte"
+    ]
+  },
+  {
+    "id": "json",
+    "filenames": [
+      ".prettierrc"
+    ]
   }
 ];
 
@@ -3299,7 +3571,32 @@ const loader$2 = {
   /* webpackChunkName: "language-configuration-solidity" */
 
   /* webpackMode: "lazy" */
-  './solidity.js').then(module => module)).default
+  './solidity.js').then(module => module)).default,
+  'vue': async () => (await import(
+  /* webpackChunkName: "language-configuration-vue" */
+
+  /* webpackMode: "lazy" */
+  './vue.js').then(module => module)).default,
+  'vue-html': async () => (await import(
+  /* webpackChunkName: "language-configuration-vue-html" */
+
+  /* webpackMode: "lazy" */
+  './vue-html.js').then(module => module)).default,
+  'vue-postcss': async () => (await import(
+  /* webpackChunkName: "language-configuration-vue-postcss" */
+
+  /* webpackMode: "lazy" */
+  './vue-postcss.js').then(module => module)).default,
+  'vue-sugarss': async () => (await import(
+  /* webpackChunkName: "language-configuration-vue-sugarss" */
+
+  /* webpackMode: "lazy" */
+  './vue-sugarss.js').then(module => module)).default,
+  'svelte': async () => (await import(
+  /* webpackChunkName: "language-configuration-svelte" */
+
+  /* webpackMode: "lazy" */
+  './svelte.js').then(module => module)).default
 };
 
 // Generated file, do not modify
@@ -3460,7 +3757,12 @@ const loader$1 = {
   /* webpackChunkName: "snippet-solidity" */
 
   /* webpackMode: "lazy" */
-  './solidity-solidity.js').then(module => module)).default
+  './solidity-solidity.js').then(module => module)).default,
+  'svelte': async () => (await import(
+  /* webpackChunkName: "snippet-svelte" */
+
+  /* webpackMode: "lazy" */
+  './svelte.svelte-vscode-svelte.js').then(module => module)).default
 };
 
 class SimpleSnippetService {
@@ -3780,326 +4082,6 @@ for (const themeExtensionPoint of defaultThemes) {
   });
 }
 
-let popupEditorDisposable = null;
-
-function openNewCodeEditor(model) {
-  if (popupEditorDisposable != null) {
-    popupEditorDisposable.dispose();
-    popupEditorDisposable = null;
-  }
-
-  const container = document.createElement('div');
-  container.style.position = 'fixed';
-  container.style.zIndex = '10000';
-  container.style.backgroundColor = 'rgba(0, 0, 0, 0.5)';
-  container.style.top = container.style.bottom = container.style.left = container.style.right = '0';
-  container.style.cursor = 'pointer';
-  const editorElem = document.createElement('div');
-  editorElem.style.position = 'absolute';
-  editorElem.style.top = editorElem.style.bottom = editorElem.style.left = editorElem.style.right = '0';
-  editorElem.style.margin = 'auto';
-  editorElem.style.width = '80%';
-  editorElem.style.height = '80%';
-  container.appendChild(editorElem);
-  document.body.appendChild(container);
-  const editor = createEditor(editorElem, _objectSpread2({
-    model,
-    readOnly: true,
-    automaticLayout: true
-  }, getConfiguration$1(model.getLanguageId(), 'editor')));
-  popupEditorDisposable = {
-    dispose: () => {
-      editor.dispose();
-      document.body.removeChild(container);
-      popupEditorDisposable = null;
-    }
-  };
-  container.addEventListener('mousedown', event => {
-    var _popupEditorDisposabl;
-
-    if (event.target !== container) {
-      return;
-    }
-
-    (_popupEditorDisposabl = popupEditorDisposable) === null || _popupEditorDisposabl === void 0 ? void 0 : _popupEditorDisposabl.dispose();
-  });
-  return editor;
-}
-
-class MultiEditorStandaloneCodeEditorServiceImpl extends monaco$2.extra.StandaloneCodeEditorService {
-  constructor(contextKeyService, themeService, textModelService) {
-    super(contextKeyService, themeService);
-
-    _defineProperty(this, "textModelService", void 0);
-
-    _defineProperty(this, "handlers", []);
-
-    this.textModelService = textModelService;
-  }
-
-  registerEditorOpenHandler(handler) {
-    this.handlers.push(handler);
-    return {
-      dispose: () => {
-        const index = this.handlers.indexOf(handler);
-
-        if (index >= 0) {
-          this.handlers.splice(index, 1);
-        }
-      }
-    };
-  }
-
-  async openCodeEditor(input, editor, sideBySide) {
-    var _modelEditor$getDomNo;
-
-    const reference = await this.textModelService.createModelReference(input.resource);
-    const model = reference.object.textEditorModel;
-    let modelEditor;
-
-    if (editor != null && editor.getModel() === model) {
-      modelEditor = editor;
-    }
-
-    if (modelEditor == null) {
-      const codeEditors = monaco$2.extra.StandaloneServices.get(monaco$2.extra.ICodeEditorService).listCodeEditors();
-      modelEditor = codeEditors.find(editor => editor.getModel() === model);
-    }
-
-    if (modelEditor == null) {
-      for (const handler of this.handlers) {
-        const handlerEditor = await handler(model, input, editor, sideBySide);
-
-        if (handlerEditor != null) {
-          modelEditor = handlerEditor;
-          break;
-        }
-      }
-    }
-
-    if (modelEditor == null) {
-      modelEditor = openNewCodeEditor(model);
-    }
-
-    super.doOpenEditor(modelEditor, input);
-    modelEditor.focus();
-
-    if (((_modelEditor$getDomNo = modelEditor.getDomNode()) === null || _modelEditor$getDomNo === void 0 ? void 0 : _modelEditor$getDomNo.scrollIntoView) != null) {
-      var _modelEditor$getDomNo2;
-
-      (_modelEditor$getDomNo2 = modelEditor.getDomNode()) === null || _modelEditor$getDomNo2 === void 0 ? void 0 : _modelEditor$getDomNo2.scrollIntoView({
-        block: 'nearest',
-        inline: 'nearest'
-      });
-    }
-
-    const onModelUnmount = () => {
-      reference.dispose();
-    };
-
-    const onDidDisposeDisposable = modelEditor.onDidDispose(() => {
-      onModelUnmount();
-    });
-    const onDidChangeModelDisposable = modelEditor.onDidChangeModel(e => {
-      if (e.newModelUrl == null || e.newModelUrl.toString() !== model.uri.toString()) {
-        onModelUnmount();
-        onDidDisposeDisposable.dispose();
-        onDidChangeModelDisposable.dispose();
-      }
-    });
-    return modelEditor;
-  }
-
-}
-
-class SimpleResolvedModel {
-  constructor(model, readonly) {
-    this.model = model;
-    this.readonly = readonly;
-
-    _defineProperty(this, "_onWillDispose", void 0);
-
-    _defineProperty(this, "disposed", false);
-
-    this._onWillDispose = new monaco$2.Emitter();
-  }
-
-  getLanguageId() {
-    return this.model.getLanguageId();
-  }
-
-  get onWillDispose() {
-    return this._onWillDispose.event;
-  }
-
-  resolve() {
-    return Promise.resolve();
-  }
-
-  get textEditorModel() {
-    return this.model;
-  }
-
-  createSnapshot() {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return this.model.createSnapshot();
-  }
-
-  isReadonly() {
-    return this.readonly;
-  }
-
-  dispose() {
-    this.disposed = true;
-
-    this._onWillDispose.fire();
-  }
-
-  isDisposed() {
-    return this.disposed;
-  }
-
-  isResolved() {
-    return true;
-  }
-
-  getMode() {
-    return this.model.getLanguageId();
-  }
-
-}
-
-class ResourceModelCollection extends monaco$2.extra.ReferenceCollection {
-  constructor() {
-    super(...arguments);
-
-    _defineProperty(this, "providers", new Map());
-
-    _defineProperty(this, "modelsToDispose", new Set());
-  }
-
-  async createReferencedObject(key) {
-    // Untrack as being disposed
-    this.modelsToDispose.delete(key);
-    const resource = monaco$2.Uri.parse(key);
-    const existingModel = monaco$2.editor.getModel(resource);
-
-    if (existingModel != null) {
-      return new SimpleResolvedModel(existingModel, false);
-    }
-
-    if (this.providers.has(resource.scheme)) {
-      const model = await this.resolveTextModelContent(key);
-      const resolvedModel = new SimpleResolvedModel(model, true);
-      resolvedModel.onWillDispose(() => {
-        model.dispose();
-      });
-      return resolvedModel;
-    }
-
-    throw new Error("Unable to resolve resource ".concat(key));
-  }
-
-  destroyReferencedObject(key, modelPromise) {
-    const resource = monaco$2.Uri.parse(key);
-
-    if (resource.scheme === 'untitled' || resource.scheme === 'inMemory') {
-      return;
-    }
-
-    this.modelsToDispose.add(key);
-    (async () => {
-      try {
-        const model = await modelPromise;
-
-        if (!this.modelsToDispose.has(key)) {
-          // return if model has been acquired again meanwhile
-          return;
-        } // Finally we can dispose the model
-
-
-        model.dispose();
-      } finally {
-        this.modelsToDispose.delete(key); // Untrack as being disposed
-      }
-    })().catch(() => {// ignore
-    });
-  }
-
-  registerTextModelContentProvider(scheme, provider) {
-    let providers = this.providers.get(scheme);
-
-    if (providers == null) {
-      providers = [];
-      this.providers.set(scheme, providers);
-    }
-
-    providers.unshift(provider);
-    return monaco$2.extra.toDisposable(() => {
-      const providersForScheme = this.providers.get(scheme);
-
-      if (providersForScheme == null) {
-        return;
-      }
-
-      const index = providersForScheme.indexOf(provider);
-
-      if (index === -1) {
-        return;
-      }
-
-      providersForScheme.splice(index, 1);
-
-      if (providersForScheme.length === 0) {
-        this.providers.delete(scheme);
-      }
-    });
-  }
-
-  hasTextModelContentProvider(scheme) {
-    return this.providers.get(scheme) !== undefined;
-  }
-
-  async resolveTextModelContent(key) {
-    var _this$providers$get;
-
-    const resource = monaco$2.Uri.parse(key);
-    const providersForScheme = (_this$providers$get = this.providers.get(resource.scheme)) !== null && _this$providers$get !== void 0 ? _this$providers$get : [];
-
-    for (const provider of providersForScheme) {
-      const value = await provider.provideTextContent(resource);
-
-      if (value != null) {
-        return value;
-      }
-    }
-
-    throw new Error("Unable to resolve text model content for resource ".concat(key));
-  }
-
-}
-
-class TextModelService extends monaco$2.extra.StandaloneTextModelService {
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-  constructor(modelService) {
-    super(modelService);
-
-    _defineProperty(this, "resourceModelCollection", new ResourceModelCollection());
-
-    _defineProperty(this, "asyncModelCollection", new monaco$2.extra.AsyncReferenceCollection(this.resourceModelCollection));
-  }
-
-  registerTextModelContentProvider(scheme, provider) {
-    return this.resourceModelCollection.registerTextModelContentProvider(scheme, provider);
-  }
-
-  async createModelReference(resource) {
-    const result = await this.asyncModelCollection.acquire(resource.toString());
-    return result;
-  }
-
-}
-
 const fixedPositions = [0, 6, 7, 11];
 const lastFixedPosition = fixedPositions[fixedPositions.length - 1];
 
@@ -4219,16 +4201,136 @@ function setup(editor) {
   setup$1(editor);
 }
 
-monaco$2.extra.StandaloneServices.initialize({
-  get textModelService() {
-    return new TextModelService(monaco$2.extra.StandaloneServices.get(monaco$2.extra.IModelService));
-  },
+let currentEditor = null;
+
+function openNewCodeEditor(model) {
+  if (currentEditor != null && model === currentEditor.model) {
+    return currentEditor.editor;
+  }
 
-  get codeEditorService() {
-    return new MultiEditorStandaloneCodeEditorServiceImpl(monaco$2.extra.StandaloneServices.get(monaco$2.extra.IContextKeyService), monaco$2.extra.StandaloneServices.get(monaco$2.editor.IStandaloneThemeService), monaco$2.extra.StandaloneServices.get(monaco$2.extra.ITextModelService));
+  if (currentEditor != null) {
+    currentEditor.dispose();
+    currentEditor = null;
   }
 
-}); // Disable high contrast autodetection because it fallbacks on the hc-black no matter what
+  const container = document.createElement('div');
+  container.style.position = 'fixed';
+  container.style.zIndex = '10000';
+  container.style.backgroundColor = 'rgba(0, 0, 0, 0.5)';
+  container.style.top = container.style.bottom = container.style.left = container.style.right = '0';
+  container.style.cursor = 'pointer';
+  const editorElem = document.createElement('div');
+  editorElem.style.position = 'absolute';
+  editorElem.style.top = editorElem.style.bottom = editorElem.style.left = editorElem.style.right = '0';
+  editorElem.style.margin = 'auto';
+  editorElem.style.width = '80%';
+  editorElem.style.height = '80%';
+  container.appendChild(editorElem);
+  document.body.appendChild(container);
+
+  try {
+    const editor = createEditor(editorElem, _objectSpread2({
+      model,
+      readOnly: true,
+      automaticLayout: true
+    }, getConfiguration$1(model.getLanguageId(), 'editor')));
+    currentEditor = {
+      dispose: () => {
+        editor.dispose();
+        document.body.removeChild(container);
+        currentEditor = null;
+      },
+      model,
+      editor
+    };
+    container.addEventListener('mousedown', event => {
+      var _currentEditor;
+
+      if (event.target !== container) {
+        return;
+      }
+
+      (_currentEditor = currentEditor) === null || _currentEditor === void 0 ? void 0 : _currentEditor.dispose();
+    });
+    return editor;
+  } catch (error) {
+    document.body.removeChild(container);
+    currentEditor = null;
+    throw error;
+  }
+}
+
+class EditorOpenHandlerRegistry {
+  constructor() {
+    _defineProperty(this, "handlers", []);
+
+    _defineProperty(this, "openCodeEditor", async (model, options, sideBySide) => {
+      var _modelEditor$getDomNo;
+
+      let modelEditor;
+
+      for (const handler of this.handlers) {
+        const handlerEditor = await handler(model, options, null, sideBySide);
+
+        if (handlerEditor != null) {
+          modelEditor = handlerEditor;
+          break;
+        }
+      }
+
+      if (modelEditor == null) {
+        modelEditor = openNewCodeEditor(model); // Destroy model ref when we close the editor popup
+
+        const onModelUnmount = () => {
+          model.dispose();
+        };
+
+        const onDidDisposeDisposable = modelEditor.onDidDispose(() => {
+          onModelUnmount();
+        });
+        const onDidChangeModelDisposable = modelEditor.onDidChangeModel(e => {
+          if (e.newModelUrl == null || e.newModelUrl.toString() !== model.uri.toString()) {
+            onModelUnmount();
+            onDidDisposeDisposable.dispose();
+            onDidChangeModelDisposable.dispose();
+          }
+        });
+      }
+
+      modelEditor.focus();
+
+      if (((_modelEditor$getDomNo = modelEditor.getDomNode()) === null || _modelEditor$getDomNo === void 0 ? void 0 : _modelEditor$getDomNo.scrollIntoView) != null) {
+        var _modelEditor$getDomNo2;
+
+        (_modelEditor$getDomNo2 = modelEditor.getDomNode()) === null || _modelEditor$getDomNo2 === void 0 ? void 0 : _modelEditor$getDomNo2.scrollIntoView({
+          block: 'nearest',
+          inline: 'nearest'
+        });
+      }
+
+      return modelEditor;
+    });
+  }
+
+  registerEditorOpenHandler(handler) {
+    this.handlers.push(handler);
+    return {
+      dispose: () => {
+        const index = this.handlers.indexOf(handler);
+
+        if (index >= 0) {
+          this.handlers.splice(index, 1);
+        }
+      }
+    };
+  }
+
+}
+
+const editorOpenHandlerRegistry = new EditorOpenHandlerRegistry();
+monaco$2.extra.StandaloneServices.initialize(_objectSpread2(_objectSpread2({}, getModelEditorServiceOverride((model, input, sideBySide) => {
+  return editorOpenHandlerRegistry.openCodeEditor(model, input, sideBySide);
+})), getMessageServiceOverride(document.body))); // Disable high contrast autodetection because it fallbacks on the hc-black no matter what
 
 monaco$2.extra.StandaloneServices.get(monaco$2.editor.IStandaloneThemeService).setAutoDetectHighContrast(false); // Force EOL to be '\n' even on Windows
 
@@ -4254,8 +4356,7 @@ function registerTextModelContentProvider(scheme, provider) {
 }
 
 function registerEditorOpenHandler(handler) {
-  const codeEditorService = monaco$2.extra.StandaloneServices.get(monaco$2.extra.ICodeEditorService);
-  return codeEditorService.registerEditorOpenHandler(handler);
+  return editorOpenHandlerRegistry.registerEditorOpenHandler(handler);
 }
 
 var lib$1 = {};
@@ -16093,8 +16194,8 @@ function initVimMode(editor, statusBarElement) {
   return lib.initVimMode(editor, statusBarElement);
 }
 
-const keybindingService = monaco$2.extra.StandaloneServices.get(monaco$2.extra.IKeybindingService);
 function updateKeybindings(bindings) {
+  const keybindingService = monaco$2.extra.StandaloneServices.get(monaco$2.extra.IKeybindingService);
   keybindingService.setUserKeybindings(bindings);
 }
 function updateEditorKeybindingsMode(editor) {