@codingame/monaco-vscode-debug-service-override 25.1.2 → 26.0.1

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

@@ -47,7 +47,30 @@ import { RawDebugSession } from './rawDebugSession.js';
 
 const TRIGGERED_BREAKPOINT_MAX_DELAY = 1500;
 let DebugSession = class DebugSession {
-    constructor(id, _configuration, root, model, options, debugService, telemetryService, hostService, configurationService, paneCompositeService, workspaceContextService, productService, notificationService, lifecycleService, uriIdentityService, instantiationService, customEndpointTelemetryService, workbenchEnvironmentService, logService, testService, testResultService, accessibilityService) {
+    constructor(
+        id,
+        _configuration,
+        root,
+        model,
+        options,
+        debugService,
+        telemetryService,
+        hostService,
+        configurationService,
+        paneCompositeService,
+        workspaceContextService,
+        productService,
+        notificationService,
+        lifecycleService,
+        uriIdentityService,
+        instantiationService,
+        customEndpointTelemetryService,
+        workbenchEnvironmentService,
+        logService,
+        testService,
+        testResultService,
+        accessibilityService
+    ) {
         this.id = id;
         this._configuration = _configuration;
         this.root = root;
@@ -97,22 +120,19 @@ let DebugSession = class DebugSession {
         this.parentSession = this._options.parentSession;
         if (this.hasSeparateRepl()) {
             this.repl = ( new ReplModel(this.configurationService));
-        }
-        else {
+        } else {
             this.repl = this.parentSession.repl;
         }
         const toDispose = this.globalDisposables;
         const replListener = toDispose.add(( new MutableDisposable()));
-        replListener.value = this.repl.onDidChangeElements((e) => this._onDidChangeREPLElements.fire(e));
+        replListener.value = this.repl.onDidChangeElements(e => this._onDidChangeREPLElements.fire(e));
         if (lifecycleService) {
             toDispose.add(lifecycleService.onWillShutdown(() => {
                 this.shutdown();
                 dispose(toDispose);
             }));
         }
-        this.correlatedTestRun = options?.testRun
-            ? testResultService.getResult(options.testRun.runId)
-            : this.parentSession?.correlatedTestRun;
+        this.correlatedTestRun = options?.testRun ? testResultService.getResult(options.testRun.runId) : this.parentSession?.correlatedTestRun;
         if (this.correlatedTestRun) {
             toDispose.add(this.correlatedTestRun.onComplete(() => this.terminate()));
         }
@@ -122,15 +142,14 @@ let DebugSession = class DebugSession {
         }
         this.passFocusScheduler = ( new RunOnceScheduler(() => {
             if (( this.debugService.getModel().getSessions().some(s => s.state === State.Stopped)) || ( this.getAllThreads().some(t => t.stopped))) {
-                if (typeof this.lastContinuedThreadId === 'number') {
+                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;
+                        const toFocusThread = typeof toFocusThreadId === "number" ? this.getThread(toFocusThreadId) : undefined;
                         this.debugService.focusStackFrame(undefined, toFocusThread);
                     }
-                }
-                else {
+                } else {
                     const session = this.debugService.getViewModel().focusedSession;
                     if (session && session.getId() === this.getId() && session.state !== State.Stopped) {
                         this.debugService.focusStackFrame(undefined);
@@ -143,7 +162,7 @@ let DebugSession = class DebugSession {
             toDispose.add(parent.onDidEndAdapter(() => {
                 if (!this.hasSeparateRepl() && this.raw?.isInShutdown === false) {
                     this.repl = this.repl.clone();
-                    replListener.value = this.repl.onDidChangeElements((e) => this._onDidChangeREPLElements.fire(e));
+                    replListener.value = this.repl.onDidChangeElements(e => this._onDidChangeREPLElements.fire(e));
                     this.parentSession = undefined;
                 }
             }));
@@ -190,8 +209,8 @@ let DebugSession = class DebugSession {
     }
     get autoExpandLazyVariables() {
         const screenReaderOptimized = this.accessibilityService.isScreenReaderOptimized();
-        const value = this.configurationService.getValue('debug').autoExpandLazyVariables;
-        return value === 'auto' && screenReaderOptimized || value === 'on';
+        const value = this.configurationService.getValue("debug").autoExpandLazyVariables;
+        return value === "auto" && screenReaderOptimized || value === "on";
     }
     setConfiguration(configuration) {
         this._configuration = configuration;
@@ -266,10 +285,10 @@ let DebugSession = class DebugSession {
             await this.raw.start();
             this.registerListeners();
             await this.raw.initialize({
-                clientID: 'vscode',
+                clientID: "vscode",
                 clientName: this.productService.nameLong,
                 adapterID: this.configuration.type,
-                pathFormat: 'path',
+                pathFormat: "path",
                 linesStartAt1: true,
                 columnsStartAt1: true,
                 supportsVariableType: true,
@@ -282,15 +301,14 @@ let DebugSession = class DebugSession {
                 supportsArgsCanBeInterpretedByShell: true,
                 supportsMemoryEvent: true,
                 supportsStartDebuggingRequest: true,
-                supportsANSIStyling: true,
+                supportsANSIStyling: true
             });
             this.initialized = true;
             this._onDidChangeState.fire();
             this.rememberedCapabilities = this.raw.capabilities;
             this.debugService.setExceptionBreakpointsForSession(this, (this.raw && this.raw.capabilities.exceptionBreakpointFilters) || []);
             this.debugService.getModel().registerBreakpointModes(this.configuration.type, this.raw.capabilities.breakpointModes || []);
-        }
-        catch (err) {
+        } catch (err) {
             this.initialized = true;
             this._onDidChangeState.fire();
             await this.shutdown();
@@ -299,7 +317,7 @@ let DebugSession = class DebugSession {
     }
     async launchOrAttach(config) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'launch or attach'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "launch or attach"))));
         }
         if (this.parentSession && this.parentSession.state === State.Inactive) {
             throw canceled();
@@ -307,8 +325,7 @@ let DebugSession = class DebugSession {
         config.__sessionId = this.getId();
         try {
             await this.raw.launchOrAttach(config);
-        }
-        catch (err) {
+        } catch (err) {
             this.shutdown();
             throw err;
         }
@@ -326,16 +343,16 @@ let DebugSession = class DebugSession {
         this.cancelAllRequests();
         if (this._options.lifecycleManagedByParent && this.parentSession) {
             await this.parentSession.terminate(restart);
-        }
-        else if (this.correlatedTestRun && !this.correlatedTestRun.completedAt && !this.didTerminateTestRun) {
+        } else if (this.correlatedTestRun && !this.correlatedTestRun.completedAt && !this.didTerminateTestRun) {
             this.cancelCorrelatedTestRun();
-        }
-        else if (this.raw) {
-            if (this.raw.capabilities.supportsTerminateRequest && this._configuration.resolved.request === 'launch') {
+        } 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 });
+            } else {
+                await this.raw.disconnect({
+                    restart,
+                    terminateDebuggee: true
+                });
             }
         }
         if (!restart) {
@@ -349,9 +366,12 @@ let DebugSession = class DebugSession {
         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 });
+        } else if (this.raw) {
+            await this.raw.disconnect({
+                restart,
+                terminateDebuggee: false,
+                suspendDebuggee: suspend
+            });
         }
         if (!restart) {
             this._options.compoundRoot?.sessionStopped();
@@ -359,19 +379,20 @@ let DebugSession = class DebugSession {
     }
     async restart() {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'restart'))));
+            throw ( new Error(( localize(7208, "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 });
+        } else {
+            await this.raw.restart({
+                arguments: this.configuration
+            });
         }
     }
     async sendBreakpoints(modelUri, breakpointsToSend, sourceModified) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'breakpoints'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "breakpoints"))));
         }
         if (!this.raw.readyForBreakpoints) {
             return Promise.resolve(undefined);
@@ -399,10 +420,12 @@ let DebugSession = class DebugSession {
     }
     async sendFunctionBreakpoints(fbpts) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'function breakpoints'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "function breakpoints"))));
         }
         if (this.raw.readyForBreakpoints) {
-            const response = await this.raw.setFunctionBreakpoints({ breakpoints: ( fbpts.map(bp => bp.toDAP())) });
+            const response = await this.raw.setFunctionBreakpoints({
+                breakpoints: ( fbpts.map(bp => bp.toDAP()))
+            });
             if (response?.body) {
                 const data = ( new Map());
                 for (let i = 0; i < fbpts.length; i++) {
@@ -414,18 +437,25 @@ let DebugSession = class DebugSession {
     }
     async sendExceptionBreakpoints(exbpts) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'exception breakpoints'))));
