@codingame/monaco-vscode-debug-service-override 4.5.0 → 4.5.2

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

@@ -37,6 +37,7 @@ import { getActiveWindow } from 'vscode/vscode/vs/base/browser/dom';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 import { isDefined } from 'vscode/vscode/vs/base/common/types';
 
+const _moduleId = "vs/workbench/contrib/debug/browser/debugSession";
 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) {
@@ -58,34 +59,34 @@ let DebugSession = class DebugSession {
         this.workbenchEnvironmentService = workbenchEnvironmentService;
         this.logService = logService;
         this.initialized = false;
-        this.sources = ( new Map());
-        this.threads = ( new Map());
+        this.sources = ( (new Map()));
+        this.threads = ( (new Map()));
         this.threadIds = [];
-        this.cancellationMap = ( new Map());
-        this.rawListeners = ( new DisposableStore());
-        this.globalDisposables = ( new DisposableStore());
+        this.cancellationMap = ( (new Map()));
+        this.rawListeners = ( (new DisposableStore()));
+        this.globalDisposables = ( (new DisposableStore()));
         this.stoppedDetails = [];
-        this.statusQueue = this.rawListeners.add(( new ThreadStatusScheduler()));
-        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.statusQueue = this.rawListeners.add(( (new ThreadStatusScheduler())));
+        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));
+            this.repl = ( (new ReplModel(this.configurationService)));
         }
         else {
             this.repl = this.parentSession.repl;
         }
         const toDispose = this.globalDisposables;
-        const replListener = toDispose.add(( new MutableDisposable()));
+        const replListener = toDispose.add(( (new MutableDisposable())));
         replListener.value = this.repl.onDidChangeElements(() => this._onDidChangeREPLElements.fire());
         if (lifecycleService) {
             toDispose.add(lifecycleService.onWillShutdown(() => {
@@ -97,8 +98,8 @@ let DebugSession = class DebugSession {
         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))) {
+        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) {
@@ -114,7 +115,7 @@ let DebugSession = class DebugSession {
                     }
                 }
             }
-        }, 800));
+        }, 800)));
         const parent = this._options.parentSession;
         if (parent) {
             toDispose.add(parent.onDidEndAdapter(() => {
@@ -133,7 +134,9 @@ let DebugSession = class DebugSession {
         this._subId = subId;
     }
     getMemory(memoryReference) {
-        return ( new MemoryRegion(memoryReference, this));
+        return (
+             (new MemoryRegion(memoryReference, this))
+        );
     }
     get subId() {
         return this._subId;
@@ -193,7 +196,7 @@ let DebugSession = class DebugSession {
         if (focusedThread && focusedThread.session === this) {
             return focusedThread.stopped ? 2  : 3 ;
         }
-        if (( this.getAllThreads().some(t => t.stopped))) {
+        if (( (this.getAllThreads().some(t => t.stopped)))) {
             return 2 ;
         }
         return 3 ;
@@ -272,7 +275,12 @@ let DebugSession = class DebugSession {
     }
     async launchOrAttach(config) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'launch or attach'));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                0,
+                "No debugger available, can not send '{0}'",
+                'launch or attach'
+            ))));
         }
         if (this.parentSession && this.parentSession.state === 0 ) {
             throw canceled();
@@ -323,7 +331,9 @@ let DebugSession = class DebugSession {
     }
     async restart() {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'restart'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'restart')
+            )));
         }
         this.cancelAllRequests();
         if (this._options.lifecycleManagedByParent && this.parentSession) {
@@ -335,7 +345,9 @@ let DebugSession = class DebugSession {
     }
     async sendBreakpoints(modelUri, breakpointsToSend, sourceModified) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'breakpoints'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'breakpoints')
