@kusto/monaco-kusto 5.6.6 → 6.1.0

package/release/esm/kusto.worker.js

@@ -1,8 +1,2249 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-kusto version: 6.1.0(b14a2ec944d355ac340af8280e7c1a4ea98f6c8c)
+ * Released under the MIT license
+ * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
+ *-----------------------------------------------------------------------------*/
+
 import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
-import { KustoWorker } from './kustoWorker';
-self.onmessage = function () {
-    // ignore the first message
-    worker.initialize(function (ctx, createData) {
-        return new KustoWorker(ctx, createData);
+import * as ls from 'vscode-languageserver-types';
+import XRegExp from 'xregexp';
+
+// Definition of schema object in the context of language services. This model is exposed to consumers of this library.
+
+// an input parameter either be a scalar in which case it has a name, type and cslType, or it can be columnar, in which case
+// it will have a name, and a list of scalar types which are the column types.
+
+/**
+ * Schema types:
+ * Engine – The main schema type. Contains clusters, databases, tables, table columns and functions.
+ * Cluster Manager – Internal only. A schema for clusters that manages other clusters.
+ * Data Management – Internal only. A schema for ingestion point operations.
+ */
+
+const dotnetTypeToKustoType = {
+  'System.SByte': 'bool',
+  'System.Byte': 'uint8',
+  'System.Int16': 'int16',
+  'System.UInt16': 'uint16',
+  'System.Int32': 'int',
+  'System.UInt32': 'uint',
+  'System.Int64': 'long',
+  'System.UInt64': 'ulong',
+  'System.String': 'string',
+  'System.Single': 'float',
+  'System.Double': 'real',
+  'System.DateTime': 'datetime',
+  'System.TimeSpan': 'timespan',
+  'System.Guid': 'guid',
+  'System.Boolean': 'bool',
+  'Newtonsoft.Json.Linq.JArray': 'dynamic',
+  'Newtonsoft.Json.Linq.JObject': 'dynamic',
+  'Newtonsoft.Json.Linq.JToken': 'dynamic',
+  'System.Object': 'dynamic',
+  'System.Data.SqlTypes.SqlDecimal': 'decimal'
+};
+const getCslTypeNameFromClrType = clrType => dotnetTypeToKustoType[clrType] || clrType;
+const kustoTypeToEntityDataType = {
+  object: 'Object',
+  bool: 'Boolean',
+  uint8: 'Byte',
+  int16: 'Int16',
+  uint16: 'UInt16',
+  int: 'Int32',
+  uint: 'UInt32',
+  long: 'Int64',
+  ulong: 'UInt64',
+  float: 'Single',
+  real: 'Double',
+  decimal: 'Decimal',
+  datetime: 'DateTime',
+  string: 'String',
+  dynamic: 'Dynamic',
+  timespan: 'TimeSpan'
+};
+const getEntityDataTypeFromCslType = cslType => kustoTypeToEntityDataType[cslType] || cslType;
+const getCallName = fn => `${fn.name}(${fn.inputParameters.map(p => `{${p.name}}`).join(',')})`;
+const getExpression = fn => `let ${fn.name} = ${getInputParametersAsCslString(fn.inputParameters)} ${fn.body}`;
+const getInputParametersAsCslString = inputParameters => `(${inputParameters.map(inputParameter => getInputParameterAsCslString(inputParameter)).join(',')})`;
+const getInputParameterAsCslString = inputParameter => {
+  // If this is a tabular parameter
+  if (inputParameter.columns && inputParameter.columns.length > 0) {
+    const attributesAsString = inputParameter.columns.map(col => `${col.name}:${col.cslType || getCslTypeNameFromClrType(col.type)}`).join(',');
+    return `${inputParameter.name}:${attributesAsString === '' ? '*' : attributesAsString}`;
+  } else {
+    return `${inputParameter.name}:${inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type)}`;
+  }
+};
+
+// polyfill string endsWith
+if (!String.prototype.endsWith) {
+  String.prototype.endsWith = function (search, this_len) {
+    if (this_len === undefined || this_len > this.length) {
+      this_len = this.length;
+    }
+    return this.substring(this_len - search.length, this_len) === search;
+  };
+}
+
+// If we're running in a web worker - which doesn't share global context with the main thread -
+// we need to manually load dependencies that are not explicit- meaning our non-module dependencies
+// generated by Bridge.Net
+if (typeof document == 'undefined') {
+  // monaco will run the worker from vs/base/worker so the relative path needs to be from there (hence going up 2 dirs)
+  importScripts('../../language/kusto/bridge.min.js');
+  importScripts('../../language/kusto/kusto.javascript.client.min.js');
+  importScripts('../../language/kusto/Kusto.Language.Bridge.min.js');
+}
+var k = Kusto.Data.IntelliSense;
+var parsing = Kusto.Language.Parsing;
+Kusto.Language.Syntax;
+var k2 = Kusto.Language.Editor;
+var sym = Kusto.Language.Symbols;
+var GlobalState = Kusto.Language.GlobalState;
+let List = System.Collections.Generic.List$1;
+function assertNever(x) {
+  throw new Error('Unexpected object: ' + x);
+}
+class ParseProperties {
+  constructor(version, uri, rulesProvider, parseMode) {
+    this.version = version;
+    this.uri = uri;
+    this.rulesProvider = rulesProvider;
+    this.parseMode = parseMode;
+  }
+  isParseNeeded(document, rulesProvider, parseMode) {
+    if (document.uri === this.uri && (!rulesProvider || rulesProvider === this.rulesProvider) && document.version <= this.version && parseMode && parseMode <= this.parseMode) {
+      return false;
+    }
+    return true;
+  }
+}
+let TokenKind;
+
+/**
+ * A plain old javascript object that is roughly equivalent to the @kusto/language-service-next object, but without
+ * all the Bridge.Net properties and methods. this object is being sent from web worker to main thread and turns out
+ * that when posting the message we lose all properties (and functions), thus we use a POJO instead.
+ * This issue started happening once upgrading to 0.20.0 from 0.15.5.
+ */
+(function (TokenKind) {
+  TokenKind[TokenKind["TableToken"] = 2] = "TableToken";
+  TokenKind[TokenKind["TableColumnToken"] = 4] = "TableColumnToken";
+  TokenKind[TokenKind["OperatorToken"] = 8] = "OperatorToken";
+  TokenKind[TokenKind["SubOperatorToken"] = 16] = "SubOperatorToken";
+  TokenKind[TokenKind["CalculatedColumnToken"] = 32] = "CalculatedColumnToken";
+  TokenKind[TokenKind["StringLiteralToken"] = 64] = "StringLiteralToken";
+  TokenKind[TokenKind["FunctionNameToken"] = 128] = "FunctionNameToken";
+  TokenKind[TokenKind["UnknownToken"] = 256] = "UnknownToken";
+  TokenKind[TokenKind["CommentToken"] = 512] = "CommentToken";
+  TokenKind[TokenKind["PlainTextToken"] = 1024] = "PlainTextToken";
+  TokenKind[TokenKind["DataTypeToken"] = 2048] = "DataTypeToken";
+  TokenKind[TokenKind["ControlCommandToken"] = 4096] = "ControlCommandToken";
+  TokenKind[TokenKind["CommandPartToken"] = 8192] = "CommandPartToken";
+  TokenKind[TokenKind["QueryParametersToken"] = 16384] = "QueryParametersToken";
+  TokenKind[TokenKind["CslCommandToken"] = 32768] = "CslCommandToken";
+  TokenKind[TokenKind["LetVariablesToken"] = 65536] = "LetVariablesToken";
+  TokenKind[TokenKind["PluginToken"] = 131072] = "PluginToken";
+  TokenKind[TokenKind["BracketRangeToken"] = 262144] = "BracketRangeToken";
+  TokenKind[TokenKind["ClientDirectiveToken"] = 524288] = "ClientDirectiveToken";
+})(TokenKind || (TokenKind = {}));
+/**
+ * convert the bridge.net object to a plain javascript object that only contains data.
+ * @param k2Classifications @kusto/language-service-next bridge.net object
+ */
+function toClassifiedRange(k2Classifications) {
+  return k2Classifications.map(classification => ({
+    start: classification.Start,
+    end: classification.End,
+    length: classification.Length,
+    kind: classification.Kind
+  }));
+}
+
+/**
+ * colorization data for specific line range.
+ */
+
+const symbolKindToName = {
+  [sym.SymbolKind.Cluster]: 'Cluster',
+  [sym.SymbolKind.Column]: 'Column',
+  [sym.SymbolKind.Command]: 'Command',
+  [sym.SymbolKind.Database]: 'Database',
+  [sym.SymbolKind.EntityGroup]: 'EntityGroup',
+  [sym.SymbolKind.EntityGroupElement]: 'EntityGroupElement',
+  [sym.SymbolKind.Error]: 'Error',
+  [sym.SymbolKind.Function]: 'Function',
+  [sym.SymbolKind.Graph]: 'Graph',
+  [sym.SymbolKind.Group]: 'Group',
+  [sym.SymbolKind.MaterializedView]: 'MaterializedView',
+  [sym.SymbolKind.None]: 'None',
+  [sym.SymbolKind.Operator]: 'Operator',
+  [sym.SymbolKind.Option]: 'Option',
+  [sym.SymbolKind.Parameter]: 'Parameter',
+  [sym.SymbolKind.Pattern]: 'Pattern',
+  [sym.SymbolKind.QueryOperatorParameter]: 'QueryOperatorParameter',
+  [sym.SymbolKind.Scalar]: 'Scalar',
+  [sym.SymbolKind.Table]: 'Table',
+  [sym.SymbolKind.Tuple]: 'Tuple',
+  [sym.SymbolKind.Variable]: 'Variable',
+  [sym.SymbolKind.Void]: 'Void'
+};
+/**
+ * Kusto Language service translates the kusto object model (transpiled from C# by Bridge.Net)
+ * to the vscode language server types, which are used by vscode language extensions.
+ * This should make things easier in the future to provide a vscode extension based on this translation layer.
+ *
+ * Further translations, if needed, to support specific editors (Atom, sublime, Etc)
+ * should be done on top of this API, since it is (at least meant to be) a standard that is supported by multiple editors.
+ *
+ * Note1:  Currently monaco isn't using this object model so further translation will be necessary on calling modules.
+ *
+ * Note2: This file is responsible for interacting with the kusto object model and exposing Microsoft language service types.
+ * An exception to that rule is tokenization (and syntax highlighting which depends on it) -
+ * since it's not currently part of the Microsoft language service protocol. Thus tokenize() _does_ 'leak' kusto types to the callers.
+ */
+class KustoLanguageService {
+  /**
+   * Taken from:
+   * https://msazure.visualstudio.com/One/_git/Azure-Kusto-Service?path=/Src/Tools/Kusto.Explorer.Control/QueryEditors/KustoScriptEditor/KustoScriptEditorControl2.xaml.cs&version=GBdev&line=2075&lineEnd=2075&lineStartColumn=9&lineEndColumn=77&lineStyle=plain&_a=contents
+   */
+  _toOptionKind = {
+    [k2.CompletionKind.AggregateFunction]: k.OptionKind.FunctionAggregation,
+    [k2.CompletionKind.BuiltInFunction]: k.OptionKind.FunctionScalar,
+    [k2.CompletionKind.Cluster]: k.OptionKind.Database,
+    [k2.CompletionKind.Column]: k.OptionKind.Column,
+    [k2.CompletionKind.CommandPrefix]: k.OptionKind.Command,
+    [k2.CompletionKind.Database]: k.OptionKind.Database,
+    [k2.CompletionKind.DatabaseFunction]: k.OptionKind.FunctionServerSide,
+    [k2.CompletionKind.Example]: k.OptionKind.Literal,
+    [k2.CompletionKind.Identifier]: k.OptionKind.None,
+    [k2.CompletionKind.Keyword]: k.OptionKind.Option,
+    [k2.CompletionKind.LocalFunction]: k.OptionKind.FunctionLocal,
+    [k2.CompletionKind.MaterialiedView]: k.OptionKind.MaterializedView,
+    [k2.CompletionKind.Parameter]: k.OptionKind.Parameter,
+    [k2.CompletionKind.Punctuation]: k.OptionKind.None,
+    [k2.CompletionKind.QueryPrefix]: k.OptionKind.Operator,
+    [k2.CompletionKind.RenderChart]: k.OptionKind.OptionRender,
+    [k2.CompletionKind.ScalarInfix]: k.OptionKind.None,
+    [k2.CompletionKind.ScalarPrefix]: k.OptionKind.Literal,
+    [k2.CompletionKind.ScalarType]: k.OptionKind.DataType,
+    [k2.CompletionKind.Syntax]: k.OptionKind.None,
+    [k2.CompletionKind.Table]: k.OptionKind.Table,
+    [k2.CompletionKind.TabularPrefix]: k.OptionKind.None,
+    [k2.CompletionKind.TabularSuffix]: k.OptionKind.None,
+    [k2.CompletionKind.Unknown]: k.OptionKind.None,
+    [k2.CompletionKind.Variable]: k.OptionKind.Parameter,
+    [k2.CompletionKind.Option]: k.OptionKind.Option,
+    [k2.CompletionKind.Graph]: k.OptionKind.Graph
+  };
+  constructor(schema, languageSettings) {
+    this._schemaCache = {};
+    this._kustoJsSchema = KustoLanguageService.convertToKustoJsSchema(schema);
+    this.__kustoJsSchemaV2 = this.convertToKustoJsSchemaV2(schema);
+    this._schema = schema;
+    this._clustersSetInGlobalState = new Set();
+    this._nonEmptyDatabaseSetInGlobalState = new Set(); // used to remove clusters that are already in the global state
+
+    this.configure(languageSettings);
+    this._newlineAppendPipePolicy = new Kusto.Data.IntelliSense.ApplyPolicy();
+    this._newlineAppendPipePolicy.Text = '\n| ';
+  }
+  createDatabaseUniqueName(clusterName, databaseName) {
+    return `${clusterName}_${databaseName}`;
+  }
+
+  /**
+   * A setter for _kustoJsSchemaV2. After a schema (global state) is set, create 2 sets of cluster and database names.
+   */
+  set _kustoJsSchemaV2(globalState) {
+    this.__kustoJsSchemaV2 = globalState;
+    this._clustersSetInGlobalState.clear();
+    this._nonEmptyDatabaseSetInGlobalState.clear();
+
+    // create 2 Sets with cluster names and database names based on the updated Global State.
+    for (let i = 0; i < globalState.Clusters.Count; i++) {
+      const clusterSymbol = this._kustoJsSchemaV2.Clusters.getItem(i);
+      this._clustersSetInGlobalState.add(clusterSymbol.Name);
+      for (let i2 = 0; i2 < clusterSymbol.Databases.Count; i2++) {
+        const databaseSymbol = clusterSymbol.Databases.getItem(i2);
+        if (databaseSymbol.Tables.Count > 0) {
+          // only include database with tables
+          this._nonEmptyDatabaseSetInGlobalState.add(this.createDatabaseUniqueName(clusterSymbol.Name, databaseSymbol.Name));
+        }
+      }
+    }
+  }
+
+  /**
+   * A getter for __kustoJsSchemaV2
+   */
+  get _kustoJsSchemaV2() {
+    return this.__kustoJsSchemaV2;
+  }
+  configure(languageSettings) {
+    this._languageSettings = languageSettings;
+
+    // Since we're still reverting to V1 intellisense for control commands, we need to update the rules provider
+    // (which is a notion of V1 intellisense).
+    this.createRulesProvider(this._kustoJsSchema, this._schema.clusterType);
+  }
+  doComplete(document, position) {
+    return this.isIntellisenseV2() ? this.doCompleteV2(document, position) : this.doCompleteV1(document, position);
+  }
+  disabledCompletionItemsV2 = {
+    // render charts
+    ladderchart: k2.CompletionKind.RenderChart,
+    pivotchart: k2.CompletionKind.RenderChart,
+    timeline: k2.CompletionKind.RenderChart,
+    timepivot: k2.CompletionKind.RenderChart,
+    '3Dchart': k2.CompletionKind.RenderChart,
+    list: k2.CompletionKind.RenderChart
+  };
+
+  /**
+   * important: Only use during development to test Global State.
+   * Prints clusters, databases and tables that are currently in the GlobalState.
+   */
+  debugGlobalState(globals) {
+    // iterate over clusters
+    console.log(`globals.Clusters.Count: ${globals.Clusters.Count}`);
+    for (let i = 0; i < globals.Clusters.Count; i++) {
+      const cluster = globals.Clusters.getItem(i);
+      console.log(`cluster: ${cluster.Name}`);
+
+      // iterate over databases
+      console.log(`cluster.Databases.Count: ${cluster.Databases.Count}`);
+      for (let i2 = 0; i2 < cluster.Databases.Count; i2++) {
+        const database = cluster.Databases.getItem(i2);
+        console.log(`cluster.database: [${cluster.Name}].[${database.Name}]`);
+
+        // iterate over tables
+        console.log(`cluster.Databases.Tables.Count: ${database.Tables.Count}`);
+        for (let i3 = 0; i3 < database.Tables.Count; i3++) {
+          const table = database.Tables.getItem(i3);
+          console.log(`cluster.database.table: [${cluster.Name}].[${database.Name}].[${table.Name}]`);
+        }
+      }
+    }
+  }
+
+  /**
+   * Prepending the doc of the actual topic at the top
+   */
+  formatHelpTopic(helpTopic) {
+    return `**${helpTopic.Name} [(view online)](${helpTopic.Url})**\n\n${helpTopic.LongDescription}`;
+  }
+  doCompleteV2(document, position) {
+    if (!document) {
+      return Promise.resolve(ls.CompletionList.create([]));
+    }
+    const script = this.parseDocumentV2(document);
+
+    // print cluster/database/tables from CodeScript.Globals
+    // this.debugGlobalState(script.Globals);
+
+    // get current command
+    const cursorOffset = document.offsetAt(position);
+    let currentCommand = script.GetBlockAtPosition(cursorOffset);
+
+    // get completion items
+    const completionItems = currentCommand.Service.GetCompletionItems(cursorOffset);
+    let disabledItems = this.disabledCompletionItemsV2;
+    if (this._languageSettings.disabledCompletionItems) {
+      this._languageSettings.disabledCompletionItems.map(item => {
+        // logic will treat unknown as a '*' wildcard, meaning that if the key is in the object
+        // the completion item will be suppressed.
+        disabledItems[item] = k2.CompletionKind.Unknown;
+      });
+    }
+    const itemsAsArray = this.toArray(completionItems.Items);
+    let items = itemsAsArray.filter(item => !(item && item.MatchText && disabledItems[item.MatchText] !== undefined && (disabledItems[item.MatchText] === k2.CompletionKind.Unknown || disabledItems[item.MatchText] === item.Kind))).map((kItem, i) => {
+      const v1CompletionOption = new k.CompletionOption(this._toOptionKind[kItem.Kind] || k.OptionKind.None, kItem.DisplayText);
+      const helpTopic = this.getTopic(v1CompletionOption);
+      // If we have AfterText it means that the cursor should no be placed at end of suggested text.
+      // In that case we switch to snippet format and represent the point where the cursor should be as
+      // as '\$0'
+      const {
+        textToInsert,
+        format
+      } = kItem.AfterText && kItem.AfterText.length > 0 ? {
+        // Need to escape dollar sign since it is used as a placeholder in snippet.
+        // Usually dollar sign is not a valid character in a function name, but grafana uses macros that start with dollars.
+        textToInsert: `${kItem.EditText.replace('$', '\\$')}$0${kItem.AfterText}`,
+        format: ls.InsertTextFormat.Snippet
+      } : {
+        textToInsert: kItem.EditText,
+        format: ls.InsertTextFormat.PlainText
+      };
+      const lsItem = ls.CompletionItem.create(kItem.DisplayText);
+
+      // Adding to columns a prefix to their sortText so they will appear first in the list
+      const sortTextPrefix = lsItem.kind === ls.CompletionItemKind.Field ? 0 : itemsAsArray.length;
+      const startPosition = document.positionAt(completionItems.EditStart);
+      const endPosition = document.positionAt(completionItems.EditStart + completionItems.EditLength);
+      lsItem.textEdit = ls.TextEdit.replace(ls.Range.create(startPosition, endPosition), textToInsert);
+      lsItem.sortText = this.getSortText(sortTextPrefix + i + 1);
+      // Changing the first letter to be lower case, to ignore case-sensitive matching
+      lsItem.filterText = lsItem.label.charAt(0).toLowerCase() + lsItem.label.slice(1);
+      lsItem.kind = this.kustoKindToLsKindV2(kItem.Kind);
+      lsItem.insertTextFormat = format;
+      lsItem.detail = helpTopic ? helpTopic.ShortDescription : undefined;
+      lsItem.documentation = helpTopic ? {
+        value: this.formatHelpTopic(helpTopic),
+        kind: ls.MarkupKind.Markdown
+      } : undefined;
+      return lsItem;
+    });
+    return Promise.resolve(ls.CompletionList.create(items));
+  }
+  isIntellisenseV2 = () => this._languageSettings.useIntellisenseV2 && this._schema && this._schema.clusterType === 'Engine';
+
+  /**
+   * when trying to get a topic we need the function name (abs, toLower, ETC).
+   * The problem is that the 'Value' string also contains the  arguments (e.g abs(number)), which means that we are
+   * not able to correlate the option with its documentation.
+   * This piece of code tries to strip this hwne getting topic.
+   * @param completionOption the Completion option
+   */
+  getTopic(completionOption) {
+    if (completionOption.Kind == k.OptionKind.FunctionScalar || completionOption.Kind == k.OptionKind.FunctionAggregation) {
+      // from a value like 'abs(number)' remove the '(number)' so that only 'abs' will remain
+      const indexOfParen = completionOption.Value.indexOf('(');
+      if (indexOfParen >= 0) {
+        completionOption = new k.CompletionOption(completionOption.Kind, completionOption.Value.substring(0, indexOfParen));
+      }
+    }
+    return k.CslDocumentation.Instance.GetTopic(completionOption);
+  }
+  disabledCompletionItemsV1 = {
+    capacity: k.OptionKind.Policy,
+    callout: k.OptionKind.Policy,
+    encoding: k.OptionKind.Policy,
+    batching: k.OptionKind.Policy,
+    querythrottling: k.OptionKind.Policy,
+    merge: k.OptionKind.Policy,
+    querylimit: k.OptionKind.Policy,
+    rowstore: k.OptionKind.Policy,
+    streamingingestion: k.OptionKind.Policy,
+    restricted_view_access: k.OptionKind.Policy,
+    sharding: k.OptionKind.Policy,
+    'restricted-viewers': k.OptionKind.Policy,
+    attach: k.OptionKind.Command,
+    purge: k.OptionKind.Command
+  };
+  doCompleteV1(document, position) {
+    // TODO: fix typing in CslCommandParser to allow rulesProvider to be query only.
+    let caretAbsolutePosition = document.offsetAt(position);
+
+    // find out what's the current command to only parse this one.
+    this.parseDocumentV1(document, k.ParseMode.CommandTokensOnly);
+    let currentCommand = this.getCurrentCommand(document, caretAbsolutePosition);
+    let commandTextUntilCursor = '';
+    if (currentCommand) {
+      currentCommand.AbsoluteStart;
+      this.parseTextV1(currentCommand.Text, k.ParseMode.TokenizeAllText);
+      const caretRelativePosition = caretAbsolutePosition - currentCommand.AbsoluteStart;
+      commandTextUntilCursor = currentCommand.Text.substring(currentCommand.CslExpressionStartPosition, caretRelativePosition);
+    }
+    let commandTextWithoutLastWord = this.getCommandWithoutLastWord(commandTextUntilCursor);
+    let context = this._rulesProvider.AnalyzeCommand$1(commandTextUntilCursor, currentCommand).Context;
+    let result = {
+      v: null
+    };
+    this._rulesProvider.TryMatchAnyRule(commandTextWithoutLastWord, result);
+    let rule = result.v;
+    if (rule) {
+      const completionOptions = this.toArray(rule.GetCompletionOptions(context));
+
+      // TODO once AppendPipePolicy becomes a public static member of ApplyPolicy in our c# code, and bridge.Net transplies this,
+      //  remove the 'as any' part..
+      // Also = DefaultApplyPolicy is internal in c# code, so not exposed in d.ts, so we cast it to any.
+      if (this._languageSettings.newlineAfterPipe && rule.DefaultAfterApplyPolicy === Kusto.Data.IntelliSense.ApplyPolicy.AppendPipePolicy) {
+        rule.DefaultAfterApplyPolicy = this._newlineAppendPipePolicy;
+      }
+      let options = completionOptions.filter(option => !(option && option.Value && this.disabledCompletionItemsV1[option.Value] === option.Kind)).map((option, ordinal) => {
+        const {
+          insertText,
+          insertTextFormat
+        } = this.getTextToInsert(rule, option);
+        const helpTopic = k.CslDocumentation.Instance.GetTopic(option);
+        const item = ls.CompletionItem.create(option.Value);
+        item.kind = this.kustoKindToLsKind(option.Kind);
+        item.insertText = insertText;
+        item.insertTextFormat = insertTextFormat;
+        item.sortText = this.getSortText(ordinal + 1);
+        item.detail = helpTopic ? helpTopic.ShortDescription : undefined;
+        item.documentation = helpTopic ? {
+          value: helpTopic.LongDescription,
+          kind: ls.MarkupKind.Markdown
+        } : undefined;
+        return item;
+      });
+      return Promise.resolve(ls.CompletionList.create(options));
+    }
+    return Promise.resolve(ls.CompletionList.create([]));
+  }
+  doRangeFormat(document, range) {
+    if (!document) {
+      return Promise.resolve([]);
+    }
+    const rangeStartOffset = document.offsetAt(range.start);
+    const rangeEndOffset = document.offsetAt(range.end);
+    const commands = this.getFormattedCommandsInDocumentV2(document, rangeStartOffset, rangeEndOffset);
+    if (!commands.originalRange || commands.formattedCommands.length === 0) {
+      return Promise.resolve([]);
+    }
+    return Promise.resolve([ls.TextEdit.replace(commands.originalRange, commands.formattedCommands.join(''))]);
+  }
+  doDocumentFormat(document) {
+    if (!document) {
+      return Promise.resolve([]);
+    }
+    const startPos = document.positionAt(0);
+    const endPos = document.positionAt(document.getText().length);
+    const fullDocRange = ls.Range.create(startPos, endPos);
+    const formattedDoc = this.getFormattedCommandsInDocumentV2(document).formattedCommands.join('');
+    return Promise.resolve([ls.TextEdit.replace(fullDocRange, formattedDoc)]);
+  }
+
+  // Method is not triggered, instead doRangeFormat is invoked with the range of the caret's line.
+  doCurrentCommandFormat(document, caretPosition) {
+    const offset = document.offsetAt(caretPosition);
+    const range = this.createRange(document, offset - 1, offset + 1);
+    return this.doRangeFormat(document, range);
+  }
+  doFolding(document) {
+    if (!document) {
+      return Promise.resolve([]);
+    }
+    return this.getCommandsInDocument(document).then(commands => {
+      return commands.map(command => {
+        // don't count the last empty line as part of the folded range (consider linux, mac, pc newlines)
+        if (command.text.endsWith('\r\n')) {
+          command.absoluteEnd -= 2;
+        } else if (command.text.endsWith('\r') || command.text.endsWith('\n')) {
+          --command.absoluteEnd;
+        }
+        const startPosition = document.positionAt(command.absoluteStart);
+        const endPosition = document.positionAt(command.absoluteEnd);
+        return {
+          startLine: startPosition.line,
+          startCharacter: startPosition.character,
+          endLine: endPosition.line,
+          endCharacter: endPosition.character
+        };
+      });
+    });
+  }
+  getClusterReferences(document, cursorOffset) {
+    const script = this.parseDocumentV2(document);
+    const currentBlock = this.getCurrentCommandV2(script, cursorOffset);
+    let clusterReferences = currentBlock?.Service?.GetClusterReferences();
+    if (!clusterReferences) {
+      return Promise.resolve([]);
+    }
+    let newClustersReferences = [];
+    let newClustersReferencesSet = new Set(); // used to remove duplicates
+
+    // Keep only unique clusters that aren't already exist in the Global State
+    for (let i = 0; i < clusterReferences.Count; i++) {
+      const clusterReference = clusterReferences.getItem(i);
+      const clusterHostName = Kusto.Language.KustoFacts.GetHostName(clusterReference.Cluster);
+
+      // ignore duplicates
+      if (newClustersReferencesSet.has(clusterHostName)) {
+        continue;
+      }
+      newClustersReferencesSet.add(clusterHostName);
+
+      // ignore references that are already in the GlobalState.
+      if (!this._clustersSetInGlobalState.has(clusterHostName)) {
+        newClustersReferences.push({
+          clusterName: clusterHostName
+        });
+      }
+    }
+    return Promise.resolve(newClustersReferences);
+  }
+  getDatabaseReferences(document, cursorOffset) {
+    const script = this.parseDocumentV2(document);
+    const currentBlock = this.getCurrentCommandV2(script, cursorOffset);
+    let databasesReferences = currentBlock?.Service?.GetDatabaseReferences();
+    if (!databasesReferences) {
+      return Promise.resolve([]);
+    }
+    let newDatabasesReferences = [];
+    let newDatabasesReferencesSet = new Set();
+    for (let i1 = 0; i1 < databasesReferences.Count; i1++) {
+      const databaseReference = databasesReferences.getItem(i1);
+      const clusterHostName = Kusto.Language.KustoFacts.GetHostName(databaseReference.Cluster);
+
+      // ignore duplicates
+      const databaseReferenceUniqueId = this.createDatabaseUniqueName(clusterHostName, databaseReference.Database);
+      if (newDatabasesReferencesSet.has(databaseReferenceUniqueId)) {
+        continue;
+      }
+      newDatabasesReferencesSet.add(databaseReferenceUniqueId);
+
+      // ignore references that are already in the GlobalState.
+      let foundInGlobalState = this._nonEmptyDatabaseSetInGlobalState.has(databaseReferenceUniqueId);
+      if (!foundInGlobalState) {
+        newDatabasesReferences.push({
+          databaseName: databaseReference.Database,
+          clusterName: databaseReference.Cluster
+        });
+      }
+    }
+    return Promise.resolve(newDatabasesReferences);
+  }
+  doValidation(document, changeIntervals, includeWarnings, includeSuggestions) {
+    // didn't implement validation for v1.
+    if (!document || !this.isIntellisenseV2()) {
+      return Promise.resolve([]);
+    }
+    const script = this.parseDocumentV2(document);
+    let blocks = this.toArray(script.Blocks);
+    if (changeIntervals.length > 0) {
+      blocks = this.getAffectedBlocks(blocks, changeIntervals);
+    }
+    const diagnostics = blocks.map(block => {
+      // GetDiagnostics returns the errors in the block
+      let diagnostics = this.toArray(block.Service.GetDiagnostics());
+      const enableWarnings = includeWarnings ?? this._languageSettings.enableQueryWarnings;
+      const enableSuggestions = includeSuggestions ?? this._languageSettings.enableQuerySuggestions;
+      if (enableWarnings || enableSuggestions) {
+        // Concat Warnings and suggestions to the diagnostics
+        const warningAndSuggestionDiagnostics = block.Service.GetAnalyzerDiagnostics(true);
+        const filterredDiagnostics = this.toArray(warningAndSuggestionDiagnostics).filter(d => {
+          const allowSeverity = enableWarnings && d.Severity === 'Warning' || enableSuggestions && d.Severity === 'Suggestion';
+          const allowCode = !this._languageSettings.disabledDiagnoticCodes?.includes(d.Code);
+          return allowSeverity && allowCode;
+        });
+        diagnostics = diagnostics.concat(filterredDiagnostics);
+      }
+      return diagnostics;
+    }).reduce((prev, curr) => prev.concat(curr), []);
+    const lsDiagnostics = this.toLsDiagnostics(diagnostics, document);
+    return Promise.resolve(lsDiagnostics);
+  }
+  getApplyCodeActions(document, start, end) {
+    const script = this.parseDocumentV2(document);
+    let block = this.getAffectedBlocks(this.toArray(script.Blocks), [{
+      start,
+      end
+    }])[0];
+    const codeActionInfo = block.Service.GetCodeActions(start, start, 0, null, true, null, new Kusto.Language.Utils.CancellationToken());
+    const codeActions = this.toArray(codeActionInfo.Actions);
+    // Some code actions are of type "MenuAction". We want to flat them out, to show them seperately.
+    let flatCodeActions = [];
+    for (let i = 0; i < codeActions.length; i++) {
+      flatCodeActions.push(...this.flattenCodeActions(codeActions[i], null));
+    }
+    return flatCodeActions;
+  }
+  getResultActions(document, start, end) {
+    const script = this.parseDocumentV2(document);
+    let block = this.getAffectedBlocks(this.toArray(script.Blocks), [{
+      start,
+      end
+    }])[0];
+    const applyCodeActions = this.getApplyCodeActions(document, start, end);
+    const resultActionsMap = applyCodeActions.map(applyCodeAction => {
+      let changes = [];
+      const codeActionResults = this.toArray(block.Service.ApplyCodeAction(applyCodeAction, start).Actions);
+      const changeTextAction = codeActionResults.find(c => c instanceof Kusto.Language.Editor.ChangeTextAction);
+      if (changeTextAction) {
+        changes = this.toArray(changeTextAction.Changes).map(change => ({
+          start: change.Start + block.Start,
+          deleteLength: change.DeleteLength,
+          insertText: change.InsertText
+        }));
+      }
+      return {
+        title: applyCodeAction.Title,
+        changes,
+        kind: applyCodeAction.Kind
+      };
+    }).filter(resultAction => resultAction.changes.length);
+    return Promise.resolve(resultActionsMap);
+  }
+  transformCodeActionTitle(currentActionTitle, parentActionTitle) {
+    let title = currentActionTitle;
+    switch (title) {
+      case 'Apply':
+        title = 'Apply once';
+        break;
+      case 'Fix All':
+        title = 'Apply to all';
+        break;
+      case 'Extract Value':
+        title = 'Extract value';
+        break;
+    }
+    if (parentActionTitle) {
+      // We want to lower case the first character since it's going to be in brackets
+      const parentActionTitleLowerCased = parentActionTitle.charAt(0).toUpperCase() + parentActionTitle.slice(1);
+      title = `${title} (${parentActionTitleLowerCased})`;
+    }
+    return title;
+  }
+  flattenCodeActions(codeAction, parentTitle) {
+    const applyActions = [];
+    if (codeAction instanceof k2.ApplyAction) {
+      codeAction.Title = this.transformCodeActionTitle(codeAction.Title, parentTitle);
+      applyActions.push(codeAction);
+    } else if (codeAction instanceof k2.MenuAction) {
+      const nestedCodeActions = this.toArray(codeAction.Actions);
+      for (let i = 0; i < nestedCodeActions.length; i++) {
+        applyActions.push(...this.flattenCodeActions(nestedCodeActions[i], codeAction.Title));
+      }
+    }
+    return applyActions;
+  }
+  toLsDiagnostics(diagnostics, document) {
+    return diagnostics.filter(diag => diag.HasLocation).map(diag => {
+      const start = document.positionAt(diag.Start);
+      const end = document.positionAt(diag.Start + diag.Length);
+      const range = ls.Range.create(start, end);
+      let severity;
+      switch (diag.Severity) {
+        case 'Suggestion':
+          severity = ls.DiagnosticSeverity.Information;
+          break;
+        case 'Warning':
+          severity = ls.DiagnosticSeverity.Warning;
+          break;
+        default:
+          severity = ls.DiagnosticSeverity.Error;
+      }
+      return ls.Diagnostic.create(range, diag.Message, severity, diag.Code);
+    });
+  }
+
+  /**
+   * Colorize one or more kusto blocks (a.k.a commands), or just the entire document.
+   * Supports multi-cursor editing (colorizes blocks on multiple changes).
+   * @param document The document to colorize
+   * @param changeIntervals an array containing 0 or more changed intervals. if the array is empty - just colorize the entire row.
+   * if the array contains a single change - just color the kusto blocks that wraps this change. If multiple changes are provided,
+   * colorize all blocks that intersect these changes.
+   * The code will try to only parse once if this is the same command.
+   */
+  doColorization(document, changeIntervals) {
+    if (!document || !this._languageSettings.useSemanticColorization) {
+      return Promise.resolve([]);
+    }
+
+    // V1 intellisense
+    if (!this.isIntellisenseV2()) {
+      // Handle specific ranges changes (and not the whole doc)
+      if (changeIntervals.length > 0) {
+        this.parseDocumentV1(document, k.ParseMode.CommandTokensOnly);
+        const affectedCommands = this.toArray(this._parser.Results).filter(command =>
+        // a command is affected if it intersects at least on of changed ranges.
+        command // command can be null. we're filtering all nulls in the array.
+        ? changeIntervals.some(({
+          start: changeStart,
+          end: changeEnd
+        }) =>
+        // both intervals intersect if either the start or the end of interval A is inside interval B.
+        // If we deleted something at the end of a command, the interval will not intersect the current command.
+        // so we also want consider affected commands commands the end where the interval begins.
+        // hence the + 1.
+        command.AbsoluteStart >= changeStart && command.AbsoluteStart <= changeEnd || changeStart >= command.AbsoluteStart && changeStart <= command.AbsoluteEnd + 1) : false);
+
+        // We're not on any command so don't return any classifications.
+        // this can happen if we're at the and of the file and deleting empty rows (for example).
+        if (!affectedCommands || affectedCommands.length === 0) {
+          return Promise.resolve([{
+            classifications: [],
+            absoluteStart: changeIntervals[0].start,
+            absoluteEnd: changeIntervals[0].end
+          }]);
+        }
+        const results = affectedCommands.map(command => {
+          this.parseTextV1(command.Text, k.ParseMode.TokenizeAllText);
+          const k2Classifications = this.getClassificationsFromParseResult(command.AbsoluteStart);
+          const classifications = toClassifiedRange(k2Classifications);
+          return {
+            classifications: classifications,
+            absoluteStart: command.AbsoluteStart,
+            absoluteEnd: command.AbsoluteEnd
+          };
+        });
+        return Promise.resolve(results);
+      }
+
+      // Entire document requested
+      this.parseDocumentV1(document, k.ParseMode.TokenizeAllText);
+      const classifications = this.getClassificationsFromParseResult();
+      return Promise.resolve([{
+        classifications: toClassifiedRange(classifications),
+        absoluteStart: 0,
+        absoluteEnd: document.getText().length
+      }]);
+    }
+
+    // V2 intellisense
+    const script = this.parseDocumentV2(document);
+    if (changeIntervals.length > 0) {
+      const blocks = this.toArray(script.Blocks);
+      const affectedBlocks = this.getAffectedBlocks(blocks, changeIntervals);
+      const result = affectedBlocks.map(block => ({
+        classifications: toClassifiedRange(this.toArray(block.Service.GetClassifications(block.Start, block.End).Classifications)),
+        absoluteStart: block.Start,
+        absoluteEnd: block.End
+      }));
+      return Promise.resolve(result);
+    }
+
+    // Entire document requested
+    const blocks = this.toArray(script.Blocks);
+    const classifications = blocks.map(block => {
+      return this.toArray(block.Service.GetClassifications(block.Start, block.Length).Classifications);
+    }).reduce((prev, curr) => prev.concat(curr), []);
+    return Promise.resolve([{
+      classifications: toClassifiedRange(classifications),
+      absoluteStart: 0,
+      absoluteEnd: document.getText().length
+    }]);
+  }
+  getAffectedBlocks(blocks, changeIntervals) {
+    return blocks.filter(block =>
+    // a command is affected if it intersects at least on of changed ranges.
+    block // command can be null. we're filtering all nulls in the array.
+    ? changeIntervals.some(({
+      start: changeStart,
+      end: changeEnd
+    }) =>
+    // both intervals intersect if either the start or the end of interval A is inside interval B.
+    block.Start >= changeStart && block.Start <= changeEnd || changeStart >= block.Start && changeStart <= block.End + 1) : false);
+  }
+  addClusterToSchema(document, clusterName, databaseNames) {
+    let clusterNameOnly = Kusto.Language.KustoFacts.GetHostName(clusterName);
+    let cluster = this._kustoJsSchemaV2.GetCluster$1(clusterNameOnly);
+    if (cluster) {
+      // add databases that are not already in the cluster.
+      databaseNames.filter(databaseName => !cluster.GetDatabase(databaseName)).map(databaseName => {
+        const symbol = new sym.DatabaseSymbol.$ctor1(databaseName, undefined, false);
+        cluster = cluster.AddDatabase(symbol);
+      });
+    }
+    if (!cluster) {
+      const databaseSymbols = databaseNames.map(databaseName => {
+        const symbol = new sym.DatabaseSymbol.$ctor1(databaseName, undefined, false);
+        return symbol;
+      });
+      const databaseSymbolsList = new (List(sym.DatabaseSymbol).$ctor1)(databaseSymbols);
+      cluster = new sym.ClusterSymbol.$ctor1(clusterNameOnly, databaseSymbolsList, false);
+    }
+    this._kustoJsSchemaV2 = this._kustoJsSchemaV2.AddOrReplaceCluster(cluster);
+    this._script = k2.CodeScript.From$1(document.getText(), this._kustoJsSchemaV2);
+    return Promise.resolve();
+  }
+  addDatabaseToSchema(document, clusterName, databaseSchema) {
+    let clusterHostName = Kusto.Language.KustoFacts.GetHostName(clusterName);
+    let cluster = this._kustoJsSchemaV2.GetCluster$1(clusterHostName);
+    if (!cluster) {
+      cluster = new sym.ClusterSymbol.$ctor1(clusterHostName, null, false);
+    }
+    const databaseSymbol = KustoLanguageService.convertToDatabaseSymbol(databaseSchema);
+    cluster = cluster.AddOrUpdateDatabase(databaseSymbol);
+    this._kustoJsSchemaV2 = this._kustoJsSchemaV2.AddOrReplaceCluster(cluster);
+    this._script = k2.CodeScript.From$1(document.getText(), this._kustoJsSchemaV2);
+    return Promise.resolve();
+  }
+  setSchema(schema) {
+    this._schema = schema;
+    // We support intellisenseV2 only if the clusterType is "Engine", even if the setting is enabled
+    if (this._languageSettings.useIntellisenseV2 && schema && schema.clusterType === 'Engine') {
+      let kustoJsSchemaV2 = this.convertToKustoJsSchemaV2(schema);
+      this._kustoJsSchemaV2 = kustoJsSchemaV2;
+      this._script = undefined;
+      this._parsePropertiesV2 = undefined;
+    }
+
+    // since V2 doesn't support control commands, we're initializing V1 intellisense for both cases and we'll going to use V1 intellisense for control commands.
+    return new Promise((resolve, reject) => {
+      const kustoJsSchema = schema ? KustoLanguageService.convertToKustoJsSchema(schema) : undefined;
+      this._kustoJsSchema = kustoJsSchema;
+      this.createRulesProvider(kustoJsSchema, schema.clusterType);
+      resolve(undefined);
+    });
+  }
+  setParameters(scalarParameters, tabularParameters) {
+    if (!this._languageSettings.useIntellisenseV2 || this._schema.clusterType !== 'Engine') {
+      throw new Error('setParameters requires intellisense V2 and Engine cluster');
+    }
+    this._schema.globalScalarParameters = scalarParameters;
+    this._schema.globalTabularParameters = tabularParameters;
+    const scalarSymbols = scalarParameters.map(param => KustoLanguageService.createParameterSymbol(param));
+    const tabularSymbols = tabularParameters.map(param => KustoLanguageService.createTabularParameterSymbol(param));
+    this._kustoJsSchemaV2 = this._kustoJsSchemaV2.WithParameters(KustoLanguageService.toBridgeList([...scalarSymbols, ...tabularSymbols]));
+    return Promise.resolve(undefined);
+  }
+
+  /**
+   * A combination of normalizeSchema and setSchema
+   * @param schema schema json as received from .show schema as json
+   * @param clusterConnectionString cluster connection string
+   * @param databaseInContextName name of database in context
+   */
+  setSchemaFromShowSchema(schema, clusterConnectionString, databaseInContextName, globalScalarParameters, globalTabularParameters) {
+    return this.normalizeSchema(schema, clusterConnectionString, databaseInContextName).then(normalized => this.setSchema({
+      ...normalized,
+      globalScalarParameters,
+      globalTabularParameters
+    }));
+  }
+
+  /**
+   * Converts the result of .show schema as json to a normalized schema used by kusto language service.
+   * @param schema result of show schema
+   * @param clusterConnectionString cluster connection string`
+   * @param databaseInContextName database in context name
+   */
+  normalizeSchema(schema, clusterConnectionString, databaseInContextName) {
+    const databases = Object.keys(schema.Databases).map(key => schema.Databases[key]).map(({
+      Name,
+      Tables,
+      ExternalTables,
+      MaterializedViews,
+      Functions,
+      MinorVersion,
+      MajorVersion
+    }) => ({
+      name: Name,
+      minorVersion: MinorVersion,
+      majorVersion: MajorVersion,
+      tables: [].concat(...[[Tables, 'Table'], [MaterializedViews, 'MaterializedView'], [ExternalTables, 'ExternalTable']].filter(([tableContainer]) => tableContainer).map(([tableContainer, tableEntity]) => Object.values(tableContainer).map(({
+        Name,
+        OrderedColumns,
+        DocString
+      }) => ({
+        name: Name,
+        docstring: DocString,
+        entityType: tableEntity,
+        columns: OrderedColumns.map(({
+          Name,
+          Type,
+          DocString,
+          CslType,
+          Examples
+        }) => ({
+          name: Name,
+          type: CslType,
+          docstring: DocString,
+          examples: Examples
+        }))
+      })))),
+      functions: Object.keys(Functions).map(key => Functions[key]).map(({
+        Name,
+        Body,
+        DocString,
+        InputParameters
+      }) => ({
+        name: Name,
+        body: Body,
+        docstring: DocString,
+        inputParameters: InputParameters.map(inputParam => ({
+          name: inputParam.Name,
+          type: inputParam.Type,
+          cslType: inputParam.CslType,
+          cslDefaultValue: inputParam.CslDefaultValue,
+          columns: inputParam.Columns ? inputParam.Columns.map(col => ({
+            name: col.Name,
+            type: col.Type,
+            cslType: col.CslType
+          })) : inputParam.Columns
+        }))
+      }))
+    }));
+    const result = {
+      clusterType: 'Engine',
+      cluster: {
+        connectionString: clusterConnectionString,
+        databases: databases
+      },
+      database: databases.filter(db => db.name === databaseInContextName)[0]
+    };
+    return Promise.resolve(result);
+  }
+  getSchema() {
+    return Promise.resolve(this._schema);
+  }
+  getCommandInContext(document, cursorOffset) {
+    return this.isIntellisenseV2() ? this.getCommandInContextV2(document, cursorOffset) : this.getCommandInContextV1(document, cursorOffset);
+  }
+  getCommandAndLocationInContext(document, cursorOffset) {
+    // We are going to remove v1 intellisense. no use to keep parity.
+    if (!document || !this.isIntellisenseV2()) {
+      return Promise.resolve(null);
+    }
+    const script = this.parseDocumentV2(document);
+    const block = this.getCurrentCommandV2(script, cursorOffset);
+    if (!block) {
+      return Promise.resolve(null);
+    }
+    const start = document.positionAt(block.Start);
+    const end = document.positionAt(block.End);
+    const location = ls.Location.create(document.uri, ls.Range.create(start, end));
+    const text = block.Text;
+    return Promise.resolve({
+      text,
+      location
+    });
+  }
+  getCommandInContextV1(document, cursorOffset) {
+    this.parseDocumentV1(document, k.ParseMode.CommandTokensOnly);
+    const command = this.getCurrentCommand(document, cursorOffset);
+    if (!command) {
+      return Promise.resolve(null);
+    }
+    return Promise.resolve(command.Text);
+  }
+  getCommandInContextV2(document, cursorOffset) {
+    if (!document) {
+      return Promise.resolve(null);
+    }
+    const script = this.parseDocumentV2(document);
+    const block = this.getCurrentCommandV2(script, cursorOffset);
+    if (!block) {
+      return Promise.resolve(null);
+    }
+
+    // TODO: do we need to do tricks like V1 is doing in this.getCurrentCommand?
+    return Promise.resolve(block.Text);
+  }
+
+  /**
+   * Return an array of commands in document. each command contains the range and text.
+   */
+  getCommandsInDocument(document) {
+    if (!document) {
+      return Promise.resolve([]);
+    }
+    return this.isIntellisenseV2() ? this.getCommandsInDocumentV2(document) : this.getCommandsInDocumentV1(document);
+  }
+  getCommandsInDocumentV1(document) {
+    this.parseDocumentV1(document, k.ParseMode.CommandTokensOnly);
+    let commands = this.toArray(this._parser.Results);
+    return Promise.resolve(commands.map(({
+      AbsoluteStart,
+      AbsoluteEnd,
+      Text
+    }) => ({
+      absoluteStart: AbsoluteStart,
+      absoluteEnd: AbsoluteEnd,
+      text: Text
+    })));
+  }
+  toPlacementStyle(formatterPlacementStyle) {
+    if (!formatterPlacementStyle) {
+      return undefined;
+    }
+    switch (formatterPlacementStyle) {
+      case 'None':
+        return k2.PlacementStyle.None;
+      case 'NewLine':
+        return k2.PlacementStyle.NewLine;
+      case 'Smart':
+        return k2.PlacementStyle.Smart;
+      default:
+        throw new Error('Unknown PlacementStyle');
+    }
+  }
+  getFormattedCommandsInDocumentV2(document, rangeStart, rangeEnd) {
+    const script = this.parseDocumentV2(document);
+    const commands = this.toArray(script.Blocks).filter(command => {
+      if (!command.Text || command.Text.trim() == '') return false;
+      if (rangeStart == null || rangeEnd == null) return true;
+
+      // calculate command end position without \r\n.
+      let commandEnd = command.End;
+      const commandText = command.Text;
+      for (let i = commandText.length - 1; i >= 0; i--) {
+        if (commandText[i] != '\r' && commandText[i] != '\n') {
+          break;
+        } else {
+          commandEnd--;
+        }
+      }
+      if (command.Start > rangeStart && command.Start < rangeEnd) return true;
+      if (commandEnd > rangeStart && commandEnd < rangeEnd) return true;
+      if (command.Start <= rangeStart && commandEnd >= rangeEnd) return true;
+    });
+    if (commands.length === 0) {
+      return {
+        formattedCommands: []
+      };
+    }
+    const formattedCommands = commands.map(command => {
+      const formatterOptions = this._languageSettings.formatter;
+      const formatter = Kusto.Language.Editor.FormattingOptions.Default.WithIndentationSize(formatterOptions?.indentationSize ?? 4).WithInsertMissingTokens(false).WithPipeOperatorStyle(this.toPlacementStyle(formatterOptions?.pipeOperatorStyle) ?? k2.PlacementStyle.Smart).WithSemicolonStyle(Kusto.Language.Editor.PlacementStyle.None).WithBrackettingStyle(k2.BrackettingStyle.Diagonal);
+      if (rangeStart == null || rangeEnd == null || rangeStart === command.Start && rangeEnd === command.End) {
+        const result = command.Service.GetFormattedText(formatter);
+        return result.Text;
+      }
+      return command.Service.GetFormattedText(formatter).Text;
+    });
+    const originalRange = this.createRange(document, commands[0].Start, commands[commands.length - 1].End);
+    return {
+      formattedCommands,
+      originalRange
+    };
+  }
+  getCommandsInDocumentV2(document) {
+    const script = this.parseDocumentV2(document);
+    let commands = this.toArray(script.Blocks).filter(command => command.Text.trim() != '');
+    return Promise.resolve(commands.map(({
+      Start,
+      End,
+      Text
+    }) => ({
+      absoluteStart: Start,
+      absoluteEnd: End,
+      text: Text
+    })));
+  }
+  getClientDirective(text) {
+    let outParam = {
+      v: null
+    };
+    const isClientDirective = k.CslCommandParser.IsClientDirective(text, outParam);
+    return Promise.resolve({
+      isClientDirective,
+      directiveWithoutLeadingComments: outParam.v
+    });
+  }
+  getAdminCommand(text) {
+    let outParam = {
+      v: null
+    };
+    const isAdminCommand = k.CslCommandParser.IsAdminCommand$1(text, outParam);
+    return Promise.resolve({
+      isAdminCommand,
+      adminCommandWithoutLeadingComments: outParam.v
+    });
+  }
+  findDefinition(document, position) {
+    if (!document || !this.isIntellisenseV2()) {
+      return Promise.resolve([]);
+    }
+    const script = this.parseDocumentV2(document);
+    const cursorOffset = document.offsetAt(position);
+    let currentBlock = this.getCurrentCommandV2(script, cursorOffset);
+    if (!currentBlock) {
+      return Promise.resolve([]);
+    }
+    const relatedInfo = currentBlock.Service.GetRelatedElements(document.offsetAt(position));
+    const relatedElements = this.toArray(relatedInfo.Elements);
+    const definition = relatedElements[0];
+    if (!definition) {
+      return Promise.resolve([]);
+    }
+    const start = document.positionAt(definition.Start);
+    const end = document.positionAt(definition.End);
+    const range = ls.Range.create(start, end);
+    const location = ls.Location.create(document.uri, range);
+    return Promise.resolve([location]);
+  }
+  findReferences(document, position) {
+    if (!document || !this.isIntellisenseV2()) {
+      return Promise.resolve([]);
+    }
+    const script = this.parseDocumentV2(document);
+    const cursorOffset = document.offsetAt(position);
+    let currentBlock = this.getCurrentCommandV2(script, cursorOffset);
+    if (!currentBlock) {
+      return Promise.resolve([]);
+    }
+    const relatedInfo = currentBlock.Service.GetRelatedElements(document.offsetAt(position));
+    const relatedElements = this.toArray(relatedInfo.Elements);
+    if (!relatedElements || relatedElements.length == 0) {
+      return Promise.resolve([]);
+    }
+    const references = relatedElements.map(relatedElement => {
+      const start = document.positionAt(relatedElement.Start);
+      const end = document.positionAt(relatedElement.End);
+      const range = ls.Range.create(start, end);
+      const location = ls.Location.create(document.uri, range);
+      return location;
+    });
+    return Promise.resolve(references);
+  }
+  getQueryParams(document, cursorOffset) {
+    if (!document || !this.isIntellisenseV2()) {
+      return Promise.resolve([]);
+    }
+    this.parseDocumentV2(document);
+    const parsedAndAnalyzed = this.parseAndAnalyze(document, cursorOffset);
+    const queryParamStatements = this.toArray(parsedAndAnalyzed.Syntax.GetDescendants(Kusto.Language.Syntax.QueryParametersStatement));
+    if (!queryParamStatements || queryParamStatements.length == 0) {
+      return Promise.resolve([]);
+    }
+    const queryParams = [];
+    queryParamStatements.forEach(paramStatement => {
+      paramStatement.WalkElements(el => el.ReferencedSymbol && el.ReferencedSymbol.Type ? queryParams.push({
+        name: el.ReferencedSymbol.Name,
+        type: el.ReferencedSymbol.Type.Name
+      }) : undefined);
+    });
+    return Promise.resolve(queryParams);
+  }
+  getRenderInfo(document, cursorOffset) {
+    const parsedAndAnalyzed = this.parseAndAnalyze(document, cursorOffset);
+    if (!parsedAndAnalyzed) {
+      return Promise.resolve(undefined);
+    }
+    const renderStatements = this.toArray(parsedAndAnalyzed.Syntax.GetDescendants(Kusto.Language.Syntax.RenderOperator));
+    if (!renderStatements || renderStatements.length === 0) {
+      return Promise.resolve(undefined);
+    }
+
+    // assuming a single render statement
+    const renderStatement = renderStatements[0];
+
+    // Start and end relative to block start.
+    const startOffset = renderStatement.TextStart;
+    const endOffset = renderStatement.End;
+    const visualization = renderStatement.ChartType.ValueText;
+    const withClause = renderStatement.WithClause;
+    if (!withClause) {
+      const info = {
+        options: {
+          visualization
+        },
+        location: {
+          startOffset,
+          endOffset
+        }
+      };
+      return Promise.resolve(info);
+    }
+    const properties = this.toArray(withClause.Properties);
+    const props = properties.reduce((prev, property) => {
+      const name = property.Element$1.Name.SimpleName;
+      switch (name) {
+        case 'xcolumn':
+          const value = property.Element$1.Expression.ReferencedSymbol.Name;
+          prev[name] = value;
+          break;
+        case 'ycolumns':
+        case 'anomalycolumns':
+          const nameNodes = this.toArray(property.Element$1.Expression.Names);
+          const values = nameNodes.map(nameNode => nameNode.Element$1.SimpleName);
+          prev[name] = values;
+          break;
+        case 'ymin':
+        case 'ymax':
+          const numericVal = parseFloat(property.Element$1.Expression.ConstantValue);
+          prev[name] = numericVal;
+          break;
+        case 'title':
+        case 'xtitle':
+        case 'ytitle':
+        case 'visualization':
+        case 'series':
+          const strVal = property.Element$1.Expression.ConstantValue;
+          prev[name] = strVal;
+          break;
+        case 'xaxis':
+        case 'yaxis':
+          const scale = property.Element$1.Expression.ConstantValue;
+          prev[name] = scale;
+          break;
+        case 'legend':
+          const legend = property.Element$1.Expression.ConstantValue;
+          prev[name] = legend;
+          break;
+        case 'ysplit':
+          const split = property.Element$1.Expression.ConstantValue;
+          prev[name] = split;
+          break;
+        case 'accumulate':
+          const accumulate = property.Element$1.Expression.ConstantValue;
+          prev[name] = accumulate;
+          break;
+        case 'kind':
+          const val = property.Element$1.Expression.ConstantValue;
+          prev[name] = val;
+          break;
+        default:
+          assertNever(name);
+      }
+      return prev;
+    }, {});
+    const renderOptions = {
+      visualization,
+      ...props
+    };
+    const renderInfo = {
+      options: renderOptions,
+      location: {
+        startOffset,
+        endOffset
+      }
+    };
+    return Promise.resolve(renderInfo);
+  }
+  getReferencedSymbols(document, offset) {
+    const parsedAndAnalyzed = this.parseAndAnalyze(document, offset);
+    if (!parsedAndAnalyzed) {
+      Promise.resolve([]);
+    }
+
+    // We take all referenced symbols in the query
+    const referencedSymbols = this.toArray(parsedAndAnalyzed.Syntax.GetDescendants(Kusto.Language.Syntax.Expression)).filter(expression => expression.ReferencedSymbol !== null).map(x => x.ReferencedSymbol);
+    const result = referencedSymbols.map(sym => ({
+      name: sym.Name,
+      kind: symbolKindToName[sym.Kind] ?? `${sym.Kind}`,
+      display: sym.Display
+    }));
+    return Promise.resolve(result);
+  }
+  getReferencedGlobalParams(document, cursorOffset) {
+    const parsedAndAnalyzed = this.parseAndAnalyze(document, cursorOffset);
+    if (!parsedAndAnalyzed) {
+      Promise.resolve([]);
+    }
+
+    // We take the ambient parameters
+    const ambientParameters = this.toArray(this._kustoJsSchemaV2.Parameters);
+
+    // We take all referenced symbols in the query
+    const referencedSymbols = this.toArray(parsedAndAnalyzed.Syntax.GetDescendants(Kusto.Language.Syntax.Expression)).filter(expression => expression.ReferencedSymbol !== null).map(x => x.ReferencedSymbol);
+
+    // The Intersection between them is the ambient parameters that are used in the query.
+    // Note: Ideally we would use Set here (or at least array.Include), but were' compiling down to es2015.
+    const intersection = referencedSymbols.filter(referencedSymbol => ambientParameters.filter(ambientParameter => ambientParameter === referencedSymbol).length > 0);
+    const result = intersection.map(param => ({
+      name: param.Name,
+      type: param.Type.Name
+    }));
+    return Promise.resolve(result);
+  }
+  getGlobalParams(document) {
+    if (!this.isIntellisenseV2()) {
+      return Promise.resolve([]);
+    }
+    const params = this.toArray(this._kustoJsSchemaV2.Parameters);
+    const result = params.map(param => ({
+      name: param.Name,
+      type: param.Type.Name
+    }));
+    return Promise.resolve(result);
+  }
+  doRename(document, position, newName) {
+    if (!document || !this.isIntellisenseV2()) {
+      return Promise.resolve(undefined);
+    }
+    const script = this.parseDocumentV2(document);
+    const cursorOffset = document.offsetAt(position);
+    let currentBLock = this.getCurrentCommandV2(script, cursorOffset);
+    if (!currentBLock) {
+      return Promise.resolve(undefined);
+    }
+    const relatedInfo = currentBLock.Service.GetRelatedElements(document.offsetAt(position));
+    const relatedElements = this.toArray(relatedInfo.Elements);
+    const declarations = relatedElements.filter(e => e.Kind == k2.RelatedElementKind.Declaration);
+
+    // A declaration must be one of the elements
+    if (!declarations || declarations.length == 0) {
+      return Promise.resolve(undefined);
+    }
+    const edits = relatedElements.map(edit => {
+      const start = document.positionAt(edit.Start);
+      const end = document.positionAt(edit.End);
+      const range = ls.Range.create(start, end);
+      return ls.TextEdit.replace(range, newName);
+    });
+
+    // create a workspace edit
+    const workspaceEdit = {
+      changes: {
+        [document.uri]: edits
+      }
+    };
+    return Promise.resolve(workspaceEdit);
+  }
+  doHover(document, position) {
+    if (!document || !this.isIntellisenseV2()) {
+      return Promise.resolve(undefined);
+    }
+    const script = this.parseDocumentV2(document);
+    const cursorOffset = document.offsetAt(position);
+    let currentBLock = this.getCurrentCommandV2(script, cursorOffset);
+    if (!currentBLock) {
+      return Promise.resolve(undefined);
+    }
+    const isSupported = currentBLock.Service.IsFeatureSupported(k2.CodeServiceFeatures.QuickInfo, cursorOffset);
+    if (!isSupported) {
+      return Promise.resolve(undefined);
+    }
+    const quickInfo = currentBLock.Service.GetQuickInfo(cursorOffset);
+    if (!quickInfo || !quickInfo.Items) {
+      return Promise.resolve(undefined);
+    }
+    let items = this.toArray(quickInfo.Items);
+    if (!items) {
+      return Promise.resolve(undefined);
+    }
+
+    // Errors, Warnings and Suggestions are already shown in getDiagnostics. we don't want them in doHover.
+    items = items.filter(item => item.Kind !== k2.QuickInfoKind.Error && item.Kind !== k2.QuickInfoKind.Suggestion && item.Kind !== k2.QuickInfoKind.Warning);
+    const itemsText = items.map(item => item.Text.replace('\n\n', '\n* * *\n'));
+    // separate items by horizontal line.
+    const text = itemsText.join('\n* * *\n');
+    // Instead of just an empty line between the first line (the signature) and the second line (the description)
+    // add an horizontal line (* * * in markdown) between them.
+    return Promise.resolve({
+      contents: text
+    });
+  }
+
+  //#region dummy schema for manual testing
+  static get dummySchema() {
+    const database = {
+      majorVersion: 0,
+      minorVersion: 0,
+      name: 'Kuskus',
+      tables: [{
+        name: 'KustoLogs',
+        columns: [{
+          name: 'Source',
+          type: 'string'
+        }, {
+          name: 'Timestamp',
+          type: 'datetime'
+        }, {
+          name: 'Directory',
+          type: 'string'
+        }],
+        docstring: 'A dummy description to test that docstring shows as expected when hovering over a table'
+      }],
+      functions: [{
+        name: 'HowBig',
+        inputParameters: [{
+          name: 'T',
+          columns: [{
+            name: 'Timestamp',
+            type: 'System.DateTime',
+            cslType: 'datetime'
+          }]
+        }],
+        docstring: 'A dummy description to test that docstring shows as expected when hovering over a function',
+        body: "{\r\n    union \r\n    (T | count | project V='Volume', Metric = strcat(Count/1e9, ' Billion records')),\r\n    (T | summarize FirstRecord=min(Timestamp)| project V='Volume', Metric = strcat(toint((now()-FirstRecord)/1d), ' Days of data (from: ', format_datetime(FirstRecord, 'yyyy-MM-dd'),')')),\r\n    (T | where Timestamp > ago(1h) | count | project V='Velocity', Metric = strcat(Count/1e6, ' Million records / hour')),\r\n    (T | summarize Latency=now()-max(Timestamp) | project V='Velocity', Metric = strcat(Latency / 1sec, ' seconds latency')),\r\n    (T | take 1 | project V='Variety', Metric=tostring(pack_all()))\r\n    | order by V \r\n}"
+      }, {
+        name: 'FindCIDPast24h',
+        inputParameters: [{
+          name: 'clientActivityId',
+          type: 'System.String',
+          cslType: 'string'
+        }],
+        body: '{ KustoLogs | where Timestamp > now(-1d) | where ClientActivityId == clientActivityId}   '
+      }]
+    };
+    const languageServiceSchema = {
+      clusterType: 'Engine',
+      cluster: {
+        connectionString: 'https://kuskus.kusto.windows.net;fed=true',
+        databases: [database]
+      },
+      database: database
+    };
+    return languageServiceSchema;
+  }
+  //#endregion
+
+  static convertToEntityDataType(kustoType) {}
+  /**
+   * We do not want to expose Bridge.Net generated schema, so we expose a cleaner javascript schema.
+   * Here it gets converted to the bridge.Net schema
+   * @param schema Language Service schema
+   */
+  static convertToKustoJsSchema(schema) {
+    switch (schema.clusterType) {
+      case 'Engine':
+        const currentDatabaseName = schema.database ? schema.database.name : undefined;
+        const kCluster = new k.KustoIntelliSenseClusterEntity();
+        let kDatabaseInContext = undefined;
+        kCluster.ConnectionString = schema.cluster.connectionString;
+        const databases = [];
+        schema.cluster.databases.forEach(database => {
+          const kDatabase = new k.KustoIntelliSenseDatabaseEntity();
+          kDatabase.Name = database.name;
+          const tables = [];
+          database.tables.forEach(table => {
+            const kTable = new k.KustoIntelliSenseTableEntity();
+            kTable.Name = table.name;
+            const cols = [];
+            table.columns.forEach(column => {
+              const kColumn = new k.KustoIntelliSenseColumnEntity();
+              kColumn.Name = column.name;
+              kColumn.TypeCode = k.EntityDataType[getEntityDataTypeFromCslType(column.type)];
+              cols.push(kColumn);
+            });
+            kTable.Columns = new Bridge.ArrayEnumerable(cols);
+            tables.push(kTable);
+          });
+          const functions = [];
+          database.functions.forEach(fn => {
+            const kFunction = new k.KustoIntelliSenseFunctionEntity();
+            kFunction.Name = fn.name, kFunction.CallName = getCallName(fn), kFunction.Expression = getExpression(fn), functions.push(kFunction);
+          });
+          kDatabase.Tables = new Bridge.ArrayEnumerable(tables);
+          kDatabase.Functions = new Bridge.ArrayEnumerable(functions);
+          databases.push(kDatabase);
+          if (database.name == currentDatabaseName) {
+            kDatabaseInContext = kDatabase;
+          }
+        });
+        kCluster.Databases = new Bridge.ArrayEnumerable(databases);
+        const kSchema = new k.KustoIntelliSenseQuerySchema(kCluster, kDatabaseInContext);
+        return kSchema;
+      case 'ClusterManager':
+        const accounts = schema.accounts.map(account => {
+          const kAccount = new k.KustoIntelliSenseAccountEntity();
+          kAccount.Name = account;
+          return kAccount;
+        });
+        const services = schema.services.map(service => {
+          const kService = new k.KustoIntelliSenseServiceEntity();
+          kService.Name = service;
+          return kService;
+        });
+        const connectionString = schema.connectionString;
+        const result = {
+          accounts,
+          services,
+          connectionString
+        };
+        return result;
+      case 'DataManagement':
+        return undefined;
+      default:
+        return assertNever(schema);
+    }
+  }
+
+  /**
+   * Returns something like '(x: string, y: datetime)'
+   * @param params scalar parameters
+   */
+  static scalarParametersToSignature(params) {
+    const signatureWithoutParens = params.map(param => `${param.name}: ${param.cslType}`).join(', ');
+    return `(${signatureWithoutParens})`;
+  }
+
+  /**
+   * Returns something like '(x: string, T: (y: int))'
+   * @param params input parameters (tabular or scalar)
+   */
+  static inputParameterToSignature(params) {
+    const signatureWithoutParens = params.map(param => {
+      if (param.columns) {
+        const tableSignature = this.scalarParametersToSignature(param.columns);
+        return `${param.name}: ${tableSignature}`;
+      } else {
+        return `${param.name}: ${param.cslType}`;
+      }
+    }).join(', ');
+    return `(${signatureWithoutParens})`;
+  }
+
+  /**
+   * converts a function definition to a let statement.
+   * @param fn function
+   */
+  static toLetStatement(fn) {
+    const signature = this.inputParameterToSignature(fn.inputParameters);
+    return `let ${fn.name} = ${signature} ${fn.body}`;
+  }
+  static createColumnSymbol(col) {
+    return new sym.ColumnSymbol(col.name, sym.ScalarTypes.GetSymbol(getCslTypeNameFromClrType(col.type)), col.docstring, null, null, col.examples ? KustoLanguageService.toBridgeList(col.examples) : null);
+  }
+  static createParameterSymbol(param) {
+    const paramSymbol = Kusto.Language.Symbols.ScalarTypes.GetSymbol(getCslTypeNameFromClrType(param.type));
+    return new sym.ParameterSymbol(param.name, paramSymbol, null);
+  }
+  static createTabularParameterSymbol(param) {
+    const columnSymbols = param.columns.map(col => KustoLanguageService.createColumnSymbol(col));
+    const para = new Kusto.Language.Symbols.TableSymbol.$ctor4(param.name, columnSymbols);
+    return new sym.ParameterSymbol(param.name, para, param.docstring);
+  }
+  static createParameter(param) {
+    if (!param.columns) {
+      const paramSymbol = Kusto.Language.Symbols.ScalarTypes.GetSymbol(getCslTypeNameFromClrType(param.type));
+      const expression = param.cslDefaultValue && typeof param.cslDefaultValue === 'string' ? parsing.QueryParser.ParseLiteral$1(param.cslDefaultValue) : undefined;
+      return new sym.Parameter.$ctor3(param.name, paramSymbol, null, null, null, false, null, 1, 1, expression, null);
+    }
+    if (param.columns.length == 0) {
+      return new sym.Parameter.ctor(param.name, sym.ParameterTypeKind.Tabular, sym.ArgumentKind.Expression, null, null, false, null, 1, 1, null, null);
+    }
+    const argumentType = new sym.TableSymbol.ctor(param.columns.map(col => KustoLanguageService.createColumnSymbol(col)));
+    return new sym.Parameter.$ctor2(param.name, argumentType);
+  }
+  static convertToDatabaseSymbol(db) {
+    const createFunctionSymbol = fn => {
+      const parameters = fn.inputParameters.map(param => KustoLanguageService.createParameter(param));
+
+      // TODO: handle outputColumns (right now it doesn't seem to be implemented for any function).
+      return new sym.FunctionSymbol.$ctor14(fn.name, fn.body, KustoLanguageService.toBridgeList(parameters), fn.docstring);
+    };
+    const createTableSymbol = tbl => {
+      const columnSymbols = tbl.columns.map(col => KustoLanguageService.createColumnSymbol(col));
+      let symbol = new sym.TableSymbol.$ctor4(tbl.name, columnSymbols);
+      symbol.Description = tbl.docstring;
+      switch (tbl.entityType) {
+        case 'MaterializedViewTable':
+          const mvQuery = tbl.mvQuery ?? null;
+          symbol = new sym.MaterializedViewSymbol.$ctor2(tbl.name, symbol.Columns, mvQuery, tbl.docstring);
+          symbol = symbol.WithIsMaterializedView(true);
+          break;
+        case 'ExternalTable':
+          symbol = symbol.WithIsExternal(true);
+          break;
+      }
+      return symbol;
+    };
+    const createDatabaseSymbol = db => {
+      const tableSymbols = db.tables ? db.tables.map(tbl => createTableSymbol(tbl)) : [];
+      const functionSymbols = db.functions ? db.functions.map(fun => createFunctionSymbol(fun)) : [];
+      return new sym.DatabaseSymbol.ctor(db.name, tableSymbols.concat(functionSymbols));
+    };
+    const databaseSymbol = createDatabaseSymbol(db);
+    return databaseSymbol;
+  }
+  convertToKustoJsSchemaV2(schema) {
+    let cached = this._schemaCache[schema.cluster.connectionString];
+
+    // create a cache entry for the cluster if non yet exists.
+    if (!cached) {
+      this._schemaCache[schema.cluster.connectionString] = {};
+      cached = this._schemaCache[schema.cluster.connectionString];
+    }
+
+    // Remove deleted databases from cache
+    const schemaDbLookup = schema.cluster.databases.reduce((prev, curr) => prev[curr.name] = curr, {});
+    Object.keys(cached).map(dbName => {
+      if (!schemaDbLookup[dbName]) {
+        delete cached.dbName;
+      }
+    });
+    let globalState = GlobalState.Default;
+    const currentDatabaseName = schema.database ? schema.database.name : undefined;
+    let databaseInContext = undefined;
+
+    // Update out-of-data databases to cache
+    const databases = schema.cluster.databases.map(db => {
+      const shouldIncludeFunctions = db.name === currentDatabaseName;
+      const cachedDb = cached[db.name];
+      // This is an older version than we have, or we need to parse functions.
+      if (!cachedDb || cachedDb.database.majorVersion < db.majorVersion || shouldIncludeFunctions && !cachedDb.includesFunctions) {
+        // only add functions for the database in context (it's very time consuming)
+
+        const databaseSymbol = KustoLanguageService.convertToDatabaseSymbol(db);
+        cached[db.name] = {
+          database: db,
+          symbol: databaseSymbol,
+          includesFunctions: shouldIncludeFunctions
+        };
+      }
+      const databaseSymbol = cached[db.name].symbol;
+      if (db.name === currentDatabaseName) {
+        databaseInContext = databaseSymbol;
+      }
+      return databaseSymbol;
+    });
+
+    // Replace new URL due to polyfill issue in IE
+    // const hostname = new URL(schema.cluster.connectionString.split(';')[0]).hostname;
+    const hostname = schema.cluster.connectionString.match(/(.*\/\/)?([^\/;]*)/)[2];
+    const clusterName = hostname.split('.')[0];
+    const clusterSymbol = new sym.ClusterSymbol.ctor(clusterName, databases);
+    globalState = globalState.WithCluster(clusterSymbol);
+    if (databaseInContext) {
+      globalState = globalState.WithDatabase(databaseInContext);
+    }
+
+    // Inject global scalar parameters to global scope.
+    const scalarParameters = (schema.globalScalarParameters ?? []).map(param => KustoLanguageService.createParameterSymbol(param));
+
+    // Inject global tabular parameters to global scope.
+    let tabularParameters = (schema.globalTabularParameters ?? []).map(param => KustoLanguageService.createTabularParameterSymbol(param));
+    if (tabularParameters.length || scalarParameters.length) {
+      globalState = globalState.WithParameters(KustoLanguageService.toBridgeList([...scalarParameters, ...tabularParameters]));
+    }
+    return globalState;
+  }
+  getClassificationsFromParseResult(offset = 0) {
+    const classifications = this.toArray(this._parser.Results).map(command => this.toArray(command.Tokens)).reduce((prev, curr) => prev.concat(curr), []).map(cslCommandToken => {
+      const range = new k2.ClassifiedRange(this.tokenKindToClassificationKind(cslCommandToken.TokenKind), cslCommandToken.AbsoluteStart + offset, cslCommandToken.Length);
+      return range;
+    });
+    return classifications;
+  }
+
+  /**
+   * trim trailing newlines from range
+   */
+  static trimTrailingNewlineFromRange(textInRange, rangeStartOffset, document, range) {
+    let currentIndex = textInRange.length - 1;
+    while (textInRange[currentIndex] === '\r' || textInRange[currentIndex] === '\n') {
+      --currentIndex;
+    }
+    const newEndOffset = rangeStartOffset + currentIndex + 1;
+    const newEndPosition = document.positionAt(newEndOffset);
+    const newRange = ls.Range.create(range.start, newEndPosition);
+    return newRange;
+  }
+
+  /**
+   * Maps numbers to strings, such that if a>b numerically, f(a)>f(b) lexicographically.
+   * 1 -> "a", 26 -> "z", 27 -> "za", 28 -> "zb", 52 -> "zz", 53 ->"zza"
+   * @param order - The number to be converted to a sorting-string. order should start at 1.
+   * @returns A string repenting the order.
+   */
+  getSortText(order) {
+    if (order <= 0) {
+      throw new RangeError(`order should be a number >= 1. instead got ${order}`);
+    }
+    let sortText = '';
+    let numCharacters = 26; // "z" - "a" + 1;
+
+    let div = Math.floor(order / numCharacters);
+    for (let i = 0; i < div; ++i) {
+      sortText += 'z';
+    }
+    let reminder = order % numCharacters;
+    if (reminder > 0) {
+      sortText += String.fromCharCode(96 + reminder);
+    }
+    return sortText;
+  }
+
+  /**
+   * ParseTextV1 parses the given text with the given parse mode.
+   * Additionally - it will make sure not to provide rules provider for non-engine clusters
+   * since the only rules provider parse can handle is the engine's. It will try to look for function
+   * definitions to colorize and will throw since they're not there.
+   * @param text
+   * @param parseMode
+   */
+  parseTextV1(text, parseMode) {
+    this._parser.Parse(this._schema.clusterType === 'Engine' ? this._rulesProvider : null, text, parseMode);
+  }
+  parseDocumentV1(document, parseMode) {
+    // already parsed a later version, or better parse mode for this uri
+    if (this._parsePropertiesV1 && !this._parsePropertiesV1.isParseNeeded(document, this._rulesProvider, parseMode)) {
+      return;
+    }
+    this.parseTextV1(document.getText(), parseMode);
+    this._parsePropertiesV1 = new ParseProperties(document.version, document.uri, this._rulesProvider, parseMode);
+  }
+  parseDocumentV2(document) {
+    if (this._parsePropertiesV2 && !this._parsePropertiesV2.isParseNeeded(document, this._rulesProvider)) {
+      return this._script;
+    }
+    if (!this._script) {
+      this._script = k2.CodeScript.From$1(document.getText(), this._kustoJsSchemaV2);
+    } else {
+      this._script = this._script.WithText(document.getText());
+    }
+    this._parsePropertiesV2 = new ParseProperties(document.version, document.uri);
+    return this._script;
+  }
+
+  /**
+   * Return the CslCommand that wraps the caret location, or undefined if caret is outside any command
+   * @param document the document to extract the current command from
+   * @param caretAbsolutePosition absolute caret position
+   */
+  getCurrentCommand(document, caretAbsolutePosition) {
+    let commands = this.toArray(this._parser.Results);
+    let command = commands.filter(command => command.AbsoluteStart <= caretAbsolutePosition && command.AbsoluteEnd >= caretAbsolutePosition)[0];
+
+    // There is an edge case when cursor appears at the end of the command
+    // which is not yet considered to be part of the parsed command (therefore: +1 for the AbsoluteEdit property)
+    if (!command) {
+      command = commands.filter(command => command.AbsoluteStart <= caretAbsolutePosition && command.AbsoluteEnd + 1 >= caretAbsolutePosition)[0];
+
+      // If we have 2 newlines in the end of the text the cursor is _probably_ at the end of the text
+      // which this means that we're not actually standing on any command. Thus return null.
+      if (!command || command.Text.endsWith('\r\n\r\n')) {
+        return null;
+      }
+    }
+    return command;
+  }
+  getCurrentCommandV2(script, offset) {
+    let block = script.GetBlockAtPosition(offset);
+    return block;
+  }
+  getTextToInsert(rule, option) {
+    const beforeApplyInfo = rule.GetBeforeApplyInfo(option.Value);
+    const afterApplyInfo = rule.GetAfterApplyInfo(option.Value);
+
+    // this is the basic text to be inserted,
+    // but we still need to figure out where the cursor will end up after completion is applied.
+    let insertText = beforeApplyInfo.Text || '' + option.Value + afterApplyInfo.Text || '';
+    let insertTextFormat = ls.InsertTextFormat.PlainText;
+    const snippetFinalTabStop = '$0';
+    if (afterApplyInfo.OffsetToken && afterApplyInfo.OffsetPosition) {
+      const tokenOffset = insertText.indexOf(afterApplyInfo.OffsetToken);
+      if (tokenOffset >= 0) {
+        insertText = this.insertToString(insertText, snippetFinalTabStop, tokenOffset - insertText.length + afterApplyInfo.OffsetPosition);
+        insertTextFormat = ls.InsertTextFormat.Snippet;
+      }
+    } else if (afterApplyInfo.OffsetPosition) {
+      // We only handle negative offsets
+      insertText = this.insertToString(insertText, snippetFinalTabStop, afterApplyInfo.OffsetPosition);
+      insertTextFormat = ls.InsertTextFormat.Snippet;
+    }
+    return {
+      insertText,
+      insertTextFormat
+    };
+  }
+
+  /**
+   * create a new string with stringToInsert inserted at offsetFromEnd in originalString.
+   * @param originalString string to insert to
+   * @param stringToInsert string to insert
+   * @param offsetFromEnd a negative number that will represent offset to the left. 0 means simple concat
+   */
+  insertToString(originalString, stringToInsert, offsetFromEnd) {
+    let index = originalString.length + offsetFromEnd;
+    if (offsetFromEnd >= 0 || index < 0) {
+      return originalString; // Cannot insert before or after the string
+    }
+
+    let before = originalString.substring(0, index);
+    let after = originalString.substring(index);
+    return before + stringToInsert + after;
+  }
+  getCommandWithoutLastWord(text) {
+    const lastWordRegex = XRegExp('[\\w_]*$', 's');
+    return text.replace(lastWordRegex, '');
+  }
+  createRulesProvider(schema, clusterType) {
+    let queryParameters = new (List(String))();
+    let availableClusters = new (List(String))();
+    this._parser = new k.CslCommandParser();
+    if (clusterType == 'Engine') {
+      const engineSchema = schema;
+      this._rulesProvider = this._languageSettings && this._languageSettings.includeControlCommands ? new k.CslIntelliSenseRulesProvider.$ctor1(engineSchema.Cluster, engineSchema, queryParameters, availableClusters, null, true, true) : new k.CslQueryIntelliSenseRulesProvider.$ctor1(engineSchema.Cluster, engineSchema, queryParameters, availableClusters, null, null, null);
+      return;
+    }
+    if (clusterType === 'DataManagement') {
+      this._rulesProvider = new k.DataManagerIntelliSenseRulesProvider(null);
+      return;
+    }
+
+    // This is a cluster manger
+    const {
+      accounts,
+      services,
+      connectionString
+    } = schema;
+    new k.KustoIntelliSenseAccountEntity();
+    new k.KustoIntelliSenseServiceEntity();
+    this._rulesProvider = new k.ClusterManagerIntelliSenseRulesProvider.$ctor1(new Bridge.ArrayEnumerable(accounts), new Bridge.ArrayEnumerable(services), connectionString);
+  }
+  _kustoKindtolsKind = {
+    [k.OptionKind.None]: ls.CompletionItemKind.Interface,
+    [k.OptionKind.Operator]: ls.CompletionItemKind.Method,
+    [k.OptionKind.Command]: ls.CompletionItemKind.Method,
+    [k.OptionKind.Service]: ls.CompletionItemKind.Class,
+    [k.OptionKind.Policy]: ls.CompletionItemKind.Reference,
+    [k.OptionKind.Database]: ls.CompletionItemKind.Class,
+    [k.OptionKind.Table]: ls.CompletionItemKind.Class,
+    [k.OptionKind.DataType]: ls.CompletionItemKind.Class,
+    [k.OptionKind.Literal]: ls.CompletionItemKind.Property,
+    [k.OptionKind.Parameter]: ls.CompletionItemKind.Variable,
+    [k.OptionKind.IngestionMapping]: ls.CompletionItemKind.Variable,
+    [k.OptionKind.ExpressionFunction]: ls.CompletionItemKind.Variable,
+    [k.OptionKind.Option]: ls.CompletionItemKind.Interface,
+    [k.OptionKind.OptionKind]: ls.CompletionItemKind.Interface,
+    [k.OptionKind.OptionRender]: ls.CompletionItemKind.Interface,
+    [k.OptionKind.Column]: ls.CompletionItemKind.Function,
+    [k.OptionKind.ColumnString]: ls.CompletionItemKind.Field,
+    [k.OptionKind.ColumnNumeric]: ls.CompletionItemKind.Field,
+    [k.OptionKind.ColumnDateTime]: ls.CompletionItemKind.Field,
+    [k.OptionKind.ColumnTimespan]: ls.CompletionItemKind.Field,
+    [k.OptionKind.FunctionServerSide]: ls.CompletionItemKind.Field,
+    [k.OptionKind.FunctionAggregation]: ls.CompletionItemKind.Field,
+    [k.OptionKind.FunctionFilter]: ls.CompletionItemKind.Field,
+    [k.OptionKind.FunctionScalar]: ls.CompletionItemKind.Field,
+    [k.OptionKind.ClientDirective]: ls.CompletionItemKind.Enum
+  };
+  _kustoKindToLsKindV2 = {
+    [k2.CompletionKind.AggregateFunction]: ls.CompletionItemKind.Field,
+    [k2.CompletionKind.BuiltInFunction]: ls.CompletionItemKind.Field,
+    [k2.CompletionKind.Cluster]: ls.CompletionItemKind.Class,
+    [k2.CompletionKind.Column]: ls.CompletionItemKind.Function,
+    [k2.CompletionKind.CommandPrefix]: ls.CompletionItemKind.Field,
+    [k2.CompletionKind.Database]: ls.CompletionItemKind.Class,
+    [k2.CompletionKind.DatabaseFunction]: ls.CompletionItemKind.Field,
+    [k2.CompletionKind.Example]: ls.CompletionItemKind.Text,
+    [k2.CompletionKind.Identifier]: ls.CompletionItemKind.Method,
+    [k2.CompletionKind.Keyword]: ls.CompletionItemKind.Method,
+    [k2.CompletionKind.LocalFunction]: ls.CompletionItemKind.Field,
+    [k2.CompletionKind.MaterialiedView]: ls.CompletionItemKind.Class,
+    [k2.CompletionKind.Parameter]: ls.CompletionItemKind.Variable,
+    [k2.CompletionKind.Punctuation]: ls.CompletionItemKind.Interface,
+    [k2.CompletionKind.QueryPrefix]: ls.CompletionItemKind.Function,
+    [k2.CompletionKind.RenderChart]: ls.CompletionItemKind.Method,
+    [k2.CompletionKind.ScalarInfix]: ls.CompletionItemKind.Field,
+    [k2.CompletionKind.ScalarPrefix]: ls.CompletionItemKind.Field,
+    [k2.CompletionKind.ScalarType]: ls.CompletionItemKind.TypeParameter,
+    [k2.CompletionKind.Syntax]: ls.CompletionItemKind.Method,
+    [k2.CompletionKind.Table]: ls.CompletionItemKind.Class,
+    [k2.CompletionKind.TabularPrefix]: ls.CompletionItemKind.Field,
+    // datatable, externaldata
+    [k2.CompletionKind.TabularSuffix]: ls.CompletionItemKind.Field,
+    [k2.CompletionKind.Unknown]: ls.CompletionItemKind.Interface,
+    [k2.CompletionKind.Variable]: ls.CompletionItemKind.Variable,
+    [k2.CompletionKind.Option]: ls.CompletionItemKind.Text,
+    [k2.CompletionKind.Graph]: ls.CompletionItemKind.Class
+  };
+  kustoKindToLsKind(kustoKind) {
+    let res = this._kustoKindtolsKind[kustoKind];
+    return res ? res : ls.CompletionItemKind.Variable;
+  }
+  kustoKindToLsKindV2(kustoKind) {
+    let res = this._kustoKindToLsKindV2[kustoKind];
+    return res ? res : ls.CompletionItemKind.Variable;
+  }
+  createRange(document, start, end) {
+    return ls.Range.create(document.positionAt(start), document.positionAt(end));
+  }
+  toArray(bridgeList) {
+    return Bridge.toArray(bridgeList);
+  }
+  static toBridgeList(array) {
+    // copied from bridge.js from the implementation of Enumerable.prototype.toList
+    return new (System.Collections.Generic.List$1(System.Object).$ctor1)(array);
+  }
+  _tokenKindToClassificationKind = {
+    [TokenKind.TableToken]: k2.ClassificationKind.Table,
+    [TokenKind.TableColumnToken]: k2.ClassificationKind.Column,
+    [TokenKind.OperatorToken]: k2.ClassificationKind.QueryOperator,
+    [TokenKind.SubOperatorToken]: k2.ClassificationKind.Function,
+    [TokenKind.CalculatedColumnToken]: k2.ClassificationKind.Column,
+    [TokenKind.StringLiteralToken]: k2.ClassificationKind.Literal,
+    [TokenKind.FunctionNameToken]: k2.ClassificationKind.Function,
+    [TokenKind.UnknownToken]: k2.ClassificationKind.PlainText,
+    [TokenKind.CommentToken]: k2.ClassificationKind.Comment,
+    [TokenKind.PlainTextToken]: k2.ClassificationKind.PlainText,
+    [TokenKind.DataTypeToken]: k2.ClassificationKind.Type,
+    [TokenKind.ControlCommandToken]: k2.ClassificationKind.PlainText,
+    // TODO ?
+    [TokenKind.CommandPartToken]: k2.ClassificationKind.PlainText,
+    // TODO ?
+    [TokenKind.QueryParametersToken]: k2.ClassificationKind.QueryParameter,
+    [TokenKind.CslCommandToken]: k2.ClassificationKind.Keyword,
+    // TODO ?
+    [TokenKind.LetVariablesToken]: k2.ClassificationKind.Identifier,
+    // TODO ?
+    [TokenKind.PluginToken]: k2.ClassificationKind.Function,
+    [TokenKind.BracketRangeToken]: k2.ClassificationKind.Keyword,
+    // TODO ?
+    [TokenKind.ClientDirectiveToken]: k2.ClassificationKind.Keyword // TODO ?
+  };
+
+  tokenKindToClassificationKind(token) {
+    const conversion = this._tokenKindToClassificationKind[token];
+    return conversion || k2.ClassificationKind.PlainText;
+  }
+  parseAndAnalyze(document, cursorOffset) {
+    if (!document || !this.isIntellisenseV2()) {
+      return undefined;
+    }
+    const script = this.parseDocumentV2(document);
+    let text = script.Text;
+    if (cursorOffset !== undefined) {
+      let currentBlock = this.getCurrentCommandV2(script, cursorOffset);
+      if (!currentBlock) {
+        return undefined;
+      }
+      text = currentBlock.Text;
+    }
+    const parsedAndAnalyzed = Kusto.Language.KustoCode.ParseAndAnalyze(text, this._kustoJsSchemaV2);
+    return parsedAndAnalyzed;
+  }
+}
+let languageService = new KustoLanguageService(KustoLanguageService.dummySchema, {
+  includeControlCommands: true,
+  useIntellisenseV2: true,
+  useSemanticColorization: true
+});
+
+/**
+ * Obtain an instance of the kusto language service.
+ */
+function getKustoLanguageService() {
+  return languageService;
+}
+
+class KustoWorker {
+  // --- model sync -----------------------
+
+  constructor(ctx, createData) {
+    this._ctx = ctx;
+    this._languageSettings = createData.languageSettings;
+    this._languageService = getKustoLanguageService();
+    this._languageService.configure(this._languageSettings);
+  }
+
+  // --- language service host ---------------
+
+  setSchema(schema) {
+    return this._languageService.setSchema(schema);
+  }
+  addClusterToSchema(uri, clusterName, databasesNames) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      console.error(`addClusterToSchema: document is ${document}. uri is ${uri}`);
+      return Promise.resolve();
+    }
+    return this._languageService.addClusterToSchema(document, clusterName, databasesNames);
+  }
+  addDatabaseToSchema(uri, clusterName, databaseSchema) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      console.error(`addDatabaseToSchema: document is ${document}. uri is ${uri}`);
+      return Promise.resolve();
+    }
+    return this._languageService.addDatabaseToSchema(document, clusterName, databaseSchema);
+  }
+  setSchemaFromShowSchema(schema, clusterConnectionString, databaseInContextName) {
+    return this._languageService.setSchemaFromShowSchema(schema, clusterConnectionString, databaseInContextName);
+  }
+  normalizeSchema(schema, clusterConnectionString, databaseInContextName) {
+    return this._languageService.normalizeSchema(schema, clusterConnectionString, databaseInContextName);
+  }
+  getSchema() {
+    return this._languageService.getSchema();
+  }
+  getCommandInContext(uri, cursorOffset) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      console.error(`getCommandInContext: document is ${document}. uri is ${uri}`);
+      return null;
+    }
+    const commandInContext = this._languageService.getCommandInContext(document, cursorOffset);
+    if (commandInContext === undefined) {
+      return null;
+    }
+    return commandInContext;
+  }
+  getQueryParams(uri, cursorOffset) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      console.error(`getQueryParams: document is ${document}. uri is ${uri}`);
+      return null;
+    }
+    const queryParams = this._languageService.getQueryParams(document, cursorOffset);
+    if (queryParams === undefined) {
+      return null;
+    }
+    return queryParams;
+  }
+  getGlobalParams(uri) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      console.error(`getGLobalParams: document is ${document}. uri is ${uri}`);
+      return null;
+    }
+    const globalParams = this._languageService.getGlobalParams(document);
+    if (globalParams === undefined) {
+      return null;
+    }
+    return globalParams;
+  }
+  getReferencedSymbols(uri, cursorOffset) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      console.error(`getReferencedGlobalParams: document is ${document}. uri is ${uri}`);
+      return null;
+    }
+    const referencedParams = this._languageService.getReferencedSymbols(document, cursorOffset);
+    if (referencedParams === undefined) {
+      return null;
+    }
+    return referencedParams;
+  }
+  getReferencedGlobalParams(uri, cursorOffset) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      console.error(`getReferencedGlobalParams: document is ${document}. uri is ${uri}`);
+      return null;
+    }
+    const referencedParams = this._languageService.getReferencedGlobalParams(document, cursorOffset);
+    if (referencedParams === undefined) {
+      return null;
+    }
+    return referencedParams;
+  }
+  getRenderInfo(uri, cursorOffset) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      console.error(`getRenderInfo: document is ${document}. uri is ${uri}`);
+    }
+    return this._languageService.getRenderInfo(document, cursorOffset).then(result => {
+      if (!result) {
+        return null;
+      }
+      return result;
+    });
+  }
+
+  /**
+   * Get command in context and the command range.
+   * This method will basically convert generate microsoft language service interface to monaco interface.
+   * @param uri document URI
+   * @param cursorOffset offset from start of document to cursor
+   */
+  getCommandAndLocationInContext(uri, cursorOffset) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      console.error(`getCommandAndLocationInContext: document is ${document}. uri is ${uri}`);
+      return Promise.resolve(null);
+    }
+    return this._languageService.getCommandAndLocationInContext(document, cursorOffset).then(result => {
+      if (!result) {
+        return null;
+      }
+
+      // convert to monaco object.
+      const {
+        text,
+        location: {
+          range: {
+            start,
+            end
+          }
+        }
+      } = result;
+      const range = new monaco.Range(start.line + 1, start.character + 1, end.line + 1, end.character + 1);
+      return {
+        range,
+        text
+      };
     });
