@kusto/monaco-kusto 12.0.3 → 12.0.4

package/release/esm/kustoMode.js

@@ -1,148 +1,941 @@
-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: 12.0.4(d2b0b92cc089b35f33fd16e2da422c4ffc972e0c)
+ * 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';
+import { L as LANGUAGE_ID, T as Token, t as tokenTypes } from './globals-9d8df38a.js';
+
+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 this._client;
+  }
+  getLanguageServiceWorker(...resources) {
+    let _client;
+    return this._getClient().then(client => {
+      _client = client;
+    }).then(_ => {
+      return this._worker.withSyncedResources(resources);
+    }).then(_ => _client);
+  }
+}
+
+const createCompletionCacheManager = getFromLanguageService => {
+  let completionList;
+  let lastWord;
+  return {
+    getCompletionItems: (word, resource, position) => {
+      const shouldGetItems = !lastWord || !word || !word?.includes(lastWord);
+      if (shouldGetItems) {
+        completionList = getFromLanguageService(resource, position);
+      }
+      lastWord = word;
+      return completionList;
+    }
+  };
+};
+
+function createCompletionFilteredText(userInput, completionItem) {
+  if (!userInput) return completionItem.filterText;
+  const containedInFilterText = completionItem.filterText.toLowerCase().includes(userInput.toLowerCase());
+  if (!containedInFilterText) return completionItem.filterText;
+  return `${userInput}${completionItem.filterText}`;
+}
+function getFocusedItem(completionItems, userInput) {
+  const firstCompletionItem = completionItems[0];
+  if (!userInput) return firstCompletionItem;
+  const firstMatchingItem = completionItems.find(item => item.filterText?.toLowerCase().startsWith(userInput.toLowerCase()));
+  return firstMatchingItem ?? firstCompletionItem;
+}
+
+// --- 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);
+      });
+    };
+    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);
         }
-        return t;
+      }
+    }).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
+  };
+}
+
+// --- 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(workerAccessor, languageSettings) {
+    this.languageSettings = languageSettings;
+    const getFromLanguageService = async (resource, position) => {
+      const worker = await workerAccessor(resource);
+      return worker.doComplete(resource.toString(), position);
     };
