@codingame/monaco-vscode-debug-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/contrib/debug/browser/debugActionViewItems.d.ts

@@ -0,0 +1,50 @@
+import { IAction } from "vscode/vscode/vs/base/common/actions";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { ICommandService } from "vscode/vscode/vs/platform/commands/common/commands.service";
+import { IDebugSession } from "vscode/vscode/vs/workbench/contrib/debug/common/debug";
+import { IDebugService } from "vscode/vscode/vs/workbench/contrib/debug/common/debug.service";
+import { IContextViewService } from "vscode/vscode/vs/platform/contextview/browser/contextView.service";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { BaseActionViewItem, IBaseActionViewItemOptions, SelectActionViewItem } from "vscode/vscode/vs/base/browser/ui/actionbar/actionViewItems";
+import { IKeybindingService } from "vscode/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IHoverService } from "vscode/vscode/vs/platform/hover/browser/hover.service";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+export declare class StartDebugActionViewItem extends BaseActionViewItem {
+    private context;
+    private readonly debugService;
+    private readonly configurationService;
+    private readonly commandService;
+    private readonly contextService;
+    private readonly keybindingService;
+    private readonly hoverService;
+    private readonly contextKeyService;
+    private static readonly SEPARATOR;
+    private container;
+    private start;
+    private selectBox;
+    private debugOptions;
+    private toDispose;
+    private selected;
+    private providers;
+    constructor(context: unknown, action: IAction, options: IBaseActionViewItemOptions, debugService: IDebugService, configurationService: IConfigurationService, commandService: ICommandService, contextService: IWorkspaceContextService, contextViewService: IContextViewService, keybindingService: IKeybindingService, hoverService: IHoverService, contextKeyService: IContextKeyService);
+    private registerListeners;
+    render(container: HTMLElement): void;
+    setActionContext(context: any): void;
+    isEnabled(): boolean;
+    focus(fromRight?: boolean): void;
+    blur(): void;
+    setFocusable(focusable: boolean): void;
+    dispose(): void;
+    private updateOptions;
+    private _setAriaLabel;
+}
+export declare class FocusSessionActionViewItem extends SelectActionViewItem<IDebugSession> {
+    protected readonly debugService: IDebugService;
+    private readonly configurationService;
+    constructor(action: IAction, session: IDebugSession | undefined, debugService: IDebugService, contextViewService: IContextViewService, configurationService: IConfigurationService);
+    protected getActionContext(_: string, index: number): IDebugSession;
+    private update;
+    private getSelectedSession;
+    protected getSessions(): ReadonlyArray<IDebugSession>;
+    protected mapFocusedSessionToSelected(focusedSession: IDebugSession): IDebugSession;
+}

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

@@ -1,10 +1,13 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
+import { KeyCode } from 'vscode/vscode/vs/base/common/keyCodes';
 import { $ as $$1, append, addDisposableListener, EventType } from 'vscode/vscode/vs/base/browser/dom';
 import { StandardKeyboardEvent } from 'vscode/vscode/vs/base/browser/keyboardEvent';
 import { SelectBox } from 'vscode/vscode/vs/base/browser/ui/selectBox/selectBox';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
+import { State } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 import { asCssVariable } from 'vscode/vscode/vs/platform/theme/common/colorUtils';
@@ -19,15 +22,18 @@ import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { WorkbenchState } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ADD_CONFIGURATION_ID } from '@codingame/monaco-vscode-debug-notebook-common/vscode/vs/workbench/contrib/debug/browser/debugCommands';
+import { ADD_CONFIGURATION_ID } from '@codingame/monaco-vscode-88aa9a78-75f5-5aaa-89e9-bbdd580b3b5c-common/vscode/vs/workbench/contrib/debug/browser/debugCommands';
 import { BaseActionViewItem, SelectActionViewItem } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionViewItems';