+            )));
         }
         if (!this.raw.readyForBreakpoints) {
             return Promise.resolve(undefined);
@@ -349,12 +361,12 @@ let DebugSession = class DebugSession {
         }
         const response = await this.raw.setBreakpoints({
             source: rawSource,
-            lines: ( breakpointsToSend.map(bp => bp.sessionAgnosticData.lineNumber)),
-            breakpoints: ( breakpointsToSend.map(bp => bp.toDAP())),
+            lines: ( (breakpointsToSend.map(bp => bp.sessionAgnosticData.lineNumber))),
+            breakpoints: ( (breakpointsToSend.map(bp => bp.toDAP()))),
             sourceModified
         });
         if (response?.body) {
-            const data = ( new Map());
+            const data = ( (new Map()));
             for (let i = 0; i < breakpointsToSend.length; i++) {
                 data.set(breakpointsToSend[i].getId(), response.body.breakpoints[i]);
             }
@@ -363,12 +375,17 @@ let DebugSession = class DebugSession {
     }
     async sendFunctionBreakpoints(fbpts) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'function breakpoints'));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                0,
+                "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());
+                const data = ( (new Map()));
                 for (let i = 0; i < fbpts.length; i++) {
                     data.set(fbpts[i].getId(), response.body.breakpoints[i]);
                 }
@@ -378,21 +395,26 @@ let DebugSession = class DebugSession {
     }
     async sendExceptionBreakpoints(exbpts) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'exception breakpoints'));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                0,
+                "No debugger available, can not send '{0}'",
+                'exception breakpoints'
+            ))));
         }
         if (this.raw.readyForBreakpoints) {
             const args = this.capabilities.supportsExceptionFilterOptions ? {
                 filters: [],
-                filterOptions: ( exbpts.map(exb => {
+                filterOptions: ( (exbpts.map(exb => {
                     if (exb.condition) {
                         return { filterId: exb.filter, condition: exb.condition };
                     }
                     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());
+                const data = ( (new Map()));
                 for (let i = 0; i < exbpts.length; i++) {
                     data.set(exbpts[i].getId(), response.body.breakpoints[i]);
                 }
@@ -402,7 +424,9 @@ let DebugSession = class DebugSession {
     }
     dataBytesBreakpointInfo(address, bytes) {
         if (this.raw?.capabilities.supportsDataBreakpointBytes === false) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'sessionDoesNotSupporBytesBreakpoints', "Session does not support breakpoints with bytes"));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 1, "Session does not support breakpoints with bytes")
+            )));
         }
         return this._dataBreakpointInfo({ name: address, bytes, asAddress: true });
     }
@@ -411,20 +435,30 @@ let DebugSession = class DebugSession {
     }
     async _dataBreakpointInfo(args) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'data breakpoints info'));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                0,
+                "No debugger available, can not send '{0}'",
+                'data breakpoints info'
+            ))));
         }
         if (!this.raw.readyForBreakpoints) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'sessionNotReadyForBreakpoints', "Session is not ready for breakpoints"));
+            throw ( (new Error(localizeWithPath(_moduleId, 2, "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(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'data breakpoints'));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                0,
+                "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 };
@@ -432,10 +466,10 @@ let DebugSession = class DebugSession {
                 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());
+                const data = ( (new Map()));
                 let i = 0;
                 for (const dap of converted) {
                     if (!dap.dap) {
@@ -451,12 +485,17 @@ let DebugSession = class DebugSession {
     }
     async sendInstructionBreakpoints(instructionBreakpoints) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'instruction breakpoints'));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                0,
+                "No debugger available, can not send '{0}'",
+                '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());
+                const data = ( (new Map()));
                 for (let i = 0; i < instructionBreakpoints.length; i++) {
                     data.set(instructionBreakpoints[i].getId(), response.body.breakpoints[i]);
                 }
@@ -466,14 +505,19 @@ let DebugSession = class DebugSession {
     }
     async breakpointsLocations(uri, lineNumber) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'breakpoints locations'));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                0,
+                "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 })));
+        const positions = ( (response.body.breakpoints.map(bp => ({ lineNumber: bp.line, column: bp.column || 1 }))));
         return distinct(positions, p => `${p.lineNumber}:${p.column}`);
     }
     getDebugProtocolBreakpoint(breakpointId) {
@@ -481,20 +525,26 @@ let DebugSession = class DebugSession {
     }
     customRequest(request, args) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", request));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "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(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stackTrace'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "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(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'exceptionInfo'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'exceptionInfo')
+            )));
         }
         const response = await this.raw.exceptionInfo({ threadId });
         if (response) {
@@ -509,28 +559,36 @@ let DebugSession = class DebugSession {
     }
     scopes(frameId, threadId) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'scopes'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "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(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'variables'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "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(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'evaluate'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'evaluate')
+            )));
         }
         return this.raw.evaluate({ expression, frameId, context });
     }
     async restartFrame(frameId, threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'restartFrame'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'restartFrame')
