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

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

@@ -52,6 +52,7 @@ import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle
 import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite.service';
 import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
 
+const _moduleId = "vs/workbench/contrib/debug/browser/debugService";
 let DebugService = class DebugService {
     constructor(editorService, paneCompositeService, viewsService, viewDescriptorService, notificationService, dialogService, layoutService, contextService, contextKeyService, lifecycleService, instantiationService, extensionService, fileService, configurationService, extensionHostDebugService, activityService, commandService, quickInputService, workspaceTrustRequestService, uriIdentityService) {
         this.editorService = editorService;
@@ -74,16 +75,16 @@ let DebugService = class DebugService {
         this.quickInputService = quickInputService;
         this.workspaceTrustRequestService = workspaceTrustRequestService;
         this.uriIdentityService = uriIdentityService;
-        this.restartingSessions = ( new Set());
-        this.disposables = ( new DisposableStore());
+        this.restartingSessions = ( (new Set()));
+        this.disposables = ( (new DisposableStore()));
         this.initializing = false;
-        this.sessionCancellationTokens = ( new Map());
+        this.sessionCancellationTokens = ( (new Map()));
         this.haveDoneLazySetup = false;
-        this.breakpointsToSendOnResourceSaved = ( new Set());
-        this._onDidChangeState = ( new Emitter());
-        this._onDidNewSession = ( new Emitter());
-        this._onWillNewSession = ( new Emitter());
-        this._onDidEndSession = ( new Emitter());
+        this.breakpointsToSendOnResourceSaved = ( (new Set()));
+        this._onDidChangeState = ( (new Emitter()));
+        this._onDidNewSession = ( (new Emitter()));
+        this._onWillNewSession = ( (new Emitter()));
+        this._onDidEndSession = ( (new Emitter()));
         this.adapterManager = this.instantiationService.createInstance(AdapterManager, { onDidNewSession: this.onDidNewSession });
         this.disposables.add(this.adapterManager);
         this.configurationManager = this.instantiationService.createInstance(ConfigurationManager, this.adapterManager);
@@ -92,7 +93,7 @@ let DebugService = class DebugService {
         this.chosenEnvironments = this.debugStorage.loadChosenEnvironments();
         this.model = this.instantiationService.createInstance(DebugModel, this.debugStorage);
         this.telemetry = this.instantiationService.createInstance(DebugTelemetry, this.model);
-        this.viewModel = ( new ViewModel(contextKeyService));
+        this.viewModel = ( (new ViewModel(contextKeyService)));
         this.taskRunner = this.instantiationService.createInstance(DebugTaskRunner);
         this.disposables.add(this.fileService.onDidFilesChange(e => this.onFileChanges(e)));
         this.disposables.add(this.lifecycleService.onWillShutdown(this.dispose, this));
@@ -131,16 +132,7 @@ let DebugService = class DebugService {
             if (numberOfSessions > 0) {
                 const viewContainer = this.viewDescriptorService.getViewContainerByViewId(CALLSTACK_VIEW_ID);
                 if (viewContainer) {
-                    this.activity = this.activityService.showViewContainerActivity(viewContainer.id, { badge: ( new NumberBadge(numberOfSessions, n => n === 1 ? ( localizeWithPath(
-                        'vs/workbench/contrib/debug/browser/debugService',
-                        '1activeSession',
-                        "1 active session"
-                    )) : ( localizeWithPath(
-                        'vs/workbench/contrib/debug/browser/debugService',
-                        'nActiveSessions',
-                        "{0} active sessions",
-                        n
-                    )))) });
+                    this.activity = this.activityService.showViewContainerActivity(viewContainer.id, { badge: ( (new NumberBadge(numberOfSessions, n => n === 1 ? ( localizeWithPath(_moduleId, 0, "1 active session")) : ( localizeWithPath(_moduleId, 1, "{0} active sessions", n))))) });
                 }
             }
         }));
@@ -263,18 +255,18 @@ let DebugService = class DebugService {
     }
     lazySetup() {
         if (!this.haveDoneLazySetup) {
-            this.disposables.add(this.fileService.registerProvider(DEBUG_MEMORY_SCHEME, ( new DebugMemoryFileSystemProvider(this))));
+            this.disposables.add(this.fileService.registerProvider(DEBUG_MEMORY_SCHEME, ( (new DebugMemoryFileSystemProvider(this)))));
             this.haveDoneLazySetup = true;
         }
     }
     async startDebugging(launch, configOrName, options, saveBeforeStart = !options?.parentSession) {
         const message = options && options.noDebug ? ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugService',
-            'runTrust',
+            _moduleId,
+            2,
             "Running executes build tasks and program code from your workspace."
         )) : ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugService',
-            'debugTrust',
+            _moduleId,
+            3,
             "Debugging executes build tasks and program code from your workspace."
         ));
         const trust = await this.workspaceTrustRequestService.requestWorkspaceTrust({ message });
