@codingame/monaco-editor-wrapper 1.15.0 → 2.1.1

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';
@@ -787,40 +789,86 @@ var rawGrammars = [
     }
   },
   {
-    "language": "ocaml",
-    "scopeName": "source.ocaml"
+    "language": "dune",
+    "scopeName": "source.dune"
   },
   {
-    "language": "ocaml.hover.info",
-    "scopeName": "source.ocaml.hover.info"
+    "language": "dune-project",
+    "scopeName": "source.dune-project"
   },
   {
-    "language": "ocaml.hover.type",
-    "scopeName": "source.ocaml.hover.type"
+    "language": "dune-workspace",
+    "scopeName": "source.dune-workspace"
   },
   {
     "language": "ocaml.merlin",
     "scopeName": "source.ocaml.merlin"
   },
+  {
+    "scopeName": "markdown.ocaml.codeblock",
+    "injectTo": [
+      "text.html.markdown"
+    ],
+    "embeddedLanguages": {
+      "meta.embedded.block.ocaml": "ocaml"
+    }
+  },
+  {
+    "language": "ocaml",
+    "scopeName": "source.ocaml"
+  },
+  {
+    "language": "ocaml.interface",
+    "scopeName": "source.ocaml.interface"
+  },
   {
     "language": "ocaml.ocamlbuild",
     "scopeName": "source.ocaml.ocamlbuild"
   },
+  {
+    "language": "ocaml.ocamldoc",
+    "scopeName": "source.ocaml.ocamldoc"
+  },
+  {
+    "language": "ocaml.ocamlformat",
+    "scopeName": "source.ocaml.ocamlformat"
+  },
+  {
+    "language": "ocaml.ocamllex",
+    "scopeName": "source.ocaml.ocamllex"
+  },
+  {
+    "scopeName": "source.action.menhir",
+    "injectTo": [
+      "source.ocaml"
+    ]
+  },
+  {
+    "language": "ocaml.menhir",
+    "scopeName": "source.ocaml.menhir",
+    "embeddedLanguages": {
+      "source.embedded-action.menhir": "source.action.menhir"
+    }
+  },
   {
     "language": "ocaml.opam",
     "scopeName": "source.ocaml.opam"
   },
   {
-    "language": "reason.hover.info",
-    "scopeName": "source.reason.hover.info"
+    "language": "ocaml.opam-install",
+    "scopeName": "source.ocaml.opam-install"
   },
   {
-    "language": "reason.hover.signature",
-    "scopeName": "source.reason.hover.signature"
+    "language": "ocaml.META",
+    "scopeName": "source.ocaml.META"
   },
   {
-    "language": "reason.hover.type",
-    "scopeName": "source.reason.hover.type"
+    "language": "ocaml.oasis",
+    "scopeName": "source.ocaml.oasis"
+  },
+  {
+    "language": "atd",
+    "scopeName": "source.atd"
   },
   {
     "scopeName": "markdown.reason.codeblock",
@@ -832,13 +880,8 @@ var rawGrammars = [
     }
   },
   {
-    "scopeName": "markdown.ocaml.codeblock",
-    "injectTo": [
-      "text.html.markdown"
-    ],
-    "embeddedLanguages": {
-      "meta.embedded.block.ocaml": "ocaml"
-    }
+    "language": "cram",
+    "scopeName": "source.cram"
   },
   {
     "language": "pascal",
@@ -1480,61 +1523,106 @@ const loader$3 = {
 
   /* webpackMode: "lazy" */
   './codeblock2.js').then(module => module)).default,
-  'source.ocaml': async () => (await import(
-  /* webpackChunkName: "grammar-source-ocaml" */
+  'source.dune': async () => (await import(
+  /* webpackChunkName: "grammar-source-dune" */
 
   /* webpackMode: "lazy" */
-  './ocaml2.js').then(module => module)).default,
-  'source.ocaml.hover.info': async () => (await import(
-  /* webpackChunkName: "grammar-source-ocaml-hover-info" */
+  './dune2.js').then(module => module)).default,
+  'source.dune-project': async () => (await import(
+  /* webpackChunkName: "grammar-source-dune-project" */
 
   /* webpackMode: "lazy" */
-  './ocaml-hover-info.js').then(module => module)).default,
-  'source.ocaml.hover.type': async () => (await import(
-  /* webpackChunkName: "grammar-source-ocaml-hover-type" */
+  './dune-project2.js').then(module => module)).default,
+  'source.dune-workspace': async () => (await import(
+  /* webpackChunkName: "grammar-source-dune-workspace" */
 
   /* webpackMode: "lazy" */
-  './ocaml-hover-type.js').then(module => module)).default,
+  './dune-workspace2.js').then(module => module)).default,
   'source.ocaml.merlin': async () => (await import(
   /* webpackChunkName: "grammar-source-ocaml-merlin" */
 
   /* webpackMode: "lazy" */
   './merlin.js').then(module => module)).default,
