@codingame/monaco-vscode-api 1.78.4 → 1.78.5

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

@@ -0,0 +1,93 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IExtensionService } from '../../services/extensions/common/extensions.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
+let MainThreadCommands = class MainThreadCommands {
+    constructor(extHostContext, _commandService, _extensionService) {
+        this._commandService = _commandService;
+        this._extensionService = _extensionService;
+        this._commandRegistrations = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostCommands));
+        this._generateCommandsDocumentationRegistration = CommandsRegistry.registerCommand('_generateCommandsDocumentation', () => this._generateCommandsDocumentation());
+    }
+    dispose() {
+        this._commandRegistrations.dispose();
+        this._generateCommandsDocumentationRegistration.dispose();
+    }
+    async _generateCommandsDocumentation() {
+        const result = await this._proxy.$getContributedCommandHandlerDescriptions();
+        const commands = CommandsRegistry.getCommands();
+        for (const [id, command] of commands) {
+            if (command.description) {
+                result[id] = command.description;
+            }
+        }
+        const all = [];
+        for (const id in result) {
+            all.push('`' + id + '` - ' + _generateMarkdown(result[id]));
+        }
+        console.log(all.join('\n'));
+    }
+    $registerCommand(id) {
+        this._commandRegistrations.set(id, CommandsRegistry.registerCommand(id, (accessor, ...args) => {
+            return this._proxy.$executeContributedCommand(id, ...args).then(result => {
+                return revive(result);
+            }, onUnexpectedExternalError);
+        }));
+    }
+    $unregisterCommand(id) {
+        this._commandRegistrations.deleteAndDispose(id);
+    }
+    $fireCommandActivationEvent(id) {
+        const activationEvent = `onCommand:${id}`;
+        if (!this._extensionService.activationEventIsDone(activationEvent)) {
+            this._extensionService.activateByEvent(activationEvent);
+        }
+    }
+    async $executeCommand(id, args, retry) {
+        if (args instanceof SerializableObjectWithBuffers) {
+            args = args.value;
+        }
+        for (let i = 0; i < args.length; i++) {
+            args[i] = revive(args[i]);
+        }
+        if (retry && args.length > 0 && !CommandsRegistry.getCommand(id)) {
+            await this._extensionService.activateByEvent(`onCommand:${id}`);
+            throw new Error('$executeCommand:retry');
+        }
+        return this._commandService.executeCommand(id, ...args);
+    }
+    $getCommands() {
+        return Promise.resolve([...( CommandsRegistry.getCommands().keys())]);
+    }
+};
+MainThreadCommands = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadCommands),
+    ( __param(1, ICommandService)),
+    ( __param(2, IExtensionService))
+], MainThreadCommands);
+function _generateMarkdown(description) {
+    if (typeof description === 'string') {
+        return description;
+    }
+    else {
+        const parts = [description.description];
+        parts.push('\n\n');
+        if (description.args) {
+            for (const arg of description.args) {
+                parts.push(`* _${arg.name}_ - ${arg.description || ''}\n`);
+            }
+        }
+        if (description.returns) {
+            parts.push(`* _(returns)_ - ${description.returns}`);
+        }
+        parts.push('\n\n');
+        return parts.join('');
+    }
+}
+export { MainThreadCommands };

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