+            throw ( new Error(( localize(7208, "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,
+                            condition: exb.condition
+                        };
                     }
-                    return { filterId: exb.filter };
+                    return {
+                        filterId: exb.filter
+                    };
                 }))
-            } : { filters: ( exbpts.map(exb => exb.filter)) };
+            } : {
+                filters: ( exbpts.map(exb => exb.filter))
+            };
             const response = await this.raw.setExceptionBreakpoints(args);
             if (response?.body && response.body.breakpoints) {
                 const data = ( new Map());
@@ -438,46 +468,60 @@ let DebugSession = class DebugSession {
     }
     dataBytesBreakpointInfo(address, bytes) {
         if (this.raw?.capabilities.supportsDataBreakpointBytes === false) {
-            throw ( new Error(( localize(6898, "Session does not support breakpoints with bytes"))));
+            throw ( new Error(( localize(7209, "Session does not support breakpoints with bytes"))));
         }
-        return this._dataBreakpointInfo({ name: address, bytes, asAddress: true });
+        return this._dataBreakpointInfo({
+            name: address,
+            bytes,
+            asAddress: true
+        });
     }
     dataBreakpointInfo(name, variablesReference, frameId) {
-        return this._dataBreakpointInfo({ name, variablesReference, frameId });
+        return this._dataBreakpointInfo({
+            name,
+            variablesReference,
+            frameId
+        });
     }
     async _dataBreakpointInfo(args) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'data breakpoints info'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "data breakpoints info"))));
         }
         if (!this.raw.readyForBreakpoints) {
-            throw ( new Error(( localize(6899, "Session is not ready for breakpoints"))));
+            throw ( new Error(( localize(7210, "Session is not ready for breakpoints"))));
         }
         const response = await this.raw.dataBreakpointInfo(args);
         return response?.body;
     }
     async sendDataBreakpoints(dataBreakpoints) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'data breakpoints'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "data breakpoints"))));
         }
         if (this.raw.readyForBreakpoints) {
-            const converted = await Promise.all(( dataBreakpoints.map(async (bp) => {
+            const converted = await Promise.all(( dataBreakpoints.map(async bp => {
                 try {
                     const dap = await bp.toDAP(this);
-                    return { dap, bp };
-                }
-                catch (e) {
-                    return { bp, message: e.message };
+                    return {
+                        dap,
+                        bp
+                    };
+                } catch (e) {
+                    return {
+                        bp,
+                        message: e.message
+                    };
                 }
             })));
-            const response = await this.raw.setDataBreakpoints({ breakpoints: ( converted.map(d => d.dap)).filter(isDefined) });
+            const response = await this.raw.setDataBreakpoints({
+                breakpoints: ( converted.map(d => d.dap)).filter(isDefined)
+            });
             if (response?.body) {
                 const data = ( new Map());
                 let i = 0;
                 for (const dap of converted) {
                     if (!dap.dap) {
                         data.set(dap.bp.getId(), dap.message);
-                    }
-                    else if (i < response.body.breakpoints.length) {
+                    } else if (i < response.body.breakpoints.length) {
                         data.set(dap.bp.getId(), response.body.breakpoints[i++]);
                     }
                 }
@@ -488,13 +532,15 @@ let DebugSession = class DebugSession {
     async sendInstructionBreakpoints(instructionBreakpoints) {
         if (!this.raw) {
             throw ( new Error(( localize(
-                6897,
+                7208,
                 "No debugger available, can not send '{0}'",
-                'instruction breakpoints'
+                "instruction breakpoints"
             ))));
         }
         if (this.raw.readyForBreakpoints) {
-            const response = await this.raw.setInstructionBreakpoints({ breakpoints: ( instructionBreakpoints.map(ib => ib.toDAP())) });
+            const response = await this.raw.setInstructionBreakpoints({
+                breakpoints: ( instructionBreakpoints.map(ib => ib.toDAP()))
+            });
             if (response?.body) {
                 const data = ( new Map());
                 for (let i = 0; i < instructionBreakpoints.length; i++) {
@@ -506,14 +552,20 @@ let DebugSession = class DebugSession {
     }
     async breakpointsLocations(uri, lineNumber) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'breakpoints locations'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "breakpoints locations"))));
         }
         const source = this.getRawSource(uri);
-        const response = await this.raw.breakpointLocations({ source, line: lineNumber });
+        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 })));
+        const positions = ( response.body.breakpoints.map(bp => ({
+            lineNumber: bp.line,
+            column: bp.column || 1
+        })));
         return distinct(positions, p => `${p.lineNumber}:${p.column}`);
     }
     getDebugProtocolBreakpoint(breakpointId) {
@@ -521,22 +573,28 @@ let DebugSession = class DebugSession {
     }
     customRequest(request, args) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", request))));
+            throw ( new Error(( localize(7208, "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(6897, "No debugger available, can not send '{0}'", 'stackTrace'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "stackTrace"))));
         }
         const sessionToken = this.getNewCancellationToken(threadId, token);
-        return this.raw.stackTrace({ threadId, startFrame, levels }, sessionToken);
+        return this.raw.stackTrace({
+            threadId,
+            startFrame,
+            levels
+        }, sessionToken);
     }
     async exceptionInfo(threadId) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'exceptionInfo'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "exceptionInfo"))));
         }
