@kusto/monaco-kusto 5.6.5 → 6.0.0

package/release/esm/languageFeatures.js

@@ -1,1030 +0,0 @@
-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 ls from './_deps/vscode-languageserver-types/main';
-import * as _ from './_deps/lodash/lodash';
-var Uri = monaco.Uri;
-var Range = monaco.Range;
-var ClassificationKind = Kusto.Language.Editor.ClassificationKind;
-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];
-            }
-        };
-        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.title.includes('Extract Function')) {
-                                return "continue";
-                            }
-                            var codeActionKind = ((_a = this_1.defaults.languageSettings.quickFixCodeActions) === null || _a === void 0 ? void 0 : _a.find(function (actionTitle) {
-                                return codeAction.title.includes(actionTitle);
-                            }))
-                                ? '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);
-}
-// 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).
-                // folowing 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 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 keys = getEnumKeys(ClassificationKind);
-    var result = keys.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 Range(start.lineNumber, start.column, end.lineNumber, end.column);
-    var inlineClassName = ClassificationKind.$names[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 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 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) {
-        return undefined;
-    }
-    var target = {};
-    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', '');
-            // 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
-                : "".concat(DOCS_BASE_URL, "/").concat(linkWithoutPostfix);
-            return monaco.Uri.parse(fullURL);
-        },
-    });
-    return { value: docString, isTrusted: true, uris: urisProxy };
-}
-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 wordInfo = model.getWordUntilPosition(position);
-        var wordRange = new 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,
-                    documentation: formatDocLink((_a = entry.documentation) === null || _a === void 0 ? void 0 : _a.value),
-                    detail: entry.detail,
-                    range: wordRange,
-                    kind: toCompletionItemKind(entry.kind),
-                };
-                if (entry.textEdit) {
-                    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,
-            };
-        });
-    };
-    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: 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 = 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 };