@codingame/monaco-editor-wrapper 1.4.3 → 1.5.0

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%",
@@ -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

@@ -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);
   }
 
 }
@@ -2510,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);
@@ -2527,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,
@@ -2543,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);
 }
@@ -2790,7 +2767,8 @@ var textMateLanguages = [
       ".har",
       ".jslintrc",
       ".jsonld",
-      ".geojson"
+      ".geojson",
+      ".ipynb"
     ],
     "filenames": [
       "composer.lock",
@@ -3718,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",
@@ -4254,6 +4232,10 @@ const loader = {
 };
 
 class SimpleSnippetService {
+  constructor() {
+    _defineProperty(this, "_serviceBrand", void 0);
+  }
+
   isEnabled(snippet) {
     return snippet.snippetIdentifier != null || true;
   }
@@ -4294,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#'],
@@ -4309,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) {
@@ -4325,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;
   }
@@ -4336,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();
   }
 
@@ -4397,6 +4422,7 @@ var colors = {
 	"statusBar.foreground": "#20252a",
 	"statusBar.border": "#dadada"
 };
+var semanticHighlighting = true;
 var semanticTokenColors = {
 	"*.static": {
 		fontStyle: "italic"
@@ -5004,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);
@@ -5038,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';
@@ -5104,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", []);
 
@@ -5138,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);
     }
 
@@ -5190,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;
   }
@@ -5348,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);
@@ -5465,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 => {
@@ -5488,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"
 }
 };
 

package/dist/monaco.d.ts

@@ -1,5 +1,4 @@
 import * as monaco from 'monaco-editor';
-import './hacks';
 import './languages';
 import './theme';
 import { EditorOpenHandler } from './services/MultiEditorStandaloneCodeEditorService';

package/dist/r2.js

@@ -439,7 +439,7 @@ var repository = {
 	"function-declarations": {
 		patterns: [
 			{
-				match: "((?:`[^`\\\\]*(?:\\\\.[^`\\\\]*)*`)|(?:[[:alpha:].][[:alnum:]._]*))\\s*(<?<-|=(?!=))\\s*(function)",
+				match: "((?:`[^`\\\\]*(?:\\\\.[^`\\\\]*)*`)|(?:[[:alpha:].][[:alnum:]._]*))\\s*(<?<-|=(?!=))\\s*(function)(?!\\w)",
 				captures: {
 					"1": {
 						name: "entity.name.function.r"

package/dist/scalameta.js

@@ -4,7 +4,7 @@ var scalameta = [
     "properties": {
       "metals.serverVersion": {
         "type": "string",
-        "default": "0.11.1+97-0ef9a93b-SNAPSHOT",
+        "default": "0.11.1+114-58f06ff8-SNAPSHOT",
         "markdownDescription": "The version of the Metals server artifact. Requires reloading the window.\n\n**Change only if you know what you're doing**",
         "scope": 3
       },
@@ -169,6 +169,12 @@ var scalameta = [
         "type": "string",
         "markdownDescription": "Optional Eclipse format profile to use.",
         "scope": 3
+      },
+      "metals.suggestLatestUpgrade": {
+        "type": "boolean",
+        "default": false,
+        "markdownDescription": "Once in a day, notify if there are new server releases (including snapshots)",
+        "scope": 3
       }
     }
   }

package/dist/services/CustomFoldingRulesLanguageConfigurationService.d.ts

@@ -0,0 +1,4 @@
+import * as monaco from 'monaco-editor';
+export declare class CustomFoldingRulesLanguageConfigurationService extends monaco.languages.LanguageConfigurationService {
+    getLanguageConfiguration(languageId: string): monaco.languages.ResolvedLanguageConfiguration;
+}

package/dist/services/MultiEditorStandaloneCodeEditorService.d.ts

@@ -1,9 +1,9 @@
 import * as monaco from 'monaco-editor';
-import EditorModelResolverService from './EditorModelResolverService';
+import TextModelService from './TextModelService';
 export declare type EditorOpenHandler = (model: monaco.editor.ITextModel, input: monaco.extra.IResourceEditorInput, editor: monaco.editor.ICodeEditor, sideBySide?: boolean) => Promise<monaco.editor.ICodeEditor | null>;
-export default class MultiEditorStandaloneCodeEditorServiceImpl extends monaco.extra.StandaloneCodeEditorServiceImpl {
+export default class MultiEditorStandaloneCodeEditorServiceImpl extends monaco.extra.StandaloneCodeEditorService {
     private modelResolverService;
-    constructor(styleSheet: monaco.extra.GlobalStyleSheet | null, contextKeyService: monaco.extra.IContextKeyService, themeService: monaco.editor.IThemeService, modelResolverService: EditorModelResolverService);
+    constructor(contextKeyService: monaco.extra.IContextKeyService, themeService: monaco.editor.IThemeService, modelResolverService: TextModelService);
     private handlers;
     registerEditorOpenHandler(handler: EditorOpenHandler): monaco.IDisposable;
     openCodeEditor(input: monaco.extra.IResourceEditorInput, editor: monaco.editor.ICodeEditor, sideBySide?: boolean): Promise<monaco.editor.ICodeEditor | null>;

package/dist/services/TextModelService.d.ts

@@ -0,0 +1,25 @@
+import * as monaco from 'monaco-editor';
+export declare class SimpleResolvedModel implements monaco.extra.IResolvedTextEditorModel {
+    private model;
+    private readonly;
+    private readonly _onWillDispose;
+    constructor(model: monaco.editor.ITextModel, readonly: boolean);
+    getLanguageId(): string | undefined;
+    get onWillDispose(): monaco.IEvent<void>;
+    resolve(): Promise<void>;
+    get textEditorModel(): monaco.editor.ITextModel;
+    createSnapshot(): monaco.editor.ITextSnapshot;
+    isReadonly(): boolean;
+    private disposed;
+    dispose(): void;
+    isDisposed(): boolean;
+    isResolved(): boolean;
+    getMode(): string | undefined;
+}
+export default class TextModelService extends monaco.extra.StandaloneTextModelService {
+    private readonly resourceModelCollection;
+    private readonly asyncModelCollection;
+    constructor(modelService: monaco.extra.IModelService);
+    registerTextModelContentProvider(scheme: string, provider: monaco.extra.ITextModelContentProvider): monaco.IDisposable;
+    createModelReference(resource: monaco.Uri): Promise<monaco.extra.IReference<monaco.extra.IResolvedTextEditorModel>>;
+}

package/dist/theme/tools.d.ts

@@ -6,7 +6,8 @@ export interface IVSCodeTheme {
         [name: string]: string;
     };
     tokenColors: monaco.extra.ITextMateThemingRule[];
-    semanticTokenColors: Record<string, monaco.extra.ITokenColorizationSetting>;
+    semanticTokenColors?: Record<string, monaco.extra.ITokenColorizationSetting>;
+    semanticHighlighting?: boolean;
 }
 declare function convertTheme(theme: IVSCodeTheme): monaco.editor.IStandaloneThemeData;
 declare function fixVSCodeThemeColors(vscodeTheme: IVSCodeTheme): IVSCodeTheme;