-        const response = await this.raw.exceptionInfo({ threadId });
+        const response = await this.raw.exceptionInfo({
+            threadId
+        });
         if (response) {
             return {
                 id: response.body.exceptionId,
@@ -549,30 +607,46 @@ let DebugSession = class DebugSession {
     }
     scopes(frameId, threadId) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'scopes'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "scopes"))));
         }
         const token = this.getNewCancellationToken(threadId);
-        return this.raw.scopes({ frameId }, token);
+        return this.raw.scopes({
+            frameId
+        }, token);
     }
     variables(variablesReference, threadId, filter, start, count) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'variables'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "variables"))));
         }
         const token = threadId ? this.getNewCancellationToken(threadId) : undefined;
-        return this.raw.variables({ variablesReference, filter, start, count }, token);
+        return this.raw.variables({
+            variablesReference,
+            filter,
+            start,
+            count
+        }, token);
     }
     evaluate(expression, frameId, context, location) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'evaluate'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "evaluate"))));
         }
-        return this.raw.evaluate({ expression, frameId, context, line: location?.line, column: location?.column, source: location?.source });
+        return this.raw.evaluate({
+            expression,
+            frameId,
+            context,
+            line: location?.line,
+            column: location?.column,
+            source: location?.source
+        });
     }
     async restartFrame(frameId, threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'restartFrame'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "restartFrame"))));
         }
