@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode-services/env.js

@@ -0,0 +1,69 @@
+import { matchesScheme } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ExtHostTelemetryLogger } from '../vscode/vs/workbench/api/common/extHostTelemetry.js';
+import { IExtHostInitDataService } from '../vscode/vs/workbench/api/common/extHostInitDataService.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { getExtHostServices } from './extHost.js';
+import { unsupported } from '../tools.js';
+function create(getExtension) {
+    return {
+        get machineId() { return StandaloneServices.get(IExtHostInitDataService).telemetryInfo.machineId; },
+        get sessionId() { return StandaloneServices.get(IExtHostInitDataService).telemetryInfo.sessionId; },
+        get language() { return StandaloneServices.get(IExtHostInitDataService).environment.appLanguage; },
+        get appName() { return StandaloneServices.get(IExtHostInitDataService).environment.appName; },
+        get appRoot() { return StandaloneServices.get(IExtHostInitDataService).environment.appRoot?.fsPath ?? ''; },
+        get appHost() { return StandaloneServices.get(IExtHostInitDataService).environment.appHost; },
+        get uriScheme() { return StandaloneServices.get(IExtHostInitDataService).environment.appUriScheme; },
+        get clipboard() {
+            const { extHostClipboard } = getExtHostServices();
+            return extHostClipboard.value;
+        },
+        remoteName: undefined,
+        get shell() { return unsupported(); },
+        get uiKind() {
+            return StandaloneServices.get(IExtHostInitDataService).uiKind;
+        },
+        async asExternalUri(uri) {
+            const { extHostWindow } = getExtHostServices();
+            try {
+                return await extHostWindow.asExternalUri(uri, { allowTunneling: false });
+            }
+            catch (err) {
+                if (matchesScheme(uri, Schemas.http) || matchesScheme(uri, Schemas.https)) {
+                    return uri;
+                }
+                throw err;
+            }
+        },
+        openExternal: async (uri, options) => {
+            const { extHostWindow } = getExtHostServices();
+            return extHostWindow.openUri(uri, {
+                allowTunneling: false,
+                allowContributedOpeners: options?.allowContributedOpeners
+            });
+        },
+        isNewAppInstall: false,
+        get isTelemetryEnabled() {
+            const { extHostTelemetry } = getExtHostServices();
+            return extHostTelemetry.getTelemetryConfiguration();
+        },
+        get onDidChangeTelemetryEnabled() {
+            const { extHostTelemetry } = getExtHostServices();
+            return extHostTelemetry.onDidChangeTelemetryEnabled;
+        },
+        createTelemetryLogger(sender) {
+            const { extHostTelemetry } = getExtHostServices();
+            ExtHostTelemetryLogger.validateSender(sender);
+            return extHostTelemetry.instantiateLogger(getExtension(), sender);
+        },
+        get logLevel() {
+            const { extHostLogService } = getExtHostServices();
+            return extHostLogService.getLevel();
+        },
+        get onDidChangeLogLevel() {
+            const { extHostLogService } = getExtHostServices();
+            return extHostLogService.onDidChangeLogLevel;
+        }
+    };
+}
+export { create as default };

package/dist/vscode-services/extHost.js

