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

package/vscode/src/vs/workbench/contrib/debug/common/debugStorage.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
 import 'vscode/vscode/vs/base/common/arrays';
@@ -9,10 +10,12 @@ import 'vscode/vscode/vs/base/common/cancellation';
 import 'vscode/vscode/vs/base/common/observableInternal/utils';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
-import { Breakpoint, FunctionBreakpoint, ExceptionBreakpoint, DataBreakpoint, Expression } from '@codingame/monaco-vscode-debug-notebook-common/vscode/vs/workbench/contrib/debug/common/debugModel';
+import { Breakpoint, FunctionBreakpoint, ExceptionBreakpoint, DataBreakpoint, Expression } from '@codingame/monaco-vscode-88aa9a78-75f5-5aaa-89e9-bbdd580b3b5c-common/vscode/vs/workbench/contrib/debug/common/debugModel';
 import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { mapValues } from 'vscode/vscode/vs/base/common/objects';
 
 const DEBUG_BREAKPOINTS_KEY = 'debug.breakpoint';
 const DEBUG_FUNCTION_BREAKPOINTS_KEY = 'debug.functionbreakpoint';
@@ -33,7 +36,7 @@ let DebugStorage = class DebugStorage extends Disposable {
         this.exceptionBreakpoints = observableValue(this, this.loadExceptionBreakpoints());
         this.dataBreakpoints = observableValue(this, this.loadDataBreakpoints());
         this.watchExpressions = observableValue(this, this.loadWatchExpressions());
-        this._register(storageService.onDidChangeValue(1 , undefined, this._store)(e => {
+        this._register(storageService.onDidChangeValue(StorageScope.WORKSPACE, undefined, this._store)(e => {
             if (e.external) {
                 switch (e.key) {
                     case DEBUG_BREAKPOINTS_KEY:
@@ -51,15 +54,15 @@ let DebugStorage = class DebugStorage extends Disposable {
         }));
     }
     loadDebugUxState() {
-        return this.storageService.get(DEBUG_UX_STATE_KEY, 1 , 'default');
+        return this.storageService.get(DEBUG_UX_STATE_KEY, StorageScope.WORKSPACE, 'default');
     }
     storeDebugUxState(value) {
-        this.storageService.store(DEBUG_UX_STATE_KEY, value, 1 , 1 );
+        this.storageService.store(DEBUG_UX_STATE_KEY, value, StorageScope.WORKSPACE, StorageTarget.MACHINE);
     }
     loadBreakpoints() {
         let result;
         try {
-            result = ( JSON.parse(this.storageService.get(DEBUG_BREAKPOINTS_KEY, 1 , '[]')).map((breakpoint) => {
+            result = ( JSON.parse(this.storageService.get(DEBUG_BREAKPOINTS_KEY, StorageScope.WORKSPACE, '[]')).map((breakpoint) => {
                 breakpoint.uri = URI.revive(breakpoint.uri);
                 return ( new Breakpoint(
                     breakpoint,
@@ -76,7 +79,7 @@ let DebugStorage = class DebugStorage extends Disposable {
     loadFunctionBreakpoints() {
         let result;
         try {
-            result = ( JSON.parse(this.storageService.get(DEBUG_FUNCTION_BREAKPOINTS_KEY, 1 , '[]')).map((fb) => {
+            result = ( JSON.parse(this.storageService.get(DEBUG_FUNCTION_BREAKPOINTS_KEY, StorageScope.WORKSPACE, '[]')).map((fb) => {
                 return ( new FunctionBreakpoint(fb, fb.id));
             }));
         }
@@ -86,7 +89,7 @@ let DebugStorage = class DebugStorage extends Disposable {
     loadExceptionBreakpoints() {
         let result;
         try {
-            result = ( JSON.parse(this.storageService.get(DEBUG_EXCEPTION_BREAKPOINTS_KEY, 1 , '[]')).map((exBreakpoint) => {
+            result = ( JSON.parse(this.storageService.get(DEBUG_EXCEPTION_BREAKPOINTS_KEY, StorageScope.WORKSPACE, '[]')).map((exBreakpoint) => {
                 return ( new ExceptionBreakpoint(exBreakpoint, exBreakpoint.id));
             }));
         }
@@ -96,7 +99,7 @@ let DebugStorage = class DebugStorage extends Disposable {
     loadDataBreakpoints() {
         let result;
         try {
-            result = ( JSON.parse(this.storageService.get(DEBUG_DATA_BREAKPOINTS_KEY, 1 , '[]')).map((dbp) => {
+            result = ( JSON.parse(this.storageService.get(DEBUG_DATA_BREAKPOINTS_KEY, StorageScope.WORKSPACE, '[]')).map((dbp) => {
                 return ( new DataBreakpoint(dbp, dbp.id));
             }));
         }
@@ -106,7 +109,7 @@ let DebugStorage = class DebugStorage extends Disposable {
     loadWatchExpressions() {
         let result;
         try {
-            result = ( JSON.parse(this.storageService.get(DEBUG_WATCH_EXPRESSIONS_KEY, 1 , '[]')).map((watchStoredData) => {
+            result = ( JSON.parse(this.storageService.get(DEBUG_WATCH_EXPRESSIONS_KEY, StorageScope.WORKSPACE, '[]')).map((watchStoredData) => {
                 return ( new Expression(watchStoredData.name, watchStoredData.id));
             }));
         }
@@ -114,47 +117,48 @@ let DebugStorage = class DebugStorage extends Disposable {
         return result || [];
     }
     loadChosenEnvironments() {
-        return JSON.parse(this.storageService.get(DEBUG_CHOSEN_ENVIRONMENTS_KEY, 1 , '{}'));
+        const obj = JSON.parse(this.storageService.get(DEBUG_CHOSEN_ENVIRONMENTS_KEY, StorageScope.WORKSPACE, '{}'));
+        return mapValues(obj, (value) => typeof value === 'string' ? { type: value } : value);
     }
     storeChosenEnvironments(environments) {
-        this.storageService.store(DEBUG_CHOSEN_ENVIRONMENTS_KEY, JSON.stringify(environments), 1 , 1 );
+        this.storageService.store(DEBUG_CHOSEN_ENVIRONMENTS_KEY, JSON.stringify(environments), StorageScope.WORKSPACE, StorageTarget.MACHINE);
     }
     storeWatchExpressions(watchExpressions) {
         if (watchExpressions.length) {
-            this.storageService.store(DEBUG_WATCH_EXPRESSIONS_KEY, JSON.stringify(( watchExpressions.map(we => ({ name: we.name, id: we.getId() })))), 1 , 1 );
+            this.storageService.store(DEBUG_WATCH_EXPRESSIONS_KEY, JSON.stringify(( watchExpressions.map(we => ({ name: we.name, id: we.getId() })))), StorageScope.WORKSPACE, StorageTarget.MACHINE);
         }
         else {
-            this.storageService.remove(DEBUG_WATCH_EXPRESSIONS_KEY, 1 );
+            this.storageService.remove(DEBUG_WATCH_EXPRESSIONS_KEY, StorageScope.WORKSPACE);
         }
     }
     storeBreakpoints(debugModel) {
         const breakpoints = debugModel.getBreakpoints();
         if (breakpoints.length) {
-            this.storageService.store(DEBUG_BREAKPOINTS_KEY, JSON.stringify(breakpoints), 1 , 1 );
+            this.storageService.store(DEBUG_BREAKPOINTS_KEY, JSON.stringify(breakpoints), StorageScope.WORKSPACE, StorageTarget.MACHINE);
         }
         else {
-            this.storageService.remove(DEBUG_BREAKPOINTS_KEY, 1 );
+            this.storageService.remove(DEBUG_BREAKPOINTS_KEY, StorageScope.WORKSPACE);
         }
         const functionBreakpoints = debugModel.getFunctionBreakpoints();
         if (functionBreakpoints.length) {
-            this.storageService.store(DEBUG_FUNCTION_BREAKPOINTS_KEY, JSON.stringify(functionBreakpoints), 1 , 1 );
+            this.storageService.store(DEBUG_FUNCTION_BREAKPOINTS_KEY, JSON.stringify(functionBreakpoints), StorageScope.WORKSPACE, StorageTarget.MACHINE);
         }
         else {
-            this.storageService.remove(DEBUG_FUNCTION_BREAKPOINTS_KEY, 1 );
+            this.storageService.remove(DEBUG_FUNCTION_BREAKPOINTS_KEY, StorageScope.WORKSPACE);
         }
         const dataBreakpoints = debugModel.getDataBreakpoints().filter(dbp => dbp.canPersist);
         if (dataBreakpoints.length) {
-            this.storageService.store(DEBUG_DATA_BREAKPOINTS_KEY, JSON.stringify(dataBreakpoints), 1 , 1 );
+            this.storageService.store(DEBUG_DATA_BREAKPOINTS_KEY, JSON.stringify(dataBreakpoints), StorageScope.WORKSPACE, StorageTarget.MACHINE);
         }
         else {
-            this.storageService.remove(DEBUG_DATA_BREAKPOINTS_KEY, 1 );
+            this.storageService.remove(DEBUG_DATA_BREAKPOINTS_KEY, StorageScope.WORKSPACE);
         }
         const exceptionBreakpoints = debugModel.getExceptionBreakpoints();
         if (exceptionBreakpoints.length) {
-            this.storageService.store(DEBUG_EXCEPTION_BREAKPOINTS_KEY, JSON.stringify(exceptionBreakpoints), 1 , 1 );
+            this.storageService.store(DEBUG_EXCEPTION_BREAKPOINTS_KEY, JSON.stringify(exceptionBreakpoints), StorageScope.WORKSPACE, StorageTarget.MACHINE);
         }
         else {
-            this.storageService.remove(DEBUG_EXCEPTION_BREAKPOINTS_KEY, 1 );
+            this.storageService.remove(DEBUG_EXCEPTION_BREAKPOINTS_KEY, StorageScope.WORKSPACE);
         }
     }
 };

package/vscode/src/vs/workbench/contrib/debug/common/debugTelemetry.d.ts

@@ -0,0 +1,10 @@
+import { IDebugModel, IDebugSession, AdapterEndEvent } from "vscode/vscode/vs/workbench/contrib/debug/common/debug";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { Debugger } from "./debugger.js";
+export declare class DebugTelemetry {
+    private readonly model;
+    private readonly telemetryService;
+    constructor(model: IDebugModel, telemetryService: ITelemetryService);
+    logDebugSessionStart(dbgr: Debugger, launchJsonExists: boolean): void;
+    logDebugSessionStop(session: IDebugSession, adapterExitEvent: AdapterEndEvent): void;
+}

package/vscode/src/vs/workbench/contrib/debug/common/debugTelemetry.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 
 let DebugTelemetry = class DebugTelemetry {

package/vscode/src/vs/workbench/contrib/debug/common/debugViewModel.d.ts

@@ -0,0 +1,77 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IDebugSession, IExpression, IExpressionContainer, IStackFrame, IThread, IViewModel } from "vscode/vscode/vs/workbench/contrib/debug/common/debug";
+export declare class ViewModel implements IViewModel {
+    private contextKeyService;
+    firstSessionStart: boolean;
+    private _focusedStackFrame;
+    private _focusedSession;
+    private _focusedThread;
+    private selectedExpression;
+    private readonly _onDidFocusSession;
+    private readonly _onDidFocusThread;
+    private readonly _onDidFocusStackFrame;
+    private readonly _onDidSelectExpression;
+    private readonly _onDidEvaluateLazyExpression;
+    private readonly _onWillUpdateViews;
+    private readonly _onDidChangeVisualization;
+    private readonly visualized;
+    private readonly preferredVisualizers;
+    private expressionSelectedContextKey;
+    private loadedScriptsSupportedContextKey;
+    private stepBackSupportedContextKey;
+    private focusedSessionIsAttach;
+    private focusedSessionIsNoDebug;
+    private restartFrameSupportedContextKey;
+    private stepIntoTargetsSupported;
+    private jumpToCursorSupported;
+    private setVariableSupported;
+    private setDataBreakpointAtByteSupported;
+    private setExpressionSupported;
+    private multiSessionDebug;
+    private terminateDebuggeeSupported;
+    private suspendDebuggeeSupported;
+    private disassembleRequestSupported;
+    private focusedStackFrameHasInstructionPointerReference;
+    constructor(contextKeyService: IContextKeyService);
+    getId(): string;
+    get focusedSession(): IDebugSession | undefined;
+    get focusedThread(): IThread | undefined;
+    get focusedStackFrame(): IStackFrame | undefined;
+    setFocus(stackFrame: IStackFrame | undefined, thread: IThread | undefined, session: IDebugSession | undefined, explicit: boolean): void;
+    get onDidFocusSession(): Event<IDebugSession | undefined>;
+    get onDidFocusThread(): Event<{
+        thread: IThread | undefined;
+        explicit: boolean;
+        session: IDebugSession | undefined;
+    }>;
+    get onDidFocusStackFrame(): Event<{
+        stackFrame: IStackFrame | undefined;
+        explicit: boolean;
+        session: IDebugSession | undefined;
+    }>;
+    get onDidChangeVisualization(): Event<{
+        original: IExpression;
+        replacement: IExpression;
+    }>;
+    getSelectedExpression(): {
+        expression: IExpression;
+        settingWatch: boolean;
+    } | undefined;
+    setSelectedExpression(expression: IExpression | undefined, settingWatch: boolean): void;
+    get onDidSelectExpression(): Event<{
+        expression: IExpression;
+        settingWatch: boolean;
+    } | undefined>;
+    get onDidEvaluateLazyExpression(): Event<IExpressionContainer>;
+    updateViews(): void;
+    get onWillUpdateViews(): Event<void>;
+    isMultiSessionView(): boolean;
+    setMultiSessionView(isMultiSessionView: boolean): void;
+    setVisualizedExpression(original: IExpression, visualized: IExpression & {
+        treeId: string;
+    } | undefined): void;
+    getVisualizedExpression(expression: IExpression): IExpression | string | undefined;
+    evaluateLazyExpression(expression: IExpressionContainer): Promise<void>;
+    private getPreferredVisualizedKey;
+}

package/vscode/src/vs/workbench/contrib/debug/common/debugViewModel.js

@@ -1,3 +1,4 @@
+
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { CONTEXT_EXPRESSION_SELECTED, CONTEXT_LOADED_SCRIPTS_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_FOCUSED_SESSION_IS_NO_DEBUG, CONTEXT_RESTART_FRAME_SUPPORTED, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, CONTEXT_SET_VARIABLE_SUPPORTED, CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED, CONTEXT_SET_EXPRESSION_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED, CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { isSessionAttach } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';

package/vscode/src/vs/workbench/contrib/debug/common/debugVisualizers.d.ts

@@ -0,0 +1,55 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { IDisposable, IReference } from "vscode/vscode/vs/base/common/lifecycle";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { ExtensionIdentifier } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { MainThreadDebugVisualization, IDebugVisualization, IDebugVisualizationContext, IExpression, IDebugVisualizationTreeItem, IDebugSession } from "vscode/vscode/vs/workbench/contrib/debug/common/debug";
+import { VisualizedExpression } from "@codingame/monaco-vscode-88aa9a78-75f5-5aaa-89e9-bbdd580b3b5c-common/vscode/vs/workbench/contrib/debug/common/debugModel";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IDebugVisualizerService } from "vscode/vscode/vs/workbench/contrib/debug/common/debugVisualizers.service";
+export interface VisualizerHandle {
+    id: string;
+    extensionId: ExtensionIdentifier;
+    provideDebugVisualizers(context: IDebugVisualizationContext, token: CancellationToken): Promise<IDebugVisualization[]>;
+    resolveDebugVisualizer(viz: IDebugVisualization, token: CancellationToken): Promise<MainThreadDebugVisualization>;
+    executeDebugVisualizerCommand(id: number): Promise<void>;
+    disposeDebugVisualizers(ids: number[]): void;
+}
+export interface VisualizerTreeHandle {
+    getTreeItem(element: IDebugVisualizationContext): Promise<IDebugVisualizationTreeItem | undefined>;
+    getChildren(element: number): Promise<IDebugVisualizationTreeItem[]>;
+    disposeItem(element: number): void;
+    editItem?(item: number, value: string): Promise<IDebugVisualizationTreeItem | undefined>;
+}
+export declare class DebugVisualizer {
+    private readonly handle;
+    private readonly viz;
+    get name(): string;
+    get iconPath(): {
+        light?: import("vscode/vscode/vs/base/common/uri").URI | undefined;
+        dark: import("vscode/vscode/vs/base/common/uri").URI;
+    } | undefined;
+    get iconClass(): string | undefined;
+    constructor(handle: VisualizerHandle, viz: IDebugVisualization);
+    resolve(token: CancellationToken): Promise<MainThreadDebugVisualization>;
+    execute(): Promise<void>;
+}
+export declare class DebugVisualizerService implements IDebugVisualizerService {
+    private readonly contextKeyService;
+    private readonly extensionService;
+    private readonly logService;
+    readonly _serviceBrand: undefined;
+    private readonly handles;
+    private readonly trees;
+    private readonly didActivate;
+    private registrations;
+    constructor(contextKeyService: IContextKeyService, extensionService: IExtensionService, logService: ILogService);
+    getApplicableFor(variable: IExpression, token: CancellationToken): Promise<IReference<DebugVisualizer[]>>;
+    register(handle: VisualizerHandle): IDisposable;
+    registerTree(treeId: string, handle: VisualizerTreeHandle): IDisposable;
+    getVisualizedNodeFor(treeId: string, expr: IExpression): Promise<VisualizedExpression | undefined>;
+    getVisualizedChildren(session: IDebugSession | undefined, treeId: string, treeElementId: number): Promise<IExpression[]>;
+    editTreeItem(treeId: string, treeItem: IDebugVisualizationTreeItem, newValue: string): Promise<void>;
+    private getVariableContext;
+    private processExtensionRegistration;
+}

package/vscode/src/vs/workbench/contrib/debug/common/debugVisualizers.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { isDefined } from 'vscode/vscode/vs/base/common/types';
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
@@ -7,7 +8,7 @@ import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { CONTEXT_VARIABLE_NAME, CONTEXT_VARIABLE_VALUE, CONTEXT_VARIABLE_TYPE } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { getContextForVariable } from './debugContext.js';
-import { Variable, VisualizedExpression, Scope } from '@codingame/monaco-vscode-debug-notebook-common/vscode/vs/workbench/contrib/debug/common/debugModel';
+import { Variable, VisualizedExpression, Scope } from '@codingame/monaco-vscode-88aa9a78-75f5-5aaa-89e9-bbdd580b3b5c-common/vscode/vs/workbench/contrib/debug/common/debugModel';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
 

package/vscode/src/vs/workbench/contrib/debug/common/debugger.d.ts

@@ -0,0 +1,52 @@
+import { IJSONSchema, IJSONSchemaMap, IJSONSchemaSnippet } from "vscode/vscode/vs/base/common/jsonSchema";
+import { IWorkspaceFolder } from "vscode/vscode/vs/platform/workspace/common/workspace";
+import { IConfig, IDebuggerContribution, IDebugAdapter, IDebugger, IDebugSession, IAdapterManager, IDebuggerMetadata } from "vscode/vscode/vs/workbench/contrib/debug/common/debug";
+import { IDebugService } from "vscode/vscode/vs/workbench/contrib/debug/common/debug.service";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IConfigurationResolverService } from "vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service";
+import { ITextResourcePropertiesService } from "vscode/vscode/vs/editor/common/services/textResourceConfiguration";
+import { IExtensionDescription } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { ITelemetryEndpoint } from "vscode/vscode/vs/platform/telemetry/common/telemetry";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { ContextKeyExpression } from "vscode/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+export declare class Debugger implements IDebugger, IDebuggerMetadata {
+    private adapterManager;
+    private readonly configurationService;
+    private readonly resourcePropertiesService;
+    private readonly configurationResolverService;
+    private readonly environmentService;
+    private readonly debugService;
+    private readonly contextKeyService;
+    private debuggerContribution;
+    private mergedExtensionDescriptions;
+    private mainExtensionDescription;
+    private debuggerWhen;
+    private debuggerHiddenWhen;
+    constructor(adapterManager: IAdapterManager, dbgContribution: IDebuggerContribution, extensionDescription: IExtensionDescription, configurationService: IConfigurationService, resourcePropertiesService: ITextResourcePropertiesService, configurationResolverService: IConfigurationResolverService, environmentService: IWorkbenchEnvironmentService, debugService: IDebugService, contextKeyService: IContextKeyService);
+    merge(otherDebuggerContribution: IDebuggerContribution, extensionDescription: IExtensionDescription): void;
+    startDebugging(configuration: IConfig, parentSessionId: string): Promise<boolean>;
+    createDebugAdapter(session: IDebugSession): Promise<IDebugAdapter>;
+    substituteVariables(folder: IWorkspaceFolder | undefined, config: IConfig): Promise<IConfig>;
+    runInTerminal(args: DebugProtocol.RunInTerminalRequestArguments, sessionId: string): Promise<number | undefined>;
+    get label(): string;
+    get type(): string;
+    get variables(): {
+        [key: string]: string;
+    } | undefined;
+    get configurationSnippets(): IJSONSchemaSnippet[] | undefined;
+    get languages(): string[] | undefined;
+    get when(): ContextKeyExpression | undefined;
+    get hiddenWhen(): ContextKeyExpression | undefined;
+    get enabled(): boolean;
+    get isHiddenFromDropdown(): boolean;
+    get strings(): any;
+    interestedInLanguage(languageId: string): boolean;
+    hasInitialConfiguration(): boolean;
+    hasDynamicConfigurationProviders(): boolean;
+    hasConfigurationProvider(): boolean;
+    getInitialConfigurationContent(initialConfigs?: IConfig[]): Promise<string>;
+    getMainExtensionDescriptor(): IExtensionDescription;
+    getCustomTelemetryEndpoint(): ITelemetryEndpoint | undefined;
+    getSchemaAttributes(definitions: IJSONSchemaMap): IJSONSchema[] | null;
+}

package/vscode/src/vs/workbench/contrib/debug/common/debugger.js

@@ -1,11 +1,12 @@
-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 { isObject } from 'vscode/vscode/vs/base/common/types';
 import { DebugConfigurationProviderTriggerKind, debuggerDisabledMessage } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { IConfigurationResolverService } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
-import { applyDeprecatedVariableMessage } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolverUtils';
+import { applyDeprecatedVariableMessage } from '@codingame/monaco-vscode-2448342b-297f-5823-9f41-f18eef0f6ee8-common/vscode/vs/workbench/services/configurationResolver/common/configurationResolverUtils';
 import { ITextResourcePropertiesService } from 'vscode/vscode/vs/editor/common/services/textResourceConfiguration';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
@@ -37,7 +38,7 @@ let Debugger = class Debugger {
                 return source;
             }
             if (isObject(source)) {
-                ( (Object.keys(source))).forEach(key => {
+                ( Object.keys(source)).forEach(key => {
                     if (key !== '__proto__') {
                         if (isObject(destination[key]) && isObject(source[key])) {
                             mixin(destination[key], source[key], overwrite, level + 1);
@@ -78,7 +79,7 @@ let Debugger = class Debugger {
         if (da) {
             return Promise.resolve(da);
         }
-        throw ( (new Error(localize(10362, "Cannot find debug adapter for type '{0}'.", this.type))));
+        throw ( new Error(( localize(5624, "Cannot find debug adapter for type '{0}'.", this.type))));
     }
     async substituteVariables(folder, config) {
         const substitutedConfig = await this.adapterManager.substituteVariables(this.type, folder, config);
@@ -137,12 +138,12 @@ let Debugger = class Debugger {
         if (initialConfigs) {
             initialConfigurations = initialConfigurations.concat(initialConfigs);
         }
-        const eol = this.resourcePropertiesService.getEOL(( (URI.from({ scheme: Schemas.untitled, path: '1' })))) === '\r\n' ? '\r\n' : '\n';
-        const configs = ( (JSON.stringify(initialConfigurations, null, '\t').split('\n').map(line => '\t' + line))).join(eol).trim();
-        const comment1 = ( localize(10363, "Use IntelliSense to learn about possible attributes."));
-        const comment2 = ( localize(10364, "Hover to view descriptions of existing attributes."));
+        const eol = this.resourcePropertiesService.getEOL(( URI.from({ scheme: Schemas.untitled, path: '1' }))) === '\r\n' ? '\r\n' : '\n';
+        const configs = ( JSON.stringify(initialConfigurations, null, '\t').split('\n').map(line => '\t' + line)).join(eol).trim();
+        const comment1 = ( localize(5625, "Use IntelliSense to learn about possible attributes."));
+        const comment2 = ( localize(5626, "Hover to view descriptions of existing attributes."));
         const comment3 = ( localize(
-            10365,
+            5627,
             "For more information, visit: {0}",
             'https://go.microsoft.com/fwlink/?linkid=830387'
         ));
@@ -157,7 +158,7 @@ let Debugger = class Debugger {
         ].join(eol);
         const editorConfig = this.configurationService.getValue();
         if (editorConfig.editor && editorConfig.editor.insertSpaces) {
-            content = content.replace(( (new RegExp('\t', 'g'))), ' '.repeat(editorConfig.editor.tabSize));
+            content = content.replace(( new RegExp('\t', 'g')), ' '.repeat(editorConfig.editor.tabSize));
         }
         return Promise.resolve(content);
     }
@@ -180,83 +181,81 @@ let Debugger = class Debugger {
         if (!this.debuggerContribution.configurationAttributes) {
             return null;
         }
-        return (
-             (( (Object.keys(this.debuggerContribution.configurationAttributes))).map(request => {
-                const definitionId = `${this.type}:${request}`;
-                const platformSpecificDefinitionId = `${this.type}:${request}:platform`;
-                const attributes = this.debuggerContribution.configurationAttributes[request];
-                const defaultRequired = ['name', 'type', 'request'];
-                attributes.required = attributes.required && attributes.required.length ? defaultRequired.concat(attributes.required) : defaultRequired;
-                attributes.additionalProperties = false;
-                attributes.type = 'object';
-                if (!attributes.properties) {
-                    attributes.properties = {};
-                }
-                const properties = attributes.properties;
-                properties['type'] = {
-                    enum: [this.type],
-                    enumDescriptions: [this.label],
-                    description: ( localize(10366, "Type of configuration.")),
-                    pattern: '^(?!node2)',
-                    deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
-                    doNotSuggest: !!this.debuggerContribution.deprecated,
-                    errorMessage: ( localize(
-                        10367,
-                        "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
-                    )),
-                    patternErrorMessage: ( localize(
-                        10368,
-                        "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
-                    ))
-                };
-                properties['request'] = {
-                    enum: [request],
-                    description: ( localize(10369, "Request type of configuration. Can be \"launch\" or \"attach\".")),
-                };
-                for (const prop in definitions['common'].properties) {
-                    properties[prop] = {
-                        $ref: `#/definitions/common/properties/${prop}`
-                    };
-                }
-                ( (Object.keys(properties))).forEach(name => {
-                    applyDeprecatedVariableMessage(properties[name]);
-                });
-                definitions[definitionId] = { ...attributes };
-                definitions[platformSpecificDefinitionId] = {
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: filter(properties, key => key !== 'type' && key !== 'request' && key !== 'name')
+        return (( Object.keys(this.debuggerContribution.configurationAttributes)).map(request => {
+            const definitionId = `${this.type}:${request}`;
+            const platformSpecificDefinitionId = `${this.type}:${request}:platform`;
+            const attributes = this.debuggerContribution.configurationAttributes[request];
+            const defaultRequired = ['name', 'type', 'request'];
+            attributes.required = attributes.required && attributes.required.length ? defaultRequired.concat(attributes.required) : defaultRequired;
+            attributes.additionalProperties = false;
+            attributes.type = 'object';
+            if (!attributes.properties) {
+                attributes.properties = {};
+            }
+            const properties = attributes.properties;
+            properties['type'] = {
+                enum: [this.type],
+                enumDescriptions: [this.label],
+                description: ( localize(5628, "Type of configuration.")),
+                pattern: '^(?!node2)',
+                deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
+                doNotSuggest: !!this.debuggerContribution.deprecated,
+                errorMessage: ( localize(
+                    5629,
+                    "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
+                )),
+                patternErrorMessage: ( localize(
+                    5630,
+                    "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
+                ))
+            };
+            properties['request'] = {
+                enum: [request],
+                description: ( localize(5631, "Request type of configuration. Can be \"launch\" or \"attach\".")),
+            };
+            for (const prop in definitions['common'].properties) {
+                properties[prop] = {
+                    $ref: `#/definitions/common/properties/${prop}`
                 };
-                const attributesCopy = { ...attributes };
-                attributesCopy.properties = {
-                    ...properties,
-                    ...{
-                        windows: {
-                            $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                            description: ( localize(10370, "Windows specific launch configuration attributes.")),
-                        },
-                        osx: {
-                            $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                            description: ( localize(10371, "OS X specific launch configuration attributes.")),
-                        },
-                        linux: {
-                            $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                            description: ( localize(10372, "Linux specific launch configuration attributes.")),
-                        }
+            }
+            ( Object.keys(properties)).forEach(name => {
+                applyDeprecatedVariableMessage(properties[name]);
+            });
+            definitions[definitionId] = { ...attributes };
+            definitions[platformSpecificDefinitionId] = {
+                type: 'object',
+                additionalProperties: false,
+                properties: filter(properties, key => key !== 'type' && key !== 'request' && key !== 'name')
+            };
+            const attributesCopy = { ...attributes };
+            attributesCopy.properties = {
+                ...properties,
+                ...{
+                    windows: {
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                        description: ( localize(5632, "Windows specific launch configuration attributes.")),
+                    },
+                    osx: {
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                        description: ( localize(5633, "OS X specific launch configuration attributes.")),
+                    },
+                    linux: {
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                        description: ( localize(5634, "Linux specific launch configuration attributes.")),
                     }
-                };
-                return attributesCopy;
-            }))
-        );
+                }
+            };
+            return attributesCopy;
+        }));
     }
 };
-Debugger = ( (__decorate([
-    ( (__param(3, IConfigurationService))),
-    ( (__param(4, ITextResourcePropertiesService))),
-    ( (__param(5, IConfigurationResolverService))),
-    ( (__param(6, IWorkbenchEnvironmentService))),
-    ( (__param(7, IDebugService))),
-    ( (__param(8, IContextKeyService)))
-], Debugger)));
+Debugger = ( __decorate([
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ITextResourcePropertiesService)),
+    ( __param(5, IConfigurationResolverService)),
+    ( __param(6, IWorkbenchEnvironmentService)),
+    ( __param(7, IDebugService)),
+    ( __param(8, IContextKeyService))
+], Debugger));
 
 export { Debugger };

package/vscode/src/vs/workbench/contrib/debug/common/replAccessibilityAnnouncer.d.ts

@@ -0,0 +1,9 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IAccessibilityService } from "vscode/vscode/vs/platform/accessibility/common/accessibility.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IWorkbenchContribution } from "vscode/vscode/vs/workbench/common/contributions";
+import { IDebugService } from "vscode/vscode/vs/workbench/contrib/debug/common/debug.service";
+export declare class ReplAccessibilityAnnouncer extends Disposable implements IWorkbenchContribution {
+    static ID: string;
+    constructor(debugService: IDebugService, accessibilityService: IAccessibilityService, logService: ILogService);
+}

package/vscode/src/vs/workbench/contrib/debug/common/replAccessibilityAnnouncer.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility.service';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands.d.ts

@@ -0,0 +1,2 @@
+export declare const COPY_NOTEBOOK_VARIABLE_VALUE_ID = "workbench.debug.viewlet.action.copyWorkspaceVariableValue";
+export declare const COPY_NOTEBOOK_VARIABLE_VALUE_LABEL: string;