@codingame/monaco-vscode-editor-api 11.1.2 → 12.0.1

package/vscode/src/vs/editor/standalone/browser/standaloneLanguages.d.ts

@@ -0,0 +1,114 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { Range } from "vscode/vscode/vs/editor/common/core/range";
+import * as languages from "vscode/vscode/vs/editor/common/languages";
+import { ILanguageExtensionPoint, ILanguageService } from "vscode/vscode/vs/editor/common/languages/language";
+import { LanguageConfiguration } from "vscode/vscode/vs/editor/common/languages/languageConfiguration";
+import { LanguageSelector } from "vscode/vscode/vs/editor/common/languageSelector";
+import * as model from "vscode/vscode/vs/editor/common/model";
+import { IMonarchLanguage } from "../common/monarch/monarchTypes.js";
+import { IStandaloneThemeService } from "vscode/vscode/vs/editor/standalone/common/standaloneTheme";
+import { IMarkerData } from "vscode/vscode/vs/platform/markers/common/markers";
+export declare function register(language: ILanguageExtensionPoint): void;
+export declare function getLanguages(): ILanguageExtensionPoint[];
+export declare function getEncodedLanguageId(languageId: string): number;
+export declare function onLanguage(languageId: string, callback: () => void): IDisposable;
+export declare function onLanguageEncountered(languageId: string, callback: () => void): IDisposable;
+export declare function setLanguageConfiguration(languageId: string, configuration: LanguageConfiguration): IDisposable;
+export declare class EncodedTokenizationSupportAdapter implements languages.ITokenizationSupport, IDisposable {
+    private readonly _languageId;
+    private readonly _actual;
+    constructor(languageId: string, actual: EncodedTokensProvider);
+    dispose(): void;
+    getInitialState(): languages.IState;
+    tokenize(line: string, hasEOL: boolean, state: languages.IState): languages.TokenizationResult;
+    tokenizeEncoded(line: string, hasEOL: boolean, state: languages.IState): languages.EncodedTokenizationResult;
+}
+export declare class TokenizationSupportAdapter implements languages.ITokenizationSupport, IDisposable {
+    private readonly _languageId;
+    private readonly _actual;
+    private readonly _languageService;
+    private readonly _standaloneThemeService;
+    constructor(_languageId: string, _actual: TokensProvider, _languageService: ILanguageService, _standaloneThemeService: IStandaloneThemeService);
+    dispose(): void;
+    getInitialState(): languages.IState;
+    private static _toClassicTokens;
+    static adaptTokenize(language: string, actual: {
+        tokenize(line: string, state: languages.IState): ILineTokens;
+    }, line: string, state: languages.IState): languages.TokenizationResult;
+    tokenize(line: string, hasEOL: boolean, state: languages.IState): languages.TokenizationResult;
+    private _toBinaryTokens;
+    tokenizeEncoded(line: string, hasEOL: boolean, state: languages.IState): languages.EncodedTokenizationResult;
+}
+export interface IToken {
+    startIndex: number;
+    scopes: string;
+}
+export interface ILineTokens {
+    tokens: IToken[];
+    endState: languages.IState;
+}
+export interface IEncodedLineTokens {
+    tokens: Uint32Array;
+    endState: languages.IState;
+}
+export interface TokensProviderFactory {
+    create(): languages.ProviderResult<TokensProvider | EncodedTokensProvider | IMonarchLanguage>;
+}
+export interface TokensProvider {
+    getInitialState(): languages.IState;
+    tokenize(line: string, state: languages.IState): ILineTokens;
+}
+export interface EncodedTokensProvider {
+    getInitialState(): languages.IState;
+    tokenizeEncoded(line: string, state: languages.IState): IEncodedLineTokens;
+    tokenize?(line: string, state: languages.IState): ILineTokens;
+}
+export declare function setColorMap(colorMap: string[] | null): void;
+export declare function registerTokensProviderFactory(languageId: string, factory: TokensProviderFactory): IDisposable;
+export declare function setTokensProvider(languageId: string, provider: TokensProvider | EncodedTokensProvider | Thenable<TokensProvider | EncodedTokensProvider>): IDisposable;
+export declare function setMonarchTokensProvider(languageId: string, languageDef: IMonarchLanguage | Thenable<IMonarchLanguage>): IDisposable;
+export declare function registerReferenceProvider(languageSelector: LanguageSelector, provider: languages.ReferenceProvider): IDisposable;
+export declare function registerRenameProvider(languageSelector: LanguageSelector, provider: languages.RenameProvider): IDisposable;
+export declare function registerNewSymbolNameProvider(languageSelector: LanguageSelector, provider: languages.NewSymbolNamesProvider): IDisposable;
+export declare function registerSignatureHelpProvider(languageSelector: LanguageSelector, provider: languages.SignatureHelpProvider): IDisposable;
+export declare function registerHoverProvider(languageSelector: LanguageSelector, provider: languages.HoverProvider): IDisposable;
+export declare function registerDocumentSymbolProvider(languageSelector: LanguageSelector, provider: languages.DocumentSymbolProvider): IDisposable;
+export declare function registerDocumentHighlightProvider(languageSelector: LanguageSelector, provider: languages.DocumentHighlightProvider): IDisposable;
+export declare function registerLinkedEditingRangeProvider(languageSelector: LanguageSelector, provider: languages.LinkedEditingRangeProvider): IDisposable;
+export declare function registerDefinitionProvider(languageSelector: LanguageSelector, provider: languages.DefinitionProvider): IDisposable;
+export declare function registerImplementationProvider(languageSelector: LanguageSelector, provider: languages.ImplementationProvider): IDisposable;
+export declare function registerTypeDefinitionProvider(languageSelector: LanguageSelector, provider: languages.TypeDefinitionProvider): IDisposable;
+export declare function registerCodeLensProvider(languageSelector: LanguageSelector, provider: languages.CodeLensProvider): IDisposable;
+export declare function registerCodeActionProvider(languageSelector: LanguageSelector, provider: CodeActionProvider, metadata?: CodeActionProviderMetadata): IDisposable;
+export declare function registerDocumentFormattingEditProvider(languageSelector: LanguageSelector, provider: languages.DocumentFormattingEditProvider): IDisposable;
+export declare function registerDocumentRangeFormattingEditProvider(languageSelector: LanguageSelector, provider: languages.DocumentRangeFormattingEditProvider): IDisposable;
+export declare function registerOnTypeFormattingEditProvider(languageSelector: LanguageSelector, provider: languages.OnTypeFormattingEditProvider): IDisposable;
+export declare function registerLinkProvider(languageSelector: LanguageSelector, provider: languages.LinkProvider): IDisposable;
+export declare function registerCompletionItemProvider(languageSelector: LanguageSelector, provider: languages.CompletionItemProvider): IDisposable;
+export declare function registerColorProvider(languageSelector: LanguageSelector, provider: languages.DocumentColorProvider): IDisposable;
+export declare function registerFoldingRangeProvider(languageSelector: LanguageSelector, provider: languages.FoldingRangeProvider): IDisposable;
+export declare function registerDeclarationProvider(languageSelector: LanguageSelector, provider: languages.DeclarationProvider): IDisposable;
+export declare function registerSelectionRangeProvider(languageSelector: LanguageSelector, provider: languages.SelectionRangeProvider): IDisposable;
+export declare function registerDocumentSemanticTokensProvider(languageSelector: LanguageSelector, provider: languages.DocumentSemanticTokensProvider): IDisposable;
+export declare function registerDocumentRangeSemanticTokensProvider(languageSelector: LanguageSelector, provider: languages.DocumentRangeSemanticTokensProvider): IDisposable;
+export declare function registerInlineCompletionsProvider(languageSelector: LanguageSelector, provider: languages.InlineCompletionsProvider): IDisposable;
+export declare function registerInlineEditProvider(languageSelector: LanguageSelector, provider: languages.InlineEditProvider): IDisposable;
+export declare function registerInlayHintsProvider(languageSelector: LanguageSelector, provider: languages.InlayHintsProvider): IDisposable;
+export interface CodeActionContext {
+    readonly markers: IMarkerData[];
+    readonly only?: string;
+    readonly trigger: languages.CodeActionTriggerType;
+}
+export interface CodeActionProvider {
+    provideCodeActions(model: model.ITextModel, range: Range, context: CodeActionContext, token: CancellationToken): languages.ProviderResult<languages.CodeActionList>;
+    resolveCodeAction?(codeAction: languages.CodeAction, token: CancellationToken): languages.ProviderResult<languages.CodeAction>;
+}
+export interface CodeActionProviderMetadata {
+    readonly providedCodeActionKinds?: readonly string[];
+    readonly documentation?: ReadonlyArray<{
+        readonly kind: string;
+        readonly command: languages.Command;
+    }>;
+}
+export declare function createMonacoLanguagesAPI(): typeof monaco.languages;