+  'markdown.ocaml.codeblock': async () => (await import(
+  /* webpackChunkName: "grammar-markdown-ocaml-codeblock" */
+
+  /* webpackMode: "lazy" */
+  './ocaml-markdown-codeblock.js').then(module => module)).default,
+  'source.ocaml': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml" */
+
+  /* webpackMode: "lazy" */
+  './ocaml2.js').then(module => module)).default,
+  'source.ocaml.interface': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-interface" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.interface2.js').then(module => module)).default,
   'source.ocaml.ocamlbuild': async () => (await import(
   /* webpackChunkName: "grammar-source-ocaml-ocamlbuild" */
 
   /* webpackMode: "lazy" */
   './ocamlbuild.js').then(module => module)).default,
+  'source.ocaml.ocamldoc': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-ocamldoc" */
+
+  /* webpackMode: "lazy" */
+  './ocamldoc.js').then(module => module)).default,
+  'source.ocaml.ocamlformat': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-ocamlformat" */
+
+  /* webpackMode: "lazy" */
+  './ocamlformat.js').then(module => module)).default,
+  'source.ocaml.ocamllex': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-ocamllex" */
+
+  /* webpackMode: "lazy" */
+  './ocamllex.js').then(module => module)).default,
+  'source.action.menhir': async () => (await import(
+  /* webpackChunkName: "grammar-source-action-menhir" */
+
+  /* webpackMode: "lazy" */
+  './menhir-action.js').then(module => module)).default,
+  'source.ocaml.menhir': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-menhir" */
+
+  /* webpackMode: "lazy" */
+  './menhir.js').then(module => module)).default,
   'source.ocaml.opam': async () => (await import(
   /* webpackChunkName: "grammar-source-ocaml-opam" */
 
   /* webpackMode: "lazy" */
   './opam.js').then(module => module)).default,
-  'source.reason.hover.info': async () => (await import(
-  /* webpackChunkName: "grammar-source-reason-hover-info" */
+  'source.ocaml.opam-install': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-opam-install" */
 
   /* webpackMode: "lazy" */
-  './reason-hover-info.js').then(module => module)).default,
-  'source.reason.hover.signature': async () => (await import(
-  /* webpackChunkName: "grammar-source-reason-hover-signature" */
+  './opam-install.js').then(module => module)).default,
+  'source.ocaml.META': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-META" */
 
   /* webpackMode: "lazy" */
-  './reason-hover-signature.js').then(module => module)).default,
-  'source.reason.hover.type': async () => (await import(
-  /* webpackChunkName: "grammar-source-reason-hover-type" */
+  './META.js').then(module => module)).default,
+  'source.ocaml.oasis': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-oasis" */
 
   /* webpackMode: "lazy" */
-  './reason-hover-type.js').then(module => module)).default,
+  './oasis.js').then(module => module)).default,
+  'source.atd': async () => (await import(
+  /* webpackChunkName: "grammar-source-atd" */
+
+  /* webpackMode: "lazy" */
+  './atd2.js').then(module => module)).default,
   'markdown.reason.codeblock': async () => (await import(
   /* webpackChunkName: "grammar-markdown-reason-codeblock" */
 
   /* webpackMode: "lazy" */
   './reason-markdown-codeblock.js').then(module => module)).default,
