@kusto/monaco-kusto 5.3.10 → 5.3.12

package/release/dev/monaco.contribution.js

@@ -95,13 +95,12 @@ define('vs/language/kusto/commandFormatter',["require", "exports"], function (re
     exports.default = KustoCommandFormatter;
 });
 
-/// <reference path="../node_modules/monaco-editor-core/monaco.d.ts" />
 define('vs/language/kusto/extendedEditor',["require", "exports"], function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.extend = void 0;
     /**
-     * Extending ICode editor to contain additional kusto-speicifc methods.
+     * 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) {
@@ -122,7 +121,8 @@ define('vs/language/kusto/extendedEditor',["require", "exports"], function (requ
                     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) {
+                if (lineNumber > zeroBasedCursorLineNumber &&
+                    commandOrdinal > linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal) {
                     break;
                 }
             }
@@ -204,7 +204,7 @@ define('vs/language/kusto/monaco.contribution',["require", "exports", "./command
         },
         enableQueryWarnings: false,
         enableQuerySuggestions: false,
-        disabledDiagnoticCodes: [],
+        disabledDiagnosticCodes: [],
     };
     function getKustoWorker() {
         return new Promise(function (resolve, reject) {
@@ -232,7 +232,7 @@ define('vs/language/kusto/monaco.contribution',["require", "exports", "./command
             id: 'kusto',
             extensions: ['.csl', '.kql'],
         });
-        // TODO: asked if there's a cleaner way to register an editor contribution. looks like monaco has an internal contribution regstrar but it's no exposed in the API.
+        // TODO: asked if there's a cleaner way to register an editor contribution. looks like monaco has an internal contribution registrar but it's no exposed in the API.
         // https://stackoverflow.com/questions/46700245/how-to-add-an-ieditorcontribution-to-monaco-editor
         var commandHighlighter;
         var commandFormatter;
@@ -298,7 +298,7 @@ define('vs/language/kusto/monaco.contribution',["require", "exports", "./command
         // Most other language features are initialized in kustoMode.ts
         monacoInstance.editor.onDidCreateEditor(function (editor) {
             // hook up extension methods to editor.
-            extendedEditor_1.extend(editor);
+            (0, extendedEditor_1.extend)(editor);
             commandHighlighter = new commandHighlighter_1.default(editor);
             if (isStandaloneCodeEditor(editor)) {
                 commandFormatter = new commandFormatter_1.default(editor);
@@ -307,14 +307,15 @@ define('vs/language/kusto/monaco.contribution',["require", "exports", "./command
         });
         function triggerSuggestDialogWhenCompletionItemSelected(editor) {
             editor.onDidChangeCursorSelection(function (event) {
-                // checking the condition inside the event makes sure we will stay up to date whne kusto configuration changes at runtime.
+                // 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) {
+                    if (!didAcceptSuggestion ||
+                        editor.getModel().getWordAtPosition(event.selection.getPosition()) !== null) {
                         return;
                     }
                     event.selection;

package/release/esm/extendedEditor.js

@@ -1,6 +1,5 @@
-/// <reference path="../node_modules/monaco-editor-core/monaco.d.ts" />
 /**
- * Extending ICode editor to contain additional kusto-speicifc methods.
+ * 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.
  */
 export function extend(editor) {
@@ -21,7 +20,8 @@ export function extend(editor) {
                 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) {
+            if (lineNumber > zeroBasedCursorLineNumber &&
+                commandOrdinal > linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal) {
                 break;
             }
         }

package/release/esm/kustoMode.js

@@ -46,7 +46,10 @@ export function setupMode(defaults, monacoInstance) {
             return (__assign(__assign({}, worker), { setSchema: function (schema) { return augmentedSetSchema(schema, worker); }, setSchemaFromShowSchema: function (schema, connection, database, globalScalarParameters, globalTabularParameters) {
                     worker
                         .normalizeSchema(schema, connection, database)
-                        .then(function (schema) { return (globalScalarParameters ? __assign(__assign({}, schema), { globalScalarParameters: globalScalarParameters, globalTabularParameters: globalTabularParameters }) : schema); })
+                        .then(function (schema) {
+                        return globalScalarParameters
+                            ? __assign(__assign({}, schema), { globalScalarParameters: globalScalarParameters, globalTabularParameters: globalTabularParameters }) : schema;
+                    })
                         .then(function (normalized) { return augmentedSetSchema(normalized, worker); });
                 } }));
         });

package/release/esm/kustoWorker.js

@@ -14,7 +14,7 @@ var KustoWorker = /** @class */ (function () {
     KustoWorker.prototype.addClusterToSchema = function (uri, clusterName, databasesNames) {
         var document = this._getTextDocument(uri);
         if (!document) {
-            console.error("addClusterToSchema: document is " + document + ". uri is " + uri);
+            console.error("addClusterToSchema: document is ".concat(document, ". uri is ").concat(uri));
             return Promise.resolve();
         }
         return this._languageService.addClusterToSchema(document, clusterName, databasesNames);
@@ -22,7 +22,7 @@ var KustoWorker = /** @class */ (function () {
     KustoWorker.prototype.addDatabaseToSchema = function (uri, clusterName, databaseSchema) {
         var document = this._getTextDocument(uri);
         if (!document) {
-            console.error("addDatabaseToSchema: document is " + document + ". uri is " + uri);
+            console.error("addDatabaseToSchema: document is ".concat(document, ". uri is ").concat(uri));
             return Promise.resolve();
         }
         return this._languageService.addDatabaseToSchema(document, clusterName, databaseSchema);
@@ -39,7 +39,7 @@ var KustoWorker = /** @class */ (function () {
     KustoWorker.prototype.getCommandInContext = function (uri, cursorOffset) {
         var document = this._getTextDocument(uri);
         if (!document) {
-            console.error("getCommandInContext: document is " + document + ". uri is " + uri);
+            console.error("getCommandInContext: document is ".concat(document, ". uri is ").concat(uri));
             return null;
         }
         var commandInContext = this._languageService.getCommandInContext(document, cursorOffset);
@@ -51,7 +51,7 @@ var KustoWorker = /** @class */ (function () {
     KustoWorker.prototype.getQueryParams = function (uri, cursorOffset) {
         var document = this._getTextDocument(uri);
         if (!document) {
-            console.error("getQueryParams: document is " + document + ". uri is " + uri);
+            console.error("getQueryParams: document is ".concat(document, ". uri is ").concat(uri));
             return null;
         }
         var queryParams = this._languageService.getQueryParams(document, cursorOffset);
@@ -63,7 +63,7 @@ var KustoWorker = /** @class */ (function () {
     KustoWorker.prototype.getGlobalParams = function (uri) {
         var document = this._getTextDocument(uri);
         if (!document) {
-            console.error("getGLobalParams: document is " + document + ". uri is " + uri);
+            console.error("getGLobalParams: document is ".concat(document, ". uri is ").concat(uri));
             return null;
         }
         var globalParams = this._languageService.getGlobalParams(document);
@@ -75,7 +75,7 @@ var KustoWorker = /** @class */ (function () {
     KustoWorker.prototype.getReferencedGlobalParams = function (uri, cursorOffest) {
         var document = this._getTextDocument(uri);
         if (!document) {
-            console.error("getReferencedGlobalParams: document is " + document + ". uri is " + uri);
+            console.error("getReferencedGlobalParams: document is ".concat(document, ". uri is ").concat(uri));
             return null;
         }
         var referencedParams = this._languageService.getReferencedGlobalParams(document, cursorOffest);
@@ -87,7 +87,7 @@ var KustoWorker = /** @class */ (function () {
     KustoWorker.prototype.getRenderInfo = function (uri, cursorOffset) {
         var document = this._getTextDocument(uri);
         if (!document) {
-            console.error("getRenderInfo: document is " + document + ". uri is " + uri);
+            console.error("getRenderInfo: document is ".concat(document, ". uri is ").concat(uri));
         }
         return this._languageService.getRenderInfo(document, cursorOffset).then(function (result) {
             if (!result) {
@@ -105,7 +105,7 @@ var KustoWorker = /** @class */ (function () {
     KustoWorker.prototype.getCommandAndLocationInContext = function (uri, cursorOffset) {
         var document = this._getTextDocument(uri);
         if (!document) {
-            console.error("getCommandAndLocationInContext: document is " + document + ". uri is " + uri);
+            console.error("getCommandAndLocationInContext: document is ".concat(document, ". uri is ").concat(uri));
             return Promise.resolve(null);
         }
         return this._languageService.getCommandAndLocationInContext(document, cursorOffset).then(function (result) {
@@ -124,7 +124,7 @@ var KustoWorker = /** @class */ (function () {
     KustoWorker.prototype.getCommandsInDocument = function (uri) {
         var document = this._getTextDocument(uri);
         if (!document) {
-            console.error("getCommandInDocument: document is " + document + ". uri is " + uri);
+            console.error("getCommandInDocument: document is ".concat(document, ". uri is ").concat(uri));
             return null;
         }
         return this._languageService.getCommandsInDocument(document);

package/release/esm/languageFeatures.js

@@ -3,7 +3,6 @@ import * as _ from './_deps/lodash/lodash';
 var Uri = monaco.Uri;
 var Range = monaco.Range;
 var ClassificationKind = Kusto.Language.Editor.ClassificationKind;
-// --- diagnostics ---
 var DiagnosticsAdapter = /** @class */ (function () {
     function DiagnosticsAdapter(_monacoInstance, _languageId, _worker, defaults, onSchemaChange) {
         var _this = this;
@@ -146,9 +145,9 @@ var DiagnosticsAdapter = /** @class */ (function () {
                 }
                 else {
                     // Add custom popup for syntax error: icon, header and message as markdown
-                    var header = syntaxErrorAsMarkDown.header ? "**" + syntaxErrorAsMarkDown.header + "** \n\n" : '';
-                    var icon = syntaxErrorAsMarkDown.icon ? "![](" + syntaxErrorAsMarkDown.icon + ")" : '';
-                    var popupErrorHoverHeaderMessage_1 = icon + " " + header;
+                    var header = syntaxErrorAsMarkDown.header ? "**".concat(syntaxErrorAsMarkDown.header, "** \n\n") : '';
+                    var icon = syntaxErrorAsMarkDown.icon ? "![](".concat(syntaxErrorAsMarkDown.icon, ")") : '';
+                    var popupErrorHoverHeaderMessage_1 = "".concat(icon, " ").concat(header);
                     var newDecorations = markers.map(function (marker) {
                         return {
                             range: {
@@ -175,8 +174,7 @@ var DiagnosticsAdapter = /** @class */ (function () {
                             },
                         };
                     });
-                    var oldMarkers = monaco.editor
-                        .getModelMarkers({
+                    var oldMarkers = monaco.editor.getModelMarkers({
                         owner: languageId,
                         resource: resource,
                     });
@@ -482,7 +480,7 @@ function getCssForClassification() {
     var classificationColorTriplets = getClassificationColorTriplets();
     var cssInnerHtml = classificationColorTriplets
         .map(function (pair) {
-        return ".vs ." + pair.classification + " {color: #" + pair.colorLight + ";} .vs-dark ." + pair.classification + " {color: #" + pair.colorDark + ";}";
+        return ".vs .".concat(pair.classification, " {color: #").concat(pair.colorLight, ";} .vs-dark .").concat(pair.classification, " {color: #").concat(pair.colorDark, ";}");
     })
         .join('\n');
     return cssInnerHtml;
@@ -583,7 +581,7 @@ function toTextEdit(textEdit) {
         text: textEdit.newText,
     };
 }
-var DOCS_BASE_URL = "https://learn.microsoft.com/azure/data-explorer/kusto/query";
+var DOCS_BASE_URL = 'https://learn.microsoft.com/azure/data-explorer/kusto/query';
 function formatDocLink(docString) {
     // If the docString is empty, we want to return undefined to prevent an empty documentation popup.
     if (!docString) {
@@ -593,9 +591,11 @@ function formatDocLink(docString) {
     var urisProxy = new Proxy(target, {
         get: function (_target, prop, _receiver) {
             // The link comes with a postfix of ".md" that we want to remove
-            var linkWithoutPostfix = prop.toString().replace(".md", "");
+            var linkWithoutPostfix = prop.toString().replace('.md', '');
             // Sometimes we get the link as a full URL. For example in the main doc link of the item
-            var fullURL = linkWithoutPostfix.startsWith("https") ? linkWithoutPostfix : DOCS_BASE_URL + "/" + linkWithoutPostfix;
+            var fullURL = linkWithoutPostfix.startsWith('https')
+                ? linkWithoutPostfix
+                : "".concat(DOCS_BASE_URL, "/").concat(linkWithoutPostfix);
             return monaco.Uri.parse(fullURL);
         },
     });

package/release/esm/languageService/kustoLanguageService.js

@@ -9,16 +9,15 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __spreadArrays = (this && this.__spreadArrays) || function () {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
-/// <reference path="../../node_modules/@kusto/language-service/Kusto.JavaScript.Client.d.ts" />
-/// <reference path="../../node_modules/@kusto/language-service-next/Kusto.Language.Bridge.d.ts" />
-/// <reference path="../typings/refs.d.ts" />
 import * as s from './schema';
 // polyfill string endsWith
 if (!String.prototype.endsWith) {
@@ -124,7 +123,7 @@ var KustoLanguageService = /** @class */ (function () {
         /**
          * Taken from:
          * https://msazure.visualstudio.com/One/_git/Azure-Kusto-Service?path=/Src/Tools/Kusto.Explorer.Control/QueryEditors/KustoScriptEditor/KustoScriptEditorControl2.xaml.cs&version=GBdev&line=2075&lineEnd=2075&lineStartColumn=9&lineEndColumn=77&lineStyle=plain&_a=contents
-        */
+         */
         this._toOptionKind = (_a = {},
             _a[k2.CompletionKind.AggregateFunction] = k.OptionKind.FunctionAggregation,
             _a[k2.CompletionKind.BuiltInFunction] = k.OptionKind.FunctionScalar,
@@ -271,7 +270,7 @@ var KustoLanguageService = /** @class */ (function () {
         this._newlineAppendPipePolicy.Text = '\n| ';
     }
     KustoLanguageService.prototype.createDatabaseUniqueName = function (clusterName, databaseName) {
-        return clusterName + "_" + databaseName;
+        return "".concat(clusterName, "_").concat(databaseName);
     };
     Object.defineProperty(KustoLanguageService.prototype, "_kustoJsSchemaV2", {
         /**
@@ -318,20 +317,20 @@ var KustoLanguageService = /** @class */ (function () {
      */
     KustoLanguageService.prototype.debugGlobalState = function (globals) {
         // iterate over clusters
-        console.log("globals.Clusters.Count: " + globals.Clusters.Count);
+        console.log("globals.Clusters.Count: ".concat(globals.Clusters.Count));
         for (var i = 0; i < globals.Clusters.Count; i++) {
             var cluster = globals.Clusters.getItem(i);
-            console.log("cluster: " + cluster.Name);
+            console.log("cluster: ".concat(cluster.Name));
             // iterate over databases
-            console.log("cluster.Databases.Count: " + cluster.Databases.Count);
+            console.log("cluster.Databases.Count: ".concat(cluster.Databases.Count));
             for (var i2 = 0; i2 < cluster.Databases.Count; i2++) {
                 var database = cluster.Databases.getItem(i2);
-                console.log("cluster.database: [" + cluster.Name + "].[" + database.Name + "]");
+                console.log("cluster.database: [".concat(cluster.Name, "].[").concat(database.Name, "]"));
                 // iterate over tables
-                console.log("cluster.Databases.Tables.Count: " + database.Tables.Count);
+                console.log("cluster.Databases.Tables.Count: ".concat(database.Tables.Count));
                 for (var i3 = 0; i3 < database.Tables.Count; i3++) {
                     var table = database.Tables.getItem(i3);
-                    console.log("cluster.database.table: [" + cluster.Name + "].[" + database.Name + "].[" + table.Name + "]");
+                    console.log("cluster.database.table: [".concat(cluster.Name, "].[").concat(database.Name, "].[").concat(table.Name, "]"));
                 }
             }
         }
@@ -340,7 +339,7 @@ var KustoLanguageService = /** @class */ (function () {
      * Prepending the doc of the actual topic at the top
      */
     KustoLanguageService.prototype.formatHelpTopic = function (helpTopic) {
-        return "**" + helpTopic.Name + " [(view online)](" + helpTopic.Url + ")**\n\n" + helpTopic.LongDescription;
+        return "**".concat(helpTopic.Name, " [(view online)](").concat(helpTopic.Url, ")**\n\n").concat(helpTopic.LongDescription);
     };
     KustoLanguageService.prototype.doCompleteV2 = function (document, position) {
         var _this = this;
@@ -382,7 +381,7 @@ var KustoLanguageService = /** @class */ (function () {
                 ? {
                     // Need to escape dollar sign since it is used as a placeholder in snippet.
                     // Usually dollar sign is not a valid character in a function name, but grafana uses macros that start with dollars.
-                    textToInsert: kItem.EditText.replace('$', '\\$') + "$0" + kItem.AfterText,
+                    textToInsert: "".concat(kItem.EditText.replace('$', '\\$'), "$0").concat(kItem.AfterText),
                     format: ls.InsertTextFormat.Snippet,
                 }
                 : {
@@ -786,13 +785,14 @@ var KustoLanguageService = /** @class */ (function () {
     KustoLanguageService.prototype.setSchema = function (schema) {
         var _this = this;
         this._schema = schema;
-        if (this._languageSettings.useIntellisenseV2) {
-            var kustoJsSchemaV2 = schema && schema.clusterType === 'Engine' ? this.convertToKustoJsSchemaV2(schema) : null;
+        // We support intellisenseV2 only if the clusterType is "Engine", even if the setting is enabled
+        if (this._languageSettings.useIntellisenseV2 && schema && schema.clusterType === 'Engine') {
+            var kustoJsSchemaV2 = this.convertToKustoJsSchemaV2(schema);
             this._kustoJsSchemaV2 = kustoJsSchemaV2;
             this._script = undefined;
             this._parsePropertiesV2 = undefined;
         }
-        // since V2 doesn't support control commands, we're initializing V1 intellisense for both cases and we'll going to use V1 intellisense for contorl commands.
+        // since V2 doesn't support control commands, we're initializing V1 intellisense for both cases and we'll going to use V1 intellisense for control commands.
         return new Promise(function (resolve, reject) {
             var kustoJsSchema = schema ? KustoLanguageService.convertToKustoJsSchema(schema) : undefined;
             _this._kustoJsSchema = kustoJsSchema;
@@ -807,8 +807,10 @@ var KustoLanguageService = /** @class */ (function () {
         this._schema.globalScalarParameters = scalarParameters;
         this._schema.globalTabularParameters = tabularParameters;
         var scalarSymbols = scalarParameters.map(function (param) { return KustoLanguageService.createParameterSymbol(param); });
-        var tabularSymbols = tabularParameters.map(function (param) { return KustoLanguageService.createTabularParameterSymbol(param); });
-        this._kustoJsSchemaV2 = this._kustoJsSchemaV2.WithParameters(KustoLanguageService.toBridgeList(__spreadArrays(scalarSymbols, tabularSymbols)));
+        var tabularSymbols = tabularParameters.map(function (param) {
+            return KustoLanguageService.createTabularParameterSymbol(param);
+        });
+        this._kustoJsSchemaV2 = this._kustoJsSchemaV2.WithParameters(KustoLanguageService.toBridgeList(__spreadArray(__spreadArray([], scalarSymbols, true), tabularSymbols, true)));
         return Promise.resolve(undefined);
     };
     /**
@@ -1455,8 +1457,8 @@ var KustoLanguageService = /** @class */ (function () {
      * @param params scalar parameters
      */
     KustoLanguageService.scalarParametersToSignature = function (params) {
-        var signatureWithoutParens = params.map(function (param) { return param.name + ": " + param.cslType; }).join(', ');
-        return "(" + signatureWithoutParens + ")";
+        var signatureWithoutParens = params.map(function (param) { return "".concat(param.name, ": ").concat(param.cslType); }).join(', ');
+        return "(".concat(signatureWithoutParens, ")");
     };
     /**
      * Returns something like '(x: string, T: (y: int))'
@@ -1468,14 +1470,14 @@ var KustoLanguageService = /** @class */ (function () {
             .map(function (param) {
             if (param.columns) {
                 var tableSignature = _this.scalarParametersToSignature(param.columns);
-                return param.name + ": " + tableSignature;
+                return "".concat(param.name, ": ").concat(tableSignature);
             }
             else {
-                return param.name + ": " + param.cslType;
+                return "".concat(param.name, ": ").concat(param.cslType);
             }
         })
             .join(', ');
-        return "(" + signatureWithoutParens + ")";
+        return "(".concat(signatureWithoutParens, ")");
     };
     /**
      * converts a function definition to a let statement.
@@ -1483,7 +1485,7 @@ var KustoLanguageService = /** @class */ (function () {
      */
     KustoLanguageService.toLetStatement = function (fn) {
         var signature = this.inputParameterToSignature(fn.inputParameters);
-        return "let " + fn.name + " = " + signature + " " + fn.body;
+        return "let ".concat(fn.name, " = ").concat(signature, " ").concat(fn.body);
     };
     KustoLanguageService.createColumnSymbol = function (col) {
         return new sym.ColumnSymbol(col.name, sym.ScalarTypes.GetSymbol(getCslTypeNameFromClrType(col.type)), col.docstring, null, null, col.examples ? KustoLanguageService.toBridgeList(col.examples) : null);
@@ -1591,11 +1593,15 @@ var KustoLanguageService = /** @class */ (function () {
             globalState = globalState.WithDatabase(databaseInContext);
         }
         // Inject global scalar parameters to global scope.
-        var scalarParameters = ((_a = schema.globalScalarParameters) !== null && _a !== void 0 ? _a : []).map(function (param) { return KustoLanguageService.createParameterSymbol(param); });
+        var scalarParameters = ((_a = schema.globalScalarParameters) !== null && _a !== void 0 ? _a : []).map(function (param) {
+            return KustoLanguageService.createParameterSymbol(param);
+        });
         // Inject global tabular parameters to global scope.
-        var tabularParameters = ((_b = schema.globalTabularParameters) !== null && _b !== void 0 ? _b : []).map(function (param) { return KustoLanguageService.createTabularParameterSymbol(param); });
+        var tabularParameters = ((_b = schema.globalTabularParameters) !== null && _b !== void 0 ? _b : []).map(function (param) {
+            return KustoLanguageService.createTabularParameterSymbol(param);
+        });
         if (tabularParameters.length || scalarParameters.length) {
-            globalState = globalState.WithParameters(KustoLanguageService.toBridgeList(__spreadArrays(scalarParameters, tabularParameters)));
+            globalState = globalState.WithParameters(KustoLanguageService.toBridgeList(__spreadArray(__spreadArray([], scalarParameters, true), tabularParameters, true)));
         }
         return globalState;
     };
@@ -1632,7 +1638,7 @@ var KustoLanguageService = /** @class */ (function () {
      */
     KustoLanguageService.prototype.getSortText = function (order) {
         if (order <= 0) {
-            throw new RangeError("order should be a number >= 1. instead got " + order);
+            throw new RangeError("order should be a number >= 1. instead got ".concat(order));
         }
         var sortText = '';
         var numCharacters = 26; // "z" - "a" + 1;

package/release/esm/languageService/kustoMonarchLanguageDefinition.js

@@ -1,23 +1,69 @@
 export var KustoLanguageDefinition = {
     name: 'kusto',
     mimeTypes: ['text/kusto'],
-    displayName: "Kusto",
-    defaultToken: "invalid",
-    brackets: [['[', ']', 'delimiter.square'],
-        ['(', ')', 'delimiter.parenthesis']],
+    displayName: 'Kusto',
+    defaultToken: 'invalid',
+    brackets: [
+        ['[', ']', 'delimiter.square'],
+        ['(', ')', 'delimiter.parenthesis'],
+    ],
     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),
     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'
+        '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'
+        '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',
     ],
     tokenizer: {
         root: [
@@ -30,7 +76,9 @@ export var KustoLanguageDefinition = {
             [/[;,.]/, 'delimiter'],
             [/[()\[\]]/, '@brackets'],
             [/[<>=!%&+\-*/|~^]/, 'operator'],
-            [/[\w@#\-$]+/, {
+            [
+                /[\w@#\-$]+/,
+                {
                     cases: {
                         '@keywords': 'keyword',
                         '@promotedOperatorCommandTokens': 'operator.sql',
@@ -38,39 +86,42 @@ export var KustoLanguageDefinition = {
                         '@operators': 'operator',
                         '@builtinFunctions': 'predefined',
                         '@default': 'identifier',
-                    }
-                }],
+                    },
+                },
+            ],
         ],
         whitespace: [[/\s+/, 'white']],
-        comments: [["\\/\\/+.*", "comment"]],
+        comments: [['\\/\\/+.*', 'comment']],
         numbers: [
             [/0[xX][0-9a-fA-F]*/, 'number'],
             [/[$][+-]*\d*(\.\d*)?/, 'number'],
-            [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number']
+            [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number'],
         ],
         strings: [
             [/H'/, { token: 'string.quote', bracket: '@open', next: '@string' }],
             [/h'/, { token: 'string.quote', bracket: '@open', next: '@string' }],
-            [/'/, { token: 'string.quote', bracket: '@open', next: '@string' }]
+            [/'/, { token: 'string.quote', bracket: '@open', next: '@string' }],
         ],
         string: [
             [/[^']+/, 'string'],
             [/''/, 'string'],
-            [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
+            [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
         ],
         dqstrings: [
             [/H"/, { token: 'string.quote', bracket: '@open', next: '@dqstring' }],
             [/h"/, { token: 'string.quote', bracket: '@open', next: '@dqstring' }],
-            [/"/, { token: 'string.quote', bracket: '@open', next: '@dqstring' }]
+            [/"/, { token: 'string.quote', bracket: '@open', next: '@dqstring' }],
         ],
         dqstring: [
             [/[^"]+/, 'string'],
             [/""/, 'string'],
-            [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
+            [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
         ],
-        literals: [[/datetime\(\d{4}-\d{2}-\d{2}(\s+\d{2}:\d{2}(:\d{2}(\.\d{0,3})?)?)?\)/, 'number'],
+        literals: [
+            [/datetime\(\d{4}-\d{2}-\d{2}(\s+\d{2}:\d{2}(:\d{2}(\.\d{0,3})?)?)?\)/, 'number'],
             [/time\((\d+(s(ec(onds?)?)?|m(in(utes?)?)?|h(ours?)?|d(ays?)?)|(\s*(('[^']+')|("[^"]+"))\s*))\)/, 'number'],
             [/guid\([\da-fA-F]{8}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{12}\)/, 'number'],
-            [/typeof\((int|string|date|datetime|time|long|real|boolean|bool)\)/, 'number']]
-    }
+            [/typeof\((int|string|date|datetime|time|long|real|boolean|bool)\)/, 'number'],
+        ],
+    },
 };

package/release/esm/languageService/schema.js

@@ -19,7 +19,7 @@ var dotnetTypeToKustoType = {
     'Newtonsoft.Json.Linq.JObject': 'dynamic',
     'Newtonsoft.Json.Linq.JToken': 'dynamic',
     'System.Object': 'dynamic',
-    'System.Data.SqlTypes.SqlDecimal': 'decimal'
+    'System.Data.SqlTypes.SqlDecimal': 'decimal',
 };
 export var getCslTypeNameFromClrType = function (clrType) { return dotnetTypeToKustoType[clrType] || clrType; };
 var kustoTypeToEntityDataType = {
@@ -38,27 +38,27 @@ var kustoTypeToEntityDataType = {
     datetime: 'DateTime',
     string: 'String',
     dynamic: 'Dynamic',
-    timespan: 'TimeSpan'
+    timespan: 'TimeSpan',
 };
 export var getEntityDataTypeFromCslType = function (cslType) { return kustoTypeToEntityDataType[cslType] || cslType; };
 export var getCallName = function (fn) {
-    return fn.name + "(" + fn.inputParameters.map(function (p) { return "{" + p.name + "}"; }).join(',') + ")";
+    return "".concat(fn.name, "(").concat(fn.inputParameters.map(function (p) { return "{".concat(p.name, "}"); }).join(','), ")");
 };
 export var getExpression = function (fn) {
-    return "let " + fn.name + " = " + getInputParametersAsCslString(fn.inputParameters) + " " + fn.body;
+    return "let ".concat(fn.name, " = ").concat(getInputParametersAsCslString(fn.inputParameters), " ").concat(fn.body);
 };
 export var getInputParametersAsCslString = function (inputParameters) {
-    return "(" + inputParameters.map(function (inputParameter) { return getInputParameterAsCslString(inputParameter); }).join(',') + ")";
+    return "(".concat(inputParameters.map(function (inputParameter) { return getInputParameterAsCslString(inputParameter); }).join(','), ")");
 };
 var getInputParameterAsCslString = function (inputParameter) {
     // If this is a tabular parameter
     if (inputParameter.columns && inputParameter.columns.length > 0) {
         var attributesAsString = inputParameter.columns
-            .map(function (col) { return col.name + ":" + (col.cslType || getCslTypeNameFromClrType(col.type)); })
+            .map(function (col) { return "".concat(col.name, ":").concat(col.cslType || getCslTypeNameFromClrType(col.type)); })
             .join(',');
-        return inputParameter.name + ":" + (attributesAsString === '' ? '*' : attributesAsString);
+        return "".concat(inputParameter.name, ":").concat(attributesAsString === '' ? '*' : attributesAsString);
     }
     else {
-        return inputParameter.name + ":" + (inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type));
+        return "".concat(inputParameter.name, ":").concat(inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type));
     }
 };

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

@@ -1,3 +1,4 @@
+/// <reference types="monaco-editor-core/monaco" />
 import IEvent = monaco.IEvent;
 export declare class LanguageServiceDefaultsImpl implements monaco.languages.kusto.LanguageServiceDefaults {
     private _onDidChange;