+            )));
         }
         await this.raw.restartFrame({ frameId }, threadId);
     }
@@ -543,7 +601,9 @@ let DebugSession = class DebugSession {
     async next(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'next'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'next')
+            )));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.next({ threadId, granularity });
@@ -551,7 +611,9 @@ let DebugSession = class DebugSession {
     async stepIn(threadId, targetId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepIn'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'stepIn')
+            )));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepIn({ threadId, targetId, granularity });
@@ -559,7 +621,9 @@ let DebugSession = class DebugSession {
     async stepOut(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepOut'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'stepOut')
+            )));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepOut({ threadId, granularity });
@@ -567,7 +631,9 @@ let DebugSession = class DebugSession {
     async stepBack(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepBack'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'stepBack')
+            )));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepBack({ threadId, granularity });
@@ -575,61 +641,78 @@ let DebugSession = class DebugSession {
     async continue(threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'continue'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'continue')
+            )));
         }
         await this.raw.continue({ threadId });
     }
     async reverseContinue(threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'reverse continue'));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                0,
+                "No debugger available, can not send '{0}'",
+                'reverse continue'
+            ))));
         }
         await this.raw.reverseContinue({ threadId });
     }
     async pause(threadId) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'pause'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'pause')
+            )));
         }
         await this.raw.pause({ threadId });
     }
     async terminateThreads(threadIds) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'terminateThreads'));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                0,
+                "No debugger available, can not send '{0}'",
+                'terminateThreads'
+            ))));
         }
         await this.raw.terminateThreads({ threadIds });
     }
     setVariable(variablesReference, name, value) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'setVariable'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "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(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'setExpression'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "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(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'gotoTargets'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'gotoTargets')
+            )));
         }
         return this.raw.gotoTargets({ source, line, column });
     }
     goto(threadId, targetId) {
         if (!this.raw) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'goto'));
+            throw ( (new Error(
+                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'goto')
+            )));
         }
         return this.raw.goto({ threadId, targetId });
     }
     loadSource(resource) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'loadSource'
-            )))));
+            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'loadSource'))))));
         }
         const source = this.getSourceForUri(resource);
         let rawSource;
@@ -644,16 +727,18 @@ let DebugSession = class DebugSession {
     }
     async getLoadedSources() {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'noDebugAdapter',
+            return Promise.reject(( (new Error(( localizeWithPath(
+                _moduleId,
+                0,
                 "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)));
+            return (
+                 (response.body.sources.map(src => this.getSource(src)))
+            );
         }
         else {
             return [];
@@ -661,12 +746,7 @@ let DebugSession = class DebugSession {
     }
     async completions(frameId, threadId, text, position, overwriteBefore, token) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'completions'
-            )))));
+            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'completions'))))));
         }
         const sessionCancelationToken = this.getNewCancellationToken(threadId, token);
         return this.raw.completions({
@@ -678,58 +758,33 @@ let DebugSession = class DebugSession {
     }
     async stepInTargets(frameId) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'stepInTargets'
-            )))));
+            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "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(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'cancel'
-            )))));
+            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "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(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'disassemble'
-            )))));
+            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "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(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'readMemory'
-            )))));
+            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "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(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'disassemble'
-            )))));
+            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'disassemble'))))));
         }
         return this.raw.writeMemory({ memoryReference, offset, allowPartial, data });
     }
