@codingame/monaco-editor-wrapper 1.4.3 → 1.7.0

package/dist/main.js

@@ -8,44 +8,20 @@ import EmacsExtension from '@codingame/monaco-emacs';
 import * as monacoVim from 'monaco-vim';
 
 function _mergeNamespaces(n, m) {
-  m.forEach(function (e) {
-    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-      if (k !== 'default' && !(k in n)) {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  });
-  return Object.freeze(n);
+	m.forEach(function (e) {
+		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+			if (k !== 'default' && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
 }
 
-monaco.errorHandler.setUnexpectedErrorHandler(error => {
-  console.error('Unexpected error', error);
-});
-/* Add custom blocks parsing (for tech.io):
-// { [autofold]
-//  custom block content
-// }
-*/
-
-const CUSTOM_BLOCK_BEGIN_REGEX = '^\\w*(?:\\/\\/|#).*\\{';
-const CUSTOM_BLOCK_END_REGEX = '^\\w*(?:\\/\\/|#).*\\}';
-const original = monaco.languages.LanguageConfigurationRegistryImpl.prototype.getFoldingRules;
-
-monaco.languages.LanguageConfigurationRegistryImpl.prototype.getFoldingRules = function (languageId) {
-  const foldingRules = original.call(this, languageId);
-  const markers = foldingRules.markers;
-  return _objectSpread2(_objectSpread2({}, foldingRules), {}, {
-    markers: {
-      start: markers != null ? new RegExp(markers.start.source + '|' + CUSTOM_BLOCK_BEGIN_REGEX) : new RegExp(CUSTOM_BLOCK_BEGIN_REGEX),
-      end: markers != null ? new RegExp(markers.end.source + '|' + CUSTOM_BLOCK_END_REGEX) : new RegExp(CUSTOM_BLOCK_END_REGEX)
-    }
-  });
-};
-
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -62,8 +38,8 @@ var main$1 = {exports: {}};
 var main = /*@__PURE__*/getDefaultExportFromCjs(main$1.exports);
 
 var vscodeTextmate = /*#__PURE__*/Object.freeze(/*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  'default': main
+	__proto__: null,
+	'default': main
 }, [main$1.exports]));
 
 function isValidHexColor(hex) {
@@ -205,7 +181,7 @@ async function addVSCodeTheme(name, vscodeTheme) {
     encodedTokensColors: themeData.tokenColorMap.slice(1)
   });
 
-  monaco.editor.defineTheme(name, monacoTheme);
+  monaco.editor.defineTheme(name, monacoTheme, vscodeTheme.semanticHighlighting);
 }
 function getThemeData(themeName) {
   var _vscodeThemeData$get;
@@ -273,7 +249,7 @@ class CGTMGrammarFactory extends monaco.extra.TMGrammarFactory {
       }, themeData.tokenColorMap);
     };
 
-    const standaloneThemeService = monaco.editor.StaticServices.standaloneThemeService.get();
+    const standaloneThemeService = monaco.extra.StandaloneServices.get(monaco.editor.IStandaloneThemeService);
 
     this._register(standaloneThemeService.onDidColorThemeChange(updateTheme));
 
@@ -288,15 +264,15 @@ function toMonacoToken(token) {
   });
 }
 
-class CGTMTokenizationSupport extends monaco.extra.TMTokenizationSupport {
+class CGTMTokenizationSupport extends monaco.extra.TMTokenizationSupportWithLineLimit {
   constructor(languageId, encodedLanguageId, actual, grammar) {
-    super(languageId, encodedLanguageId, actual, monaco.editor.StaticServices.configurationService.get());
+    super(languageId, encodedLanguageId, actual, monaco.extra.StandaloneServices.get(monaco.extra.IConfigurationService));
     this.languageId = languageId;
     this.grammar = grammar;
   } // To make "inspect tokens" work, default impl is `throw new Error('Not supported!');`
 
 
-  tokenize(line, hasEOL, state, offsetDelta) {
+  tokenize(line, hasEOL, state) {
     return monaco.languages.adaptTokenize(this.languageId, {
       tokenize: (line, state) => {
         const actualResult = this.grammar.tokenizeLine(line, state);
@@ -305,7 +281,7 @@ class CGTMTokenizationSupport extends monaco.extra.TMTokenizationSupport {
           endState: actualResult.ruleStack
         };
       }
-    }, line, state, offsetDelta);
+    }, line, state);
   }
 
 }
@@ -475,6 +451,7 @@ var rawGrammars = [
       "meta.embedded.block.pug": "jade",
       "meta.embedded.block.javascript": "javascript",
       "meta.embedded.block.json": "json",
+      "meta.embedded.block.jsonc": "jsonc",
       "meta.embedded.block.less": "less",
       "meta.embedded.block.objc": "objc",
       "meta.embedded.block.scss": "scss",
@@ -865,29 +842,13 @@ var rawGrammars = [
     "language": "tcl",
     "scopeName": "source.tcl"
   },
-  {
-    "language": "verilog",
-    "scopeName": "source.verilog"
-  },
   {
     "language": "systemverilog",
     "scopeName": "source.systemverilog"
   },
   {
-    "language": "bsv",
-    "scopeName": "source.bsv"
-  },
-  {
-    "language": "ucf",
-    "scopeName": "source.ucfconstraints"
-  },
-  {
-    "language": "sdc",
-    "scopeName": "source.sdc"
-  },
-  {
-    "language": "xdc",
-    "scopeName": "source.sdc"
+    "language": "verilog",
+    "scopeName": "source.systemverilog"
   },
   {
     "scopeName": "markdown.verilog.codeblock",
@@ -895,8 +856,8 @@ var rawGrammars = [
       "text.html.markdown"
     ],
     "embeddedLanguages": {
-      "meta.embedded.block.verilog": "source.verilog",
-      "meta.embedded.block.systemverilog": "source.systemverilog"
+      "meta.embedded.block.systemverilog": "source.systemverilog",
+      "meta.embedded.block.verilog": "source.verilog"
     }
   },
   {
@@ -1269,21 +1230,9 @@ const loader$2 = {
   'source.tcl': async () => (await import(
   /* webpackChunkName: "grammar-source-tcl" */
   './tcl.tmlanguage.yaml.js').then(module => module)).default,
-  'source.verilog': async () => (await import(
-  /* webpackChunkName: "grammar-source-verilog" */
-  './verilog.tmLanguage.js').then(module => module)).default,
   'source.systemverilog': async () => (await import(
   /* webpackChunkName: "grammar-source-systemverilog" */
   './systemverilog.tmLanguage.js').then(module => module)).default,
-  'source.bsv': async () => (await import(
-  /* webpackChunkName: "grammar-source-bsv" */
-  './BSV.tmLanguage.js').then(module => module)).default,
-  'source.ucfconstraints': async () => (await import(
-  /* webpackChunkName: "grammar-source-ucfconstraints" */
-  './ucf.tmLanguage.js').then(module => module)).default,
-  'source.sdc': async () => (await import(
-  /* webpackChunkName: "grammar-source-sdc" */
-  './sdc.tmLanguage.js').then(module => module)).default,
   'markdown.verilog.codeblock': async () => (await import(
   /* webpackChunkName: "grammar-markdown-verilog-codeblock" */
   './codeblock3.js').then(module => module)).default,
@@ -2510,8 +2459,8 @@ for (const contribution of extensions.semanticTokenScopes) {
 }
 
 function createGrammarFactory() {
-  const modeService = monaco.editor.StaticServices.modeService.get();
-  const parsedGrammars = rawGrammars.map(grammar => _objectSpread2(_objectSpread2({}, monaco.extra.parseTextMateGrammar(grammar, modeService)), {}, {
+  const languageService = monaco.extra.StandaloneServices.get(monaco.languages.ILanguageService);
+  const parsedGrammars = rawGrammars.map(grammar => _objectSpread2(_objectSpread2({}, monaco.extra.parseTextMateGrammar(grammar, languageService)), {}, {
     location: monaco.Uri.file(grammar.scopeName + '.json')
   }));
   return new CGTMGrammarFactory(parsedGrammars, loader$2, onigFile);
@@ -2527,10 +2476,10 @@ function getOrCreateGrammarFactory() {
   return textMateGrammarFactory;
 }
 
-const modeService$2 = monaco.editor.StaticServices.modeService.get();
+const languageService$2 = monaco.extra.StandaloneServices.get(monaco.languages.ILanguageService);
 async function createTextMateTokensProvider(languageId) {
   const grammarFactory = getOrCreateGrammarFactory();
-  const encodedLanguageId = modeService$2.languageIdCodec.encodeLanguageId(languageId);
+  const encodedLanguageId = languageService$2.languageIdCodec.encodeLanguageId(languageId);
   const {
     grammar,
     initialState,
@@ -2543,7 +2492,8 @@ async function createTextMateTokensProvider(languageId) {
 
   const tokenization = new monaco.extra.TMTokenization(grammar, initialState, containsEmbeddedLanguages);
   tokenization.onDidEncounterLanguage(encodedLanguageId => {
-    modeService$2.triggerMode(modeService$2.languageIdCodec.decodeLanguageId(encodedLanguageId));
+    // Force monaco to load this language and trigger the global `onDidEncounterLanguage`
+    languageService$2.createById(languageService$2.languageIdCodec.decodeLanguageId(encodedLanguageId));
   });
   return new CGTMTokenizationSupport(languageId, encodedLanguageId, tokenization, grammar);
 }
@@ -2790,7 +2740,8 @@ var textMateLanguages = [
       ".har",
       ".jslintrc",
       ".jsonld",
-      ".geojson"
+      ".geojson",
+      ".ipynb"
     ],
     "filenames": [
       "composer.lock",
@@ -3608,68 +3559,28 @@ var textMateLanguages = [
       ".test"
     ]
   },
-  {
-    "id": "verilog",
-    "aliases": [
-      "Verilog",
-      "verilog"
-    ],
-    "extensions": [
-      ".v",
-      ".vh",
-      ".vl"
-    ]
-  },
   {
     "id": "systemverilog",
     "aliases": [
+      "SystemVerilog",
+      "systemverilog",
       "System Verilog",
-      "systemverilog"
+      "Systemverilog"
     ],
     "extensions": [
       ".sv",
-      ".svh",
-      ".SV"
+      ".svh"
     ]
   },
   {
-    "id": "bsv",
-    "aliases": [
-      "BluespecSystemVerilog",
-      "Bluespec SystemVerilog",
-      "BSV"
-    ],
-    "extensions": [
-      ".bsv",
-      ".BSV"
-    ]
-  },
-  {
-    "id": "ucf",
-    "aliases": [
-      "vivado ucf",
-      "ucf constraints"
-    ],
-    "extensions": [
-      ".ucf"
-    ]
-  },
-  {
-    "id": "sdc",
-    "aliases": [
-      "Synopsys Design Constraints"
-    ],
-    "extensions": [
-      ".sdc"
-    ]
-  },
-  {
-    "id": "xdc",
+    "id": "verilog",
     "aliases": [
-      "Xilinx Design Constraints"
+      "Verilog",
+      "verilog"
     ],
     "extensions": [
-      ".xdc"
+      ".v",
+      ".vh"
     ]
   },
   {
@@ -3718,12 +3629,12 @@ var textMateLanguages = [
       "requirements.txt"
     ],
     "filenamePatterns": [
-      "*-constraints.txt",
-      "*-requirements.in",
-      "*-requirements.txt",
-      "constraints-*.txt",
-      "requirements-*.in",
-      "requirements-*.txt"
+      "**/*-requirements.{txt, in}",
+      "**/*-contstraints.txt",
+      "**/requirements-*.{txt, in}",
+      "**/constraints-*.txt",
+      "**/requirements/*.{txt,in}",
+      "**/constraints/*.txt"
     ],
     "filenames": [
       "constraints.txt",
@@ -4113,24 +4024,12 @@ const loader$1 = {
   'tcl': async () => (await import(
   /* webpackChunkName: "language-configuration-tcl" */
   './tcl.js').then(module => module)).default,
-  'verilog': async () => (await import(
-  /* webpackChunkName: "language-configuration-verilog" */
-  './verilog.js').then(module => module)).default,
   'systemverilog': async () => (await import(
   /* webpackChunkName: "language-configuration-systemverilog" */
   './systemverilog.js').then(module => module)).default,
-  'bsv': async () => (await import(
-  /* webpackChunkName: "language-configuration-bsv" */
-  './bsv.js').then(module => module)).default,
-  'ucf': async () => (await import(
-  /* webpackChunkName: "language-configuration-ucf" */
-  './ucf.js').then(module => module)).default,
-  'sdc': async () => (await import(
-  /* webpackChunkName: "language-configuration-sdc" */
-  './sdc.js').then(module => module)).default,
-  'xdc': async () => (await import(
-  /* webpackChunkName: "language-configuration-xdc" */
-  './xdc.js').then(module => module)).default,
+  'verilog': async () => (await import(
+  /* webpackChunkName: "language-configuration-verilog" */
+  './verilog.js').then(module => module)).default,
   'postgres': async () => (await import(
   /* webpackChunkName: "language-configuration-postgres" */
   './postgres.js').then(module => module)).default,
@@ -4157,52 +4056,52 @@ const loader$1 = {
 const loader = {
   'coffeescript': async () => (await import(
   /* webpackChunkName: "snippet-coffeescript" */
-  './coffeescript-coffeescript.js').then(module => module)).default,
+  './coffeescript-coffeescript.code-snippets.js').then(module => module)).default,
   'c': async () => (await import(
   /* webpackChunkName: "snippet-c" */
-  './cpp-c.js').then(module => module)).default,
+  './cpp-c.code-snippets.js').then(module => module)).default,
   'cpp': async () => (await import(
   /* webpackChunkName: "snippet-cpp" */
-  './cpp-cpp.js').then(module => module)).default,
+  './cpp-cpp.code-snippets.js').then(module => module)).default,
   'csharp': async () => (await import(
   /* webpackChunkName: "snippet-csharp" */
   './omnisharp-csharp.js').then(module => module)).default,
   'fsharp': async () => (await import(
   /* webpackChunkName: "snippet-fsharp" */
-  './fsharp-fsharp.js').then(module => module)).default,
+  './fsharp-fsharp.code-snippets.js').then(module => module)).default,
   'groovy': async () => (await import(
   /* webpackChunkName: "snippet-groovy" */
-  './groovy-groovy.js').then(module => module)).default,
+  './groovy-groovy.code-snippets.js').then(module => module)).default,
   'java': async () => (await import(
   /* webpackChunkName: "snippet-java" */
   './java-java.js').then(module => module)).default,
   'javascript': async () => (await import(
   /* webpackChunkName: "snippet-javascript" */
-  './javascript-javascript.js').then(module => module)).default,
+  './javascript-javascript.code-snippets.js').then(module => module)).default,
   'javascriptreact': async () => (await import(
   /* webpackChunkName: "snippet-javascriptreact" */
-  './javascript-javascriptreact.js').then(module => module)).default,
+  './javascript-javascript.code-snippets.js').then(module => module)).default,
   'markdown': async () => (await import(
   /* webpackChunkName: "snippet-markdown" */
-  './markdown-basics-markdown.js').then(module => module)).default,
+  './markdown-basics-markdown.code-snippets.js').then(module => module)).default,
   'php': async () => (await import(
   /* webpackChunkName: "snippet-php" */
-  './php-php.js').then(module => module)).default,
+  './php-php.code-snippets.js').then(module => module)).default,
   'powershell': async () => (await import(
   /* webpackChunkName: "snippet-powershell" */
-  './powershell-powershell.js').then(module => module)).default,
+  './powershell-powershell.code-snippets.js').then(module => module)).default,
   'swift': async () => (await import(
   /* webpackChunkName: "snippet-swift" */
-  './swift-swift.js').then(module => module)).default,
+  './swift-swift.code-snippets.js').then(module => module)).default,
   'typescript': async () => (await import(
   /* webpackChunkName: "snippet-typescript" */
-  './typescript-basics-typescript.js').then(module => module)).default,
+  './typescript-basics-typescript.code-snippets.js').then(module => module)).default,
   'typescriptreact': async () => (await import(
   /* webpackChunkName: "snippet-typescriptreact" */
-  './typescript-basics-typescriptreact.js').then(module => module)).default,
+  './typescript-basics-typescript.code-snippets.js').then(module => module)).default,
   'vb': async () => (await import(
   /* webpackChunkName: "snippet-vb" */
-  './vb-vb.js').then(module => module)).default,
+  './vb-vb.code-snippets.js').then(module => module)).default,
   'diet': async () => (await import(
   /* webpackChunkName: "snippet-diet" */
   './d-diet.js').then(module => module)).default,