-        await this.raw.restartFrame({ frameId }, threadId);
+        await this.raw.restartFrame({
+            frameId
+        }, threadId);
     }
     setLastSteppingGranularity(threadId, granularity) {
         const thread = this.getThread(threadId);
@@ -583,173 +657,238 @@ let DebugSession = class DebugSession {
     async next(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'next'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "next"))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
-        await this.raw.next({ threadId, granularity });
+        await this.raw.next({
+            threadId,
+            granularity
+        });
     }
     async stepIn(threadId, targetId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'stepIn'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "stepIn"))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
-        await this.raw.stepIn({ threadId, targetId, granularity });
+        await this.raw.stepIn({
+            threadId,
+            targetId,
+            granularity
+        });
     }
     async stepOut(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'stepOut'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "stepOut"))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
-        await this.raw.stepOut({ threadId, granularity });
+        await this.raw.stepOut({
+            threadId,
+            granularity
+        });
     }
     async stepBack(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'stepBack'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "stepBack"))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
-        await this.raw.stepBack({ threadId, granularity });
+        await this.raw.stepBack({
+            threadId,
+            granularity
+        });
     }
     async continue(threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'continue'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "continue"))));
         }
-        await this.raw.continue({ threadId });
+        await this.raw.continue({
+            threadId
+        });
     }
     async reverseContinue(threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'reverse continue'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "reverse continue"))));
         }
-        await this.raw.reverseContinue({ threadId });
+        await this.raw.reverseContinue({
+            threadId
+        });
     }
     async pause(threadId) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'pause'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "pause"))));
         }
-        await this.raw.pause({ threadId });
+        await this.raw.pause({
+            threadId
+        });
     }
     async terminateThreads(threadIds) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'terminateThreads'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "terminateThreads"))));
         }
-        await this.raw.terminateThreads({ threadIds });
+        await this.raw.terminateThreads({
+            threadIds
+        });
     }
     setVariable(variablesReference, name, value) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'setVariable'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "setVariable"))));
         }
-        return this.raw.setVariable({ variablesReference, name, value });
+        return this.raw.setVariable({
+            variablesReference,
+            name,
+            value
+        });
     }
     setExpression(frameId, expression, value) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'setExpression'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "setExpression"))));
         }
-        return this.raw.setExpression({ expression, value, frameId });
+        return this.raw.setExpression({
+            expression,
+            value,
+            frameId
+        });
     }
     gotoTargets(source, line, column) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'gotoTargets'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "gotoTargets"))));
         }
-        return this.raw.gotoTargets({ source, line, column });
+        return this.raw.gotoTargets({
+            source,
+            line,
+            column
+        });
     }
     goto(threadId, targetId) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'goto'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "goto"))));
         }
-        return this.raw.goto({ threadId, targetId });
+        return this.raw.goto({
+            threadId,
+            targetId
+        });
     }
     loadSource(resource) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'loadSource')))));
+            return Promise.reject(( new Error(( localize(7208, "No debugger available, can not send '{0}'", "loadSource")))));
         }
         const source = this.getSourceForUri(resource);
         let rawSource;
         if (source) {
             rawSource = source.raw;
-        }
-        else {
+        } else {
             const data = Source.getEncodedDebugData(resource);
-            rawSource = { path: data.path, sourceReference: data.sourceReference };
+            rawSource = {
+                path: data.path,
+                sourceReference: data.sourceReference
+            };
         }
-        return this.raw.source({ sourceReference: rawSource.sourceReference || 0, source: rawSource });
+        return this.raw.source({
+            sourceReference: rawSource.sourceReference || 0,
+            source: rawSource
+        });
     }
     async getLoadedSources() {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'getLoadedSources')))));
+            return Promise.reject(( new Error(( localize(7208, "No debugger available, can not send '{0}'", "getLoadedSources")))));
         }
         const response = await this.raw.loadedSources({});
         if (response?.body && response.body.sources) {
             return ( response.body.sources.map(src => this.getSource(src)));
-        }
-        else {
+        } else {
             return [];
         }
     }
     async completions(frameId, threadId, text, position, token) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'completions')))));
+            return Promise.reject(( new Error(( localize(7208, "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,
+            line: position.lineNumber
         }, sessionCancelationToken);
     }
     async stepInTargets(frameId) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'stepInTargets')))));