@@ -0,0 +1,78 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { getScopes, Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { MainContext, ExtHostContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+let MainThreadConfiguration = class MainThreadConfiguration {
+    constructor(extHostContext, _workspaceContextService, configurationService, _environmentService) {
+        this._workspaceContextService = _workspaceContextService;
+        this.configurationService = configurationService;
+        this._environmentService = _environmentService;
+        const proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostConfiguration));
+        proxy.$initializeConfiguration(this._getConfigurationData());
+        this._configurationListener = configurationService.onDidChangeConfiguration(e => {
+            proxy.$acceptConfigurationChanged(this._getConfigurationData(), e.change);
+        });
+    }
+    _getConfigurationData() {
+        const configurationData = { ...(this.configurationService.getConfigurationData()), configurationScopes: [] };
+        if (!this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment) {
+            configurationData.configurationScopes = getScopes();
+        }
+        return configurationData;
+    }
+    dispose() {
+        this._configurationListener.dispose();
+    }
+    $updateConfigurationOption(target, key, value, overrides, scopeToLanguage) {
+        overrides = { resource: overrides?.resource ? URI.revive(overrides.resource) : undefined, overrideIdentifier: overrides?.overrideIdentifier };
+        return this.writeConfiguration(target, key, value, overrides, scopeToLanguage);
+    }
+    $removeConfigurationOption(target, key, overrides, scopeToLanguage) {
+        overrides = { resource: overrides?.resource ? URI.revive(overrides.resource) : undefined, overrideIdentifier: overrides?.overrideIdentifier };
+        return this.writeConfiguration(target, key, undefined, overrides, scopeToLanguage);
+    }
+    writeConfiguration(target, key, value, overrides, scopeToLanguage) {
+        target = target !== null && target !== undefined ? target : this.deriveConfigurationTarget(key, overrides);
+        const configurationValue = this.configurationService.inspect(key, overrides);
+        switch (target) {
+            case 8 :
+                return this._updateValue(key, value, target, configurationValue?.memory?.override, overrides, scopeToLanguage);
+            case 6 :
+                return this._updateValue(key, value, target, configurationValue?.workspaceFolder?.override, overrides, scopeToLanguage);
+            case 5 :
+                return this._updateValue(key, value, target, configurationValue?.workspace?.override, overrides, scopeToLanguage);
+            case 4 :
+                return this._updateValue(key, value, target, configurationValue?.userRemote?.override, overrides, scopeToLanguage);
+            default:
+                return this._updateValue(key, value, target, configurationValue?.userLocal?.override, overrides, scopeToLanguage);
+        }
+    }
+    _updateValue(key, value, configurationTarget, overriddenValue, overrides, scopeToLanguage) {
+        overrides = scopeToLanguage === true ? overrides
+            : scopeToLanguage === false ? { resource: overrides.resource }
+                : overrides.overrideIdentifier && overriddenValue !== undefined ? overrides
+                    : { resource: overrides.resource };
+        return this.configurationService.updateValue(key, value, overrides, configurationTarget, { donotNotifyError: true });
+    }
+    deriveConfigurationTarget(key, overrides) {
+        if (overrides.resource && this._workspaceContextService.getWorkbenchState() === 3 ) {
+            const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
+            if (configurationProperties[key] && ((configurationProperties[key].scope === 4  || configurationProperties[key].scope === 5) )) {
+                return 6 ;
+            }
+        }
+        return 5 ;
+    }
+};
+MainThreadConfiguration = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadConfiguration),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IEnvironmentService))
+], MainThreadConfiguration);
+export { MainThreadConfiguration };

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

@@ -0,0 +1,33 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { MainContext } from '../common/extHost.protocol.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { log } from '../../../base/common/console.js';
+import { logRemoteEntry, logRemoteEntryIfError } from '../../services/extensions/common/remoteConsoleUtil.js';
+import { parseExtensionDevOptions } from '../../services/extensions/common/extensionDevOptions.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+let MainThreadConsole = class MainThreadConsole {
+    constructor(_extHostContext, _environmentService, _logService) {
+        this._environmentService = _environmentService;
+        this._logService = _logService;
+        const devOpts = parseExtensionDevOptions(this._environmentService);
+        this._isExtensionDevTestFromCli = devOpts.isExtensionDevTestFromCli;
+    }
+    dispose() {
+    }
+    $logExtensionHostMessage(entry) {
+        if (this._isExtensionDevTestFromCli) {
+            logRemoteEntry(this._logService, entry);
+        }
+        else {
+            logRemoteEntryIfError(this._logService, entry, 'Extension Host');
+            log(entry, 'Extension Host');
+        }
+    }
+};
+MainThreadConsole = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadConsole),
+    ( __param(1, IEnvironmentService)),
+    ( __param(2, ILogService))
+], MainThreadConsole);
+export { MainThreadConsole };

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