@@ -304,7 +296,11 @@ let DebugService = class DebugService {
             }
             if (compound) {
                 if (!compound.configurations) {
-                    throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugService', { key: 'compoundMustHaveConfigurations', comment: ['compound indicates a "compounds" configuration item', '"configurations" is an attribute and should not be localized'] }, "Compound must have \"configurations\" attribute set in order to start multiple configurations."));
+                    throw ( (new Error(localizeWithPath(
+                        _moduleId,
+                        4,
+                        "Compound must have \"configurations\" attribute set in order to start multiple configurations."
+                    ))));
                 }
                 if (compound.preLaunchTask) {
                     const taskResult = await this.taskRunner.runTaskAndCheckErrors(launch?.workspace || this.contextService.getWorkspace(), compound.preLaunchTask);
@@ -314,9 +310,9 @@ let DebugService = class DebugService {
                     }
                 }
                 if (compound.stopAll) {
-                    options = { ...options, compoundRoot: ( new DebugCompoundRoot()) };
+                    options = { ...options, compoundRoot: ( (new DebugCompoundRoot())) };
                 }
-                const values = await Promise.all(( compound.configurations.map(configData => {
+                const values = await Promise.all(( (compound.configurations.map(configData => {
                     const name = typeof configData === 'string' ? configData : configData.name;
                     if (name === compound.name) {
                         return Promise.resolve(false);
@@ -331,8 +327,18 @@ let DebugService = class DebugService {
                             launchForName = launch;
                         }
                         else {
-                            throw new Error(launchesContainingName.length === 0 ? localizeWithPath('vs/workbench/contrib/debug/browser/debugService', 'noConfigurationNameInWorkspace', "Could not find launch configuration '{0}' in the workspace.", name)
-                                : localizeWithPath('vs/workbench/contrib/debug/browser/debugService', 'multipleConfigurationNamesInWorkspace', "There are multiple launch configurations '{0}' in the workspace. Use folder name to qualify the configuration.", name));
+                            throw ( (new Error(launchesContainingName.length === 0 ? localizeWithPath(
+                                _moduleId,
+                                5,
+                                "Could not find launch configuration '{0}' in the workspace.",
+                                name
+                            )
+                                : localizeWithPath(
+                                _moduleId,
+                                6,
+                                "There are multiple launch configurations '{0}' in the workspace. Use folder name to qualify the configuration.",
+                                name
+                            ))));
                         }
                     }
                     else if (configData.folder) {
@@ -341,28 +347,31 @@ let DebugService = class DebugService {
                             launchForName = launchesMatchingConfigData[0];
                         }
                         else {
-                            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugService', 'noFolderWithName', "Can not find folder with name '{0}' for configuration '{1}' in compound '{2}'.", configData.folder, configData.name, compound.name));
+                            throw ( (new Error(localizeWithPath(
+                                _moduleId,
+                                7,
+                                "Can not find folder with name '{0}' for configuration '{1}' in compound '{2}'.",
+                                configData.folder,
+                                configData.name,
+                                compound.name
+                            ))));
                         }
                     }
                     return this.createSession(launchForName, launchForName.getConfiguration(name), options);
-                })));
+                }))));
                 const result = values.every(success => !!success);
                 this.endInitializingState();
                 return result;
             }
             if (configOrName && !config) {
                 const message = !!launch ? ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/debugService',
-                    'configMissing',
+                    _moduleId,
+                    8,
                     "Configuration '{0}' is missing in 'launch.json'.",
                     typeof configOrName === 'string' ? configOrName : configOrName.name
                 )) :
-                    ( localizeWithPath(
-                        'vs/workbench/contrib/debug/browser/debugService',
-                        'launchJsonDoesNotExist',
-                        "'launch.json' does not exist for passed workspace folder."
-                    ));
-                throw new Error(message);
+                    ( localizeWithPath(_moduleId, 9, "'launch.json' does not exist for passed workspace folder."));
+                throw ( (new Error(message)));
             }
             const result = await this.createSession(launch, config, options);
             this.endInitializingState();