@@ -778,8 +833,8 @@ let DebugSession = class DebugSession {
         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)));
+            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);
@@ -840,16 +895,8 @@ let DebugSession = class DebugSession {
         }
         this.rawListeners.add(this.raw.onDidInitialize(async () => {
             status(this.configuration.noDebug
-                ? ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'debuggingStartedNoDebug',
-                "Started running without debugging."
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'debuggingStarted',
-                "Debugging started."
-            )));
+                ? ( localizeWithPath(_moduleId, 3, "Started running without debugging."))
+                : ( localizeWithPath(_moduleId, 4, "Debugging started.")));
             const sendConfigurationDone = async () => {
                 if (this.raw && this.raw.capabilities.supportsConfigurationDoneRequest) {
                     try {
@@ -876,9 +923,9 @@ let DebugSession = class DebugSession {
             statusQueue.cancel([event.body.threadId]);
             if (event.body.reason === 'started') {
                 if (!this.fetchThreadsScheduler) {
-                    this.fetchThreadsScheduler = ( new RunOnceScheduler(() => {
+                    this.fetchThreadsScheduler = ( (new RunOnceScheduler(() => {
                         this.fetchThreads();
-                    }, 100));
+                    }, 100)));
                     this.rawListeners.add(this.fetchThreadsScheduler);
                 }
                 if (!this.fetchThreadsScheduler.isScheduled()) {
@@ -896,11 +943,7 @@ let DebugSession = class DebugSession {
             }
         }));
         this.rawListeners.add(this.raw.onDidTerminateDebugee(async (event) => {
-            status(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugSession',
-                'debuggingStopped',
-                "Debugging stopped."
-            )));
+            status(( localizeWithPath(_moduleId, 5, "Debugging stopped.")));
             if (event.body && event.body.restart) {
                 await this.debugService.restartSession(this, event.body.restart);
             }
@@ -927,7 +970,7 @@ let DebugSession = class DebugSession {
             this.model.clearThreads(this.getId(), false, threadId);
             this._onDidChangeState.fire();
         }));
-        const outputQueue = ( new Queue());
+        const outputQueue = ( (new Queue()));
         this.rawListeners.add(this.raw.onDidOutput(async (event) => {
             const outputSeverity = event.body.category === 'stderr' ? Severity$1.Error : event.body.category === 'console' ? Severity$1.Warning : Severity$1.Info;
             if (event.body.variablesReference) {
@@ -936,7 +979,7 @@ let DebugSession = class DebugSession {
                     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 container = ( (new ExpressionContainer(this, undefined, event.body.variablesReference, generateUuid())));
                 const children = container.getChildren();
                 outputQueue.queue(async () => {
                     const resolved = await children;
@@ -1001,7 +1044,7 @@ let DebugSession = class DebugSession {
                         lineNumber: event.body.breakpoint.line,
                     }], false);
                 if (bps.length === 1) {
-                    const data = ( new Map([[bps[0].getId(), event.body.breakpoint]]));
+                    const data = ( (new Map([[bps[0].getId(), event.body.breakpoint]])));
                     this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
                 }
             }
@@ -1021,19 +1064,19 @@ let DebugSession = class DebugSession {
                     if (!breakpoint.column) {
                         event.body.breakpoint.column = undefined;
                     }
-                    const data = ( new Map([[breakpoint.getId(), event.body.breakpoint]]));
+                    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]]));
+                    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]]));
+                    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]]));
+                    const data = ( (new Map([[exceptionBreakpoint.getId(), event.body.breakpoint]])));
                     this.model.setBreakpointSessionData(this.getId(), this.capabilities, data);
                 }
             }
