@kusto/monaco-kusto 8.1.0 → 8.3.0

package/release/esm/monaco.contribution.js

@@ -1,455 +1,207 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 8.1.0(7000174e976f65eb699b0ee78332810263aba5f0)
- * Released under the MIT license
- * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
- *-----------------------------------------------------------------------------*/
-
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
-import { g as getCslTypeNameFromClrType, a as getCallName, b as getExpression, c as getInputParametersAsCslString, d as getEntityDataTypeFromCslType } from './schema-76f41b43.js';
-export { s as showSchema } from './schema-76f41b43.js';
-
-function getCurrentCommandRange(editor, cursorPosition) {
-  const zeroBasedCursorLineNumber = cursorPosition.lineNumber - 1;
-  const lines = editor.getModel().getLinesContent();
-  let commandOrdinal = 0;
-  const linesWithCommandOrdinal = [];
-  for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
-    let isEmptyLine = lines[lineNumber].trim() === '';
-    if (isEmptyLine) {
-      // increase commandCounter - we'll be starting a new command.
-      linesWithCommandOrdinal.push({
-        commandOrdinal: commandOrdinal++,
-        lineNumber
-      });
-    } else {
-      linesWithCommandOrdinal.push({
-        commandOrdinal: commandOrdinal,
-        lineNumber
-      });
-    }
-
-    // No need to keep scanning if we're past our line and we've seen an empty line.
-    if (lineNumber > zeroBasedCursorLineNumber && commandOrdinal > linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal) {
-      break;
+import KustoCommandHighlighter from './commandHighlighter';
+import KustoCommandFormatter from './commandFormatter';
+import { extend, getCurrentCommandRange } from './extendedEditor';
+import { getCslTypeNameFromClrType, getCallName, getExpression, getInputParametersAsCslString, getEntityDataTypeFromCslType, } from './languageService/schema';
+export * from './languageService/schema';
+export * from './languageService/renderInfo';
+export * from './languageService/settings';
+export * from './types';
+export { getCurrentCommandRange } from './extendedEditor';
+// --- Kusto configuration and defaults ---------
+var LanguageServiceDefaultsImpl = /** @class */ (function () {
+    function LanguageServiceDefaultsImpl(languageSettings) {
+        this._onDidChange = new monaco.Emitter();
+        this.setLanguageSettings(languageSettings);
+        // default to never kill worker when idle.
+        // reason: when killing worker - schema gets lost. We transmit the schema back to main process when killing
+        // the worker, but in some extreme cases web worker runs out of memory while stringifying the schema.
+        // This stems from the fact that web workers have much more limited memory that the main process.
+        // An alternative solution (not currently implemented) is to just save the schema in the main process whenever calling
+        // setSchema. That way we don't need to stringify the schema on the worker side when killing the web worker.
+        this._workerMaxIdleTime = 0;
     }
-  }
-  const currentCommandOrdinal = linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal;
-  const currentCommandLines = linesWithCommandOrdinal.filter(line => line.commandOrdinal === currentCommandOrdinal);
-  const currentCommandStartLine = currentCommandLines[0].lineNumber + 1;
-  const currentCommandEndLine = currentCommandLines[currentCommandLines.length - 1].lineNumber + 1;
-
-  // End-column of 1 means no characters will be highlighted - since columns are 1-based in monaco apis.
-  // Start-column of 1 and End column of 2 means 1st character is selected.
-  // Thus if a line has n column and we need to provide n+1 so that the entire line will be highlighted.
-  const commandEndColumn = lines[currentCommandEndLine - 1].length + 1;
-  return new monaco.Range(currentCommandStartLine, 1, currentCommandEndLine, commandEndColumn);
-}
-
-/**
- * Extending ICode editor to contain additional kusto-specific methods.
- * note that the extend method needs to be called at least once to take affect, otherwise this here code is useless.
- */
-function extend(editor) {
-  const proto = Object.getPrototypeOf(editor);
-  proto.getCurrentCommandRange = function (cursorPosition) {
-    getCurrentCommandRange(this, cursorPosition);
-  };
-}
-
-/**
- * Highlights the command that surround cursor location
- */
-class KustoCommandHighlighter {
-  static ID = 'editor.contrib.kustoCommandHighlighter';
-  static CURRENT_COMMAND_HIGHLIGHT = {
-    className: 'selectionHighlight'
-  };
-  disposables = [];
-  decorations = [];
-
-  /**
-   * Register to cursor movement and selection events.
-   * @param editor monaco editor instance
-   */
-  constructor(editor) {
-    this.editor = editor;
-    // Note that selection update is triggered not only for selection changes, but also just when no text selection is occurring and cursor just moves around.
-    // This case is counted as a 0-length selection starting and ending on the cursor position.
-    this.editor.onDidChangeCursorSelection(changeEvent => {
-      if (this.editor.getModel().getLanguageId() !== 'kusto') {
-        return;
-      }
-      this.highlightCommandUnderCursor(changeEvent);
+    Object.defineProperty(LanguageServiceDefaultsImpl.prototype, "onDidChange", {
+        get: function () {
+            return this._onDidChange.event;
+        },
+        enumerable: false,
+        configurable: true
     });
-  }
-  getId() {
-    return KustoCommandHighlighter.ID;
-  }
-  dispose() {
-    this.disposables.forEach(d => d.dispose());
-  }
-  highlightCommandUnderCursor(changeEvent) {
-    // Looks like the user selected a bunch of text. we don't want to highlight the entire command in this case - since highlighting
-    // the text is more helpful.
-    if (!changeEvent.selection.isEmpty()) {
-      this.decorations = this.editor.deltaDecorations(this.decorations, []);
-      return;
-    }
-    const commandRange = getCurrentCommandRange(this.editor, changeEvent.selection.getStartPosition());
-    const decorations = [{
-      range: commandRange,
-      options: KustoCommandHighlighter.CURRENT_COMMAND_HIGHLIGHT
-    }];
-    this.decorations = this.editor.deltaDecorations(this.decorations, decorations);
-  }
-}
-
-class KustoCommandFormatter {
-  actionAdded = false;
-  constructor(editor) {
-    this.editor = editor;
-    // selection also represents no selection - for example the event gets triggered when moving cursor from point
-    // a to point b. in the case start position will equal end position.
-    editor.onDidChangeCursorSelection(changeEvent => {
-      if (this.editor.getModel().getLanguageId() !== 'kusto') {
-        return;
-      }
-      // Theoretically you would expect this code to run only once in onDidCreateEditor.
-      // Turns out that onDidCreateEditor is fired before the IStandaloneEditor is completely created (it is emitted by
-      // the super ctor before the child ctor was able to fully run).
-      // Thus we don't have  a key binding provided yet when onDidCreateEditor is run, which is essential to call addAction.
-      // By adding the action here in onDidChangeCursorSelection we're making sure that the editor has a key binding provider,
-      // and we just need to make sure that this happens only once.
-      if (!this.actionAdded) {
-        editor.addAction({
-          id: 'editor.action.kusto.formatCurrentCommand',
-          label: 'Format Command Under Cursor',
-          keybindings: [monaco.KeyMod.chord(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyK, monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyF)],
-          run: ed => {
-            editor.trigger('KustoCommandFormatter', 'editor.action.formatSelection', null);
-          },
-          contextMenuGroupId: '1_modification'
-        });
-        this.actionAdded = true;
-      }
+    Object.defineProperty(LanguageServiceDefaultsImpl.prototype, "languageSettings", {
+        get: function () {
+            return this._languageSettings;
+        },
+        enumerable: false,
+        configurable: true
     });
-  }
-}
-
-// --- Kusto configuration and defaults ---------
-
-class LanguageServiceDefaultsImpl {
-  _onDidChange = new monaco.Emitter();
-
-  // in milliseconds. For example - this is 2 minutes 2 * 60 * 1000
-
-  constructor(languageSettings) {
-    this.setLanguageSettings(languageSettings);
-    // default to never kill worker when idle.
-    // reason: when killing worker - schema gets lost. We transmit the schema back to main process when killing
-    // the worker, but in some extreme cases web worker runs out of memory while stringifying the schema.
-    // This stems from the fact that web workers have much more limited memory that the main process.
-    // An alternative solution (not currently implemented) is to just save the schema in the main process whenever calling
-    // setSchema. That way we don't need to stringify the schema on the worker side when killing the web worker.
-    this._workerMaxIdleTime = 0;
-  }
-  get onDidChange() {
-    return this._onDidChange.event;
-  }
-  get languageSettings() {
-    return this._languageSettings;
-  }
-  setLanguageSettings(options) {
-    this._languageSettings = options || Object.create(null);
-    this._onDidChange.fire(this);
-  }
-  setMaximumWorkerIdleTime(value) {
-    // doesn't fire an event since no
-    // worker restart is required here
-    this._workerMaxIdleTime = value;
-  }
-  getWorkerMaxIdleTime() {
-    return this._workerMaxIdleTime;
-  }
-}
-const defaultLanguageSettings = {
-  includeControlCommands: true,
-  newlineAfterPipe: true,
-  openSuggestionDialogAfterPreviousSuggestionAccepted: true,
-  useIntellisenseV2: true,
-  useSemanticColorization: true,
-  useTokenColorization: false,
-  enableHover: true,
-  formatter: {
-    indentationSize: 4,
-    pipeOperatorStyle: 'Smart'
-  },
-  syntaxErrorAsMarkDown: {
-    enableSyntaxErrorAsMarkDown: false
-  },
-  enableQueryWarnings: false,
-  enableQuerySuggestions: false,
-  disabledDiagnosticCodes: [],
-  quickFixCodeActions: ['Change to', 'FixAll'],
-  enableQuickFixes: false
+    LanguageServiceDefaultsImpl.prototype.setLanguageSettings = function (options) {
+        this._languageSettings = options || Object.create(null);
+        this._onDidChange.fire(this);
+    };
+    LanguageServiceDefaultsImpl.prototype.setMaximumWorkerIdleTime = function (value) {
+        // doesn't fire an event since no
+        // worker restart is required here
+        this._workerMaxIdleTime = value;
+    };
+    LanguageServiceDefaultsImpl.prototype.getWorkerMaxIdleTime = function () {
+        return this._workerMaxIdleTime;
+    };
+    return LanguageServiceDefaultsImpl;
+}());
+var defaultLanguageSettings = {
+    includeControlCommands: true,
+    newlineAfterPipe: true,
+    openSuggestionDialogAfterPreviousSuggestionAccepted: true,
+    useIntellisenseV2: true,
+    useSemanticColorization: true,
+    useTokenColorization: false,
+    enableHover: true,
+    formatter: {
+        indentationSize: 4,
+        pipeOperatorStyle: 'Smart',
+    },
+    syntaxErrorAsMarkDown: {
+        enableSyntaxErrorAsMarkDown: false,
+    },
+    enableQueryWarnings: false,
+    enableQuerySuggestions: false,
+    disabledDiagnosticCodes: [],
+    quickFixCodeActions: ['Change to', 'FixAll'],
+    enableQuickFixes: false,
 };
-function getKustoWorker() {
-  return new Promise((resolve, reject) => {
-    withMode(mode => {
-      mode.getKustoWorker().then(resolve, reject);
+export function getKustoWorker() {
+    return new Promise(function (resolve, reject) {
+        withMode(function (mode) {
+            mode.getKustoWorker().then(resolve, reject);
+        });
     });
-  });
 }
 function withMode(callback) {
-  import('./kustoMode.js').then(callback);
+    import('./kustoMode').then(callback);
 }
-const kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
-const themeNames = {
-  light: 'kusto-light',
-  dark: 'kusto-dark',
-  dark2: 'kusto-dark2'
+export var kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
+export var themeNames = {
+    light: 'kusto-light',
+    dark: 'kusto-dark',
+    dark2: 'kusto-dark2',
 };
-monaco.languages.onLanguage('kusto', () => {
-  withMode(mode => mode.setupMode(kustoDefaults, monaco));
+monaco.languages.onLanguage('kusto', function () {
+    withMode(function (mode) { return mode.setupMode(kustoDefaults, monaco); });
 });
 monaco.languages.register({
-  id: 'kusto',
-  extensions: ['.csl', '.kql']
+    id: 'kusto',
+    extensions: ['.csl', '.kql'],
 });
 monaco.editor.defineTheme(themeNames.light, {
-  base: 'vs',
-  inherit: true,
-  rules: [{
-    token: 'comment',
-    foreground: '008000'
-  },
-  // CommentToken Green
-  {
-    token: 'variable.predefined',
-    foreground: '800080'
-  },
-  // CalculatedColumnToken Purple
-  {
-    token: 'function',
-    foreground: '0000FF'
-  },
-  // FunctionNameToken Blue
-  {
-    token: 'operator.sql',
-    foreground: 'CC3700'
-  },
-  // _WAS_ OperatorToken OrangeRed, but wasn't accessible.
-  {
-    token: 'string',
-    foreground: 'B22222'
-  },
-  // StringLiteralToken Firebrick
-  {
-    token: 'operator.scss',
-    foreground: '0000FF'
-  },
-  // SubOperatorToken Blue
-  {
-    token: 'variable',
-    foreground: 'C71585'
-  },
-  // TableColumnToken MediumVioletRed
-  {
-    token: 'variable.parameter',
-    foreground: '9932CC'
-  },
-  // TableToken DarkOrchid
-  {
-    token: '',
-    foreground: '000000'
-  },
-  // UnknownToken, PlainTextToken  Black
-  {
-    token: 'type',
-    foreground: '0000FF'
-  },
-  // DataTypeToken Blue
-  {
-    token: 'tag',
-    foreground: '0000FF'
-  },
-  // ControlCommandToken Blue
-  {
-    token: 'annotation',
-    foreground: '2B91AF'
-  },
-  // QueryParametersToken FF2B91AF
-  {
-    token: 'keyword',
-    foreground: '0000FF'
-  },
-  // CslCommandToken, PluginToken Blue
-  {
-    token: 'number',
-    foreground: '191970'
-  },
-  // LetVariablesToken MidnightBlue
-  {
-    token: 'annotation',
-    foreground: '9400D3'
-  },
-  // ClientDirectiveToken DarkViolet
-  {
-    token: 'invalid',
-    background: 'cd3131'
-  }],
-  colors: {}
+    base: 'vs',
+    inherit: true,
+    rules: [
+        { token: 'comment', foreground: '008000' },
+        { token: 'variable.predefined', foreground: '800080' },
+        { token: 'function', foreground: '0000FF' },
+        { token: 'operator.sql', foreground: 'CC3700' },
+        { token: 'string', foreground: 'B22222' },
+        { token: 'operator.scss', foreground: '0000FF' },
+        { token: 'variable', foreground: 'C71585' },
+        { token: 'variable.parameter', foreground: '9932CC' },
+        { token: '', foreground: '000000' },
+        { token: 'type', foreground: '0000FF' },
+        { token: 'tag', foreground: '0000FF' },
+        { token: 'annotation', foreground: '2B91AF' },
+        { token: 'keyword', foreground: '0000FF' },
+        { token: 'number', foreground: '191970' },
+        { token: 'annotation', foreground: '9400D3' },
+        { token: 'invalid', background: 'cd3131' },
+    ],
+    colors: {},
 });
 monaco.editor.defineTheme(themeNames.dark, {
-  base: 'vs-dark',
-  inherit: true,
-  rules: [{
-    token: 'comment',
-    foreground: '608B4E'
-  },
-  // CommentToken Green
-  {
-    token: 'variable.predefined',
-    foreground: '4ec9b0'
-  },
-  // CalculatedColumnToken Purple
-  {
-    token: 'function',
-    foreground: 'dcdcaa'
-  },
-  // FunctionNameToken Blue
-  {
-    token: 'operator.sql',
-    foreground: '9cdcfe'
-  },
-  // OperatorToken OrangeRed
-  {
-    token: 'string',
-    foreground: 'ce9178'
-  },
-  // StringLiteralToken Firebrick
-  {
-    token: 'operator.scss',
-    foreground: '569cd6'
-  },
-  // SubOperatorToken Blue
-  {
-    token: 'variable',
-    foreground: '4ec9b0'
-  },
-  // TableColumnToken MediumVioletRed
-  {
-    token: 'variable.parameter',
-    foreground: 'c586c0'
-  },
-  // TableToken DarkOrchid
-  {
-    token: '',
-    foreground: 'd4d4d4'
-  },
-  // UnknownToken, PlainTextToken  Black
-  {
-    token: 'type',
-    foreground: '569cd6'
-  },
-  // DataTypeToken Blue
-  {
-    token: 'tag',
-    foreground: '569cd6'
-  },
-  // ControlCommandToken Blue
-  {
-    token: 'annotation',
-    foreground: '9cdcfe'
-  },
-  // QueryParametersToken FF2B91AF
-  {
-    token: 'keyword',
-    foreground: '569cd6'
-  },
-  // CslCommandToken, PluginToken Blue
-  {
-    token: 'number',
-    foreground: 'd7ba7d'
-  },
-  // LetVariablesToken MidnightBlue
-  {
-    token: 'annotation',
-    foreground: 'b5cea8'
-  },
-  // ClientDirectiveToken DarkViolet
-  {
-    token: 'invalid',
-    background: 'cd3131'
-  }],
-  colors: {
+    base: 'vs-dark',
+    inherit: true,
+    rules: [
+        { token: 'comment', foreground: '608B4E' },
+        { token: 'variable.predefined', foreground: '4ec9b0' },
+        { token: 'function', foreground: 'dcdcaa' },
+        { token: 'operator.sql', foreground: '9cdcfe' },
+        { token: 'string', foreground: 'ce9178' },
+        { token: 'operator.scss', foreground: '569cd6' },
+        { token: 'variable', foreground: '4ec9b0' },
+        { token: 'variable.parameter', foreground: 'c586c0' },
+        { token: '', foreground: 'd4d4d4' },
+        { token: 'type', foreground: '569cd6' },
+        { token: 'tag', foreground: '569cd6' },
+        { token: 'annotation', foreground: '9cdcfe' },
+        { token: 'keyword', foreground: '569cd6' },
+        { token: 'number', foreground: 'd7ba7d' },
+        { token: 'annotation', foreground: 'b5cea8' },
+        { token: 'invalid', background: 'cd3131' },
+    ],
+    colors: {
     // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
-  }
+    },
 });
 monaco.editor.defineTheme(themeNames.dark2, {
-  base: 'vs-dark',
-  inherit: true,
-  rules: [],
-  colors: {
-    // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
-    'editor.background': '#1B1A19',
-    // gray 200
-    'editorSuggestWidget.selectedBackground': '#004E8C'
-  }
+    base: 'vs-dark',
+    inherit: true,
+    rules: [],
+    colors: {
+        // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
+        'editor.background': '#1B1A19',
+        'editorSuggestWidget.selectedBackground': '#004E8C',
+    },
 });
-
 // Initialize kusto specific language features that don't currently have a natural way to extend using existing apis.
 // Most other language features are initialized in kustoMode.ts
-monaco.editor.onDidCreateEditor(editor => {
-  if (window.MonacoEnvironment?.globalAPI) {
-    // hook up extension methods to editor.
-    extend(editor);
-  }
-
-  // TODO: asked if there's a cleaner way to register an editor contribution. looks like monaco has an internal contribution registrar but it's no exposed in the API.
-  // https://stackoverflow.com/questions/46700245/how-to-add-an-ieditorcontribution-to-monaco-editor
-  new KustoCommandHighlighter(editor);
-  if (isStandaloneCodeEditor(editor)) {
-    new KustoCommandFormatter(editor);
-  }
-  triggerSuggestDialogWhenCompletionItemSelected(editor);
+monaco.editor.onDidCreateEditor(function (editor) {
+    var _a;
+    if ((_a = window.MonacoEnvironment) === null || _a === void 0 ? void 0 : _a.globalAPI) {
+        // hook up extension methods to editor.
+        extend(editor);
+    }
+    // TODO: asked if there's a cleaner way to register an editor contribution. looks like monaco has an internal contribution registrar but it's no exposed in the API.
+    // https://stackoverflow.com/questions/46700245/how-to-add-an-ieditorcontribution-to-monaco-editor
+    new KustoCommandHighlighter(editor);
+    if (isStandaloneCodeEditor(editor)) {
+        new KustoCommandFormatter(editor);
+    }
+    triggerSuggestDialogWhenCompletionItemSelected(editor);
 });
 function triggerSuggestDialogWhenCompletionItemSelected(editor) {
-  editor.onDidChangeCursorSelection(event => {
-    // checking the condition inside the event makes sure we will stay up to date when kusto configuration changes at runtime.
-    if (kustoDefaults && kustoDefaults.languageSettings && kustoDefaults.languageSettings.openSuggestionDialogAfterPreviousSuggestionAccepted) {
-      var didAcceptSuggestion = event.source === 'snippet' && event.reason === monaco.editor.CursorChangeReason.NotSet;
-      // If the word at the current position is not null - meaning we did not add a space after completion.
-      // In this case we don't want to activate the eager mode, since it will display the current selected word..
-      if (!didAcceptSuggestion || editor.getModel().getWordAtPosition(event.selection.getPosition()) !== null) {
-        return;
-      }
-      event.selection;
-      // OK so now we in a situation where we know a suggestion was selected and we want to trigger another one.
-      // the only problem is that the suggestion widget itself listens to this same event in order to know it needs to close.
-      // The only problem is that we're ahead in line, so we're triggering a suggest operation that will be shut down once
-      // the next callback is called. This is why we're waiting here - to let all the callbacks run synchronously and be
-      // the 'last' subscriber to run. Granted this is hacky, but until monaco provides a specific event for suggestions,
-      // this is the best we have.
-      setTimeout(() => editor.trigger('monaco-kusto', 'editor.action.triggerSuggest', {}), 10);
-    }
-  });
+    editor.onDidChangeCursorSelection(function (event) {
+        // checking the condition inside the event makes sure we will stay up to date when kusto configuration changes at runtime.
+        if (kustoDefaults &&
+            kustoDefaults.languageSettings &&
+            kustoDefaults.languageSettings.openSuggestionDialogAfterPreviousSuggestionAccepted) {
+            var didAcceptSuggestion = event.source === 'snippet' && event.reason === monaco.editor.CursorChangeReason.NotSet;
+            // If the word at the current position is not null - meaning we did not add a space after completion.
+            // In this case we don't want to activate the eager mode, since it will display the current selected word..
+            if (!didAcceptSuggestion || editor.getModel().getWordAtPosition(event.selection.getPosition()) !== null) {
+                return;
+            }
+            event.selection;
+            // OK so now we in a situation where we know a suggestion was selected and we want to trigger another one.
+            // the only problem is that the suggestion widget itself listens to this same event in order to know it needs to close.
+            // The only problem is that we're ahead in line, so we're triggering a suggest operation that will be shut down once
+            // the next callback is called. This is why we're waiting here - to let all the callbacks run synchronously and be
+            // the 'last' subscriber to run. Granted this is hacky, but until monaco provides a specific event for suggestions,
+            // this is the best we have.
+            setTimeout(function () { return editor.trigger('monaco-kusto', 'editor.action.triggerSuggest', {}); }, 10);
+        }
+    });
 }
 function isStandaloneCodeEditor(editor) {
-  return editor.addAction !== undefined;
+    return editor.addAction !== undefined;
 }
-const globalApi = {
-  getCslTypeNameFromClrType,
-  getCallName,
-  getExpression,
-  getInputParametersAsCslString,
-  getEntityDataTypeFromCslType,
-  kustoDefaults,
-  getKustoWorker,
-  getCurrentCommandRange,
-  themeNames
+var globalApi = {
+    getCslTypeNameFromClrType: getCslTypeNameFromClrType,
+    getCallName: getCallName,
+    getExpression: getExpression,
+    getInputParametersAsCslString: getInputParametersAsCslString,
+    getEntityDataTypeFromCslType: getEntityDataTypeFromCslType,
+    kustoDefaults: kustoDefaults,
+    getKustoWorker: getKustoWorker,
+    getCurrentCommandRange: getCurrentCommandRange,
+    themeNames: themeNames,
 };
 monaco.languages.kusto = globalApi;
-
-export { getCallName, getCslTypeNameFromClrType, getCurrentCommandRange, getEntityDataTypeFromCslType, getExpression, getInputParametersAsCslString, getKustoWorker, kustoDefaults, themeNames };

package/release/esm/{schema-76f41b43.js → schema-ee621489.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 8.1.0(7000174e976f65eb699b0ee78332810263aba5f0)
+ * monaco-kusto version: 8.3.0(b1e36a8cfc8e35c070743997d6e7770ea8081289)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -80,6 +80,5 @@ const getInputParameterAsCslString = inputParameter => {
  * .show schema as json
  */
 let showSchema;
-(function (_showSchema) {})(showSchema || (showSchema = {}));
 
 export { getCallName as a, getExpression as b, getInputParametersAsCslString as c, getEntityDataTypeFromCslType as d, getCslTypeNameFromClrType as g, showSchema as s };

package/release/esm/types.js

@@ -0,0 +1 @@
+export {};