@@ -394,7 +403,7 @@ let DebugService = class DebugService {
         if (!type) {
             activeEditor = this.editorService.activeEditor;
             if (activeEditor && activeEditor.resource) {
-                type = this.chosenEnvironments[( activeEditor.resource.toString())];
+                type = this.chosenEnvironments[( (activeEditor.resource.toString()))];
             }
             if (!type) {
                 guess = await this.adapterManager.guessDebugger(false);
@@ -403,7 +412,7 @@ let DebugService = class DebugService {
                 }
             }
         }
-        const initCancellationToken = ( new CancellationTokenSource());
+        const initCancellationToken = ( (new CancellationTokenSource()));
         const sessionId = generateUuid();
         this.sessionCancellationTokens.set(sessionId, initCancellationToken);
         const configByProviders = await this.configurationManager.resolveConfigurationByProviders(launch && launch.workspace ? launch.workspace.uri : undefined, type, config, initCancellationToken.token);
@@ -434,39 +443,34 @@ let DebugService = class DebugService {
                     let message;
                     if (configByProviders.request !== 'attach' && configByProviders.request !== 'launch') {
                         message = configByProviders.request ? ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugService',
-                            'debugRequestNotSupported',
+                            _moduleId,
+                            10,
                             "Attribute '{0}' has an unsupported value '{1}' in the chosen debug configuration.",
                             'request',
                             configByProviders.request
                         ))
                             : ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugService',
-                            'debugRequesMissing',
+                            _moduleId,
+                            11,
                             "Attribute '{0}' is missing from the chosen debug configuration.",
                             'request'
                         ));
                     }
                     else {
                         message = resolvedConfig.type ? ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugService',
-                            'debugTypeNotSupported',
+                            _moduleId,
+                            12,
                             "Configured debug type '{0}' is not supported.",
                             resolvedConfig.type
                         )) :
                             ( localizeWithPath(
-                                'vs/workbench/contrib/debug/browser/debugService',
-                                'debugTypeMissing',
+                                _moduleId,
+                                13,
                                 "Missing property 'type' for the chosen launch configuration."
                             ));
                     }
                     const actionList = [];
-                    actionList.push(( new Action('installAdditionalDebuggers', ( localizeWithPath(
-                        'vs/workbench/contrib/debug/browser/debugService',
-                        { key: 'installAdditionalDebuggers', comment: ['Placeholder is the debug type, so for example "node", "python"'] },
-                        "Install {0} Extension",
-                        resolvedConfig.type
-                    )), undefined, true, async () => this.commandService.executeCommand('debug.installAdditionalDebuggers', resolvedConfig?.type))));
+                    actionList.push(( (new Action('installAdditionalDebuggers', ( localizeWithPath(_moduleId, 14, "Install {0} Extension", resolvedConfig.type)), undefined, true, async () => this.commandService.executeCommand('debug.installAdditionalDebuggers', resolvedConfig?.type)))));
                     await this.showError(message, actionList);
                     return false;
                 }
@@ -476,7 +480,7 @@ let DebugService = class DebugService {
                 }
                 const result = await this.doCreateSession(sessionId, launch?.workspace, { resolved: resolvedConfig, unresolved: unresolvedConfig }, options);
                 if (result && guess && activeEditor && activeEditor.resource) {
-                    this.chosenEnvironments[( activeEditor.resource.toString())] = guess.type;
+                    this.chosenEnvironments[( (activeEditor.resource.toString()))] = guess.type;
                     this.debugStorage.storeChosenEnvironments(this.chosenEnvironments);
                 }
                 return result;
@@ -487,8 +491,8 @@ let DebugService = class DebugService {
                 }
                 else if (this.contextService.getWorkbenchState() === 1 ) {
                     await this.showError(( localizeWithPath(
-                        'vs/workbench/contrib/debug/browser/debugService',
-                        'noFolderWorkspaceDebugError',
+                        _moduleId,
+                        15,
                         "The active file can not be debugged. Make sure it is saved and that you have a debug extension installed for that file type."
                     )));
                 }
