@codingame/monaco-editor-wrapper 1.14.9 → 2.1.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",
@@ -773,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": "ocaml.META",
+    "scopeName": "source.ocaml.META"
   },
   {
-    "language": "reason.hover.signature",
-    "scopeName": "source.reason.hover.signature"
+    "language": "ocaml.oasis",
+    "scopeName": "source.ocaml.oasis"
   },
   {
-    "language": "reason.hover.type",
-    "scopeName": "source.reason.hover.type"
+    "language": "atd",
+    "scopeName": "source.atd"
   },
   {
     "scopeName": "markdown.reason.codeblock",
@@ -818,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",
@@ -1001,6 +1058,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"
+    ]
   }
 ];
 
@@ -1328,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" */
+  './opam-install.js').then(module => module)).default,
+  'source.ocaml.META': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-META" */
 
   /* webpackMode: "lazy" */
-  './reason-hover-info.js').then(module => module)).default,
-  'source.reason.hover.signature': async () => (await import(
-  /* webpackChunkName: "grammar-source-reason-hover-signature" */
+  './META.js').then(module => module)).default,
+  'source.ocaml.oasis': async () => (await import(
+  /* webpackChunkName: "grammar-source-ocaml-oasis" */
 
   /* webpackMode: "lazy" */
-  './reason-hover-signature.js').then(module => module)).default,
-  'source.reason.hover.type': async () => (await import(
-  /* webpackChunkName: "grammar-source-reason-hover-type" */
+  './oasis.js').then(module => module)).default,
+  'source.atd': async () => (await import(
+  /* webpackChunkName: "grammar-source-atd" */
 
   /* webpackMode: "lazy" */
-  './reason-hover-type.js').then(module => module)).default,
+  './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" */
 
