@codingame/monaco-editor-wrapper 1.4.0 → 1.5.0

package/dist/jsx-tags.js

@@ -98,12 +98,61 @@ var surroundingPairs = [
 		"\""
 	]
 ];
+var wordPattern = {
+	pattern: "(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\$\\^\\&\\*\\(\\)\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:'\"\\,\\.\\<\\>\\/\\s]+)"
+};
+var onEnterRules = [
+	{
+		beforeText: {
+			pattern: "<(?!(?:area|base|br|col|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr))([_:\\w][_:\\w\\-.\\d]*)([^/>]*(?!/)>)[^<]*$",
+			flags: "i"
+		},
+		afterText: {
+			pattern: "^<\\/([_:\\w][_:\\w-.\\d]*)\\s*>$",
+			flags: "i"
+		},
+		action: {
+			indent: "indentOutdent"
+		}
+	},
+	{
+		beforeText: {
+			pattern: "<(?!(?:area|base|br|col|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr))([_:\\w][_:\\w\\-.\\d]*)([^/>]*(?!/)>)[^<]*$",
+			flags: "i"
+		},
+		action: {
+			indent: "indent"
+		}
+	},
+	{
+		beforeText: {
+			pattern: "^>$"
+		},
+		afterText: {
+			pattern: "/^<\\/([_:\\w][_:\\w-.\\d]*)\\s*>$",
+			flags: "i"
+		},
+		action: {
+			indent: "indentOutdent"
+		}
+	},
+	{
+		beforeText: {
+			pattern: "^>$"
+		},
+		action: {
+			indent: "indent"
+		}
+	}
+];
 var jsxTags = {
 	comments: comments,
 	brackets: brackets,
 	colorizedBracketPairs: colorizedBracketPairs,
 	autoClosingPairs: autoClosingPairs,
-	surroundingPairs: surroundingPairs
+	surroundingPairs: surroundingPairs,
+	wordPattern: wordPattern,
+	onEnterRules: onEnterRules
 };
 
-export { autoClosingPairs, brackets, colorizedBracketPairs, comments, jsxTags as default, surroundingPairs };
+export { autoClosingPairs, brackets, colorizedBracketPairs, comments, jsxTags as default, onEnterRules, surroundingPairs, wordPattern };

package/dist/languages/extensions/languageConfigurationLoader.d.ts

@@ -1,3 +1,11 @@
 import * as monaco from 'monaco-editor';
-declare const loader: Partial<Record<string, () => Promise<Record<string, monaco.extra.ILanguageConfiguration>>>>;
+export interface RawLanguageConfiguration extends Omit<monaco.extra.ILanguageConfiguration, 'folding'> {
+    folding?: Omit<monaco.extra.ILanguageConfiguration['folding'], 'markers'> & {
+        markers?: {
+            start: string;
+            end: string;
+        };
+    };
+}
+declare const loader: Partial<Record<string, () => Promise<RawLanguageConfiguration>>>;
 export default loader;

package/dist/languages/textMate/CGTMTokenizationSupport.d.ts

@@ -1,8 +1,8 @@
 import * as monaco from 'monaco-editor';
 import { IGrammar } from 'vscode-textmate';
-export default class CGTMTokenizationSupport extends monaco.extra.TMTokenizationSupport {
+export default class CGTMTokenizationSupport extends monaco.extra.TMTokenizationSupportWithLineLimit {
     private languageId;
     private grammar;
     constructor(languageId: string, encodedLanguageId: monaco.languages.LanguageId, actual: monaco.extra.TMTokenization, grammar: IGrammar);
-    tokenize(line: string, hasEOL: boolean, state: monaco.languages.IState, offsetDelta: number): monaco.TokenizationResult;
+    tokenize(line: string, hasEOL: boolean, state: monaco.languages.IState): monaco.TokenizationResult;
 }

package/dist/lua2.js

@@ -226,6 +226,16 @@ var lua = [
             ],
             "type": "string"
           },
+          "codestyle-check": {
+            "default": "None",
+            "description": "%config.diagnostics.codestyle-check%",
+            "enum": [
+              "Any",
+              "Opened",
+              "None"
+            ],
+            "type": "string"
+          },
           "count-down-loop": {
             "default": "Any",
             "description": "%config.diagnostics.count-down-loop%",
@@ -640,6 +650,17 @@ var lua = [
             ],
             "type": "string"
           },