@@ -0,0 +1,385 @@
+import './missing-services.js';
+import { IExtHostCommands, ExtHostCommands } from '../vscode/vs/workbench/api/common/extHostCommands.js';
+import { IExtHostRpcService, ExtHostRpcService } from '../vscode/vs/workbench/api/common/extHostRpcService.js';
+import { LogLevel, ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ExtHostCustomersRegistry } from '../vscode/vs/workbench/services/extensions/common/extHostCustomers.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IExtHostApiDeprecationService, ExtHostApiDeprecationService } from '../vscode/vs/workbench/api/common/extHostApiDeprecationService.js';
+import { ExtHostContext, MainContext } from '../vscode/vs/workbench/api/common/extHost.protocol.js';
+import { ExtHostDiagnostics } from '../vscode/vs/workbench/api/common/extHostDiagnostics.js';
+import { IExtHostFileSystemInfo, ExtHostFileSystemInfo } from '../vscode/vs/workbench/api/common/extHostFileSystemInfo.js';
+import { ExtHostDocuments } from '../vscode/vs/workbench/api/common/extHostDocuments.js';
+import { createExtHostQuickOpen } from '../vscode/vs/workbench/api/common/extHostQuickOpen.js';
+import { IExtHostWorkspace, ExtHostWorkspace } from '../vscode/vs/workbench/api/common/extHostWorkspace.js';
+import { ExtHostMessageService } from '../vscode/vs/workbench/api/common/extHostMessageService.js';
+import { ExtHostProgress } from '../vscode/vs/workbench/api/common/extHostProgress.js';
+import { ExtHostDocumentContentProvider } from '../vscode/vs/workbench/api/common/extHostDocumentContentProviders.js';
+import { IExtHostDocumentsAndEditors, ExtHostDocumentsAndEditors } from '../vscode/vs/workbench/api/common/extHostDocumentsAndEditors.js';
+import { ExtHostEditors } from '../vscode/vs/workbench/api/common/extHostTextEditors.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { ExtHostBulkEdits } from '../vscode/vs/workbench/api/common/extHostBulkEdits.js';
+import { ExtHostLanguages } from '../vscode/vs/workbench/api/common/extHostLanguages.js';
+import { IURITransformerService } from '../vscode/vs/workbench/api/common/extHostUriTransformerService.js';
+import { IExtHostWindow, ExtHostWindow } from '../vscode/vs/workbench/api/common/extHostWindow.js';
+import { ExtHostClipboard } from '../vscode/vs/workbench/api/common/extHostClipboard.js';
+import { IExtHostTelemetry, ExtHostTelemetry } from '../vscode/vs/workbench/api/common/extHostTelemetry.js';
+import { ExtHostLanguageFeatures } from '../vscode/vs/workbench/api/common/extHostLanguageFeatures.js';
+import { IExtHostConfiguration, ExtHostConfiguration } from '../vscode/vs/workbench/api/common/extHostConfiguration.js';
+import { IExtHostDebugService, WorkerExtHostDebugService } from '../vscode/vs/workbench/api/common/extHostDebugService.js';
+import { IExtHostVariableResolverProvider, ExtHostVariableResolverProviderService } from '../vscode/vs/workbench/api/common/extHostVariableResolverService.js';
+import { IHostUtils, IExtHostExtensionService, AbstractExtHostExtensionService } from '../vscode/vs/workbench/api/common/extHostExtensionService.js';
+import { IExtensionStoragePaths, ExtensionStoragePaths } from '../vscode/vs/workbench/api/common/extHostStoragePaths.js';
+import { IExtHostTunnelService, ExtHostTunnelService } from '../vscode/vs/workbench/api/common/extHostTunnelService.js';
+import { IExtHostLocalizationService, ExtHostLocalizationService } from '../vscode/vs/workbench/api/common/extHostLocalizationService.js';
+import { IExtHostEditorTabs, ExtHostEditorTabs } from '../vscode/vs/workbench/api/common/extHostEditorTabs.js';
+import { registerSingleton } from 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
+import { BufferedEmitter } from '../vscode/vs/base/parts/ipc/common/ipc.net.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { RPCProtocol } from '../vscode/vs/workbench/services/extensions/common/rpcProtocol.js';
+import { IExtHostConsumerFileSystem, ExtHostConsumerFileSystem } from '../vscode/vs/workbench/api/common/extHostFileSystemConsumer.js';
+import { IExtHostInitDataService } from '../vscode/vs/workbench/api/common/extHostInitDataService.js';
+import { UIKind } from '../vscode/vs/workbench/services/extensions/common/extensionHostProtocol.js';
+import { IExtHostTerminalService } from '../vscode/vs/workbench/api/common/extHostTerminalService.js';
+import { IExtHostDecorations, ExtHostDecorations } from '../vscode/vs/workbench/api/common/extHostDecorations.js';
+import { ExtensionRuntime } from '../vscode/vs/workbench/api/common/extHostTypes.js';
+import { ExtHostFileSystem } from '../vscode/vs/workbench/api/common/extHostFileSystem.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ExtHostDocumentSaveParticipant } from '../vscode/vs/workbench/api/common/extHostDocumentSaveParticipant.js';
+import { ExtHostFileSystemEventService } from '../vscode/vs/workbench/api/common/extHostFileSystemEventService.js';
+import { MainThreadMessageService } from '../vscode/vs/workbench/api/browser/mainThreadMessageService.js';
+import { ExtHostApiCommands } from '../vscode/vs/workbench/api/common/extHostApiCommands.js';
+import { IExtHostOutputService, ExtHostOutputService } from '../vscode/vs/workbench/api/common/extHostOutput.js';
+import '../vscode/vs/workbench/api/browser/mainThreadCommands.js';
+import '../vscode/vs/workbench/api/browser/mainThreadWindow.js';
+import '../vscode/vs/workbench/api/browser/mainThreadDiagnostics.js';
+import '../vscode/vs/workbench/api/browser/mainThreadQuickOpen.js';
+import '../vscode/vs/workbench/api/browser/mainThreadTelemetry.js';
+import '../vscode/vs/workbench/api/browser/mainThreadProgress.js';
+import '../vscode/vs/workbench/api/browser/mainThreadDocumentContentProviders.js';
+import '../vscode/vs/workbench/api/browser/mainThreadBulkEdits.js';
+import '../vscode/vs/workbench/api/browser/mainThreadLanguages.js';
+import '../vscode/vs/workbench/api/browser/mainThreadClipboard.js';
+import '../vscode/vs/workbench/api/browser/mainThreadLanguageFeatures.js';
+import '../vscode/vs/workbench/api/browser/mainThreadConfiguration.js';
+import '../vscode/vs/workbench/api/browser/mainThreadDebugService.js';
+import '../vscode/vs/workbench/api/browser/mainThreadConsole.js';
+import '../vscode/vs/workbench/api/browser/mainThreadWorkspace.js';
+import '../vscode/vs/workbench/api/browser/mainThreadExtensionService.js';
+import '../vscode/vs/workbench/api/browser/mainThreadFileSystem.js';
+import '../vscode/vs/workbench/api/browser/mainThreadFileSystemEventService.js';
+import '../vscode/vs/workbench/api/browser/mainThreadDocumentsAndEditors.js';
+import '../vscode/vs/workbench/api/browser/mainThreadOutputService.js';
+import '../vscode/vs/workbench/api/browser/mainThreadSaveParticipant.js';
+import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
+import { unsupported } from '../tools.js';
+const original = MainThreadMessageService.prototype.$showMessage;
+MainThreadMessageService.prototype.$showMessage = function (severity, message, options, commands) {
+    const _options = {
+        ...options,
+        source: undefined
+    };
+    return original.call(this, severity, message, _options, commands);
+};
+class SimpleMessagePassingProtocol {
+    constructor() {
+        this._onMessage = new BufferedEmitter();
+        this.onMessage = this._onMessage.event;
+    }
+    send(buffer) {
+        setTimeout(() => {
+            this._onMessage.fire(buffer);
+        });
+    }
+}
+const imessagePassingProtocol = new SimpleMessagePassingProtocol();
+const rpcProtocol = new RPCProtocol(imessagePassingProtocol);
+class InjectedExtHostRpcService extends ExtHostRpcService {
+    constructor() {
+        super(rpcProtocol);
+    }
+}
+const environment = {
+    isExtensionDevelopmentDebug: false,
+    appName: 'Monaco',
+    appHost: 'web',
+    appLanguage: window.navigator.language ?? 'en-US',
+    extensionTelemetryLogResource: ( URI.from({ scheme: 'user', path: '/extensionTelemetryLogResource.log' })),
+    isExtensionTelemetryLoggingOnly: false,
+    get appUriScheme() { return unsupported(); },
+    get globalStorageHome() { return unsupported(); },
+    get workspaceStorageHome() { return unsupported(); }
+};
+registerSingleton(IExtHostInitDataService, class ExtHostInitDataService {
+    constructor() {
+        this.version = '1.0.0';
+        this.parentPid = 0;
+        this.environment = environment;
+        this.allExtensions = [];
+        this.myExtensions = [];
+        this.consoleForward = {
+            includeStack: false,
+            logNative: false
+        };
+        this.logLevel = LogLevel.Off;
+        this.logsLocation = ( URI.from({ scheme: 'logs', path: '/' }));
+        this.logFile = ( URI.from({ scheme: 'logs', path: '/logs.log' }));
+        this.autoStart = true;
+        this.remote = {
+            isRemote: false,
+            authority: undefined,
+            connectionData: null
+        };
+        this.uiKind = UIKind.Web;
+        this.loggers = [];
+        this.logName = 'browser';
+        this.activationEvents = {};
+    }
+    get telemetryInfo() { return unsupported(); }
+}, 0 );
+registerSingleton(IHostUtils, class HostUtils {
+    constructor() {
+        this.pid = undefined;
+    }
+    exit() {
+        window.close();
+    }
+    async exists() {
+        return true;
+    }
+    async realpath(path) {
+        return path;
+    }
+}, 0 );
+registerSingleton(IExtHostRpcService, InjectedExtHostRpcService, 0 );
+registerSingleton(IExtHostFileSystemInfo, ExtHostFileSystemInfo, 0 );
+registerSingleton(IExtHostConsumerFileSystem, ExtHostConsumerFileSystem, 0 );
+registerSingleton(IExtensionStoragePaths, ExtensionStoragePaths, 0 );
+registerSingleton(IExtHostLocalizationService, ExtHostLocalizationService, 1 );
+registerSingleton(IExtHostDocumentsAndEditors, ExtHostDocumentsAndEditors, 0 );
+class ExtHostExtensionService extends AbstractExtHostExtensionService {
+    constructor() {
+        super(...arguments);
+        this.extensionRuntime = ExtensionRuntime.Webworker;
+        this._getEntryPoint = () => undefined;
+        this._loadCommonJSModule = unsupported;
+        this.$setRemoteEnvironment = unsupported;
+    }
+    async _beforeAlmostReadyToRunExtensions() { }
+    getExtensionRegistries() {
+        return { mine: this._myRegistry, all: this._globalRegistry };
+    }
+}
+registerSingleton(IExtHostExtensionService, ExtHostExtensionService, 0 );
+registerSingleton(IExtHostConfiguration, ExtHostConfiguration, 0 );
+registerSingleton(IExtHostTunnelService, ExtHostTunnelService, 0 );
+registerSingleton(IExtHostFileSystemInfo, ExtHostFileSystemInfo, 0 );
+registerSingleton(IExtHostTelemetry, ExtHostTelemetry, 0 );
+registerSingleton(IExtHostCommands, ExtHostCommands, 0 );
+registerSingleton(IExtHostDocumentsAndEditors, ExtHostDocumentsAndEditors, 0 );
+registerSingleton(IExtHostWindow, ExtHostWindow, 0 );
+registerSingleton(IExtHostWorkspace, ExtHostWorkspace, 0 );
+registerSingleton(IExtHostEditorTabs, ExtHostEditorTabs, 0 );
+registerSingleton(IExtHostApiDeprecationService, ExtHostApiDeprecationService, 0 );
+registerSingleton(IExtHostDecorations, ExtHostDecorations, 0 );
+registerSingleton(IExtHostDebugService, WorkerExtHostDebugService, 0 );
+registerSingleton(IExtHostVariableResolverProvider, ExtHostVariableResolverProviderService, 0 );
+registerSingleton(IExtHostOutputService, ExtHostOutputService, 1 );
+registerSingleton(IExtHostTerminalService, class ExtHostTerminalService {
+    constructor() {
+        this.activeTerminal = undefined;
+        this.terminals = [];
+        this.onDidCloseTerminal = Event.None;
+        this.onDidOpenTerminal = Event.None;
+        this.onDidChangeActiveTerminal = Event.None;
+        this.onDidChangeTerminalDimensions = Event.None;
+        this.onDidChangeTerminalState = Event.None;
+        this.onDidWriteTerminalData = Event.None;
+        this.onDidChangeShell = Event.None;
+        this.createTerminal = unsupported;
+        this.createTerminalFromOptions = unsupported;
+        this.createExtensionTerminal = unsupported;
+        this.attachPtyToTerminal = unsupported;
+        this.getDefaultShell = unsupported;
+        this.getDefaultShellArgs = unsupported;
+        this.registerLinkProvider = unsupported;
+        this.registerProfileProvider = unsupported;
+        this.registerTerminalQuickFixProvider = unsupported;
+        this.getEnvironmentVariableCollection = unsupported;
+        this.$acceptTerminalClosed = unsupported;
+        this.$acceptTerminalOpened = unsupported;
+        this.$acceptActiveTerminalChanged = unsupported;
+        this.$acceptTerminalProcessId = unsupported;
+        this.$acceptTerminalProcessData = unsupported;
+        this.$acceptTerminalTitleChange = unsupported;
+        this.$acceptTerminalDimensions = unsupported;
+        this.$acceptTerminalMaximumDimensions = unsupported;
+        this.$acceptTerminalInteraction = unsupported;
+        this.$startExtensionTerminal = unsupported;
+        this.$acceptProcessAckDataEvent = unsupported;
+        this.$acceptProcessInput = unsupported;
+        this.$acceptProcessResize = unsupported;
+        this.$acceptProcessShutdown = unsupported;
+        this.$acceptProcessRequestInitialCwd = unsupported;
+        this.$acceptProcessRequestCwd = unsupported;
+        this.$acceptProcessRequestLatency = unsupported;
+        this.$provideLinks = unsupported;
+        this.$activateLink = unsupported;
+        this.$initEnvironmentVariableCollections = unsupported;
+        this.$acceptDefaultProfile = unsupported;
+        this.$createContributedProfileTerminal = unsupported;
+        this.$provideTerminalQuickFixes = unsupported;
+        this.dispose = unsupported;
+    }
+}, 0 );
+const mainContext = {
+    remoteAuthority: null,
+    extensionHostKind: 1 ,
+    internalExtensionService: {
+        _activateById() {
+            return Promise.resolve();
+        },
+        _onWillActivateExtension() {
+        },
+        _onDidActivateExtension() {
+        },
+        _onDidActivateExtensionError() {
+        },
+        _onExtensionRuntimeError() {
+        }
+    },
+    getProxy: function (identifier) {
+        return ( rpcProtocol.getProxy(identifier));
+    },
+    set: function (identifier, instance) {
+        return rpcProtocol.set(identifier, instance);
+    },
+    assertRegistered: function (identifiers) {
+        rpcProtocol.assertRegistered(identifiers);
+    },
+    drain: function () {
+        return rpcProtocol.drain();
+    },
+    dispose() {
+        rpcProtocol.dispose();
+    },
+    _setExtensionHostProxy() { },
+    _setAllMainProxyIdentifiers() { }
+};
+async function createExtHostServices() {
+    const rpcProtocol = StandaloneServices.get(IExtHostRpcService);
+    const instantiationService = StandaloneServices.get(IInstantiationService);
+    const logService = StandaloneServices.get(ILogService);
+    const extHostConsumerFileSystem = StandaloneServices.get(IExtHostConsumerFileSystem);
+    const extHostApiDeprecationService = StandaloneServices.get(IExtHostApiDeprecationService);
+    const uriTransformerService = StandaloneServices.get(IURITransformerService);
+    const extHostFileSystemInfo = StandaloneServices.get(IExtHostFileSystemInfo);
+    const extHostTunnelService = StandaloneServices.get(IExtHostTunnelService);
+    const extHostTelemetry = StandaloneServices.get(IExtHostTelemetry);
+    rpcProtocol.set(ExtHostContext.ExtHostFileSystemInfo, extHostFileSystemInfo);
+    rpcProtocol.set(ExtHostContext.ExtHostTunnelService, extHostTunnelService);
+    rpcProtocol.set(ExtHostContext.ExtHostTelemetry, extHostTelemetry);
+    const extHostCommands = rpcProtocol.set(ExtHostContext.ExtHostCommands, StandaloneServices.get(IExtHostCommands));
+    const extHostDocumentsAndEditors = rpcProtocol.set(ExtHostContext.ExtHostDocumentsAndEditors, StandaloneServices.get(IExtHostDocumentsAndEditors));
+    const extHostQuickOpen = rpcProtocol.set(ExtHostContext.ExtHostQuickOpen, createExtHostQuickOpen(mainContext, null, extHostCommands));
+    const extHostDocuments = rpcProtocol.set(ExtHostContext.ExtHostDocuments, new ExtHostDocuments(mainContext, extHostDocumentsAndEditors));
+    const extHostLanguages = rpcProtocol.set(ExtHostContext.ExtHostLanguages, new ExtHostLanguages(mainContext, extHostDocuments, extHostCommands.converter, uriTransformerService));
+    const extHostDiagnostics = rpcProtocol.set(ExtHostContext.ExtHostDiagnostics, new ExtHostDiagnostics(mainContext, logService, extHostFileSystemInfo, extHostDocumentsAndEditors));
+    const extHostProgress = rpcProtocol.set(ExtHostContext.ExtHostProgress, new ExtHostProgress(( rpcProtocol.getProxy(MainContext.MainThreadProgress))));
+    const extHostDocumentContentProviders = rpcProtocol.set(ExtHostContext.ExtHostDocumentContentProviders, new ExtHostDocumentContentProvider(mainContext, extHostDocumentsAndEditors, logService));
+    const extHostEditors = rpcProtocol.set(ExtHostContext.ExtHostEditors, new ExtHostEditors(mainContext, extHostDocumentsAndEditors));
+    const extHostLanguageFeatures = rpcProtocol.set(ExtHostContext.ExtHostLanguageFeatures, new ExtHostLanguageFeatures(rpcProtocol, uriTransformerService, extHostDocuments, extHostCommands, extHostDiagnostics, logService, extHostApiDeprecationService, extHostTelemetry));
+    const extHostDebugService = rpcProtocol.set(ExtHostContext.ExtHostDebugService, StandaloneServices.get(IExtHostDebugService));
+    const extHostWindow = rpcProtocol.set(ExtHostContext.ExtHostWindow, StandaloneServices.get(IExtHostWindow));
+    const extHostWorkspace = rpcProtocol.set(ExtHostContext.ExtHostWorkspace, StandaloneServices.get(IExtHostWorkspace));
+    const extHostConfiguration = rpcProtocol.set(ExtHostContext.ExtHostConfiguration, StandaloneServices.get(IExtHostConfiguration));
+    const extHostExtensionService = rpcProtocol.set(ExtHostContext.ExtHostExtensionService, StandaloneServices.get(IExtHostExtensionService));
+    const extHostOutputService = rpcProtocol.set(ExtHostContext.ExtHostOutputService, StandaloneServices.get(IExtHostOutputService));
+    const extHostFileSystem = rpcProtocol.set(ExtHostContext.ExtHostFileSystem, new ExtHostFileSystem(rpcProtocol, extHostLanguageFeatures));
+    const extHostDocumentSaveParticipant = rpcProtocol.set(ExtHostContext.ExtHostDocumentSaveParticipant, new ExtHostDocumentSaveParticipant(logService, extHostDocuments, ( rpcProtocol.getProxy(MainContext.MainThreadBulkEdits))));
+    const extHostFileSystemEvent = rpcProtocol.set(ExtHostContext.ExtHostFileSystemEventService, new ExtHostFileSystemEventService(rpcProtocol, logService, extHostDocumentsAndEditors));
+    const extHostBulkEdits = new ExtHostBulkEdits(rpcProtocol, extHostDocumentsAndEditors);
+    const extHostClipboard = new ExtHostClipboard(mainContext);
+    const extHostMessageService = new ExtHostMessageService(rpcProtocol, logService);
+    ExtHostApiCommands.register(extHostCommands);
+    const namedCustomers = ExtHostCustomersRegistry.getNamedCustomers();
+    for (let i = 0, len = namedCustomers.length; i < len; i++) {
+        const [id, ctor] = namedCustomers[i];
+        try {
+            const instance = instantiationService.createInstance(ctor, mainContext);
+            rpcProtocol.set(id, instance);
+        }
+        catch (err) {
+            logService.error(`Cannot instantiate named customer: '${id.sid}'`);
+            logService.error(err);
+            errors.onUnexpectedError(err);
+        }
+    }
+    const customers = ExtHostCustomersRegistry.getCustomers();
+    for (const ctor of customers) {
+        try {
+            instantiationService.createInstance(ctor, mainContext);
+        }
+        catch (err) {
+            logService.error(err);
+            errors.onUnexpectedError(err);
+        }
+    }
+    await extHostExtensionService.initialize();
+    return {
+        extHostLogService: logService,
+        extHostApiDeprecationService,
+        extHostMessageService,
+        extHostDocumentsAndEditors,
+        extHostBulkEdits,
+        extHostDocuments,
+        extHostDocumentContentProviders,
+        extHostQuickOpen,
+        extHostProgress,
+        extHostDiagnostics,
+        extHostEditors,
+        extHostCommands,
+        extHostLanguages,
+        extHostWindow,
+        extHostClipboard,
+        extHostLanguageFeatures,
+        extHostWorkspace,
+        extHostConfiguration,
+        extHostTelemetry,
+        extHostDebugService,
+        extHostFileSystem,
+        extHostConsumerFileSystem,
+        extHostExtensionService,
+        extHostDocumentSaveParticipant,
+        extHostFileSystemEvent,
+        extHostOutputService
+    };
+}
+let extHostServices;
+let configProvider;
+let initializePromise;
+const extHostInitializedEmitter = new Emitter();
+const onExtHostInitialized = extHostInitializedEmitter.event;
+async function _initialize() {
+    extHostServices = await createExtHostServices();
+    configProvider = await extHostServices.extHostConfiguration.getConfigProvider();
+    extHostInitializedEmitter.fire();
+}
+async function initialize() {
+    if (initializePromise == null) {
+        initializePromise = _initialize();
+    }
+    await initializePromise;
+}
+function getExtHostServices() {
+    if (extHostServices == null) {
+        throw new Error('Extension api not initialized');
+    }
+    return extHostServices;
+}
+function getConfigProvider() {
+    if (configProvider == null) {
+        throw new Error('Extension api not initialized');
+    }
+    return configProvider;
+}
+export { getConfigProvider, getExtHostServices, initialize, onExtHostInitialized };