@@ -0,0 +1,347 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IDebugService } from '../../contrib/debug/common/debug.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { AbstractDebugAdapter } from '../../contrib/debug/common/abstractDebugAdapter.js';
+import { isSessionAttach, convertToVSCPaths, convertToDAPaths } from '../../contrib/debug/common/debugUtils.js';
+import { ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
+let MainThreadDebugService = class MainThreadDebugService {
+    constructor(extHostContext, debugService) {
+        this.debugService = debugService;
+        this._toDispose = ( new DisposableStore());
+        this._debugAdaptersHandleCounter = 1;
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDebugService));
+        this._toDispose.add(debugService.onDidNewSession(session => {
+            this._proxy.$acceptDebugSessionStarted(this.getSessionDto(session));
+            this._toDispose.add(session.onDidChangeName(name => {
+                this._proxy.$acceptDebugSessionNameChanged(this.getSessionDto(session), name);
+            }));
+        }));
+        this._toDispose.add(debugService.onWillNewSession(session => {
+            this._toDispose.add(session.onDidCustomEvent(event => this._proxy.$acceptDebugSessionCustomEvent(this.getSessionDto(session), event)));
+        }));
+        this._toDispose.add(debugService.onDidEndSession(session => {
+            this._proxy.$acceptDebugSessionTerminated(this.getSessionDto(session));
+            this._sessions.delete(session.getId());
+        }));
+        this._toDispose.add(debugService.getViewModel().onDidFocusSession(session => {
+            this._proxy.$acceptDebugSessionActiveChanged(this.getSessionDto(session));
+        }));
+        this._debugAdapters = ( new Map());
+        this._debugConfigurationProviders = ( new Map());
+        this._debugAdapterDescriptorFactories = ( new Map());
+        this._sessions = ( new Set());
+    }
+    dispose() {
+        this._toDispose.dispose();
+    }
+    createDebugAdapter(session) {
+        const handle = this._debugAdaptersHandleCounter++;
+        const da = ( new ExtensionHostDebugAdapter(this, handle, this._proxy, session));
+        this._debugAdapters.set(handle, da);
+        return da;
+    }
+    substituteVariables(folder, config) {
+        return Promise.resolve(this._proxy.$substituteVariables(folder ? folder.uri : undefined, config));
+    }
+    runInTerminal(args, sessionId) {
+        return this._proxy.$runInTerminal(args, sessionId);
+    }
+    $registerDebugTypes(debugTypes) {
+        this._toDispose.add(this.debugService.getAdapterManager().registerDebugAdapterFactory(debugTypes, this));
+    }
+    $startBreakpointEvents() {
+        if (!this._breakpointEventsActive) {
+            this._breakpointEventsActive = true;
+            this._toDispose.add(this.debugService.getModel().onDidChangeBreakpoints(e => {
+                if (e && !e.sessionOnly) {
+                    const delta = {};
+                    if (e.added) {
+                        delta.added = this.convertToDto(e.added);
+                    }
+                    if (e.removed) {
+                        delta.removed = ( e.removed.map(x => x.getId()));
+                    }
+                    if (e.changed) {
+                        delta.changed = this.convertToDto(e.changed);
+                    }
+                    if (delta.added || delta.removed || delta.changed) {
+                        this._proxy.$acceptBreakpointsDelta(delta);
+                    }
+                }
+            }));
+            const bps = this.debugService.getModel().getBreakpoints();
+            const fbps = this.debugService.getModel().getFunctionBreakpoints();
+            const dbps = this.debugService.getModel().getDataBreakpoints();
+            if (bps.length > 0 || fbps.length > 0) {
+                this._proxy.$acceptBreakpointsDelta({
+                    added: this.convertToDto(bps).concat(this.convertToDto(fbps)).concat(this.convertToDto(dbps))
+                });
+            }
+        }
+    }
+    $registerBreakpoints(DTOs) {
+        for (const dto of DTOs) {
+            if (dto.type === 'sourceMulti') {
+                const rawbps = ( dto.lines.map(l => ({
+                    id: l.id,
+                    enabled: l.enabled,
+                    lineNumber: l.line + 1,
+                    column: l.character > 0 ? l.character + 1 : undefined,
+                    condition: l.condition,
+                    hitCondition: l.hitCondition,
+                    logMessage: l.logMessage
+                })));
+                this.debugService.addBreakpoints(URI.revive(dto.uri), rawbps);
+            }
+            else if (dto.type === 'function') {
+                this.debugService.addFunctionBreakpoint(dto.functionName, dto.id);
+            }
+            else if (dto.type === 'data') {
+                this.debugService.addDataBreakpoint(dto.label, dto.dataId, dto.canPersist, dto.accessTypes, dto.accessType);
+            }
+        }
+        return Promise.resolve();
+    }
+    $unregisterBreakpoints(breakpointIds, functionBreakpointIds, dataBreakpointIds) {
+        breakpointIds.forEach(id => this.debugService.removeBreakpoints(id));
+        functionBreakpointIds.forEach(id => this.debugService.removeFunctionBreakpoints(id));
+        dataBreakpointIds.forEach(id => this.debugService.removeDataBreakpoints(id));
+        return Promise.resolve();
+    }
+    $registerDebugConfigurationProvider(debugType, providerTriggerKind, hasProvide, hasResolve, hasResolve2, handle) {
+        const provider = {
+            type: debugType,
+            triggerKind: providerTriggerKind
+        };
+        if (hasProvide) {
+            provider.provideDebugConfigurations = (folder, token) => {
+                return this._proxy.$provideDebugConfigurations(handle, folder, token);
+            };
+        }
+        if (hasResolve) {
+            provider.resolveDebugConfiguration = (folder, config, token) => {
+                return this._proxy.$resolveDebugConfiguration(handle, folder, config, token);
+            };
+        }
+        if (hasResolve2) {
+            provider.resolveDebugConfigurationWithSubstitutedVariables = (folder, config, token) => {
+                return this._proxy.$resolveDebugConfigurationWithSubstitutedVariables(handle, folder, config, token);
+            };
+        }
+        this._debugConfigurationProviders.set(handle, provider);
+        this._toDispose.add(this.debugService.getConfigurationManager().registerDebugConfigurationProvider(provider));
+        return Promise.resolve(undefined);
+    }
+    $unregisterDebugConfigurationProvider(handle) {
+        const provider = this._debugConfigurationProviders.get(handle);
+        if (provider) {
+            this._debugConfigurationProviders.delete(handle);
+            this.debugService.getConfigurationManager().unregisterDebugConfigurationProvider(provider);
+        }
+    }
+    $registerDebugAdapterDescriptorFactory(debugType, handle) {
+        const provider = {
+            type: debugType,
+            createDebugAdapterDescriptor: session => {
+                return Promise.resolve(this._proxy.$provideDebugAdapter(handle, this.getSessionDto(session)));
+            }
+        };
+        this._debugAdapterDescriptorFactories.set(handle, provider);
+        this._toDispose.add(this.debugService.getAdapterManager().registerDebugAdapterDescriptorFactory(provider));
+        return Promise.resolve(undefined);
+    }
+    $unregisterDebugAdapterDescriptorFactory(handle) {
+        const provider = this._debugAdapterDescriptorFactories.get(handle);
+        if (provider) {
+            this._debugAdapterDescriptorFactories.delete(handle);
+            this.debugService.getAdapterManager().unregisterDebugAdapterDescriptorFactory(provider);
+        }
+    }
+    getSession(sessionId) {
+        if (sessionId) {
+            return this.debugService.getModel().getSession(sessionId, true);
+        }
+        return undefined;
+    }
+    async $startDebugging(folder, nameOrConfig, options) {
+        const folderUri = folder ? URI.revive(folder) : undefined;
+        const launch = this.debugService.getConfigurationManager().getLaunch(folderUri);
+        const parentSession = this.getSession(options.parentSessionID);
+        const saveBeforeStart = typeof options.suppressSaveBeforeStart === 'boolean' ? !options.suppressSaveBeforeStart : undefined;
+        const debugOptions = {
+            noDebug: options.noDebug,
+            parentSession,
+            lifecycleManagedByParent: options.lifecycleManagedByParent,
+            repl: options.repl,
+            compact: options.compact,
+            compoundRoot: parentSession?.compoundRoot,
+            saveBeforeRestart: saveBeforeStart,
+            suppressDebugStatusbar: options.suppressDebugStatusbar,
+            suppressDebugToolbar: options.suppressDebugToolbar,
+            suppressDebugView: options.suppressDebugView,
+        };
+        try {
+            return this.debugService.startDebugging(launch, nameOrConfig, debugOptions, saveBeforeStart);
+        }
+        catch (err) {
+            throw new ErrorNoTelemetry(err && err.message ? err.message : 'cannot start debugging');
+        }
+    }
+    $setDebugSessionName(sessionId, name) {
+        const session = this.debugService.getModel().getSession(sessionId);
+        session?.setName(name);
+    }
+    $customDebugAdapterRequest(sessionId, request, args) {
+        const session = this.debugService.getModel().getSession(sessionId, true);
+        if (session) {
+            return session.customRequest(request, args).then(response => {
+                if (response && response.success) {
+                    return response.body;
+                }
+                else {
+                    return Promise.reject(( new ErrorNoTelemetry(response ? response.message : 'custom request failed')));
+                }
+            });
+        }
+        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
+    }
+    $getDebugProtocolBreakpoint(sessionId, breakpoinId) {
+        const session = this.debugService.getModel().getSession(sessionId, true);
+        if (session) {
+            return Promise.resolve(session.getDebugProtocolBreakpoint(breakpoinId));
+        }
+        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
+    }
+    $stopDebugging(sessionId) {
+        if (sessionId) {
+            const session = this.debugService.getModel().getSession(sessionId, true);
+            if (session) {
+                return this.debugService.stopSession(session, isSessionAttach(session));
+            }
+        }
+        else {
+            return this.debugService.stopSession(undefined);
+        }
+        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
+    }
+    $appendDebugConsole(value) {
+        const session = this.debugService.getViewModel().focusedSession;
+        session?.appendToRepl({ output: value, sev: Severity.Warning });
+    }
+    $acceptDAMessage(handle, message) {
+        this.getDebugAdapter(handle).acceptMessage(convertToVSCPaths(message, false));
+    }
+    $acceptDAError(handle, name, message, stack) {
+        this.getDebugAdapter(handle).fireError(handle, ( new Error(`${name}: ${message}\n${stack}`)));
+    }
+    $acceptDAExit(handle, code, signal) {
+        this.getDebugAdapter(handle).fireExit(handle, code, signal);
+    }
+    getDebugAdapter(handle) {
+        const adapter = this._debugAdapters.get(handle);
+        if (!adapter) {
+            throw new Error('Invalid debug adapter');
+        }
+        return adapter;
+    }
+    $sessionCached(sessionID) {
+        this._sessions.add(sessionID);
+    }
+    getSessionDto(session) {
+        if (session) {
+            const sessionID = session.getId();
+            if (this._sessions.has(sessionID)) {
+                return sessionID;
+            }
+            else {
+                return {
+                    id: sessionID,
+                    type: session.configuration.type,
+                    name: session.name,
+                    folderUri: session.root ? session.root.uri : undefined,
+                    configuration: session.configuration,
+                    parent: session.parentSession?.getId(),
+                };
+            }
+        }
+        return undefined;
+    }
+    convertToDto(bps) {
+        return ( bps.map(bp => {
+            if ('name' in bp) {
+                const fbp = bp;
+                return {
+                    type: 'function',
+                    id: fbp.getId(),
+                    enabled: fbp.enabled,
+                    condition: fbp.condition,
+                    hitCondition: fbp.hitCondition,
+                    logMessage: fbp.logMessage,
+                    functionName: fbp.name
+                };
+            }
+            else if ('dataId' in bp) {
+                const dbp = bp;
+                return {
+                    type: 'data',
+                    id: dbp.getId(),
+                    dataId: dbp.dataId,
+                    enabled: dbp.enabled,
+                    condition: dbp.condition,
+                    hitCondition: dbp.hitCondition,
+                    logMessage: dbp.logMessage,
+                    label: dbp.description,
+                    canPersist: dbp.canPersist
+                };
+            }
+            else {
+                const sbp = bp;
+                return {
+                    type: 'source',
+                    id: sbp.getId(),
+                    enabled: sbp.enabled,
+                    condition: sbp.condition,
+                    hitCondition: sbp.hitCondition,
+                    logMessage: sbp.logMessage,
+                    uri: sbp.uri,
+                    line: sbp.lineNumber > 0 ? sbp.lineNumber - 1 : 0,
+                    character: (typeof sbp.column === 'number' && sbp.column > 0) ? sbp.column - 1 : 0,
+                };
+            }
+        }));
+    }
+};
+MainThreadDebugService = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadDebugService),
+    ( __param(1, IDebugService))
+], MainThreadDebugService);
+class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
+    constructor(_ds, _handle, _proxy, _session) {
+        super();
+        this._ds = _ds;
+        this._handle = _handle;
+        this._proxy = _proxy;
+        this._session = _session;
+    }
+    fireError(handle, err) {
+        this._onError.fire(err);
+    }
+    fireExit(handle, code, signal) {
+        this._onExit.fire(code);
+    }
+    startSession() {
+        return Promise.resolve(this._proxy.$startDASession(this._handle, this._ds.getSessionDto(this._session)));
+    }
+    sendMessage(message) {
+        this._proxy.$sendDAMessage(this._handle, convertToDAPaths(message, true));
+    }
+    async stopSession() {
+        await this.cancelPendingRequests();
+        return Promise.resolve(this._proxy.$stopDASession(this._handle));
+    }
+}
+export { MainThreadDebugService };

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