+            return Promise.reject(( new Error(( localize(7208, "No debugger available, can not send '{0}'", "stepInTargets")))));
         }
-        const response = await this.raw.stepInTargets({ frameId });
+        const response = await this.raw.stepInTargets({
+            frameId
+        });
         return response?.body.targets;
     }
     async cancel(progressId) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'cancel')))));
+            return Promise.reject(( new Error(( localize(7208, "No debugger available, can not send '{0}'", "cancel")))));
         }
-        return this.raw.cancel({ progressId });
+        return this.raw.cancel({
+            progressId
+        });
     }
     async disassemble(memoryReference, offset, instructionOffset, instructionCount) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'disassemble')))));
-        }
-        const response = await this.raw.disassemble({ memoryReference, offset, instructionOffset, instructionCount, resolveSymbols: true });
+            return Promise.reject(( new Error(( localize(7208, "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(6897, "No debugger available, can not send '{0}'", 'readMemory')))));
+            return Promise.reject(( new Error(( localize(7208, "No debugger available, can not send '{0}'", "readMemory")))));
         }
-        return this.raw.readMemory({ count, memoryReference, offset });
+        return this.raw.readMemory({
+            count,
+            memoryReference,
+            offset
+        });
     }
     writeMemory(memoryReference, offset, data, allowPartial) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'disassemble')))));
+            return Promise.reject(( new Error(( localize(7208, "No debugger available, can not send '{0}'", "disassemble")))));
         }
-        return this.raw.writeMemory({ memoryReference, offset, allowPartial, data });
+        return this.raw.writeMemory({
+            memoryReference,
+            offset,
+            allowPartial,
+            data
+        });
     }
     async resolveLocationReference(locationReference) {
         if (!this.raw) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'locations'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "locations"))));
         }
-        const location = await this.raw.locations({ locationReference });
+        const location = await this.raw.locations({
+            locationReference
+        });
         if (!location?.body) {
-            throw ( new Error(( localize(6897, "No debugger available, can not send '{0}'", 'locations'))));
+            throw ( new Error(( localize(7208, "No debugger available, can not send '{0}'", "locations"))));
         }
         const source = this.getSource(location.body.source);