@@ -1497,7 +1737,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
@@ -2452,127 +2762,256 @@ var textMateLanguages = [
     ]
   },
   {
-    "id": "ocaml",
+    "id": "dune",
     "aliases": [
-      "OCaml"
+      "dune"
     ],
     "extensions": [
-      ".ml",
-      ".mli"
+      "dune",
+      "jbuild"
     ]
   },
   {
-    "id": "ocaml.hover.info"
+    "id": "dune-project",
+    "aliases": [
+      "dune project"
+    ],
+    "extensions": [
+      "dune-project"
+    ]
   },
   {
-    "id": "ocaml.hover.type"
+    "id": "dune-workspace",
+    "aliases": [
+      "dune workspace"
+    ],
+    "filenames": [
+      "dune-workspace"
+    ],
+    "filenamePatterns": [
+      "dune-workspace.*"
+    ]
   },
   {
     "id": "ocaml.merlin",
     "aliases": [
-      "Merlin"
+      "Merlin",
+      "merlin"
     ],
     "extensions": [
-      "merlin"
+      ".merlin"
     ]
   },
   {
-    "id": "ocaml.ocamlbuild",
+    "id": "ocaml",
     "aliases": [
-      "OCamlbuild"
+      "OCaml",
+      "ocaml"
     ],
     "extensions": [
-      "_tags"
+      ".ml",
+      ".eliom",
+      ".ocamlinit"
     ]
   },
   {
-    "id": "ocaml.opam",
+    "id": "ocaml.interface",
     "aliases": [
-      "OPAM"
+      "OCaml Interface",
+      "ocaml interface"
     ],
     "extensions": [
-      "opam"
+      ".mli",
+      ".eliomi"
     ]
   },
   {
-    "id": "reason",
+    "id": "ocaml.opam",
     "aliases": [
-      "Reason"
+      "opam"
+    ],
+    "filenames": [
+      "opam"
     ],
     "extensions": [
-      ".re",
-      ".rei"
+      ".opam",
+      ".opam.locked",
+      ".opam.template"
     ]
   },
   {
-    "id": "reason.hover.info"
+    "id": "ocaml.opam-install",
+    "aliases": [
+      "opam install"
+    ],
+    "extensions": [
+      ".install"
+    ]
   },
   {
-    "id": "reason.hover.signature"
+    "id": "ocaml.META",
+    "aliases": [
+      "META",
+      "meta"
+    ],
+    "filenames": [
+      "META"
+    ]
   },
   {
-    "id": "reason.hover.type"
+    "id": "ocaml.ocamlbuild",
+    "aliases": [
+      "OCamlbuild",
+      "ocamlbuild"
+    ],
+    "extensions": [
+      "_tags"
+    ]
   },
   {
-    "id": "pascal",
+    "id": "ocaml.oasis",
     "aliases": [
-      "Pascal",
-      "pascal"
+      "OASIS",
+      "oasis"
     ],
     "extensions": [
-      ".pas",
-      ".p",
-      ".dfm",
-      ".fmx",
-      ".dpr",
-      ".dpk",
-      ".lfm",
-      ".dpr",
-      ".lpr"
+      "_oasis"
     ]
   },
   {
-    "id": "scala",
+    "id": "ocaml.ocamldoc",
     "aliases": [
-      "Scala",
-      "scala"
+      "OCamldoc",
+      "ocamldoc"
     ],
     "extensions": [
-      ".scala",
-      ".sbt",
-      ".sc"
+      ".mld"
     ]
   },
   {
-    "id": "javap-verbose",
+    "id": "ocaml.ocamlformat",
+    "aliases": [
+      "OCamlFormat",
+      "ocamlformat"
+    ],
     "extensions": [
-      ".javap-verbose"
+      ".ocamlformat"
     ]
   },
   {
-    "id": "javap",
+    "id": "ocaml.ocamllex",
+    "aliases": [
+      "OCamllex",
+      "ocamllex"
+    ],
     "extensions": [
-      ".javap"
+      ".mll"
     ]
   },
   {
-    "id": "java",
+    "id": "ocaml.menhir",
+    "aliases": [
+      "Menhir",
+      "menhir",
+      "OCamlyacc",
+      "ocamlyacc"
+    ],
     "extensions": [
-      ".cfr"
+      ".mly"
     ]
   },
   {
-    "id": "tasty",
+    "id": "atd",
     "aliases": [
-      "TASTy",
-      "tasty"
+      "ATD",
+      "atd"
     ],
     "extensions": [
-      ".tasty-decoded"
+      ".atd"
     ]
   },
   {
-    "id": "buildtarget",
+    "id": "reason",
+    "aliases": [
+      "Reason",
+      "reason"
+    ],
+    "extensions": [
+      ".re",
+      ".rei"
+    ]
+  },
+  {
+    "id": "cram",
+    "aliases": [
+      "Cram Test",
+      "Cram",
+      "cram"
+    ],
+    "extensions": [
+      ".t"
+    ]
+  },
+  {
+    "id": "pascal",
+    "aliases": [
+      "Pascal",
+      "pascal"
+    ],
+    "extensions": [
+      ".pas",
+      ".p",
+      ".dfm",
+      ".fmx",
+      ".dpr",
+      ".dpk",
+      ".lfm",
+      ".dpr",
+      ".lpr"
+    ]
+  },
+  {
+    "id": "scala",
+    "aliases": [
+      "Scala",
+      "scala"
+    ],
+    "extensions": [
+      ".scala",
+      ".sbt",
+      ".sc"
+    ]
+  },
+  {
+    "id": "javap-verbose",
+    "extensions": [
+      ".javap-verbose"
+    ]
+  },
+  {
+    "id": "javap",
+    "extensions": [
+      ".javap"
+    ]
+  },
+  {
+    "id": "java",
+    "extensions": [
+      ".cfr"
+    ]
+  },
+  {
+    "id": "tasty",
+    "aliases": [
+      "TASTy",
+      "tasty"
+    ],
+    "extensions": [
+      ".tasty-decoded"
+    ]
+  },
+  {
+    "id": "buildtarget",
     "extensions": [
       ".metals-buildtarget"
     ]
@@ -2590,6 +3029,9 @@ var textMateLanguages = [
     "extensions": [
       ".cpy",
       ".copy"
+    ],
+    "filenamePatterns": [
+      "**/*copybook*/**"
     ]
   },
   {
@@ -2833,6 +3275,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"
+    ]
   }
 ];
 
@@ -3205,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" */
 
@@ -3299,7 +3854,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
@@ -3396,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-reason.js').then(module => module)).default,
+  './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-ocamllex.js').then(module => module)).default,
   'pascal': async () => (await import(
   /* webpackChunkName: "snippet-pascal" */
 
@@ -3460,7 +4055,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 +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];
 
@@ -4219,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;
+  }
 
-  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 +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 = {};
@@ -16093,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) {