@kusto/monaco-kusto 10.0.8 → 10.0.9

package/release/esm/kustoMode.js

@@ -1,1173 +1,154 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 10.0.8(134ff03184264a9900737e4b5cf93f69540e1c8e)
- * Released under the MIT license
- * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
- *-----------------------------------------------------------------------------*/
-
-import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
-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;
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
         }
-      });
-    }
-    return 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']],
-  // types are wrong
-  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.
-  // Kusto.Data.IntelliSense.CslCommandParser.PromotedOperatorCommandTokens.slice(0),
-  promotedOperatorCommandTokens: ['where', 'count', 'extend', 'join', 'limit', 'order', 'project', 'project-away', 'project-rename', 'project-reorder', 'project-keep', 'render', 'sort', 'summarize', 'distinct', 'take', 'top', 'top-nested', 'top-hitters', 'union', 'mv-expand', 'mv-apply', 'reduce', 'evaluate', 'parse', 'parse-where', 'parse-kv', 'sample', 'sample-distinct', 'make-series', 'getschema', 'serialize', 'invoke', 'as', 'scan'],
-  // Kusto.Data.IntelliSense.CslCommandParser.OperatorCommandTokens.slice(0),
-  operatorCommandTokens: ['filter', 'fork', 'facet', 'range', 'consume', 'find', 'search', 'print', 'partition', 'lookup', 'where', 'count', 'extend', 'join', 'limit', 'order', 'project', 'project-away', 'project-rename', 'project-reorder', 'project-keep', 'render', 'sort', 'summarize', 'distinct', 'take', 'top', 'top-nested', 'top-hitters', 'union', 'mv-expand', 'mv-apply', 'reduce', 'evaluate', 'parse', 'parse-where', 'parse-kv', 'sample', 'sample-distinct', 'make-series', 'getschema', 'serialize', 'invoke', 'as', 'scan'],
-  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']]
-  }
-};
-
-// --- diagnostics ---
-
-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);
-      });
+        return t;
     };
-    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
-          }]);
-        });
-      }
-    };
-    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
-  };
-}
-/**
- * Copy of Kusto.Language.Editor.ClassificationKind we don't have to depend on it in this file
- */
-const ClassificationKind = {
-  PlainText: 0,
-  Comment: 1,
-  Punctuation: 2,
-  Directive: 3,
-  Literal: 4,
-  StringLiteral: 5,
-  Type: 6,
-  Column: 7,
-  Table: 8,
-  Database: 9,
-  Function: 10,
-  Parameter: 11,
-  Variable: 12,
-  Identifier: 13,
-  ClientParameter: 14,
-  QueryParameter: 15,
-  ScalarOperator: 16,
-  MathOperator: 17,
-  QueryOperator: 18,
-  Command: 19,
-  Keyword: 20,
-  MaterializedView: 21,
-  SchemaMember: 22,
-  SignatureParameter: 23,
-  Option: 24
+    return __assign.apply(this, arguments);
 };
-const ClassificationKindNames = {};
-for (const [key, value] of Object.entries(ClassificationKind)) {
-  ClassificationKindNames[value] = key;
-}
-
-// commented here is the color definitions are were defined by v1 intellisense terminology:
-// { token: 'comment', foreground: '008000' }, // CommentToken Green
-// { token: 'variable.predefined', foreground: '800080' }, // CalculatedColumnToken Purple
-// { token: 'function', foreground: '0000FF' }, // FunctionNameToken Blue
-// { token: 'operator.sql', foreground: 'FF4500' }, // OperatorToken OrangeRed (now changed to darker color CC3700 because wasn't accessible)
-// { token: 'string', foreground: 'B22222' }, // StringLiteralToken Firebrick
-// { token: 'operator.scss', foreground: '0000FF' }, // SubOperatorToken Blue
-// { token: 'variable', foreground: 'C71585' }, // TableColumnToken MediumVioletRed
-// { token: 'variable.parameter', foreground: '9932CC' }, // TableToken DarkOrchid
-// { token: '', foreground: '000000' }, // UnknownToken, PlainTextToken  Black
-// { token: 'type', foreground: '0000FF' }, // DataTypeToken Blue
-// { token: 'tag', foreground: '0000FF' }, // ControlCommandToken Blue
-// { token: 'annotation', foreground: '2B91AF' }, // QueryParametersToken FF2B91AF
-// { token: 'keyword', foreground: '0000FF' }, // CslCommandToken, PluginToken Blue
-// { token: 'number', foreground: '191970' }, // LetVariablesToken MidnightBlue
-// { token: 'annotation', foreground: '9400D3' }, // ClientDirectiveToken DarkViolet
-// { token: 'invalid', background: 'cd3131' },
-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'
-};
-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();
-        }
-      }
+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());
     });
-    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 monaco.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;
+};
+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 };
     }
-    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);
-    });
-  }
-}
-
-/**
- * Generates a mapping between ClassificationKind and color.
- */
-function getClassificationColorTriplets() {
-  const result = Object.keys(ClassificationKind).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;
-}
-
+};
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+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;
+});
 /**
- * Inject a CSS sheet to the head of document, coloring kusto elements by classification.
- * TODO: make idempotent
+ * Called when Kusto language is first needed (a model has the language set)
+ * @param defaults
  */