-  'markdown.ocaml.codeblock': async () => (await import(
-  /* webpackChunkName: "grammar-markdown-ocaml-codeblock" */
+  'source.cram': async () => (await import(
+  /* webpackChunkName: "grammar-source-cram" */
 
   /* webpackMode: "lazy" */
-  './ocaml-markdown-codeblock.js').then(module => module)).default,
+  './cram.js').then(module => module)).default,
   'source.pascal': async () => (await import(
   /* webpackChunkName: "grammar-source-pascal" */
 
@@ -2673,67 +2761,196 @@ var textMateLanguages = [
       ".kts"
     ]
   },
+  {
+    "id": "dune",
+    "aliases": [
+      "dune"
+    ],
+    "extensions": [
+      "dune",
+      "jbuild"
+    ]
+  },
+  {
+    "id": "dune-project",
+    "aliases": [
+      "dune project"
+    ],
+    "extensions": [
+      "dune-project"
+    ]
+  },
+  {
+    "id": "dune-workspace",
+    "aliases": [
+      "dune workspace"
+    ],
+    "filenames": [
+      "dune-workspace"
+    ],
+    "filenamePatterns": [
+      "dune-workspace.*"
+    ]
+  },
+  {
+    "id": "ocaml.merlin",
+    "aliases": [
+      "Merlin",
+      "merlin"
+    ],
+    "extensions": [
+      ".merlin"
+    ]
+  },
   {
     "id": "ocaml",
     "aliases": [
-      "OCaml"
+      "OCaml",
+      "ocaml"
     ],
     "extensions": [
       ".ml",
-      ".mli"
+      ".eliom",
+      ".ocamlinit"
     ]
   },
   {
-    "id": "ocaml.hover.info"
+    "id": "ocaml.interface",
+    "aliases": [
+      "OCaml Interface",
+      "ocaml interface"
+    ],
+    "extensions": [
+      ".mli",
+      ".eliomi"
+    ]
   },
   {
-    "id": "ocaml.hover.type"
+    "id": "ocaml.opam",
+    "aliases": [
+      "opam"
+    ],
+    "filenames": [
+      "opam"
+    ],
+    "extensions": [
+      ".opam",
+      ".opam.locked",
+      ".opam.template"
+    ]
   },
   {
-    "id": "ocaml.merlin",
+    "id": "ocaml.opam-install",
     "aliases": [
-      "Merlin"
+      "opam install"
     ],
     "extensions": [
-      "merlin"
+      ".install"
+    ]
+  },
+  {
+    "id": "ocaml.META",
+    "aliases": [
+      "META",
+      "meta"
+    ],
+    "filenames": [
+      "META"
     ]
   },
   {
     "id": "ocaml.ocamlbuild",
     "aliases": [
-      "OCamlbuild"
+      "OCamlbuild",
+      "ocamlbuild"
     ],
     "extensions": [
       "_tags"
     ]
   },
   {
-    "id": "ocaml.opam",
+    "id": "ocaml.oasis",
     "aliases": [
-      "OPAM"
+      "OASIS",
+      "oasis"
     ],
     "extensions": [
-      "opam"
+      "_oasis"
     ]
   },
   {
-    "id": "reason",
+    "id": "ocaml.ocamldoc",
     "aliases": [
-      "Reason"
+      "OCamldoc",
+      "ocamldoc"
     ],
     "extensions": [
-      ".re",
-      ".rei"
+      ".mld"
     ]
   },
   {
-    "id": "reason.hover.info"
+    "id": "ocaml.ocamlformat",
+    "aliases": [
+      "OCamlFormat",
+      "ocamlformat"
+    ],
+    "extensions": [
+      ".ocamlformat"
+    ]
   },
   {
-    "id": "reason.hover.signature"
+    "id": "ocaml.ocamllex",
+    "aliases": [
+      "OCamllex",
+      "ocamllex"
+    ],
+    "extensions": [
+      ".mll"
+    ]
   },
   {
-    "id": "reason.hover.type"
+    "id": "ocaml.menhir",
+    "aliases": [
+      "Menhir",
+      "menhir",
+      "OCamlyacc",
+      "ocamlyacc"
+    ],
+    "extensions": [
+      ".mly"
+    ]
+  },
+  {
+    "id": "atd",
+    "aliases": [
+      "ATD",
+      "atd"
+    ],
+    "extensions": [
+      ".atd"
+    ]
+  },
+  {
+    "id": "reason",
+    "aliases": [
+      "Reason",
+      "reason"
+    ],
+    "extensions": [
+      ".re",
+      ".rei"
+    ]
+  },
+  {
+    "id": "cram",
+    "aliases": [
+      "Cram Test",
+      "Cram",
+      "cram"
+    ],
+    "extensions": [
+      ".t"
+    ]
   },
   {
     "id": "pascal",
@@ -2812,6 +3029,9 @@ var textMateLanguages = [
     "extensions": [
       ".cpy",
       ".copy"
+    ],
+    "filenamePatterns": [
+      "**/*copybook*/**"
     ]
   },
   {
@@ -3475,11 +3695,76 @@ const loader$2 = {
 
   /* webpackMode: "lazy" */
   './kotlinscript.js').then(module => module)).default,
+  'dune': async () => (await import(
+  /* webpackChunkName: "language-configuration-dune" */
+
+  /* webpackMode: "lazy" */
+  './dune.js').then(module => module)).default,
+  'dune-project': async () => (await import(
+  /* webpackChunkName: "language-configuration-dune-project" */
+
+  /* webpackMode: "lazy" */
+  './dune-project.js').then(module => module)).default,
+  'dune-workspace': async () => (await import(
+  /* webpackChunkName: "language-configuration-dune-workspace" */
+
+  /* webpackMode: "lazy" */
+  './dune-workspace.js').then(module => module)).default,
   'ocaml': async () => (await import(
   /* webpackChunkName: "language-configuration-ocaml" */
 
   /* webpackMode: "lazy" */
   './ocaml.js').then(module => module)).default,
+  'ocaml.interface': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.interface" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.interface.js').then(module => module)).default,
+  'ocaml.opam': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.opam" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.opam.js').then(module => module)).default,
+  'ocaml.opam-install': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.opam-install" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.opam-install.js').then(module => module)).default,
+  'ocaml.META': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.META" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.META.js').then(module => module)).default,
+  'ocaml.ocamlbuild': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.ocamlbuild" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.ocamlbuild.js').then(module => module)).default,
+  'ocaml.oasis': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.oasis" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.oasis.js').then(module => module)).default,
+  'ocaml.ocamlformat': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.ocamlformat" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.ocamlformat.js').then(module => module)).default,
+  'ocaml.ocamllex': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.ocamllex" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.ocamllex.js').then(module => module)).default,
+  'ocaml.menhir': async () => (await import(
+  /* webpackChunkName: "language-configuration-ocaml.menhir" */
+
+  /* webpackMode: "lazy" */
+  './ocaml.menhir.js').then(module => module)).default,
+  'atd': async () => (await import(
+  /* webpackChunkName: "language-configuration-atd" */
+
+  /* webpackMode: "lazy" */
+  './atd.js').then(module => module)).default,
   'reason': async () => (await import(
   /* webpackChunkName: "language-configuration-reason" */
 
@@ -3691,11 +3976,26 @@ const loader$1 = {
 
   /* webpackMode: "lazy" */
   './kotlin-kotlin.js').then(module => module)).default,
-  'reason': async () => (await import(
-  /* webpackChunkName: "snippet-reason" */
+  'dune': async () => (await import(
+  /* webpackChunkName: "snippet-dune" */
+
+  /* webpackMode: "lazy" */
+  './ocaml-dune.js').then(module => module)).default,
+  'dune-project': async () => (await import(
+  /* webpackChunkName: "snippet-dune-project" */
+
+  /* webpackMode: "lazy" */
+  './ocaml-dune-project.js').then(module => module)).default,
+  'ocaml': async () => (await import(
+  /* webpackChunkName: "snippet-ocaml" */
+
+  /* webpackMode: "lazy" */
+  './ocaml-ocaml.js').then(module => module)).default,
+  'ocaml.ocamllex': async () => (await import(
+  /* webpackChunkName: "snippet-ocaml.ocamllex" */
 
   /* webpackMode: "lazy" */
-  './ocaml-reason.js').then(module => module)).default,
+  './ocaml-ocamllex.js').then(module => module)).default,
   'pascal': async () => (await import(
   /* webpackChunkName: "snippet-pascal" */
 
@@ -4080,326 +4380,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];
 
@@ -4519,16 +4499,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;
+  }
+
+  if (currentEditor != null) {
+    currentEditor.dispose();
+    currentEditor = 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);
+
+  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;
+      }
 
-  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));
+      (_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);
+        }
+      }
+    };
+  }
+
+}
 
-}); // Disable high contrast autodetection because it fallbacks on the hc-black no matter what
+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
 
@@ -4554,8 +4654,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 = {};
@@ -16393,8 +16492,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) {