@kusto/monaco-kusto 6.1.2 → 7.0.0

package/release/dev/monaco.contribution.js

@@ -1,11 +1,80 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.1.2(4c9ec21ad04b49f9f8e8a8f7fe773fe9a8b47334)
+ * monaco-kusto version: 7.0.0(f23f8fe8dd705f8413d0d094c76eb0af2131aace)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/editor/editor.main'], (function (require, exports, editor_main) { 'use strict';
+define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/editor/editor.main'], (function (require, exports, monaco) { 'use strict';
+
+    function _interopNamespaceDefault(e) {
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n.default = e;
+        return Object.freeze(n);
+    }
+
+    var monaco__namespace = /*#__PURE__*/_interopNamespaceDefault(monaco);
+
+    function getCurrentCommandRange(editor, cursorPosition) {
+      var zeroBasedCursorLineNumber = cursorPosition.lineNumber - 1;
+      var lines = editor.getModel().getLinesContent();
+      var commandOrdinal = 0;
+      var linesWithCommandOrdinal = [];
+      for (var lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+        var isEmptyLine = lines[lineNumber].trim() === '';
+        if (isEmptyLine) {
+          // increase commandCounter - we'll be starting a new command.
+          linesWithCommandOrdinal.push({
+            commandOrdinal: commandOrdinal++,
+            lineNumber: lineNumber
+          });
+        } else {
+          linesWithCommandOrdinal.push({
+            commandOrdinal: commandOrdinal,
+            lineNumber: lineNumber
+          });
+        }
+
+        // No need to keep scanning if we're past our line and we've seen an empty line.
+        if (lineNumber > zeroBasedCursorLineNumber && commandOrdinal > linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal) {
+          break;
+        }
+      }
+      var currentCommandOrdinal = linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal;
+      var currentCommandLines = linesWithCommandOrdinal.filter(function (line) {
+        return line.commandOrdinal === currentCommandOrdinal;
+      });
+      var currentCommandStartLine = currentCommandLines[0].lineNumber + 1;
+      var currentCommandEndLine = currentCommandLines[currentCommandLines.length - 1].lineNumber + 1;
+
+      // End-column of 1 means no characters will be highlighted - since columns are 1-based in monaco apis.
+      // Start-column of 1 and End column of 2 means 1st character is selected.
+      // Thus if a line has n column and we need to provide n+1 so that the entire line will be highlighted.
+      var commandEndColumn = lines[currentCommandEndLine - 1].length + 1;
+      return new monaco__namespace.Range(currentCommandStartLine, 1, currentCommandEndLine, commandEndColumn);
+    }
+
+    /**
+     * Extending ICode editor to contain additional kusto-specific methods.
+     * note that the extend method needs to be called at least once to take affect, otherwise this here code is useless.
+     */
+    function extend(editor) {
+      var proto = Object.getPrototypeOf(editor);
+      proto.getCurrentCommandRange = function (cursorPosition) {
+        getCurrentCommandRange(this, cursorPosition);
+      };
+    }
 
     function _typeof$2(obj) { "@babel/helpers - typeof"; return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof$2(obj); }
     function _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
