@kusto/monaco-kusto 5.6.6 → 6.1.0

package/release/esm/kustoMode.js

@@ -1,101 +1,1133 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-kusto version: 6.1.0(b14a2ec944d355ac340af8280e7c1a4ea98f6c8c)
+ * Released under the MIT license
+ * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
+ *-----------------------------------------------------------------------------*/
+
+import * as ls from 'vscode-languageserver-types';
+import debounce from 'lodash-es/debounce';
+
+class WorkerManager {
+  constructor(_monacoInstance, defaults) {
+    this._monacoInstance = _monacoInstance;
+    this._defaults = defaults;
+    this._worker = null;
+    this._idleCheckInterval = self.setInterval(() => this._checkIfIdle(), 30 * 1000);
+    this._lastUsedTime = 0;
+    this._configChangeListener = this._defaults.onDidChange(() => this._saveStateAndStopWorker());
+  }
+  _stopWorker() {
+    if (this._worker) {
+      this._worker.dispose();
+      this._worker = null;
+    }
+    this._client = null;
+  }
+  _saveStateAndStopWorker() {
+    if (!this._worker) {
+      return;
+    }
+    this._worker.getProxy().then(proxy => {
+      proxy.getSchema().then(schema => {
+        this._storedState = {
+          schema: schema
+        };
+        this._stopWorker();
+      });
+    });
+  }
+  dispose() {
+    clearInterval(this._idleCheckInterval);
+    this._configChangeListener.dispose();
+    this._stopWorker();
+  }
+  _checkIfIdle() {
+    if (!this._worker) {
+      return;
+    }
+    const maxIdleTime = this._defaults.getWorkerMaxIdleTime();
+    let timePassedSinceLastUsed = Date.now() - this._lastUsedTime;
+    if (maxIdleTime > 0 && timePassedSinceLastUsed > maxIdleTime) {
+      this._saveStateAndStopWorker();
+    }
+  }
+  _getClient() {
+    this._lastUsedTime = Date.now();
+
+    // Since onDidProvideCompletionItems is not used in web worker, and since functions cannot be trivially serialized (throws exception unable to clone), We remove it here.
+    const {
+      onDidProvideCompletionItems,
+      ...languageSettings
+    } = this._defaults.languageSettings;
+    if (!this._client) {
+      this._worker = this._monacoInstance.editor.createWebWorker({
+        // module that exports the create() method and returns a `KustoWorker` instance
+        moduleId: 'vs/language/kusto/kustoWorker',
+        label: 'kusto',
+        // passed in to the create() method
+        createData: {
+          languageSettings: languageSettings,
+          languageId: 'kusto'
+        }
+      });
+      this._client = this._worker.getProxy().then(proxy => {
+        // push state we held onto before killing the client.
+        if (this._storedState) {
+          return proxy.setSchema(this._storedState.schema).then(() => proxy);
+        } else {
+          return proxy;
         }
-        return t;
+      });
+    }
+    return this._client;
+  }
+  getLanguageServiceWorker(...resources) {
+    let _client;
+    return this._getClient().then(client => {
+      _client = client;
+    }).then(_ => {
+      return this._worker.withSyncedResources(resources);
+    }).then(_ => _client);
+  }
+}
+
+const KustoLanguageDefinition = {
+  name: 'kusto',
+  mimeTypes: ['text/kusto'],
+  displayName: 'Kusto',
+  defaultToken: 'invalid',
+  brackets: [['[', ']', 'delimiter.square'], ['(', ')', 'delimiter.parenthesis']],
+  wordDefinition: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  // .slice() call is for creating a shallow copy of the array since bridge.net shoves a $type property on the array which monaco doesn't like.
+  promotedOperatorCommandTokens: Kusto.Data.IntelliSense.CslCommandParser.PromotedOperatorCommandTokens.slice(0),
+  operatorCommandTokens: Kusto.Data.IntelliSense.CslCommandParser.OperatorCommandTokens.slice(0),
+  keywords: ['by', 'on', 'contains', 'notcontains', 'containscs', 'notcontainscs', 'startswith', 'has', 'matches', 'regex', 'true', 'false', 'and', 'or', 'typeof', 'int', 'string', 'date', 'datetime', 'time', 'long', 'real', '​boolean', 'bool'],
+  operators: ['+', '-', '*', '/', '>', '<', '==', '<>', '<=', '>=', '~', '!~'],
+  builtinFunctions: ['countof', 'bin', 'extentid', 'extract', 'extractjson', 'floor', 'iif', 'isnull', 'isnotnull', 'notnull', 'isempty', 'isnotempty', 'notempty', 'now', 're2', 'strcat', 'strlen', 'toupper', 'tostring', 'count', 'cnt', 'sum', 'min', 'max', 'avg'],
+  tokenizer: {
+    root: [{
+      include: '@whitespace'
+    }, {
+      include: '@numbers'
+    }, {
+      include: '@strings'
+    }, {
+      include: '@dqstrings'
+    }, {
+      include: '@literals'
+    }, {
+      include: '@comments'
+    }, [/[;,.]/, 'delimiter'], [/[()\[\]]/, '@brackets'], [/[<>=!%&+\-*/|~^]/, 'operator'], [/[\w@#\-$]+/, {
+      cases: {
+        '@keywords': 'keyword',
+        '@promotedOperatorCommandTokens': 'operator.sql',
+        '@operatorCommandTokens': 'keyword',
+        '@operators': 'operator',
+        '@builtinFunctions': 'predefined',
+        '@default': 'identifier'
+      }
+    }]],
+    whitespace: [[/\s+/, 'white']],
+    comments: [['\\/\\/+.*', 'comment']],
+    numbers: [[/0[xX][0-9a-fA-F]*/, 'number'], [/[$][+-]*\d*(\.\d*)?/, 'number'], [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number']],
+    strings: [[/H'/, {
+      token: 'string.quote',
+      bracket: '@open',
+      next: '@string'
+    }], [/h'/, {
+      token: 'string.quote',
+      bracket: '@open',
+      next: '@string'
+    }], [/'/, {
+      token: 'string.quote',
+      bracket: '@open',
+      next: '@string'
+    }]],
+    string: [[/[^']+/, 'string'], [/''/, 'string'], [/'/, {
+      token: 'string.quote',
+      bracket: '@close',
+      next: '@pop'
+    }]],
+    dqstrings: [[/H"/, {
+      token: 'string.quote',
+      bracket: '@open',
+      next: '@dqstring'
+    }], [/h"/, {
+      token: 'string.quote',
+      bracket: '@open',
+      next: '@dqstring'
+    }], [/"/, {
+      token: 'string.quote',
+      bracket: '@open',
+      next: '@dqstring'
+    }]],
+    dqstring: [[/[^"]+/, 'string'], [/""/, 'string'], [/"/, {
+      token: 'string.quote',
+      bracket: '@close',
+      next: '@pop'
+    }]],
+    literals: [[/datetime\(\d{4}-\d{2}-\d{2}(\s+\d{2}:\d{2}(:\d{2}(\.\d{0,3})?)?)?\)/, 'number'], [/time\((\d+(s(ec(onds?)?)?|m(in(utes?)?)?|h(ours?)?|d(ays?)?)|(\s*(('[^']+')|("[^"]+"))\s*))\)/, 'number'], [/guid\([\da-fA-F]{8}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{12}\)/, 'number'], [/typeof\((int|string|date|datetime|time|long|real|boolean|bool)\)/, 'number']]
+  }
+};
+
+var Uri = monaco.Uri;
+monaco.Position;
+var Range = monaco.Range;
+monaco.Thenable;
+monaco.CancellationToken;
+monaco.IDisposable;
+var ClassificationKind = Kusto.Language.Editor.ClassificationKind;
+class DiagnosticsAdapter {
+  _disposables = [];
+  _contentListener = Object.create(null);
+  _configurationListener = Object.create(null);
+  _schemaListener = Object.create(null);
+  _cursorListener = Object.create(null);
+  _debouncedValidations = Object.create(null);
+  constructor(_monacoInstance, _languageId, _worker, defaults, onSchemaChange) {
+    this._monacoInstance = _monacoInstance;
+    this._languageId = _languageId;
+    this._worker = _worker;
+    this.defaults = defaults;
+    const onModelAdd = model => {
+      let languageId = model.getLanguageId();
+      const modelUri = model.uri.toString();
+      if (languageId !== this._languageId) {
+        return;
+      }
+      const debouncedValidation = this.getOrCreateDebouncedValidation(model, languageId);
+      this._contentListener[modelUri] = model.onDidChangeContent(e => {
+        const intervalsToValidate = changeEventToIntervals(e);
+        debouncedValidation(intervalsToValidate);
+      });
+      this._configurationListener[modelUri] = this.defaults.onDidChange(() => {
+        self.setTimeout(() => this._doValidate(model, languageId, []), 0);
+      });
+      this._schemaListener[modelUri] = onSchemaChange(() => {
+        self.setTimeout(() => this._doValidate(model, languageId, []), 0);
+      });
+    };
+    const onEditorAdd = editor => {
+      const editorId = editor.getId();
+      if (!this._cursorListener[editorId]) {
+        editor.onDidDispose(() => {
+          this._cursorListener[editorId]?.dispose();
+          delete this._cursorListener[editorId];
+        });
+        this._cursorListener[editorId] = editor.onDidChangeCursorSelection(e => {
+          const model = editor.getModel();
+          const languageId = model.getLanguageId();
+          if (languageId !== this._languageId) {
+            return;
+          }
+          const cursorOffset = model.getOffsetAt(e.selection.getPosition());
+          const debouncedValidation = this.getOrCreateDebouncedValidation(model, languageId);
+          debouncedValidation([{
+            start: cursorOffset,
+            end: cursorOffset
+          }]);
+        });
+      }
     };
-    return __assign.apply(this, arguments);
+    const onModelRemoved = model => {
+      this._monacoInstance.editor.setModelMarkers(model, this._languageId, []);
+      let uriStr = model.uri.toString();
+      let contentListener = this._contentListener[uriStr];
+      if (contentListener) {
+        contentListener.dispose();
+        delete this._contentListener[uriStr];
+      }
+      let configurationListener = this._configurationListener[uriStr];
+      if (configurationListener) {
+        configurationListener.dispose();
+        delete this._configurationListener[uriStr];
+      }
+      let schemaListener = this._schemaListener[uriStr];
+      if (schemaListener) {
+        schemaListener.dispose();
+        delete this._schemaListener[uriStr];
+      }
+      let 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: async (model, range, context, _token) => {
+          const startOffset = model.getOffsetAt(range.getStartPosition());
+          const endOffset = model.getOffsetAt(range.getEndPosition());
+          // We want to show the quick fix option only if we have markers in our selected range
+          const showQuickFix = context.markers.length > 0;
+          const actions = await this.getMonacoCodeActions(model, startOffset, endOffset, showQuickFix);
+          return {
+            actions,
+            dispose: () => {}
+          };
+        }
+      }));
+    }
+    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(event => {
+      onModelRemoved(event.model);
+      onModelAdd(event.model);
+    }));
+    this._disposables.push({
+      dispose: () => {
+        for (let key in this._contentListener) {
+          this._contentListener[key].dispose();
+        }
+        for (let key in this._cursorListener) {
+          this._cursorListener[key].dispose();
+        }
+        for (let key in this._debouncedValidations) {
+          this._debouncedValidations[key].cancel();
+        }
+      }
+    });
+    this._monacoInstance.editor.getModels().forEach(onModelAdd);
+    this._monacoInstance.editor.getEditors().forEach(onEditorAdd);
+  }
+  async getMonacoCodeActions(model, startOffset, endOffset, enableQuickFix) {
+    const actions = [];
+    const worker = await this._worker(model.uri);
+    const resource = model.uri;
+    const codeActions = await worker.getResultActions(resource.toString(), startOffset, endOffset);
+    for (let i = 0; i < codeActions.length; i++) {
+      const codeAction = codeActions[i];
+      if (codeAction.kind.includes('Extract Function')) {
+        // Ignore extract function actions for now since they are buggy currently
+        continue;
+      }
+      const codeActionKind = this.defaults.languageSettings.quickFixCodeActions?.find(actionKind => codeAction.kind.includes(actionKind)) ? 'quickfix' : 'custom';
+      if (codeActionKind === 'quickfix' && !enableQuickFix) {
+        return;
+      }
+      const changes = codeAction.changes;
+      const edits = changes.map(change => {
+        const startPosition = model.getPositionAt(change.start);
+        const 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: change.insertText ?? ''
+          }
+        };
+      });
+      actions.push({
+        title: codeAction.title,
+        diagnostics: [],
+        kind: codeActionKind,
+        edit: {
+          edits: [...edits]
+        }
+      });
+    }
+    return actions;
+  }
+  getOrCreateDebouncedValidation(model, languageId) {
+    const modelUri = model.uri.toString();
+    if (!this._debouncedValidations[modelUri]) {
+      this._debouncedValidations[modelUri] = debounce(intervals => this._doValidate(model, languageId, intervals), 500);
+    }
+    return this._debouncedValidations[modelUri];
+  }
+  dispose() {
+    this._disposables.forEach(d => d && d.dispose());
+    this._disposables = [];
+  }
+  _doValidate(model, languageId, intervals) {
+    if (model.isDisposed()) {
+      return;
+    }
+    const resource = model.uri;
+    const versionNumberBefore = model.getVersionId();
+    this._worker(resource).then(worker => {
+      return worker.doValidation(resource.toString(), intervals);
+    }).then(diagnostics => {
+      const newModel = this._monacoInstance.editor.getModel(resource);
+      const versionId = newModel.getVersionId();
+      if (versionId !== versionNumberBefore) {
+        return;
+      }
+      const markers = diagnostics.map(d => toDiagnostics(resource, d));
+      let model = this._monacoInstance.editor.getModel(resource);
+      let oldDecorations = model.getAllDecorations().filter(decoration => decoration.options.className == 'squiggly-error').map(decoration => decoration.id);
+      if (model && model.getLanguageId() === languageId) {
+        const 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
+          const header = syntaxErrorAsMarkDown.header ? `**${syntaxErrorAsMarkDown.header}** \n\n` : '';
+          const icon = syntaxErrorAsMarkDown.icon ? `![](${syntaxErrorAsMarkDown.icon})` : '';
+          const popupErrorHoverHeaderMessage = `${icon} ${header}`;
+          const newDecorations = markers.map(marker => {
+            return {
+              range: {
+                startLineNumber: marker.startLineNumber,
+                startColumn: marker.startColumn,
+                endLineNumber: marker.endLineNumber,
+                endColumn: marker.endColumn
+              },
+              options: {
+                hoverMessage: {
+                  value: popupErrorHoverHeaderMessage + marker.message
+                },
+                className: 'squiggly-error',
+                // monaco syntax error style (red underline)
+                zIndex: 100,
+                // This message will be the upper most mesage in the popup
+                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
+                }
+              }
+            };
+          });
+          const 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, err => {
+      console.error(err);
+    });
+  }
+}
+function changeEventToIntervals(e) {
+  return e.changes.map(change => ({
+    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) {
+  let 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
+  };
+}
+// 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' },
+const 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'
 };
-import { WorkerManager } from './workerManager';
-import { KustoLanguageDefinition } from './languageService/kustoMonarchLanguageDefinition';
-import * as languageFeatures from './languageFeatures';
-var kustoWorker;
-var resolveWorker;
-var rejectWorker;
-var workerPromise = new Promise(function (resolve, reject) {
-    resolveWorker = resolve;
-    rejectWorker = reject;
-});
+const 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'
+};
+class ColorizationAdapter {
+  _disposables = [];
+  _contentListener = Object.create(null);
+  _configurationListener = Object.create(null);
+  _schemaListener = Object.create(null);
+  decorations = [];
+  constructor(_monacoInstance, _languageId, _worker, defaults, onSchemaChange) {
+    this._monacoInstance = _monacoInstance;
+    this._languageId = _languageId;
+    this._worker = _worker;
+    injectCss();
+    const onModelAdd = model => {
+      let languageId = model.getLanguageId();
+      if (languageId !== this._languageId) {
+        return;
+      }
+      const debouncedColorization = debounce(intervals => this._doColorization(model, languageId, intervals), 500);
+      this._contentListener[model.uri.toString()] = model.onDidChangeContent(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.
+        const intervalsToColorize = changeEventToIntervals(e);
+        debouncedColorization(intervalsToColorize);
+      });
+      this._configurationListener[model.uri.toString()] = defaults.onDidChange(() => {
+        self.setTimeout(() => this._doColorization(model, languageId, []), 0);
+      });
+      this._schemaListener[model.uri.toString()] = onSchemaChange(() => {
+        self.setTimeout(() => this._doColorization(model, languageId, []), 0);
+      });
+    };
+    const onModelRemoved = model => {
+      model.deltaDecorations(this.decorations, []);
+      let uriStr = model.uri.toString();
+      let contentListener = this._contentListener[uriStr];
+      if (contentListener) {
+        contentListener.dispose();
+        delete this._contentListener[uriStr];
+      }
+      let configurationListener = this._configurationListener[uriStr];
+      if (configurationListener) {
+        configurationListener.dispose();
+        delete this._configurationListener[uriStr];
+      }
+      let 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(event => {
+      onModelRemoved(event.model);
+      onModelAdd(event.model);
+    }));
+    this._disposables.push({
+      dispose: () => {
+        for (let key in this._contentListener) {
+          this._contentListener[key].dispose();
+        }
+      }
+    });
+    this._monacoInstance.editor.getModels().forEach(onModelAdd);
+  }
+  dispose() {
+    this._disposables.forEach(d => 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
+   */
+  _rangeDoesNotIntersectAny(range, impactedLineRanges) {
+    return impactedLineRanges.every(lineRange => range.startLineNumber > lineRange.lastImpactedLine || range.endLineNumber < lineRange.firstImpactedLine);
+  }
+  _doColorization(model, languageId, intervals) {
+    if (model.isDisposed()) {
+      return;
+    }
+    const resource = model.uri;
+    const versionNumberBeforeColorization = model.getVersionId();
+    this._worker(resource).then(worker => {
+      return worker.doColorization(resource.toString(), intervals);
+    }).then(colorizationRanges => {
+      const newModel = this._monacoInstance.editor.getModel(model.uri);
+      const versionId = newModel.getVersionId();
+
+      // don't colorize an older version of the document.
+      if (versionId !== versionNumberBeforeColorization) {
+        return;
+      }
+      const decorationRanges = colorizationRanges.map(colorizationRange => {
+        const decorations = colorizationRange.classifications.map(classification => 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(d => d.options.inlineClassName !== 'PlainText' && d.options.inlineClassName != 'Identifier');
+        const firstImpactedLine = model.getPositionAt(colorizationRange.absoluteStart).lineNumber;
+        const 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.
+        const lastImpactedLine = endPosition.column == 1 && endPosition.lineNumber > 1 ? endPosition.lineNumber - 1 : endPosition.lineNumber;
+        return {
+          decorations,
+          firstImpactedLine,
+          lastImpactedLine
+        };
+      });
+
+      // Compute the previous decorations we want to replace with the new ones.
+      const oldDecorations = decorationRanges.map(range => model.getLinesDecorations(range.firstImpactedLine, range.lastImpactedLine).filter(d => classificationToColorLight[d.options.inlineClassName]) // Don't delete any other decorations
+      .map(d => d.id)).reduce((prev, curr) => prev.concat(curr), []);
+
+      // Flatten decoration groups to an array of decorations
+      const newDecorations = decorationRanges.reduce((prev, next) => prev.concat(next.decorations), []);
+      if (model && model.getLanguageId() === languageId) {
+        this.decorations = model.deltaDecorations(oldDecorations, newDecorations);
+      }
+    }).then(undefined, err => {
+      console.error(err);
+    });
+  }
+}
+
 /**
- * Called when Kusto language is first needed (a model has the language set)
- * @param defaults
+ * Gets all keys of an enum (the string keys not the numeric values).
+ * @param e Enum type
  */
-export function setupMode(defaults, monacoInstance) {
-    var onSchemaChange = new monaco.Emitter();
-    // TODO: when should we dispose of these? seems like monaco-css and monaco-typescript don't dispose of these.
-    var disposables = [];
-    var monarchTokensProvider;
-    var client = new WorkerManager(monacoInstance, defaults);
-    disposables.push(client);
-    var workerAccessor = function (first) {
-        var more = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            more[_i - 1] = arguments[_i];
-        }
-        var augmentedSetSchema = function (schema, worker, globalScalarParameters, globalTabularParameters) {
-            var workerPromise = worker.setSchema(schema);
-            workerPromise.then(function () {
-                onSchemaChange.fire(schema);
-            });
+function getEnumKeys(e) {
+  return Object.keys(e).filter(k => typeof e[k] === 'number');
+}
+
+/**
+ * Generates a mapping between ClassificationKind and color.
+ */
+function getClassificationColorTriplets() {
+  const keys = getEnumKeys(ClassificationKind);
+  const result = keys.map(key => ({
+    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() {
+  const classificationColorTriplets = getClassificationColorTriplets();
+  const cssInnerHtml = classificationColorTriplets.map(pair => `.vs .${pair.classification} {color: #${pair.colorLight};} .vs-dark .${pair.classification} {color: #${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() {
+  const container = document.getElementsByTagName('head')[0];
+  var style = document.createElement('style');
+  style.type = 'text/css';
+  style.media = 'screen';
+  container.appendChild(style);
+  style.innerHTML = getCssForClassification();
+}
+function toDecoration(model, classification) {
+  const start = model.getPositionAt(classification.start);
+  const end = model.getPositionAt(classification.start + classification.length);
+  const range = new Range(start.lineNumber, start.column, end.lineNumber, end.column);
+  const inlineClassName = ClassificationKind.$names[classification.kind];
+  return {
+    range,
+    options: {
+      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) {
+  let 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
+  };
+}
+const 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;
+  }
+  const target = {};
+  const urisProxy = new Proxy(target, {
+    get(_target, prop, _receiver) {
+      // The link comes with a postfix of ".md" that we want to remove
+      const linkWithoutPostfix = prop.toString().replace('.md', '');
+      // Sometimes we get the link as a full URL. For example in the main doc link of the item
+      const fullURL = linkWithoutPostfix.startsWith('https') ? linkWithoutPostfix : `${DOCS_BASE_URL}/${linkWithoutPostfix}`;
+      return monaco.Uri.parse(fullURL);
+    }
+  });
+  return {
+    value: docString,
+    isTrusted: true,
+    uris: urisProxy
+  };
+}
+class CompletionAdapter {
+  constructor(_worker, languageSettings) {
+    this._worker = _worker;
+    this.languageSettings = languageSettings;
+  }
+  get triggerCharacters() {
+    return [' '];
+  }
+  provideCompletionItems(model, position, context, token) {
+    const wordInfo = model.getWordUntilPosition(position);
+    const wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
+    const resource = model.uri;
+    const onDidProvideCompletionItems = this.languageSettings.onDidProvideCompletionItems;
+    return this._worker(resource).then(worker => {
+      return worker.doComplete(resource.toString(), fromPosition(position));
+    }).then(info => onDidProvideCompletionItems ? onDidProvideCompletionItems(info) : info).then(info => {
+      if (!info) {
+        return;
+      }
+      let items = info.items.map(entry => {
+        let item = {
+          label: entry.label,
+          insertText: entry.insertText,
+          sortText: entry.sortText,
+          filterText: entry.filterText,
+          documentation: formatDocLink(entry.documentation?.value),
+          detail: entry.detail,
+          range: wordRange,
+          kind: toCompletionItemKind(entry.kind)
         };
-        var worker = client.getLanguageServiceWorker.apply(client, [first].concat(more));
-        return worker.then(function (worker) {
-            return (__assign(__assign({}, worker), { setSchema: function (schema) { return augmentedSetSchema(schema, worker); }, setSchemaFromShowSchema: function (schema, connection, database, globalScalarParameters, globalTabularParameters) {
-                    worker
-                        .normalizeSchema(schema, connection, database)
-                        .then(function (schema) {
-                        return globalScalarParameters
-                            ? __assign(__assign({}, schema), { globalScalarParameters: globalScalarParameters, globalTabularParameters: globalTabularParameters }) : schema;
-                    })
-                        .then(function (normalized) { return augmentedSetSchema(normalized, worker); });
-                } }));
-        });
-    };
-    var language = 'kusto';
-    disposables.push(monacoInstance.languages.registerCompletionItemProvider(language, new languageFeatures.CompletionAdapter(workerAccessor, defaults.languageSettings)));
-    // Monaco tokenization runs in main thread so we're using a quick schema-unaware tokenization.
-    // a web worker will run semantic colorization in the background (ColorizationAdapter).
-    if (defaults.languageSettings.useTokenColorization) {
-        monarchTokensProvider = monacoInstance.languages.setMonarchTokensProvider(language, KustoLanguageDefinition);
-    }
-    // listen to configuration changes and if we're switching from semantic to monarch colorization, do the switch.
-    defaults.onDidChange(function (e) {
-        if (!e.languageSettings.useTokenColorization && monarchTokensProvider !== undefined) {
-            monarchTokensProvider.dispose();
-            monarchTokensProvider = undefined;
+        if (entry.textEdit) {
+          item.range = toRange(entry.textEdit.range);
+          item.insertText = entry.textEdit.newText;
         }
-        if (e.languageSettings.useTokenColorization && monarchTokensProvider == undefined) {
-            monarchTokensProvider = monacoInstance.languages.setMonarchTokensProvider(language, KustoLanguageDefinition);
+        if (entry.insertTextFormat === ls.InsertTextFormat.Snippet) {
+          item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
         }
+        return item;
+      });
+      return {
+        isIncomplete: info.isIncomplete,
+        suggestions: items
+      };
     });
-    disposables.push(new languageFeatures.DiagnosticsAdapter(monacoInstance, language, workerAccessor, defaults, onSchemaChange.event));
-    disposables.push(new languageFeatures.ColorizationAdapter(monacoInstance, language, workerAccessor, defaults, onSchemaChange.event));
-    disposables.push(monacoInstance.languages.registerDocumentRangeFormattingEditProvider(language, new languageFeatures.FormatAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerFoldingRangeProvider(language, new languageFeatures.FoldingAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerDefinitionProvider(language, new languageFeatures.DefinitionAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerRenameProvider(language, new languageFeatures.RenameAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerReferenceProvider(language, new languageFeatures.ReferenceAdapter(workerAccessor)));
-    if (defaults.languageSettings.enableHover) {
-        disposables.push(monacoInstance.languages.registerHoverProvider(language, new languageFeatures.HoverAdapter(workerAccessor)));
-    }
-    monacoInstance.languages.registerDocumentFormattingEditProvider(language, new languageFeatures.DocumentFormatAdapter(workerAccessor));
-    kustoWorker = workerAccessor;
-    resolveWorker(workerAccessor);
-    monacoInstance.languages.setLanguageConfiguration(language, {
-        folding: {
-            offSide: false,
-            markers: { start: /^\s*[\r\n]/gm, end: /^\s*[\r\n]/gm },
-        },
-        comments: {
-            lineComment: '//',
-            blockComment: null,
+  }
+}
+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)
+  };
+}
+class DefinitionAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideDefinition(model, position, token) {
+    const resource = model.uri;
+    return this._worker(resource).then(worker => {
+      return worker.findDefinition(resource.toString(), fromPosition(position));
+    }).then(definition => {
+      if (!definition || definition.length == 0) {
+        return;
+      }
+      return [toLocation(definition[0])];
+    });
+  }
+}
+
+// --- references ------
+
+class ReferenceAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideReferences(model, position, context, token) {
+    const resource = model.uri;
+    return this._worker(resource).then(worker => {
+      return worker.findReferences(resource.toString(), fromPosition(position));
+    }).then(entries => {
+      if (!entries) {
+        return;
+      }
+      return entries.map(toLocation);
+    });
+  }
+}
+
+// --- rename ------
+
+function toWorkspaceEdit(edit) {
+  if (!edit || !edit.changes) {
+    return void 0;
+  }
+  let resourceEdits = [];
+  for (let uri in edit.changes) {
+    const _uri = Uri.parse(uri);
+    for (let e of edit.changes[uri]) {
+      resourceEdits.push({
+        resource: _uri,
+        textEdit: {
+          range: toRange(e.range),
+          text: e.newText
         },
+        versionId: undefined
+      });
+    }
+  }
+  return {
+    edits: resourceEdits
+  };
+}
+class RenameAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideRenameEdits(model, position, newName, token) {
+    const resource = model.uri;
+    return this._worker(resource).then(worker => {
+      return worker.doRename(resource.toString(), fromPosition(position), newName);
+    }).then(edit => {
+      return toWorkspaceEdit(edit);
+    });
+  }
+}
+
+// --- formatting -----
+
+class DocumentFormatAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideDocumentFormattingEdits(model, options, token) {
+    const resource = model.uri;
+    return this._worker(resource).then(worker => {
+      return worker.doDocumentFormat(resource.toString()).then(edits => edits.map(edit => toTextEdit(edit)));
+    });
+  }
+}
+class FormatAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideDocumentRangeFormattingEdits(model, range, options, token) {
+    const resource = model.uri;
+    return this._worker(resource).then(worker => {
+      return worker.doRangeFormat(resource.toString(), fromRange(range)).then(edits => edits.map(edit => toTextEdit(edit)));
+    });
+  }
+}
+
+// --- Folding ---
+class FoldingAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideFoldingRanges(model, context, token) {
+    const resource = model.uri;
+    return this._worker(resource).then(worker => {
+      return worker.doFolding(resource.toString()).then(foldingRanges => foldingRanges.map(range => toFoldingRange(range)));
+    });
+  }
+}
+function toFoldingRange(range) {
+  return {
+    start: range.startLine + 1,
+    end: range.endLine + 1,
+    kind: monaco.languages.FoldingRangeKind.Region
+  };
+}
+
+// --- hover ------
+
+class HoverAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideHover(model, position, token) {
+    let resource = model.uri;
+    return this._worker(resource).then(worker => {
+      return worker.doHover(resource.toString(), fromPosition(position));
+    }).then(info => {
+      if (!info) {
+        return;
+      }
+      return {
+        range: toRange(info.range),
+        contents: toMarkedStringArray(info.contents)
+      };
     });
-    return kustoWorker;
+  }
+}
+
+monaco.Uri;
+monaco.IDisposable;
+let kustoWorker;
+let resolveWorker;
+let workerPromise = new Promise((resolve, reject) => {
+  resolveWorker = resolve;
+});
+
+/**
+ * Called when Kusto language is first needed (a model has the language set)
+ * @param defaults
+ */
+function setupMode(defaults, monacoInstance) {
+  let onSchemaChange = new monaco.Emitter();
+  // TODO: when should we dispose of these? seems like monaco-css and monaco-typescript don't dispose of these.
+  let disposables = [];
+  let monarchTokensProvider;
+  const client = new WorkerManager(monacoInstance, defaults);
+  disposables.push(client);
+  const workerAccessor = (first, ...more) => {
+    const augmentedSetSchema = (schema, worker, globalScalarParameters, globalTabularParameters) => {
+      const workerPromise = worker.setSchema(schema);
+      workerPromise.then(() => {
+        onSchemaChange.fire(schema);
+      });
+    };
+    const worker = client.getLanguageServiceWorker(...[first].concat(more));
+    return worker.then(worker => ({
+      ...worker,
+      setSchema: schema => augmentedSetSchema(schema, worker),
+      setSchemaFromShowSchema: (schema, connection, database, globalScalarParameters, globalTabularParameters) => {
+        worker.normalizeSchema(schema, connection, database).then(schema => globalScalarParameters ? {
+          ...schema,
+          globalScalarParameters,
+          globalTabularParameters
+        } : schema).then(normalized => augmentedSetSchema(normalized, worker));
+      }
+    }));
+  };
+  const language = 'kusto';
+  disposables.push(monacoInstance.languages.registerCompletionItemProvider(language, new CompletionAdapter(workerAccessor, defaults.languageSettings)));
+
+  // Monaco tokenization runs in main thread so we're using a quick schema-unaware tokenization.
+  // a web worker will run semantic colorization in the background (ColorizationAdapter).
+  if (defaults.languageSettings.useTokenColorization) {
+    monarchTokensProvider = monacoInstance.languages.setMonarchTokensProvider(language, KustoLanguageDefinition);
+  }
+
+  // listen to configuration changes and if we're switching from semantic to monarch colorization, do the switch.
+  defaults.onDidChange(e => {
+    if (!e.languageSettings.useTokenColorization && monarchTokensProvider !== undefined) {
+      monarchTokensProvider.dispose();
+      monarchTokensProvider = undefined;
+    }
+    if (e.languageSettings.useTokenColorization && monarchTokensProvider == undefined) {
+      monarchTokensProvider = monacoInstance.languages.setMonarchTokensProvider(language, KustoLanguageDefinition);
+    }
+  });
+  disposables.push(new DiagnosticsAdapter(monacoInstance, language, workerAccessor, defaults, onSchemaChange.event));
+  disposables.push(new ColorizationAdapter(monacoInstance, language, workerAccessor, defaults, onSchemaChange.event));
+  disposables.push(monacoInstance.languages.registerDocumentRangeFormattingEditProvider(language, new FormatAdapter(workerAccessor)));
+  disposables.push(monacoInstance.languages.registerFoldingRangeProvider(language, new FoldingAdapter(workerAccessor)));
+  disposables.push(monacoInstance.languages.registerDefinitionProvider(language, new DefinitionAdapter(workerAccessor)));
+  disposables.push(monacoInstance.languages.registerRenameProvider(language, new RenameAdapter(workerAccessor)));
+  disposables.push(monacoInstance.languages.registerReferenceProvider(language, new ReferenceAdapter(workerAccessor)));
+  if (defaults.languageSettings.enableHover) {
+    disposables.push(monacoInstance.languages.registerHoverProvider(language, new HoverAdapter(workerAccessor)));
+  }
+  monacoInstance.languages.registerDocumentFormattingEditProvider(language, new DocumentFormatAdapter(workerAccessor));
+  kustoWorker = workerAccessor;
+  resolveWorker(workerAccessor);
+  monacoInstance.languages.setLanguageConfiguration(language, {
+    folding: {
+      offSide: false,
+      markers: {
+        start: /^\s*[\r\n]/gm,
+        end: /^\s*[\r\n]/gm
+      }
+    },
+    comments: {
+      lineComment: '//',
+      blockComment: null
+    }
+  });
+  return kustoWorker;
 }
-export function getKustoWorker() {
-    return workerPromise.then(function () { return kustoWorker; });
+function getKustoWorker() {
+  return workerPromise.then(() => kustoWorker);
 }
+
+export { getKustoWorker, setupMode };