-import { debugStart } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
+import { debugStart } from '@codingame/monaco-vscode-fc42f049-7883-579d-bb0b-2aa1010a19a8-common/vscode/vs/workbench/contrib/debug/browser/debugIcons';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
 import { defaultSelectBoxStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
 import { getDefaultHoverDelegate } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
 import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.service';
+import { AccessibilityVerbositySettingId } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { AccessibilityCommandId } from 'vscode/vscode/vs/workbench/contrib/accessibility/common/accessibilityCommands';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 
 var StartDebugActionViewItem_1;
@@ -49,13 +55,13 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
         this.selected = 0;
         this.providers = [];
         this.toDispose = [];
-        this.selectBox = ( (new SelectBox(
+        this.selectBox = ( new SelectBox(
             [],
             -1,
             contextViewService,
             defaultSelectBoxStyles,
-            { ariaLabel: ( localize(10461, 'Debug Launch Configurations')) }
-        )));
+            { ariaLabel: ( localize(5175, 'Debug Launch Configurations')) }
+        ));
         this.selectBox.setFocusable(false);
         this.toDispose.push(this.selectBox);
         this.registerListeners();
@@ -82,7 +88,7 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
         this._setAriaLabel(title);
         this.toDispose.push(addDisposableListener(this.start, EventType.CLICK, () => {
             this.start.blur();
-            if (this.debugService.state !== 1 ) {
+            if (this.debugService.state !== State.Initializing) {
                 this.actionRunner.run(this.action, this.context);
             }
         }));
@@ -98,8 +104,8 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
             this.start.classList.remove('active');
         }));
         this.toDispose.push(addDisposableListener(this.start, EventType.KEY_DOWN, (e) => {
-            const event = ( (new StandardKeyboardEvent(e)));
-            if (event.equals(17 )) {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.RightArrow)) {
                 this.start.tabIndex = -1;
                 this.selectBox.focus();
                 event.stopPropagation();
@@ -118,8 +124,8 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
         const selectBoxContainer = $('.configuration');
         this.selectBox.render(append(container, selectBoxContainer));
         this.toDispose.push(addDisposableListener(selectBoxContainer, EventType.KEY_DOWN, (e) => {
-            const event = ( (new StandardKeyboardEvent(e)));
-            if (event.equals(15 )) {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.LeftArrow)) {
                 this.selectBox.setFocusable(false);
                 this.start.tabIndex = 0;
                 this.start.focus();
@@ -177,7 +183,7 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
         this.selected = 0;
         this.debugOptions = [];
         const manager = this.debugService.getConfigurationManager();
-        const inWorkspace = this.contextService.getWorkbenchState() === 3 ;
+        const inWorkspace = this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE;
         let lastGroup;
         const disabledIdxs = [];
         manager.getAllConfigurations().forEach(({ launch, name, presentation }) => {
@@ -212,7 +218,7 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
             });
         });
         if (this.debugOptions.length === 0) {
-            this.debugOptions.push({ label: ( localize(10462, "No Configurations")), handler: async () => false });
+            this.debugOptions.push({ label: ( localize(5176, "No Configurations")), handler: async () => false });
         }
         this.debugOptions.push({ label: StartDebugActionViewItem_1.SEPARATOR, handler: () => Promise.resolve(false) });
         disabledIdxs.push(this.debugOptions.length - 1);
@@ -230,31 +236,31 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
             });
         });
         manager.getLaunches().filter(l => !l.hidden).forEach(l => {
-            const label = inWorkspace ? ( localize(10463, "Add Config ({0})...", l.name)) : ( localize(10464, "Add Configuration..."));
+            const label = inWorkspace ? ( localize(5177, "Add Config ({0})...", l.name)) : ( localize(5178, "Add Configuration..."));
             this.debugOptions.push({
                 label, handler: async () => {
-                    await this.commandService.executeCommand(ADD_CONFIGURATION_ID, ( (l.uri.toString())));
+                    await this.commandService.executeCommand(ADD_CONFIGURATION_ID, ( l.uri.toString()));
                     return false;
                 }
             });
         });
-        this.selectBox.setOptions(( (this.debugOptions.map(
+        this.selectBox.setOptions(( this.debugOptions.map(
             (data, index) => ({ text: data.label, isDisabled: disabledIdxs.indexOf(index) !== -1 })
-        ))), this.selected);
+        )), this.selected);
     }
     _setAriaLabel(title) {
         let ariaLabel = title;
         let keybinding;
-        const verbose = this.configurationService.getValue("accessibility.verbosity.debug" );
+        const verbose = this.configurationService.getValue(AccessibilityVerbositySettingId.Debug);
         if (verbose) {
-            keybinding = this.keybindingService.lookupKeybinding("editor.action.accessibilityHelp" , this.contextKeyService)?.getLabel() ?? undefined;
+            keybinding = this.keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp, this.contextKeyService)?.getLabel() ?? undefined;
         }
         if (keybinding) {
-            ariaLabel = ( localize(10465, "{0}, use ({1}) for accessibility help", ariaLabel, keybinding));
+            ariaLabel = ( localize(5179, "{0}, use ({1}) for accessibility help", ariaLabel, keybinding));
         }
         else {
             ariaLabel = ( localize(
-                10466,
+                5180,
                 "{0}, run the command Open Accessibility Help which is currently not triggerable via keybinding.",
                 ariaLabel
             ));
@@ -262,19 +268,19 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
         this.start.ariaLabel = ariaLabel;
     }
 };
