monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/standaloneLanguages.js

@@ -0,0 +1,621 @@
+import { Color } from '../../../base/common/color.js';
+import { Range } from '../../common/core/range.js';
+import { SelectedSuggestionInfo, FoldingRangeKind, TokenizationRegistry, LazyTokenizationSupport, EncodedTokenizationResult, Token, TokenizationResult } from '../../common/languages.js';
+import { ILanguageService } from '../../common/languages/language.js';
+import { ILanguageConfigurationService } from '../../common/languages/languageConfigurationRegistry.js';
+import { ModesRegistry } from '../../common/languages/modesRegistry.js';
+import { ILanguageFeaturesService } from '../../common/services/languageFeatures.js';
+import { InlineCompletionHintStyle, InlineCompletionEndOfLifeReasonKind, HoverVerbosityAction, PartialAcceptTriggerKind, NewSymbolNameTriggerKind, NewSymbolNameTag, CodeActionTriggerType, InlineCompletionTriggerKind, InlayHintKind, SignatureHelpTriggerKind, CompletionTriggerKind, IndentAction, SymbolTag, SymbolKind, CompletionItemInsertTextRule, CompletionItemTag, CompletionItemKind, DocumentHighlightKind } from '../../common/standalone/standaloneEnums.js';
+import { StandaloneServices } from './standaloneServices.js';
+import { compile } from '../common/monarch/monarchCompile.js';
+import { MonarchTokenizer } from '../common/monarch/monarchLexer.js';
+import { IStandaloneThemeService } from '../common/standaloneTheme.js';
+import { IConfigurationService } from '../../../platform/configuration/common/configuration.js';
+import { IMarkerService } from '../../../platform/markers/common/markers.js';
+import { EditDeltaInfo } from '../../common/textModelEditSource.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Register information about a new language.
+ */
+function register(language) {
+    // Intentionally using the `ModesRegistry` here to avoid
+    // instantiating services too quickly in the standalone editor.
+    ModesRegistry.registerLanguage(language);
+}
+/**
+ * Get the information of all the registered languages.
+ */
+function getLanguages() {
+    let result = [];
+    result = result.concat(ModesRegistry.getLanguages());
+    return result;
+}
+function getEncodedLanguageId(languageId) {
+    const languageService = StandaloneServices.get(ILanguageService);
+    return languageService.languageIdCodec.encodeLanguageId(languageId);
+}
+/**
+ * An event emitted when a language is associated for the first time with a text model.
+ * @event
+ */
+function onLanguage(languageId, callback) {
+    return StandaloneServices.withServices(() => {
+        const languageService = StandaloneServices.get(ILanguageService);
+        const disposable = languageService.onDidRequestRichLanguageFeatures((encounteredLanguageId) => {
+            if (encounteredLanguageId === languageId) {
+                // stop listening
+                disposable.dispose();
+                // invoke actual listener
+                callback();
+            }
+        });
+        return disposable;
+    });
+}
+/**
+ * An event emitted when a language is associated for the first time with a text model or
+ * when a language is encountered during the tokenization of another language.
+ * @event
+ */
+function onLanguageEncountered(languageId, callback) {
+    return StandaloneServices.withServices(() => {
+        const languageService = StandaloneServices.get(ILanguageService);
+        const disposable = languageService.onDidRequestBasicLanguageFeatures((encounteredLanguageId) => {
+            if (encounteredLanguageId === languageId) {
+                // stop listening
+                disposable.dispose();
+                // invoke actual listener
+                callback();
+            }
+        });
+        return disposable;
+    });
+}
+/**
+ * Set the editing configuration for a language.
+ */
+function setLanguageConfiguration(languageId, configuration) {
+    const languageService = StandaloneServices.get(ILanguageService);
+    if (!languageService.isRegisteredLanguageId(languageId)) {
+        throw new Error(`Cannot set configuration for unknown language ${languageId}`);
+    }
+    const languageConfigurationService = StandaloneServices.get(ILanguageConfigurationService);
+    return languageConfigurationService.register(languageId, configuration, 100);
+}
+/**
+ * @internal
+ */
+class EncodedTokenizationSupportAdapter {
+    constructor(languageId, actual) {
+        this._languageId = languageId;
+        this._actual = actual;
+    }
+    dispose() {
+        // NOOP
+    }
+    getInitialState() {
+        return this._actual.getInitialState();
+    }
+    tokenize(line, hasEOL, state) {
+        if (typeof this._actual.tokenize === 'function') {
+            return TokenizationSupportAdapter.adaptTokenize(this._languageId, this._actual, line, state);
+        }
+        throw new Error('Not supported!');
+    }
+    tokenizeEncoded(line, hasEOL, state) {
+        const result = this._actual.tokenizeEncoded(line, state);
+        return new EncodedTokenizationResult(result.tokens, result.endState);
+    }
+}
+/**
+ * @internal
+ */
+class TokenizationSupportAdapter {
+    constructor(_languageId, _actual, _languageService, _standaloneThemeService) {
+        this._languageId = _languageId;
+        this._actual = _actual;
+        this._languageService = _languageService;
+        this._standaloneThemeService = _standaloneThemeService;
+    }
+    dispose() {
+        // NOOP
+    }
+    getInitialState() {
+        return this._actual.getInitialState();
+    }
+    static _toClassicTokens(tokens, language) {
+        const result = [];
+        let previousStartIndex = 0;
+        for (let i = 0, len = tokens.length; i < len; i++) {
+            const t = tokens[i];
+            let startIndex = t.startIndex;
+            // Prevent issues stemming from a buggy external tokenizer.
+            if (i === 0) {
+                // Force first token to start at first index!
+                startIndex = 0;
+            }
+            else if (startIndex < previousStartIndex) {
+                // Force tokens to be after one another!
+                startIndex = previousStartIndex;
+            }
+            result[i] = new Token(startIndex, t.scopes, language);
+            previousStartIndex = startIndex;
+        }
+        return result;
+    }
+    static adaptTokenize(language, actual, line, state) {
+        const actualResult = actual.tokenize(line, state);
+        const tokens = TokenizationSupportAdapter._toClassicTokens(actualResult.tokens, language);
+        let endState;
+        // try to save an object if possible
+        if (actualResult.endState.equals(state)) {
+            endState = state;
+        }
+        else {
+            endState = actualResult.endState;
+        }
+        return new TokenizationResult(tokens, endState);
+    }
+    tokenize(line, hasEOL, state) {
+        return TokenizationSupportAdapter.adaptTokenize(this._languageId, this._actual, line, state);
+    }
+    _toBinaryTokens(languageIdCodec, tokens) {
+        const languageId = languageIdCodec.encodeLanguageId(this._languageId);
+        const tokenTheme = this._standaloneThemeService.getColorTheme().tokenTheme;
+        const result = [];
+        let resultLen = 0;
+        let previousStartIndex = 0;
+        for (let i = 0, len = tokens.length; i < len; i++) {
+            const t = tokens[i];
+            const metadata = tokenTheme.match(languageId, t.scopes) | 1024 /* MetadataConsts.BALANCED_BRACKETS_MASK */;
+            if (resultLen > 0 && result[resultLen - 1] === metadata) {
+                // same metadata
+                continue;
+            }
+            let startIndex = t.startIndex;
+            // Prevent issues stemming from a buggy external tokenizer.
+            if (i === 0) {
+                // Force first token to start at first index!
+                startIndex = 0;
+            }
+            else if (startIndex < previousStartIndex) {
+                // Force tokens to be after one another!
+                startIndex = previousStartIndex;
+            }
+            result[resultLen++] = startIndex;
+            result[resultLen++] = metadata;
+            previousStartIndex = startIndex;
+        }
+        const actualResult = new Uint32Array(resultLen);
+        for (let i = 0; i < resultLen; i++) {
+            actualResult[i] = result[i];
+        }
+        return actualResult;
+    }
+    tokenizeEncoded(line, hasEOL, state) {
+        const actualResult = this._actual.tokenize(line, state);
+        const tokens = this._toBinaryTokens(this._languageService.languageIdCodec, actualResult.tokens);
+        let endState;
+        // try to save an object if possible
+        if (actualResult.endState.equals(state)) {
+            endState = state;
+        }
+        else {
+            endState = actualResult.endState;
+        }
+        return new EncodedTokenizationResult(tokens, endState);
+    }
+}
+function isATokensProvider(provider) {
+    return (typeof provider.getInitialState === 'function');
+}
+function isEncodedTokensProvider(provider) {
+    return 'tokenizeEncoded' in provider;
+}
+function isThenable(obj) {
+    return obj && typeof obj.then === 'function';
+}
+/**
+ * Change the color map that is used for token colors.
+ * Supported formats (hex): #RRGGBB, $RRGGBBAA, #RGB, #RGBA
+ */
+function setColorMap(colorMap) {
+    const standaloneThemeService = StandaloneServices.get(IStandaloneThemeService);
+    if (colorMap) {
+        const result = [null];
+        for (let i = 1, len = colorMap.length; i < len; i++) {
+            result[i] = Color.fromHex(colorMap[i]);
+        }
+        standaloneThemeService.setColorMapOverride(result);
+    }
+    else {
+        standaloneThemeService.setColorMapOverride(null);
+    }
+}
+/**
+ * @internal
+ */
+function createTokenizationSupportAdapter(languageId, provider) {
+    if (isEncodedTokensProvider(provider)) {
+        return new EncodedTokenizationSupportAdapter(languageId, provider);
+    }
+    else {
+        return new TokenizationSupportAdapter(languageId, provider, StandaloneServices.get(ILanguageService), StandaloneServices.get(IStandaloneThemeService));
+    }
+}
+/**
+ * Register a tokens provider factory for a language. This tokenizer will be exclusive with a tokenizer
+ * set using `setTokensProvider` or one created using `setMonarchTokensProvider`, but will work together
+ * with a tokens provider set using `registerDocumentSemanticTokensProvider` or `registerDocumentRangeSemanticTokensProvider`.
+ */
+function registerTokensProviderFactory(languageId, factory) {
+    const adaptedFactory = new LazyTokenizationSupport(async () => {
+        const result = await Promise.resolve(factory.create());
+        if (!result) {
+            return null;
+        }
+        if (isATokensProvider(result)) {
+            return createTokenizationSupportAdapter(languageId, result);
+        }
+        return new MonarchTokenizer(StandaloneServices.get(ILanguageService), StandaloneServices.get(IStandaloneThemeService), languageId, compile(languageId, result), StandaloneServices.get(IConfigurationService));
+    });
+    return TokenizationRegistry.registerFactory(languageId, adaptedFactory);
+}
+/**
+ * Set the tokens provider for a language (manual implementation). This tokenizer will be exclusive
+ * with a tokenizer created using `setMonarchTokensProvider`, or with `registerTokensProviderFactory`,
+ * but will work together with a tokens provider set using `registerDocumentSemanticTokensProvider`
+ * or `registerDocumentRangeSemanticTokensProvider`.
+ */
+function setTokensProvider(languageId, provider) {
+    const languageService = StandaloneServices.get(ILanguageService);
+    if (!languageService.isRegisteredLanguageId(languageId)) {
+        throw new Error(`Cannot set tokens provider for unknown language ${languageId}`);
+    }
+    if (isThenable(provider)) {
+        return registerTokensProviderFactory(languageId, { create: () => provider });
+    }
+    return TokenizationRegistry.register(languageId, createTokenizationSupportAdapter(languageId, provider));
+}
+/**
+ * Set the tokens provider for a language (monarch implementation). This tokenizer will be exclusive
+ * with a tokenizer set using `setTokensProvider`, or with `registerTokensProviderFactory`, but will
+ * work together with a tokens provider set using `registerDocumentSemanticTokensProvider` or
+ * `registerDocumentRangeSemanticTokensProvider`.
+ */
+function setMonarchTokensProvider(languageId, languageDef) {
+    const create = (languageDef) => {
+        return new MonarchTokenizer(StandaloneServices.get(ILanguageService), StandaloneServices.get(IStandaloneThemeService), languageId, compile(languageId, languageDef), StandaloneServices.get(IConfigurationService));
+    };
+    if (isThenable(languageDef)) {
+        return registerTokensProviderFactory(languageId, { create: () => languageDef });
+    }
+    return TokenizationRegistry.register(languageId, create(languageDef));
+}
+/**
+ * Register a reference provider (used by e.g. reference search).
+ */
+function registerReferenceProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.referenceProvider.register(languageSelector, provider);
+}
+/**
+ * Register a rename provider (used by e.g. rename symbol).
+ */
+function registerRenameProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.renameProvider.register(languageSelector, provider);
+}
+/**
+ * Register a new symbol-name provider (e.g., when a symbol is being renamed, show new possible symbol-names)
+ */
+function registerNewSymbolNameProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.newSymbolNamesProvider.register(languageSelector, provider);
+}
+/**
+ * Register a signature help provider (used by e.g. parameter hints).
+ */
+function registerSignatureHelpProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.signatureHelpProvider.register(languageSelector, provider);
+}
+/**
+ * Register a hover provider (used by e.g. editor hover).
+ */
+function registerHoverProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.hoverProvider.register(languageSelector, {
+        provideHover: async (model, position, token, context) => {
+            const word = model.getWordAtPosition(position);
+            return Promise.resolve(provider.provideHover(model, position, token, context)).then((value) => {
+                if (!value) {
+                    return undefined;
+                }
+                if (!value.range && word) {
+                    value.range = new Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn);
+                }
+                if (!value.range) {
+                    value.range = new Range(position.lineNumber, position.column, position.lineNumber, position.column);
+                }
+                return value;
+            });
+        }
+    });
+}
+/**
+ * Register a document symbol provider (used by e.g. outline).
+ */
+function registerDocumentSymbolProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentSymbolProvider.register(languageSelector, provider);
+}
+/**
+ * Register a document highlight provider (used by e.g. highlight occurrences).
+ */
+function registerDocumentHighlightProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentHighlightProvider.register(languageSelector, provider);
+}
+/**
+ * Register an linked editing range provider.
+ */
+function registerLinkedEditingRangeProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.linkedEditingRangeProvider.register(languageSelector, provider);
+}
+/**
+ * Register a definition provider (used by e.g. go to definition).
+ */
+function registerDefinitionProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.definitionProvider.register(languageSelector, provider);
+}
+/**
+ * Register a implementation provider (used by e.g. go to implementation).
+ */
+function registerImplementationProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.implementationProvider.register(languageSelector, provider);
+}
+/**
+ * Register a type definition provider (used by e.g. go to type definition).
+ */
+function registerTypeDefinitionProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.typeDefinitionProvider.register(languageSelector, provider);
+}
+/**
+ * Register a code lens provider (used by e.g. inline code lenses).
+ */
+function registerCodeLensProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.codeLensProvider.register(languageSelector, provider);
+}
+/**
+ * Register a code action provider (used by e.g. quick fix).
+ */
+function registerCodeActionProvider(languageSelector, provider, metadata) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.codeActionProvider.register(languageSelector, {
+        providedCodeActionKinds: metadata?.providedCodeActionKinds,
+        documentation: metadata?.documentation,
+        provideCodeActions: (model, range, context, token) => {
+            const markerService = StandaloneServices.get(IMarkerService);
+            const markers = markerService.read({ resource: model.uri }).filter(m => {
+                return Range.areIntersectingOrTouching(m, range);
+            });
+            return provider.provideCodeActions(model, range, { markers, only: context.only, trigger: context.trigger }, token);
+        },
+        resolveCodeAction: provider.resolveCodeAction
+    });
+}
+/**
+ * Register a formatter that can handle only entire models.
+ */
+function registerDocumentFormattingEditProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentFormattingEditProvider.register(languageSelector, provider);
+}
+/**
+ * Register a formatter that can handle a range inside a model.
+ */
+function registerDocumentRangeFormattingEditProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentRangeFormattingEditProvider.register(languageSelector, provider);
+}
+/**
+ * Register a formatter than can do formatting as the user types.
+ */
+function registerOnTypeFormattingEditProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.onTypeFormattingEditProvider.register(languageSelector, provider);
+}
+/**
+ * Register a link provider that can find links in text.
+ */
+function registerLinkProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.linkProvider.register(languageSelector, provider);
+}
+/**
+ * Register a completion item provider (use by e.g. suggestions).
+ */
+function registerCompletionItemProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.completionProvider.register(languageSelector, provider);
+}
+/**
+ * Register a document color provider (used by Color Picker, Color Decorator).
+ */
+function registerColorProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.colorProvider.register(languageSelector, provider);
+}
+/**
+ * Register a folding range provider
+ */
+function registerFoldingRangeProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.foldingRangeProvider.register(languageSelector, provider);
+}
+/**
+ * Register a declaration provider
+ */
+function registerDeclarationProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.declarationProvider.register(languageSelector, provider);
+}
+/**
+ * Register a selection range provider
+ */
+function registerSelectionRangeProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.selectionRangeProvider.register(languageSelector, provider);
+}
+/**
+ * Register a document semantic tokens provider. A semantic tokens provider will complement and enhance a
+ * simple top-down tokenizer. Simple top-down tokenizers can be set either via `setMonarchTokensProvider`
+ * or `setTokensProvider`.
+ *
+ * For the best user experience, register both a semantic tokens provider and a top-down tokenizer.
+ */
+function registerDocumentSemanticTokensProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentSemanticTokensProvider.register(languageSelector, provider);
+}
+/**
+ * Register a document range semantic tokens provider. A semantic tokens provider will complement and enhance a
+ * simple top-down tokenizer. Simple top-down tokenizers can be set either via `setMonarchTokensProvider`
+ * or `setTokensProvider`.
+ *
+ * For the best user experience, register both a semantic tokens provider and a top-down tokenizer.
+ */
+function registerDocumentRangeSemanticTokensProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentRangeSemanticTokensProvider.register(languageSelector, provider);
+}
+/**
+ * Register an inline completions provider.
+ */
+function registerInlineCompletionsProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.inlineCompletionsProvider.register(languageSelector, provider);
+}
+/**
+ * Register an inlay hints provider.
+ */
+function registerInlayHintsProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.inlayHintsProvider.register(languageSelector, provider);
+}
+/**
+ * @internal
+ */
+function createMonacoLanguagesAPI() {
+    return {
+        // eslint-disable-next-line local/code-no-any-casts
+        register: register,
+        // eslint-disable-next-line local/code-no-any-casts
+        getLanguages: getLanguages,
+        // eslint-disable-next-line local/code-no-any-casts
+        onLanguage: onLanguage,
+        // eslint-disable-next-line local/code-no-any-casts
+        onLanguageEncountered: onLanguageEncountered,
+        // eslint-disable-next-line local/code-no-any-casts
+        getEncodedLanguageId: getEncodedLanguageId,
+        // provider methods
+        // eslint-disable-next-line local/code-no-any-casts
+        setLanguageConfiguration: setLanguageConfiguration,
+        setColorMap: setColorMap,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerTokensProviderFactory: registerTokensProviderFactory,
+        // eslint-disable-next-line local/code-no-any-casts
+        setTokensProvider: setTokensProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        setMonarchTokensProvider: setMonarchTokensProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerReferenceProvider: registerReferenceProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerRenameProvider: registerRenameProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerNewSymbolNameProvider: registerNewSymbolNameProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerCompletionItemProvider: registerCompletionItemProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerSignatureHelpProvider: registerSignatureHelpProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerHoverProvider: registerHoverProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerDocumentSymbolProvider: registerDocumentSymbolProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerDocumentHighlightProvider: registerDocumentHighlightProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerLinkedEditingRangeProvider: registerLinkedEditingRangeProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerDefinitionProvider: registerDefinitionProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerImplementationProvider: registerImplementationProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerTypeDefinitionProvider: registerTypeDefinitionProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerCodeLensProvider: registerCodeLensProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerCodeActionProvider: registerCodeActionProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerDocumentFormattingEditProvider: registerDocumentFormattingEditProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerDocumentRangeFormattingEditProvider: registerDocumentRangeFormattingEditProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerOnTypeFormattingEditProvider: registerOnTypeFormattingEditProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerLinkProvider: registerLinkProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerColorProvider: registerColorProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerFoldingRangeProvider: registerFoldingRangeProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerDeclarationProvider: registerDeclarationProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerSelectionRangeProvider: registerSelectionRangeProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerDocumentSemanticTokensProvider: registerDocumentSemanticTokensProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerDocumentRangeSemanticTokensProvider: registerDocumentRangeSemanticTokensProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerInlineCompletionsProvider: registerInlineCompletionsProvider,
+        // eslint-disable-next-line local/code-no-any-casts
+        registerInlayHintsProvider: registerInlayHintsProvider,
+        // enums
+        DocumentHighlightKind: DocumentHighlightKind,
+        CompletionItemKind: CompletionItemKind,
+        CompletionItemTag: CompletionItemTag,
+        CompletionItemInsertTextRule: CompletionItemInsertTextRule,
+        SymbolKind: SymbolKind,
+        SymbolTag: SymbolTag,
+        IndentAction: IndentAction,
+        CompletionTriggerKind: CompletionTriggerKind,
+        SignatureHelpTriggerKind: SignatureHelpTriggerKind,
+        InlayHintKind: InlayHintKind,
+        InlineCompletionTriggerKind: InlineCompletionTriggerKind,
+        CodeActionTriggerType: CodeActionTriggerType,
+        NewSymbolNameTag: NewSymbolNameTag,
+        NewSymbolNameTriggerKind: NewSymbolNameTriggerKind,
+        PartialAcceptTriggerKind: PartialAcceptTriggerKind,
+        HoverVerbosityAction: HoverVerbosityAction,
+        InlineCompletionEndOfLifeReasonKind: InlineCompletionEndOfLifeReasonKind,
+        InlineCompletionHintStyle: InlineCompletionHintStyle,
+        // classes
+        FoldingRangeKind: FoldingRangeKind,
+        // eslint-disable-next-line local/code-no-any-casts
+        SelectedSuggestionInfo: SelectedSuggestionInfo,
+        // eslint-disable-next-line local/code-no-any-casts
+        EditDeltaInfo: EditDeltaInfo,
+    };
+}
+
+export { EncodedTokenizationSupportAdapter, TokenizationSupportAdapter, createMonacoLanguagesAPI, getEncodedLanguageId, getLanguages, onLanguage, onLanguageEncountered, register, registerCodeActionProvider, registerCodeLensProvider, registerColorProvider, registerCompletionItemProvider, registerDeclarationProvider, registerDefinitionProvider, registerDocumentFormattingEditProvider, registerDocumentHighlightProvider, registerDocumentRangeFormattingEditProvider, registerDocumentRangeSemanticTokensProvider, registerDocumentSemanticTokensProvider, registerDocumentSymbolProvider, registerFoldingRangeProvider, registerHoverProvider, registerImplementationProvider, registerInlayHintsProvider, registerInlineCompletionsProvider, registerLinkProvider, registerLinkedEditingRangeProvider, registerNewSymbolNameProvider, registerOnTypeFormattingEditProvider, registerReferenceProvider, registerRenameProvider, registerSelectionRangeProvider, registerSignatureHelpProvider, registerTokensProviderFactory, registerTypeDefinitionProvider, setColorMap, setLanguageConfiguration, setMonarchTokensProvider, setTokensProvider };