package/vscode/src/vs/editor/standalone/browser/standaloneLanguages.js

@@ -0,0 +1,444 @@
+
+import { Color } from 'vscode/vscode/vs/base/common/color';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { MetadataConsts } from 'vscode/vscode/vs/editor/common/encodedTokenAttributes';
+import { EncodedTokenizationResult, Token, TokenizationResult, LazyTokenizationSupport, TokenizationRegistry, FoldingRangeKind, SelectedSuggestionInfo } from 'vscode/vscode/vs/editor/common/languages';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { ILanguageConfigurationService } from 'vscode/vscode/vs/editor/common/languages/languageConfigurationRegistry';
+import { ModesRegistry } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
+import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
+import { DocumentHighlightKind, CompletionItemKind, CompletionItemTag, CompletionItemInsertTextRule, SymbolKind, SymbolTag, IndentAction, CompletionTriggerKind, SignatureHelpTriggerKind, InlayHintKind, InlineCompletionTriggerKind, InlineEditTriggerKind, CodeActionTriggerType, NewSymbolNameTag, NewSymbolNameTriggerKind, PartialAcceptTriggerKind, HoverVerbosityAction } from 'vscode/vscode/vs/editor/common/standalone/standaloneEnums';
+import { StandaloneServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+import { compile } from '../common/monarch/monarchCompile.js';
+import { MonarchTokenizer } from '../common/monarch/monarchLexer.js';
+import { IStandaloneThemeService } from 'vscode/vscode/vs/editor/standalone/common/standaloneTheme';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { IMarkerService } from 'vscode/vscode/vs/platform/markers/common/markers.service';
+
+function register(language) {
+    ModesRegistry.registerLanguage(language);
+}
+function getLanguages() {
+    let result = [];
+    result = result.concat(ModesRegistry.getLanguages());
+    return result;
+}
+function getEncodedLanguageId(languageId) {
+    const languageService = StandaloneServices.get(ILanguageService);
+    return languageService.languageIdCodec.encodeLanguageId(languageId);
+}
+function onLanguage(languageId, callback) {
+    return StandaloneServices.withServices(() => {
+        const languageService = StandaloneServices.get(ILanguageService);
+        const disposable = languageService.onDidRequestRichLanguageFeatures((encounteredLanguageId) => {
+            if (encounteredLanguageId === languageId) {
+                disposable.dispose();
+                callback();
+            }
+        });
+        return disposable;
+    });
+}
+function onLanguageEncountered(languageId, callback) {
+    return StandaloneServices.withServices(() => {
+        const languageService = StandaloneServices.get(ILanguageService);
+        const disposable = languageService.onDidRequestBasicLanguageFeatures((encounteredLanguageId) => {
+            if (encounteredLanguageId === languageId) {
+                disposable.dispose();
+                callback();
+            }
+        });
+        return disposable;
+    });
+}
+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);
+}
+class EncodedTokenizationSupportAdapter {
+    constructor(languageId, actual) {
+        this._languageId = languageId;
+        this._actual = actual;
+    }
+    dispose() {
+    }
+    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);
+    }
+}
+class TokenizationSupportAdapter {
+    constructor(_languageId, _actual, _languageService, _standaloneThemeService) {
+        this._languageId = _languageId;
+        this._actual = _actual;
+        this._languageService = _languageService;
+        this._standaloneThemeService = _standaloneThemeService;
+    }
+    dispose() {
+    }
+    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;
+            if (i === 0) {
+                startIndex = 0;
+            }
+            else if (startIndex < previousStartIndex) {
+                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;
+        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) | MetadataConsts.BALANCED_BRACKETS_MASK;
+            if (resultLen > 0 && result[resultLen - 1] === metadata) {
+                continue;
+            }
+            let startIndex = t.startIndex;
+            if (i === 0) {
+                startIndex = 0;
+            }
+            else if (startIndex < previousStartIndex) {
+                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;
+        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';
+}
+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);
+    }
+}
+function createTokenizationSupportAdapter(languageId, provider) {
+    if (isEncodedTokensProvider(provider)) {
+        return ( new EncodedTokenizationSupportAdapter(languageId, provider));
+    }
+    else {
+        return ( new TokenizationSupportAdapter(
+            languageId,
+            provider,
+            StandaloneServices.get(ILanguageService),
+            StandaloneServices.get(IStandaloneThemeService)
+        ));
+    }
+}
+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);
+}
+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));
+}
+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));
+}
+function registerReferenceProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.referenceProvider.register(languageSelector, provider);
+}
+function registerRenameProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.renameProvider.register(languageSelector, provider);
+}
+function registerNewSymbolNameProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.newSymbolNamesProvider.register(languageSelector, provider);
+}
+function registerSignatureHelpProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.signatureHelpProvider.register(languageSelector, provider);
+}
+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;
+            });
+        }
+    });
+}
+function registerDocumentSymbolProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentSymbolProvider.register(languageSelector, provider);
+}
+function registerDocumentHighlightProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentHighlightProvider.register(languageSelector, provider);
+}
+function registerLinkedEditingRangeProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.linkedEditingRangeProvider.register(languageSelector, provider);
+}
+function registerDefinitionProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.definitionProvider.register(languageSelector, provider);
+}
+function registerImplementationProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.implementationProvider.register(languageSelector, provider);
+}
+function registerTypeDefinitionProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.typeDefinitionProvider.register(languageSelector, provider);
+}
+function registerCodeLensProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.codeLensProvider.register(languageSelector, provider);
+}
+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
+    });
+}
+function registerDocumentFormattingEditProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentFormattingEditProvider.register(languageSelector, provider);
+}
+function registerDocumentRangeFormattingEditProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentRangeFormattingEditProvider.register(languageSelector, provider);
+}
+function registerOnTypeFormattingEditProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.onTypeFormattingEditProvider.register(languageSelector, provider);
+}
+function registerLinkProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.linkProvider.register(languageSelector, provider);
+}
+function registerCompletionItemProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.completionProvider.register(languageSelector, provider);
+}
+function registerColorProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.colorProvider.register(languageSelector, provider);
+}
+function registerFoldingRangeProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.foldingRangeProvider.register(languageSelector, provider);
+}
+function registerDeclarationProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.declarationProvider.register(languageSelector, provider);
+}
+function registerSelectionRangeProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.selectionRangeProvider.register(languageSelector, provider);
+}
+function registerDocumentSemanticTokensProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentSemanticTokensProvider.register(languageSelector, provider);
+}
+function registerDocumentRangeSemanticTokensProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.documentRangeSemanticTokensProvider.register(languageSelector, provider);
+}
+function registerInlineCompletionsProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.inlineCompletionsProvider.register(languageSelector, provider);
+}
+function registerInlineEditProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.inlineEditProvider.register(languageSelector, provider);
+}
+function registerInlayHintsProvider(languageSelector, provider) {
+    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
+    return languageFeaturesService.inlayHintsProvider.register(languageSelector, provider);
+}
+function createMonacoLanguagesAPI() {
+    return {
+        register: register,
+        getLanguages: getLanguages,
+        onLanguage: onLanguage,
+        onLanguageEncountered: onLanguageEncountered,
+        getEncodedLanguageId: getEncodedLanguageId,
+        setLanguageConfiguration: setLanguageConfiguration,
+        setColorMap: setColorMap,
+        registerTokensProviderFactory: registerTokensProviderFactory,
+        setTokensProvider: setTokensProvider,
+        setMonarchTokensProvider: setMonarchTokensProvider,
+        registerReferenceProvider: registerReferenceProvider,
+        registerRenameProvider: registerRenameProvider,
+        registerNewSymbolNameProvider: registerNewSymbolNameProvider,
+        registerCompletionItemProvider: registerCompletionItemProvider,
+        registerSignatureHelpProvider: registerSignatureHelpProvider,
+        registerHoverProvider: registerHoverProvider,
+        registerDocumentSymbolProvider: registerDocumentSymbolProvider,
+        registerDocumentHighlightProvider: registerDocumentHighlightProvider,
+        registerLinkedEditingRangeProvider: registerLinkedEditingRangeProvider,
+        registerDefinitionProvider: registerDefinitionProvider,
+        registerImplementationProvider: registerImplementationProvider,
+        registerTypeDefinitionProvider: registerTypeDefinitionProvider,
+        registerCodeLensProvider: registerCodeLensProvider,
+        registerCodeActionProvider: registerCodeActionProvider,
+        registerDocumentFormattingEditProvider: registerDocumentFormattingEditProvider,
+        registerDocumentRangeFormattingEditProvider: registerDocumentRangeFormattingEditProvider,
+        registerOnTypeFormattingEditProvider: registerOnTypeFormattingEditProvider,
+        registerLinkProvider: registerLinkProvider,
+        registerColorProvider: registerColorProvider,
+        registerFoldingRangeProvider: registerFoldingRangeProvider,
+        registerDeclarationProvider: registerDeclarationProvider,
+        registerSelectionRangeProvider: registerSelectionRangeProvider,
+        registerDocumentSemanticTokensProvider: registerDocumentSemanticTokensProvider,
+        registerDocumentRangeSemanticTokensProvider: registerDocumentRangeSemanticTokensProvider,
+        registerInlineCompletionsProvider: registerInlineCompletionsProvider,
+        registerInlineEditProvider: registerInlineEditProvider,
+        registerInlayHintsProvider: registerInlayHintsProvider,
+        DocumentHighlightKind: DocumentHighlightKind,
+        CompletionItemKind: CompletionItemKind,
+        CompletionItemTag: CompletionItemTag,
+        CompletionItemInsertTextRule: CompletionItemInsertTextRule,
+        SymbolKind: SymbolKind,
+        SymbolTag: SymbolTag,
+        IndentAction: IndentAction,
+        CompletionTriggerKind: CompletionTriggerKind,
+        SignatureHelpTriggerKind: SignatureHelpTriggerKind,
+        InlayHintKind: InlayHintKind,
+        InlineCompletionTriggerKind: InlineCompletionTriggerKind,
+        InlineEditTriggerKind: InlineEditTriggerKind,
+        CodeActionTriggerType: CodeActionTriggerType,
+        NewSymbolNameTag: NewSymbolNameTag,
+        NewSymbolNameTriggerKind: NewSymbolNameTriggerKind,
+        PartialAcceptTriggerKind: PartialAcceptTriggerKind,
+        HoverVerbosityAction: HoverVerbosityAction,
+        FoldingRangeKind: FoldingRangeKind,
+        SelectedSuggestionInfo: SelectedSuggestionInfo,
+    };
+}
+
+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, registerInlineEditProvider, registerLinkProvider, registerLinkedEditingRangeProvider, registerNewSymbolNameProvider, registerOnTypeFormattingEditProvider, registerReferenceProvider, registerRenameProvider, registerSelectionRangeProvider, registerSignatureHelpProvider, registerTokensProviderFactory, registerTypeDefinitionProvider, setColorMap, setLanguageConfiguration, setMonarchTokensProvider, setTokensProvider };

