@codingame/monaco-vscode-api 1.79.3-next.2 → 1.79.3-next.4

package/dist/service-override/views.d.ts

@@ -1,17 +1,17 @@
-import { I as IEditorOverrideServices } from '../standaloneServices.js';
-import { V as ViewContainerLocation } from '../views.js';
 import { a as ServicesAccessor } from '../instantiation.js';
 import { a as IDisposable } from '../event.js';
 export { I as IReference } from '../event.js';
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import { V as ViewContainerLocation } from '../views.js';
 export { I as IEditorOptions, a as IResolvedTextEditorModel } from '../editorBrowser.js';
 import { T as ThemeIcon } from '../themables.js';
 import { O as OpenEditor } from '../editor.js';
+import 'vscode';
 import 'monaco-editor';
 import '../uri.js';
 import '../contextkey.js';
 import '../extensions.d2.ts';
 import '../composite.js';
-import 'vscode';
 
 /**
  * The Codicon library is a set of default icons that are built-in in VS Code.

package/dist/services.d.ts

@@ -19,7 +19,7 @@ import { I as IconIdentifier, T as ThemeIcon } from './themables.js';
 import { I as IJSONSchema, a as IJSONSchemaMap } from './jsonSchema.js';
 import { I as IView$3, a as IViewDescriptorService, b as IViewPaneContainer, c as ViewContainer, d as IViewContainerModel, e as IViewDescriptor, f as IAddedViewDescriptorRef, g as IPaneComposite, V as ViewContainerLocation } from './views.js';
 export { h as IViewsService } from './views.js';
-import { e as ICommandAction, f as ICommandActionTitle, g as Icon, h as IEnvironmentService, E as ExtensionIdentifier, T as TargetPlatform, b as IExtensionDescription } from './extensions.d2.ts';
+import { e as ICommandAction, f as ICommandActionTitle, g as Icon, h as IEnvironmentService, E as ExtensionIdentifier, T as TargetPlatform, a as IExtensionDescription } from './extensions.d2.ts';
 import { b as IProgress, c as IProgressStep, I as IComposite, d as ICompositeControl, a as IProgressIndicator } from './composite.js';
 import { a as IContextKeyService, C as ContextKeyExpression } from './contextkey.js';
 import { a as IExtensionService } from './extensionsRegistry.js';

package/dist/views.d.ts

@@ -3,7 +3,7 @@ import { U as URI } from './uri.js';
 import { E as Event } from './event.js';
 import { T as ThemeIcon } from './themables.js';
 import { C as ContextKeyExpression } from './contextkey.js';
-import { a as ILocalizedString, E as ExtensionIdentifier } from './extensions.d2.ts';
+import { c as ILocalizedString, E as ExtensionIdentifier } from './extensions.d2.ts';
 import { I as IComposite, a as IProgressIndicator } from './composite.js';
 
 interface IKeybindings {

package/dist/vscode/vs/workbench/api/browser/mainThreadDecorations.js

@@ -0,0 +1,100 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IDecorationsService } from '../../services/decorations/common/decorations.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+class DecorationRequestsQueue {
+    constructor(_proxy, _handle) {
+        this._proxy = _proxy;
+        this._handle = _handle;
+        this._idPool = 0;
+        this._requests = ( new Map());
+        this._resolver = ( new Map());
+    }
+    enqueue(uri, token) {
+        const id = ++this._idPool;
+        const result = ( new Promise(resolve => {
+            this._requests.set(id, { id, uri });
+            this._resolver.set(id, resolve);
+            this._processQueue();
+        }));
+        const sub = token.onCancellationRequested(() => {
+            this._requests.delete(id);
+            this._resolver.delete(id);
+        });
+        return result.finally(() => sub.dispose());
+    }
+    _processQueue() {
+        if (typeof this._timer === 'number') {
+            return;
+        }
+        this._timer = setTimeout(() => {
+            const requests = this._requests;
+            const resolver = this._resolver;
+            this._proxy.$provideDecorations(this._handle, [...( requests.values())], CancellationToken.None).then(data => {
+                for (const [id, resolve] of resolver) {
+                    resolve(data[id]);
+                }
+            });
+            this._requests = ( new Map());
+            this._resolver = ( new Map());
+            this._timer = undefined;
+        }, 0);
+    }
+}
+let MainThreadDecorations = class MainThreadDecorations {
+    constructor(context, _decorationsService) {
+        this._decorationsService = _decorationsService;
+        this._provider = ( new Map());
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostDecorations));
+    }
+    dispose() {
+        this._provider.forEach(value => dispose(value));
+        this._provider.clear();
+    }
+    $registerDecorationProvider(handle, label) {
+        const emitter = ( new Emitter());
+        const queue = ( new DecorationRequestsQueue(this._proxy, handle));
+        const registration = this._decorationsService.registerDecorationsProvider({
+            label,
+            onDidChange: emitter.event,
+            provideDecorations: async (uri, token) => {
+                const data = await queue.enqueue(uri, token);
+                if (!data) {
+                    return undefined;
+                }
+                const [bubble, tooltip, letter, themeColor] = data;
+                return {
+                    weight: 10,
+                    bubble: bubble ?? false,
+                    color: themeColor?.id,
+                    tooltip,
+                    letter
+                };
+            }
+        });
+        this._provider.set(handle, [emitter, registration]);
+    }
+    $onDidChange(handle, resources) {
+        const provider = this._provider.get(handle);
+        if (provider) {
+            const [emitter] = provider;
+            emitter.fire(resources && ( resources.map(r => URI.revive(r))));
+        }
+    }
+    $unregisterDecorationProvider(handle) {
+        const provider = this._provider.get(handle);
+        if (provider) {
+            dispose(provider);
+            this._provider.delete(handle);
+        }
+    }
+};
+MainThreadDecorations = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadDecorations),
+    ( __param(1, IDecorationsService))
+], MainThreadDecorations);
+export { MainThreadDecorations };

package/dist/vscode/vs/workbench/api/browser/mainThreadExtensionService.js

@@ -8,7 +8,8 @@ import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { areSameExtensions } from '../../../platform/extensionManagement/common/extensionManagementUtil.js';
 import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { MainContext } from '../common/extHost.protocol.js';
+import { WebSocketRemoteConnection, ManagedRemoteConnection } from '../../../platform/remote/common/remoteAuthorityResolver.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
 import { IExtensionsWorkbenchService } from '../../contrib/extensions/common/extensions.js';
 import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.js';
 import { IWorkbenchExtensionEnablementService } from '../../services/extensionManagement/common/extensionManagement.js';
@@ -29,6 +30,8 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         this._extensionHostKind = extHostContext.extensionHostKind;
         const internalExtHostContext = extHostContext;
         this._internalExtensionService = internalExtHostContext.internalExtensionService;
+        internalExtHostContext._setExtensionHostProxy(( new ExtensionHostProxy(( extHostContext.getProxy(ExtHostContext.ExtHostExtensionService)))));
+        internalExtHostContext._setAllMainProxyIdentifiers(( ( Object.keys(MainContext)).map((key) => MainContext[key])));
     }
     dispose() {
     }
@@ -210,4 +213,73 @@ MainThreadExtensionService = __decorate([
     ( __param(7, ICommandService)),
     ( __param(8, IWorkbenchEnvironmentService))
 ], MainThreadExtensionService);
+class ExtensionHostProxy {
+    constructor(_actual) {
+        this._actual = _actual;
+    }
+    async resolveAuthority(remoteAuthority, resolveAttempt) {
+        const resolved = reviveResolveAuthorityResult(await this._actual.$resolveAuthority(remoteAuthority, resolveAttempt));
+        return resolved;
+    }
+    async getCanonicalURI(remoteAuthority, uri) {
+        const uriComponents = await this._actual.$getCanonicalURI(remoteAuthority, uri);
+        return (uriComponents ? URI.revive(uriComponents) : uriComponents);
+    }
+    startExtensionHost(extensionsDelta) {
+        return this._actual.$startExtensionHost(extensionsDelta);
+    }
+    extensionTestsExecute() {
+        return this._actual.$extensionTestsExecute();
+    }
+    activateByEvent(activationEvent, activationKind) {
+        return this._actual.$activateByEvent(activationEvent, activationKind);
+    }
+    activate(extensionId, reason) {
+        return this._actual.$activate(extensionId, reason);
+    }
+    setRemoteEnvironment(env) {
+        return this._actual.$setRemoteEnvironment(env);
+    }
+    updateRemoteConnectionData(connectionData) {
+        return this._actual.$updateRemoteConnectionData(connectionData);
+    }
+    deltaExtensions(extensionsDelta) {
+        return this._actual.$deltaExtensions(extensionsDelta);
+    }
+    test_latency(n) {
+        return this._actual.$test_latency(n);
+    }
+    test_up(b) {
+        return this._actual.$test_up(b);
+    }
+    test_down(size) {
+        return this._actual.$test_down(size);
+    }
+}
+function reviveResolveAuthorityResult(result) {
+    if (result.type === 'ok') {
+        return {
+            type: 'ok',
+            value: {
+                ...result.value,
+                authority: reviveResolvedAuthority(result.value.authority),
+            }
+        };
+    }
+    else {
+        return result;
+    }
+}
+function reviveResolvedAuthority(resolvedAuthority) {
+    return {
+        ...resolvedAuthority,
+        connectTo: reviveConnection(resolvedAuthority.connectTo),
+    };
+}
+function reviveConnection(connection) {
+    if (connection.type === 0 ) {
+        return ( new WebSocketRemoteConnection(connection.host, connection.port));
+    }
+    return ( new ManagedRemoteConnection(connection.id));
+}
 export { MainThreadExtensionService };

package/dist/vscode/vs/workbench/api/common/extHostRequireInterceptor.js

@@ -0,0 +1,248 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import * as performance from 'monaco-editor/esm/vs/base/common/performance.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { MainContext } from './extHost.protocol.js';
+import { IExtHostConfiguration } from './extHostConfiguration.js';
+import { nullExtensionDescription } from '../../services/extensions/common/extensions.js';
+import { ExtensionIdentifierMap } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtHostExtensionService } from './extHostExtensionService.js';
+import { platform } from 'monaco-editor/esm/vs/base/common/process.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { escapeRegExpCharacters } from 'monaco-editor/esm/vs/base/common/strings.js';
+let RequireInterceptor = class RequireInterceptor {
+    constructor(_apiFactory, _extensionRegistry, _instaService, _extHostConfiguration, _extHostExtensionService, _initData, _logService) {
+        this._apiFactory = _apiFactory;
+        this._extensionRegistry = _extensionRegistry;
+        this._instaService = _instaService;
+        this._extHostConfiguration = _extHostConfiguration;
+        this._extHostExtensionService = _extHostExtensionService;
+        this._initData = _initData;
+        this._logService = _logService;
+        this._factories = ( new Map());
+        this._alternatives = [];
+    }
+    async install() {
+        this._installInterceptor();
+        performance.mark('code/extHost/willWaitForConfig');
+        const configProvider = await this._extHostConfiguration.getConfigProvider();
+        performance.mark('code/extHost/didWaitForConfig');
+        const extensionPaths = await this._extHostExtensionService.getExtensionPathIndex();
+        this.register(( new VSCodeNodeModuleFactory(
+            this._apiFactory,
+            extensionPaths,
+            this._extensionRegistry,
+            configProvider,
+            this._logService
+        )));
+        this.register(this._instaService.createInstance(KeytarNodeModuleFactory, extensionPaths));
+        this.register(this._instaService.createInstance(NodeModuleAliasingModuleFactory));
+        if (this._initData.remote.isRemote) {
+            this.register(this._instaService.createInstance(OpenNodeModuleFactory, extensionPaths, this._initData.environment.appUriScheme));
+        }
+    }
+    register(interceptor) {
+        if ('nodeModuleName' in interceptor) {
+            if (Array.isArray(interceptor.nodeModuleName)) {
+                for (const moduleName of interceptor.nodeModuleName) {
+                    this._factories.set(moduleName, interceptor);
+                }
+            }
+            else {
+                this._factories.set(interceptor.nodeModuleName, interceptor);
+            }
+        }
+        if (typeof interceptor.alternativeModuleName === 'function') {
+            this._alternatives.push((moduleName) => {
+                return interceptor.alternativeModuleName(moduleName);
+            });
+        }
+    }
+};
+RequireInterceptor = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IExtHostConfiguration)),
+    ( __param(4, IExtHostExtensionService)),
+    ( __param(5, IExtHostInitDataService)),
+    ( __param(6, ILogService))
+], RequireInterceptor));
+let NodeModuleAliasingModuleFactory = class NodeModuleAliasingModuleFactory {
+    constructor(initData) {
+        if (initData.environment.appRoot && NodeModuleAliasingModuleFactory.aliased.size) {
+            const root = escapeRegExpCharacters(this.forceForwardSlashes(initData.environment.appRoot.fsPath));
+            const npmIdChrs = `[a-z0-9_.-]`;
+            const npmModuleName = `@${npmIdChrs}+\\/${npmIdChrs}+|${npmIdChrs}+`;
+            const moduleFolders = 'node_modules|node_modules\\.asar(?:\\.unpacked)?';
+            this.re = ( new RegExp(`^(${root}/${moduleFolders}\\/)(${npmModuleName})(.*)$`, 'i'));
+        }
+    }
+    alternativeModuleName(name) {
+        if (!this.re) {
+            return;
+        }
+        const result = this.re.exec(this.forceForwardSlashes(name));
+        if (!result) {
+            return;
+        }
+        const [, prefix, moduleName, suffix] = result;
+        const dealiased = NodeModuleAliasingModuleFactory.aliased.get(moduleName);
+        if (dealiased === undefined) {
+            return;
+        }
+        console.warn(`${moduleName} as been renamed to ${dealiased}, please update your imports`);
+        return prefix + dealiased + suffix;
+    }
+    forceForwardSlashes(str) {
+        return str.replace(/\\/g, '/');
+    }
+};
+NodeModuleAliasingModuleFactory.aliased = ( new Map([
+    ['vscode-ripgrep', '@vscode/ripgrep'],
+    ['vscode-windows-registry', '@vscode/windows-registry'],
+]));
+NodeModuleAliasingModuleFactory = ( __decorate([
+    ( __param(0, IExtHostInitDataService))
+], NodeModuleAliasingModuleFactory));
+class VSCodeNodeModuleFactory {
+    constructor(_apiFactory, _extensionPaths, _extensionRegistry, _configProvider, _logService) {
+        this._apiFactory = _apiFactory;
+        this._extensionPaths = _extensionPaths;
+        this._extensionRegistry = _extensionRegistry;
+        this._configProvider = _configProvider;
+        this._logService = _logService;
+        this.nodeModuleName = 'vscode';
+        this._extApiImpl = ( new ExtensionIdentifierMap());
+    }
+    load(_request, parent) {
+        const ext = this._extensionPaths.findSubstr(parent);
+        if (ext) {
+            let apiImpl = this._extApiImpl.get(ext.identifier);
+            if (!apiImpl) {
+                apiImpl = this._apiFactory(ext, this._extensionRegistry, this._configProvider);
+                this._extApiImpl.set(ext.identifier, apiImpl);
+            }
+            return apiImpl;
+        }
+        if (!this._defaultApiImpl) {
+            let extensionPathsPretty = '';
+            this._extensionPaths.forEach((value, index) => extensionPathsPretty += `\t${index} -> ${value.identifier.value}\n`);
+            this._logService.warn(`Could not identify extension for 'vscode' require call from ${parent}. These are the extension path mappings: \n${extensionPathsPretty}`);
+            this._defaultApiImpl = this._apiFactory(nullExtensionDescription, this._extensionRegistry, this._configProvider);
+        }
+        return this._defaultApiImpl;
+    }
+}
+let KeytarNodeModuleFactory = class KeytarNodeModuleFactory {
+    constructor(_extensionPaths, rpcService, initData) {
+        this._extensionPaths = _extensionPaths;
+        this.nodeModuleName = 'keytar';
+        this._mainThreadTelemetry = ( rpcService.getProxy(MainContext.MainThreadTelemetry));
+        const { environment } = initData;
+        const mainThreadKeytar = ( rpcService.getProxy(MainContext.MainThreadKeytar));
+        if (environment.appRoot) {
+            let appRoot = environment.appRoot.fsPath;
+            if (platform === 'win32') {
+                appRoot = appRoot.replace(/\\/g, '/');
+            }
+            if (appRoot[appRoot.length - 1] === '/') {
+                appRoot = appRoot.substr(0, appRoot.length - 1);
+            }
+            this.alternativeNames = ( new Set());
+            this.alternativeNames.add(`${appRoot}/node_modules.asar/keytar`);
+            this.alternativeNames.add(`${appRoot}/node_modules/keytar`);
+        }
+        this._impl = {
+            getPassword: (service, account) => {
+                return mainThreadKeytar.$getPassword(service, account);
+            },
+            setPassword: (service, account, password) => {
+                return mainThreadKeytar.$setPassword(service, account, password);
+            },
+            deletePassword: (service, account) => {
+                return mainThreadKeytar.$deletePassword(service, account);
+            },
+            findPassword: (service) => {
+                return mainThreadKeytar.$findPassword(service);
+            },
+            findCredentials(service) {
+                return mainThreadKeytar.$findCredentials(service);
+            }
+        };
+    }
+    load(_request, parent) {
+        const ext = this._extensionPaths.findSubstr(parent);
+        this._mainThreadTelemetry.$publicLog2('shimming.keytar', { extension: ext?.identifier.value ?? 'unknown_extension' });
+        return this._impl;
+    }
+    alternativeModuleName(name) {
+        const length = name.length;
+        if (length <= 7 || !this.alternativeNames) {
+            return undefined;
+        }
+        const sep = length - 7;
+        if ((name.charAt(sep) === '/' || name.charAt(sep) === '\\') && name.endsWith('keytar')) {
+            name = name.replace(/\\/g, '/');
+            if (( this.alternativeNames.has(name))) {
+                return 'keytar';
+            }
+        }
+        return undefined;
+    }
+};
+KeytarNodeModuleFactory = ( __decorate([
+    ( __param(1, IExtHostRpcService)),
+    ( __param(2, IExtHostInitDataService))
+], KeytarNodeModuleFactory));
+let OpenNodeModuleFactory = class OpenNodeModuleFactory {
+    constructor(_extensionPaths, _appUriScheme, rpcService) {
+        this._extensionPaths = _extensionPaths;
+        this._appUriScheme = _appUriScheme;
+        this.nodeModuleName = ['open', 'opn'];
+        this._mainThreadTelemetry = ( rpcService.getProxy(MainContext.MainThreadTelemetry));
+        const mainThreadWindow = ( rpcService.getProxy(MainContext.MainThreadWindow));
+        this._impl = (target, options) => {
+            const uri = ( URI.parse(target));
+            if (options) {
+                return this.callOriginal(target, options);
+            }
+            if (uri.scheme === 'http' || uri.scheme === 'https') {
+                return mainThreadWindow.$openUri(uri, target, { allowTunneling: true });
+            }
+            else if (uri.scheme === 'mailto' || uri.scheme === this._appUriScheme) {
+                return mainThreadWindow.$openUri(uri, target, {});
+            }
+            return this.callOriginal(target, options);
+        };
+    }
+    load(request, parent, original) {
+        const extension = this._extensionPaths.findSubstr(parent);
+        if (extension) {
+            this._extensionId = extension.identifier.value;
+            this.sendShimmingTelemetry();
+        }
+        this._original = original(request);
+        return this._impl;
+    }
+    callOriginal(target, options) {
+        this.sendNoForwardTelemetry();
+        return this._original(target, options);
+    }
+    sendShimmingTelemetry() {
+        if (!this._extensionId) {
+            return;
+        }
+        this._mainThreadTelemetry.$publicLog2('shimming.open', { extension: this._extensionId });
+    }
+    sendNoForwardTelemetry() {
+        if (!this._extensionId) {
+            return;
+        }
+        this._mainThreadTelemetry.$publicLog2('shimming.open.call.noForward', { extension: this._extensionId });
+    }
+};
+OpenNodeModuleFactory = ( __decorate([
+    ( __param(2, IExtHostRpcService))
+], OpenNodeModuleFactory));
+export { RequireInterceptor };

package/dist/vscode/vs/workbench/api/worker/extHostExtensionService.js

@@ -0,0 +1,114 @@
+import fetch from '../../../../../custom-fetch.js';
+import { createApiFactoryAndRegisterActors } from '../../../../../override/vs/workbench/api/common/extHost.api.impl.js';
+import { AbstractExtHostExtensionService } from '../common/extHostExtensionService.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { RequireInterceptor } from '../common/extHostRequireInterceptor.js';
+import { ExtensionRuntime } from '../common/extHostTypes.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+class WorkerRequireInterceptor extends RequireInterceptor {
+    _installInterceptor() { }
+    getModule(request, parent) {
+        for (const alternativeModuleName of this._alternatives) {
+            const alternative = alternativeModuleName(request);
+            if (alternative) {
+                request = alternative;
+                break;
+            }
+        }
+        if (( (this._factories.has(request)))) {
+            return this._factories.get(request).load(request, parent, () => { throw new Error('CANNOT LOAD MODULE from here.'); });
+        }
+        return undefined;
+    }
+}
+class ExtHostExtensionService extends AbstractExtHostExtensionService {
+    constructor() {
+        super(...arguments);
+        this.extensionRuntime = ExtensionRuntime.Webworker;
+    }
+    async _beforeAlmostReadyToRunExtensions() {
+        const apiFactory = this._instaService.invokeFunction(createApiFactoryAndRegisterActors);
+        this._fakeModules = this._instaService.createInstance(WorkerRequireInterceptor, apiFactory, { mine: this._myRegistry, all: this._globalRegistry });
+        await this._fakeModules.install();
+        performance.mark('code/extHost/didInitAPI');
+        await this._waitForDebuggerAttachment();
+    }
+    _getEntryPoint(extensionDescription) {
+        return extensionDescription.browser;
+    }
+    async _loadCommonJSModule(extension, module, activationTimesBuilder) {
+        module = module.with({ path: ensureSuffix(module.path, '.js') });
+        const extensionId = extension?.identifier.value;
+        if (extensionId) {
+            performance.mark(`code/extHost/willFetchExtensionCode/${extensionId}`);
+        }
+        const browserUri = URI.revive(await this._mainThreadExtensionsProxy.$asBrowserUri(module));
+        const response = await fetch(( (browserUri.toString(true))));
+        if (extensionId) {
+            performance.mark(`code/extHost/didFetchExtensionCode/${extensionId}`);
+        }
+        if (response.status !== 200) {
+            throw new Error(response.statusText);
+        }
+        const source = await response.text();
+        const sourceURL = `${( ( module.toString(true)))}#vscode-extension`;
+        const fullSource = `${source}\n//# sourceURL=${sourceURL}`;
+        let initFn;
+        try {
+            initFn = ( (new Function('module', 'exports', 'require', fullSource)));
+        }
+        catch (err) {
+            if (extensionId) {
+                console.error(`Loading code for extension ${extensionId} failed: ${err.message}`);
+            }
+            else {
+                console.error(`Loading code failed: ${err.message}`);
+            }
+            console.error(`${( ( module.toString(true)))}${typeof err.line === 'number' ? ` line ${err.line}` : ''}${typeof err.column === 'number' ? ` column ${err.column}` : ''}`);
+            console.error(err);
+            throw err;
+        }
+        if (extension) {
+            await this._extHostLocalizationService.initializeLocalizedMessages(extension);
+        }
+        const _exports = {};
+        const _module = { exports: _exports };
+        const _require = (request) => {
+            const result = this._fakeModules.getModule(request, module);
+            if (result === undefined) {
+                throw new Error(`Cannot load module '${request}'`);
+            }
+            return result;
+        };
+        try {
+            activationTimesBuilder.codeLoadingStart();
+            if (extensionId) {
+                performance.mark(`code/extHost/willLoadExtensionCode/${extensionId}`);
+            }
+            initFn(_module, _exports, _require);
+            return (_module.exports !== _exports ? _module.exports : _exports);
+        }
+        finally {
+            if (extensionId) {
+                performance.mark(`code/extHost/didLoadExtensionCode/${extensionId}`);
+            }
+            activationTimesBuilder.codeLoadingStop();
+        }
+    }
+    async $setRemoteEnvironment(_env) {
+        return;
+    }
+    async _waitForDebuggerAttachment(waitTimeout = 5000) {
+        if (!this._initData.environment.isExtensionDevelopmentDebug) {
+            return;
+        }
+        const deadline = Date.now() + waitTimeout;
+        while (Date.now() < deadline && !('__jsDebugIsReady' in globalThis)) {
+            await timeout(10);
+        }
+    }
+}
+function ensureSuffix(path, suffix) {
+    return path.endsWith(suffix) ? path : path + suffix;
+}
+export { ExtHostExtensionService };

package/dist/vscode/vs/workbench/services/commands/common/commandService.js

@@ -0,0 +1,77 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+let CommandService = class CommandService extends Disposable {
+    constructor(_instantiationService, _extensionService, _logService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._extensionService = _extensionService;
+        this._logService = _logService;
+        this._extensionHostIsReady = false;
+        this._onWillExecuteCommand = this._register(( new Emitter()));
+        this.onWillExecuteCommand = this._onWillExecuteCommand.event;
+        this._onDidExecuteCommand = ( new Emitter());
+        this.onDidExecuteCommand = this._onDidExecuteCommand.event;
+        this._extensionService.whenInstalledExtensionsRegistered().then(value => this._extensionHostIsReady = value);
+        this._starActivation = null;
+    }
+    _activateStar() {
+        if (!this._starActivation) {
+            this._starActivation = Promise.race([
+                this._extensionService.activateByEvent(`*`),
+                timeout(30000)
+            ]);
+        }
+        return this._starActivation;
+    }
+    async executeCommand(id, ...args) {
+        this._logService.trace('CommandService#executeCommand', id);
+        const activationEvent = `onCommand:${id}`;
+        const commandIsRegistered = !!CommandsRegistry.getCommand(id);
+        if (commandIsRegistered) {
+            if (this._extensionService.activationEventIsDone(activationEvent)) {
+                return this._tryExecuteCommand(id, args);
+            }
+            if (!this._extensionHostIsReady) {
+                this._extensionService.activateByEvent(activationEvent);
+                return this._tryExecuteCommand(id, args);
+            }
+            await this._extensionService.activateByEvent(activationEvent);
+            return this._tryExecuteCommand(id, args);
+        }
+        await Promise.all([
+            this._extensionService.activateByEvent(activationEvent),
+            Promise.race([
+                this._activateStar(),
+                Event.toPromise(Event.filter(CommandsRegistry.onDidRegisterCommand, e => e === id))
+            ]),
+        ]);
+        return this._tryExecuteCommand(id, args);
+    }
+    _tryExecuteCommand(id, args) {
+        const command = CommandsRegistry.getCommand(id);
+        if (!command) {
+            return Promise.reject(( new Error(`command '${id}' not found`)));
+        }
+        try {
+            this._onWillExecuteCommand.fire({ commandId: id, args });
+            const result = this._instantiationService.invokeFunction(command.handler, ...args);
+            this._onDidExecuteCommand.fire({ commandId: id, args });
+            return Promise.resolve(result);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+};
+CommandService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, ILogService))
+], CommandService));
+export { CommandService };