package/dist/vscode-services/extensions.js

@@ -0,0 +1,46 @@
+import { Extension } from '../vscode/vs/workbench/api/common/extHostExtensionService.js';
+import { isProposedApiEnabled } from '../vscode/vs/workbench/services/extensions/common/extensions.js';
+import { ExtensionKind } from '../vscode/vs/workbench/api/common/extHostTypes.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { getExtHostServices } from './extHost.js';
+function create(getExtension) {
+    return {
+        getExtension(extensionId, includeFromDifferentExtensionHosts = false) {
+            const { extHostExtensionService: extensionService } = getExtHostServices();
+            const extensionInfo = extensionService.getExtensionRegistries();
+            const extension = getExtension();
+            if (!isProposedApiEnabled(getExtension(), 'extensionsAny')) {
+                includeFromDifferentExtensionHosts = false;
+            }
+            const mine = extensionInfo.mine.getExtensionDescription(extensionId);
+            if (mine != null) {
+                return new Extension(extensionService, extension.identifier, mine, ExtensionKind.UI, false);
+            }
+            if (includeFromDifferentExtensionHosts) {
+                const foreign = extensionInfo.all.getExtensionDescription(extensionId);
+                if (foreign != null) {
+                    return new Extension(extensionService, extension.identifier, foreign, ExtensionKind.UI, true);
+                }
+            }
+            return undefined;
+        },
+        get all() {
+            const { extHostExtensionService } = getExtHostServices();
+            const extensionInfo = extHostExtensionService.getExtensionRegistries();
+            const result = [];
+            for (const desc of extensionInfo.mine.getAllExtensionDescriptions()) {
+                result.push(new Extension(extHostExtensionService, getExtension().identifier, desc, ExtensionKind.UI, false));
+            }
+            return result;
+        },
+        get onDidChange() {
+            const { extHostExtensionService } = getExtHostServices();
+            const extensionInfo = extHostExtensionService.getExtensionRegistries();
+            if (isProposedApiEnabled(getExtension(), 'extensionsAny')) {
+                return Event.any(extensionInfo.mine.onDidChange, extensionInfo.all.onDidChange);
+            }
+            return extensionInfo.mine.onDidChange;
+        }
+    };
+}
+export { create as default };