package/vscode/src/vs/editor/standalone/browser/standaloneWebWorker.d.ts

@@ -0,0 +1,15 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IModelService } from "vscode/vscode/vs/editor/common/services/model";
+export declare function createWebWorker<T extends object>(modelService: IModelService, opts: IWebWorkerOptions): MonacoWebWorker<T>;
+export interface MonacoWebWorker<T> {
+    dispose(): void;
+    getProxy(): Promise<T>;
+    withSyncedResources(resources: URI[]): Promise<T>;
+}
+export interface IWebWorkerOptions {
+    moduleId: string;
+    createData?: any;
+    label?: string;
+    host?: any;
+    keepIdleModels?: boolean;
+}

package/vscode/src/vs/editor/standalone/browser/standaloneWebWorker.js

@@ -0,0 +1,66 @@
+
+import { getAllMethodNames } from 'vscode/vscode/vs/base/common/objects';
+import { EditorWorkerClient } from 'vscode/vscode/vs/editor/browser/services/editorWorkerService';
+import { standaloneEditorWorkerDescriptor } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+function createWebWorker(modelService, opts) {
+    return ( new MonacoWebWorkerImpl(modelService, opts));
+}
+class MonacoWebWorkerImpl extends EditorWorkerClient {
+    constructor(modelService, opts) {
+        const workerDescriptor = {
+            moduleId: standaloneEditorWorkerDescriptor.moduleId,
+            esmModuleLocation: standaloneEditorWorkerDescriptor.esmModuleLocation,
+            label: opts.label,
+        };
+        super(workerDescriptor, opts.keepIdleModels || false, modelService);
+        this._foreignModuleId = opts.moduleId;
+        this._foreignModuleCreateData = opts.createData || null;
+        this._foreignModuleHost = opts.host || null;
+        this._foreignProxy = null;
+    }
+    fhr(method, args) {
+        if (!this._foreignModuleHost || typeof this._foreignModuleHost[method] !== 'function') {
+            return Promise.reject(( new Error('Missing method ' + method + ' or missing main thread foreign host.')));
+        }
+        try {
+            return Promise.resolve(this._foreignModuleHost[method].apply(this._foreignModuleHost, args));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+    _getForeignProxy() {
+        if (!this._foreignProxy) {
+            this._foreignProxy = this._getProxy().then((proxy) => {
+                const foreignHostMethods = this._foreignModuleHost ? getAllMethodNames(this._foreignModuleHost) : [];
+                return proxy.$loadForeignModule(this._foreignModuleId, this._foreignModuleCreateData, foreignHostMethods).then((foreignMethods) => {
+                    this._foreignModuleCreateData = null;
+                    const proxyMethodRequest = (method, args) => {
+                        return proxy.$fmr(method, args);
+                    };
+                    const createProxyMethod = (method, proxyMethodRequest) => {
+                        return function () {
+                            const args = Array.prototype.slice.call(arguments, 0);
+                            return proxyMethodRequest(method, args);
+                        };
+                    };
+                    const foreignProxy = {};
+                    for (const foreignMethod of foreignMethods) {
+                        foreignProxy[foreignMethod] = createProxyMethod(foreignMethod, proxyMethodRequest);
+                    }
+                    return foreignProxy;
+                });
+            });
+        }
+        return this._foreignProxy;
+    }
+    getProxy() {
+        return this._getForeignProxy();
+    }
+    withSyncedResources(resources) {
+        return this.workerWithSyncedResources(resources).then(_ => ( this.getProxy()));
+    }
+}
+
+export { createWebWorker };