-StartDebugActionViewItem = StartDebugActionViewItem_1 = ( (__decorate([
-    ( (__param(3, IDebugService))),
-    ( (__param(4, IConfigurationService))),
-    ( (__param(5, ICommandService))),
-    ( (__param(6, IWorkspaceContextService))),
-    ( (__param(7, IContextViewService))),
-    ( (__param(8, IKeybindingService))),
-    ( (__param(9, IHoverService))),
-    ( (__param(10, IContextKeyService)))
-], StartDebugActionViewItem)));
+StartDebugActionViewItem = StartDebugActionViewItem_1 = ( __decorate([
+    ( __param(3, IDebugService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IWorkspaceContextService)),
+    ( __param(7, IContextViewService)),
+    ( __param(8, IKeybindingService)),
+    ( __param(9, IHoverService)),
+    ( __param(10, IContextKeyService))
+], StartDebugActionViewItem));
 let FocusSessionActionViewItem = class FocusSessionActionViewItem extends SelectActionViewItem {
     constructor(action, session, debugService, contextViewService, configurationService) {
-        super(null, action, [], -1, contextViewService, defaultSelectBoxStyles, { ariaLabel: ( localize(10467, 'Debug Session')) });
+        super(null, action, [], -1, contextViewService, defaultSelectBoxStyles, { ariaLabel: ( localize(5181, 'Debug Session')) });
         this.debugService = debugService;
         this.configurationService = configurationService;
         this._register(this.debugService.getViewModel().onDidFocusSession(() => {
@@ -305,14 +311,14 @@ let FocusSessionActionViewItem = class FocusSessionActionViewItem extends Select
             session = this.getSelectedSession();
         }
         const sessions = this.getSessions();
-        const names = ( (sessions.map(s => {
+        const names = ( sessions.map(s => {
             const label = s.getLabel();
             if (s.parentSession) {
                 return `\u00A0\u00A0${label}`;
             }
             return label;
-        })));
-        this.setOptions(( (names.map((data) => ({ text: data })))), session ? sessions.indexOf(session) : undefined);
+        }));
+        this.setOptions(( names.map((data) => ({ text: data }))), session ? sessions.indexOf(session) : undefined);
     }
     getSelectedSession() {
         const session = this.debugService.getViewModel().focusedSession;
@@ -331,10 +337,10 @@ let FocusSessionActionViewItem = class FocusSessionActionViewItem extends Select
         return focusedSession;
     }
 };
-FocusSessionActionViewItem = ( (__decorate([
-    ( (__param(2, IDebugService))),
-    ( (__param(3, IContextViewService))),
-    ( (__param(4, IConfigurationService)))
-], FocusSessionActionViewItem)));
+FocusSessionActionViewItem = ( __decorate([
+    ( __param(2, IDebugService)),
+    ( __param(3, IContextViewService)),
+    ( __param(4, IConfigurationService))
+], FocusSessionActionViewItem));
 
 export { FocusSessionActionViewItem, StartDebugActionViewItem };

package/vscode/src/vs/workbench/contrib/debug/browser/debugAdapterManager.d.ts

@@ -0,0 +1,71 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { ILanguageService } from "vscode/vscode/vs/editor/common/languages/language";
+import { ITextModel } from "vscode/vscode/vs/editor/common/model";
+import { IMenuService } from "vscode/vscode/vs/platform/actions/common/actions.service";
+import { ICommandService } from "vscode/vscode/vs/platform/commands/common/commands.service";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IQuickInputService } from "vscode/vscode/vs/platform/quickinput/common/quickInput.service";
+import { IWorkspaceFolder } from "vscode/vscode/vs/platform/workspace/common/workspace";
+import { IAdapterDescriptor, IAdapterManager, IConfig, IConfigurationManager, IDebugAdapter, IDebugAdapterDescriptorFactory, IDebugAdapterFactory, IDebugSession, IGuessedDebugger } from "vscode/vscode/vs/workbench/contrib/debug/common/debug";
+import { Debugger } from "../common/debugger.js";
+import { ITaskService } from "vscode/vscode/vs/workbench/contrib/tasks/common/taskService.service";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { ILifecycleService } from "vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+export interface IAdapterManagerDelegate {
+    onDidNewSession: Event<IDebugSession>;
+    configurationManager(): IConfigurationManager;
+}
+export declare class AdapterManager extends Disposable implements IAdapterManager {
+    private readonly delegate;
+    private readonly editorService;
+    private readonly configurationService;
+    private readonly quickInputService;
+    private readonly instantiationService;
+    private readonly commandService;
+    private readonly extensionService;
+    private readonly contextKeyService;
+    private readonly languageService;
+    private readonly dialogService;
+    private readonly lifecycleService;
+    private readonly tasksService;
+    private readonly menuService;
+    private debuggers;
+    private adapterDescriptorFactories;
+    private debugAdapterFactories;
+    private debuggersAvailable;
+    private debugExtensionsAvailable;
+    private readonly _onDidRegisterDebugger;
+    private readonly _onDidDebuggersExtPointRead;
+    private breakpointContributions;
+    private debuggerWhenKeys;
+    private taskLabels;
+    private earlyActivatedExtensions;
+    private usedDebugTypes;
+    constructor(delegate: IAdapterManagerDelegate, editorService: IEditorService, configurationService: IConfigurationService, quickInputService: IQuickInputService, instantiationService: IInstantiationService, commandService: ICommandService, extensionService: IExtensionService, contextKeyService: IContextKeyService, languageService: ILanguageService, dialogService: IDialogService, lifecycleService: ILifecycleService, tasksService: ITaskService, menuService: IMenuService);
+    private registerListeners;
+    private updateTaskLabels;
+    private updateDebugAdapterSchema;
+    registerDebugAdapterFactory(debugTypes: string[], debugAdapterLauncher: IDebugAdapterFactory): IDisposable;
+    hasEnabledDebuggers(): boolean;
+    createDebugAdapter(session: IDebugSession): IDebugAdapter | undefined;
+    substituteVariables(debugType: string, folder: IWorkspaceFolder | undefined, config: IConfig): Promise<IConfig>;
+    runInTerminal(debugType: string, args: DebugProtocol.RunInTerminalRequestArguments, sessionId: string): Promise<number | undefined>;
+    registerDebugAdapterDescriptorFactory(debugAdapterProvider: IDebugAdapterDescriptorFactory): IDisposable;
+    unregisterDebugAdapterDescriptorFactory(debugAdapterProvider: IDebugAdapterDescriptorFactory): void;
+    getDebugAdapterDescriptor(session: IDebugSession): Promise<IAdapterDescriptor | undefined>;
+    getDebuggerLabel(type: string): string | undefined;
+    get onDidRegisterDebugger(): Event<void>;
+    get onDidDebuggersExtPointRead(): Event<void>;
+    canSetBreakpointsIn(model: ITextModel): boolean;
+    getDebugger(type: string): Debugger | undefined;
+    getEnabledDebugger(type: string): Debugger | undefined;
+    someDebuggerInterestedInLanguage(languageId: string): boolean;
+    guessDebugger(gettingConfigurations: boolean): Promise<IGuessedDebugger | undefined>;
+    private initExtensionActivationsIfNeeded;
+    activateDebuggers(activationEvent: string, debugType?: string): Promise<void>;
+}

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

