@codingame/monaco-editor-wrapper 1.7.0 → 1.8.0

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

@@ -668,6 +668,25 @@ declare const _default: {
             };
         };
     }>;
+    sql: () => Promise<{
+        comments: {
+            lineComment: string;
+            blockComment: string[];
+        };
+        brackets: string[][];
+        autoClosingPairs: (string[] | {
+            open: string;
+            close: string;
+            notIn: string[];
+        })[];
+        surroundingPairs: string[][];
+        folding: {
+            markers: {
+                start: string;
+                end: string;
+            };
+        };
+    }>;
     swift: () => Promise<{
         comments: {
             lineComment: string;
@@ -1078,7 +1097,6 @@ declare const _default: {
             };
         };
     }>;
-    sql: () => Promise<{}>;
     scala: () => Promise<{
         comments: {
             lineComment: string;
@@ -1288,7 +1306,7 @@ declare const _default: {
     }>;
     rmd: () => Promise<{
         comments: {
-            lineComment: string;
+            blockComment: string[];
         };
         brackets: string[][];
         autoClosingPairs: string[][];

package/dist/languages/index.d.ts

@@ -1,3 +1,4 @@
 import './snippets';
 declare function getMonacoLanguage(languageOrModeId: string): string;
-export { getMonacoLanguage };
+declare function loadLanguage(languageId: string): Promise<void>;
+export { getMonacoLanguage, loadLanguage };

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

@@ -1,3 +1,3 @@
 import * as monaco from 'monaco-editor';
 import './semanticTokens';
-export declare function createTextMateTokensProvider(languageId: string): Promise<monaco.languages.ITokenizationSupport>;
+export declare function getOrCreateTextMateTokensProvider(languageId: string): Promise<monaco.languages.ITokenizationSupport>;

package/dist/main.js

@@ -2477,6 +2477,7 @@ function getOrCreateGrammarFactory() {
 }
 
 const languageService$2 = monaco.extra.StandaloneServices.get(monaco.languages.ILanguageService);
+
 async function createTextMateTokensProvider(languageId) {
   const grammarFactory = getOrCreateGrammarFactory();
   const encodedLanguageId = languageService$2.languageIdCodec.encodeLanguageId(languageId);
@@ -2498,6 +2499,18 @@ async function createTextMateTokensProvider(languageId) {
   return new CGTMTokenizationSupport(languageId, encodedLanguageId, tokenization, grammar);
 }
 
+const tokenizationSupports = new Map();
+function getOrCreateTextMateTokensProvider(languageId) {
+  let tokenizationSupportPromise = tokenizationSupports.get(languageId);
+
+  if (tokenizationSupportPromise == null) {
+    tokenizationSupportPromise = createTextMateTokensProvider(languageId);
+    tokenizationSupports.set(languageId, tokenizationSupportPromise);
+  }
+
+  return tokenizationSupportPromise;
+}
+
 var textMateLanguages = [
   {
     "id": "clojure",
@@ -4249,7 +4262,7 @@ for (const languageId of languagesIds) {
   });
   monaco.languages.setTokenizationSupportFactory(languageId, {
     createTokenizationSupport: async () => {
-      return createTextMateTokensProvider(languageId).catch(err => {
+      return getOrCreateTextMateTokensProvider(languageId).catch(err => {
         const monarchLoader = languageLoader[languageId];
 
         if (monarchLoader != null) {
@@ -4284,20 +4297,23 @@ function parseLanguageConfiguration(config) {
   });
 }
 
+async function loadLanguageConfiguration(languageId) {
+  const loader = loader$1[languageId];
+
+  if (loader != null) {
+    const configuration = await loader();
+    monaco.extra.handleLanguageConfiguration(languageId, addCustomFoldingMarkers(parseLanguageConfiguration(configuration)));
+  }
+}
+
 languageService.onDidEncounterLanguage(async languageId => {
   if (languageId === 'plaintext') {
     return;
   }
 
-  const loader = loader$1[languageId];
-
-  if (loader != null) {
-    loader().then(configuration => {
-      monaco.extra.handleLanguageConfiguration(languageId, addCustomFoldingMarkers(parseLanguageConfiguration(configuration)));
-    }).catch(error => {
-      console.error('Unable to load language configuration', error);
-    });
-  }
+  loadLanguageConfiguration(languageId).catch(error => {
+    console.error('Unable to load language configuration', error);
+  });
 });
 
 function getMonacoLanguage(languageOrModeId) {

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/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;
+}