-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 monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
-  const inlineClassName = ClassificationKindNames[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 monaco.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 DEFAULT_DOCS_BASE_URL = 'https://learn.microsoft.com/azure/data-explorer/kusto/query';
-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 monaco.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,
-          // TODO: Is this cast safe?
-          documentation: this.formatDocLink(entry.documentation?.value),
-          detail: entry.detail,
-          range: wordRange,
-          kind: toCompletionItemKind(entry.kind)
-        };
-        if (entry.textEdit) {
-          // TODO: Where is the "range" property coming from?
-          item.range = toRange(entry.textEdit.range);
-          item.insertText = entry.textEdit.newText;
-        }
-        if (entry.insertTextFormat === ls.InsertTextFormat.Snippet) {
-          item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+export function setupMode(defaults, monacoInstance) {
+    var _this = this;
+    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];
         }
-        return item;
-      });
-      return {
-        isIncomplete: info.isIncomplete,
-        suggestions: items
-      };
-    });
-  }
-  formatDocLink(docString) {
-    // If the docString is empty, we want to return undefined to prevent an empty documentation popup.
-    if (!docString) {
-      return undefined;
-    }
-    const {
-      documentationBaseUrl = DEFAULT_DOCS_BASE_URL,
-      documentationSuffix
-    } = this.languageSettings;
-    const urisProxy = new Proxy({}, {
-      get(_target, prop, _receiver) {
-        // The link comes with a postfix of ".md" that we want to remove
-        let url = prop.toString().replace('.md', '');
-        // Sometimes we get the link as a full URL. For example in the main doc link of the item
-        if (!url.startsWith('https')) {
-          url = `${documentationBaseUrl}/${url}`;
+        var augmentedSetSchema = function (schema, worker) { return __awaiter(_this, void 0, void 0, function () {
+            var workerPromise;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        workerPromise = worker.setSchema(schema);
+                        return [4 /*yield*/, workerPromise.then(function () {
+                                onSchemaChange.fire(schema);
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        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) {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, worker.normalizeSchema(schema, connection, database).then(function (schema) {
+                                    if (globalScalarParameters || globalTabularParameters) {
+                                        schema = __assign(__assign({}, schema), { globalScalarParameters: globalScalarParameters, globalTabularParameters: globalTabularParameters });
+                                    }
+                                    augmentedSetSchema(schema, worker);
+                                })];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            } })); });
+    };
+    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;
         }
-        const monacoUri = monaco.Uri.parse(url);
-        if (documentationSuffix) {
-          // We need to override the toString method to add the suffix, otherwise it gets encoded and page doesn't open
-          monacoUri.toString = () => url + documentationSuffix;
+        if (e.languageSettings.useTokenColorization && monarchTokensProvider == undefined) {
+            monarchTokensProvider = monacoInstance.languages.setMonarchTokensProvider(language, KustoLanguageDefinition);
         }
-        return monacoUri;
-      }
-    });
-    return {
-      value: docString,
-      isTrusted: true,
-      uris: urisProxy
-    };
-  }
-}
-function isMarkupContent(thing) {
-  return thing && typeof thing === 'object' && typeof thing.kind === 'string';
-}
-function toMarkdownString(entry) {
-  if (typeof entry === 'string') {
-    return {
-      value: entry
-    };
-  }
-  if (isMarkupContent(entry)) {
-    if (entry.kind === 'plaintext') {
-      return {
-        value: entry.value.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&')
-      };
-    }
-    return {
-      value: entry.value
-    };
-  }
-  return {
-    value: '```' + entry.value + '\n' + entry.value + '\n```\n'
-  };
-}
-function toMarkedStringArray(contents) {
-  if (!contents) {
-    return void 0;
-  }
-  if (Array.isArray(contents)) {
-    return contents.map(toMarkdownString);
-  }
-  return [toMarkdownString(contents)];
-}
-
-// --- definition ------
-
-function toLocation(location) {
-  return {
-    uri: monaco.Uri.parse(location.uri),
-    range: toRange(location.range)
-  };
-}
-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 = monaco.Uri.parse(uri);
-    for (let e of edit.changes[uri]) {
-      resourceEdits.push({
-        resource: _uri,
-        textEdit: {
-          range: toRange(e.range),
-          text: e.newText
+    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,
         },
-        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)
-      };
     });
-  }
-}
-
-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 = async (schema, worker) => {
-      const workerPromise = worker.setSchema(schema);
-      await workerPromise.then(() => {
-        onSchemaChange.fire(schema);
-      });
-    };
-    const worker = client.getLanguageServiceWorker(...[first].concat(more));
-    return worker.then(worker => ({
-      ...worker,
-      setSchema: schema => augmentedSetSchema(schema, worker),
-      async setSchemaFromShowSchema(schema, connection, database, globalScalarParameters, globalTabularParameters) {
-        await worker.normalizeSchema(schema, connection, database).then(schema => {
-          if (globalScalarParameters || globalTabularParameters) {
-            schema = {
-              ...schema,
-              globalScalarParameters,
-              globalTabularParameters
-            };
-          }
-          augmentedSetSchema(schema, 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;
+    return kustoWorker;
 }
-function getKustoWorker() {
-  return workerPromise.then(() => kustoWorker);
+export function getKustoWorker() {
+    return workerPromise.then(function () { return kustoWorker; });
 }
-
-export { getKustoWorker, setupMode };