@@ -1,8 +1,9 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 import { equalsIgnoreCase } from 'vscode/vscode/vs/base/common/strings';
 import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
 import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
@@ -23,15 +24,17 @@ import { Debugger } from '../common/debugger.js';
 import { debuggersExtPoint, breakpointsExtPoint, launchSchema, presentationSchema } from '../common/debugSchemas.js';
 import { TaskDefinitionRegistry } from 'vscode/vscode/vs/workbench/contrib/tasks/common/taskDefinitionRegistry';
 import { ITaskService } from 'vscode/vscode/vs/workbench/contrib/tasks/common/taskService.service';
-import { launchSchemaId } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
+import { launchSchemaId } from '@codingame/monaco-vscode-37e80bf5-92f5-5e4c-8b6d-98e0bb89dbef-common/vscode/vs/workbench/services/configuration/common/configuration';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 
-const jsonRegistry = ( (Registry.as(Extensions.JSONContribution)));
+const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
 let AdapterManager = class AdapterManager extends Disposable {
     constructor(delegate, editorService, configurationService, quickInputService, instantiationService, commandService, extensionService, contextKeyService, languageService, dialogService, lifecycleService, tasksService, menuService) {
         super();
+        this.delegate = delegate;
         this.editorService = editorService;
         this.configurationService = configurationService;
         this.quickInputService = quickInputService;
@@ -44,13 +47,13 @@ let AdapterManager = class AdapterManager extends Disposable {
         this.lifecycleService = lifecycleService;
         this.tasksService = tasksService;
         this.menuService = menuService;
-        this.debugAdapterFactories = ( (new Map()));
-        this._onDidRegisterDebugger = ( (new Emitter()));
-        this._onDidDebuggersExtPointRead = ( (new Emitter()));
+        this.debugAdapterFactories = ( new Map());
+        this._onDidRegisterDebugger = ( new Emitter());
+        this._onDidDebuggersExtPointRead = ( new Emitter());
         this.breakpointContributions = [];
-        this.debuggerWhenKeys = ( (new Set()));
+        this.debuggerWhenKeys = ( new Set());
         this.taskLabels = [];
-        this.usedDebugTypes = ( (new Set()));
+        this.usedDebugTypes = ( new Set());
         this.adapterDescriptorFactories = [];
         this.debuggers = [];
         this.registerListeners();
@@ -67,12 +70,12 @@ let AdapterManager = class AdapterManager extends Disposable {
         this._register(this.onDidDebuggersExtPointRead(() => {
             this.debugExtensionsAvailable.set(this.debuggers.length > 0);
         }));
-        const updateTaskScheduler = this._register(( (new RunOnceScheduler(() => this.updateTaskLabels(), 5000))));
+        const updateTaskScheduler = this._register(( new RunOnceScheduler(() => this.updateTaskLabels(), 5000)));
         this._register(Event.any(tasksService.onDidChangeTaskConfig, tasksService.onDidChangeTaskProviders)(() => {
             updateTaskScheduler.cancel();
             updateTaskScheduler.schedule();
         }));
-        this.lifecycleService.when(4 )
+        this.lifecycleService.when(LifecyclePhase.Eventually)
             .then(() => this.debugExtensionsAvailable.set(this.debuggers.length > 0));
         this._register(delegate.onDidNewSession(s => {
             this.usedDebugTypes.add(s.configuration.type);
@@ -84,7 +87,7 @@ let AdapterManager = class AdapterManager extends Disposable {
             delta.added.forEach(added => {
                 added.value.forEach(rawAdapter => {
                     if (!rawAdapter.type || (typeof rawAdapter.type !== 'string')) {
-                        added.collector.error(( localize(5748, "Debugger 'type' can not be omitted and must be of type 'string'.")));
+                        added.collector.error(( localize(5182, "Debugger 'type' can not be omitted and must be of type 'string'.")));
                     }
                     if (rawAdapter.type !== '*') {
                         const existing = this.getDebugger(rawAdapter.type);
@@ -107,21 +110,21 @@ let AdapterManager = class AdapterManager extends Disposable {
                 });
             });
             delta.removed.forEach(removed => {
-                const removedTypes = ( (removed.value.map(rawAdapter => rawAdapter.type)));
+                const removedTypes = ( removed.value.map(rawAdapter => rawAdapter.type));
                 this.debuggers = this.debuggers.filter(d => removedTypes.indexOf(d.type) === -1);
             });
             this.updateDebugAdapterSchema();
             this._onDidDebuggersExtPointRead.fire();
         });
         breakpointsExtPoint.setHandler(extensions => {
-            this.breakpointContributions = extensions.flatMap(ext => ( (ext.value.map(
+            this.breakpointContributions = extensions.flatMap(ext => ( ext.value.map(
                 breakpoint => this.instantiationService.createInstance(Breakpoints, breakpoint)
-            ))));
+            )));
         });
     }
     updateTaskLabels() {
         this.tasksService.getKnownTasks().then(tasks => {
-            this.taskLabels = ( (tasks.map(task => task._label)));
+            this.taskLabels = ( tasks.map(task => task._label));
             this.updateDebugAdapterSchema();
         });
     }
@@ -134,7 +137,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                     'name': {
                         type: 'string',
                         description: ( localize(
-                            5749,
+                            5183,
                             "Name of configuration; appears in the launch configuration dropdown menu."
                         )),
                         default: 'Launch'
@@ -142,7 +145,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                     'debugServer': {
                         type: 'number',
                         description: ( localize(
-                            5750,
+                            5184,
                             "For debug extension development only: if a port is specified VS Code tries to connect to a debug adapter running in server mode"
                         )),
                         default: 4711
@@ -153,7 +156,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                             }],
                         default: '',
                         defaultSnippets: [{ body: { task: '', type: '' } }],
-                        description: ( localize(5751, "Task to run before debug session starts.")),
+                        description: ( localize(5185, "Task to run before debug session starts.")),
                         examples: this.taskLabels,
                     },
                     'postDebugTask': {
@@ -162,7 +165,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                             }],
                         default: '',
                         defaultSnippets: [{ body: { task: '', type: '' } }],
-                        description: ( localize(5752, "Task to run after debug session ends.")),
+                        description: ( localize(5186, "Task to run after debug session ends.")),
                         examples: this.taskLabels,
                     },
                     'presentation': presentationSchema,
@@ -170,7 +173,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                     'suppressMultipleSessionWarning': {
                         type: 'boolean',
                         description: ( localize(
-                            5753,
+                            5187,
                             "Disable the warning when trying to start the same debug configuration more than once."
                         )),
                         default: true
@@ -231,7 +234,7 @@ let AdapterManager = class AdapterManager extends Disposable {
         if (factory) {
             return factory.runInTerminal(args, sessionId);
         }
-        return Promise.resolve(void 0);
+        return Promise.resolve(undefined);
     }
     registerDebugAdapterDescriptorFactory(debugAdapterProvider) {
         this.adapterDescriptorFactories.push(debugAdapterProvider);
@@ -276,9 +279,7 @@ let AdapterManager = class AdapterManager extends Disposable {
         if (this.configurationService.getValue('debug').allowBreakpointsEverywhere) {
             return true;
         }
-        return (
-             (this.breakpointContributions.some(breakpoints => breakpoints.language === languageId && breakpoints.enabled))
-        );
+        return ( this.breakpointContributions.some(breakpoints => breakpoints.language === languageId && breakpoints.enabled));
     }
     getDebugger(type) {
         return this.debuggers.find(dbg => equalsIgnoreCase(dbg.type, type));
@@ -307,7 +308,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                 .filter(a => a.enabled)
                 .filter(a => language && a.interestedInLanguage(language));
             if (adapters.length === 1) {
-                return adapters[0];
+                return { debugger: adapters[0] };
             }
             if (adapters.length > 1) {
                 candidates = adapters;
@@ -324,13 +325,13 @@ let AdapterManager = class AdapterManager extends Disposable {
                 languageLabel = `'${languageLabel}'`;
             }
             const { confirmed } = await this.dialogService.confirm({
-                type: Severity$1.Warning,
+                type: Severity.Warning,
                 message: ( localize(
-                    5754,
+                    5188,
                     "You don't have an extension for debugging {0}. Should we find a {0} extension in the Marketplace?",
                     languageLabel
                 )),
-                primaryButton: ( localize(5755, "&&Find {0} extension", languageLabel))
+                primaryButton: ( localize(5189, "&&Find {0} extension", languageLabel))
             });
             if (confirmed) {
                 await this.commandService.executeCommand('debug.installAdditionalDebuggers', languageLabel);
@@ -347,7 +348,7 @@ let AdapterManager = class AdapterManager extends Disposable {
             if (descriptor.id && !!this.earlyActivatedExtensions?.has(descriptor.id)) {
                 suggestedCandidates.push(d);
             }
-            else if (( (this.usedDebugTypes.has(d.type)))) {
+            else if (( this.usedDebugTypes.has(d.type))) {
                 suggestedCandidates.push(d);
             }
             else {
@@ -355,29 +356,46 @@ let AdapterManager = class AdapterManager extends Disposable {
             }
         });
         const picks = [];
+        const dynamic = await this.delegate.configurationManager().getDynamicProviders();
         if (suggestedCandidates.length > 0) {
-            picks.push({ type: 'separator', label: ( localize(5756, "Suggested")) }, ...( (suggestedCandidates.map(c => ({ label: c.label, debugger: c })))));
+            picks.push({ type: 'separator', label: ( localize(5190, "Suggested")) }, ...( suggestedCandidates.map(c => ({ label: c.label, pick: () => ({ debugger: c }) }))));
         }
         if (otherCandidates.length > 0) {
             if (picks.length > 0) {
                 picks.push({ type: 'separator', label: '' });
             }
-            picks.push(...( (otherCandidates.map(c => ({ label: c.label, debugger: c })))));
+            picks.push(...( otherCandidates.map(c => ({ label: c.label, pick: () => ({ debugger: c }) }))));
+        }
+        if (dynamic.length) {
+            if (picks.length) {
+                picks.push({ type: 'separator', label: '' });
+            }
+            for (const d of dynamic) {
+                picks.push({
+                    label: ( localize(5191, "More {0} options...", d.label)),
+                    pick: async () => {
+                        const cfg = await d.pick();
+                        if (!cfg) {
+                            return undefined;
+                        }
+                        return cfg && { debugger: this.getDebugger(d.type), withConfig: cfg };
+                    },
+                });
+            }
         }
-        picks.push({ type: 'separator', label: '' }, { label: languageLabel ? ( localize(5757, "Install an extension for {0}...", languageLabel)) : ( localize(5758, "Install extension...")) });
+        picks.push({ type: 'separator', label: '' }, { label: languageLabel ? ( localize(5192, "Install an extension for {0}...", languageLabel)) : ( localize(5193, "Install extension...")) });
         const contributed = this.menuService.getMenuActions(MenuId.DebugCreateConfiguration, this.contextKeyService);
         for (const [, action] of contributed) {
             for (const item of action) {
                 picks.push(item);
             }
         }
-        const placeHolder = ( localize(5759, "Select debugger"));
-        return this.quickInputService.pick(picks, { activeItem: picks[0], placeHolder })
-            .then(async (picked) => {
-            if (picked && 'debugger' in picked && picked.debugger) {
-                return picked.debugger;
+        const placeHolder = ( localize(5194, "Select debugger"));
+        return this.quickInputService.pick(picks, { activeItem: picks[0], placeHolder }).then(async (picked) => {
+            if (picked && 'pick' in picked && typeof picked.pick === 'function') {
+                return await picked.pick();
             }
-            else if (picked instanceof MenuItemAction) {
+            if (picked instanceof MenuItemAction) {
                 picked.run();
                 return;
             }
@@ -389,7 +407,7 @@ let AdapterManager = class AdapterManager extends Disposable {
     }
     initExtensionActivationsIfNeeded() {
         if (!this.earlyActivatedExtensions) {
-            this.earlyActivatedExtensions = ( (new Set()));
+            this.earlyActivatedExtensions = ( new Set());
             const status = this.extensionService.getExtensionsStatus();
             for (const id in status) {
                 if (!!status[id].activationTimes) {
@@ -410,19 +428,19 @@ let AdapterManager = class AdapterManager extends Disposable {
         await Promise.all(promises);
     }
 };
-AdapterManager = ( (__decorate([
-    ( (__param(1, IEditorService))),
-    ( (__param(2, IConfigurationService))),
-    ( (__param(3, IQuickInputService))),
-    ( (__param(4, IInstantiationService))),
-    ( (__param(5, ICommandService))),
-    ( (__param(6, IExtensionService))),
-    ( (__param(7, IContextKeyService))),
-    ( (__param(8, ILanguageService))),
-    ( (__param(9, IDialogService))),
-    ( (__param(10, ILifecycleService))),
-    ( (__param(11, ITaskService))),
-    ( (__param(12, IMenuService)))
-], AdapterManager)));
+AdapterManager = ( __decorate([
+    ( __param(1, IEditorService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IQuickInputService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IExtensionService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, ILanguageService)),
+    ( __param(9, IDialogService)),
+    ( __param(10, ILifecycleService)),
+    ( __param(11, ITaskService)),
+    ( __param(12, IMenuService))
+], AdapterManager));
 
 export { AdapterManager };