@kusto/monaco-kusto 6.1.1 → 6.2.0

package/release/dev/monaco.contribution.js

@@ -1,11 +1,30 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.1.1(678731e78268dbe877b517e302fa7db86fd96b3c)
+ * monaco-kusto version: 6.2.0(8e26147bc7c3b5a7a3bc6ee55311dfa0b612c10c)
  * 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$1) { '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$1);
 
     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"); } }
@@ -92,7 +111,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,
@@ -165,13 +184,14 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     function _defineProperty(obj, key, value) { key = _toPropertyKey(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(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
     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
@@ -243,251 +263,242 @@ 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;
     }
-
-    // --- Registration to monaco editor ---
-    if (monaco.editor) {
-      setupMonacoKusto(monaco);
-    }
+    monaco__namespace.languages.kusto = {
+      kustoDefaults: kustoDefaults,
+      getKustoWorker: getKustoWorker
+    };
 
     exports.LanguageServiceDefaultsImpl = LanguageServiceDefaultsImpl;
-    exports.setupMonacoKusto = setupMonacoKusto;
+    exports.getKustoWorker = getKustoWorker;
+    exports.kustoDefaults = kustoDefaults;
 
 }));

package/release/esm/kusto.worker.js

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.1.1(678731e78268dbe877b517e302fa7db86fd96b3c)
+ * monaco-kusto version: 6.2.0(8e26147bc7c3b5a7a3bc6ee55311dfa0b612c10c)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -17,14 +17,12 @@ import '@kusto/language-service-next/Kusto.Language.Bridge.min';
 
 // an input parameter either be a scalar in which case it has a name, type and cslType, or it can be columnar, in which case
 // it will have a name, and a list of scalar types which are the column types.
-
 /**
  * Schema types:
  * Engine – The main schema type. Contains clusters, databases, tables, table columns and functions.
  * Cluster Manager – Internal only. A schema for clusters that manages other clusters.
  * Data Management – Internal only. A schema for ingestion point operations.
  */
-
 const dotnetTypeToKustoType = {
   'System.SByte': 'bool',
   'System.Byte': 'uint8',
@@ -364,7 +362,11 @@ class KustoLanguageService {
       const lsItem = ls.CompletionItem.create(kItem.DisplayText);
 
       // Adding to columns a prefix to their sortText so they will appear first in the list
-      const sortTextPrefix = lsItem.kind === ls.CompletionItemKind.Field ? 0 : itemsAsArray.length;
+      let sortTextPrefix = lsItem.kind === ls.CompletionItemKind.Field ? 0 : itemsAsArray.length;
+      const countOfWords = lsItem.label.split('_').length;
+      // We always want results with multiple words to show after shorter options.
+      // For example: to show "count_distinct" after "count"
+      sortTextPrefix = sortTextPrefix * countOfWords;
       const startPosition = document.positionAt(completionItems.EditStart);
       const endPosition = document.positionAt(completionItems.EditStart + completionItems.EditLength);
       lsItem.textEdit = ls.TextEdit.replace(ls.Range.create(startPosition, endPosition), textToInsert);

package/release/esm/kustoMode.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="../monaco" />
 /// <reference types="monaco-editor/monaco" />
 import type { LanguageServiceDefaultsImpl } from './monaco.contribution';
-import { WorkerAccessor } from './languageFeatures';
+import * as languageFeatures from './languageFeatures';
 /**
  * Called when Kusto language is first needed (a model has the language set)
  * @param defaults
  */
-export declare function setupMode(defaults: LanguageServiceDefaultsImpl, monacoInstance: typeof monaco): WorkerAccessor;
-export declare function getKustoWorker(): Promise<WorkerAccessor>;
+export declare function setupMode(defaults: LanguageServiceDefaultsImpl, monacoInstance: typeof globalThis.monaco): languageFeatures.WorkerAccessor;
+export declare function getKustoWorker(): Promise<languageFeatures.WorkerAccessor>;

package/release/esm/kustoMode.js

@@ -1,10 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.1.1(678731e78268dbe877b517e302fa7db86fd96b3c)
+ * monaco-kusto version: 6.2.0(8e26147bc7c3b5a7a3bc6ee55311dfa0b612c10c)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import * as ls from 'vscode-languageserver-types';
 import debounce from 'lodash-es/debounce';
 
@@ -174,12 +175,8 @@ const KustoLanguageDefinition = {
   }
 };
 
-var Uri = monaco.Uri;
-monaco.Position;
-var Range = monaco.Range;
-monaco.Thenable;
-monaco.CancellationToken;
-monaco.IDisposable;
+// --- diagnostics ---
+
 class DiagnosticsAdapter {
   _disposables = [];
   _contentListener = Object.create(null);
@@ -635,7 +632,7 @@ class ColorizationAdapter {
 
   /**
    * Return true if the range doesn't intersect any of the line ranges.
-   * @param range Range
+   * @param range monaco.Range
    * @param impactedLineRanges an array of line ranges
    */
   _rangeDoesNotIntersectAny(range, impactedLineRanges) {
@@ -731,7 +728,7 @@ function injectCss() {
 function toDecoration(model, classification) {
   const start = model.getPositionAt(classification.start);
   const end = model.getPositionAt(classification.start + classification.length);
-  const range = new Range(start.lineNumber, start.column, end.lineNumber, end.column);
+  const range = new monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
   const inlineClassName = ClassificationKindNames[classification.kind];
   return {
     range,
@@ -765,7 +762,7 @@ function toRange(range) {
   if (!range) {
     return void 0;
   }
-  return new Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);
+  return new monaco.Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);
 }
 function toCompletionItemKind(kind) {
   let mItemKind = monaco.languages.CompletionItemKind;
@@ -850,7 +847,7 @@ class CompletionAdapter {
   }
   provideCompletionItems(model, position, context, token) {
     const wordInfo = model.getWordUntilPosition(position);
-    const wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
+    const wordRange = new monaco.Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
     const resource = model.uri;
     const onDidProvideCompletionItems = this.languageSettings.onDidProvideCompletionItems;
     return this._worker(resource).then(worker => {
@@ -923,7 +920,7 @@ function toMarkedStringArray(contents) {
 
 function toLocation(location) {
   return {
-    uri: Uri.parse(location.uri),
+    uri: monaco.Uri.parse(location.uri),
     range: toRange(location.range)
   };
 }
@@ -971,7 +968,7 @@ function toWorkspaceEdit(edit) {
   }
   let resourceEdits = [];
   for (let uri in edit.changes) {
-    const _uri = Uri.parse(uri);
+    const _uri = monaco.Uri.parse(uri);
     for (let e of edit.changes[uri]) {
       resourceEdits.push({
         resource: _uri,
@@ -1068,8 +1065,6 @@ class HoverAdapter {
   }
 }
 
-monaco.Uri;
-monaco.IDisposable;
 let kustoWorker;
 let resolveWorker;
 let workerPromise = new Promise((resolve, reject) => {