@kusto/monaco-kusto 6.1.0 → 6.1.1

package/release/dev/kustoMode.d.ts

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

package/release/dev/kustoMode.js

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.1.0(b14a2ec944d355ac340af8280e7c1a4ea98f6c8c)
+ * monaco-kusto version: 6.1.1(678731e78268dbe877b517e302fa7db86fd96b3c)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/kustoMode', ['exports', './main-ac12725e'], (function (exports, main) { 'use strict';
+define('vs/language/kusto/kustoMode', ['exports', './main-068f3954'], (function (exports, main) { 'use strict';
 
     var _excluded = ["onDidProvideCompletionItems"];
     function _typeof$7(obj) { "@babel/helpers - typeof"; return _typeof$7 = "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$7(obj); }
@@ -135,10 +135,13 @@ define('vs/language/kusto/kustoMode', ['exports', './main-ac12725e'], (function
       displayName: 'Kusto',
       defaultToken: 'invalid',
       brackets: [['[', ']', 'delimiter.square'], ['(', ')', 'delimiter.parenthesis']],
+      // types are wrong
       wordDefinition: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
       // .slice() call is for creating a shallow copy of the array since bridge.net shoves a $type property on the array which monaco doesn't like.
-      promotedOperatorCommandTokens: Kusto.Data.IntelliSense.CslCommandParser.PromotedOperatorCommandTokens.slice(0),
-      operatorCommandTokens: Kusto.Data.IntelliSense.CslCommandParser.OperatorCommandTokens.slice(0),
+      // Kusto.Data.IntelliSense.CslCommandParser.PromotedOperatorCommandTokens.slice(0),
+      promotedOperatorCommandTokens: ['where', 'count', 'extend', 'join', 'limit', 'order', 'project', 'project-away', 'project-rename', 'project-reorder', 'project-keep', 'render', 'sort', 'summarize', 'distinct', 'take', 'top', 'top-nested', 'top-hitters', 'union', 'mv-expand', 'mv-apply', 'reduce', 'evaluate', 'parse', 'parse-where', 'parse-kv', 'sample', 'sample-distinct', 'make-series', 'getschema', 'serialize', 'invoke', 'as', 'scan'],
+      // Kusto.Data.IntelliSense.CslCommandParser.OperatorCommandTokens.slice(0),
+      operatorCommandTokens: ['filter', 'fork', 'facet', 'range', 'consume', 'find', 'search', 'print', 'partition', 'lookup', 'where', 'count', 'extend', 'join', 'limit', 'order', 'project', 'project-away', 'project-rename', 'project-reorder', 'project-keep', 'render', 'sort', 'summarize', 'distinct', 'take', 'top', 'top-nested', 'top-hitters', 'union', 'mv-expand', 'mv-apply', 'reduce', 'evaluate', 'parse', 'parse-where', 'parse-kv', 'sample', 'sample-distinct', 'make-series', 'getschema', 'serialize', 'invoke', 'as', 'scan'],
       keywords: ['by', 'on', 'contains', 'notcontains', 'containscs', 'notcontainscs', 'startswith', 'has', 'matches', 'regex', 'true', 'false', 'and', 'or', 'typeof', 'int', 'string', 'date', 'datetime', 'time', 'long', 'real', '​boolean', 'bool'],
       operators: ['+', '-', '*', '/', '>', '<', '==', '<>', '<=', '>=', '~', '!~'],
       builtinFunctions: ['countof', 'bin', 'extentid', 'extract', 'extractjson', 'floor', 'iif', 'isnull', 'isnotnull', 'notnull', 'isempty', 'isnotempty', 'notempty', 'now', 're2', 'strcat', 'strlen', 'toupper', 'tostring', 'count', 'cnt', 'sum', 'min', 'max', 'avg'],
@@ -673,7 +676,11 @@ define('vs/language/kusto/kustoMode', ['exports', './main-ac12725e'], (function
       return debounced;
     }
 
-    function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+    function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+    function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest(); }
+    function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+    function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+    function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
     function _toConsumableArray$1(arr) { return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread$1(); }
     function _nonIterableSpread$1() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
     function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
@@ -696,7 +703,6 @@ define('vs/language/kusto/kustoMode', ['exports', './main-ac12725e'], (function
     monaco.Thenable;
     monaco.CancellationToken;
     monaco.IDisposable;
-    var ClassificationKind = Kusto.Language.Editor.ClassificationKind;
     var DiagnosticsAdapter = /*#__PURE__*/function () {
       function DiagnosticsAdapter(_monacoInstance, _languageId, _worker, defaults, onSchemaChange) {
         var _this = this;
@@ -1089,6 +1095,44 @@ define('vs/language/kusto/kustoMode', ['exports', './main-ac12725e'], (function
         source: diag.source
       };
     }
+    /**
+     * Copy of Kusto.Language.Editor.ClassificationKind we don't have to depend on it in this file
+     */
+    var ClassificationKind = {
+      PlainText: 0,
+      Comment: 1,
+      Punctuation: 2,
+      Directive: 3,
+      Literal: 4,
+      StringLiteral: 5,
+      Type: 6,
+      Column: 7,
+      Table: 8,
+      Database: 9,
+      Function: 10,
+      Parameter: 11,
+      Variable: 12,
+      Identifier: 13,
+      ClientParameter: 14,
+      QueryParameter: 15,
+      ScalarOperator: 16,
+      MathOperator: 17,
+      QueryOperator: 18,
+      Command: 19,
+      Keyword: 20,
+      MaterializedView: 21,
+      SchemaMember: 22,
+      SignatureParameter: 23,
+      Option: 24
+    };
+    var ClassificationKindNames = {};
+    for (var _i = 0, _Object$entries = Object.entries(ClassificationKind); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        key = _Object$entries$_i[0],
+        value = _Object$entries$_i[1];
+      ClassificationKindNames[value] = key;
+    }
+
     // commented here is the color definitions are were defined by v1 intellisense terminology:
     // { token: 'comment', foreground: '008000' }, // CommentToken Green
     // { token: 'variable.predefined', foreground: '800080' }, // CalculatedColumnToken Purple
@@ -1226,8 +1270,8 @@ define('vs/language/kusto/kustoMode', ['exports', './main-ac12725e'], (function
         }));
         this._disposables.push({
           dispose: function dispose() {
-            for (var key in _this5._contentListener) {
-              _this5._contentListener[key].dispose();
+            for (var _key3 in _this5._contentListener) {
+              _this5._contentListener[_key3].dispose();
             }
           }
         });
@@ -1323,22 +1367,11 @@ define('vs/language/kusto/kustoMode', ['exports', './main-ac12725e'], (function
       return ColorizationAdapter;
     }();
 
-    /**
-     * Gets all keys of an enum (the string keys not the numeric values).
-     * @param e Enum type
-     */
-    function getEnumKeys(e) {
-      return Object.keys(e).filter(function (k) {
-        return typeof e[k] === 'number';
-      });
-    }
-
     /**
      * Generates a mapping between ClassificationKind and color.
      */
     function getClassificationColorTriplets() {
-      var keys = getEnumKeys(ClassificationKind);
-      var result = keys.map(function (key) {
+      var result = Object.keys(ClassificationKind).map(function (key) {
         return {
           classification: key,
           colorLight: classificationToColorLight[key],
@@ -1379,7 +1412,7 @@ define('vs/language/kusto/kustoMode', ['exports', './main-ac12725e'], (function
       var start = model.getPositionAt(classification.start);
       var end = model.getPositionAt(classification.start + classification.length);
       var range = new Range(start.lineNumber, start.column, end.lineNumber, end.column);
-      var inlineClassName = ClassificationKind.$names[classification.kind];
+      var inlineClassName = ClassificationKindNames[classification.kind];
       return {
         range: range,
         options: {

package/release/dev/kustoWorker.d.ts

@@ -1,18 +1,16 @@
-/// <reference types="monaco-editor-core/monaco" />
-type IWorkerContext = monaco.worker.IWorkerContext;
+/// <reference types="monaco-editor/monaco" />
+import * as ls from 'vscode-languageserver-types';
 import * as kustoService from './languageService/kustoLanguageService';
 import type { LanguageSettings } from './languageService/settings';
 import { Schema, showSchema, ScalarParameter, Database, TabularParameter } from './languageService/schema';
-import * as ls from 'vscode-languageserver-types';
 import type { ColorizationRange } from './languageService/kustoLanguageService';
 import type { RenderInfo } from './languageService/renderInfo';
-import type { FoldingRange } from 'vscode-languageserver-types';
 export declare class KustoWorker {
     private _ctx;
     private _languageService;
     private _languageId;
     private _languageSettings;
-    constructor(ctx: IWorkerContext, createData: ICreateData);
+    constructor(ctx: monaco.worker.IWorkerContext, createData: ICreateData);
     setSchema(schema: Schema): Promise<void>;
     addClusterToSchema(uri: string, clusterName: string, databasesNames: string[]): Promise<void>;
     addDatabaseToSchema(uri: string, clusterName: string, databaseSchema: Database): Promise<void>;
@@ -60,7 +58,7 @@ export declare class KustoWorker {
     }[], includeWarnings?: boolean, includeSuggestions?: boolean): Promise<ls.Diagnostic[]>;
     getResultActions(uri: string, start: number, end: number): Promise<kustoService.ResultAction[]>;
     doRangeFormat(uri: string, range: ls.Range): Promise<ls.TextEdit[]>;
-    doFolding(uri: string): Promise<FoldingRange[]>;
+    doFolding(uri: string): Promise<ls.FoldingRange[]>;
     doDocumentFormat(uri: string): Promise<ls.TextEdit[]>;
     doCurrentCommandFormat(uri: string, caretPosition: ls.Position): Promise<ls.TextEdit[]>;
     doColorization(uri: string, colorizationIntervals: {
@@ -88,5 +86,4 @@ export interface ICreateData {
     languageId: string;
     languageSettings: LanguageSettings;
 }
-export declare function create(ctx: IWorkerContext, createData: ICreateData): KustoWorker;
-export {};
+export declare function create(ctx: monaco.worker.IWorkerContext, createData: ICreateData): KustoWorker;

package/release/dev/kustoWorker.js

@@ -1,94 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.1.0(b14a2ec944d355ac340af8280e7c1a4ea98f6c8c)
+ * monaco-kusto version: 6.1.1(678731e78268dbe877b517e302fa7db86fd96b3c)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/kustoWorker', ['exports', './main-ac12725e'], (function (exports, main) { 'use strict';
-
-    // Definition of schema object in the context of language services. This model is exposed to consumers of this library.
-
-    // 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.
-     */
-
-    var dotnetTypeToKustoType = {
-      'System.SByte': 'bool',
-      'System.Byte': 'uint8',
-      'System.Int16': 'int16',
-      'System.UInt16': 'uint16',
-      'System.Int32': 'int',
-      'System.UInt32': 'uint',
-      'System.Int64': 'long',
-      'System.UInt64': 'ulong',
-      'System.String': 'string',
-      'System.Single': 'float',
-      'System.Double': 'real',
-      'System.DateTime': 'datetime',
-      'System.TimeSpan': 'timespan',
-      'System.Guid': 'guid',
-      'System.Boolean': 'bool',
-      'Newtonsoft.Json.Linq.JArray': 'dynamic',
-      'Newtonsoft.Json.Linq.JObject': 'dynamic',
-      'Newtonsoft.Json.Linq.JToken': 'dynamic',
-      'System.Object': 'dynamic',
-      'System.Data.SqlTypes.SqlDecimal': 'decimal'
-    };
-    var getCslTypeNameFromClrType = function getCslTypeNameFromClrType(clrType) {
-      return dotnetTypeToKustoType[clrType] || clrType;
-    };
-    var kustoTypeToEntityDataType = {
-      object: 'Object',
-      bool: 'Boolean',
-      uint8: 'Byte',
-      int16: 'Int16',
-      uint16: 'UInt16',
-      int: 'Int32',
-      uint: 'UInt32',
-      long: 'Int64',
-      ulong: 'UInt64',
-      float: 'Single',
-      real: 'Double',
-      decimal: 'Decimal',
-      datetime: 'DateTime',
-      string: 'String',
-      dynamic: 'Dynamic',
-      timespan: 'TimeSpan'
-    };
-    var getEntityDataTypeFromCslType = function getEntityDataTypeFromCslType(cslType) {
-      return kustoTypeToEntityDataType[cslType] || cslType;
-    };
-    var getCallName = function getCallName(fn) {
-      return "".concat(fn.name, "(").concat(fn.inputParameters.map(function (p) {
-        return "{".concat(p.name, "}");
-      }).join(','), ")");
-    };
-    var getExpression = function getExpression(fn) {
-      return "let ".concat(fn.name, " = ").concat(getInputParametersAsCslString(fn.inputParameters), " ").concat(fn.body);
-    };
-    var getInputParametersAsCslString = function getInputParametersAsCslString(inputParameters) {
-      return "(".concat(inputParameters.map(function (inputParameter) {
-        return getInputParameterAsCslString(inputParameter);
-      }).join(','), ")");
-    };
-    var getInputParameterAsCslString = function getInputParameterAsCslString(inputParameter) {
-      // If this is a tabular parameter
-      if (inputParameter.columns && inputParameter.columns.length > 0) {
-        var attributesAsString = inputParameter.columns.map(function (col) {
-          return "".concat(col.name, ":").concat(col.cslType || getCslTypeNameFromClrType(col.type));
-        }).join(',');
-        return "".concat(inputParameter.name, ":").concat(attributesAsString === '' ? '*' : attributesAsString);
-      } else {
-        return "".concat(inputParameter.name, ":").concat(inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type));
-      }
-    };
+define('vs/language/kusto/kustoWorker', ['exports', './main-068f3954'], (function (exports, main) { 'use strict';
 
     function _slicedToArray$2(arr, i) { return _arrayWithHoles$2(arr) || _iterableToArrayLimit$2(arr, i) || _unsupportedIterableToArray$3(arr, i) || _nonIterableRest$2(); }
     function _nonIterableRest$2() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -3517,6 +3434,104 @@ define('vs/language/kusto/kustoWorker', ['exports', './main-ac12725e'], (functio
     unicodeProperties(XRegExp);
     unicodeScripts(XRegExp);
 
+    // Definition of schema object in the context of language services. This model is exposed to consumers of this library.
+
+    // 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.
+     */
+
+    var dotnetTypeToKustoType = {
+      'System.SByte': 'bool',
+      'System.Byte': 'uint8',
+      'System.Int16': 'int16',
+      'System.UInt16': 'uint16',
+      'System.Int32': 'int',
+      'System.UInt32': 'uint',
+      'System.Int64': 'long',
+      'System.UInt64': 'ulong',
+      'System.String': 'string',
+      'System.Single': 'float',
+      'System.Double': 'real',
+      'System.DateTime': 'datetime',
+      'System.TimeSpan': 'timespan',
+      'System.Guid': 'guid',
+      'System.Boolean': 'bool',
+      'Newtonsoft.Json.Linq.JArray': 'dynamic',
+      'Newtonsoft.Json.Linq.JObject': 'dynamic',
+      'Newtonsoft.Json.Linq.JToken': 'dynamic',
+      'System.Object': 'dynamic',
+      'System.Data.SqlTypes.SqlDecimal': 'decimal'
+    };
+    var getCslTypeNameFromClrType = function getCslTypeNameFromClrType(clrType) {
+      return dotnetTypeToKustoType[clrType] || clrType;
+    };
+    var kustoTypeToEntityDataType = {
+      object: 'Object',
+      bool: 'Boolean',
+      uint8: 'Byte',
+      int16: 'Int16',
+      uint16: 'UInt16',
+      int: 'Int32',
+      uint: 'UInt32',
+      long: 'Int64',
+      ulong: 'UInt64',
+      float: 'Single',
+      real: 'Double',
+      decimal: 'Decimal',
+      datetime: 'DateTime',
+      string: 'String',
+      dynamic: 'Dynamic',
+      timespan: 'TimeSpan'
+    };
+    var getEntityDataTypeFromCslType = function getEntityDataTypeFromCslType(cslType) {
+      return kustoTypeToEntityDataType[cslType] || cslType;
+    };
+    var getCallName = function getCallName(fn) {
+      return "".concat(fn.name, "(").concat(fn.inputParameters.map(function (p) {
+        return "{".concat(p.name, "}");
+      }).join(','), ")");
+    };
+    var getExpression = function getExpression(fn) {
+      return "let ".concat(fn.name, " = ").concat(getInputParametersAsCslString(fn.inputParameters), " ").concat(fn.body);
+    };
+    var getInputParametersAsCslString = function getInputParametersAsCslString(inputParameters) {
+      return "(".concat(inputParameters.map(function (inputParameter) {
+        return getInputParameterAsCslString(inputParameter);
+      }).join(','), ")");
+    };
+    var getInputParameterAsCslString = function getInputParameterAsCslString(inputParameter) {
+      // If this is a tabular parameter
+      if (inputParameter.columns && inputParameter.columns.length > 0) {
+        var attributesAsString = inputParameter.columns.map(function (col) {
+          return "".concat(col.name, ":").concat(col.cslType || getCslTypeNameFromClrType(col.type));
+        }).join(',');
+        return "".concat(inputParameter.name, ":").concat(attributesAsString === '' ? '*' : attributesAsString);
+      } else {
+        return "".concat(inputParameter.name, ":").concat(inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type));
+      }
+    };
+
+    // If we're running in a web worker - which doesn't share global context with the main thread -
+    // we need to manually load dependencies that are not explicit- meaning our non-module dependencies
+    // generated by Bridge.Net
+    if (typeof document == 'undefined') {
+        // monaco will run the worker from vs/base/worker so the relative path needs
+        // to be from there (hence going up 2 dirs) This stinks because we're
+        // requiring the host app to put files in specific locations
+        importScripts(
+            '../../language/kusto/bridge.min.js',
+            '../../language/kusto/kusto.javascript.client.min.js',
+            '../../language/kusto/newtonsoft.json.min.js',
+            '../../language/kusto/Kusto.Language.Bridge.min.js'
+        );
+    }
+
     var _symbolKindToName;
     function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest(); }
     function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -3537,29 +3552,8 @@ define('vs/language/kusto/kustoWorker', ['exports', './main-ac12725e'], (functio
     function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
     function _toPropertyKey$1(arg) { var key = _toPrimitive$1(arg, "string"); return _typeof$1(key) === "symbol" ? key : String(key); }
     function _toPrimitive$1(input, hint) { if (_typeof$1(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof$1(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-
-    // polyfill string endsWith
-    if (!String.prototype.endsWith) {
-      String.prototype.endsWith = function (search, this_len) {
-        if (this_len === undefined || this_len > this.length) {
-          this_len = this.length;
-        }
-        return this.substring(this_len - search.length, this_len) === search;
-      };
-    }
-
-    // If we're running in a web worker - which doesn't share global context with the main thread -
-    // we need to manually load dependencies that are not explicit- meaning our non-module dependencies
-    // generated by Bridge.Net
-    if (typeof document == 'undefined') {
-      // monaco will run the worker from vs/base/worker so the relative path needs to be from there (hence going up 2 dirs)
-      importScripts('../../language/kusto/bridge.min.js');
-      importScripts('../../language/kusto/kusto.javascript.client.min.js');
-      importScripts('../../language/kusto/Kusto.Language.Bridge.min.js');
-    }
     var k = Kusto.Data.IntelliSense;
     var parsing = Kusto.Language.Parsing;
-    Kusto.Language.Syntax;
     var k2 = Kusto.Language.Editor;
     var sym = Kusto.Language.Symbols;
     var GlobalState = Kusto.Language.GlobalState;
@@ -3586,15 +3580,7 @@ define('vs/language/kusto/kustoWorker', ['exports', './main-ac12725e'], (functio
       }]);
       return ParseProperties;
     }();
-    var TokenKind;
-
-    /**
-     * A plain old javascript object that is roughly equivalent to the @kusto/language-service-next object, but without
-     * all the Bridge.Net properties and methods. this object is being sent from web worker to main thread and turns out
-     * that when posting the message we lose all properties (and functions), thus we use a POJO instead.
-     * This issue started happening once upgrading to 0.20.0 from 0.15.5.
-     */
-    (function (TokenKind) {
+    var TokenKind = /*#__PURE__*/function (TokenKind) {
       TokenKind[TokenKind["TableToken"] = 2] = "TableToken";
       TokenKind[TokenKind["TableColumnToken"] = 4] = "TableColumnToken";
       TokenKind[TokenKind["OperatorToken"] = 8] = "OperatorToken";
@@ -3614,7 +3600,16 @@ define('vs/language/kusto/kustoWorker', ['exports', './main-ac12725e'], (functio
       TokenKind[TokenKind["PluginToken"] = 131072] = "PluginToken";
       TokenKind[TokenKind["BracketRangeToken"] = 262144] = "BracketRangeToken";
       TokenKind[TokenKind["ClientDirectiveToken"] = 524288] = "ClientDirectiveToken";
-    })(TokenKind || (TokenKind = {}));
+      return TokenKind;
+    }({});
+
+    /**
+     * A plain old javascript object that is roughly equivalent to the @kusto/language-service-next object, but without
+     * all the Bridge.Net properties and methods. this object is being sent from web worker to main thread and turns out
+     * that when posting the message we lose all properties (and functions), thus we use a POJO instead.
+     * This issue started happening once upgrading to 0.20.0 from 0.15.5.
+     */
+
     /**
      * convert the bridge.net object to a plain javascript object that only contains data.
      * @param k2Classifications @kusto/language-service-next bridge.net object
@@ -5799,9 +5794,13 @@ define('vs/language/kusto/kustoWorker', ['exports', './main-ac12725e'], (functio
               _result$location$rang = result.location.range,
               start = _result$location$rang.start,
               end = _result$location$rang.end;
-            var range = new monaco.Range(start.line + 1, start.character + 1, end.line + 1, end.character + 1);
             return {
-              range: range,
+              range: {
+                startLineNumber: start.line + 1,
+                startColumn: start.character + 1,
+                endLineNumber: end.line + 1,
+                endColumn: end.character + 1
+              },
               text: text
             };
           });

package/release/dev/languageFeatures.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="monaco-editor-core/monaco" />
+/// <reference types="monaco-editor/monaco" />
 /// <reference types="../monaco" />
 import type { LanguageServiceDefaultsImpl } from './monaco.contribution';
 import type { KustoWorker } from './kustoWorker';

package/release/dev/languageService/kustoLanguageService.d.ts

@@ -1,10 +1,11 @@
 /// <reference types="@kusto/language-service-next/Kusto.Language.Bridge" />
 /// <reference types="@kusto/language-service/Kusto.JavaScript.Client" />
-import * as s from './schema';
 import * as ls from 'vscode-languageserver-types';
 import type { TextDocument } from 'vscode-languageserver-textdocument';
 import type { FoldingRange } from 'vscode-languageserver-types';
+import * as s from './schema';
 import type { LanguageSettings } from './settings';
+import 'language-service';
 import k = Kusto.Data.IntelliSense;
 import k2 = Kusto.Language.Editor;
 import { Database } from './schema';

package/release/dev/languageService/kustoMonarchLanguageDefinition.d.ts

@@ -1 +1,2 @@
-export declare const KustoLanguageDefinition: any;
+/// <reference types="monaco-editor/monaco" />
+export declare const KustoLanguageDefinition: monaco.languages.IMonarchLanguage;

package/release/dev/languageService/renderInfo.d.ts

@@ -1,8 +1,8 @@
-export declare type VisualizationType = 'anomalychart' | 'areachart' | 'barchart' | 'columnchart' | 'ladderchart' | 'linechart' | 'piechart' | 'pivotchart' | 'scatterchart' | 'stackedareachart' | 'timechart' | 'table' | 'timeline' | 'timepivot' | 'card';
-export declare type Scale = 'linear' | 'log';
-export declare type LegendVisibility = 'visible' | 'hidden';
-export declare type YSplit = 'none' | 'axes' | 'panels';
-export declare type Kind = 'default' | 'unstacked' | 'stacked' | 'stacked100' | 'map';
+export type VisualizationType = 'anomalychart' | 'areachart' | 'barchart' | 'columnchart' | 'ladderchart' | 'linechart' | 'piechart' | 'pivotchart' | 'scatterchart' | 'stackedareachart' | 'timechart' | 'table' | 'timeline' | 'timepivot' | 'card';
+export type Scale = 'linear' | 'log';
+export type LegendVisibility = 'visible' | 'hidden';
+export type YSplit = 'none' | 'axes' | 'panels';
+export type Kind = 'default' | 'unstacked' | 'stacked' | 'stacked100' | 'map';
 export interface RenderOptions {
     visualization?: null | VisualizationType;
     title?: null | string;

package/release/dev/{main-ac12725e.js → main-068f3954.js}

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.1.0(b14a2ec944d355ac340af8280e7c1a4ea98f6c8c)
+ * monaco-kusto version: 6.1.1(678731e78268dbe877b517e302fa7db86fd96b3c)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/main-ac12725e', ['exports'], (function (exports) { 'use strict';
+define('vs/language/kusto/main-068f3954', ['exports'], (function (exports) { 'use strict';
 
     /* --------------------------------------------------------------------------------------------
      * Copyright (c) Microsoft Corporation. All rights reserved.

package/release/dev/monaco.contribution.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="../monaco" />
-/// <reference types="monaco-editor-core/monaco" />
-import IEvent = monaco.IEvent;
+/// <reference types="monaco-editor/monaco" />
+import 'monaco-editor';
 export declare class LanguageServiceDefaultsImpl implements monaco.languages.kusto.LanguageServiceDefaults {
     private _onDidChange;
     private _languageSettings;
     private _workerMaxIdleTime;
     constructor(languageSettings: monaco.languages.kusto.LanguageSettings);
-    get onDidChange(): IEvent<monaco.languages.kusto.LanguageServiceDefaults>;
+    get onDidChange(): monaco.IEvent<monaco.languages.kusto.LanguageServiceDefaults>;
     get languageSettings(): monaco.languages.kusto.LanguageSettings;
     setLanguageSettings(options: monaco.languages.kusto.LanguageSettings): void;
     setMaximumWorkerIdleTime(value: number): void;

package/release/dev/monaco.contribution.js

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.1.0(b14a2ec944d355ac340af8280e7c1a4ea98f6c8c)
+ * monaco-kusto version: 6.1.1(678731e78268dbe877b517e302fa7db86fd96b3c)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/monaco.contribution', ['require', 'exports'], (function (require, exports) { 'use strict';
+define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/editor/editor.main'], (function (require, exports, editor_main) { 'use strict';
 
     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"); } }
@@ -19,7 +19,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports'], (functio
      */
     var KustoCommandHighlighter = /*#__PURE__*/function () {
       /**
-       * Register to cursor movement and seleciton events.
+       * Register to cursor movement and selection events.
        * @param editor monaco editor instance
        */
       function KustoCommandHighlighter(editor) {
@@ -28,7 +28,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports'], (functio
         _defineProperty$2(this, "disposables", []);
         _defineProperty$2(this, "decorations", []);
         this.editor = editor;
-        // Note that selection update is triggered not only for selection changes, but also just when no text selection is occuring and cursor just moves around.
+        // Note that selection update is triggered not only for selection changes, but also just when no text selection is occurring and cursor just moves around.
         // This case is counted as a 0-length selection starting and ending on the cursor position.
         this.editor.onDidChangeCursorSelection(function (changeEvent) {
           if (_this.editor.getModel().getLanguageId() !== 'kusto') {
@@ -165,17 +165,13 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports'], (functio
     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); }
-    var Emitter = monaco.Emitter;
-    monaco.IEvent;
-
-    // declare var require: <T>(moduleId: [string], callback: (module: T) => void) => void;
 
     // --- Kusto configuration and defaults ---------
 
     var LanguageServiceDefaultsImpl = /*#__PURE__*/function () {
       function LanguageServiceDefaultsImpl(languageSettings) {
         _classCallCheck(this, LanguageServiceDefaultsImpl);
-        _defineProperty(this, "_onDidChange", new Emitter());
+        _defineProperty(this, "_onDidChange", new monaco.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