@@ -1066,7 +1109,7 @@ let DebugSession = class DebugSession {
                 this.model.clearThreads(this.getId(), true);
                 const details = this.stoppedDetails;
                 this.stoppedDetails.length = 1;
-                await Promise.all(( details.map(d => this.handleStop(d))));
+                await Promise.all(( (details.map(d => this.handleStop(d)))));
             }
             const viewModel = this.debugService.getViewModel();
             if (viewModel.focusedSession === this) {
@@ -1084,7 +1127,7 @@ let DebugSession = class DebugSession {
         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));
+            const focusedThreadDoesNotExist = focusedThread !== undefined && focusedThread.session === this && !( (this.threads.has(focusedThread.threadId)));
             if (focusedThreadDoesNotExist) {
                 this.debugService.focusStackFrame(undefined, undefined);
             }
@@ -1146,17 +1189,17 @@ let DebugSession = class DebugSession {
             }
             breakpoints = this.getBreakpointsAtPosition(frame.source.uri, frame.range.startLineNumber, frame.range.endLineNumber, frame.range.startColumn, frame.range.endColumn);
         }
-        const urisToResend = ( new Set());
+        const urisToResend = ( (new Set()));
         this.model.getBreakpoints({ triggeredOnly: true, enabledOnly: true }).forEach(bp => {
             breakpoints.forEach(cbp => {
                 if (bp.enabled && bp.triggeredBy === cbp.getId()) {
                     bp.setSessionDidTrigger(this.getId());
-                    urisToResend.add(( bp.uri.toString()));
+                    urisToResend.add(( (bp.uri.toString())));
                 }
             });
         });
         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) {
@@ -1196,11 +1239,11 @@ let DebugSession = class DebugSession {
         this.globalDisposables.dispose();
     }
     getSourceForUri(uri) {
-        return this.sources.get(( this.uriIdentityService.asCanonicalUri(uri).toString()));
+        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());
+        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;
@@ -1225,7 +1268,7 @@ let DebugSession = class DebugSession {
         }
     }
     getNewCancellationToken(threadId, token) {
-        const tokenSource = ( new CancellationTokenSource(token));
+        const tokenSource = ( (new CancellationTokenSource(token)));
         const tokens = this.cancellationMap.get(threadId) || [];
         tokens.push(tokenSource);
         this.cancellationMap.set(threadId, tokens);
@@ -1251,34 +1294,34 @@ 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))
-], 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)))
+], DebugSession)));
 class ThreadStatusScheduler extends Disposable {
     constructor() {
         super(...arguments);
         this.pendingCancellations = [];
-        this.threadOps = this._register(( new DisposableMap()));
+        this.threadOps = this._register(( (new DisposableMap())));
     }
     async run(threadIdsP, operation) {
-        const cancelledWhileLookingUpThreads = ( new Set());
+        const cancelledWhileLookingUpThreads = ( (new Set()));
         this.pendingCancellations.push(cancelledWhileLookingUpThreads);
         const threadIds = await threadIdsP;
         for (let i = 0; i < this.pendingCancellations.length; i++) {
@@ -1293,18 +1336,18 @@ class ThreadStatusScheduler extends Disposable {
                 }
             }
         }
-        if (( cancelledWhileLookingUpThreads.has(undefined))) {
+        if (( (cancelledWhileLookingUpThreads.has(undefined)))) {
             return;
         }
-        await Promise.all(( threadIds.map(threadId => {
-            if (( cancelledWhileLookingUpThreads.has(threadId))) {
+        await Promise.all(( (threadIds.map(threadId => {
+            if (( (cancelledWhileLookingUpThreads.has(threadId)))) {
                 return;
             }
             this.threadOps.get(threadId)?.cancel();
-            const cts = ( new CancellationTokenSource());
+            const cts = ( (new CancellationTokenSource()));
             this.threadOps.set(threadId, cts);
             return operation(threadId, cts.token);
-        })));
+        }))));
     }
     cancel(threadIds) {
         if (!threadIds) {