-    return __assign.apply(this, arguments);
+    this.completionCacheManager = createCompletionCacheManager(getFromLanguageService);
+  }
+  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 userInput = model?.getWordAtPosition(position)?.word;
+    const onDidProvideCompletionItems = this.languageSettings.onDidProvideCompletionItems;
+    return this.completionCacheManager.getCompletionItems(userInput, resource, fromPosition(position)).then(info => onDidProvideCompletionItems ? onDidProvideCompletionItems(info) : info).then(info => {
+      if (!info) return;
+      const selectedItem = getFocusedItem(info.items, userInput);
+      let items = info.items.map((entry, index) => {
+        let item = {
+          label: entry.label,
+          insertText: entry.insertText,
+          sortText: entry.sortText,
+          filterText: createCompletionFilteredText(userInput, entry),
+          // TODO: Is this cast safe?
+          documentation: this.formatDocLink(entry.documentation?.value),
+          detail: entry.detail,
+          range: wordRange,
+          kind: toCompletionItemKind(entry.kind),
+          preselect: selectedItem.filterText === entry.filterText
+        };
+        if (entry.textEdit) {
+          // TODO: Where is the "range" property coming from?
+          item.range = toRange(entry.textEdit.range);
+          item.insertText = entry.textEdit.newText;
+        }
+        if (entry.insertTextFormat === ls.InsertTextFormat.Snippet) {
+          item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+        }
+        return item;
+      });
+      return {
+        incomplete: true,
+        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}`;
+        }
+        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;
+        }
+        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
+        },
+        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)
+      };
+    });
+  }
+}
+
+const queryOperators = ['as', 'consume', 'distinct', 'evaluate', 'extend', 'getschema', 'graph-match', 'graph-merge', 'graph-to-table', 'invoke', 'join', 'limit', 'lookup', 'make-graph', 'make-series', 'mv-apply', 'mv-expand', 'order', 'parse', 'parse-kv', 'parse-where', 'project', 'project-away', 'project-keep', 'project-rename', 'project-reorder', 'range', 'reduce', 'render', 'sample', 'sample-distinct', 'scan', 'serialize', 'sort', 'summarize', 'take', 'top', 'top-hitters', 'top-nested', 'union', 'where', 'filter', 'fork', 'facet', 'range', 'consume', 'find', 'search', 'print', 'partition', 'lookup'];
+const queryParameters = ['kind'];
+const types = ['bool', 'datetime', 'decimal', 'double', 'dynamic', 'guid', 'int', 'long', 'real', 'string', 'timespan'];
+const commands = ['.add', '.alter', '.alter-merge', '.append', '.as', '.assert', '.attach', '.consume', '.count', '.create', '.create-merge', '.create-or-alter', '.create-set', '.datatable', '.default', '.define', '.delete', '.detach', '.distinct', '.drop', '.drop-pretend', '.dup-next-failed-ingest', '.dup-next-ingest', '.evaluate', '.export', '.extend', '.externaldata', '.filter', '.find', '.fork', '.getschema', '.ingest', '.join', '.limit', '.load', '.make-series', '.materialize', '.move', '.mv-expand', '.order', '.parse', '.parse-where', '.partition', '.pivot', '.print', '.project', '.project-away', '.project-keep', '.project-rename', '.reduce', '.remove', '.rename', '.replace', '.restrict', '.run', '.sample', '.sample-distinct', '.save', '.search', '.serialize', '.set', '.set-or-append', '.set-or-replace', '.show', '.sort', '.summarize', '.take', '.top', '.top-hitters', '.top-nested', '.union'];
+const functions = ['abs', 'acos', 'ago', 'array_concat', 'array_length', 'array_slice', 'array_split', 'asin', 'atan', 'atan2', 'avg', 'bag_keys', 'base64_decodestring', 'base64_encodestring', 'bin', 'bin_at', 'binary_and', 'binary_not', 'binary_or', 'binary_shift_left', 'binary_shift_right', 'binary_xor', 'case', 'ceiling', 'coalesce', 'columnifexists', 'cos', 'count', 'countof', 'cot', 'cursor_after', 'datatable', 'datepart', 'datetime_add', 'datetime_diff', 'datetime_part', 'dayofmonth', 'dayofweek', 'dayofyear', 'dcount', 'dcount_hll', 'degrees', 'endofday', 'endofmonth', 'endofweek', 'endofyear', 'exp', 'exp10', 'exp2', 'extract', 'extractall', 'extractjson', 'format_datetime', 'format_timespan', 'floor', 'gamma', 'geo_distance_2points', 'geo_geohash_to_central_point', 'geo_point_in_circle', 'geo_point_in_polygon', 'geo_point_to_geohash', 'getmonth', 'gettype', 'getyear', 'hash', 'hash_sha256', 'hll_merge', 'iif', 'indexof', 'isempty', 'isfinite', 'isinf', 'isascii', 'isnan', 'isnotempty', 'isnotnull', 'isnull', 'isutf8', 'log', 'log10', 'log2', 'loggamma', 'make_datetime', 'make_string', 'make_timespan', 'materialize', 'max', 'max_of', 'min', 'min_of', 'monthofyear', 'next', 'not', 'pack', 'pack_array', 'pack_dictionary', 'parse_csv', 'parse_ipv4', 'parse_json', 'parse_path', 'parse_url', 'parse_urlquery', 'parse_user_agent', 'parse_version', 'parse_xml', 'parsejson', 'percentrank_tdigest', 'percentile_tdigest', 'pow', 'prev', 'radians', 'rand', 'rank_tdigest', 'repeat', 'replace', 'reverse', 'round', 'row_cumsum', 'row_window_session', 'series_add', 'series_decompose', 'series_decompose_anomalies', 'series_decompose_forecast', 'series_divide', 'series_equals', 'series_fill_backward', 'series_fill_const', 'series_fill_forward', 'series_fill_linear', 'series_fir', 'series_fit_2lines', 'series_fit_2lines_dynamic', 'series_fit_line', 'series_fit_line_dynamic', 'series_greater', 'series_greater_equals', 'series_iir', 'series_less', 'series_less_equals', 'series_multiply', 'series_not_equals', 'series_outliers', 'series_pearson_correlation', 'series_periods_detect', 'series_periods_validate', 'series_seasonal', 'series_stats', 'series_stats_dynamic', 'series_subtract', 'sign', 'sin', 'split', 'sqrt', 'startofday', 'startofmonth', 'startofweek', 'startofyear', 'strcat', 'strcat_array', 'strcat_delim', 'strcmp', 'strlen', 'strrep', 'string_size', 'substring', 'sum', 'tan', 'tdigest_merge', 'tobool', 'toboolean', 'todecimal', 'todouble', 'todynamic', 'tofloat', 'toguid', 'tohex', 'toint', 'tolong', 'tolower', 'toobject', 'toreal', 'toscalar', 'tostring', 'totimespan', 'toupper', 'translate', 'trim', 'trim_end', 'trim_start', 'typeof', 'url_decode', 'url_encode', 'week_of_year', 'welch_test'];
+const keywords = ['and', 'as', 'asc', 'between', 'by', 'contains', 'count', 'desc', 'extend', 'false', 'filter', 'find', 'from', 'has', 'in', 'inner', 'join', 'leftouter', 'let', 'not', 'on', 'or', 'policy', 'project', 'project-away', 'project-rename', 'project-reorder', 'project-keep', 'range', 'rename', 'retention', 'summarize', 'table', 'take', 'to', 'true', 'where', 'with'];
+const kustoLanguageDefinition = {
+  name: LANGUAGE_ID,
+  mimeTypes: ['text/kusto'],
+  displayName: 'Kusto',
+  defaultToken: 'invalid',
+  queryOperators,
+  queryParameters,
+  types,
+  commands,
+  functions,
+  keywords,
+  tokenizer: {
+    root: [[/(\/\/.*$)/, Token.Comment], [/[\(\)\{\}\|\[\]\:\=\,\<|\.\..]/, Token.Punctuation], [/[\+\-\*\/\%\!\<\<=\>\>=\=\==\!=\<>\:\;\,\=~\@\?\=>\!~]/, Token.MathOperator], [/"([^"\\]*(\\.[^"\\]*)*)"/, Token.StringLiteral], [/'([^"\\]*(\\.[^"\\]*)*)'/, Token.StringLiteral], [/[\w@#\-$\.]+/, {
+      cases: {
+        '@queryOperators': Token.QueryOperator,
+        '@queryParameters': Token.QueryParameter,
+        '@types': Token.Type,
+        '@commands': Token.Command,
+        '@functions': Token.Function,
+        '@keywords': Token.Keyword,
+        '@default': 'identifier'
+      }
+    }]]
+  }
 };
-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());
+
+class SemanticTokensProvider {
+  constructor(classificationsGetter) {
+    this.classificationsGetter = classificationsGetter;
+  }
+  getLegend() {
+    return {
+      tokenTypes,
+      tokenModifiers: []
+    };
+  }
+  async provideDocumentSemanticTokens(model) {
+    const resource = model.uri;
+    const classifications = await this.classificationsGetter(resource);
+    const semanticTokens = classifications.map((classification, index) => {
+      const previousClassification = classifications[index - 1];
+      return semanticTokenMaker(classification, previousClassification);
     });
+    return {
+      data: new Uint32Array(semanticTokens.flat()),
+      resultId: model.getVersionId().toString()
+    };
+  }
+  releaseDocumentSemanticTokens() {}
+}
+const emptyClassification = {
+  line: 0,
+  character: 0,
+  length: 0,
+  kind: 0
 };
-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 };
+function semanticTokenMaker(classification, previousClassification = emptyClassification) {
+  const {
+    line,
+    character,
+    length,
+    kind
+  } = classification;
+  const deltaLine = line - previousClassification.line;
+  const deltaStart = deltaLine ? character : character - previousClassification.character;
+  return [deltaLine, deltaStart, length, kind, 0];
+}
+
+// Registers semantic token provider that utilizes the language service
+// for more context-relevant syntax highlighting.
+function semanticTokensProviderRegistrarCreator() {
+  const semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreatorForTest();
+  return (monacoInstance, workerAccessor) => {
+    const semanticTokensProvider = semanticTokensProviderMaker(workerAccessor);
+    semanticTokensProviderRegistrar(monacoInstance, semanticTokensProvider);
+  };
+}
+function semanticTokensProviderRegistrarCreatorForTest() {
+  let semanticTokensDisposable;
+  return (monacoInstance, semanticTokensProvider) => {
+    if (semanticTokensDisposable) {
+      semanticTokensDisposable.dispose();
     }
-};
-import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
-import { WorkerManager } from './workerManager';
-import * as languageFeatures from './languageFeatures';
-import { kustoLanguageDefinition } from './syntaxHighlighting/kustoMonarchLanguageDefinition';
-import { LANGUAGE_ID } from './globals';
-import { semanticTokensProviderRegistrarCreator } from './syntaxHighlighting/semanticTokensProviderRegistrar';
-var kustoWorker;
-var resolveWorker;
-var rejectWorker;
-var workerPromise = new Promise(function (resolve, reject) {
-    resolveWorker = resolve;
-    rejectWorker = reject;
+    semanticTokensDisposable = monacoInstance.languages.registerDocumentSemanticTokensProvider(LANGUAGE_ID, semanticTokensProvider);
+  };
+}
+function semanticTokensProviderMaker(workerAccessor) {
+  const classificationsGetter = async resource => {
+    const worker = await workerAccessor(resource);
+    return worker.getClassifications(resource.toString());
+  };
+  return new SemanticTokensProvider(classificationsGetter);
+}
+
+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
  */
-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 semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreator();
-    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) { 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();
-                        semanticTokensProviderRegistrar(monacoInstance, workerAccessor);
-                        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*/];
-                        }
-                    });
-                });
-            } })); });
+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 = [];
+  const semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreator();
+  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);
+      });
+      semanticTokensProviderRegistrar(monacoInstance, workerAccessor);
     };
-    disposables.push(monacoInstance.languages.registerCompletionItemProvider(LANGUAGE_ID, new languageFeatures.CompletionAdapter(workerAccessor, defaults.languageSettings)));
-    var monarchTokensProvider = monacoInstance.languages.setMonarchTokensProvider(LANGUAGE_ID, kustoLanguageDefinition);
-    disposables.push(new languageFeatures.DiagnosticsAdapter(monacoInstance, LANGUAGE_ID, workerAccessor, defaults, onSchemaChange.event));
-    disposables.push(monacoInstance.languages.registerDocumentRangeFormattingEditProvider(LANGUAGE_ID, new languageFeatures.FormatAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerFoldingRangeProvider(LANGUAGE_ID, new languageFeatures.FoldingAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerDefinitionProvider(LANGUAGE_ID, new languageFeatures.DefinitionAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerRenameProvider(LANGUAGE_ID, new languageFeatures.RenameAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerReferenceProvider(LANGUAGE_ID, new languageFeatures.ReferenceAdapter(workerAccessor)));
-    if (defaults.languageSettings.enableHover) {
-        disposables.push(monacoInstance.languages.registerHoverProvider(LANGUAGE_ID, new languageFeatures.HoverAdapter(workerAccessor)));
-    }
-    monacoInstance.languages.registerDocumentFormattingEditProvider(LANGUAGE_ID, new languageFeatures.DocumentFormatAdapter(workerAccessor));
-    kustoWorker = workerAccessor;
-    resolveWorker(workerAccessor);
-    monacoInstance.languages.setLanguageConfiguration(LANGUAGE_ID, {
-        folding: {
-            offSide: false,
-            markers: { start: /^\s*[\r\n]/gm, end: /^\s*[\r\n]/gm },
-        },
-        comments: {
-            lineComment: '//',
-            blockComment: null,
-        },
-        autoClosingPairs: [
-            { open: '{', close: '}' },
-            { open: '[', close: ']' },
-            { open: '(', close: ')' },
-            { open: "'", close: "'", notIn: ['string', 'comment'] },
-            { open: '"', close: '"', notIn: ['string', 'comment'] },
-        ],
-    });
-    return kustoWorker;
+    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);
+        });
+      }
+    }));
+  };
+  disposables.push(monacoInstance.languages.registerCompletionItemProvider(LANGUAGE_ID, new CompletionAdapter(workerAccessor, defaults.languageSettings)));
+  monacoInstance.languages.setMonarchTokensProvider(LANGUAGE_ID, kustoLanguageDefinition);
+  disposables.push(new DiagnosticsAdapter(monacoInstance, LANGUAGE_ID, workerAccessor, defaults, onSchemaChange.event));
+  disposables.push(monacoInstance.languages.registerDocumentRangeFormattingEditProvider(LANGUAGE_ID, new FormatAdapter(workerAccessor)));
+  disposables.push(monacoInstance.languages.registerFoldingRangeProvider(LANGUAGE_ID, new FoldingAdapter(workerAccessor)));
+  disposables.push(monacoInstance.languages.registerDefinitionProvider(LANGUAGE_ID, new DefinitionAdapter(workerAccessor)));
+  disposables.push(monacoInstance.languages.registerRenameProvider(LANGUAGE_ID, new RenameAdapter(workerAccessor)));
+  disposables.push(monacoInstance.languages.registerReferenceProvider(LANGUAGE_ID, new ReferenceAdapter(workerAccessor)));
+  if (defaults.languageSettings.enableHover) {
+    disposables.push(monacoInstance.languages.registerHoverProvider(LANGUAGE_ID, new HoverAdapter(workerAccessor)));
+  }
+  monacoInstance.languages.registerDocumentFormattingEditProvider(LANGUAGE_ID, new DocumentFormatAdapter(workerAccessor));
+  kustoWorker = workerAccessor;
+  resolveWorker(workerAccessor);
+  monacoInstance.languages.setLanguageConfiguration(LANGUAGE_ID, {
+    folding: {
+      offSide: false,
+      markers: {
+        start: /^\s*[\r\n]/gm,
+        end: /^\s*[\r\n]/gm
+      }
+    },
+    comments: {
+      lineComment: '//',
+      blockComment: null
+    },
+    autoClosingPairs: [{
+      open: '{',
+      close: '}'
+    }, {
+      open: '[',
+      close: ']'
+    }, {
+      open: '(',
+      close: ')'
+    }, {
+      open: "'",
+      close: "'",
+      notIn: ['string', 'comment']
+    }, {
+      open: '"',
+      close: '"',
+      notIn: ['string', 'comment']
+    }]
+  });
+  return kustoWorker;
 }
-export function getKustoWorker() {
-    return workerPromise.then(function () { return kustoWorker; });
+function getKustoWorker() {
+  return workerPromise.then(() => kustoWorker);
 }
+
+export { getKustoWorker, setupMode };