@@ -0,0 +1,67 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+let MainThreadDiagnostics = class MainThreadDiagnostics {
+    constructor(extHostContext, _markerService, _uriIdentService) {
+        this._markerService = _markerService;
+        this._uriIdentService = _uriIdentService;
+        this._activeOwners = ( new Set());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDiagnostics));
+        this._markerListener = this._markerService.onMarkerChanged(this._forwardMarkers, this);
+    }
+    dispose() {
+        this._markerListener.dispose();
+        this._activeOwners.forEach(owner => this._markerService.changeAll(owner, []));
+        this._activeOwners.clear();
+    }
+    _forwardMarkers(resources) {
+        const data = [];
+        for (const resource of resources) {
+            const allMarkerData = this._markerService.read({ resource });
+            if (allMarkerData.length === 0) {
+                data.push([resource, []]);
+            }
+            else {
+                const forgeinMarkerData = allMarkerData.filter(marker => !this._activeOwners.has(marker.owner));
+                if (forgeinMarkerData.length > 0) {
+                    data.push([resource, forgeinMarkerData]);
+                }
+            }
+        }
+        if (data.length > 0) {
+            this._proxy.$acceptMarkersChange(data);
+        }
+    }
+    $changeMany(owner, entries) {
+        for (const entry of entries) {
+            const [uri, markers] = entry;
+            if (markers) {
+                for (const marker of markers) {
+                    if (marker.relatedInformation) {
+                        for (const relatedInformation of marker.relatedInformation) {
+                            relatedInformation.resource = URI.revive(relatedInformation.resource);
+                        }
+                    }
+                    if (marker.code && typeof marker.code !== 'string') {
+                        marker.code.target = URI.revive(marker.code.target);
+                    }
+                }
+            }
+            this._markerService.changeOne(owner, this._uriIdentService.asCanonicalUri(URI.revive(uri)), markers);
+        }
+        this._activeOwners.add(owner);
+    }
+    $clear(owner) {
+        this._markerService.changeAll(owner, []);
+        this._activeOwners.delete(owner);
+    }
+};
+MainThreadDiagnostics = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadDiagnostics),
+    ( __param(1, IMarkerService)),
+    ( __param(2, IUriIdentityService))
+], MainThreadDiagnostics);
+export { MainThreadDiagnostics };