@kusto/monaco-kusto 11.4.0 → 12.0.1

package/release/esm/languageServiceManager/kustoLanguageService.js

@@ -9,6 +9,42 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -86,18 +122,6 @@ export var TokenKind;
     TokenKind[TokenKind["BracketRangeToken"] = 262144] = "BracketRangeToken";
     TokenKind[TokenKind["ClientDirectiveToken"] = 524288] = "ClientDirectiveToken";
 })(TokenKind || (TokenKind = {}));
-/**
- * convert the bridge.net object to a plain javascript object that only contains data.
- * @param k2Classifications @kusto/language-service-next bridge.net object
- */
-function toClassifiedRange(k2Classifications) {
-    return k2Classifications.map(function (classification) { return ({
-        start: classification.Start,
-        end: classification.End,
-        length: classification.Length,
-        kind: classification.Kind,
-    }); });
-}
 var symbolKindToName = (_a = {},
     _a[sym.SymbolKind.Cluster] = 'Cluster',
     _a[sym.SymbolKind.Column] = 'Column',
@@ -182,22 +206,6 @@ var KustoLanguageService = /** @class */ (function () {
             '3Dchart': k2.CompletionKind.RenderChart,
             list: k2.CompletionKind.RenderChart,
         };
-        this.disabledCompletionItemsV1 = {
-            capacity: k.OptionKind.Policy,
-            callout: k.OptionKind.Policy,
-            encoding: k.OptionKind.Policy,
-            batching: k.OptionKind.Policy,
-            querythrottling: k.OptionKind.Policy,
-            merge: k.OptionKind.Policy,
-            querylimit: k.OptionKind.Policy,
-            rowstore: k.OptionKind.Policy,
-            streamingingestion: k.OptionKind.Policy,
-            restricted_view_access: k.OptionKind.Policy,
-            sharding: k.OptionKind.Policy,
-            'restricted-viewers': k.OptionKind.Policy,
-            attach: k.OptionKind.Command,
-            purge: k.OptionKind.Command,
-        };
         this._kustoKindtolsKind = (_b = {},
             _b[k.OptionKind.None] = ls.CompletionItemKind.Interface,
             _b[k.OptionKind.Operator] = ls.CompletionItemKind.Method,
@@ -675,46 +683,27 @@ var KustoLanguageService = /** @class */ (function () {
             return ls.Diagnostic.create(range, diag.Message, severity, diag.Code);
         });
     };
-    /**
-     * Colorize one or more kusto blocks (a.k.a commands), or just the entire document.
-     * Supports multi-cursor editing (colorizes blocks on multiple changes).
-     * @param document The document to colorize
-     * @param changeIntervals an array containing 0 or more changed intervals. if the array is empty - just colorize the entire row.
-     * if the array contains a single change - just color the kusto blocks that wraps this change. If multiple changes are provided,
-     * colorize all blocks that intersect these changes.
-     * The code will try to only parse once if this is the same command.
-     */
-    KustoLanguageService.prototype.doColorization = function (document, changeIntervals) {
-        var _this = this;
-        if (!document || !this._languageSettings.useSemanticColorization) {
-            return Promise.resolve([]);
-        }
-        // V2 intellisense
-        var script = this.parseDocumentV2(document);
-        if (changeIntervals.length > 0) {
-            var blocks_1 = this.toArray(script.Blocks);
-            var affectedBlocks = this.getAffectedBlocks(blocks_1, changeIntervals);
-            var result = affectedBlocks.map(function (block) { return ({
-                classifications: toClassifiedRange(_this.toArray(block.Service.GetClassifications(block.Start, block.End).Classifications)),
-                absoluteStart: block.Start,
-                absoluteEnd: block.End,
-            }); });
-            return Promise.resolve(result);
-        }
-        // Entire document requested
-        var blocks = this.toArray(script.Blocks);
-        var classifications = blocks
-            .map(function (block) {
-            return _this.toArray(block.Service.GetClassifications(block.Start, block.Length).Classifications);
-        })
-            .reduce(function (prev, curr) { return prev.concat(curr); }, []);
-        return Promise.resolve([
-            {
-                classifications: toClassifiedRange(classifications),
-                absoluteStart: 0,
-                absoluteEnd: document.getText().length,
-            },
-        ]);
+    KustoLanguageService.prototype.getClassifications = function (document) {
+        return __awaiter(this, void 0, void 0, function () {
+            var codeScript, codeBlocks, classificationRanges;
+            var _this = this;
+            return __generator(this, function (_a) {
+                codeScript = this.parseDocumentV2(document);
+                codeBlocks = this.toArray(codeScript.Blocks);
+                classificationRanges = codeBlocks.map(function (block) {
+                    var Classifications = block.Service.GetClassifications(block.Start, block.Length).Classifications;
+                    return _this.toArray(Classifications);
+                });
+                return [2 /*return*/, classificationRanges.flatMap(function (ranges) {
+                        return ranges.map(function (range) {
+                            var _a = document.positionAt(range.Start), line = _a.line, character = _a.character;
+                            var length = range.Length;
+                            var kind = range.Kind;
+                            return { line: line, character: character, length: length, kind: kind };
+                        });
+                    })];
+            });
+        });
     };
     KustoLanguageService.prototype.getAffectedBlocks = function (blocks, changeIntervals) {
         return blocks.filter(function (block) {
@@ -1612,8 +1601,7 @@ var KustoLanguageService = /** @class */ (function () {
         return command;
     };
     KustoLanguageService.prototype.getCurrentCommandV2 = function (script, offset) {
-        var block = script.GetBlockAtPosition(offset);
-        return block;
+        return script.GetBlockAtPosition(offset);
     };
     KustoLanguageService.prototype.getTextToInsert = function (rule, option) {
         var beforeApplyInfo = rule.GetBeforeApplyInfo(option.Value);
@@ -1744,7 +1732,6 @@ var KustoLanguageService = /** @class */ (function () {
 }());
 var languageService = new KustoLanguageService(KustoLanguageService.dummySchema, {
     includeControlCommands: true,
-    useSemanticColorization: true,
     completionOptions: { includeExtendedSyntax: false },
 });
 /**

package/release/esm/languageServiceManager/schema.d.ts

@@ -62,8 +62,8 @@ export interface EngineSchema {
         readonly databases: readonly Database[];
     };
     readonly database: Database | undefined;
-    readonly globalScalarParameters?: readonly ScalarParameter[];
-    readonly globalTabularParameters?: readonly TabularParameter[];
+    globalScalarParameters?: readonly ScalarParameter[];
+    globalTabularParameters?: readonly TabularParameter[];
 }
 export type TableEntityType = 'Table' | 'ExternalTable' | 'MaterializedViewTable';
 export interface ClusterMangerSchema {

package/release/esm/languageServiceManager/settings.d.ts

@@ -3,8 +3,6 @@ export interface LanguageSettings {
     includeControlCommands?: boolean;
     newlineAfterPipe?: boolean;
     openSuggestionDialogAfterPreviousSuggestionAccepted?: boolean;
-    useSemanticColorization?: boolean;
-    useTokenColorization?: boolean;
     disabledCompletionItems?: string[];
     onDidProvideCompletionItems?: OnDidProvideCompletionItems;
     enableHover?: boolean;

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

@@ -5,7 +5,7 @@ export * from './languageServiceManager/schema';
 export * from './languageServiceManager/renderInfo';
 export * from './languageServiceManager/settings';
 export * from './types';
-export { getCurrentCommandRange } from './extendedEditor';
+export * from './extendedGlobalApi';
 declare class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
     private _onDidChange;
     private _languageSettings;
@@ -19,8 +19,3 @@ declare class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
 }
 export declare function getKustoWorker(): Promise<WorkerAccessor>;
 export declare const kustoDefaults: LanguageServiceDefaultsImpl;
-export declare const themeNames: {
-    light: string;
-    dark: string;
-    dark2: string;
-};

package/release/esm/monaco.contribution.js

@@ -1,14 +1,64 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import * as mode from './kustoMode';
 import KustoCommandHighlighter from './commandHighlighter';
 import KustoCommandFormatter from './commandFormatter';
-import { extend, getCurrentCommandRange } from './extendedEditor';
-import { getCslTypeNameFromClrType, getCallName, getExpression, getInputParametersAsCslString, getEntityDataTypeFromCslType, } from './languageServiceManager/schema';
+import { extend } from './extendedEditor';
+import { themes } from './syntaxHighlighting/themes';
+import { LANGUAGE_ID } from './globals';
+import * as schema from './languageServiceManager/schema';
+import { getRangeHtml } from './extendedGlobalApi';
 export * from './languageServiceManager/schema';
 export * from './languageServiceManager/renderInfo';
 export * from './languageServiceManager/settings';
 export * from './types';
-export { getCurrentCommandRange } from './extendedEditor';
-// --- Kusto configuration and defaults ---------
+export * from './extendedGlobalApi';
 var LanguageServiceDefaultsImpl = /** @class */ (function () {
     function LanguageServiceDefaultsImpl(languageSettings) {
         this._onDidChange = new monaco.Emitter();
@@ -53,8 +103,6 @@ var defaultLanguageSettings = {
     includeControlCommands: true,
     newlineAfterPipe: true,
     openSuggestionDialogAfterPreviousSuggestionAccepted: true,
-    useSemanticColorization: true,
-    useTokenColorization: false,
     enableHover: true,
     formatter: {
         indentationSize: 4,
@@ -71,85 +119,23 @@ var defaultLanguageSettings = {
     completionOptions: { includeExtendedSyntax: false },
 };
 export function getKustoWorker() {
-    return new Promise(function (resolve, reject) {
-        withMode(function (mode) {
-            mode.getKustoWorker().then(resolve, reject);
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, mode.getKustoWorker()];
         });
     });
 }
-function withMode(callback) {
-    import('./kustoMode').then(callback);
-}
 export var kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
-export var themeNames = {
-    light: 'kusto-light',
-    dark: 'kusto-dark',
-    dark2: 'kusto-dark2',
-};
-monaco.languages.onLanguage('kusto', function () {
-    withMode(function (mode) { return mode.setupMode(kustoDefaults, monaco); });
+monaco.languages.onLanguage(LANGUAGE_ID, function () {
+    mode.setupMode(kustoDefaults, monaco);
 });
 monaco.languages.register({
-    id: 'kusto',
+    id: LANGUAGE_ID,
     extensions: ['.csl', '.kql'],
 });
-monaco.editor.defineTheme(themeNames.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.editor.defineTheme(themeNames.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.editor.defineTheme(themeNames.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',
-    },
+themes.forEach(function (_a) {
+    var name = _a.name, data = _a.data;
+    return monaco.editor.defineTheme(name, data);
 });
 // 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
@@ -193,15 +179,5 @@ function triggerSuggestDialogWhenCompletionItemSelected(editor) {
 function isStandaloneCodeEditor(editor) {
     return editor.addAction !== undefined;
 }
-var globalApi = {
-    getCslTypeNameFromClrType: getCslTypeNameFromClrType,
-    getCallName: getCallName,
-    getExpression: getExpression,
-    getInputParametersAsCslString: getInputParametersAsCslString,
-    getEntityDataTypeFromCslType: getEntityDataTypeFromCslType,
-    kustoDefaults: kustoDefaults,
-    getKustoWorker: getKustoWorker,
-    getCurrentCommandRange: getCurrentCommandRange,
-    themeNames: themeNames,
-};
+var globalApi = __assign(__assign({}, schema), { kustoDefaults: kustoDefaults, getKustoWorker: getKustoWorker, getRangeHtml: getRangeHtml });
 monaco.languages.kusto = globalApi;

package/release/esm/{schema-c006895b.js → schema-b8f0ba9b.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 11.4.0(7572339ea10d5d0fdd55c4a2b813f3663acab903)
+ * monaco-kusto version: 12.0.1(56b90ce0fd31e7d6792f5098d1e8204274966b6e)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -81,4 +81,14 @@ const getInputParameterAsCslString = inputParameter => {
  */
 let showSchema;
 
-export { getCallName as a, getExpression as b, getInputParametersAsCslString as c, getEntityDataTypeFromCslType as d, getCslTypeNameFromClrType as g, showSchema as s };
+const schema = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    getCallName,
+    getCslTypeNameFromClrType,
+    getEntityDataTypeFromCslType,
+    getExpression,
+    getInputParametersAsCslString,
+    showSchema
+}, Symbol.toStringTag, { value: 'Module' }));
+
+export { getEntityDataTypeFromCslType as a, getCallName as b, getExpression as c, getInputParametersAsCslString as d, showSchema as e, getCslTypeNameFromClrType as g, schema as s };

package/release/esm/syntaxHighlighting/SemanticTokensProvider.d.ts

@@ -0,0 +1,18 @@
+import type * as monaco from 'monaco-editor';
+import { editor } from 'monaco-editor';
+import { ClassificationRange } from './types';
+type ClassificationsGetter = (uri: string) => Promise<ClassificationRange[]>;
+export declare class SemanticTokensProvider implements monaco.languages.DocumentSemanticTokensProvider {
+    private readonly classificationsGetter;
+    constructor(classificationsGetter: ClassificationsGetter);
+    getLegend(): {
+        tokenTypes: import("./types").Token[];
+        tokenModifiers: any[];
+    };
+    provideDocumentSemanticTokens(model: editor.ITextModel): Promise<{
+        data: Uint32Array;
+        resultId: string;
+    }>;
+    releaseDocumentSemanticTokens(): void;
+}
+export {};

package/release/esm/syntaxHighlighting/SemanticTokensProvider.js

@@ -0,0 +1,78 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { tokenTypes } from './types';
+var SemanticTokensProvider = /** @class */ (function () {
+    function SemanticTokensProvider(classificationsGetter) {
+        this.classificationsGetter = classificationsGetter;
+    }
+    SemanticTokensProvider.prototype.getLegend = function () {
+        return { tokenTypes: tokenTypes, tokenModifiers: [] };
+    };
+    SemanticTokensProvider.prototype.provideDocumentSemanticTokens = function (model) {
+        return __awaiter(this, void 0, void 0, function () {
+            var uri, classifications, semanticTokens;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        uri = model.uri.toString();
+                        return [4 /*yield*/, this.classificationsGetter(uri)];
+                    case 1:
+                        classifications = _a.sent();
+                        semanticTokens = classifications.map(function (classification, index) {
+                            var previousClassification = classifications[index - 1];
+                            return semanticTokenMaker(classification, previousClassification);
+                        });
+                        return [2 /*return*/, {
+                                data: new Uint32Array(semanticTokens.flat()),
+                                resultId: model.getVersionId().toString(),
+                            }];
+                }
+            });
+        });
+    };
+    SemanticTokensProvider.prototype.releaseDocumentSemanticTokens = function () { };
+    return SemanticTokensProvider;
+}());
+export { SemanticTokensProvider };
+var emptyClassification = { line: 0, character: 0, length: 0, kind: 0 };
+function semanticTokenMaker(classification, previousClassification) {
+    if (previousClassification === void 0) { previousClassification = emptyClassification; }
+    var line = classification.line, character = classification.character, length = classification.length, kind = classification.kind;
+    var deltaLine = line - previousClassification.line;
+    var deltaStart = deltaLine ? character : character - previousClassification.character;
+    return [deltaLine, deltaStart, length, kind, 0];
+}

package/release/esm/syntaxHighlighting/kustoMonarchLanguageDefinition.d.ts

@@ -0,0 +1,2 @@
+import type * as monaco from 'monaco-editor';
+export declare const kustoLanguageDefinition: monaco.languages.IMonarchLanguage;