@@ -505,10 +509,10 @@ let DebugService = class DebugService {
     }
     async doCreateSession(sessionId, root, configuration, options) {
         const session = this.instantiationService.createInstance(DebugSession, sessionId, configuration, root, this.model, options);
-        if (options?.startedByUser && ( this.model.getSessions().some(s => s.getLabel() === session.getLabel())) && configuration.resolved.suppressMultipleSessionWarning !== true) {
+        if (options?.startedByUser && ( (this.model.getSessions().some(s => s.getLabel() === session.getLabel()))) && configuration.resolved.suppressMultipleSessionWarning !== true) {
             const result = await this.dialogService.confirm({ message: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugService',
-                'multipleSession',
+                _moduleId,
+                16,
                 "'{0}' is already running. Do you want to start another instance?",
                 session.getLabel()
             )) });
@@ -575,13 +579,13 @@ let DebugService = class DebugService {
         }
     }
     registerSessionListeners(session) {
-        const listenerDisposables = ( new DisposableStore());
+        const listenerDisposables = ( (new DisposableStore()));
         this.disposables.add(listenerDisposables);
-        const sessionRunningScheduler = listenerDisposables.add(( new RunOnceScheduler(() => {
+        const sessionRunningScheduler = listenerDisposables.add(( (new RunOnceScheduler(() => {
             if (session.state === 3  && this.viewModel.focusedSession === session) {
                 this.viewModel.setFocus(undefined, this.viewModel.focusedThread, session, false);
             }
-        }, 200)));
+        }, 200))));
         listenerDisposables.add(session.onDidChangeState(() => {
             if (session.state === 3  && this.viewModel.focusedSession === session) {
                 sessionRunningScheduler.schedule();
@@ -599,10 +603,10 @@ let DebugService = class DebugService {
             if (adapterExitEvent) {
                 if (adapterExitEvent.error) {
                     this.notificationService.error(( localizeWithPath(
-                        'vs/workbench/contrib/debug/browser/debugService',
-                        'debugAdapterCrash',
+                        _moduleId,
+                        17,
                         "Debug adapter process has terminated unexpectedly ({0})",
-                        adapterExitEvent.error.message || ( adapterExitEvent.error.toString())
+                        adapterExitEvent.error.message || ( (adapterExitEvent.error.toString()))
                     )));
                 }
                 this.telemetry.logDebugSessionStop(session, adapterExitEvent);
@@ -628,7 +632,7 @@ let DebugService = class DebugService {
                 });
                 this.editorService.closeEditors(editorsToClose);
             }
-            this._onDidEndSession.fire({ session, restart: ( this.restartingSessions.has(session)) });
+            this._onDidEndSession.fire({ session, restart: ( (this.restartingSessions.has(session))) });
             const focusedSession = this.viewModel.focusedSession;
             if (focusedSession && focusedSession.getId() === session.getId()) {
                 const { session, thread, stackFrame } = getStackFrameThreadAndSessionToFocus(this.model, undefined, undefined, undefined, focusedSession);
@@ -690,7 +694,7 @@ let DebugService = class DebugService {
         }
         let resolved = session.configuration;
         if (launch && needsToSubstitute && unresolved) {
-            const initCancellationToken = ( new CancellationTokenSource());
+            const initCancellationToken = ( (new CancellationTokenSource()));
             this.sessionCancellationTokens.set(session.getId(), initCancellationToken);
             const resolvedByProviders = await this.configurationManager.resolveConfigurationByProviders(launch.workspace ? launch.workspace.uri : undefined, unresolved.type, unresolved, initCancellationToken.token);
             if (resolvedByProviders) {
@@ -742,25 +746,27 @@ let DebugService = class DebugService {
             else {
                 await session.terminate(true);
             }
-            return ( new Promise((c, e) => {
-                setTimeout(async () => {
-                    const taskResult = await runTasks();
-                    if (taskResult !== 1 ) {
-                        return c(false);
-                    }
-                    if (!resolved) {
-                        return c(false);
-                    }
-                    try {
-                        await this.launchOrAttachToSession(session, shouldFocus);
-                        this._onDidNewSession.fire(session);
-                        c(true);
-                    }
-                    catch (error) {
-                        e(error);
-                    }
-                }, 300);
-            }));
+            return (
+                 (new Promise((c, e) => {
+                    setTimeout(async () => {
+                        const taskResult = await runTasks();
+                        if (taskResult !== 1 ) {
+                            return c(false);
+                        }
+                        if (!resolved) {
+                            return c(false);
+                        }
+                        try {
+                            await this.launchOrAttachToSession(session, shouldFocus);
+                            this._onDidNewSession.fire(session);
+                            c(true);
+                        }
+                        catch (error) {
+                            e(error);
+                        }
+                    }, 300);
+                }))
+            );
         });
     }
     async stopSession(session, disconnect = false, suspend = false) {
@@ -774,7 +780,7 @@ let DebugService = class DebugService {
             this.endInitializingState();
             this.cancelTokens(undefined);
         }
-        return Promise.all(( sessions.map(s => disconnect ? s.disconnect(undefined, suspend) : s.terminate())));
+        return Promise.all(( (sessions.map(s => disconnect ? s.disconnect(undefined, suspend) : s.terminate()))));
     }
     async substituteVariables(launch, config) {
         const dbg = this.adapterManager.getDebugger(config.type);
@@ -800,23 +806,23 @@ let DebugService = class DebugService {
         return Promise.resolve(config);
     }
     async showError(message, errorActions = [], promptLaunchJson = true) {
-        const configureAction = ( new Action(
+        const configureAction = ( (new Action(
             DEBUG_CONFIGURE_COMMAND_ID,
             DEBUG_CONFIGURE_LABEL,
             undefined,
             true,
             () => this.commandService.executeCommand(DEBUG_CONFIGURE_COMMAND_ID)
-        ));
+        )));
         const actions = errorActions.filter((action) => action.id.endsWith('.command')).length > 0 ?
             errorActions :
             [...errorActions, ...(promptLaunchJson ? [configureAction] : [])];
         await this.dialogService.prompt({
             type: Severity$1.Error,
             message,
-            buttons: ( actions.map(action => ({
+            buttons: ( (actions.map(action => ({
                 label: action.label,
                 run: () => action.run()
-            }))),
+            })))),
             cancelButton: true
         });
     }
@@ -834,8 +840,8 @@ let DebugService = class DebugService {
                         if (lineNumber >= 1 && lineNumber <= model.getLineCount()) {
                             const lineContent = control.getModel().getLineContent(lineNumber);
                             alert(( localizeWithPath(
-                                'vs/workbench/contrib/debug/browser/debugService',
-                                { key: 'debuggingPaused', comment: ['First placeholder is the file line content, second placeholder is the reason why debugging is stopped, for example "breakpoint", third is the stack frame name, and last is the line number.'] },
+                                _moduleId,
+                                18,
                                 "{0}, debugging paused {1}, {2}:{3}",
                                 lineContent,
                                 thread && thread.stoppedDetails ? `, reason ${thread.stoppedDetails.reason}` : '',
@@ -909,8 +915,8 @@ let DebugService = class DebugService {
         const breakpoints = this.model.addBreakpoints(uri, rawBreakpoints);
         if (ariaAnnounce) {
             breakpoints.forEach(bp => status(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugService',
-                'breakpointAdded',
+                _moduleId,
+                19,
                 "Added breakpoint, line {0}, file {1}",
                 bp.lineNumber,
                 uri.fsPath
@@ -936,17 +942,19 @@ let DebugService = class DebugService {
         const breakpoints = this.model.getBreakpoints();
         const toRemove = breakpoints.filter(bp => !id || bp.getId() === id);
         toRemove.forEach(bp => status(( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugService',
-            'breakpointRemoved',
+            _moduleId,
+            20,
             "Removed breakpoint, line {0}, file {1}",
             bp.lineNumber,
             bp.uri.fsPath
         ))));
-        const urisToClear = ( new Set(( toRemove.map(bp => ( bp.originalUri.toString())))));
+        const urisToClear = ( (new Set(
+             (toRemove.map(bp => ( (bp.originalUri.toString()))))
+        )));
         this.model.removeBreakpoints(toRemove);
-        this.unlinkTriggeredBreakpoints(breakpoints, toRemove).forEach(uri => urisToClear.add(( uri.toString())));
+        this.unlinkTriggeredBreakpoints(breakpoints, toRemove).forEach(uri => urisToClear.add(( (uri.toString()))));
         this.debugStorage.storeBreakpoints(this.model);
-        await Promise.all(( [...urisToClear].map(uri => this.sendBreakpoints(( URI.parse(uri))))));
+        await Promise.all(( ([...urisToClear].map(uri => this.sendBreakpoints(( (URI.parse(uri))))))));
     }
     setBreakpointsActivated(activated) {
         this.model.setBreakpointsActivated(activated);
@@ -1006,8 +1014,8 @@ let DebugService = class DebugService {
         await this.sendExceptionBreakpoints();
     }
     async sendAllBreakpoints(session) {
-        const setBreakpointsPromises = ( distinct(this.model.getBreakpoints(), bp => ( bp.originalUri.toString()))
-            .map(bp => this.sendBreakpoints(bp.originalUri, false, session)));
+        const setBreakpointsPromises = ( (distinct(this.model.getBreakpoints(), bp => ( (bp.originalUri.toString())))
+            .map(bp => this.sendBreakpoints(bp.originalUri, false, session))));
         if (session?.capabilities.supportsConfigurationDoneRequest) {
             await Promise.all([
                 ...setBreakpointsPromises,
@@ -1030,7 +1038,7 @@ let DebugService = class DebugService {
         for (const removed of removedBreakpoints) {
             for (const existing of allBreakpoints) {
                 if (!removedBreakpoints.includes(existing) && existing.triggeredBy === removed.getId()) {
-                    this.model.updateBreakpoints(( new Map([[existing.getId(), { triggeredBy: undefined }]])));
+                    this.model.updateBreakpoints(( (new Map([[existing.getId(), { triggeredBy: undefined }]]))));
                     affectedUris.push(existing.originalUri);
                 }
             }
@@ -1046,9 +1054,9 @@ let DebugService = class DebugService {
                 }
             }
         }
-        await Promise.all(( this.model.getBreakpoints()
+        await Promise.all(( (this.model.getBreakpoints()
             .filter(bp => bp.triggeredBy === breakpoint.getId() && bp.enabled !== enable)
-            .map(bp => this.enableOrDisableBreakpoints(enable, bp))));
+            .map(bp => this.enableOrDisableBreakpoints(enable, bp)))));
     }
     async sendBreakpoints(modelUri, sourceModified = false, session) {
         const breakpointsToSend = this.model.getBreakpoints({ originalUri: modelUri, enabledOnly: true });
@@ -1170,13 +1178,13 @@ let DebugService = class DebugService {
         }
         if (!breakpoint.verified) {
             let listener;
-            await raceTimeout(( new Promise(resolve => {
+            await raceTimeout(( (new Promise(resolve => {
                 listener = debugModel.onDidChangeBreakpoints(() => {
                     if (breakpoint.verified) {
                         resolve();
                     }
                 });
-            })), 2000);
+            }))), 2000);
             listener.dispose();
         }
         let bestThread = viewModel.focusedThread;
@@ -1211,28 +1219,28 @@ let DebugService = class DebugService {
         return { thread: bestThread, breakpoint };
     }
 };
-DebugService = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IPaneCompositePartService)),
-    ( __param(2, IViewsService)),
-    ( __param(3, IViewDescriptorService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IDialogService)),
-    ( __param(6, IWorkbenchLayoutService)),
-    ( __param(7, IWorkspaceContextService)),
-    ( __param(8, IContextKeyService)),
-    ( __param(9, ILifecycleService)),
-    ( __param(10, IInstantiationService)),
-    ( __param(11, IExtensionService)),
-    ( __param(12, IFileService)),
-    ( __param(13, IConfigurationService)),
-    ( __param(14, IExtensionHostDebugService)),
-    ( __param(15, IActivityService)),
-    ( __param(16, ICommandService)),
-    ( __param(17, IQuickInputService)),
-    ( __param(18, IWorkspaceTrustRequestService)),
-    ( __param(19, IUriIdentityService))
-], DebugService));
+DebugService = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, IPaneCompositePartService))),
+    ( (__param(2, IViewsService))),
+    ( (__param(3, IViewDescriptorService))),
+    ( (__param(4, INotificationService))),
+    ( (__param(5, IDialogService))),
+    ( (__param(6, IWorkbenchLayoutService))),
+    ( (__param(7, IWorkspaceContextService))),
+    ( (__param(8, IContextKeyService))),
+    ( (__param(9, ILifecycleService))),
+    ( (__param(10, IInstantiationService))),
+    ( (__param(11, IExtensionService))),
+    ( (__param(12, IFileService))),
+    ( (__param(13, IConfigurationService))),
+    ( (__param(14, IExtensionHostDebugService))),
+    ( (__param(15, IActivityService))),
+    ( (__param(16, ICommandService))),
+    ( (__param(17, IQuickInputService))),
+    ( (__param(18, IWorkspaceTrustRequestService))),
+    ( (__param(19, IUriIdentityService)))
+], DebugService)));
 function getStackFrameThreadAndSessionToFocus(model, stackFrame, thread, session, avoidSession) {
     if (!session) {
         if (stackFrame || thread) {
@@ -1264,7 +1272,7 @@ async function sendToOneOrAllSessions(model, session, send) {
         await send(session);
     }
     else {
-        await Promise.all(( model.getSessions().map(s => send(s))));
+        await Promise.all(( (model.getSessions().map(s => send(s)))));
     }
 }