@codingame/monaco-vscode-debug-service-override 20.1.1 → 20.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-debug-service-override",
-  "version": "20.1.1",
+  "version": "20.2.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - debug service-override",
   "keywords": [],
@@ -15,21 +15,21 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-262ed59d-4f76-57cd-9e9f-1877f26ae049-common": "20.1.1",
-    "@codingame/monaco-vscode-34a0ffd3-b9f5-5699-b43b-38af5732f38a-common": "20.1.1",
-    "@codingame/monaco-vscode-501b06ab-3f58-516b-8a1a-c29d375d3da4-common": "20.1.1",
-    "@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common": "20.1.1",
-    "@codingame/monaco-vscode-88aa9a78-75f5-5aaa-89e9-bbdd580b3b5c-common": "20.1.1",
-    "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common": "20.1.1",
-    "@codingame/monaco-vscode-a8d3bd74-e63e-5327-96e8-4f931661e329-common": "20.1.1",
-    "@codingame/monaco-vscode-ab07af84-42e8-5a0f-8aef-b83fb90ede21-common": "20.1.1",
-    "@codingame/monaco-vscode-api": "20.1.1",
-    "@codingame/monaco-vscode-b99aef83-0d60-5e8c-a62e-9908b6256f35-common": "20.1.1",
-    "@codingame/monaco-vscode-ce7c734f-7712-563c-9335-d7acb43306af-common": "20.1.1",
-    "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common": "20.1.1",
-    "@codingame/monaco-vscode-e59ecb8c-db32-5324-8fe4-cf9921fd92b8-common": "20.1.1",
-    "@codingame/monaco-vscode-f24e325c-2ce0-5bba-8236-bfc4f53180ab-common": "20.1.1",
-    "@codingame/monaco-vscode-fc42f049-7883-579d-bb0b-2aa1010a19a8-common": "20.1.1"
+    "@codingame/monaco-vscode-262ed59d-4f76-57cd-9e9f-1877f26ae049-common": "20.2.1",
+    "@codingame/monaco-vscode-34a0ffd3-b9f5-5699-b43b-38af5732f38a-common": "20.2.1",
+    "@codingame/monaco-vscode-501b06ab-3f58-516b-8a1a-c29d375d3da4-common": "20.2.1",
+    "@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common": "20.2.1",
+    "@codingame/monaco-vscode-88aa9a78-75f5-5aaa-89e9-bbdd580b3b5c-common": "20.2.1",
+    "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common": "20.2.1",
+    "@codingame/monaco-vscode-a8d3bd74-e63e-5327-96e8-4f931661e329-common": "20.2.1",
+    "@codingame/monaco-vscode-ab07af84-42e8-5a0f-8aef-b83fb90ede21-common": "20.2.1",
+    "@codingame/monaco-vscode-api": "20.2.1",
+    "@codingame/monaco-vscode-b99aef83-0d60-5e8c-a62e-9908b6256f35-common": "20.2.1",
+    "@codingame/monaco-vscode-ce7c734f-7712-563c-9335-d7acb43306af-common": "20.2.1",
+    "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common": "20.2.1",
+    "@codingame/monaco-vscode-e59ecb8c-db32-5324-8fe4-cf9921fd92b8-common": "20.2.1",
+    "@codingame/monaco-vscode-f24e325c-2ce0-5bba-8236-bfc4f53180ab-common": "20.2.1",
+    "@codingame/monaco-vscode-fc42f049-7883-579d-bb0b-2aa1010a19a8-common": "20.2.1"
   },
   "main": "index.js",
   "module": "index.js",

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

@@ -44,6 +44,7 @@ export declare class AdapterManager extends Disposable implements IAdapterManage
     private breakpointContributions;
     private debuggerWhenKeys;
     private taskLabels;
+    /** Extensions that were already active before any debugger activation events */
     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);

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