@@ -4211,7 +4110,7 @@ const loader = {
   './kotlin-kotlin.js').then(module => module)).default,
   'kotlinscript': async () => (await import(
   /* webpackChunkName: "snippet-kotlinscript" */
-  './kotlin-kotlinscript.js').then(module => module)).default,
+  './kotlin-kotlin.js').then(module => module)).default,
   'reason': async () => (await import(
   /* webpackChunkName: "snippet-reason" */
   './ocaml-reason.js').then(module => module)).default,
@@ -4220,40 +4119,41 @@ const loader = {
   './pascal-pascal.js').then(module => module)).default,
   'COBOL': async () => (await import(
   /* webpackChunkName: "snippet-COBOL" */
-  './cobol-COBOL.js').then(module => module)).default,
+  './cobol-snippets.js').then(module => module)).default,
   'COBOL Copybook': async () => (await import(
   /* webpackChunkName: "snippet-COBOL Copybook" */
-  './cobol-COBOL Copybook.js').then(module => module)).default,
+  './cobol-snippets.js').then(module => module)).default,
   'elixir': async () => (await import(
   /* webpackChunkName: "snippet-elixir" */
-  './elixir-elixir.js').then(module => module)).default,
+  './elixir-snippets.js').then(module => module)).default,
   'erlang': async () => (await import(
   /* webpackChunkName: "snippet-erlang" */
   './erlang-erlang.js').then(module => module)).default,
   'tcl': async () => (await import(
   /* webpackChunkName: "snippet-tcl" */
   './tcl-tcl.js').then(module => module)).default,