+          "codestyle-check": {
+            "default": "Warning",
+            "description": "%config.diagnostics.codestyle-check%",
+            "enum": [
+              "Error",
+              "Warning",
+              "Information",
+              "Hint"
+            ],
+            "type": "string"
+          },
           "count-down-loop": {
             "default": "Warning",
             "description": "%config.diagnostics.count-down-loop%",
@@ -1031,7 +1052,7 @@ var lua = [
         "type": "object"
       },
       "Lua.diagnostics.workspaceDelay": {
-        "default": 3,
+        "default": 3000,
         "markdownDescription": "Latency (milliseconds) for workspace diagnostics. When you start the workspace, or edit any file, the entire workspace will be re-diagnosed in the background. Set to negative to disable workspace diagnostics.",
         "scope": 4,
         "type": "integer"
@@ -1042,6 +1063,17 @@ var lua = [
         "scope": 4,
         "type": "integer"
       },
+      "Lua.format.defaultConfig": {
+        "markdownDescription": "%config.format.defaultConfig%",
+        "scope": 4,
+        "type": "object"
+      },
+      "Lua.format.enable": {
+        "default": "true",
+        "markdownDescription": "Enable code formatter.",
+        "scope": 4,
+        "type": "boolean"
+      },
       "Lua.hint.arrayIndex": {
         "default": "Auto",
         "enum": [
@@ -1428,6 +1460,9 @@ var lua = [
         "default": null,
         "markdownDescription": "Enable telemetry to send your editor information and error logs over the network. Read our privacy policy [here](https://github.com/sumneko/lua-language-server/wiki/Privacy-Policy).\n",
         "scope": 4,
+        "tags": [
+          "telemetry"
+        ],
         "type": [
           "boolean",
           "null"

package/dist/main.js

@@ -4,48 +4,24 @@ import { _ as _objectSpread2, a as _defineProperty } from './_rollupPluginBabelH
 import onigFile from 'vscode-oniguruma/release/onig.wasm';
 import { loadWASM, createOnigScanner, createOnigString } from 'vscode-oniguruma';
 import './worker.js';
-import EmacsExtension from 'monaco-emacs';
+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);
   }
 
 }
@@ -825,6 +801,10 @@ var rawGrammars = [
     "language": "tasty",
     "scopeName": "source.tasty"
   },
+  {
+    "language": "buildtarget",
+    "scopeName": "source.buildtarget"
+  },
   {
     "language": "COBOL",
     "scopeName": "source.cobol",
@@ -1244,6 +1224,9 @@ const loader$2 = {
   'source.tasty': async () => (await import(
   /* webpackChunkName: "grammar-source-tasty" */
   './tasty.js').then(module => module)).default,
+  'source.buildtarget': async () => (await import(
+  /* webpackChunkName: "grammar-source-buildtarget" */
+  './buildtarget.js').then(module => module)).default,
   'source.cobol': async () => (await import(
   /* webpackChunkName: "grammar-source-cobol" */
   './COBOL.tmLanguage.js').then(module => module)).default,
@@ -2503,8 +2486,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);
@@ -2520,10 +2503,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,
@@ -2536,7 +2519,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);
 }
@@ -2783,7 +2767,8 @@ var textMateLanguages = [
       ".har",
       ".jslintrc",
       ".jsonld",
-      ".geojson"
+      ".geojson",
+      ".ipynb"
     ],
     "filenames": [
       "composer.lock",
@@ -3523,6 +3508,12 @@ var textMateLanguages = [
       ".tasty-decoded"
     ]
   },
+  {
+    "id": "buildtarget",
+    "extensions": [
+      ".metals-buildtarget"
+    ]
+  },
   {
     "id": "COBOL",
     "extensions": [
@@ -3705,12 +3696,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",
@@ -3790,7 +3781,8 @@ var textMateLanguages = [
       "R DCF"
     ],
     "filenames": [
-      "DESCRIPTION"
+      "DESCRIPTION",
+      ".lintr"
     ]
   },
   {
@@ -4240,6 +4232,10 @@ const loader = {
 };
 
 class SimpleSnippetService {
+  constructor() {
+    _defineProperty(this, "_serviceBrand", void 0);
+  }
+
   isEnabled(snippet) {
     return snippet.snippetIdentifier != null || true;
   }
@@ -4280,8 +4276,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#'],
@@ -4295,7 +4313,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) {
@@ -4311,9 +4329,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;
   }
@@ -4322,39 +4375,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();
   }
 
@@ -4383,6 +4422,7 @@ var colors = {
 	"statusBar.foreground": "#20252a",
 	"statusBar.border": "#dadada"
 };
+var semanticHighlighting = true;
 var semanticTokenColors = {
 	"*.static": {
 		fontStyle: "italic"
@@ -4990,11 +5030,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);
@@ -5024,7 +5065,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';
@@ -5090,9 +5131,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", []);
 
@@ -5124,7 +5167,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);
     }
 
@@ -5176,13 +5219,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;
   }
@@ -5334,7 +5384,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);
@@ -5451,7 +5501,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 => {
@@ -5474,24 +5524,28 @@ 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) {

package/dist/markdown-basics-markdown.js

@@ -97,6 +97,24 @@ var markdownBasicsMarkdown = {
 	prefix: "strikethrough",
 	body: "~~${1:${TM_SELECTED_TEXT}}~~",
 	description: "Insert strikethrough"
+},
+	"Insert inline math": {
+	prefix: [
+		"inline math"
+	],
+	body: "$${1:${TM_SELECTED_TEXT}}$",
+	description: "Insert inline math"
+},
+	"Insert fenced math": {
+	prefix: [
+		"fenced math"
+	],
+	body: [
+		"$$",
+		"${1:${TM_SELECTED_TEXT}}",
+		"$$"
+	],
+	description: "Insert fenced math"
 }
 };