@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

package/vscode/src/vs/workbench/contrib/debug/browser/debugSession.js

@@ -1,1142 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as aria from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
-import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { RunOnceScheduler, Queue } from 'monaco-editor/esm/vs/base/common/async.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
-import { DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
-import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
-import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { ITelemetryService, ICustomEndpointTelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { RawDebugSession } from './rawDebugSession.js';
-import { IDebugService, VIEWLET_ID } from '../common/debug.js';
-import { MemoryRegion, ExpressionContainer, Thread } from '../common/debugModel.js';
-import { Source } from '../common/debugSource.js';
-import { filterExceptionsFromTelemetry } from '../common/debugUtils.js';
-import { ReplModel } from '../common/replModel.js';
-import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
-import { IHostService } from '../../../services/host/browser/host.js';
-import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
-import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
-let DebugSession = class DebugSession {
-    constructor(id, _configuration, root, model, options, debugService, telemetryService, hostService, configurationService, paneCompositeService, workspaceContextService, productService, notificationService, lifecycleService, uriIdentityService, instantiationService, customEndpointTelemetryService, workbenchEnvironmentService, logService) {
-        this.id = id;
-        this._configuration = _configuration;
-        this.root = root;
-        this.model = model;
-        this.debugService = debugService;
-        this.telemetryService = telemetryService;
-        this.hostService = hostService;
-        this.configurationService = configurationService;
-        this.paneCompositeService = paneCompositeService;
-        this.workspaceContextService = workspaceContextService;
-        this.productService = productService;
-        this.notificationService = notificationService;
-        this.uriIdentityService = uriIdentityService;
-        this.instantiationService = instantiationService;
-        this.customEndpointTelemetryService = customEndpointTelemetryService;
-        this.workbenchEnvironmentService = workbenchEnvironmentService;
-        this.logService = logService;
-        this.initialized = false;
-        this.sources = ( new Map());
-        this.threads = ( new Map());
-        this.threadIds = [];
-        this.cancellationMap = ( new Map());
-        this.rawListeners = ( new DisposableStore());
-        this.stoppedDetails = [];
-        this._onDidChangeState = ( new Emitter());
-        this._onDidEndAdapter = ( new Emitter());
-        this._onDidLoadedSource = ( new Emitter());
-        this._onDidCustomEvent = ( new Emitter());
-        this._onDidProgressStart = ( new Emitter());
-        this._onDidProgressUpdate = ( new Emitter());
-        this._onDidProgressEnd = ( new Emitter());
-        this._onDidInvalidMemory = ( new Emitter());
-        this._onDidChangeREPLElements = ( new Emitter());
-        this._onDidChangeName = ( new Emitter());
-        this._options = options || {};
-        this.parentSession = this._options.parentSession;
-        if (this.hasSeparateRepl()) {
-            this.repl = ( new ReplModel(this.configurationService));
-        }
-        else {
-            this.repl = this.parentSession.repl;
-        }
-        const toDispose = this.rawListeners.add(( new DisposableStore()));
-        const replListener = toDispose.add(( new MutableDisposable()));
-        replListener.value = this.repl.onDidChangeElements(() => this._onDidChangeREPLElements.fire());
-        if (lifecycleService) {
-            toDispose.add(lifecycleService.onWillShutdown(() => this.shutdown()));
-        }
-        const compoundRoot = this._options.compoundRoot;
-        if (compoundRoot) {
-            toDispose.add(compoundRoot.onDidSessionStop(() => this.terminate()));
-        }
-        this.passFocusScheduler = ( new RunOnceScheduler(() => {
-            if (( this.debugService.getModel().getSessions().some(s => s.state === 2 )) || ( this.getAllThreads().some(t => t.stopped))) {
-                if (typeof this.lastContinuedThreadId === 'number') {
-                    const thread = this.debugService.getViewModel().focusedThread;
-                    if (thread && thread.threadId === this.lastContinuedThreadId && !thread.stopped) {
-                        const toFocusThreadId = this.getStoppedDetails()?.threadId;
-                        const toFocusThread = typeof toFocusThreadId === 'number' ? this.getThread(toFocusThreadId) : undefined;
-                        this.debugService.focusStackFrame(undefined, toFocusThread);
-                    }
-                }
-                else {
-                    const session = this.debugService.getViewModel().focusedSession;
-                    if (session && session.getId() === this.getId() && session.state !== 2 ) {
-                        this.debugService.focusStackFrame(undefined);
-                    }
-                }
-            }
-        }, 800));
-        const parent = this._options.parentSession;
-        if (parent) {
-            toDispose.add(parent.onDidEndAdapter(() => {
-                if (!this.hasSeparateRepl() && this.raw?.isInShutdown === false) {
-                    this.repl = this.repl.clone();
-                    replListener.value = this.repl.onDidChangeElements(() => this._onDidChangeREPLElements.fire());
-                    this.parentSession = undefined;
-                }
-            }));
-        }
-    }
-    getId() {
-        return this.id;
-    }
-    setSubId(subId) {
-        this._subId = subId;
-    }
-    getMemory(memoryReference) {
-        return ( new MemoryRegion(memoryReference, this));
-    }
-    get subId() {
-        return this._subId;
-    }
-    get configuration() {
-        return this._configuration.resolved;
-    }
-    get unresolvedConfiguration() {
-        return this._configuration.unresolved;
-    }
-    get lifecycleManagedByParent() {
-        return !!this._options.lifecycleManagedByParent;
-    }
-    get compact() {
-        return !!this._options.compact;
-    }
-    get saveBeforeRestart() {
-        return this._options.saveBeforeRestart ?? !this._options?.parentSession;
-    }
-    get compoundRoot() {
-        return this._options.compoundRoot;
-    }
-    get suppressDebugStatusbar() {
-        return this._options.suppressDebugStatusbar ?? false;
-    }
-    get suppressDebugToolbar() {
-        return this._options.suppressDebugToolbar ?? false;
-    }
-    get suppressDebugView() {
-        return this._options.suppressDebugView ?? false;
-    }
-    get autoExpandLazyVariables() {
-        return this.configurationService.getValue('debug').autoExpandLazyVariables;
-    }
-    setConfiguration(configuration) {
-        this._configuration = configuration;
-    }
-    getLabel() {
-        const includeRoot = this.workspaceContextService.getWorkspace().folders.length > 1;
-        return includeRoot && this.root ? `${this.name} (${resources.basenameOrAuthority(this.root.uri)})` : this.name;
-    }
-    setName(name) {
-        this._name = name;
-        this._onDidChangeName.fire(name);
-    }
-    get name() {
-        return this._name || this.configuration.name;
-    }
-    get state() {
-        if (!this.initialized) {
-            return 1 ;
-        }
-        if (!this.raw) {
-            return 0 ;
-        }
-        const focusedThread = this.debugService.getViewModel().focusedThread;
-        if (focusedThread && focusedThread.session === this) {
-            return focusedThread.stopped ? 2  : 3 ;
-        }
-        if (( this.getAllThreads().some(t => t.stopped))) {
-            return 2 ;
-        }
-        return 3 ;
-    }
-    get capabilities() {
-        return this.raw ? this.raw.capabilities : Object.create(null);
-    }
-    get onDidChangeState() {
-        return this._onDidChangeState.event;
-    }
-    get onDidEndAdapter() {
-        return this._onDidEndAdapter.event;
-    }
-    get onDidChangeReplElements() {
-        return this._onDidChangeREPLElements.event;
-    }
-    get onDidChangeName() {
-        return this._onDidChangeName.event;
-    }
-    get onDidCustomEvent() {
-        return this._onDidCustomEvent.event;
-    }
-    get onDidLoadedSource() {
-        return this._onDidLoadedSource.event;
-    }
-    get onDidProgressStart() {
-        return this._onDidProgressStart.event;
-    }
-    get onDidProgressUpdate() {
-        return this._onDidProgressUpdate.event;
-    }
-    get onDidProgressEnd() {
-        return this._onDidProgressEnd.event;
-    }
-    get onDidInvalidateMemory() {
-        return this._onDidInvalidMemory.event;
-    }
-    async initialize(dbgr) {
-        if (this.raw) {
-            await this.shutdown();
-        }
-        try {
-            const debugAdapter = await dbgr.createDebugAdapter(this);
-            this.raw = this.instantiationService.createInstance(RawDebugSession, debugAdapter, dbgr, this.id, this.configuration.name);
-            await this.raw.start();
-            this.registerListeners();
-            await this.raw.initialize({
-                clientID: 'vscode',
-                clientName: this.productService.nameLong,
-                adapterID: this.configuration.type,
-                pathFormat: 'path',
-                linesStartAt1: true,
-                columnsStartAt1: true,
-                supportsVariableType: true,
-                supportsVariablePaging: true,
-                supportsRunInTerminalRequest: true,
-                locale: platform.language,
-                supportsProgressReporting: true,
-                supportsInvalidatedEvent: true,
-                supportsMemoryReferences: true,
-                supportsArgsCanBeInterpretedByShell: true,
-                supportsMemoryEvent: true,
-                supportsStartDebuggingRequest: true
-            });
-            this.initialized = true;
-            this._onDidChangeState.fire();
-            this.debugService.setExceptionBreakpointsForSession(this, (this.raw && this.raw.capabilities.exceptionBreakpointFilters) || []);
-        }
-        catch (err) {
-            this.initialized = true;
-            this._onDidChangeState.fire();
-            await this.shutdown();
-            throw err;
-        }
-    }
-    async launchOrAttach(config) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'launch or attach'));
-        }
-        if (this.parentSession && this.parentSession.state === 0 ) {
-            throw canceled();
-        }
-        config.__sessionId = this.getId();
-        try {
-            await this.raw.launchOrAttach(config);
-        }
-        catch (err) {
-            this.shutdown();
-            throw err;
-        }
-    }
-    async terminate(restart = false) {
-        if (!this.raw) {
-            this.onDidExitAdapter();
-        }
-        this.cancelAllRequests();
-        if (this._options.lifecycleManagedByParent && this.parentSession) {
-            await this.parentSession.terminate(restart);
-        }
-        else if (this.raw) {
-            if (this.raw.capabilities.supportsTerminateRequest && this._configuration.resolved.request === 'launch') {
-                await this.raw.terminate(restart);
-            }
-            else {
-                await this.raw.disconnect({ restart, terminateDebuggee: true });
-            }
-        }
-        if (!restart) {
-            this._options.compoundRoot?.sessionStopped();
-        }
-    }
-    async disconnect(restart = false, suspend = false) {
-        if (!this.raw) {
-            this.onDidExitAdapter();
-        }
-        this.cancelAllRequests();
-        if (this._options.lifecycleManagedByParent && this.parentSession) {
-            await this.parentSession.disconnect(restart, suspend);
-        }
-        else if (this.raw) {
-            await this.raw.disconnect({ restart, terminateDebuggee: false, suspendDebuggee: suspend });
-        }
-        if (!restart) {
-            this._options.compoundRoot?.sessionStopped();
-        }
-    }
-    async restart() {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'restart'));
-        }
-        this.cancelAllRequests();
-        if (this._options.lifecycleManagedByParent && this.parentSession) {
-            await this.parentSession.restart();
-        }
-        else {
-            await this.raw.restart({ arguments: this.configuration });
-        }
-    }
-    async sendBreakpoints(modelUri, breakpointsToSend, sourceModified) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'breakpoints'));
-        }
-        if (!this.raw.readyForBreakpoints) {
-            return Promise.resolve(undefined);
-        }
-        const rawSource = this.getRawSource(modelUri);
-        if (breakpointsToSend.length && !rawSource.adapterData) {
-            rawSource.adapterData = breakpointsToSend[0].adapterData;
-        }
-        if (rawSource.path) {
-            rawSource.path = normalizeDriveLetter(rawSource.path);
-        }
-        const response = await this.raw.setBreakpoints({
-            source: rawSource,
-            lines: ( breakpointsToSend.map(bp => bp.sessionAgnosticData.lineNumber)),
-            breakpoints: ( breakpointsToSend.map(
-                bp => ({ line: bp.sessionAgnosticData.lineNumber, column: bp.sessionAgnosticData.column, condition: bp.condition, hitCondition: bp.hitCondition, logMessage: bp.logMessage })
-            )),
-            sourceModified
-        });
-        if (response && response.body) {
-            const data = ( new Map());
-            for (let i = 0; i < breakpointsToSend.length; i++) {
-                data.set(breakpointsToSend[i].getId(), response.body.breakpoints[i]);
-            }
-            this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
-        }
-    }
-    async sendFunctionBreakpoints(fbpts) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'function breakpoints'));
-        }
-        if (this.raw.readyForBreakpoints) {
-            const response = await this.raw.setFunctionBreakpoints({ breakpoints: fbpts });
-            if (response && response.body) {
-                const data = ( new Map());
-                for (let i = 0; i < fbpts.length; i++) {
-                    data.set(fbpts[i].getId(), response.body.breakpoints[i]);
-                }
-                this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
-            }
-        }
-    }
-    async sendExceptionBreakpoints(exbpts) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'exception breakpoints'));
-        }
-        if (this.raw.readyForBreakpoints) {
-            const args = this.capabilities.supportsExceptionFilterOptions ? {
-                filters: [],
-                filterOptions: ( exbpts.map(exb => {
-                    if (exb.condition) {
-                        return { filterId: exb.filter, condition: exb.condition };
-                    }
-                    return { filterId: exb.filter };
-                }))
-            } : { filters: ( exbpts.map(exb => exb.filter)) };
-            const response = await this.raw.setExceptionBreakpoints(args);
-            if (response && response.body && response.body.breakpoints) {
-                const data = ( new Map());
-                for (let i = 0; i < exbpts.length; i++) {
-                    data.set(exbpts[i].getId(), response.body.breakpoints[i]);
-                }
-                this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
-            }
-        }
-    }
-    async dataBreakpointInfo(name, variablesReference) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'data breakpoints info'));
-        }
-        if (!this.raw.readyForBreakpoints) {
-            throw new Error(localize('sessionNotReadyForBreakpoints', "Session is not ready for breakpoints"));
-        }
-        const response = await this.raw.dataBreakpointInfo({ name, variablesReference });
-        return response?.body;
-    }
-    async sendDataBreakpoints(dataBreakpoints) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'data breakpoints'));
-        }
-        if (this.raw.readyForBreakpoints) {
-            const response = await this.raw.setDataBreakpoints({ breakpoints: dataBreakpoints });
-            if (response && response.body) {
-                const data = ( new Map());
-                for (let i = 0; i < dataBreakpoints.length; i++) {
-                    data.set(dataBreakpoints[i].getId(), response.body.breakpoints[i]);
-                }
-                this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
-            }
-        }
-    }
-    async sendInstructionBreakpoints(instructionBreakpoints) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'instruction breakpoints'));
-        }
-        if (this.raw.readyForBreakpoints) {
-            const response = await this.raw.setInstructionBreakpoints({ breakpoints: instructionBreakpoints });
-            if (response && response.body) {
-                const data = ( new Map());
-                for (let i = 0; i < instructionBreakpoints.length; i++) {
-                    data.set(instructionBreakpoints[i].getId(), response.body.breakpoints[i]);
-                }
-                this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
-            }
-        }
-    }
-    async breakpointsLocations(uri, lineNumber) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'breakpoints locations'));
-        }
-        const source = this.getRawSource(uri);
-        const response = await this.raw.breakpointLocations({ source, line: lineNumber });
-        if (!response || !response.body || !response.body.breakpoints) {
-            return [];
-        }
-        const positions = ( response.body.breakpoints.map(bp => ({ lineNumber: bp.line, column: bp.column || 1 })));
-        return distinct(positions, p => `${p.lineNumber}:${p.column}`);
-    }
-    getDebugProtocolBreakpoint(breakpointId) {
-        return this.model.getDebugProtocolBreakpoint(breakpointId, this.getId());
-    }
-    customRequest(request, args) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", request));
-        }
-        return this.raw.custom(request, args);
-    }
-    stackTrace(threadId, startFrame, levels, token) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'stackTrace'));
-        }
-        const sessionToken = this.getNewCancellationToken(threadId, token);
-        return this.raw.stackTrace({ threadId, startFrame, levels }, sessionToken);
-    }
-    async exceptionInfo(threadId) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'exceptionInfo'));
-        }
-        const response = await this.raw.exceptionInfo({ threadId });
-        if (response) {
-            return {
-                id: response.body.exceptionId,
-                description: response.body.description,
-                breakMode: response.body.breakMode,
-                details: response.body.details
-            };
-        }
-        return undefined;
-    }
-    scopes(frameId, threadId) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'scopes'));
-        }
-        const token = this.getNewCancellationToken(threadId);
-        return this.raw.scopes({ frameId }, token);
-    }
-    variables(variablesReference, threadId, filter, start, count) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'variables'));
-        }
-        const token = threadId ? this.getNewCancellationToken(threadId) : undefined;
-        return this.raw.variables({ variablesReference, filter, start, count }, token);
-    }
-    evaluate(expression, frameId, context) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'evaluate'));
-        }
-        return this.raw.evaluate({ expression, frameId, context });
-    }
-    async restartFrame(frameId, threadId) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'restartFrame'));
-        }
-        await this.raw.restartFrame({ frameId }, threadId);
-    }
-    setLastSteppingGranularity(threadId, granularity) {
-        const thread = this.getThread(threadId);
-        if (thread) {
-            thread.lastSteppingGranularity = granularity;
-        }
-    }
-    async next(threadId, granularity) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'next'));
-        }
-        this.setLastSteppingGranularity(threadId, granularity);
-        await this.raw.next({ threadId, granularity });
-    }
-    async stepIn(threadId, targetId, granularity) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'stepIn'));
-        }
-        this.setLastSteppingGranularity(threadId, granularity);
-        await this.raw.stepIn({ threadId, targetId, granularity });
-    }
-    async stepOut(threadId, granularity) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'stepOut'));
-        }
-        this.setLastSteppingGranularity(threadId, granularity);
-        await this.raw.stepOut({ threadId, granularity });
-    }
-    async stepBack(threadId, granularity) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'stepBack'));
-        }
-        this.setLastSteppingGranularity(threadId, granularity);
-        await this.raw.stepBack({ threadId, granularity });
-    }
-    async continue(threadId) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'continue'));
-        }
-        await this.raw.continue({ threadId });
-    }
-    async reverseContinue(threadId) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'reverse continue'));
-        }
-        await this.raw.reverseContinue({ threadId });
-    }
-    async pause(threadId) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'pause'));
-        }
-        await this.raw.pause({ threadId });
-    }
-    async terminateThreads(threadIds) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'terminateThreads'));
-        }
-        await this.raw.terminateThreads({ threadIds });
-    }
-    setVariable(variablesReference, name, value) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'setVariable'));
-        }
-        return this.raw.setVariable({ variablesReference, name, value });
-    }
-    setExpression(frameId, expression, value) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'setExpression'));
-        }
-        return this.raw.setExpression({ expression, value, frameId });
-    }
-    gotoTargets(source, line, column) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'gotoTargets'));
-        }
-        return this.raw.gotoTargets({ source, line, column });
-    }
-    goto(threadId, targetId) {
-        if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'goto'));
-        }
-        return this.raw.goto({ threadId, targetId });
-    }
-    loadSource(resource) {
-        if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'loadSource'
-            )))));
-        }
-        const source = this.getSourceForUri(resource);
-        let rawSource;
-        if (source) {
-            rawSource = source.raw;
-        }
-        else {
-            const data = Source.getEncodedDebugData(resource);
-            rawSource = { path: data.path, sourceReference: data.sourceReference };
-        }
-        return this.raw.source({ sourceReference: rawSource.sourceReference || 0, source: rawSource });
-    }
-    async getLoadedSources() {
-        if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'getLoadedSources'
-            )))));
-        }
-        const response = await this.raw.loadedSources({});
-        if (response && response.body && response.body.sources) {
-            return ( response.body.sources.map(src => this.getSource(src)));
-        }
-        else {
-            return [];
-        }
-    }
-    async completions(frameId, threadId, text, position, overwriteBefore, token) {
-        if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'completions'
-            )))));
-        }
-        const sessionCancelationToken = this.getNewCancellationToken(threadId, token);
-        return this.raw.completions({
-            frameId,
-            text,
-            column: position.column,
-            line: position.lineNumber,
-        }, sessionCancelationToken);
-    }
-    async stepInTargets(frameId) {
-        if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'stepInTargets'
-            )))));
-        }
-        const response = await this.raw.stepInTargets({ frameId });
-        return response?.body.targets;
-    }
-    async cancel(progressId) {
-        if (!this.raw) {
-            return Promise.reject(( new Error(( localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'cancel')))));
-        }
-        return this.raw.cancel({ progressId });
-    }
-    async disassemble(memoryReference, offset, instructionOffset, instructionCount) {
-        if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'disassemble'
-            )))));
-        }
-        const response = await this.raw.disassemble({ memoryReference, offset, instructionOffset, instructionCount, resolveSymbols: true });
-        return response?.body?.instructions;
-    }
-    readMemory(memoryReference, offset, count) {
-        if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'readMemory'
-            )))));
-        }
-        return this.raw.readMemory({ count, memoryReference, offset });
-    }
-    writeMemory(memoryReference, offset, data, allowPartial) {
-        if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'disassemble'
-            )))));
-        }
-        return this.raw.writeMemory({ memoryReference, offset, allowPartial, data });
-    }
-    getThread(threadId) {
-        return this.threads.get(threadId);
-    }
-    getAllThreads() {
-        const result = [];
-        this.threadIds.forEach((threadId) => {
-            const thread = this.threads.get(threadId);
-            if (thread) {
-                result.push(thread);
-            }
-        });
-        return result;
-    }
-    clearThreads(removeThreads, reference = undefined) {
-        if (reference !== undefined && reference !== null) {
-            const thread = this.threads.get(reference);
-            if (thread) {
-                thread.clearCallStack();
-                thread.stoppedDetails = undefined;
-                thread.stopped = false;
-                if (removeThreads) {
-                    this.threads.delete(reference);
-                }
-            }
-        }
-        else {
-            this.threads.forEach(thread => {
-                thread.clearCallStack();
-                thread.stoppedDetails = undefined;
-                thread.stopped = false;
-            });
-            if (removeThreads) {
-                this.threads.clear();
-                this.threadIds = [];
-                ExpressionContainer.allValues.clear();
-            }
-        }
-    }
-    getStoppedDetails() {
-        return this.stoppedDetails.length >= 1 ? this.stoppedDetails[0] : undefined;
-    }
-    rawUpdate(data) {
-        this.threadIds = [];
-        data.threads.forEach(thread => {
-            this.threadIds.push(thread.id);
-            if (!( this.threads.has(thread.id))) {
-                this.threads.set(thread.id, ( new Thread(this, thread.name, thread.id)));
-            }
-            else if (thread.name) {
-                const oldThread = this.threads.get(thread.id);
-                if (oldThread) {
-                    oldThread.name = thread.name;
-                }
-            }
-        });
-        this.threads.forEach(t => {
-            if (this.threadIds.indexOf(t.threadId) === -1) {
-                this.threads.delete(t.threadId);
-            }
-        });
-        const stoppedDetails = data.stoppedDetails;
-        if (stoppedDetails) {
-            if (stoppedDetails.allThreadsStopped) {
-                this.threads.forEach(thread => {
-                    thread.stoppedDetails = thread.threadId === stoppedDetails.threadId ? stoppedDetails : { reason: thread.stoppedDetails?.reason };
-                    thread.stopped = true;
-                    thread.clearCallStack();
-                });
-            }
-            else {
-                const thread = typeof stoppedDetails.threadId === 'number' ? this.threads.get(stoppedDetails.threadId) : undefined;
-                if (thread) {
-                    thread.stoppedDetails = stoppedDetails;
-                    thread.clearCallStack();
-                    thread.stopped = true;
-                }
-            }
-        }
-    }
-    async fetchThreads(stoppedDetails) {
-        if (this.raw) {
-            const response = await this.raw.threads();
-            if (response && response.body && response.body.threads) {
-                this.model.rawUpdate({
-                    sessionId: this.getId(),
-                    threads: response.body.threads,
-                    stoppedDetails
-                });
-            }
-        }
-    }
-    initializeForTest(raw) {
-        this.raw = raw;
-        this.registerListeners();
-    }
-    registerListeners() {
-        if (!this.raw) {
-            return;
-        }
-        this.rawListeners.add(this.raw.onDidInitialize(async () => {
-            aria.status(( localize('debuggingStarted', "Debugging started.")));
-            const sendConfigurationDone = async () => {
-                if (this.raw && this.raw.capabilities.supportsConfigurationDoneRequest) {
-                    try {
-                        await this.raw.configurationDone();
-                    }
-                    catch (e) {
-                        this.notificationService.error(e);
-                        this.raw?.disconnect({});
-                    }
-                }
-                return undefined;
-            };
-            try {
-                await this.debugService.sendAllBreakpoints(this);
-            }
-            finally {
-                await sendConfigurationDone();
-                await this.fetchThreads();
-            }
-        }));
-        const statusQueue = ( new Queue());
-        this.rawListeners.add(this.raw.onDidStop(async (event) => {
-            statusQueue.queue(async () => {
-                this.passFocusScheduler.cancel();
-                this.stoppedDetails.push(event.body);
-                await this.fetchThreads(event.body);
-                const focusedThread = this.debugService.getViewModel().focusedThread;
-                const focusedThreadDoesNotExist = focusedThread !== undefined && focusedThread.session === this && !( this.threads.has(focusedThread.threadId));
-                if (focusedThreadDoesNotExist) {
-                    this.debugService.focusStackFrame(undefined, undefined);
-                }
-                const thread = typeof event.body.threadId === 'number' ? this.getThread(event.body.threadId) : undefined;
-                if (thread) {
-                    const promises = this.model.refreshTopOfCallstack(thread);
-                    const focus = async () => {
-                        if (focusedThreadDoesNotExist || (!event.body.preserveFocusHint && thread.getCallStack().length)) {
-                            const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
-                            if (!focusedStackFrame || focusedStackFrame.thread.session === this) {
-                                const preserveFocus = !this.configurationService.getValue('debug').focusEditorOnBreak;
-                                await this.debugService.focusStackFrame(undefined, thread, undefined, { preserveFocus });
-                            }
-                            if (thread.stoppedDetails) {
-                                if (thread.stoppedDetails.reason === 'breakpoint' && this.configurationService.getValue('debug').openDebug === 'openOnDebugBreak' && !this.suppressDebugView) {
-                                    await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 );
-                                }
-                                if (this.configurationService.getValue('debug').focusWindowOnBreak && !this.workbenchEnvironmentService.extensionTestsLocationURI) {
-                                    await this.hostService.focus({ force: true  });
-                                }
-                            }
-                        }
-                    };
-                    await promises.topCallStack;
-                    focus();
-                    await promises.wholeCallStack;
-                    const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
-                    if (!focusedStackFrame || !focusedStackFrame.source || focusedStackFrame.source.presentationHint === 'deemphasize' || focusedStackFrame.presentationHint === 'deemphasize') {
-                        focus();
-                    }
-                }
-                this._onDidChangeState.fire();
-            });
-        }));
-        this.rawListeners.add(this.raw.onDidThread(event => {
-            statusQueue.queue(async () => {
-                if (event.body.reason === 'started') {
-                    if (!this.fetchThreadsScheduler) {
-                        this.fetchThreadsScheduler = ( new RunOnceScheduler(() => {
-                            this.fetchThreads();
-                        }, 100));
-                        this.rawListeners.add(this.fetchThreadsScheduler);
-                    }
-                    if (!this.fetchThreadsScheduler.isScheduled()) {
-                        this.fetchThreadsScheduler.schedule();
-                    }
-                }
-                else if (event.body.reason === 'exited') {
-                    this.model.clearThreads(this.getId(), true, event.body.threadId);
-                    const viewModel = this.debugService.getViewModel();
-                    const focusedThread = viewModel.focusedThread;
-                    this.passFocusScheduler.cancel();
-                    if (focusedThread && event.body.threadId === focusedThread.threadId) {
-                        this.debugService.focusStackFrame(undefined, undefined, viewModel.focusedSession, { explicit: false });
-                    }
-                }
-            });
-        }));
-        this.rawListeners.add(this.raw.onDidTerminateDebugee(async (event) => {
-            aria.status(( localize('debuggingStopped', "Debugging stopped.")));
-            if (event.body && event.body.restart) {
-                await this.debugService.restartSession(this, event.body.restart);
-            }
-            else if (this.raw) {
-                await this.raw.disconnect({ terminateDebuggee: false });
-            }
-        }));
-        this.rawListeners.add(this.raw.onDidContinued(event => {
-            statusQueue.queue(async () => {
-                const threadId = event.body.allThreadsContinued !== false ? undefined : event.body.threadId;
-                if (typeof threadId === 'number') {
-                    this.stoppedDetails = this.stoppedDetails.filter(sd => sd.threadId !== threadId);
-                    const tokens = this.cancellationMap.get(threadId);
-                    this.cancellationMap.delete(threadId);
-                    tokens?.forEach(t => t.dispose(true));
-                }
-                else {
-                    this.stoppedDetails = [];
-                    this.cancelAllRequests();
-                }
-                this.lastContinuedThreadId = threadId;
-                this.passFocusScheduler.schedule();
-                this.model.clearThreads(this.getId(), false, threadId);
-                this._onDidChangeState.fire();
-            });
-        }));
-        const outputQueue = ( new Queue());
-        this.rawListeners.add(this.raw.onDidOutput(async (event) => {
-            const outputSeverity = event.body.category === 'stderr' ? Severity.Error : event.body.category === 'console' ? Severity.Warning : Severity.Info;
-            if (event.body.variablesReference) {
-                const source = event.body.source && event.body.line ? {
-                    lineNumber: event.body.line,
-                    column: event.body.column ? event.body.column : 1,
-                    source: this.getSource(event.body.source)
-                } : undefined;
-                const container = ( new ExpressionContainer(this, undefined, event.body.variablesReference, generateUuid()));
-                const children = container.getChildren();
-                outputQueue.queue(async () => {
-                    const resolved = await children;
-                    if (resolved.length === 1) {
-                        this.appendToRepl({ output: event.body.output, expression: resolved[0], sev: outputSeverity, source }, event.body.category === 'important');
-                        return;
-                    }
-                    resolved.forEach((child) => {
-                        child.name = null;
-                        this.appendToRepl({ output: '', expression: child, sev: outputSeverity, source }, event.body.category === 'important');
-                    });
-                });
-                return;
-            }
-            outputQueue.queue(async () => {
-                if (!event.body || !this.raw) {
-                    return;
-                }
-                if (event.body.category === 'telemetry') {
-                    const telemetryEndpoint = this.raw.dbgr.getCustomTelemetryEndpoint();
-                    if (telemetryEndpoint && this.telemetryService.telemetryLevel !== 0 ) {
-                        let data = event.body.data;
-                        if (!telemetryEndpoint.sendErrorTelemetry && event.body.data) {
-                            data = filterExceptionsFromTelemetry(event.body.data);
-                        }
-                        this.customEndpointTelemetryService.publicLog(telemetryEndpoint, event.body.output, data);
-                    }
-                    return;
-                }
-                const source = event.body.source && event.body.line ? {
-                    lineNumber: event.body.line,
-                    column: event.body.column ? event.body.column : 1,
-                    source: this.getSource(event.body.source)
-                } : undefined;
-                if (event.body.group === 'start' || event.body.group === 'startCollapsed') {
-                    const expanded = event.body.group === 'start';
-                    this.repl.startGroup(event.body.output || '', expanded, source);
-                    return;
-                }
-                if (event.body.group === 'end') {
-                    this.repl.endGroup();
-                    if (!event.body.output) {
-                        return;
-                    }
-                }
-                if (typeof event.body.output === 'string') {
-                    this.appendToRepl({ output: event.body.output, sev: outputSeverity, source }, event.body.category === 'important');
-                }
-            });
-        }));
-        this.rawListeners.add(this.raw.onDidBreakpoint(event => {
-            const id = event.body && event.body.breakpoint ? event.body.breakpoint.id : undefined;
-            const breakpoint = this.model.getBreakpoints().find(bp => bp.getIdFromAdapter(this.getId()) === id);
-            const functionBreakpoint = this.model.getFunctionBreakpoints().find(bp => bp.getIdFromAdapter(this.getId()) === id);
-            const dataBreakpoint = this.model.getDataBreakpoints().find(dbp => dbp.getIdFromAdapter(this.getId()) === id);
-            const exceptionBreakpoint = this.model.getExceptionBreakpoints().find(excbp => excbp.getIdFromAdapter(this.getId()) === id);
-            if (event.body.reason === 'new' && event.body.breakpoint.source && event.body.breakpoint.line) {
-                const source = this.getSource(event.body.breakpoint.source);
-                const bps = this.model.addBreakpoints(source.uri, [{
-                        column: event.body.breakpoint.column,
-                        enabled: true,
-                        lineNumber: event.body.breakpoint.line,
-                    }], false);
-                if (bps.length === 1) {
-                    const data = ( new Map([[bps[0].getId(), event.body.breakpoint]]));
-                    this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
-                }
-            }
-            if (event.body.reason === 'removed') {
-                if (breakpoint) {
-                    this.model.removeBreakpoints([breakpoint]);
-                }
-                if (functionBreakpoint) {
-                    this.model.removeFunctionBreakpoints(functionBreakpoint.getId());
-                }
-                if (dataBreakpoint) {
-                    this.model.removeDataBreakpoints(dataBreakpoint.getId());
-                }
-            }
-            if (event.body.reason === 'changed') {
-                if (breakpoint) {
-                    if (!breakpoint.column) {
-                        event.body.breakpoint.column = undefined;
-                    }
-                    const data = ( new Map([[breakpoint.getId(), event.body.breakpoint]]));
-                    this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
-                }
-                if (functionBreakpoint) {
-                    const data = ( new Map([[functionBreakpoint.getId(), event.body.breakpoint]]));
-                    this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
-                }
-                if (dataBreakpoint) {
-                    const data = ( new Map([[dataBreakpoint.getId(), event.body.breakpoint]]));
-                    this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
-                }
-                if (exceptionBreakpoint) {
-                    const data = ( new Map([[exceptionBreakpoint.getId(), event.body.breakpoint]]));
-                    this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
-                }
-            }
-        }));
-        this.rawListeners.add(this.raw.onDidLoadedSource(event => {
-            this._onDidLoadedSource.fire({
-                reason: event.body.reason,
-                source: this.getSource(event.body.source)
-            });
-        }));
-        this.rawListeners.add(this.raw.onDidCustomEvent(event => {
-            this._onDidCustomEvent.fire(event);
-        }));
-        this.rawListeners.add(this.raw.onDidProgressStart(event => {
-            this._onDidProgressStart.fire(event);
-        }));
-        this.rawListeners.add(this.raw.onDidProgressUpdate(event => {
-            this._onDidProgressUpdate.fire(event);
-        }));
-        this.rawListeners.add(this.raw.onDidProgressEnd(event => {
-            this._onDidProgressEnd.fire(event);
-        }));
-        this.rawListeners.add(this.raw.onDidInvalidateMemory(event => {
-            this._onDidInvalidMemory.fire(event);
-        }));
-        this.rawListeners.add(this.raw.onDidInvalidated(async (event) => {
-            if (!(event.body.areas && event.body.areas.length === 1 && (event.body.areas[0] === 'variables' || event.body.areas[0] === 'watch'))) {
-                this.cancelAllRequests();
-                this.model.clearThreads(this.getId(), true);
-                await this.fetchThreads(this.getStoppedDetails());
-            }
-            const viewModel = this.debugService.getViewModel();
-            if (viewModel.focusedSession === this) {
-                viewModel.updateViews();
-            }
-        }));
-        this.rawListeners.add(this.raw.onDidExitAdapter(event => this.onDidExitAdapter(event)));
-    }
-    onDidExitAdapter(event) {
-        this.initialized = true;
-        this.model.setBreakpointSessionData(this.getId(), this.capabilities, undefined);
-        this.shutdown();
-        this._onDidEndAdapter.fire(event);
-    }
-    shutdown() {
-        this.rawListeners.clear();
-        if (this.raw) {
-            this.raw.disconnect({});
-            this.raw.dispose();
-            this.raw = undefined;
-        }
-        this.fetchThreadsScheduler?.dispose();
-        this.fetchThreadsScheduler = undefined;
-        this.passFocusScheduler.cancel();
-        this.passFocusScheduler.dispose();
-        this.model.clearThreads(this.getId(), true);
-        this._onDidChangeState.fire();
-    }
-    dispose() {
-        this.cancelAllRequests();
-        this.rawListeners.dispose();
-    }
-    getSourceForUri(uri) {
-        return this.sources.get(( this.uriIdentityService.asCanonicalUri(uri).toString()));
-    }
-    getSource(raw) {
-        let source = ( new Source(raw, this.getId(), this.uriIdentityService, this.logService));
-        const uriKey = ( source.uri.toString());
-        const found = this.sources.get(uriKey);
-        if (found) {
-            source = found;
-            source.raw = mixin(source.raw, raw);
-            if (source.raw && raw) {
-                source.raw.presentationHint = raw.presentationHint;
-            }
-        }
-        else {
-            this.sources.set(uriKey, source);
-        }
-        return source;
-    }
-    getRawSource(uri) {
-        const source = this.getSourceForUri(uri);
-        if (source) {
-            return source.raw;
-        }
-        else {
-            const data = Source.getEncodedDebugData(uri);
-            return { name: data.name, path: data.path, sourceReference: data.sourceReference };
-        }
-    }
-    getNewCancellationToken(threadId, token) {
-        const tokenSource = ( new CancellationTokenSource(token));
-        const tokens = this.cancellationMap.get(threadId) || [];
-        tokens.push(tokenSource);
-        this.cancellationMap.set(threadId, tokens);
-        return tokenSource.token;
-    }
-    cancelAllRequests() {
-        this.cancellationMap.forEach(tokens => tokens.forEach(t => t.dispose(true)));
-        this.cancellationMap.clear();
-    }
-    getReplElements() {
-        return this.repl.getReplElements();
-    }
-    hasSeparateRepl() {
-        return !this.parentSession || this._options.repl !== 'mergeWithParent';
-    }
-    removeReplExpressions() {
-        this.repl.removeReplExpressions();
-    }
-    async addReplExpression(stackFrame, name) {
-        await this.repl.addReplExpression(this, stackFrame, name);
-        this.debugService.getViewModel().updateViews();
-    }
-    appendToRepl(data, isImportant) {
-        this.repl.appendToRepl(this, data);
-        if (isImportant) {
-            this.notificationService.notify({ message: ( data.output.toString()), severity: data.sev, source: this.name });
-        }
-    }
-};
-DebugSession = ( __decorate([
-    ( __param(5, IDebugService)),
-    ( __param(6, ITelemetryService)),
-    ( __param(7, IHostService)),
-    ( __param(8, IConfigurationService)),
-    ( __param(9, IPaneCompositePartService)),
-    ( __param(10, IWorkspaceContextService)),
-    ( __param(11, IProductService)),
-    ( __param(12, INotificationService)),
-    ( __param(13, ILifecycleService)),
-    ( __param(14, IUriIdentityService)),
-    ( __param(15, IInstantiationService)),
-    ( __param(16, ICustomEndpointTelemetryService)),
-    ( __param(17, IWorkbenchEnvironmentService)),
-    ( __param(18, ILogService))
-], DebugSession));
-export { DebugSession };