@@ -44,6 +44,9 @@ export declare class ConfigurationManager implements IConfigurationManager {
     constructor(adapterManager: IAdapterManager, contextService: IWorkspaceContextService, configurationService: IConfigurationService, quickInputService: IQuickInputService, instantiationService: IInstantiationService, storageService: IStorageService, extensionService: IExtensionService, historyService: IHistoryService, uriIdentityService: IUriIdentityService, contextKeyService: IContextKeyService, logService: ILogService);
     registerDebugConfigurationProvider(debugConfigurationProvider: IDebugConfigurationProvider): IDisposable;
     unregisterDebugConfigurationProvider(debugConfigurationProvider: IDebugConfigurationProvider): void;
+    /**
+     * if scope is not specified,a value of DebugConfigurationProvideTrigger.Initial is assumed.
+     */
     hasDebugConfigurationProvider(debugType: string, triggerKind?: DebugConfigurationProviderTriggerKind): boolean;
     resolveConfigurationByProviders(folderUri: uri | undefined, type: string | undefined, config: IConfig, token: CancellationToken): Promise<IConfig | null | undefined>;
     resolveDebugConfigurationWithSubstitutedVariables(folderUri: uri | undefined, type: string | undefined, config: IConfig, token: CancellationToken): Promise<IConfig | null | undefined>;

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

@@ -9,21 +9,35 @@ export declare class DebugMemoryFileSystemProvider extends Disposable implements
     private memoryFdCounter;
     private readonly fdMemory;
     private readonly changeEmitter;
+    /** @inheritdoc */
     readonly onDidChangeCapabilities: Event<any>;
+    /** @inheritdoc */
     readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    /** @inheritdoc */
     readonly capabilities: number;
     constructor(debugService: IDebugService);
     watch(resource: URI, opts: IWatchOptions): import("@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle").IDisposable;
+    /** @inheritdoc */
     stat(file: URI): Promise<IStat>;
+    /** @inheritdoc */
     mkdir(): never;
+    /** @inheritdoc */
     readdir(): never;
+    /** @inheritdoc */
     delete(): never;
+    /** @inheritdoc */
     rename(): never;
+    /** @inheritdoc */
     open(resource: URI, _opts: IFileOpenOptions): Promise<number>;
+    /** @inheritdoc */
     close(fd: number): Promise<void>;
+    /** @inheritdoc */
     writeFile(resource: URI, content: Uint8Array): Promise<void>;
+    /** @inheritdoc */
     readFile(resource: URI): Promise<Uint8Array<ArrayBuffer>>;
+    /** @inheritdoc */
     read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    /** @inheritdoc */
     write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
     protected parseUri(uri: URI): {
         session: IDebugSession;

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

@@ -98,8 +98,18 @@ export declare class DebugService implements IDebugService {
         restart: boolean;
     }>;
     private lazySetup;
+    /**
+     * main entry point
+     * properly manages compounds, checks for errors and handles the initializing state.
+     */
     startDebugging(launch: ILaunch | undefined, configOrName?: IConfig | string, options?: IDebugSessionOptions, saveBeforeStart?: boolean): Promise<boolean>;
+    /**
+     * gets the debugger for the type, resolves configurations by providers, substitutes variables and runs prelaunch tasks
+     */
     private createSession;
+    /**
+     * instantiates the new session, initializes the session, registers session listeners and reports telemetry
+     */
     private doCreateSession;
     private launchOrAttachToSession;
     private registerSessionListeners;
@@ -142,6 +152,11 @@ export declare class DebugService implements IDebugService {
     setExceptionBreakpointsForSession(session: IDebugSession, filters: DebugProtocol.ExceptionBreakpointsFilter[]): void;
     setExceptionBreakpointCondition(exceptionBreakpoint: IExceptionBreakpoint, condition: string | undefined): Promise<void>;
     sendAllBreakpoints(session?: IDebugSession): Promise<void>;
+    /**
+     * Removes the condition of triggered breakpoints that depended on
+     * breakpoints in `removedBreakpoints`. Returns the URIs of resources that
+     * had their breakpoints changed in this way.
+     */
     private unlinkTriggeredBreakpoints;
     private makeTriggeredBreakpointsMatchEnablement;
     sendBreakpoints(modelUri: uri, sourceModified?: boolean, session?: IDebugSession): Promise<void>;

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

@@ -66,7 +66,9 @@ export declare class DebugSession implements IDebugSession {
     private repl;
     private stoppedDetails;
     private readonly statusQueue;
+    /** Test run this debug session was spawned by */
     readonly correlatedTestRun?: LiveTestResult;
+    /** Whether we terminated the correlated run yet. Used so a 2nd terminate request goes through to the underlying session. */
     private didTerminateTestRun?;
     private readonly _onDidChangeState;
     private readonly _onDidEndAdapter;
@@ -79,6 +81,10 @@ export declare class DebugSession implements IDebugSession {
     private readonly _onDidChangeREPLElements;
     private _name;
     private readonly _onDidChangeName;
+    /**
+     * Promise set while enabling dependent breakpoints to block the debugger
+     * from continuing from a stopped state.
+     */
     private _waitToResume?;
     constructor(id: string, _configuration: {
         resolved: IConfig;
@@ -117,11 +123,29 @@ export declare class DebugSession implements IDebugSession {
     get onDidProgressUpdate(): Event<DebugProtocol.ProgressUpdateEvent>;
     get onDidProgressEnd(): Event<DebugProtocol.ProgressEndEvent>;
     get onDidInvalidateMemory(): Event<DebugProtocol.MemoryEvent>;
+    /**
+     * create and initialize a new debug adapter for this session
+     */
     initialize(dbgr: IDebugger): Promise<void>;
+    /**
+     * launch or attach to the debuggee
+     */
     launchOrAttach(config: IConfig): Promise<void>;
+    /**
+     * Terminate any linked test run.
+     */
     cancelCorrelatedTestRun(): void;
+    /**
+     * terminate the current debug adapter session
+     */
     terminate(restart?: boolean): Promise<void>;
+    /**
+     * end the current debug adapter session
+     */
     disconnect(restart?: boolean, suspend?: boolean): Promise<void>;
+    /**
+     * restart debug adapter session
+     */
     restart(): Promise<void>;
     sendBreakpoints(modelUri: URI, breakpointsToSend: IBreakpoint[], sourceModified: boolean): Promise<void>;
     sendFunctionBreakpoints(fbpts: IFunctionBreakpoint[]): Promise<void>;
@@ -199,9 +223,40 @@ export declare class DebugSession implements IDebugSession {
     addReplExpression(stackFrame: IStackFrame | undefined, expression: string): Promise<void>;
     appendToRepl(data: INewReplElementData, isImportant?: boolean): void;
 }
+/**
+ * Keeps track of events for threads, and cancels any previous operations for
+ * a thread when the thread goes into a new state. Currently, the operations a thread has are:
+ *
+ * - started
+ * - stopped
+ * - continue
+ * - exited
+ *
+ * In each case, the new state preempts the old state, so we don't need to
+ * queue work, just cancel old work. It's up to the caller to make sure that
+ * no UI effects happen at the point when the `token` is cancelled.
+ */
 export declare class ThreadStatusScheduler extends Disposable {
+    /**
+     * An array of set of thread IDs. When a 'stopped' event is encountered, the
+     * editor refreshes its thread IDs. In the meantime, the thread may change
+     * state it again. So the editor puts a Set into this array when it starts
+     * the refresh, and checks it after the refresh is finished, to see if
+     * any of the threads it looked up should now be invalidated.
+     */
     private pendingCancellations;
+    /**
+     * Cancellation tokens for currently-running operations on threads.
+     */
     private readonly threadOps;
+    /**
+     * Runs the operation.
+     * If thread is undefined it affects all threads.
+     */
     run(threadIdsP: Promise<number[]>, operation: (threadId: number, ct: CancellationToken) => Promise<unknown>): Promise<void>;
+    /**
+     * Cancels all ongoing state operations on the given threads.
+     * If threads is undefined it cancel all threads.
+     */
     cancel(threadIds?: readonly number[]): void;
 }

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

@@ -32,15 +32,25 @@ export declare class DebugToolBar extends Themable implements IWorkbenchContribu
     private isVisible;
     private isBuilt;
     private readonly stopActionViewItemDisposables;
+    /** coordinate of the debug toolbar per aux window */
     private readonly auxWindowCoordinates;
     private readonly trackPixelRatioListener;
     constructor(notificationService: INotificationService, telemetryService: ITelemetryService, debugService: IDebugService, layoutService: IWorkbenchLayoutService, storageService: IStorageService, configurationService: IConfigurationService, themeService: IThemeService, instantiationService: IInstantiationService, menuService: IMenuService, contextKeyService: IContextKeyService);
     private registerListeners;
+    /**
+     * Computes the x percent position at which the toolbar is currently displayed.
+     */
     private computeCurrentXPercent;
+    /**
+     * Gets the x position set in the style of the toolbar. This may not be its
+     * actual position on screen depending on toolbar locations.
+     */
     private getCurrentXPercent;
+    /** Gets the y position set in the style of the toolbar */
     private getCurrentYPosition;
     private storePosition;
     updateStyles(): void;
+    /** Gets the stored X position of the middle of the toolbar based on the current window width */
     private getStoredXPosition;
     private getStoredYPosition;
     private setCoordinates;

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

@@ -18,11 +18,17 @@ export interface IDisassembledInstructionEntry {
     allowBreakpoint: boolean;
     isBreakpointSet: boolean;
     isBreakpointEnabled: boolean;
+    /** Instruction reference from the DA */
     instructionReference: string;
+    /** Offset from the instructionReference that's the basis for the `instructionOffset` */
     instructionReferenceOffset: number;
+    /** The number of instructions (+/-) away from the instructionReference and instructionReferenceOffset this instruction lies */
     instructionOffset: number;
+    /** Whether this is the first instruction on the target line. */
     showSourceLocation?: boolean;
+    /** Original instruction from the debugger */
     instruction: DebugProtocol.DisassembledInstruction;
+    /** Parsed instruction address */
     address: bigint;
 }
 export declare class DisassemblyView extends EditorPane {
@@ -64,14 +70,28 @@ export declare class DisassemblyView extends EditorPane {
     protected createEditor(parent: HTMLElement): void;
     layout(dimension: Dimension): void;
     goToInstructionAndOffset(instructionReference: string, offset: number, focus?: boolean): Promise<void>;
+    /** Gets the address associated with the instruction reference. */
     getReferenceAddress(instructionReference: string): bigint | undefined;
+    /**
+     * Go to the address provided. If no address is provided, reveal the address of the currently focused stack frame. Returns false if that address is not available.
+     */
     private goToAddress;
     private scrollUp_LoadDisassembledInstructions;
     private scrollDown_LoadDisassembledInstructions;
+    /**
+     * Sets the memory reference address. We don't just loadDisassembledInstructions
+     * for this, since we can't really deal with discontiguous ranges (we can't
+     * detect _if_ a range is discontiguous since we don't know how much memory
+     * comes between instructions.)
+     */
     private primeMemoryReference;
+    /** Loads disasembled instructions. Returns the number of instructions that were loaded. */
     private loadDisassembledInstructions;
     private getIndexFromReferenceAndOffset;
     private getIndexFromAddress;
+    /**
+     * Clears the table and reload instructions near the target address
+     */
     private reloadDisassembly;
     private clear;
     private onContextMenu;

package/vscode/src/vs/workbench/contrib/debug/browser/media/debug.contribution.css

@@ -1,25 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .codicon-debug-hint {
 	cursor: pointer;
 }
+
 .codicon-debug-hint:not([class*='codicon-debug-breakpoint']):not([class*='codicon-debug-stackframe']) {
 	opacity: 0.4 !important;
 }
+
 .inline-breakpoint-widget.codicon {
 	display: flex !important;
 	align-items: center;
 }
+
 .inline-breakpoint-widget.codicon-debug-breakpoint-disabled {
 	opacity: 0.7;
 }
+
 .monaco-editor .inline-breakpoint-widget.line-start {
 	left: -8px !important;
 }
+
 .monaco-editor .debug-breakpoint-placeholder {
 	width: 0.9em;
 	display: inline-flex;
 	vertical-align: middle;
 	margin-top: -1px;
 }
+
+
 .codicon-debug-breakpoint-conditional.codicon-debug-stackframe-focused::after,
 .codicon-debug-breakpoint-conditional.codicon-debug-stackframe::after,
 .codicon-debug-breakpoint.codicon-debug-stackframe-focused::after,
@@ -28,6 +40,7 @@
 	font-family: var(--vscode-icon-debug-stackframe-dot-font-family);
 	position: absolute;
 }
+
 .monaco-editor .debug-top-stack-frame-column {
 	font: normal normal normal 16px/1 codicon;
 	text-rendering: auto;
@@ -35,34 +48,45 @@
 	-moz-osx-font-smoothing: grayscale;
 	margin-left: 0;
 	margin-right: 4px;
-	margin-top: -1px;
+	margin-top: -1px; /* TODO @misolori: figure out a way to not use negative margin for alignment */
 	align-items: center;
 	width: 0.9em;
 	display: inline-flex;
 	vertical-align: middle;
 }
+
 .debug-var-hover-pre {
 	margin: 0;
 }
+
 .debug-var-hover-pre span {
 	display: inline !important;
 }
+
+/* Do not push text with inline decoration when decoration on start of line */
 .monaco-editor .debug-top-stack-frame-column.start-of-line {
 	position: absolute;
 	top: 50%;
 	transform: translate(-17px, -50%);
-	margin-top: 0px;
+	margin-top: 0px; /* TODO @misolori: figure out a way to not use negative margin for alignment */
 }
+
 .monaco-editor .inline-breakpoint-widget {
 	cursor: pointer;
 }
+
 .monaco-workbench .debug-view-content .monaco-list-row .monaco-tl-contents {
 	overflow: hidden;
 	text-overflow: ellipsis;
 }
+
+/* Expressions */
+
+
 .monaco-workbench .monaco-list-row .expression {
 	display: flex;
 }
+
 .monaco-workbench .debug-pane .monaco-list-row .expression,
 .monaco-workbench .debug-hover-widget .monaco-list-row .expression {
 	font-size: 13px;
@@ -71,41 +95,55 @@
 	font-family: var(--monaco-monospace-font);
 	white-space: pre;
 }
+
 .monaco-workbench.mac .debug-pane .monaco-list-row .expression,
 .monaco-workbench.mac .debug-hover-widget .monaco-list-row .expression {
 	font-size: 11px;
 }
+
 .monaco-workbench .monaco-list-row .expression .value {
 	margin-left: 6px;
 }
+
 .monaco-workbench .monaco-list-row .expression .lazy-button {
 	margin-left: 3px;
 	display: none;
 	border-radius: 5px;
 	align-self: center;
 }
+
 .monaco-workbench .monaco-list-row .expression.lazy .lazy-button {
 	display: inline;
 }
+
+/* Links */
+
 .monaco-workbench .monaco-list-row .expression .value a.link:hover {
 	text-decoration: underline;
 }
+
 .monaco-workbench .monaco-list-row .expression .value a.link.pointer {
 	cursor: pointer;
 }
+
+/* White color when element is selected and list is focused. White looks better on blue selection background. */
 .monaco-workbench .monaco-list:focus .monaco-list-row.selected .expression .name,
 .monaco-workbench .monaco-list:focus .monaco-list-row.selected .expression .value {
 	color: inherit;
 }
+
 .monaco-workbench .monaco-list-row .expression .name.virtual {
 	opacity: 0.5;
 }
+
 .monaco-workbench .monaco-list-row .expression .name.internal {
 	opacity: 0.5;
 }
+
 .monaco-workbench .monaco-list-row .expression .unavailable {
 	font-style: italic;
 }
+
 .monaco-workbench .debug-inline-value {
 	background-color: var(--vscode-editor-inlineValuesBackground);
 	color: var(--vscode-editor-inlineValuesForeground);

package/vscode/src/vs/workbench/contrib/debug/browser/media/debugHover.css

@@ -1,3 +1,8 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-editor .debug-hover-widget {
 	position: absolute;
 	z-index: 50;
@@ -8,9 +13,11 @@
 	word-break: break-all;
 	white-space: pre;
 }
+
 .monaco-editor .debug-hover-widget .complex-value {
 	max-width: 550px;
 }
+
 .monaco-editor .debug-hover-widget .complex-value .title,
 .monaco-editor .debug-hover-widget .complex-value .tip {
 	padding-left: 15px;
@@ -23,32 +30,41 @@
 	overflow: hidden;
 	white-space: pre;
 }
+
 .monaco-editor .debug-hover-widget .complex-value .title {
 	border-bottom: 1px solid rgba(128, 128, 128, 0.35);
 }
+
 .monaco-editor .debug-hover-widget .complex-value .tip {
 	border-top: 1px solid rgba(128, 128, 128, 0.35);
 	opacity: 0.5;
 }
+
 .monaco-editor .debug-hover-widget .debug-hover-tree {
 	line-height: 18px;
 	cursor: pointer;
 }
+
 .monaco-editor .debug-hover-widget .debug-hover-tree .monaco-list-row .monaco-tl-contents {
 	user-select: text;
 	-webkit-user-select: text;
 	white-space: pre;
 }
+
+/* Disable tree highlight in debug hover tree. */
 .monaco-editor .debug-hover-widget .debug-hover-tree .monaco-list-rows .monaco-list-row:hover:not(.highlighted):not(.selected):not(.focused)  {
 	background-color: inherit;
 }
+
 .monaco-editor .debug-hover-widget pre {
 	margin-top: 0;
 	margin-bottom: 0;
 }
+
 .monaco-editor .debugHoverHighlight {
 	background-color: rgba(173, 214, 255, 0.15);
 }
+
 .monaco-editor .debug-hover-widget > .monaco-scrollable-element > .value {
 	color: rgba(108, 108, 108, 0.8);
 	overflow: auto;
@@ -57,6 +73,7 @@
 	padding: 4px 5px;
 	white-space: pre-wrap;
 }
+
 .monaco-editor.vs-dark .debugHoverHighlight,
 .monaco-editor.hc-theme .debugHoverHighlight {
 	background-color: rgba(38, 79, 120, 0.25);

package/vscode/src/vs/workbench/contrib/debug/browser/media/debugToolBar.css

@@ -1,6 +1,11 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-workbench .debug-toolbar {
 	position: absolute;
-	z-index: 2520;
+	z-index: 2520; /* Below quick input at 2550, above custom titlebar toolbar at 2500 */
 	height: 26px;
 	display: flex;
 	padding-left: 7px;
@@ -9,16 +14,20 @@
 	top: 0;
 	-webkit-app-region: no-drag;
 }
+
 .monaco-workbench .debug-toolbar .monaco-action-bar .action-item {
 	margin-right: 4px;
 }
+
 .monaco-workbench .debug-toolbar .monaco-action-bar .action-item.select-container {
 	margin-right: 7px;
 }
+
 .monaco-workbench .debug-toolbar .monaco-action-bar .action-item.select-container .monaco-select-box,
 .monaco-workbench .start-debug-action-item .select-container .monaco-select-box {
 	padding: 0 22px 0 6px;
 }
+
 .monaco-workbench .debug-toolbar .drag-area {
 	cursor: grab;
 	width: 16px;
@@ -27,9 +36,11 @@
 	align-items: center;
 	justify-content: center;
 }
+
 .monaco-workbench .debug-toolbar .drag-area.dragged {
 	cursor: grabbing;
 }
+
 .monaco-workbench  .debug-toolbar .monaco-action-bar .action-item .action-label {
 	margin-right: 0;
 	background-size: 16px;

package/vscode/src/vs/workbench/contrib/debug/browser/media/debugViewlet.css

@@ -1,9 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* Debug viewlet */
+
 .debug-pane {
 	height: 100%;
 }
+
 .debug-view-content {
 	height: 100%;
 }
+
 .monaco-workbench .debug-action.notification:after {
 	content: '';
 	width: 6px;
@@ -15,24 +24,29 @@
 	border-radius: 10px;
 	border: 1px solid white;
 }
+
 .monaco-workbench .part > .title > .title-actions .start-debug-action-item {
 	display: flex;
 	align-items: center;
 	line-height: 20px;
 	flex-shrink: 1;
 }
+
 .monaco-workbench.mac .part > .title > .title-actions .start-debug-action-item {
 	border-radius: 4px;
 }
+
 .monaco-workbench .part > .title > .title-actions .start-debug-action-item .codicon {
 	line-height: inherit;
 	flex-shrink: 0;
 }
+
 .monaco-workbench .part > .title > .title-actions .start-debug-action-item .codicon-debug-start {
 	width: 18px;
 	height: 21px;
 	padding-left: 2px;
 }
+
 .monaco-workbench .monaco-action-bar .start-debug-action-item .configuration .monaco-select-box {
 	border: none;
 	margin-top: 0px;
@@ -40,29 +54,42 @@
 	line-height: inherit;
 	padding-top: 0;
 	padding-bottom: 0;
+
+	/* The debug view title is crowded, let this one get narrower than others */
 	min-width: 90px;
 }
+
+
 .monaco-workbench.safari .monaco-action-bar .start-debug-action-item .configuration .monaco-select-box {
 	margin-bottom: 0px;
 }
+
 .monaco-workbench .monaco-action-bar .start-debug-action-item .configuration.disabled .monaco-select-box {
 	opacity: 0.7;
 	font-style: italic;
 	cursor: initial;
 }
+
+/* Debug viewlet trees */
+
 .debug-pane .line-number {
 	padding-left: 4px;
 	padding-right: 4px;
 }
+
 .debug-pane .disabled {
 	opacity: 0.65;
 	cursor: initial;
 }
+
 .debug-pane .monaco-list:focus .monaco-list-row.selected .state.label,
 .debug-pane .monaco-list:focus .monaco-list-row.selected .load-all,
 .debug-pane .monaco-list:focus .monaco-list-row.selected.focused .state.label {
 	color: inherit;
 }
+
+/* Call stack */
+
 .debug-pane .call-stack-state-message {
 	flex: 1;
 	text-align: right;
@@ -71,22 +98,26 @@
 	white-space: nowrap;
 	margin: 0px 10px;
 }
+
 .debug-pane .call-stack-state-message > .label {
 	border-radius: 3px;
 	padding: 1px 2px;
 	font-size: 9px;
 }
+
 .debug-pane .debug-call-stack .thread,
 .debug-pane .debug-call-stack .session {
 	display: flex;
 	align-items: center;
 }
+
 .debug-pane .debug-call-stack .thread > .name,
 .debug-pane .debug-call-stack .session > .name {
 	flex: 1;
 	overflow: hidden;
 	text-overflow: ellipsis;
 }
+
 .debug-pane .debug-call-stack .thread > .state.label,
 .debug-pane .debug-call-stack .session > .state.label {
 	overflow: hidden;
@@ -96,115 +127,146 @@
 	align-self: center;
 	font-size: 0.8em;
 }
+
 .debug-pane .debug-call-stack .monaco-list-row:hover .state.label {
 	display: none;
 }
+
 .debug-pane .debug-call-stack .monaco-list-row:hover .stack-frame.has-actions .file .line-number {
 	display: none;
 }
+
 .debug-pane .monaco-list-row .monaco-action-bar {
 	display: none;
 	flex-shrink: 0;
 	margin-right: 6px;
 }
+
 .debug-pane .monaco-list-row:hover .monaco-action-bar,
 .debug-pane .monaco-list-row.focused .monaco-action-bar {
 	display: initial;
 }
+
 .debug-pane .monaco-list-row .monaco-action-bar .action-label {
 	padding: 2px;
 }
+
 .debug-pane .session .codicon {
 	line-height: 22px;
 	margin-right: 2px;
 }
+
 .debug-pane .debug-call-stack .stack-frame {
 	overflow: hidden;
 	text-overflow: ellipsis;
 	padding-right: 0.8em;
 	display: flex;
 }
+
 .debug-pane .debug-call-stack .stack-frame.label {
 	text-align: center;
 	font-style: italic;
 }
+
 .debug-pane .debug-call-stack .stack-frame .label {
 	flex: 1;
 	flex-shrink: 0;
 	min-width: fit-content;
 }
+
 .debug-pane .debug-call-stack .stack-frame.label > .file {
 	display: none;
 }
+
 .debug-pane .debug-call-stack .stack-frame > .file {
 	display: flex;
 	overflow: hidden;
 	flex-wrap: wrap;
 	justify-content: flex-end;
 }
+
 .debug-pane .debug-call-stack .stack-frame > .file > .line-number.unavailable {
 	display: none;
 }
+
 .debug-pane .debug-call-stack .stack-frame > .file > .file-name {
 	overflow: hidden;
 	text-overflow: ellipsis;
 	margin-right: 0.8em;
 }
+
 .debug-pane .debug-call-stack .stack-frame > .file:not(:first-child) {
 	margin-left: 0.8em;
 }
+
 .debug-pane .debug-call-stack .load-all {
 	text-align: center;
 }
+
 .debug-pane .debug-call-stack .show-more {
 	opacity: 0.5;
 	text-align: center;
 }
+
 .debug-pane .debug-call-stack .error {
 	font-style: italic;
 	text-overflow: ellipsis;
 	overflow: hidden;
 }
+
+/* Variables & Expression view */
+
 .debug-pane .scope {
 	font-weight: bold;
 	font-size: 11px;
 }
+
 .debug-pane .monaco-list-row .expression .actionbar-spacer {
 	flex-grow: 1;
 }
+
 .debug-pane .monaco-list-row .expression .value {
 	height: 22px;
 	overflow: hidden;
 	white-space: pre;
 	text-overflow: ellipsis;
 }
+
 .debug-pane .monaco-list-row .expression .value.changed {
 	border-radius: 4px;
 }
+
 .debug-pane .monaco-inputbox {
 	width: 100%;
 	line-height: normal;
 }
+
 .debug-pane .inputBoxContainer {
 	box-sizing: border-box;
 	flex-grow: 1;
 }
+
 .debug-pane .debug-watch .monaco-inputbox {
 	font-family: var(--monaco-monospace-font);
 }
+
 .debug-pane .monaco-inputbox > .ibwrapper {
 	height: 19px;
 }
+
 .debug-pane .monaco-inputbox > .ibwrapper > .input {
 	padding: 0px;
 	color: initial;
 }
+
 .debug-pane .watch-expression {
 	display: flex;
 }
+
 .debug-pane .watch-expression .expression {
 	flex : 1;
 }
+
 .debug-pane .debug-variables .scope .error {
 	font-style: italic;
 	text-overflow: ellipsis;
@@ -218,24 +280,32 @@
 	outline: 1px dotted var(--vscode-list-filterMatchBorder);
 	outline-offset: -1px;
 }
+
+/* Breakpoints */
+
 .debug-pane .monaco-list-row {
 	line-height: 22px;
 }
+
 .debug-pane .debug-breakpoints .monaco-list-row .breakpoint {
 	padding-left: 2px;
 }
+
 .debug-pane .debug-breakpoints .breakpoint.exception {
 	padding-left: 21px;
 }
+
 .debug-pane .debug-breakpoints .breakpoint {
 	display: flex;
 	padding-right: 0.8em;
 	flex: 1;
 	align-items: center;
 }
+
 .debug-pane .debug-breakpoints .breakpoint input {
 	flex-shrink: 0;
 }
+
 .debug-pane .debug-breakpoints .breakpoint > .codicon {
 	width: 19px;
 	height: 19px;
@@ -244,6 +314,7 @@
 	align-items: center;
 	justify-content: center;
 }
+
 .debug-pane .debug-breakpoints .breakpoint > .access-type {
 	opacity: 0.7;
 	margin-left: 0.9em;
@@ -258,13 +329,16 @@
 	text-overflow: ellipsis;
 	overflow: hidden;
 }
+
 .debug-pane .debug-breakpoints .breakpoint .name {
 	overflow: hidden;
 	text-overflow: ellipsis
 }
+
 .debug-pane .pane-header .breakpoint-warning {
 	margin-left: 3px;
 }
+
 .debug-pane .pane-header .breakpoint-warning .monaco-icon-label .codicon {
 	display: flex;
 	align-items: center;

package/vscode/src/vs/workbench/contrib/debug/browser/media/repl.css

@@ -1,53 +1,76 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* Debug repl */
+
 .monaco-workbench .repl {
 	height: 100%;
 	box-sizing: border-box;
 	overflow: hidden;
 }
+
 .monaco-workbench .repl .repl-tree .monaco-tl-contents {
 	user-select: text;
 	-webkit-user-select: text;
 	white-space: pre;
 }
+
 .monaco-workbench .repl .repl-tree .monaco-tl-contents .expression {
 	font-family: var(--vscode-repl-font-family);
 	font-size: var(--vscode-repl-font-size);
 	line-height: var(--vscode-repl-line-height);
 }
+
 .monaco-workbench .repl .repl-tree .monaco-tl-contents .expression .lazy-button {
 	cursor: pointer;
 }
+
 .monaco-workbench .repl .repl-tree .monaco-tl-twistie {
 	background-position-y: calc(100% - (var(--vscode-repl-font-size-for-twistie)));
 }
+
 .monaco-workbench .repl .repl-tree.word-wrap .monaco-tl-contents {
+	/* Wrap words but also do not trim whitespace #6275 */
 	word-wrap: break-word;
 	white-space: pre-wrap;
+	/* Break on all #7533 */
 	word-break: break-all;
 }
+
 .monaco-workbench .repl .repl-tree.word-wrap .monaco-tl-contents .expression.nested-variable {
-	white-space: pre;
+	white-space: pre; /* Preserve whitespace but don't wrap */
 }
+
 .monaco-workbench .repl .repl-tree .monaco-tl-twistie.collapsible + .monaco-tl-contents,
 .monaco-workbench .repl .repl-tree .monaco-tl-twistie {
 	cursor: pointer;
 }
+
 .monaco-workbench .repl .repl-tree .output.expression.value-and-source {
 	display: flex;
 }
+
 .monaco-workbench .repl .repl-tree .output.expression.value-and-source .label {
 	margin-right: 4px;
 }
+
 .monaco-workbench .repl .repl-tree .output.expression.value-and-source .count-badge-wrapper {
 	margin-right: 4px;
 }
+
 .monaco-workbench .repl .repl-tree .output.expression.value-and-source .count-badge-wrapper .monaco-count-badge {
+	/* Allow the badge to be a bit shorter so it does not look cut off */
 	min-height: 16px;
 	word-break: keep-all;
 }
+
 .monaco-workbench .repl .repl-tree .monaco-tl-contents .arrow {
 	position:absolute;
 	left: 2px;
 }
+
 .monaco-workbench .repl .repl-tree .output.expression.value-and-source .source,
 .monaco-workbench .repl .repl-tree .group .source {
 	margin-left: auto;
@@ -58,23 +81,30 @@
 	text-overflow: ellipsis;
 	white-space: nowrap;
 	text-align: right;
+	/*Use direction so the source shows elipses on the left*/
 	direction: rtl;
 	max-width: 400px;
 }
+
 .monaco-workbench .repl .repl-tree .output.expression > .value,
 .monaco-workbench .repl .repl-tree .evaluation-result.expression > .value {
 	margin-left: 0px;
 }
+
 .monaco-workbench .repl .repl-tree .output.expression .name:not(:empty) {
 	margin-right: 6px;
 }
+
 .monaco-workbench .repl .repl-input-wrapper {
 	display: flex;
 	align-items: center;
 }
+
+/* Do not render show more in REPL suggest widget status bar */
 .monaco-workbench .repl .repl-input-wrapper .suggest-status-bar .monaco-action-bar.right {
 	display: none;
 }
+
 .monaco-workbench .repl .repl-input-wrapper .repl-input-chevron {
 	padding: 0 6px 0 8px;
 	width: 16px;
@@ -84,15 +114,20 @@
 	justify-content: center;
 	font-weight: 600;
 }
+
+/* Output coloring  and styling */
 .monaco-workbench .repl .repl-tree .output.expression > .ignore {
 	font-style: italic;
 }
+
+/* ANSI Codes */
 .monaco-workbench .repl .repl-tree .output.expression .code-bold	{ font-weight: bold; }
 .monaco-workbench .repl .repl-tree .output.expression .code-italic	{ font-style: italic; }
 .monaco-workbench .repl .repl-tree .output.expression .code-underline { text-decoration: underline;  text-decoration-style:solid; }
 .monaco-workbench .repl .repl-tree .output.expression .code-double-underline { text-decoration: underline;  text-decoration-style:double; }
 .monaco-workbench .repl .repl-tree .output.expression .code-strike-through { text-decoration:line-through;  text-decoration-style:solid; }
 .monaco-workbench .repl .repl-tree .output.expression .code-overline { text-decoration:overline;  text-decoration-style:solid; }
+/* because they can exist at same time we need all the possible underline(or double-underline),overline and strike-through combinations */
 .monaco-workbench .repl .repl-tree .output.expression .code-overline.code-underline.code-strike-through { text-decoration: overline underline line-through; text-decoration-style:solid; }
 .monaco-workbench .repl .repl-tree .output.expression .code-overline.code-underline { text-decoration: overline underline; text-decoration-style:solid; }
 .monaco-workbench .repl .repl-tree .output.expression .code-overline.code-strike-through { text-decoration: overline line-through; text-decoration-style:solid; }

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

@@ -6,6 +6,9 @@ import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
 import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+/**
+ * Encapsulates the DebugAdapter lifecycle and some idiosyncrasies of the Debug Adapter Protocol.
+ */
 export declare class RawDebugSession implements IDisposable {
     readonly dbgr: IDebugger;
     private readonly sessionId;
@@ -47,6 +50,10 @@ export declare class RawDebugSession implements IDisposable {
     get isInShutdown(): boolean;
     get onDidExitAdapter(): Event<AdapterEndEvent>;
     get capabilities(): DebugProtocol.Capabilities;
+    /**
+     * DA is ready to accepts setBreakpoint requests.
+     * Becomes true after "initialized" events has been received.
+     */
     get readyForBreakpoints(): boolean;
     get onDidInitialize(): Event<DebugProtocol.InitializedEvent>;
     get onDidStop(): Event<DebugProtocol.StoppedEvent>;
@@ -64,10 +71,22 @@ export declare class RawDebugSession implements IDisposable {
     get onDidInvalidated(): Event<DebugProtocol.InvalidatedEvent>;
     get onDidInvalidateMemory(): Event<DebugProtocol.MemoryEvent>;
     get onDidEvent(): Event<DebugProtocol.Event>;
+    /**
+     * Starts the underlying debug adapter and tracks the session time for telemetry.
+     */
     start(): Promise<void>;
+    /**
+     * Send client capabilities to the debug adapter and receive DA capabilities in return.
+     */
     initialize(args: DebugProtocol.InitializeRequestArguments): Promise<DebugProtocol.InitializeResponse | undefined>;
+    /**
+     * Terminate the debuggee and shutdown the adapter
+     */
     disconnect(args: DebugProtocol.DisconnectArguments): Promise<any>;
     launchOrAttach(config: IConfig): Promise<DebugProtocol.Response | undefined>;
+    /**
+     * Try killing the debuggee softly...
+     */
     terminate(restart?: boolean): Promise<DebugProtocol.TerminateResponse | undefined>;
     restart(args: DebugProtocol.RestartArguments): Promise<DebugProtocol.RestartResponse | undefined>;
     next(args: DebugProtocol.NextArguments): Promise<DebugProtocol.NextResponse | undefined>;

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

@@ -107,6 +107,9 @@ export declare class ReplDelegate extends CachedListVirtualDelegate<IReplElement
     private readonly replOptions;
     constructor(configurationService: IConfigurationService, replOptions: IReplOptions);
     getHeight(element: IReplElement): number;
+    /**
+     * With wordWrap enabled, this is an estimate. With wordWrap disabled, this is the real height that the list will use.
+     */
     protected estimateHeight(element: IReplElement, ignoreValueLength?: boolean): number;
     getTemplateId(element: IReplElement): string;
     hasDynamicHeight(element: IReplElement): boolean;

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

@@ -8,6 +8,19 @@ import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/w
 import { IDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug.service";
 import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+/**
+ * Debug URI format
+ *
+ * a debug URI represents a Source object and the debug session where the Source comes from.
+ *
+ *       debug:arbitrary_path?session=123e4567-e89b-12d3-a456-426655440000&ref=1016
+ *       \___/ \____________/ \__________________________________________/ \______/
+ *         |          |                             |                          |
+ *      scheme   source.path                    session id            source.reference
+ *
+ * the arbitrary_path and the session id are encoded with 'encodeURIComponent'
+ *
+ */
 export declare class DebugContentProvider extends Disposable implements IWorkbenchContribution, ITextModelContentProvider {
     private readonly debugService;
     private readonly modelService;
@@ -18,6 +31,13 @@ export declare class DebugContentProvider extends Disposable implements IWorkben
     constructor(textModelResolverService: ITextModelService, debugService: IDebugService, modelService: IModelService, languageService: ILanguageService, editorWorkerService: IEditorWorkerService);
     dispose(): void;
     provideTextContent(resource: uri): Promise<ITextModel> | null;
+    /**
+     * Reload the model content of the given resource.
+     * If there is no model for the given resource, this method does nothing.
+     */
     static refreshDebugContent(resource: uri): void;
+    /**
+     * Create or reload the model content of the given resource.
+     */
     private createOrUpdateContentModel;
 }

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

@@ -44,11 +44,17 @@ export declare class DebugVisualizerService implements IDebugVisualizerService {
     private readonly didActivate;
     private registrations;
     constructor(contextKeyService: IContextKeyService, extensionService: IExtensionService, logService: ILogService);
+    /** @inheritdoc */
     getApplicableFor(variable: IExpression, token: CancellationToken): Promise<IReference<DebugVisualizer[]>>;
+    /** @inheritdoc */
     register(handle: VisualizerHandle): IDisposable;
+    /** @inheritdoc */
     registerTree(treeId: string, handle: VisualizerTreeHandle): IDisposable;
+    /** @inheritdoc */
     getVisualizedNodeFor(treeId: string, expr: IExpression): Promise<VisualizedExpression | undefined>;
+    /** @inheritdoc */
     getVisualizedChildren(session: IDebugSession | undefined, treeId: string, treeElementId: number): Promise<IExpression[]>;
+    /** @inheritdoc */
     editTreeItem(treeId: string, treeItem: IDebugVisualizationTreeItem, newValue: string): Promise<void>;
     private getVariableContext;
     private processExtensionRegistration;