+  }
+  getCommandsInDocument(uri) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      console.error(`getCommandInDocument: document is ${document}. uri is ${uri}`);
+      return null;
+    }
+    return this._languageService.getCommandsInDocument(document);
+  }
+  doComplete(uri, position) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    let completions = this._languageService.doComplete(document, position);
+    return completions;
+  }
+  doValidation(uri, intervals, includeWarnings, includeSuggestions) {
+    const document = this._getTextDocument(uri);
+    const diagnostics = this._languageService.doValidation(document, intervals, includeWarnings, includeSuggestions);
+    return diagnostics;
+  }
+  getResultActions(uri, start, end) {
+    const document = this._getTextDocument(uri);
+    return this._languageService.getResultActions(document, start, end);
+  }
+  doRangeFormat(uri, range) {
+    const document = this._getTextDocument(uri);
+    const formatted = this._languageService.doRangeFormat(document, range);
+    return formatted;
+  }
+  doFolding(uri) {
+    const document = this._getTextDocument(uri);
+    const folding = this._languageService.doFolding(document);
+    return folding;
+  }
+  doDocumentFormat(uri) {
+    const document = this._getTextDocument(uri);
+    const formatted = this._languageService.doDocumentFormat(document);
+    return formatted;
+  }
+  doCurrentCommandFormat(uri, caretPosition) {
+    const document = this._getTextDocument(uri);
+    const formatted = this._languageService.doCurrentCommandFormat(document, caretPosition);
+    return formatted;
+  }
+
+  // Colorize document. if offsets provided, will only colorize commands at these offsets. otherwise - will color the entire document.
+  doColorization(uri, colorizationIntervals) {
+    const document = this._getTextDocument(uri);
+    const colorizationInfo = this._languageService.doColorization(document, colorizationIntervals);
+    return colorizationInfo;
+  }
+  getClientDirective(text) {
+    return this._languageService.getClientDirective(text);
+  }
+  getAdminCommand(text) {
+    return this._languageService.getAdminCommand(text);
+  }
+  findDefinition(uri, position) {
+    const document = this._getTextDocument(uri);
+    const definition = this._languageService.findDefinition(document, position);
+    return definition;
+  }
+  findReferences(uri, position) {
+    let document = this._getTextDocument(uri);
+    const references = this._languageService.findReferences(document, position);
+    return references;
+  }
+  doRename(uri, position, newName) {
+    const document = this._getTextDocument(uri);
+    const workspaceEdit = this._languageService.doRename(document, position, newName);
+    return workspaceEdit;
+  }
+  doHover(uri, position) {
+    let document = this._getTextDocument(uri);
+    let hover = this._languageService.doHover(document, position);
+    return hover;
+  }
+  setParameters(scalarParameters, tabularParameters) {
+    return this._languageService.setParameters(scalarParameters, tabularParameters);
+  }
+  getClusterReferences(uri, cursorOffset) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return Promise.resolve(null);
+    }
+    return this._languageService.getClusterReferences(document, cursorOffset);
+  }
+  getDatabaseReferences(uri, cursorOffset) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return Promise.resolve(null);
+    }
+    return this._languageService.getDatabaseReferences(document, cursorOffset);
+  }
+  _getTextDocument(uri) {
+    let models = this._ctx.getMirrorModels();
+    for (let model of models) {
+      if (model.uri.toString() === uri) {
+        return ls.TextDocument.create(uri, this._languageId, model.version, model.getValue());
+      }
+    }
+    return null;
+  }
+}
+
+self.onmessage = () => {
+  // ignore the first message
+  worker.initialize((ctx, createData) => {
+    return new KustoWorker(ctx, createData);
+  });
 };