@@ -14,6 +83,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     function _defineProperty$2(obj, key, value) { key = _toPropertyKey$2(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
     function _toPropertyKey$2(arg) { var key = _toPrimitive$2(arg, "string"); return _typeof$2(key) === "symbol" ? key : String(key); }
     function _toPrimitive$2(input, hint) { if (_typeof$2(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof$2(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
     /**
      * Highlights the command that surround cursor location
      */
@@ -58,7 +128,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
             this.decorations = this.editor.deltaDecorations(this.decorations, []);
             return;
           }
-          var commandRange = this.editor.getCurrentCommandRange(changeEvent.selection.getStartPosition());
+          var commandRange = getCurrentCommandRange(this.editor, changeEvent.selection.getStartPosition());
           var decorations = [{
             range: commandRange,
             options: KustoCommandHighlighter.CURRENT_COMMAND_HIGHLIGHT
@@ -92,7 +162,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
           return;
         }
         // Theoretically you would expect this code to run only once in onDidCreateEditor.
-        // Turns out that onDidCreateEditor is fired before the IStandaloneEditor is completely created (it is emmited by
+        // Turns out that onDidCreateEditor is fired before the IStandaloneEditor is completely created (it is emitted by
         // the super ctor before the child ctor was able to fully run).
         // Thus we don't have  a key binding provided yet when onDidCreateEditor is run, which is essential to call addAction.
         // By adding the action here in onDidChangeCursorSelection we're making sure that the editor has a key binding provider,
@@ -101,7 +171,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
           editor.addAction({
             id: 'editor.action.kusto.formatCurrentCommand',
             label: 'Format Command Under Cursor',
-            keybindings: [monaco.KeyMod.chord(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyK, monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyF)],
+            keybindings: [monaco__namespace.KeyMod.chord(monaco__namespace.KeyMod.CtrlCmd | monaco__namespace.KeyCode.KeyK, monaco__namespace.KeyMod.CtrlCmd | monaco__namespace.KeyCode.KeyF)],
             run: function run(ed) {
               editor.trigger('KustoCommandFormatter', 'editor.action.formatSelection', null);
             },
@@ -112,52 +182,6 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
       });
     });
 
-    /**
-     * Extending ICode editor to contain additional kusto-specific methods.
-     * note that the extend method needs to be called at least once to take affect, otherwise this here code is useless.
-     */
-    function extend(editor) {
-      var proto = Object.getPrototypeOf(editor);
-      proto.getCurrentCommandRange = function (cursorPosition) {
-        var zeroBasedCursorLineNumber = cursorPosition.lineNumber - 1;
-        var lines = this.getModel().getLinesContent();
-        var commandOrdinal = 0;
-        var linesWithCommandOrdinal = [];
-        for (var lineNumber = 0; lineNumber < lines.length; lineNumber++) {
-          var isEmptyLine = lines[lineNumber].trim() === '';
-          if (isEmptyLine) {
-            // increase commandCounter - we'll be starting a new command.
-            linesWithCommandOrdinal.push({
-              commandOrdinal: commandOrdinal++,
-              lineNumber: lineNumber
-            });
-          } else {
-            linesWithCommandOrdinal.push({
-              commandOrdinal: commandOrdinal,
-              lineNumber: lineNumber
-            });
-          }
-
-          // No need to keep scanning if we're past our line and we've seen an empty line.
-          if (lineNumber > zeroBasedCursorLineNumber && commandOrdinal > linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal) {
-            break;
-          }
-        }
-        var currentCommandOrdinal = linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal;
-        var currentCommandLines = linesWithCommandOrdinal.filter(function (line) {
-          return line.commandOrdinal === currentCommandOrdinal;
-        });
-        var currentCommandStartLine = currentCommandLines[0].lineNumber + 1;
-        var currentCommandEndLine = currentCommandLines[currentCommandLines.length - 1].lineNumber + 1;
-
-        // End-column of 1 means no characters will be highlighted - since columns are 1-based in monaco apis.
-        // Start-column of 1 and End column of 2 means 1st character is selected.
-        // Thus if a line has n column and we need to provide n+1 so that the entire line will be highlighted.
-        var commandEndColumn = lines[currentCommandEndLine - 1].length + 1;
-        return new monaco.Range(currentCommandStartLine, 1, currentCommandEndLine, commandEndColumn);
-      };
-    }
-
     function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
     function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
     function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
@@ -167,13 +191,12 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 
     // --- Kusto configuration and defaults ---------
-
     var LanguageServiceDefaultsImpl = /*#__PURE__*/function () {
       // in milliseconds. For example - this is 2 minutes 2 * 60 * 1000
 
       function LanguageServiceDefaultsImpl(languageSettings) {
         _classCallCheck(this, LanguageServiceDefaultsImpl);
-        _defineProperty(this, "_onDidChange", new monaco.Emitter());
+        _defineProperty(this, "_onDidChange", new monaco__namespace.Emitter());
         this.setLanguageSettings(languageSettings);
         // default to never kill worker when idle.
         // reason: when killing worker - schema gets lost. We transmit the schema back to main process when killing
@@ -245,251 +268,244 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     function withMode(callback) {
       new Promise(function (resolve, reject) { require(['./kustoMode'], resolve, reject); }).then(callback);
     }
-    function setupMonacoKusto(monacoInstance) {
-      var kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
-      function createAPI() {
-        return {
-          kustoDefaults: kustoDefaults,
-          getKustoWorker: getKustoWorker
-        };
-      }
-      monacoInstance.languages.kusto = createAPI();
-      monacoInstance.languages.onLanguage('kusto', function () {
-        withMode(function (mode) {
-          return mode.setupMode(kustoDefaults, monacoInstance);
-        });
-      });
-      monacoInstance.languages.register({
-        id: 'kusto',
-        extensions: ['.csl', '.kql']
-      });
-      monacoInstance.editor.defineTheme('kusto-light', {
-        base: 'vs',
-        inherit: true,
-        rules: [{
-          token: 'comment',
-          foreground: '008000'
-        },
-        // CommentToken Green
-        {
-          token: 'variable.predefined',
-          foreground: '800080'
-        },
-        // CalculatedColumnToken Purple
-        {
-          token: 'function',
-          foreground: '0000FF'
-        },
-        // FunctionNameToken Blue
-        {
-          token: 'operator.sql',
-          foreground: 'CC3700'
-        },
-        // _WAS_ OperatorToken OrangeRed, but wasn't accessible.
-        {
-          token: 'string',
-          foreground: 'B22222'
-        },
-        // StringLiteralToken Firebrick
-        {
-          token: 'operator.scss',
-          foreground: '0000FF'
-        },
-        // SubOperatorToken Blue
-        {
-          token: 'variable',
-          foreground: 'C71585'
-        },
-        // TableColumnToken MediumVioletRed
-        {
-          token: 'variable.parameter',
-          foreground: '9932CC'
-        },
-        // TableToken DarkOrchid
-        {
-          token: '',
-          foreground: '000000'
-        },
-        // UnknownToken, PlainTextToken  Black
-        {
-          token: 'type',
-          foreground: '0000FF'
-        },
-        // DataTypeToken Blue
-        {
-          token: 'tag',
-          foreground: '0000FF'
-        },
-        // ControlCommandToken Blue
-        {
-          token: 'annotation',
-          foreground: '2B91AF'
-        },
-        // QueryParametersToken FF2B91AF
-        {
-          token: 'keyword',
-          foreground: '0000FF'
-        },
-        // CslCommandToken, PluginToken Blue
-        {
-          token: 'number',
-          foreground: '191970'
-        },
-        // LetVariablesToken MidnightBlue
-        {
-          token: 'annotation',
-          foreground: '9400D3'
-        },
-        // ClientDirectiveToken DarkViolet
-        {
-          token: 'invalid',
-          background: 'cd3131'
-        }],
-        colors: {}
-      });
-      monacoInstance.editor.defineTheme('kusto-dark', {
-        base: 'vs-dark',
-        inherit: true,
-        rules: [{
-          token: 'comment',
-          foreground: '608B4E'
-        },
-        // CommentToken Green
-        {
-          token: 'variable.predefined',
-          foreground: '4ec9b0'
-        },
-        // CalculatedColumnToken Purple
-        {
-          token: 'function',
-          foreground: 'dcdcaa'
-        },
-        // FunctionNameToken Blue
-        {
-          token: 'operator.sql',
-          foreground: '9cdcfe'
-        },
-        // OperatorToken OrangeRed
-        {
-          token: 'string',
-          foreground: 'ce9178'
-        },
-        // StringLiteralToken Firebrick
-        {
-          token: 'operator.scss',
-          foreground: '569cd6'
-        },
-        // SubOperatorToken Blue
-        {
-          token: 'variable',
-          foreground: '4ec9b0'
-        },
-        // TableColumnToken MediumVioletRed
-        {
-          token: 'variable.parameter',
-          foreground: 'c586c0'
-        },
-        // TableToken DarkOrchid
-        {
-          token: '',
-          foreground: 'd4d4d4'
-        },
-        // UnknownToken, PlainTextToken  Black
-        {
-          token: 'type',
-          foreground: '569cd6'
-        },
-        // DataTypeToken Blue
-        {
-          token: 'tag',
-          foreground: '569cd6'
-        },
-        // ControlCommandToken Blue
-        {
-          token: 'annotation',
-          foreground: '9cdcfe'
-        },
-        // QueryParametersToken FF2B91AF
-        {
-          token: 'keyword',
-          foreground: '569cd6'
-        },
-        // CslCommandToken, PluginToken Blue
-        {
-          token: 'number',
-          foreground: 'd7ba7d'
-        },
-        // LetVariablesToken MidnightBlue
-        {
-          token: 'annotation',
-          foreground: 'b5cea8'
-        },
-        // ClientDirectiveToken DarkViolet
-        {
-          token: 'invalid',
-          background: 'cd3131'
-        }],
-        colors: {
-          // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
-        }
-      });
-      monacoInstance.editor.defineTheme('kusto-dark2', {
-        base: 'vs-dark',
-        inherit: true,
-        rules: [],
-        colors: {
-          // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
-          'editor.background': '#1B1A19',
-          // gray 200
-          'editorSuggestWidget.selectedBackground': '#004E8C'
-        }
+    var kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
+    monaco__namespace.languages.onLanguage('kusto', function () {
+      withMode(function (mode) {
+        return mode.setupMode(kustoDefaults, monaco__namespace);
       });
+    });
+    monaco__namespace.languages.register({
+      id: 'kusto',
+      extensions: ['.csl', '.kql']
+    });
+    monaco__namespace.editor.defineTheme('kusto-light', {
+      base: 'vs',
+      inherit: true,
+      rules: [{
+        token: 'comment',
+        foreground: '008000'
+      },
+      // CommentToken Green
+      {
+        token: 'variable.predefined',
+        foreground: '800080'
+      },
+      // CalculatedColumnToken Purple
+      {
+        token: 'function',
+        foreground: '0000FF'
+      },
+      // FunctionNameToken Blue
+      {
+        token: 'operator.sql',
+        foreground: 'CC3700'
+      },
+      // _WAS_ OperatorToken OrangeRed, but wasn't accessible.
+      {
+        token: 'string',
+        foreground: 'B22222'
+      },
+      // StringLiteralToken Firebrick
+      {
+        token: 'operator.scss',
+        foreground: '0000FF'
+      },
+      // SubOperatorToken Blue
+      {
+        token: 'variable',
+        foreground: 'C71585'
+      },
+      // TableColumnToken MediumVioletRed
+      {
+        token: 'variable.parameter',
+        foreground: '9932CC'
+      },
+      // TableToken DarkOrchid
+      {
+        token: '',
+        foreground: '000000'
+      },
+      // UnknownToken, PlainTextToken  Black
+      {
+        token: 'type',
+        foreground: '0000FF'
+      },
+      // DataTypeToken Blue
+      {
+        token: 'tag',
+        foreground: '0000FF'
+      },
+      // ControlCommandToken Blue
+      {
+        token: 'annotation',
+        foreground: '2B91AF'
+      },
+      // QueryParametersToken FF2B91AF
+      {
+        token: 'keyword',
+        foreground: '0000FF'
+      },
+      // CslCommandToken, PluginToken Blue
+      {
+        token: 'number',
+        foreground: '191970'
+      },
+      // LetVariablesToken MidnightBlue
+      {
+        token: 'annotation',
+        foreground: '9400D3'
+      },
+      // ClientDirectiveToken DarkViolet
+      {
+        token: 'invalid',
+        background: 'cd3131'
+      }],
+      colors: {}
+    });
+    monaco__namespace.editor.defineTheme('kusto-dark', {
+      base: 'vs-dark',
+      inherit: true,
+      rules: [{
+        token: 'comment',
+        foreground: '608B4E'
+      },
+      // CommentToken Green
+      {
+        token: 'variable.predefined',
+        foreground: '4ec9b0'
+      },
+      // CalculatedColumnToken Purple
+      {
+        token: 'function',
+        foreground: 'dcdcaa'
+      },
+      // FunctionNameToken Blue
+      {
+        token: 'operator.sql',
+        foreground: '9cdcfe'
+      },
+      // OperatorToken OrangeRed
+      {
+        token: 'string',
+        foreground: 'ce9178'
+      },
+      // StringLiteralToken Firebrick
+      {
+        token: 'operator.scss',
+        foreground: '569cd6'
+      },
+      // SubOperatorToken Blue
+      {
+        token: 'variable',
+        foreground: '4ec9b0'
+      },
+      // TableColumnToken MediumVioletRed
+      {
+        token: 'variable.parameter',
+        foreground: 'c586c0'
+      },
+      // TableToken DarkOrchid
+      {
+        token: '',
+        foreground: 'd4d4d4'
+      },
+      // UnknownToken, PlainTextToken  Black
+      {
+        token: 'type',
+        foreground: '569cd6'
+      },
+      // DataTypeToken Blue
+      {
+        token: 'tag',
+        foreground: '569cd6'
+      },
+      // ControlCommandToken Blue
+      {
+        token: 'annotation',
+        foreground: '9cdcfe'
+      },
+      // QueryParametersToken FF2B91AF
+      {
+        token: 'keyword',
+        foreground: '569cd6'
+      },
+      // CslCommandToken, PluginToken Blue
+      {
+        token: 'number',
+        foreground: 'd7ba7d'
+      },
+      // LetVariablesToken MidnightBlue
+      {
+        token: 'annotation',
+        foreground: 'b5cea8'
+      },
+      // ClientDirectiveToken DarkViolet
+      {
+        token: 'invalid',
+        background: 'cd3131'
+      }],
+      colors: {
+        // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
+      }
+    });
+    monaco__namespace.editor.defineTheme('kusto-dark2', {
+      base: 'vs-dark',
+      inherit: true,
+      rules: [],
+      colors: {
+        // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
+        'editor.background': '#1B1A19',
+        // gray 200
+        'editorSuggestWidget.selectedBackground': '#004E8C'
+      }
+    });
 
-      // Initialize kusto specific language features that don't currently have a natural way to extend using existing apis.
-      // Most other language features are initialized in kustoMode.ts
-      monacoInstance.editor.onDidCreateEditor(function (editor) {
-        // hook up extension methods to editor.
-        extend(editor);
-        new KustoCommandHighlighter(editor);
-        if (isStandaloneCodeEditor(editor)) {
-          new KustoCommandFormatter(editor);
+    // Initialize kusto specific language features that don't currently have a natural way to extend using existing apis.
+    // Most other language features are initialized in kustoMode.ts
+    monaco__namespace.editor.onDidCreateEditor(function (editor) {
+      // hook up extension methods to editor.
+      extend(editor);
+      new KustoCommandHighlighter(editor);
+      if (isStandaloneCodeEditor(editor)) {
+        new KustoCommandFormatter(editor);
+      }
+      triggerSuggestDialogWhenCompletionItemSelected(editor);
+    });
+    function triggerSuggestDialogWhenCompletionItemSelected(editor) {
+      editor.onDidChangeCursorSelection(function (event) {
+        // checking the condition inside the event makes sure we will stay up to date when kusto configuration changes at runtime.
+        if (kustoDefaults && kustoDefaults.languageSettings && kustoDefaults.languageSettings.openSuggestionDialogAfterPreviousSuggestionAccepted) {
+          var didAcceptSuggestion = event.source === 'snippet' && event.reason === monaco__namespace.editor.CursorChangeReason.NotSet;
+          // If the word at the current position is not null - meaning we did not add a space after completion.
+          // In this case we don't want to activate the eager mode, since it will display the current selected word..
+          if (!didAcceptSuggestion || editor.getModel().getWordAtPosition(event.selection.getPosition()) !== null) {
+            return;
+          }
+          event.selection;
+          // OK so now we in a situation where we know a suggestion was selected and we want to trigger another one.
+          // the only problem is that the suggestion widget itself listens to this same event in order to know it needs to close.
+          // The only problem is that we're ahead in line, so we're triggering a suggest operation that will be shut down once
+          // the next callback is called. This is why we're waiting here - to let all the callbacks run synchronously and be
+          // the 'last' subscriber to run. Granted this is hacky, but until monaco provides a specific event for suggestions,
+          // this is the best we have.
+          setTimeout(function () {
+            return editor.trigger('monaco-kusto', 'editor.action.triggerSuggest', {});
+          }, 10);
         }
-        triggerSuggestDialogWhenCompletionItemSelected(editor);
       });
-      function triggerSuggestDialogWhenCompletionItemSelected(editor) {
-        editor.onDidChangeCursorSelection(function (event) {
-          // checking the condition inside the event makes sure we will stay up to date when kusto configuration changes at runtime.
-          if (kustoDefaults && kustoDefaults.languageSettings && kustoDefaults.languageSettings.openSuggestionDialogAfterPreviousSuggestionAccepted) {
-            var didAcceptSuggestion = event.source === 'snippet' && event.reason === monaco.editor.CursorChangeReason.NotSet;
-            // If the word at the current position is not null - meaning we did not add a space after completion.
-            // In this case we don't want to activate the eager mode, since it will display the current selected word..
-            if (!didAcceptSuggestion || editor.getModel().getWordAtPosition(event.selection.getPosition()) !== null) {
-              return;
-            }
-            event.selection;
-            // OK so now we in a situation where we know a suggestion was selected and we want to trigger another one.
-            // the only problem is that the suggestion widget itself listens to this same event in order to know it needs to close.
-            // The only problem is that we're ahead in line, so we're triggering a suggest operation that will be shut down once
-            // the next callback is called. This is why we're waiting here - to let all the callbacks run synchronously and be
-            // the 'last' subscriber to run. Granted this is hacky, but until monaco provides a specific event for suggestions,
-            // this is the best we have.
-            setTimeout(function () {
-              return editor.trigger('monaco-kusto', 'editor.action.triggerSuggest', {});
-            }, 10);
-          }
-        });
-      }
     }
     function isStandaloneCodeEditor(editor) {
       return editor.addAction !== undefined;
     }
+    var globalApi = {
+      kustoDefaults: kustoDefaults,
+      getKustoWorker: getKustoWorker,
+      getCurrentCommandRange: getCurrentCommandRange
+    };
+    monaco__namespace.languages.kusto = globalApi;
 
-    // --- Registration to monaco editor ---
-    if (monaco.editor) {
-      setupMonacoKusto(monaco);
-    }
-
-    exports.LanguageServiceDefaultsImpl = LanguageServiceDefaultsImpl;
-    exports.setupMonacoKusto = setupMonacoKusto;
+    exports.getCurrentCommandRange = getCurrentCommandRange;
+    exports.getKustoWorker = getKustoWorker;
+    exports.kustoDefaults = kustoDefaults;
 
 }));

package/release/esm/commandFormatter.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="monaco-editor/monaco" />
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 export default class KustoCommandFormatter {
     private editor;
     private actionAdded;

package/release/esm/commandHighlighter.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="../monaco" />
-/// <reference types="monaco-editor/monaco" />
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 /**
  * Highlights the command that surround cursor location
  */