@kusto/monaco-kusto 8.2.0 → 8.3.0

package/release/esm/languageFeatures.js

@@ -0,0 +1,1072 @@
+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 __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));
+};
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import * as ls from 'vscode-languageserver-types';
+import debounce from 'lodash-es/debounce';
+var DiagnosticsAdapter = /** @class */ (function () {
+    function DiagnosticsAdapter(_monacoInstance, _languageId, _worker, defaults, onSchemaChange) {
+        var _this = this;
+        this._monacoInstance = _monacoInstance;
+        this._languageId = _languageId;
+        this._worker = _worker;
+        this.defaults = defaults;
+        this._disposables = [];
+        this._contentListener = Object.create(null);
+        this._configurationListener = Object.create(null);
+        this._schemaListener = Object.create(null);
+        this._cursorListener = Object.create(null);
+        this._debouncedValidations = Object.create(null);
+        var onModelAdd = function (model) {
+            var languageId = model.getLanguageId();
+            var modelUri = model.uri.toString();
+            if (languageId !== _this._languageId) {
+                return;
+            }
+            var debouncedValidation = _this.getOrCreateDebouncedValidation(model, languageId);
+            _this._contentListener[modelUri] = model.onDidChangeContent(function (e) {
+                var intervalsToValidate = changeEventToIntervals(e);
+                debouncedValidation(intervalsToValidate);
+            });
+            _this._configurationListener[modelUri] = _this.defaults.onDidChange(function () {
+                self.setTimeout(function () { return _this._doValidate(model, languageId, []); }, 0);
+            });
+            _this._schemaListener[modelUri] = onSchemaChange(function () {
+                self.setTimeout(function () { return _this._doValidate(model, languageId, []); }, 0);
+            });
+        };
+        var onEditorAdd = function (editor) {
+            var editorId = editor.getId();
+            if (!_this._cursorListener[editorId]) {
+                editor.onDidDispose(function () {
+                    var _a;
+                    (_a = _this._cursorListener[editorId]) === null || _a === void 0 ? void 0 : _a.dispose();
+                    delete _this._cursorListener[editorId];
+                });
+                _this._cursorListener[editorId] = editor.onDidChangeCursorSelection(function (e) {
+                    var model = editor.getModel();
+                    var languageId = model.getLanguageId();
+                    if (languageId !== _this._languageId) {
+                        return;
+                    }
+                    var cursorOffset = model.getOffsetAt(e.selection.getPosition());
+                    var debouncedValidation = _this.getOrCreateDebouncedValidation(model, languageId);
+                    debouncedValidation([{ start: cursorOffset, end: cursorOffset }]);
+                });
+            }
+        };
+        var onModelRemoved = function (model) {
+            _this._monacoInstance.editor.setModelMarkers(model, _this._languageId, []);
+            var uriStr = model.uri.toString();
+            var contentListener = _this._contentListener[uriStr];
+            if (contentListener) {
+                contentListener.dispose();
+                delete _this._contentListener[uriStr];
+            }
+            var configurationListener = _this._configurationListener[uriStr];
+            if (configurationListener) {
+                configurationListener.dispose();
+                delete _this._configurationListener[uriStr];
+            }
+            var schemaListener = _this._schemaListener[uriStr];
+            if (schemaListener) {
+                schemaListener.dispose();
+                delete _this._schemaListener[uriStr];
+            }
+            var debouncedValidation = _this._debouncedValidations[uriStr];
+            if (debouncedValidation) {
+                debouncedValidation.cancel();
+                delete _this._debouncedValidations[uriStr];
+            }
+        };
+        if (this.defaults.languageSettings.enableQuickFixes) {
+            this._disposables.push(monaco.languages.registerCodeActionProvider(this._languageId, {
+                provideCodeActions: function (model, range, context, _token) { return __awaiter(_this, void 0, void 0, function () {
+                    var startOffset, endOffset, showQuickFix, actions;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                startOffset = model.getOffsetAt(range.getStartPosition());
+                                endOffset = model.getOffsetAt(range.getEndPosition());
+                                showQuickFix = context.markers.length > 0;
+                                return [4 /*yield*/, this.getMonacoCodeActions(model, startOffset, endOffset, showQuickFix)];
+                            case 1:
+                                actions = _a.sent();
+                                return [2 /*return*/, {
+                                        actions: actions,
+                                        dispose: function () { },
+                                    }];
+                        }
+                    });
+                }); },
+            }));
+        }
+        this._disposables.push(this._monacoInstance.editor.onDidCreateEditor(onEditorAdd));
+        this._disposables.push(this._monacoInstance.editor.onDidCreateModel(onModelAdd));
+        this._disposables.push(this._monacoInstance.editor.onWillDisposeModel(onModelRemoved));
+        this._disposables.push(this._monacoInstance.editor.onDidChangeModelLanguage(function (event) {
+            onModelRemoved(event.model);
+            onModelAdd(event.model);
+        }));
+        this._disposables.push({
+            dispose: function () {
+                for (var key in _this._contentListener) {
+                    _this._contentListener[key].dispose();
+                }
+                for (var key in _this._cursorListener) {
+                    _this._cursorListener[key].dispose();
+                }
+                for (var key in _this._debouncedValidations) {
+                    _this._debouncedValidations[key].cancel();
+                }
+            },
+        });
+        this._monacoInstance.editor.getModels().forEach(onModelAdd);
+        this._monacoInstance.editor.getEditors().forEach(onEditorAdd);
+    }
+    DiagnosticsAdapter.prototype.getMonacoCodeActions = function (model, startOffset, endOffset, enableQuickFix) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var actions, worker, resource, codeActions, _loop_1, this_1, i, state_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        actions = [];
+                        return [4 /*yield*/, this._worker(model.uri)];
+                    case 1:
+                        worker = _b.sent();
+                        resource = model.uri;
+                        return [4 /*yield*/, worker.getResultActions(resource.toString(), startOffset, endOffset)];
+                    case 2:
+                        codeActions = _b.sent();
+                        _loop_1 = function (i) {
+                            var codeAction = codeActions[i];
+                            if (codeAction.kind.includes('Extract Function')) {
+                                return "continue";
+                            }
+                            var codeActionKind = ((_a = this_1.defaults.languageSettings.quickFixCodeActions) === null || _a === void 0 ? void 0 : _a.find(function (actionKind) {
+                                return codeAction.kind.includes(actionKind);
+                            }))
+                                ? 'quickfix'
+                                : 'custom';
+                            if (codeActionKind === 'quickfix' && !enableQuickFix) {
+                                return { value: void 0 };
+                            }
+                            var changes = codeAction.changes;
+                            var edits = changes.map(function (change) {
+                                var _a;
+                                var startPosition = model.getPositionAt(change.start);
+                                var endPosition = model.getPositionAt(change.start + change.deleteLength);
+                                return {
+                                    resource: model.uri,
+                                    textEdit: {
+                                        range: {
+                                            startLineNumber: startPosition.lineNumber,
+                                            startColumn: startPosition.column,
+                                            endLineNumber: endPosition.lineNumber,
+                                            endColumn: endPosition.column,
+                                        },
+                                        text: (_a = change.insertText) !== null && _a !== void 0 ? _a : '',
+                                    },
+                                };
+                            });
+                            actions.push({
+                                title: codeAction.title,
+                                diagnostics: [],
+                                kind: codeActionKind,
+                                edit: {
+                                    edits: __spreadArray([], edits, true),
+                                },
+                            });
+                        };
+                        this_1 = this;
+                        for (i = 0; i < codeActions.length; i++) {
+                            state_1 = _loop_1(i);
+                            if (typeof state_1 === "object")
+                                return [2 /*return*/, state_1.value];
+                        }
+                        return [2 /*return*/, actions];
+                }
+            });
+        });
+    };
+    DiagnosticsAdapter.prototype.getOrCreateDebouncedValidation = function (model, languageId) {
+        var _this = this;
+        var modelUri = model.uri.toString();
+        if (!this._debouncedValidations[modelUri]) {
+            this._debouncedValidations[modelUri] = debounce(function (intervals) { return _this._doValidate(model, languageId, intervals); }, 500);
+        }
+        return this._debouncedValidations[modelUri];
+    };
+    DiagnosticsAdapter.prototype.dispose = function () {
+        this._disposables.forEach(function (d) { return d && d.dispose(); });
+        this._disposables = [];
+    };
+    DiagnosticsAdapter.prototype._doValidate = function (model, languageId, intervals) {
+        var _this = this;
+        if (model.isDisposed()) {
+            return;
+        }
+        var resource = model.uri;
+        var versionNumberBefore = model.getVersionId();
+        this._worker(resource)
+            .then(function (worker) {
+            return worker.doValidation(resource.toString(), intervals);
+        })
+            .then(function (diagnostics) {
+            var newModel = _this._monacoInstance.editor.getModel(resource);
+            var versionId = newModel.getVersionId();
+            if (versionId !== versionNumberBefore) {
+                return;
+            }
+            var markers = diagnostics.map(function (d) { return toDiagnostics(resource, d); });
+            var model = _this._monacoInstance.editor.getModel(resource);
+            var oldDecorations = model
+                .getAllDecorations()
+                .filter(function (decoration) { return decoration.options.className == 'squiggly-error'; })
+                .map(function (decoration) { return decoration.id; });
+            if (model && model.getLanguageId() === languageId) {
+                var syntaxErrorAsMarkDown = _this.defaults.languageSettings.syntaxErrorAsMarkDown;
+                if (!syntaxErrorAsMarkDown || !syntaxErrorAsMarkDown.enableSyntaxErrorAsMarkDown) {
+                    // Remove previous syntax error decorations and set the new markers (for example, when disabling syntaxErrorAsMarkDown after it was enabled)
+                    model.deltaDecorations(oldDecorations, []);
+                    _this._monacoInstance.editor.setModelMarkers(model, languageId, markers);
+                }
+                else {
+                    // Add custom popup for syntax error: icon, header and message as markdown
+                    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: {
+                                startLineNumber: marker.startLineNumber,
+                                startColumn: marker.startColumn,
+                                endLineNumber: marker.endLineNumber,
+                                endColumn: marker.endColumn,
+                            },
+                            options: {
+                                hoverMessage: {
+                                    value: popupErrorHoverHeaderMessage_1 + marker.message,
+                                },
+                                className: 'squiggly-error',
+                                zIndex: 100,
+                                overviewRuler: {
+                                    // The color indication on the right ruler
+                                    color: 'rgb(255, 18, 18, 0.7)',
+                                    position: monaco.editor.OverviewRulerLane.Right,
+                                },
+                                minimap: {
+                                    color: 'rgb(255, 18, 18, 0.7)',
+                                    position: monaco.editor.MinimapPosition.Inline,
+                                },
+                            },
+                        };
+                    });
+                    var oldMarkers = monaco.editor.getModelMarkers({
+                        owner: languageId,
+                        resource: resource,
+                    });
+                    if (oldMarkers && oldMarkers.length > 0) {
+                        // In case there were previous markers, remove their decorations (for example, when enabling syntaxErrorAsMarkDown after it was disabled)
+                        oldDecorations = [];
+                        // Remove previous markers
+                        _this._monacoInstance.editor.setModelMarkers(model, languageId, []);
+                    }
+                    // Remove previous syntax error decorations and set the new decorations
+                    model.deltaDecorations(oldDecorations, newDecorations);
+                }
+            }
+        })
+            .then(undefined, function (err) {
+            console.error(err);
+        });
+    };
+    return DiagnosticsAdapter;
+}());
+export { DiagnosticsAdapter };
+function changeEventToIntervals(e) {
+    return e.changes.map(function (change) { return ({
+        start: change.rangeOffset,
+        end: change.rangeOffset + change.text.length,
+    }); });
+}
+function toSeverity(lsSeverity) {
+    switch (lsSeverity) {
+        case ls.DiagnosticSeverity.Error:
+            return monaco.MarkerSeverity.Error;
+        case ls.DiagnosticSeverity.Warning:
+            return monaco.MarkerSeverity.Warning;
+        case ls.DiagnosticSeverity.Information:
+            return monaco.MarkerSeverity.Info;
+        case ls.DiagnosticSeverity.Hint:
+            return monaco.MarkerSeverity.Hint;
+        default:
+            return monaco.MarkerSeverity.Info;
+    }
+}
+function toDiagnostics(resource, diag) {
+    var code = typeof diag.code === 'number' ? String(diag.code) : diag.code;
+    return {
+        severity: toSeverity(diag.severity),
+        startLineNumber: diag.range.start.line + 1,
+        startColumn: diag.range.start.character + 1,
+        endLineNumber: diag.range.end.line + 1,
+        endColumn: diag.range.end.character + 1,
+        message: diag.message,
+        code: code,
+        source: diag.source,
+    };
+}
+// --- colorization ---
+function fromIRange(range) {
+    if (!range) {
+        return undefined;
+    }
+    if (range instanceof monaco.Range) {
+        return { start: fromPosition(range.getStartPosition()), end: fromPosition(range.getEndPosition()) };
+    }
+    var startLineNumber = range.startLineNumber, startColumn = range.startColumn, endLineNumber = range.endLineNumber, endColumn = range.endColumn;
+    range = new monaco.Range(startLineNumber, startColumn, endLineNumber, endColumn);
+}
+/**
+ * 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, _a = Object.entries(ClassificationKind); _i < _a.length; _i++) {
+    var _b = _a[_i], key = _b[0], value = _b[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
+// { token: 'function', foreground: '0000FF' }, // FunctionNameToken Blue
+// { token: 'operator.sql', foreground: 'FF4500' }, // OperatorToken OrangeRed (now changed to darker color CC3700 because 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' },
+var classificationToColorLight = {
+    Column: 'C71585',
+    Comment: '008000',
+    Database: 'C71585',
+    Function: '0000FF',
+    Identifier: '000000',
+    Keyword: '0000FF',
+    Literal: 'B22222',
+    ScalarOperator: '0000FF',
+    MaterializedView: 'C71585',
+    MathOperator: '000000',
+    Command: '0000FF',
+    Parameter: '2B91AF',
+    PlainText: '000000',
+    Punctuation: '000000',
+    QueryOperator: 'CC3700',
+    QueryParameter: 'CC3700',
+    StringLiteral: 'B22222',
+    Table: 'C71585',
+    Type: '0000FF',
+    Variable: '191970',
+    Directive: '9400D3',
+    ClientParameter: 'b5cea8',
+    SchemaMember: 'C71585',
+    SignatureParameter: '2B91AF',
+    Option: '000000',
+};
+var classificationToColorDark = {
+    Column: '4ec9b0',
+    Comment: '6A9B34',
+    Database: 'c586c0',
+    Function: 'dcdcaa',
+    Identifier: 'd4d4d4',
+    Keyword: '569cd6',
+    Literal: 'ce9178',
+    ScalarOperator: '569cd6',
+    MaterializedView: 'c586c0',
+    MathOperator: 'd4d4d4',
+    Command: 'd4d4d4',
+    Parameter: '2B91AF',
+    PlainText: 'd4d4d4',
+    Punctuation: 'd4d4d4',
+    QueryOperator: '9cdcfe',
+    QueryParameter: '9cdcfe',
+    StringLiteral: 'ce9178',
+    Table: 'c586c0',
+    Type: '569cd6',
+    Variable: 'd7ba7d',
+    Directive: 'b5cea8',
+    ClientParameter: 'b5cea8',
+    SchemaMember: '4ec9b0',
+    SignatureParameter: '2B91AF',
+    Option: 'd4d4d4',
+};
+var ColorizationAdapter = /** @class */ (function () {
+    function ColorizationAdapter(_monacoInstance, _languageId, _worker, defaults, onSchemaChange) {
+        var _this = this;
+        this._monacoInstance = _monacoInstance;
+        this._languageId = _languageId;
+        this._worker = _worker;
+        this._disposables = [];
+        this._contentListener = Object.create(null);
+        this._configurationListener = Object.create(null);
+        this._schemaListener = Object.create(null);
+        this.decorations = [];
+        injectCss();
+        var onModelAdd = function (model) {
+            var languageId = model.getLanguageId();
+            if (languageId !== _this._languageId) {
+                return;
+            }
+            var debouncedColorization = debounce(function (intervals) { return _this._doColorization(model, languageId, intervals); }, 500);
+            var handle;
+            _this._contentListener[model.uri.toString()] = model.onDidChangeContent(function (e) {
+                // Changes are represented as a range in doc before change, plus the text that it was replaced with.
+                // We are interested in the range _after_ the change (since that's what we need to colorize).
+                // following logic calculates that.
+                var intervalsToColorize = changeEventToIntervals(e);
+                debouncedColorization(intervalsToColorize);
+            });
+            _this._configurationListener[model.uri.toString()] = defaults.onDidChange(function () {
+                self.setTimeout(function () { return _this._doColorization(model, languageId, []); }, 0);
+            });
+            _this._schemaListener[model.uri.toString()] = onSchemaChange(function () {
+                self.setTimeout(function () { return _this._doColorization(model, languageId, []); }, 0);
+            });
+        };
+        var onModelRemoved = function (model) {
+            model.deltaDecorations(_this.decorations, []);
+            var uriStr = model.uri.toString();
+            var contentListener = _this._contentListener[uriStr];
+            if (contentListener) {
+                contentListener.dispose();
+                delete _this._contentListener[uriStr];
+            }
+            var configurationListener = _this._configurationListener[uriStr];
+            if (configurationListener) {
+                configurationListener.dispose();
+                delete _this._configurationListener[uriStr];
+            }
+            var schemaListener = _this._configurationListener[uriStr];
+            if (schemaListener) {
+                schemaListener.dispose();
+                delete _this._schemaListener[uriStr];
+            }
+        };
+        this._disposables.push(this._monacoInstance.editor.onDidCreateModel(onModelAdd));
+        this._disposables.push(this._monacoInstance.editor.onWillDisposeModel(onModelRemoved));
+        this._disposables.push(this._monacoInstance.editor.onDidChangeModelLanguage(function (event) {
+            onModelRemoved(event.model);
+            onModelAdd(event.model);
+        }));
+        this._disposables.push({
+            dispose: function () {
+                for (var key in _this._contentListener) {
+                    _this._contentListener[key].dispose();
+                }
+            },
+        });
+        this._monacoInstance.editor.getModels().forEach(onModelAdd);
+    }
+    ColorizationAdapter.prototype.dispose = function () {
+        this._disposables.forEach(function (d) { return d && d.dispose(); });
+        this._disposables = [];
+    };
+    /**
+     * Return true if the range doesn't intersect any of the line ranges.
+     * @param range monaco.Range
+     * @param impactedLineRanges an array of line ranges
+     */
+    ColorizationAdapter.prototype._rangeDoesNotIntersectAny = function (range, impactedLineRanges) {
+        return impactedLineRanges.every(function (lineRange) {
+            return range.startLineNumber > lineRange.lastImpactedLine || range.endLineNumber < lineRange.firstImpactedLine;
+        });
+    };
+    ColorizationAdapter.prototype._doColorization = function (model, languageId, intervals) {
+        var _this = this;
+        if (model.isDisposed()) {
+            return;
+        }
+        var resource = model.uri;
+        var versionNumberBeforeColorization = model.getVersionId();
+        this._worker(resource)
+            .then(function (worker) {
+            return worker.doColorization(resource.toString(), intervals);
+        })
+            .then(function (colorizationRanges) {
+            var newModel = _this._monacoInstance.editor.getModel(model.uri);
+            var versionId = newModel.getVersionId();
+            // don't colorize an older version of the document.
+            if (versionId !== versionNumberBeforeColorization) {
+                return;
+            }
+            var decorationRanges = colorizationRanges.map(function (colorizationRange) {
+                var decorations = colorizationRange.classifications
+                    .map(function (classification) { return toDecoration(model, classification); })
+                    // The following line will prevent things that aren't going to be colorized anyway to get a CSS class.
+                    // This will prevent the case where the non-semantic colorizer already figured out that a keyword needs
+                    // to be colorized, but the outdated semantic colorizer still thinks it's a plain text and wants it colored
+                    // in black.
+                    .filter(function (d) {
+                    return d.options.inlineClassName !== 'PlainText' && d.options.inlineClassName != 'Identifier';
+                });
+                var firstImpactedLine = model.getPositionAt(colorizationRange.absoluteStart).lineNumber;
+                var endPosition = model.getPositionAt(colorizationRange.absoluteEnd);
+                // A token that ends in the first column of the next line is not considered to be part of that line.
+                var lastImpactedLine = endPosition.column == 1 && endPosition.lineNumber > 1
+                    ? endPosition.lineNumber - 1
+                    : endPosition.lineNumber;
+                return { decorations: decorations, firstImpactedLine: firstImpactedLine, lastImpactedLine: lastImpactedLine };
+            });
+            // Compute the previous decorations we want to replace with the new ones.
+            var oldDecorations = decorationRanges
+                .map(function (range) {
+                return model
+                    .getLinesDecorations(range.firstImpactedLine, range.lastImpactedLine)
+                    .filter(function (d) { return classificationToColorLight[d.options.inlineClassName]; }) // Don't delete any other decorations
+                    .map(function (d) { return d.id; });
+            })
+                .reduce(function (prev, curr) { return prev.concat(curr); }, []);
+            // Flatten decoration groups to an array of decorations
+            var newDecorations = decorationRanges.reduce(function (prev, next) { return prev.concat(next.decorations); }, []);
+            if (model && model.getLanguageId() === languageId) {
+                _this.decorations = model.deltaDecorations(oldDecorations, newDecorations);
+            }
+        })
+            .then(undefined, function (err) {
+            console.error(err);
+        });
+    };
+    return ColorizationAdapter;
+}());
+export { 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 result = Object.keys(ClassificationKind).map(function (key) { return ({
+        classification: key,
+        colorLight: classificationToColorLight[key],
+        colorDark: classificationToColorDark[key],
+    }); });
+    return result;
+}
+/**
+ * Returns a string which is a css describing all tokens and their colors.
+ * looks a little bit something like this:
+ *
+ * .vs .Literal {color: '#000000';} .vs-dark .Literal {color: '#FFFFFF';}
+ * .vs .Comment {color: '#111111';} .vs-dark .Comment {color: '#EEEEEE';}
+ */
+function getCssForClassification() {
+    var classificationColorTriplets = getClassificationColorTriplets();
+    var cssInnerHtml = classificationColorTriplets
+        .map(function (pair) {
+        return ".vs .".concat(pair.classification, " {color: #").concat(pair.colorLight, ";} .vs-dark .").concat(pair.classification, " {color: #").concat(pair.colorDark, ";}");
+    })
+        .join('\n');
+    return cssInnerHtml;
+}
+/**
+ * Inject a CSS sheet to the head of document, coloring kusto elements by classification.
+ * TODO: make idempotent
+ */
+function injectCss() {
+    var container = document.getElementsByTagName('head')[0];
+    var style = document.createElement('style');
+    style.type = 'text/css';
+    style.media = 'screen';
+    container.appendChild(style);
+    ClassificationKind;
+    style.innerHTML = getCssForClassification();
+}
+function toDecoration(model, classification) {
+    var start = model.getPositionAt(classification.start);
+    var end = model.getPositionAt(classification.start + classification.length);
+    var range = new monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
+    var inlineClassName = ClassificationKindNames[classification.kind];
+    return {
+        range: range,
+        options: {
+            inlineClassName: inlineClassName,
+            stickiness: monaco.editor.TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+        },
+    };
+}
+// --- completion ------
+function fromPosition(position) {
+    if (!position) {
+        return void 0;
+    }
+    return { character: position.column - 1, line: position.lineNumber - 1 };
+}
+function fromRange(range) {
+    if (!range) {
+        return void 0;
+    }
+    return { start: fromPosition(range.getStartPosition()), end: fromPosition(range.getEndPosition()) };
+}
+function toRange(range) {
+    if (!range) {
+        return void 0;
+    }
+    return new monaco.Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);
+}
+function toCompletionItemKind(kind) {
+    var mItemKind = monaco.languages.CompletionItemKind;
+    switch (kind) {
+        case ls.CompletionItemKind.Text:
+            return mItemKind.Text;
+        case ls.CompletionItemKind.Method:
+            return mItemKind.Method;
+        case ls.CompletionItemKind.Function:
+            return mItemKind.Function;
+        case ls.CompletionItemKind.Constructor:
+            return mItemKind.Constructor;
+        case ls.CompletionItemKind.Field:
+            return mItemKind.Field;
+        case ls.CompletionItemKind.Variable:
+            return mItemKind.Variable;
+        case ls.CompletionItemKind.Class:
+            return mItemKind.Class;
+        case ls.CompletionItemKind.Interface:
+            return mItemKind.Interface;
+        case ls.CompletionItemKind.Module:
+            return mItemKind.Module;
+        case ls.CompletionItemKind.Property:
+            return mItemKind.Property;
+        case ls.CompletionItemKind.Unit:
+            return mItemKind.Unit;
+        case ls.CompletionItemKind.Value:
+            return mItemKind.Value;
+        case ls.CompletionItemKind.Enum:
+            return mItemKind.Enum;
+        case ls.CompletionItemKind.Keyword:
+            return mItemKind.Keyword;
+        case ls.CompletionItemKind.Snippet:
+            return mItemKind.Snippet;
+        case ls.CompletionItemKind.Color:
+            return mItemKind.Color;
+        case ls.CompletionItemKind.File:
+            return mItemKind.File;
+        case ls.CompletionItemKind.Reference:
+            return mItemKind.Reference;
+    }
+    return mItemKind.Property;
+}
+function toTextEdit(textEdit) {
+    if (!textEdit) {
+        return void 0;
+    }
+    return {
+        range: toRange(textEdit.range),
+        text: textEdit.newText,
+    };
+}
+var DEFAULT_DOCS_BASE_URL = 'https://learn.microsoft.com/azure/data-explorer/kusto/query';
+var CompletionAdapter = /** @class */ (function () {
+    function CompletionAdapter(_worker, languageSettings) {
+        this._worker = _worker;
+        this.languageSettings = languageSettings;
+    }
+    Object.defineProperty(CompletionAdapter.prototype, "triggerCharacters", {
+        get: function () {
+            return [' '];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CompletionAdapter.prototype.provideCompletionItems = function (model, position, context, token) {
+        var _this = this;
+        var wordInfo = model.getWordUntilPosition(position);
+        var wordRange = new monaco.Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
+        var resource = model.uri;
+        var onDidProvideCompletionItems = this.languageSettings.onDidProvideCompletionItems;
+        return this._worker(resource)
+            .then(function (worker) {
+            return worker.doComplete(resource.toString(), fromPosition(position));
+        })
+            .then(function (info) { return (onDidProvideCompletionItems ? onDidProvideCompletionItems(info) : info); })
+            .then(function (info) {
+            if (!info) {
+                return;
+            }
+            var items = info.items.map(function (entry) {
+                var _a;
+                var item = {
+                    label: entry.label,
+                    insertText: entry.insertText,
+                    sortText: entry.sortText,
+                    filterText: entry.filterText,
+                    // TODO: Is this cast safe?
+                    documentation: _this.formatDocLink((_a = entry.documentation) === null || _a === void 0 ? void 0 : _a.value),
+                    detail: entry.detail,
+                    range: wordRange,
+                    kind: toCompletionItemKind(entry.kind),
+                };
+                if (entry.textEdit) {
+                    // TODO: Where is the "range" property coming from?
+                    item.range = toRange(entry.textEdit.range);
+                    item.insertText = entry.textEdit.newText;
+                }
+                if (entry.insertTextFormat === ls.InsertTextFormat.Snippet) {
+                    item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+                }
+                return item;
+            });
+            return {
+                isIncomplete: info.isIncomplete,
+                suggestions: items,
+            };
+        });
+    };
+    CompletionAdapter.prototype.formatDocLink = function (docString) {
+        // If the docString is empty, we want to return undefined to prevent an empty documentation popup.
+        if (!docString) {
+            return undefined;
+        }
+        var _a = this.languageSettings, _b = _a.documentationBaseUrl, documentationBaseUrl = _b === void 0 ? DEFAULT_DOCS_BASE_URL : _b, documentationSuffix = _a.documentationSuffix;
+        var urisProxy = new Proxy({}, {
+            get: function (_target, prop, _receiver) {
+                // The link comes with a postfix of ".md" that we want to remove
+                var url = prop.toString().replace('.md', '');
+                // Sometimes we get the link as a full URL. For example in the main doc link of the item
+                if (!url.startsWith('https')) {
+                    url = "".concat(documentationBaseUrl, "/").concat(url);
+                }
+                var monacoUri = monaco.Uri.parse(url);
+                if (documentationSuffix) {
+                    // We need to override the toString method to add the suffix, otherwise it gets encoded and page doesn't open
+                    monacoUri.toString = function () { return url + documentationSuffix; };
+                }
+                return monacoUri;
+            },
+        });
+        return { value: docString, isTrusted: true, uris: urisProxy };
+    };
+    return CompletionAdapter;
+}());
+export { CompletionAdapter };
+function isMarkupContent(thing) {
+    return thing && typeof thing === 'object' && typeof thing.kind === 'string';
+}
+function toMarkdownString(entry) {
+    if (typeof entry === 'string') {
+        return {
+            value: entry,
+        };
+    }
+    if (isMarkupContent(entry)) {
+        if (entry.kind === 'plaintext') {
+            return {
+                value: entry.value.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&'),
+            };
+        }
+        return {
+            value: entry.value,
+        };
+    }
+    return { value: '```' + entry.value + '\n' + entry.value + '\n```\n' };
+}
+function toMarkedStringArray(contents) {
+    if (!contents) {
+        return void 0;
+    }
+    if (Array.isArray(contents)) {
+        return contents.map(toMarkdownString);
+    }
+    return [toMarkdownString(contents)];
+}
+// --- definition ------
+function toLocation(location) {
+    return {
+        uri: monaco.Uri.parse(location.uri),
+        range: toRange(location.range),
+    };
+}
+var DefinitionAdapter = /** @class */ (function () {
+    function DefinitionAdapter(_worker) {
+        this._worker = _worker;
+    }
+    DefinitionAdapter.prototype.provideDefinition = function (model, position, token) {
+        var resource = model.uri;
+        return this._worker(resource)
+            .then(function (worker) {
+            return worker.findDefinition(resource.toString(), fromPosition(position));
+        })
+            .then(function (definition) {
+            if (!definition || definition.length == 0) {
+                return;
+            }
+            return [toLocation(definition[0])];
+        });
+    };
+    return DefinitionAdapter;
+}());
+export { DefinitionAdapter };
+// --- references ------
+var ReferenceAdapter = /** @class */ (function () {
+    function ReferenceAdapter(_worker) {
+        this._worker = _worker;
+    }
+    ReferenceAdapter.prototype.provideReferences = function (model, position, context, token) {
+        var resource = model.uri;
+        return this._worker(resource)
+            .then(function (worker) {
+            return worker.findReferences(resource.toString(), fromPosition(position));
+        })
+            .then(function (entries) {
+            if (!entries) {
+                return;
+            }
+            return entries.map(toLocation);
+        });
+    };
+    return ReferenceAdapter;
+}());
+export { ReferenceAdapter };
+// --- rename ------
+function toWorkspaceEdit(edit) {
+    if (!edit || !edit.changes) {
+        return void 0;
+    }
+    var resourceEdits = [];
+    for (var uri in edit.changes) {
+        var _uri = monaco.Uri.parse(uri);
+        for (var _i = 0, _a = edit.changes[uri]; _i < _a.length; _i++) {
+            var e = _a[_i];
+            resourceEdits.push({
+                resource: _uri,
+                textEdit: {
+                    range: toRange(e.range),
+                    text: e.newText,
+                },
+                versionId: undefined,
+            });
+        }
+    }
+    return {
+        edits: resourceEdits,
+    };
+}
+var RenameAdapter = /** @class */ (function () {
+    function RenameAdapter(_worker) {
+        this._worker = _worker;
+    }
+    RenameAdapter.prototype.provideRenameEdits = function (model, position, newName, token) {
+        var resource = model.uri;
+        return this._worker(resource)
+            .then(function (worker) {
+            return worker.doRename(resource.toString(), fromPosition(position), newName);
+        })
+            .then(function (edit) {
+            return toWorkspaceEdit(edit);
+        });
+    };
+    return RenameAdapter;
+}());
+export { RenameAdapter };
+// --- document symbols ------
+function toSymbolKind(kind) {
+    var mKind = monaco.languages.SymbolKind;
+    switch (kind) {
+        case ls.SymbolKind.File:
+            return mKind.Array;
+        case ls.SymbolKind.Module:
+            return mKind.Module;
+        case ls.SymbolKind.Namespace:
+            return mKind.Namespace;
+        case ls.SymbolKind.Package:
+            return mKind.Package;
+        case ls.SymbolKind.Class:
+            return mKind.Class;
+        case ls.SymbolKind.Method:
+            return mKind.Method;
+        case ls.SymbolKind.Property:
+            return mKind.Property;
+        case ls.SymbolKind.Field:
+            return mKind.Field;
+        case ls.SymbolKind.Constructor:
+            return mKind.Constructor;
+        case ls.SymbolKind.Enum:
+            return mKind.Enum;
+        case ls.SymbolKind.Interface:
+            return mKind.Interface;
+        case ls.SymbolKind.Function:
+            return mKind.Function;
+        case ls.SymbolKind.Variable:
+            return mKind.Variable;
+        case ls.SymbolKind.Constant:
+            return mKind.Constant;
+        case ls.SymbolKind.String:
+            return mKind.String;
+        case ls.SymbolKind.Number:
+            return mKind.Number;
+        case ls.SymbolKind.Boolean:
+            return mKind.Boolean;
+        case ls.SymbolKind.Array:
+            return mKind.Array;
+    }
+    return mKind.Function;
+}
+// --- formatting -----
+var DocumentFormatAdapter = /** @class */ (function () {
+    function DocumentFormatAdapter(_worker) {
+        this._worker = _worker;
+    }
+    DocumentFormatAdapter.prototype.provideDocumentFormattingEdits = function (model, options, token) {
+        var resource = model.uri;
+        return this._worker(resource).then(function (worker) {
+            return worker.doDocumentFormat(resource.toString()).then(function (edits) { return edits.map(function (edit) { return toTextEdit(edit); }); });
+        });
+    };
+    return DocumentFormatAdapter;
+}());
+export { DocumentFormatAdapter };
+var FormatAdapter = /** @class */ (function () {
+    function FormatAdapter(_worker) {
+        this._worker = _worker;
+    }
+    FormatAdapter.prototype.provideDocumentRangeFormattingEdits = function (model, range, options, token) {
+        var resource = model.uri;
+        return this._worker(resource).then(function (worker) {
+            return worker
+                .doRangeFormat(resource.toString(), fromRange(range))
+                .then(function (edits) { return edits.map(function (edit) { return toTextEdit(edit); }); });
+        });
+    };
+    return FormatAdapter;
+}());
+export { FormatAdapter };
+// --- Folding ---
+var FoldingAdapter = /** @class */ (function () {
+    function FoldingAdapter(_worker) {
+        this._worker = _worker;
+    }
+    FoldingAdapter.prototype.provideFoldingRanges = function (model, context, token) {
+        var resource = model.uri;
+        return this._worker(resource).then(function (worker) {
+            return worker
+                .doFolding(resource.toString())
+                .then(function (foldingRanges) {
+                return foldingRanges.map(function (range) { return toFoldingRange(range); });
+            });
+        });
+    };
+    return FoldingAdapter;
+}());
+export { FoldingAdapter };
+function toFoldingRange(range) {
+    return {
+        start: range.startLine + 1,
+        end: range.endLine + 1,
+        kind: monaco.languages.FoldingRangeKind.Region,
+    };
+}
+// --- hover ------
+var HoverAdapter = /** @class */ (function () {
+    function HoverAdapter(_worker) {
+        this._worker = _worker;
+    }
+    HoverAdapter.prototype.provideHover = function (model, position, token) {
+        var resource = model.uri;
+        return this._worker(resource)
+            .then(function (worker) {
+            return worker.doHover(resource.toString(), fromPosition(position));
+        })
+            .then(function (info) {
+            if (!info) {
+                return;
+            }
+            return {
+                range: toRange(info.range),
+                contents: toMarkedStringArray(info.contents),
+            };
+        });
+    };
+    return HoverAdapter;
+}());
+export { HoverAdapter };