-        return { column: 1, ...location.body, source };
+        return {
+            column: 1,
+            ...location.body,
+            source
+        };
     }
     getThread(threadId) {
         return this.threads.get(threadId);
     }
     getAllThreads() {
         const result = [];
-        this.threadIds.forEach((threadId) => {
+        this.threadIds.forEach(threadId => {
             const thread = this.threads.get(threadId);
             if (thread) {
                 result.push(thread);
@@ -768,8 +907,7 @@ let DebugSession = class DebugSession {
                     this.threads.delete(reference);
                 }
             }
-        }
-        else {
+        } else {
             this.threads.forEach(thread => {
                 thread.clearCallStack();
                 thread.stoppedDetails = undefined;
@@ -791,8 +929,7 @@ let DebugSession = class DebugSession {
             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) {
+            } else if (thread.name) {
                 const oldThread = this.threads.get(thread.id);
                 if (oldThread) {
                     oldThread.name = thread.name;
@@ -808,13 +945,14 @@ let DebugSession = class DebugSession {
         if (stoppedDetails) {
             if (stoppedDetails.allThreadsStopped) {
                 this.threads.forEach(thread => {
-                    thread.stoppedDetails = thread.threadId === stoppedDetails.threadId ? stoppedDetails : { reason: thread.stoppedDetails?.reason };
+                    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;
+            } else {
+                const thread = typeof stoppedDetails.threadId === "number" ? this.threads.get(stoppedDetails.threadId) : undefined;
                 if (thread) {
                     thread.stoppedDetails = stoppedDetails;
                     thread.clearCallStack();
@@ -850,15 +988,12 @@ let DebugSession = class DebugSession {
             return;
         }
         this.rawListeners.add(this.raw.onDidInitialize(async () => {
-            status(this.configuration.noDebug
-                ? ( localize(6900, "Started running without debugging."))
-                : ( localize(6901, "Debugging started.")));
+            status(this.configuration.noDebug ? ( localize(7211, "Started running without debugging.")) : ( localize(7212, "Debugging started.")));
             const sendConfigurationDone = async () => {
                 if (this.raw && this.raw.capabilities.supportsConfigurationDoneRequest) {
                     try {
                         await this.raw.configurationDone();
-                    }
-                    catch (e) {
+                    } catch (e) {
                         this.notificationService.error(e);
                         this.raw?.disconnect({});
                     }
@@ -867,8 +1002,7 @@ let DebugSession = class DebugSession {
             };
             try {
                 await this.debugService.sendAllBreakpoints(this);
-            }
-            finally {
+            } finally {
                 await sendConfigurationDone();
                 await this.fetchThreads();
             }
@@ -877,48 +1011,47 @@ let DebugSession = class DebugSession {
         this.rawListeners.add(this.raw.onDidStop(event => this.handleStop(event.body)));
         this.rawListeners.add(this.raw.onDidThread(event => {
             statusQueue.cancel([event.body.threadId]);
-            if (event.body.reason === 'started') {
+            if (event.body.reason === "started") {
                 if (!this.fetchThreadsScheduler.value.isScheduled()) {
                     this.fetchThreadsScheduler.value.schedule();
                 }
-            }
-            else if (event.body.reason === 'exited') {
+            } 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.debugService.focusStackFrame(undefined, undefined, viewModel.focusedSession, {
+                        explicit: false
+                    });
                 }
             }
         }));
-        this.rawListeners.add(this.raw.onDidTerminateDebugee(async (event) => {
-            status(( localize(6902, "Debugging stopped.")));
+        this.rawListeners.add(this.raw.onDidTerminateDebugee(async event => {
+            status(( localize(7213, "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 });
+            } else if (this.raw) {
+                await this.raw.disconnect({
+                    terminateDebuggee: false
+                });
             }
         }));
-        this.rawListeners.add(this.raw.onDidContinued(async (event) => {
+        this.rawListeners.add(this.raw.onDidContinued(async event => {
             const allThreads = event.body.allThreadsContinued !== false;
             let affectedThreads;
             if (!allThreads) {
                 affectedThreads = [event.body.threadId];
                 if (this.threadIds.includes(event.body.threadId)) {
                     affectedThreads = [event.body.threadId];
-                }
-                else {
+                } else {
                     this.fetchThreadsScheduler.rawValue?.cancel();
                     affectedThreads = this.fetchThreads().then(() => [event.body.threadId]);
                 }
-            }
-            else if (this.fetchThreadsScheduler.value.isScheduled()) {
+            } else if (this.fetchThreadsScheduler.value.isScheduled()) {
                 this.fetchThreadsScheduler.value.cancel();
                 affectedThreads = this.fetchThreads().then(() => this.threadIds);
-            }
-            else {
+            } else {
                 affectedThreads = this.threadIds;
             }
             statusQueue.cancel(allThreads ? undefined : [event.body.threadId]);
@@ -935,8 +1068,8 @@ let DebugSession = class DebugSession {
             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;
+        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,
@@ -948,12 +1081,22 @@ let DebugSession = class DebugSession {
                 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');
+                        this.appendToRepl({
+                            output: event.body.output,
+                            expression: resolved[0],
+                            sev: outputSeverity,
+                            source
+                        }, event.body.category === "important");
                         return;
                     }
-                    resolved.forEach((child) => {
+                    resolved.forEach(child => {
                         child.name = null;
-                        this.appendToRepl({ output: '', expression: child, sev: outputSeverity, source }, event.body.category === 'important');
+                        this.appendToRepl({
+                            output: "",
+                            expression: child,
+                            sev: outputSeverity,
+                            source
+                        }, event.body.category === "important");
                     });
                 });
                 return;
@@ -962,7 +1105,7 @@ let DebugSession = class DebugSession {
                 if (!event.body || !this.raw) {
                     return;
                 }
-                if (event.body.category === 'telemetry') {
+                if (event.body.category === "telemetry") {
                     const telemetryEndpoint = this.raw.dbgr.getCustomTelemetryEndpoint();
                     if (telemetryEndpoint && this.telemetryService.telemetryLevel !== TelemetryLevel.NONE) {
                         let data = event.body.data;
@@ -978,19 +1121,23 @@ let DebugSession = class DebugSession {
                     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(this, event.body.output || '', expanded, source);
+                if (event.body.group === "start" || event.body.group === "startCollapsed") {
+                    const expanded = event.body.group === "start";
+                    this.repl.startGroup(this, event.body.output || "", expanded, source);
                     return;
                 }
-                if (event.body.group === 'end') {
+                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');
+                if (typeof event.body.output === "string") {
+                    this.appendToRepl({
+                        output: event.body.output,
+                        sev: outputSeverity,
+                        source
+                    }, event.body.category === "important");
                 }
             });
         }));
@@ -1000,19 +1147,19 @@ let DebugSession = class DebugSession {
             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) {
+            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);
+                    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 (event.body.reason === "removed") {
                 if (breakpoint) {
                     this.model.removeBreakpoints([breakpoint]);
                 }
@@ -1023,7 +1170,7 @@ let DebugSession = class DebugSession {
                     this.model.removeDataBreakpoints(dataBreakpoint.getId());
                 }
             }
-            if (event.body.reason === 'changed') {
+            if (event.body.reason === "changed") {
                 if (breakpoint) {
                     if (!breakpoint.column) {
                         event.body.breakpoint.column = undefined;
@@ -1066,17 +1213,16 @@ let DebugSession = class DebugSession {
         this.rawListeners.add(this.raw.onDidInvalidateMemory(event => {
             this._onDidInvalidMemory.fire(event);
         }));
-        this.rawListeners.add(this.raw.onDidInvalidated(async (event) => {
-            const areas = event.body.areas || ['all'];
-            if (areas.includes('threads') || areas.includes('stacks') || areas.includes('all')) {
+        this.rawListeners.add(this.raw.onDidInvalidated(async event => {
+            const areas = event.body.areas || ["all"];
+            if (areas.includes("threads") || areas.includes("stacks") || areas.includes("all")) {
                 this.cancelAllRequests();
                 this.model.clearThreads(this.getId(), true);
                 const details = this.stoppedDetails.slice();
                 this.stoppedDetails.length = 0;
                 if (details.length) {
                     await Promise.all(( details.map(d => this.handleStop(d))));
-                }
-                else if (!this.fetchThreadsScheduler.value.isScheduled()) {
+                } else if (!this.fetchThreadsScheduler.value.isScheduled()) {
                     this.fetchThreadsScheduler.value.schedule();
                 }
             }
@@ -1093,73 +1239,88 @@ let DebugSession = class DebugSession {
         if (event.hitBreakpointIds) {
             this._waitToResume = this.enableDependentBreakpoints(event.hitBreakpointIds);
         }
-        this.statusQueue.run(this.fetchThreads(event).then(() => event.threadId === undefined ? this.threadIds : [event.threadId]), async (threadId, token) => {
-            const hasLotsOfThreads = event.threadId === undefined && this.threadIds.length > 10;
-            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 threadId === 'number' ? this.getThread(threadId) : undefined;
-            if (thread) {
-                const promises = this.model.refreshTopOfCallstack(thread,  !hasLotsOfThreads);
-                const focus = async () => {
-                    if (focusedThreadDoesNotExist || (!event.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 && !token.isCancellationRequested) {
-                            if (thread.stoppedDetails.reason === 'breakpoint' && this.configurationService.getValue('debug').openDebug === 'openOnDebugBreak' && !this.suppressDebugView) {
-                                await this.paneCompositeService.openPaneComposite(VIEWLET_ID, ViewContainerLocation.Sidebar);
+        this.statusQueue.run(
+            this.fetchThreads(event).then(() => event.threadId === undefined ? this.threadIds : [event.threadId]),
+            async (threadId, token) => {
+                const hasLotsOfThreads = event.threadId === undefined && this.threadIds.length > 10;
+                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 threadId === "number" ? this.getThread(threadId) : undefined;
+                if (thread) {
+                    const promises = this.model.refreshTopOfCallstack(thread,  !hasLotsOfThreads);
+                    const focus = async () => {
+                        if (focusedThreadDoesNotExist || (!event.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 (this.configurationService.getValue('debug').focusWindowOnBreak && !this.workbenchEnvironmentService.extensionTestsLocationURI) {
-                                const activeWindow = getActiveWindow();
-                                if (!activeWindow.document.hasFocus()) {
-                                    await this.hostService.focus(mainWindow, { mode: FocusMode.Force  });
+                            if (thread.stoppedDetails && !token.isCancellationRequested) {
+                                if (thread.stoppedDetails.reason === "breakpoint" && this.configurationService.getValue("debug").openDebug === "openOnDebugBreak" && !this.suppressDebugView) {
+                                    await this.paneCompositeService.openPaneComposite(VIEWLET_ID, ViewContainerLocation.Sidebar);
+                                }
+                                if (this.configurationService.getValue("debug").focusWindowOnBreak && !this.workbenchEnvironmentService.extensionTestsLocationURI) {
+                                    const activeWindow = getActiveWindow();
+                                    if (!activeWindow.document.hasFocus()) {
+                                        await this.hostService.focus(mainWindow, {
+                                            mode: FocusMode.Force
+                                        });
+                                    }
                                 }
                             }
                         }
+                    };
+                    await promises.topCallStack;
+                    if (!event.hitBreakpointIds) {
+                        this._waitToResume = this.enableDependentBreakpoints(thread);
+                    }
+                    if (token.isCancellationRequested) {
+                        return;
                     }
-                };
-                await promises.topCallStack;
-                if (!event.hitBreakpointIds) {
-                    this._waitToResume = this.enableDependentBreakpoints(thread);
-                }
-                if (token.isCancellationRequested) {
-                    return;
-                }
-                focus();
-                await promises.wholeCallStack;
-                if (token.isCancellationRequested) {
-                    return;
-                }
-                const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
-                if (!focusedStackFrame || isFrameDeemphasized(focusedStackFrame)) {
                     focus();
+                    await promises.wholeCallStack;
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                    const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+                    if (!focusedStackFrame || isFrameDeemphasized(focusedStackFrame)) {
+                        focus();
+                    }
                 }
+                this._onDidChangeState.fire();
             }
-            this._onDidChangeState.fire();
-        });
+        );
     }
     async enableDependentBreakpoints(hitBreakpointIdsOrThread) {
         let breakpoints;
         if (Array.isArray(hitBreakpointIdsOrThread)) {
             breakpoints = this.model.getBreakpoints().filter(bp => hitBreakpointIdsOrThread.includes(bp.getIdFromAdapter(this.id)));
-        }
-        else {
+        } else {
             const frame = hitBreakpointIdsOrThread.getTopStackFrame();
             if (frame === undefined) {
                 return;
             }
-            if (hitBreakpointIdsOrThread.stoppedDetails && hitBreakpointIdsOrThread.stoppedDetails.reason !== 'breakpoint') {
+            if (hitBreakpointIdsOrThread.stoppedDetails && hitBreakpointIdsOrThread.stoppedDetails.reason !== "breakpoint") {
                 return;
             }
-            breakpoints = this.getBreakpointsAtPosition(frame.source.uri, frame.range.startLineNumber, frame.range.endLineNumber, frame.range.startColumn, frame.range.endColumn);
+            breakpoints = this.getBreakpointsAtPosition(
+                frame.source.uri,
+                frame.range.startLineNumber,
+                frame.range.endLineNumber,
+                frame.range.startColumn,
+                frame.range.endColumn
+            );
         }
         const urisToResend = ( new Set());
-        this.model.getBreakpoints({ triggeredOnly: true, enabledOnly: true }).forEach(bp => {
+        this.model.getBreakpoints({
+            triggeredOnly: true,
+            enabledOnly: true
+        }).forEach(bp => {
             breakpoints.forEach(cbp => {
                 if (bp.enabled && bp.triggeredBy === cbp.getId()) {
                     bp.setSessionDidTrigger(this.getId());
@@ -1168,11 +1329,13 @@ let DebugSession = class DebugSession {
             });
         });
         const results = [];
-        urisToResend.forEach((uri) => results.push(this.debugService.sendBreakpoints(( URI.parse(uri)), undefined, this)));
+        urisToResend.forEach(uri => results.push(this.debugService.sendBreakpoints(( URI.parse(uri)), undefined, this)));
         return Promise.all(results);
     }
     getBreakpointsAtPosition(uri, startLineNumber, endLineNumber, startColumn, endColumn) {
-        return this.model.getBreakpoints({ uri: uri }).filter(bp => {
+        return this.model.getBreakpoints({
+            uri: uri
+        }).filter(bp => {
             if (bp.lineNumber < startLineNumber || bp.lineNumber > endLineNumber) {
                 return false;
             }
@@ -1223,8 +1386,7 @@ let DebugSession = class DebugSession {
             if (source.raw && raw) {
                 source.raw.presentationHint = raw.presentationHint;
             }
-        }
-        else {
+        } else {
             this.sources.set(uriKey, source);
         }
         return source;
@@ -1233,10 +1395,13 @@ let DebugSession = class DebugSession {
         const source = this.getSourceForUri(uri);
         if (source) {
             return source.raw;
-        }
-        else {
+        } else {
             const data = Source.getEncodedDebugData(uri);
-            return { name: data.name, path: data.path, sourceReference: data.sourceReference };
+            return {
+                name: data.name,
+                path: data.path,
+                sourceReference: data.sourceReference
+            };
         }
     }
     getNewCancellationToken(threadId, token) {
@@ -1254,7 +1419,7 @@ let DebugSession = class DebugSession {
         return this.repl.getReplElements();
     }
     hasSeparateRepl() {
-        return !this.parentSession || this._options.repl !== 'mergeWithParent';
+        return !this.parentSession || this._options.repl !== "mergeWithParent";
     }
     removeReplExpressions() {
         this.repl.removeReplExpressions();
@@ -1266,29 +1431,15 @@ let DebugSession = class DebugSession {
     appendToRepl(data, isImportant) {
         this.repl.appendToRepl(this, data);
         if (isImportant) {
-            this.notificationService.notify({ message: ( data.output.toString()), severity: data.sev, source: this.name });
+            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)),
-    ( __param(19, ITestService)),
-    ( __param(20, ITestResultService)),
-    ( __param(21, IAccessibilityService))
-], DebugSession));
+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)), ( __param(19, ITestService)), ( __param(20, ITestResultService)), ( __param(21, IAccessibilityService))], DebugSession));
 class ThreadStatusScheduler extends Disposable {
     constructor() {
         super(...arguments);
@@ -1304,8 +1455,7 @@ class ThreadStatusScheduler extends Disposable {
             if (s === cancelledWhileLookingUpThreads) {
                 this.pendingCancellations.splice(i, 1);
                 break;
-            }
-            else {
+            } else {
                 for (const threadId of threadIds) {
                     s.add(threadId);
                 }
@@ -1333,8 +1483,7 @@ class ThreadStatusScheduler extends Disposable {
             for (const s of this.pendingCancellations) {
                 s.add(undefined);
             }
-        }
-        else {
+        } else {
             for (const threadId of threadIds) {
                 this.threadOps.get(threadId)?.cancel();
                 this.threadOps.deleteAndDispose(threadId);