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

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

@@ -38,13 +38,25 @@ import { debugConfigure } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 
 const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
 jsonRegistry.registerSchema(launchSchemaId, launchSchema);
-const DEBUG_SELECTED_CONFIG_NAME_KEY = 'debug.selectedconfigname';
-const DEBUG_SELECTED_ROOT = 'debug.selectedroot';
-const DEBUG_SELECTED_TYPE = 'debug.selectedtype';
-const DEBUG_RECENT_DYNAMIC_CONFIGURATIONS = 'debug.recentdynamicconfigurations';
-const ON_DEBUG_DYNAMIC_CONFIGURATIONS_NAME = 'onDebugDynamicConfigurations';
+const DEBUG_SELECTED_CONFIG_NAME_KEY = "debug.selectedconfigname";
+const DEBUG_SELECTED_ROOT = "debug.selectedroot";
+const DEBUG_SELECTED_TYPE = "debug.selectedtype";
+const DEBUG_RECENT_DYNAMIC_CONFIGURATIONS = "debug.recentdynamicconfigurations";
+const ON_DEBUG_DYNAMIC_CONFIGURATIONS_NAME = "onDebugDynamicConfigurations";
 let ConfigurationManager = class ConfigurationManager {
-    constructor(adapterManager, contextService, configurationService, quickInputService, instantiationService, storageService, extensionService, historyService, uriIdentityService, contextKeyService, logService) {
+    constructor(
+        adapterManager,
+        contextService,
+        configurationService,
+        quickInputService,
+        instantiationService,
+        storageService,
+        extensionService,
+        historyService,
+        uriIdentityService,
+        contextKeyService,
+        logService
+    ) {
         this.adapterManager = adapterManager;
         this.contextService = contextService;
         this.configurationService = configurationService;
@@ -70,11 +82,12 @@ let ConfigurationManager = class ConfigurationManager {
         const previousSelectedLaunch = this.launches.find(l => ( l.uri.toString()) === previousSelectedRoot);
         const previousSelectedName = this.storageService.get(DEBUG_SELECTED_CONFIG_NAME_KEY, StorageScope.WORKSPACE);
         this.debugConfigurationTypeContext = CONTEXT_DEBUG_CONFIGURATION_TYPE.bindTo(contextKeyService);
-        const dynamicConfig = previousSelectedType ? { type: previousSelectedType } : undefined;
+        const dynamicConfig = previousSelectedType ? {
+            type: previousSelectedType
+        } : undefined;
         if (previousSelectedLaunch && previousSelectedLaunch.getConfigurationNames().length) {
             this.selectConfiguration(previousSelectedLaunch, previousSelectedName, undefined, dynamicConfig);
-        }
-        else if (this.launches.length > 0) {
+        } else if (this.launches.length > 0) {
             this.selectConfiguration(undefined, previousSelectedName, undefined, dynamicConfig);
         }
     }
@@ -98,13 +111,15 @@ let ConfigurationManager = class ConfigurationManager {
         if (triggerKind === undefined) {
             triggerKind = DebugConfigurationProviderTriggerKind.Initial;
         }
-        const provider = this.configProviders.find(p => p.provideDebugConfigurations && (p.type === debugType) && (p.triggerKind === triggerKind));
+        const provider = this.configProviders.find(
+            p => p.provideDebugConfigurations && (p.type === debugType) && (p.triggerKind === triggerKind)
+        );
         return !!provider;
     }
     async resolveConfigurationByProviders(folderUri, type, config, token) {
         const resolveDebugConfigurationForType = async (type, config) => {
-            if (type !== '*') {
-                await this.adapterManager.activateDebuggers('onDebugResolve', type);
+            if (type !== "*") {
+                await this.adapterManager.activateDebuggers("onDebugResolve", type);
             }
             for (const p of this.configProviders) {
                 if (p.type === type && p.resolveDebugConfiguration && config) {
@@ -115,17 +130,23 @@ let ConfigurationManager = class ConfigurationManager {
         };
         let resolvedType = config.type ?? type;
         let result = config;
-        for (let seen = ( new Set()); result && !( seen.has(resolvedType));) {
+        for (let seen = ( new Set());
+             result && !( seen.has(resolvedType));
+        )
+        {
             seen.add(resolvedType);
             result = await resolveDebugConfigurationForType(resolvedType, result);
-            result = await resolveDebugConfigurationForType('*', result);
+            result = await resolveDebugConfigurationForType("*", result);
             resolvedType = result?.type ?? type;
         }
         return result;
     }
     async resolveDebugConfigurationWithSubstitutedVariables(folderUri, type, config, token) {
-        const providers = this.configProviders.filter(p => p.type === type && p.resolveDebugConfigurationWithSubstitutedVariables)
-            .concat(this.configProviders.filter(p => p.type === '*' && p.resolveDebugConfigurationWithSubstitutedVariables));
+        const providers = this.configProviders.filter(
+            p => p.type === type && p.resolveDebugConfigurationWithSubstitutedVariables
+        ).concat(
+            this.configProviders.filter(p => p.type === "*" && p.resolveDebugConfigurationWithSubstitutedVariables)
+        );
         let result = config;
         await sequence(( providers.map(provider => async () => {
             if (result) {
@@ -135,8 +156,10 @@ let ConfigurationManager = class ConfigurationManager {
         return result;
     }
     async provideDebugConfigurations(folderUri, type, token) {
-        await this.adapterManager.activateDebuggers('onDebugInitialConfigurations');
-        const results = await Promise.all(( this.configProviders.filter(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Initial && p.provideDebugConfigurations).map(p => p.provideDebugConfigurations(folderUri, token))));
+        await this.adapterManager.activateDebuggers("onDebugInitialConfigurations");
+        const results = await Promise.all(( this.configProviders.filter(
+            p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Initial && p.provideDebugConfigurations
+        ).map(p => p.provideDebugConfigurations(folderUri, token))));
         return results.reduce((first, second) => first.concat(second), []);
     }
     async getDynamicProviders() {
@@ -150,15 +173,13 @@ let ConfigurationManager = class ConfigurationManager {
             for (const event of e.activationEvents) {
                 if (event === ON_DEBUG_DYNAMIC_CONFIGURATIONS_NAME) {
                     hasGenericEvent = true;
-                }
-                else if (event.startsWith(`${ON_DEBUG_DYNAMIC_CONFIGURATIONS_NAME}:`)) {
+                } else if (event.startsWith(`${ON_DEBUG_DYNAMIC_CONFIGURATIONS_NAME}:`)) {
                     explicitTypes.push(event.slice(ON_DEBUG_DYNAMIC_CONFIGURATIONS_NAME.length + 1));
                 }
             }
             if (explicitTypes.length) {
                 explicitTypes.forEach(t => acc.add(t));
-            }
-            else if (hasGenericEvent) {
+            } else if (hasGenericEvent) {
                 const debuggerType = e.contributes?.debuggers?.[0].type;
                 if (debuggerType) {
                     acc.add(debuggerType);
@@ -176,7 +197,9 @@ let ConfigurationManager = class ConfigurationManager {
                 label: this.adapterManager.getDebuggerLabel(type),
                 getProvider: async () => {
                     await this.adapterManager.activateDebuggers(ON_DEBUG_DYNAMIC_CONFIGURATIONS_NAME, type);
-                    return this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
+                    return this.configProviders.find(
+                        p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations
+                    );
                 },
                 type,
                 pick: async () => {
@@ -186,13 +209,20 @@ let ConfigurationManager = class ConfigurationManager {
                     disposables.add(token);
                     const input = disposables.add(this.quickInputService.createQuickPick());
                     input.busy = true;
-                    input.placeholder = ( localize(6774, "Select Launch Configuration"));
+                    input.placeholder = ( localize(7084, "Select Launch Configuration"));
                     const chosenPromise = ( new Promise(resolve => {
                         disposables.add(input.onDidAccept(() => resolve(input.activeItems[0])));
-                        disposables.add(input.onDidTriggerItemButton(async (context) => {
+                        disposables.add(input.onDidTriggerItemButton(async context => {
                             resolve(undefined);
-                            const { launch, config } = context.item;
-                            await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true });
+                            const {
+                                launch,
+                                config
+                            } = context.item;
+                            await launch.openConfigFile({
+                                preserveFocus: false,
+                                type: config.type,
+                                suppressInitialConfigs: true
+                            });
                             await launch.writeConfiguration(config);
                             await this.selectConfiguration(launch, config.name);
                             this.removeRecentDynamicConfigurations(config.name, config.type);
@@ -202,8 +232,7 @@ let ConfigurationManager = class ConfigurationManager {
                     let items;
                     try {
                         items = await this.getDynamicConfigurationsByType(type, token.token);
-                    }
-                    catch (err) {
+                    } catch (err) {
                         this.logService.error(err);
                         disposables.dispose();
                         return;
@@ -221,19 +250,23 @@ let ConfigurationManager = class ConfigurationManager {
     async getDynamicConfigurationsByType(type, token = CancellationToken.None) {
         await this.adapterManager.activateDebuggers(ON_DEBUG_DYNAMIC_CONFIGURATIONS_NAME, type);
         const picks = [];
-        const provider = this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
+        const provider = this.configProviders.find(
+            p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations
+        );
         this.getLaunches().forEach(launch => {
             if (provider) {
-                picks.push(provider.provideDebugConfigurations(launch.workspace?.uri, token).then(configurations => ( configurations.map(config => ({
-                    label: config.name,
-                    description: launch.name,
-                    config,
-                    buttons: [{
+                picks.push(
+                    provider.provideDebugConfigurations(launch.workspace?.uri, token).then(configurations => ( configurations.map(config => ({
+                        label: config.name,
+                        description: launch.name,
+                        config,
+                        buttons: [{
                             iconClass: ThemeIcon.asClassName(debugConfigure),
-                            tooltip: ( localize(6775, "Edit Debug Configuration in launch.json"))
+                            tooltip: ( localize(7085, "Edit Debug Configuration in launch.json"))
                         }],
-                    launch
-                })))));
+                        launch
+                    }))))
+                );
             }
         });
         return (await Promise.all(picks)).flat();
@@ -244,7 +277,11 @@ let ConfigurationManager = class ConfigurationManager {
             for (const name of l.getConfigurationNames()) {
                 const config = l.getConfiguration(name) || l.getCompound(name);
                 if (config) {
-                    all.push({ launch: l, name, presentation: config.presentation });
+                    all.push({
+                        launch: l,
+                        name,
+                        presentation: config.presentation
+                    });
                 }
             }
         }
@@ -252,25 +289,34 @@ let ConfigurationManager = class ConfigurationManager {
     }
     removeRecentDynamicConfigurations(name, type) {
         const remaining = this.getRecentDynamicConfigurations().filter(c => c.name !== name || c.type !== type);
-        this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(remaining), StorageScope.WORKSPACE, StorageTarget.MACHINE);
+        this.storageService.store(
+            DEBUG_RECENT_DYNAMIC_CONFIGURATIONS,
+            JSON.stringify(remaining),
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
         if (this.selectedConfiguration.name === name && this.selectedType === type && this.selectedDynamic) {
             this.selectConfiguration(undefined, undefined);
-        }
-        else {
+        } else {
             this._onDidSelectConfigurationName.fire();
         }
     }
     getRecentDynamicConfigurations() {
-        return JSON.parse(this.storageService.get(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, StorageScope.WORKSPACE, '[]'));
+        return JSON.parse(
+            this.storageService.get(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, StorageScope.WORKSPACE, "[]")
+        );
     }
     registerListeners() {
-        this.toDispose.push(Event.any(this.contextService.onDidChangeWorkspaceFolders, this.contextService.onDidChangeWorkbenchState)(() => {
+        this.toDispose.push(Event.any(
+            this.contextService.onDidChangeWorkspaceFolders,
+            this.contextService.onDidChangeWorkbenchState
+        )(() => {
             this.initLaunches();
             this.selectConfiguration(undefined);
             this.setCompoundSchemaValues();
         }));
-        this.toDispose.push(this.configurationService.onDidChangeConfiguration(async (e) => {
-            if (e.affectsConfiguration('launch')) {
+        this.toDispose.push(this.configurationService.onDidChangeConfiguration(async e => {
+            if (e.affectsConfiguration("launch")) {
                 await this.selectConfiguration(undefined);
                 this.setCompoundSchemaValues();
             }
@@ -284,15 +330,19 @@ let ConfigurationManager = class ConfigurationManager {
             folder => this.instantiationService.createInstance(Launch, this, this.adapterManager, folder)
         ));
         if (this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE) {
-            this.launches.push(this.instantiationService.createInstance(WorkspaceLaunch, this, this.adapterManager));
+            this.launches.push(
+                this.instantiationService.createInstance(WorkspaceLaunch, this, this.adapterManager)
+            );
         }
-        this.launches.push(this.instantiationService.createInstance(UserLaunch, this, this.adapterManager));
+        this.launches.push(
+            this.instantiationService.createInstance(UserLaunch, this, this.adapterManager)
+        );
         if (this.selectedLaunch && this.launches.indexOf(this.selectedLaunch) === -1) {
             this.selectConfiguration(undefined);
         }
     }
     setCompoundSchemaValues() {
-        const compoundConfigurationsSchema = launchSchema.properties['compounds'].items.properties['configurations'];
+        const compoundConfigurationsSchema = launchSchema.properties["compounds"].items.properties["configurations"];
         const launchNames = ( this.launches.map(l => l.getConfigurationNames(true))).reduce((first, second) => first.concat(second), []);
         compoundConfigurationsSchema.items.oneOf[0].enum = launchNames;
         compoundConfigurationsSchema.items.oneOf[1].properties.name.enum = launchNames;
@@ -307,7 +357,9 @@ let ConfigurationManager = class ConfigurationManager {
         if (!URI.isUri(workspaceUri)) {
             return undefined;
         }
-        return this.launches.find(l => l.workspace && this.uriIdentityService.extUri.isEqual(l.workspace.uri, workspaceUri));
+        return this.launches.find(
+            l => l.workspace && this.uriIdentityService.extUri.isEqual(l.workspace.uri, workspaceUri)
+        );
     }
     get selectedConfiguration() {
         return {
@@ -327,7 +379,7 @@ let ConfigurationManager = class ConfigurationManager {
         return undefined;
     }
     async selectConfiguration(launch, name, config, dynamicConfig) {
-        if (typeof launch === 'undefined') {
+        if (typeof launch === "undefined") {
             const rootUri = this.historyService.getLastActiveWorkspaceRoot();
             launch = this.getLaunch(rootUri);
             if (!launch || launch.getConfigurationNames().length === 0) {
@@ -340,8 +392,7 @@ let ConfigurationManager = class ConfigurationManager {
         this.selectedLaunch = launch;
         if (this.selectedLaunch) {
             this.storageService.store(DEBUG_SELECTED_ROOT, ( this.selectedLaunch.uri.toString()), StorageScope.WORKSPACE, StorageTarget.MACHINE);
-        }
-        else {
+        } else {
             this.storageService.remove(DEBUG_SELECTED_ROOT, StorageScope.WORKSPACE);
         }
         const names = launch ? launch.getConfigurationNames() : [];
@@ -352,8 +403,7 @@ let ConfigurationManager = class ConfigurationManager {
         let type = config?.type;
         if (name && names.indexOf(name) >= 0) {
             this.setSelectedLaunchName(name);
-        }
-        else if (dynamicConfig && dynamicConfig.type) {
+        } else if (dynamicConfig && dynamicConfig.type) {
             type = dynamicConfig.type;
             if (!config) {
                 const providers = (await this.getDynamicProviders()).filter(p => p.type === type);
@@ -374,12 +424,19 @@ let ConfigurationManager = class ConfigurationManager {
             this.setSelectedLaunchName(name);
             let recentDynamicProviders = this.getRecentDynamicConfigurations();
             if (name && dynamicConfig.type) {
-                recentDynamicProviders.unshift({ name, type: dynamicConfig.type });
+                recentDynamicProviders.unshift({
+                    name,
+                    type: dynamicConfig.type
+                });
                 recentDynamicProviders = distinct(recentDynamicProviders, t => `${t.name} : ${t.type}`);
-                this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(recentDynamicProviders), StorageScope.WORKSPACE, StorageTarget.MACHINE);
+                this.storageService.store(
+                    DEBUG_RECENT_DYNAMIC_CONFIGURATIONS,
+                    JSON.stringify(recentDynamicProviders),
+                    StorageScope.WORKSPACE,
+                    StorageTarget.MACHINE
+                );
             }
-        }
-        else if (!this.selectedName || names.indexOf(this.selectedName) === -1) {
+        } else if (!this.selectedName || names.indexOf(this.selectedName) === -1) {
             const nameToSet = names.length ? names[0] : undefined;
             this.setSelectedLaunchName(nameToSet);
         }
@@ -389,11 +446,15 @@ let ConfigurationManager = class ConfigurationManager {
         }
         this.selectedType = dynamicConfig?.type || config?.type;
         this.selectedDynamic = !!dynamicConfig;
-        this.storageService.store(DEBUG_SELECTED_TYPE, dynamicConfig ? this.selectedType : undefined, StorageScope.WORKSPACE, StorageTarget.MACHINE);
+        this.storageService.store(
+            DEBUG_SELECTED_TYPE,
+            dynamicConfig ? this.selectedType : undefined,
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
         if (type) {
             this.debugConfigurationTypeContext.set(type);
-        }
-        else {
+        } else {
             this.debugConfigurationTypeContext.reset();
         }
         if (this.selectedLaunch !== previousLaunch || this.selectedName !== previousName || previousSelectedDynamic !== this.selectedDynamic) {
@@ -403,9 +464,13 @@ let ConfigurationManager = class ConfigurationManager {
     setSelectedLaunchName(selectedName) {
         this.selectedName = selectedName;
         if (this.selectedName) {
-            this.storageService.store(DEBUG_SELECTED_CONFIG_NAME_KEY, this.selectedName, StorageScope.WORKSPACE, StorageTarget.MACHINE);
-        }
-        else {
+            this.storageService.store(
+                DEBUG_SELECTED_CONFIG_NAME_KEY,
+                this.selectedName,
+                StorageScope.WORKSPACE,
+                StorageTarget.MACHINE
+            );
+        } else {
             this.storageService.remove(DEBUG_SELECTED_CONFIG_NAME_KEY, StorageScope.WORKSPACE);
         }
     }
@@ -413,18 +478,7 @@ let ConfigurationManager = class ConfigurationManager {
         this.toDispose = dispose(this.toDispose);
     }
 };
-ConfigurationManager = ( __decorate([
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IQuickInputService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, IExtensionService)),
-    ( __param(7, IHistoryService)),
-    ( __param(8, IUriIdentityService)),
-    ( __param(9, IContextKeyService)),
-    ( __param(10, ILogService))
-], ConfigurationManager));
+ConfigurationManager = ( __decorate([( __param(1, IWorkspaceContextService)), ( __param(2, IConfigurationService)), ( __param(3, IQuickInputService)), ( __param(4, IInstantiationService)), ( __param(5, IStorageService)), ( __param(6, IExtensionService)), ( __param(7, IHistoryService)), ( __param(8, IUriIdentityService)), ( __param(9, IContextKeyService)), ( __param(10, ILogService))], ConfigurationManager));
 class AbstractLaunch {
     constructor(configurationManager, adapterManager) {
         this.configurationManager = configurationManager;
@@ -441,17 +495,20 @@ class AbstractLaunch {
         const config = this.getDeduplicatedConfig();
         if (!config || (!Array.isArray(config.configurations) && !Array.isArray(config.compounds))) {
             return [];
-        }
-        else {
+        } else {
             const configurations = [];
             if (config.configurations) {
-                configurations.push(...config.configurations.filter(cfg => cfg && typeof cfg.name === 'string'));
+                configurations.push(
+                    ...config.configurations.filter(cfg => cfg && typeof cfg.name === "string")
+                );
             }
             if (ignoreCompoundsAndPresentation) {
                 return ( configurations.map(c => c.name));
             }
             if (config.compounds) {
-                configurations.push(...config.compounds.filter(compound => typeof compound.name === 'string' && compound.configurations && compound.configurations.length));
+                configurations.push(...config.compounds.filter(
+                    compound => typeof compound.name === "string" && compound.configurations && compound.configurations.length
+                ));
             }
             return ( getVisibleAndSorted(configurations).map(c => c.name));
         }
@@ -466,27 +523,31 @@ class AbstractLaunch {
             return;
         }
         if (this instanceof UserLaunch) {
-            return { ...configuration, __configurationTarget: ConfigurationTarget.USER };
-        }
-        else if (this instanceof WorkspaceLaunch) {
-            return { ...configuration, __configurationTarget: ConfigurationTarget.WORKSPACE };
-        }
-        else {
-            return { ...configuration, __configurationTarget: ConfigurationTarget.WORKSPACE_FOLDER };
+            return {
+                ...configuration,
+                __configurationTarget: ConfigurationTarget.USER
+            };
+        } else if (this instanceof WorkspaceLaunch) {
+            return {
+                ...configuration,
+                __configurationTarget: ConfigurationTarget.WORKSPACE
+            };
+        } else {
+            return {
+                ...configuration,
+                __configurationTarget: ConfigurationTarget.WORKSPACE_FOLDER
+            };
         }
     }
     async getInitialConfigurationContent(folderUri, type, useInitialConfigs, token) {
-        let content = '';
-        const adapter = type
-            ? { debugger: this.adapterManager.getEnabledDebugger(type) }
-            : await this.adapterManager.guessDebugger(true);
+        let content = "";
+        const adapter = type ? {
+            debugger: this.adapterManager.getEnabledDebugger(type)
+        } : await this.adapterManager.guessDebugger(true);
         if (adapter?.withConfig && adapter.debugger) {
             content = await adapter.debugger.getInitialConfigurationContent([adapter.withConfig.config]);
-        }
-        else if (adapter?.debugger) {
-            const initialConfigs = useInitialConfigs ?
-                await this.configurationManager.provideDebugConfigurations(folderUri, adapter.debugger.type, token || CancellationToken.None) :
-                [];
+        } else if (adapter?.debugger) {
+            const initialConfigs = useInitialConfigs ? await this.configurationManager.provideDebugConfigurations(folderUri, adapter.debugger.type, token || CancellationToken.None) : [];
             content = await adapter.debugger.getInitialConfigurationContent(initialConfigs);
         }
         return content;
@@ -499,7 +560,7 @@ class AbstractLaunch {
         return original && {
             version: original.version,
             compounds: original.compounds && distinguishConfigsByName(original.compounds),
-            configurations: original.configurations && distinguishConfigsByName(original.configurations),
+            configurations: original.configurations && distinguishConfigsByName(original.configurations)
         };
     }
 }
@@ -508,11 +569,22 @@ function distinguishConfigsByName(things) {
     return ( things.map(thing => {
         const no = seen.get(thing.name) || 0;
         seen.set(thing.name, no + 1);
-        return no === 0 ? thing : { ...thing, name: `${thing.name} (${no})` };
+        return no === 0 ? thing : {
+            ...thing,
+            name: `${thing.name} (${no})`
+        };
     }));
 }
 let Launch = class Launch extends AbstractLaunch {
-    constructor(configurationManager, adapterManager, workspace, fileService, textFileService, editorService, configurationService) {
+    constructor(
+        configurationManager,
+        adapterManager,
+        workspace,
+        fileService,
+        textFileService,
+        editorService,
+        configurationService
+    ) {
         super(configurationManager, adapterManager);
         this.workspace = workspace;
         this.fileService = fileService;
@@ -521,34 +593,44 @@ let Launch = class Launch extends AbstractLaunch {
         this.configurationService = configurationService;
     }
     get uri() {
-        return joinPath(this.workspace.uri, '/.vscode/launch.json');
+        return joinPath(this.workspace.uri, "/.vscode/launch.json");
     }
     get name() {
         return this.workspace.name;
     }
     getConfig() {
-        return this.configurationService.inspect('launch', { resource: this.workspace.uri }).workspaceFolderValue;
-    }
-    async openConfigFile({ preserveFocus, type, suppressInitialConfigs }, token) {
+        return this.configurationService.inspect("launch", {
+            resource: this.workspace.uri
+        }).workspaceFolderValue;
+    }
+    async openConfigFile(
+        {
+            preserveFocus,
+            type,
+            suppressInitialConfigs
+        },
+        token
+    ) {
         const resource = this.uri;
         let created = false;
-        let content = '';
+        let content = "";
         try {
             const fileContent = await this.fileService.readFile(resource);
             content = ( fileContent.value.toString());
-        }
-        catch {
+        } catch {
             content = await this.getInitialConfigurationContent(this.workspace.uri, type, !suppressInitialConfigs, token);
             if (!content) {
-                return { editor: null, created: false };
+                return {
+                    editor: null,
+                    created: false
+                };
             }
             created = true;
             try {
                 await this.textFileService.write(resource, content);
-            }
-            catch (error) {
+            } catch (error) {
                 throw ( new Error(( localize(
-                    6776,
+                    7086,
                     "Unable to create 'launch.json' file inside the '.vscode' folder ({0}).",
                     error.message
                 ))));
@@ -557,11 +639,14 @@ let Launch = class Launch extends AbstractLaunch {
         const index = content.indexOf(`"${this.configurationManager.selectedConfiguration.name}"`);
         let startLineNumber = 1;
         for (let i = 0; i < index; i++) {
-            if (content.charAt(i) === '\n') {
+            if (content.charAt(i) === "\n") {
                 startLineNumber++;
             }
         }
-        const selection = startLineNumber > 1 ? { startLineNumber, startColumn: 4 } : undefined;
+        const selection = startLineNumber > 1 ? {
+            startLineNumber,
+            startColumn: 4
+        } : undefined;
         const editor = await this.editorService.openEditor({
             resource,
             options: {
@@ -569,7 +654,7 @@ let Launch = class Launch extends AbstractLaunch {
                 preserveFocus,
                 pinned: created,
                 revealIfVisible: true
-            },
+            }
         }, ACTIVE_GROUP);
         return ({
             editor: editor ?? null,
@@ -577,19 +662,24 @@ let Launch = class Launch extends AbstractLaunch {
         });
     }
     async writeConfiguration(configuration) {
-        const fullConfig = { ...(this.getConfig() ?? {}) };
+        const fullConfig = {
+            ...(this.getConfig() ?? {})
+        };
         fullConfig.configurations = [...(fullConfig.configurations || []), configuration];
-        await this.configurationService.updateValue('launch', fullConfig, { resource: this.workspace.uri }, ConfigurationTarget.WORKSPACE_FOLDER);
+        await this.configurationService.updateValue("launch", fullConfig, {
+            resource: this.workspace.uri
+        }, ConfigurationTarget.WORKSPACE_FOLDER);
     }
 };
-Launch = ( __decorate([
-    ( __param(3, IFileService)),
-    ( __param(4, ITextFileService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IConfigurationService))
-], Launch));
+Launch = ( __decorate([( __param(3, IFileService)), ( __param(4, ITextFileService)), ( __param(5, IEditorService)), ( __param(6, IConfigurationService))], Launch));
 let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
-    constructor(configurationManager, adapterManager, editorService, configurationService, contextService) {
+    constructor(
+        configurationManager,
+        adapterManager,
+        editorService,
+        configurationService,
+        contextService
+    ) {
         super(configurationManager, adapterManager);
         this.editorService = editorService;
         this.configurationService = configurationService;
@@ -602,25 +692,36 @@ let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
         return this.contextService.getWorkspace().configuration;
     }
     get name() {
-        return localize(6777, "workspace");
+        return localize(7087, "workspace");
     }
     getConfig() {
-        return this.configurationService.inspect('launch').workspaceValue;
-    }
-    async openConfigFile({ preserveFocus, type, useInitialConfigs }, token) {
+        return this.configurationService.inspect("launch").workspaceValue;
+    }
+    async openConfigFile(
+        {
+            preserveFocus,
+            type,
+            useInitialConfigs
+        },
+        token
+    ) {
         const launchExistInFile = !!this.getConfig();
         if (!launchExistInFile) {
             const content = await this.getInitialConfigurationContent(undefined, type, useInitialConfigs, token);
             if (content) {
-                await this.configurationService.updateValue('launch', parse(content), ConfigurationTarget.WORKSPACE);
-            }
-            else {
-                return { editor: null, created: false };
+                await this.configurationService.updateValue("launch", parse(content), ConfigurationTarget.WORKSPACE);
+            } else {
+                return {
+                    editor: null,
+                    created: false
+                };
             }
         }
         const editor = await this.editorService.openEditor({
             resource: this.contextService.getWorkspace().configuration,
-            options: { preserveFocus }
+            options: {
+                preserveFocus
+            }
         }, ACTIVE_GROUP);
         return ({
             editor: editor ?? null,
@@ -628,13 +729,14 @@ let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
         });
     }
 };
-WorkspaceLaunch = ( __decorate([
-    ( __param(2, IEditorService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IWorkspaceContextService))
-], WorkspaceLaunch));
+WorkspaceLaunch = ( __decorate([( __param(2, IEditorService)), ( __param(3, IConfigurationService)), ( __param(4, IWorkspaceContextService))], WorkspaceLaunch));
 let UserLaunch = class UserLaunch extends AbstractLaunch {
-    constructor(configurationManager, adapterManager, configurationService, preferencesService) {
+    constructor(
+        configurationManager,
+        adapterManager,
+        configurationService,
+        preferencesService
+    ) {
         super(configurationManager, adapterManager);
         this.configurationService = configurationService;
         this.preferencesService = preferencesService;
@@ -646,25 +748,34 @@ let UserLaunch = class UserLaunch extends AbstractLaunch {
         return this.preferencesService.userSettingsResource;
     }
     get name() {
-        return localize(6778, "user settings");
+        return localize(7088, "user settings");
     }
     get hidden() {
         return true;
     }
     getConfig() {
-        return this.configurationService.inspect('launch').userValue;
-    }
-    async openConfigFile({ preserveFocus, type, useInitialContent }) {
-        const editor = await this.preferencesService.openUserSettings({ jsonEditor: true, preserveFocus, revealSetting: { key: 'launch' } });
+        return this.configurationService.inspect("launch").userValue;
+    }
+    async openConfigFile(
+        {
+            preserveFocus,
+            type,
+            useInitialContent
+        }
+    ) {
+        const editor = await this.preferencesService.openUserSettings({
+            jsonEditor: true,
+            preserveFocus,
+            revealSetting: {
+                key: "launch"
+            }
+        });
         return ({
             editor: editor ?? null,
             created: false
         });
     }
 };
-UserLaunch = ( __decorate([
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IPreferencesService))
-], UserLaunch));
+UserLaunch = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, IPreferencesService))], UserLaunch));
 
 export { ConfigurationManager };