-  'verilog': async () => (await import(
-  /* webpackChunkName: "snippet-verilog" */
-  './verilog-verilog.js').then(module => module)).default,
   'systemverilog': async () => (await import(
   /* webpackChunkName: "snippet-systemverilog" */
-  './verilog-systemverilog.js').then(module => module)).default,
-  'bsv': async () => (await import(
-  /* webpackChunkName: "snippet-bsv" */
-  './verilog-bsv.js').then(module => module)).default,
+  './svlangserver-systemverilog.js').then(module => module)).default,
+  'verilog': async () => (await import(
+  /* webpackChunkName: "snippet-verilog" */
+  './svlangserver-systemverilog.js').then(module => module)).default,
   'r': async () => (await import(
   /* webpackChunkName: "snippet-r" */
-  './vscode-R-r.js').then(module => module)).default,
+  './vscode-R-r-snippets.js').then(module => module)).default,
   'rd': async () => (await import(
   /* webpackChunkName: "snippet-rd" */
-  './vscode-R-rd.js').then(module => module)).default,
+  './vscode-R-r-snippets.js').then(module => module)).default,
   'rmd': async () => (await import(
   /* webpackChunkName: "snippet-rmd" */
-  './vscode-R-rmd.js').then(module => module)).default
+  './vscode-R-rmarkdown.js').then(module => module)).default
 };
 
 class SimpleSnippetService {
+  constructor() {
+    _defineProperty(this, "_serviceBrand", void 0);
+  }
+
   isEnabled(snippet) {
     return snippet.snippetIdentifier != null || true;
   }
@@ -4294,8 +4194,30 @@ class SimpleSnippetService {
 
 }
 
-const modeService$1 = monaco.editor.StaticServices.modeService.get();
-monaco.extra.setSnippetSuggestSupport(new monaco.extra.SnippetCompletionProvider(modeService$1, new SimpleSnippetService()));
+const languageService$1 = monaco.extra.StandaloneServices.get(monaco.languages.ILanguageService);
+const languageConfigurationService = monaco.extra.StandaloneServices.get(monaco.languages.ILanguageConfigurationService);
+monaco.extra.setSnippetSuggestSupport(new monaco.extra.SnippetCompletionProvider(languageService$1, new SimpleSnippetService(), languageConfigurationService));
+
+/* Add custom blocks parsing (for tech.io):
+// { [autofold]
+//  custom block content
+// }
+*/
+const CUSTOM_BLOCK_BEGIN_REGEX = '^\\w*(?:\\/\\/|#).*\\{';
+const CUSTOM_BLOCK_END_REGEX = '^\\w*(?:\\/\\/|#).*\\}';
+function addCustomFoldingMarkers(configuration) {
+  var _configuration$foldin, _configuration$foldin2;
+
+  const markers = (_configuration$foldin = configuration.folding) === null || _configuration$foldin === void 0 ? void 0 : _configuration$foldin.markers;
+  return _objectSpread2(_objectSpread2({}, configuration), {}, {
+    folding: _objectSpread2(_objectSpread2({}, (_configuration$foldin2 = configuration.folding) !== null && _configuration$foldin2 !== void 0 ? _configuration$foldin2 : {}), {}, {
+      markers: {
+        start: markers != null ? new RegExp(markers.start.source + '|' + CUSTOM_BLOCK_BEGIN_REGEX) : new RegExp(CUSTOM_BLOCK_BEGIN_REGEX),
+        end: markers != null ? new RegExp(markers.end.source + '|' + CUSTOM_BLOCK_END_REGEX) : new RegExp(CUSTOM_BLOCK_END_REGEX)
+      }
+    })
+  });
+}
 
 const customAliases = {
   csharp: ['c#'],
@@ -4309,7 +4231,7 @@ const customAliases = {
   sql: ['mysql'],
   postgres: ['postgresql', 'postgres', 'pg', 'postgre']
 };
-const modeService = monaco.editor.StaticServices.modeService.get();
+const languageService = monaco.extra.StandaloneServices.get(monaco.languages.ILanguageService);
 const languagesIds = Array.from(new Set([...Object.keys(languageLoader), ...textMateLanguages.map(rawLanguage => rawLanguage.id)]));
 
 for (const languageId of languagesIds) {
@@ -4325,9 +4247,44 @@ for (const languageId of languagesIds) {
     aliases: [...((_textMateLanguage$ali = textMateLanguage === null || textMateLanguage === void 0 ? void 0 : textMateLanguage.aliases) !== null && _textMateLanguage$ali !== void 0 ? _textMateLanguage$ali : []), ...((_customAliases$langua = customAliases[languageId]) !== null && _customAliases$langua !== void 0 ? _customAliases$langua : [])],
     mimetypes: textMateLanguage === null || textMateLanguage === void 0 ? void 0 : textMateLanguage.mimetypes
   });
+  monaco.languages.setTokenizationSupportFactory(languageId, {
+    createTokenizationSupport: async () => {
+      return createTextMateTokensProvider(languageId).catch(err => {
+        const monarchLoader = languageLoader[languageId];
+
+        if (monarchLoader != null) {
+          console.warn("Failed to load TextMate grammar for language ".concat(languageId, ", fallback to monarch"), err);
+          monaco.languages.setMonarchTokensProvider(languageId, monarchLoader().then(lang => lang.language));
+        } else {
+          console.warn("Failed to load TextMate grammar for language ".concat(languageId, " and no fallback monarch"), err);
+        }
+
+        return null;
+      });
+    }
+  });
+}
+/**
+ * Type is wrong
+ * see https://github.com/microsoft/vscode/blob/cfad2543487c4a8e8f53b4451dbccdc1c2036f41/src/vs/workbench/contrib/codeEditor/browser/languageConfigurationExtensionPoint.ts#L381
+ */
+
+
+function parseLanguageConfiguration(config) {
+  var _config$folding;
+
+  const markers = (_config$folding = config.folding) === null || _config$folding === void 0 ? void 0 : _config$folding.markers;
+  return _objectSpread2(_objectSpread2({}, config), {}, {
+    folding: config.folding != null ? _objectSpread2(_objectSpread2({}, config.folding), {}, {
+      markers: markers != null ? {
+        start: new RegExp(markers.start),
+        end: new RegExp(markers.end)
+      } : undefined
+    }) : undefined
+  });
 }
 
-modeService.onDidEncounterLanguage(async languageId => {
+languageService.onDidEncounterLanguage(async languageId => {
   if (languageId === 'plaintext') {
     return;
   }
@@ -4336,39 +4293,25 @@ modeService.onDidEncounterLanguage(async languageId => {
 
   if (loader != null) {
     loader().then(configuration => {
-      monaco.extra.handleLanguageConfiguration(languageId, configuration);
+      monaco.extra.handleLanguageConfiguration(languageId, addCustomFoldingMarkers(parseLanguageConfiguration(configuration)));
     }).catch(error => {
       console.error('Unable to load language configuration', error);
     });
   }
-
-  const textMateTokenProviderPromise = createTextMateTokensProvider(languageId).catch(err => {
-    const monarchLoader = languageLoader[languageId];
-
-    if (monarchLoader != null) {
-      console.warn("Failed to load TextMate grammar for language ".concat(languageId, ", fallback to monarch"), err);
-      monaco.languages.setMonarchTokensProvider(languageId, monarchLoader().then(lang => lang.language));
-    } else {
-      console.warn("Failed to load TextMate grammar for language ".concat(languageId, " and no fallback monarch"), err);
-    }
-
-    return null;
-  });
-  monaco.languages.setTokenizationSupport(languageId, textMateTokenProviderPromise);
 });
 
 function getMonacoLanguage(languageOrModeId) {
-  const modeId = modeService.getModeIdForLanguageName(languageOrModeId.toLowerCase());
+  const modeId = languageService.getLanguageIdByLanguageName(languageOrModeId.toLowerCase());
 
   if (modeId != null) {
     return modeId;
   }
 
-  if (modeService.isRegisteredMode(languageOrModeId)) {
+  if (languageService.isRegisteredLanguageId(languageOrModeId)) {
     return languageOrModeId;
   }
 
-  if (modeService.isRegisteredMode(languageOrModeId.toLowerCase())) {
+  if (languageService.isRegisteredLanguageId(languageOrModeId.toLowerCase())) {
     return languageOrModeId.toLowerCase();
   }
 
@@ -4397,6 +4340,7 @@ var colors = {
 	"statusBar.foreground": "#20252a",
 	"statusBar.border": "#dadada"
 };
+var semanticHighlighting = true;
 var semanticTokenColors = {
 	"*.static": {
 		fontStyle: "italic"
@@ -5004,11 +4948,12 @@ var defaultTMTheme = {
 	$schema: $schema,
 	type: type,
 	colors: colors,
+	semanticHighlighting: semanticHighlighting,
 	semanticTokenColors: semanticTokenColors,
 	tokenColors: tokenColors
 };
 
-const ThemeClass = monaco.editor.StaticServices.standaloneThemeService.get().getColorTheme().constructor;
+const ThemeClass = monaco.extra.StandaloneServices.get(monaco.editor.IStandaloneThemeService).getColorTheme().constructor;
 
 ThemeClass.prototype.getTokenStyleMetadata = function (type, modifiers, modelLanguage, useDefault, definitions) {
   const themeData = getThemeData(this.themeName);
@@ -5038,7 +4983,7 @@ configurationRegistry.registerDefaultConfigurations([{
 configurationRegistry.registerDefaultConfigurations([{
   overrides: extensions.configurationDefaults
 }]);
-const simpleConfigurationService = monaco.editor.StaticServices.configurationService.get();
+const simpleConfigurationService = monaco.extra.StandaloneServices.get(monaco.extra.IConfigurationService);
 const onConfigurationChanged = simpleConfigurationService.onDidChangeConfiguration;
 function getConfiguration(language) {
   let section = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'editor';
@@ -5104,9 +5049,11 @@ function openNewCodeEditor(model) {
   return editor;
 }
 
-class MultiEditorStandaloneCodeEditorServiceImpl extends monaco.extra.StandaloneCodeEditorServiceImpl {
-  constructor(styleSheet, contextKeyService, themeService, modelResolverService) {
-    super(styleSheet, contextKeyService, themeService);
+class MultiEditorStandaloneCodeEditorServiceImpl extends monaco.extra.StandaloneCodeEditorService {
+  constructor(contextKeyService, themeService, modelResolverService) {
+    super(contextKeyService, themeService);
+
+    _defineProperty(this, "modelResolverService", void 0);
 
     _defineProperty(this, "handlers", []);
 
@@ -5138,7 +5085,7 @@ class MultiEditorStandaloneCodeEditorServiceImpl extends monaco.extra.Standalone
     }
 
     if (modelEditor == null) {
-      const codeEditors = monaco.editor.StaticServices.codeEditorService.get().listCodeEditors();
+      const codeEditors = monaco.extra.StandaloneServices.get(monaco.extra.ICodeEditorService).listCodeEditors();
       modelEditor = codeEditors.find(editor => editor.getModel() === model);
     }
 
@@ -5190,13 +5137,20 @@ class MultiEditorStandaloneCodeEditorServiceImpl extends monaco.extra.Standalone
 
 class SimpleResolvedModel {
   constructor(model, readonly) {
-    _defineProperty(this, "disposed", false);
-
     this.model = model;
     this.readonly = readonly;
+
+    _defineProperty(this, "_onWillDispose", void 0);
+
+    _defineProperty(this, "disposed", false);
+
     this._onWillDispose = new monaco.Emitter();
   }
 
+  getLanguageId() {
+    return this.model.getLanguageId();
+  }
+
   get onWillDispose() {
     return this._onWillDispose.event;
   }
@@ -5348,7 +5302,7 @@ class ResourceModelCollection extends monaco.extra.ReferenceCollection {
 
 }
 
-class EditorModelResolverService extends monaco.extra.SimpleEditorModelResolverService {
+class TextModelService extends monaco.extra.StandaloneTextModelService {
   // eslint-disable-next-line @typescript-eslint/no-useless-constructor
   constructor(modelService) {
     super(modelService);
@@ -5465,7 +5419,7 @@ function setup$1(editor) {
     label: 'Fold all autofold regions',
     run: async editor => {
       const foldingController = monaco.extra.FoldingController.get(editor);
-      const foldingModelPromise = foldingController.getFoldingModel();
+      const foldingModelPromise = foldingController === null || foldingController === void 0 ? void 0 : foldingController.getFoldingModel();
 
       if (foldingModelPromise != null) {
         return foldingModelPromise.then(foldingModel => {
@@ -5488,34 +5442,34 @@ function setup(editor) {
   setup$1(editor);
 }
 
-monaco.editor.StaticServices.configurationService.get().updateValue('files.eol', '\n').catch(err => {
+const configurationService = monaco.extra.StandaloneServices.get(monaco.extra.IConfigurationService);
+configurationService.updateValue('files.eol', '\n').catch(err => {
   console.error('Unable to set file eol', err);
 });
-const editorModelResolverService = new EditorModelResolverService(monaco.editor.StaticServices.modelService.get());
-const multiEditorStandaloneCodeEditorServiceImpl = new MultiEditorStandaloneCodeEditorServiceImpl(null, monaco.editor.StaticServices.contextKeyService.get(), monaco.editor.StaticServices.standaloneThemeService.get(), editorModelResolverService);
+monaco.errorHandler.setUnexpectedErrorHandler(error => {
+  console.warn('Unexpected error', error);
+});
+const textModelService = new TextModelService(monaco.extra.StandaloneServices.get(monaco.extra.IModelService));
+const multiEditorStandaloneCodeEditorServiceImpl = new MultiEditorStandaloneCodeEditorServiceImpl(monaco.extra.StandaloneServices.get(monaco.extra.IContextKeyService), monaco.extra.StandaloneServices.get(monaco.editor.IStandaloneThemeService), textModelService);
+monaco.extra.StandaloneServices.initialize({
+  codeEditorService: multiEditorStandaloneCodeEditorServiceImpl,
+  textModelService
+});
 
 function createEditor(domElement, options, override) {
-  const editor = monaco.editor.create(domElement, options, _objectSpread2({
-    codeEditorService: multiEditorStandaloneCodeEditorServiceImpl,
-    textModelService: editorModelResolverService
-  }, override));
-  editorModelResolverService.setEditor(editor);
+  const editor = monaco.editor.create(domElement, options, override);
   setup(editor);
   return editor;
 }
 
 function registerTextModelContentProvider(scheme, provider) {
-  return editorModelResolverService.registerTextModelContentProvider(scheme, provider);
+  return textModelService.registerTextModelContentProvider(scheme, provider);
 }
 
 function registerEditorOpenHandler(handler) {
   return multiEditorStandaloneCodeEditorServiceImpl.registerEditorOpenHandler(handler);
 }
 
-function updateKeybindings(editor, bindings) {
-  editor._standaloneKeybindingService.setUserKeybindings(bindings);
-}
-
 function mapVimKeyBindings(keybindingConfig, mode) {
   if (keybindingConfig != null) {
     for (const item of keybindingConfig) {
@@ -5555,10 +5509,13 @@ function initVimMode(editor, statusBarElement) {
   return monacoVim.initVimMode(editor, statusBarElement);
 }
 
-function updateEditorKeybindings(editor) {
+const keybindingService = monaco.extra.StandaloneServices.get(monaco.extra.IKeybindingService);
+function updateKeybindings(bindings) {
+  keybindingService.setUserKeybindings(bindings);
+}
+function updateEditorKeybindingsMode(editor) {
   let keyBindingsMode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'classic';
   let statusBarElement = arguments.length > 2 ? arguments[2] : undefined;
-  let keyBindings = arguments.length > 3 ? arguments[3] : undefined;
 
   switch (keyBindingsMode) {
     case 'vim':
@@ -5575,11 +5532,8 @@ function updateEditorKeybindings(editor) {
 
     default:
       {
-        updateKeybindings(editor, keyBindings !== null && keyBindings !== void 0 ? keyBindings : []);
         return {
-          dispose: () => {
-            updateKeybindings(editor, []);
-          }
+          dispose: () => {}
         };
       }
   }
@@ -5805,4 +5759,4 @@ function hideCodeWithoutDecoration(editor, decorations) {
   };
 }
 
-export { addVSCodeTheme, createEditor, getConfiguration, getMonacoLanguage, getThemeData, hideCodeWithoutDecoration, lockCodeWithoutDecoration, onConfigurationChanged, registerConfigurations, registerDefaultConfigurations, registerEditorOpenHandler, registerTextModelContentProvider, updateEditorKeybindings, updateUserConfiguration };
+export { addVSCodeTheme, createEditor, getConfiguration, getMonacoLanguage, getThemeData, hideCodeWithoutDecoration, lockCodeWithoutDecoration, onConfigurationChanged, registerConfigurations, registerDefaultConfigurations, registerEditorOpenHandler, registerTextModelContentProvider, updateEditorKeybindingsMode, updateKeybindings, updateUserConfiguration };