@codingame/monaco-vscode-debug-service-override 25.1.1 → 26.0.0

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

@@ -58,19 +58,34 @@ const disassemblyNotAvailable = {
     allowBreakpoint: false,
     isBreakpointSet: false,
     isBreakpointEnabled: false,
-    instructionReference: '',
+    instructionReference: "",
     instructionOffset: 0,
     instructionReferenceOffset: 0,
     address: 0n,
     instruction: {
-        address: '-1',
-        instruction: ( localize(6933, "Disassembly not available."))
-    },
+        address: "-1",
+        instruction: ( localize(7244, "Disassembly not available."))
+    }
 };
 let DisassemblyView = class DisassemblyView extends EditorPane {
-    static { DisassemblyView_1 = this; }
-    static { this.NUM_INSTRUCTIONS_TO_LOAD = 50; }
-    constructor(group, telemetryService, themeService, storageService, _configurationService, _instantiationService, _debugService, _contextMenuService, menuService, contextKeyService) {
+    static {
+        DisassemblyView_1 = this;
+    }
+    static {
+        this.NUM_INSTRUCTIONS_TO_LOAD = 50;
+    }
+    constructor(
+        group,
+        telemetryService,
+        themeService,
+        storageService,
+        _configurationService,
+        _instantiationService,
+        _debugService,
+        _contextMenuService,
+        menuService,
+        contextKeyService
+    ) {
         super(DISASSEMBLY_VIEW_ID, group, telemetryService, themeService, storageService);
         this._configurationService = _configurationService;
         this._instantiationService = _instantiationService;
@@ -83,15 +98,16 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         this.menu = menuService.createMenu(MenuId.DebugDisassemblyContext, contextKeyService);
         this._register(this.menu);
         this._disassembledInstructions = undefined;
-        this._onDidChangeStackFrame = this._register(( new Emitter({ leakWarningThreshold: 1000 })));
+        this._onDidChangeStackFrame = this._register(( new Emitter({
+            leakWarningThreshold: 1000
+        })));
         this._previousDebuggingState = _debugService.state;
         this._register(_configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('debug')) {
-                const newValue = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
+            if (e.affectsConfiguration("debug")) {
+                const newValue = this._configurationService.getValue("debug").disassemblyView.showSourceCode;
                 if (this._enableSourceCodeRender !== newValue) {
                     this._enableSourceCodeRender = newValue;
-                }
-                else {
+                } else {
                     this._disassembledInstructions?.rerender();
                 }
             }
@@ -101,7 +117,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         if (!this._fontInfo) {
             this._fontInfo = this.createFontInfo();
             this._register(this._configurationService.onDidChangeConfiguration(e => {
-                if (e.affectsConfiguration('editor')) {
+                if (e.affectsConfiguration("editor")) {
                     this._fontInfo = this.createFontInfo();
                 }
             }));
@@ -109,15 +125,13 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         return this._fontInfo;
     }
     createFontInfo() {
-        return createBareFontInfoFromRawSettings(this._configurationService.getValue('editor'), PixelRatio.getInstance(this.window).value);
+        return createBareFontInfoFromRawSettings(
+            this._configurationService.getValue("editor"),
+            PixelRatio.getInstance(this.window).value
+        );
     }
     get currentInstructionAddresses() {
-        return ( ( ( ( this._debugService.getModel().getSessions(false).
-            map(session => session.getAllThreads())).
-            reduce((prev, curr) => prev.concat(curr), []).
-            map(thread => thread.getTopStackFrame())).
-            map(frame => frame?.instructionPointerReference)).
-            map(ref => ref ? this.getReferenceAddress(ref) : undefined));
+        return ( ( ( ( this._debugService.getModel().getSessions(false).map(session => session.getAllThreads())).reduce((prev, curr) => prev.concat(curr), []).map(thread => thread.getTopStackFrame())).map(frame => frame?.instructionPointerReference)).map(ref => ref ? this.getReferenceAddress(ref) : undefined));
     }
     get focusedCurrentInstructionReference() {
         return this._debugService.getViewModel().focusedStackFrame?.thread.getTopStackFrame()?.instructionPointerReference;
@@ -133,11 +147,15 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         const ref = this.focusedInstructionReference;
         return ref ? this.getReferenceAddress(ref) : undefined;
     }
-    get isSourceCodeRender() { return this._enableSourceCodeRender; }
+    get isSourceCodeRender() {
+        return this._enableSourceCodeRender;
+    }
     get debugSession() {
         return this._debugService.getViewModel().focusedSession;
     }
-    get onDidChangeStackFrame() { return this._onDidChangeStackFrame.event; }
+    get onDidChangeStackFrame() {
+        return this._onDidChangeStackFrame.event;
+    }
     get focusedAddressAndOffset() {
         const element = this._disassembledInstructions?.getFocusedElements()[0];
         if (!element) {
@@ -148,10 +166,14 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
     getAddressAndOffset(element) {
         const reference = element.instructionReference;
         const offset = Number(element.address - this.getReferenceAddress(reference));
-        return { reference, offset, address: element.address };
+        return {
+            reference,
+            offset,
+            address: element.address
+        };
     }
     createEditor(parent) {
-        this._enableSourceCodeRender = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
+        this._enableSourceCodeRender = this._configurationService.getValue("debug").disassemblyView.showSourceCode;
         const lineHeight = this.fontInfo.lineHeight;
         const thisOM = this;
         const delegate = new (class {
@@ -162,48 +184,52 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 if (thisOM.isSourceCodeRender && row.showSourceLocation && row.instruction.location?.path && row.instruction.line) {
                     if (row.instruction.endLine) {
                         return lineHeight * Math.max(2, (row.instruction.endLine - row.instruction.line + 2));
-                    }
-                    else {
+                    } else {
                         return lineHeight * 2;
                     }
                 }
                 return lineHeight;
             }
-        });
+        })();
         const instructionRenderer = this._register(this._instantiationService.createInstance(InstructionRenderer, this));
-        this._disassembledInstructions = this._register(this._instantiationService.createInstance(WorkbenchTable, 'DisassemblyView', parent, delegate, [
-            {
-                label: '',
-                tooltip: '',
+        this._disassembledInstructions = this._register(
+            this._instantiationService.createInstance(WorkbenchTable, "DisassemblyView", parent, delegate, [{
+                label: "",
+                tooltip: "",
                 weight: 0,
                 minimumWidth: this.fontInfo.lineHeight,
                 maximumWidth: this.fontInfo.lineHeight,
                 templateId: BreakpointRenderer.TEMPLATE_ID,
-                project(row) { return row; }
-            },
-            {
-                label: ( localize(6934, "instructions")),
-                tooltip: '',
+                project(row) {
+                    return row;
+                }
+            }, {
+                label: ( localize(7245, "instructions")),
+                tooltip: "",
                 weight: 0.3,
                 templateId: InstructionRenderer.TEMPLATE_ID,
-                project(row) { return row; }
-            },
-        ], [
-            this._instantiationService.createInstance(BreakpointRenderer, this),
-            instructionRenderer,
-        ], {
-            identityProvider: { getId: (e) => e.instruction.address },
-            horizontalScrolling: false,
-            overrideStyles: {
-                listBackground: editorBackground
-            },
-            multipleSelectionSupport: false,
-            setRowLineHeight: false,
-            openOnSingleClick: false,
-            accessibilityProvider: ( new AccessibilityProvider()),
-            mouseSupport: false
-        }));
-        this._disassembledInstructions.domNode.classList.add('disassembly-view');
+                project(row) {
+                    return row;
+                }
+            }], [
+                this._instantiationService.createInstance(BreakpointRenderer, this),
+                instructionRenderer
+            ], {
+                identityProvider: {
+                    getId: e => e.instruction.address
+                },
+                horizontalScrolling: false,
+                overrideStyles: {
+                    listBackground: editorBackground
+                },
+                multipleSelectionSupport: false,
+                setRowLineHeight: false,
+                openOnSingleClick: false,
+                accessibilityProvider: ( new AccessibilityProvider()),
+                mouseSupport: false
+            })
+        );
+        this._disassembledInstructions.domNode.classList.add("disassembly-view");
         if (this.focusedInstructionReference) {
             this.reloadDisassembly(this.focusedInstructionReference, 0);
         }
@@ -217,19 +243,26 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
             if (e.oldScrollTop > e.scrollTop && e.scrollTop < e.height) {
                 this._loadingLock = true;
                 const prevTop = Math.floor(e.scrollTop / this.fontInfo.lineHeight);
-                this.scrollUp_LoadDisassembledInstructions(DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD).then((loaded) => {
+                this.scrollUp_LoadDisassembledInstructions(DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD).then(loaded => {
                     if (loaded > 0) {
                         this._disassembledInstructions.reveal(prevTop + loaded, 0);
                     }
-                }).finally(() => { this._loadingLock = false; });
-            }
-            else if (e.oldScrollTop < e.scrollTop && e.scrollTop + e.height > e.scrollHeight - e.height) {
+                }).finally(() => {
+                    this._loadingLock = false;
+                });
+            } else if (e.oldScrollTop < e.scrollTop && e.scrollTop + e.height > e.scrollHeight - e.height) {
                 this._loadingLock = true;
-                this.scrollDown_LoadDisassembledInstructions(DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD).finally(() => { this._loadingLock = false; });
+                this.scrollDown_LoadDisassembledInstructions(DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD).finally(() => {
+                    this._loadingLock = false;
+                });
             }
         }));
         this._register(this._disassembledInstructions.onContextMenu(e => this.onContextMenu(e)));
-        this._register(this._debugService.getViewModel().onDidFocusStackFrame(({ stackFrame }) => {
+        this._register(this._debugService.getViewModel().onDidFocusStackFrame((
+            {
+                stackFrame
+            }
+        ) => {
             if (this._disassembledInstructions && stackFrame?.instructionPointerReference) {
                 this.goToInstructionAndOffset(stackFrame.instructionPointerReference, 0);
             }
@@ -238,7 +271,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         this._register(this._debugService.getModel().onDidChangeBreakpoints(bpEvent => {
             if (bpEvent && this._disassembledInstructions) {
                 let changed = false;
-                bpEvent.added?.forEach((bp) => {
+                bpEvent.added?.forEach(bp => {
                     if (bp instanceof InstructionBreakpoint) {
                         const index = this.getIndexFromReferenceAndOffset(bp.instructionReference, bp.offset);
                         if (index >= 0) {
@@ -248,7 +281,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                         }
                     }
                 });
-                bpEvent.removed?.forEach((bp) => {
+                bpEvent.removed?.forEach(bp => {
                     if (bp instanceof InstructionBreakpoint) {
                         const index = this.getIndexFromReferenceAndOffset(bp.instructionReference, bp.offset);
                         if (index >= 0) {
@@ -257,7 +290,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                         }
                     }
                 });
-                bpEvent.changed?.forEach((bp) => {
+                bpEvent.changed?.forEach(bp => {
                     if (bp instanceof InstructionBreakpoint) {
                         const index = this.getIndexFromReferenceAndOffset(bp.instructionReference, bp.offset);
                         if (index >= 0) {
@@ -278,10 +311,9 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
             }
         }));
         this._register(this._debugService.onDidChangeState(e => {
-            if ((e === State.Running || e === State.Stopped) &&
-                (this._previousDebuggingState !== State.Running && this._previousDebuggingState !== State.Stopped)) {
+            if ((e === State.Running || e === State.Stopped) && (this._previousDebuggingState !== State.Running && this._previousDebuggingState !== State.Stopped)) {
                 this.clear();
-                this._enableSourceCodeRender = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
+                this._enableSourceCodeRender = this._configurationService.getValue("debug").disassemblyView.showSourceCode;
             }
             this._previousDebuggingState = e;
             this._onDidChangeStackFrame.fire();
@@ -293,7 +325,12 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
     async goToInstructionAndOffset(instructionReference, offset, focus) {
         let addr = this._referenceToMemoryAddress.get(instructionReference);
         if (addr === undefined) {
-            await this.loadDisassembledInstructions(instructionReference, 0, -DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD, DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 2);
+            await this.loadDisassembledInstructions(
+                instructionReference,
+                0,
+                -DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD,
+                DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 2
+            );
             addr = this._referenceToMemoryAddress.get(instructionReference);
         }
         if (addr) {
@@ -324,14 +361,24 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
     async scrollUp_LoadDisassembledInstructions(instructionCount) {
         const first = this._disassembledInstructions?.row(0);
         if (first) {
-            return this.loadDisassembledInstructions(first.instructionReference, first.instructionReferenceOffset, first.instructionOffset - instructionCount, instructionCount);
+            return this.loadDisassembledInstructions(
+                first.instructionReference,
+                first.instructionReferenceOffset,
+                first.instructionOffset - instructionCount,
+                instructionCount
+            );
         }
         return 0;
     }
     async scrollDown_LoadDisassembledInstructions(instructionCount) {
         const last = this._disassembledInstructions?.row(this._disassembledInstructions?.length - 1);
         if (last) {
-            return this.loadDisassembledInstructions(last.instructionReference, last.instructionReferenceOffset, last.instructionOffset + 1, instructionCount);
+            return this.loadDisassembledInstructions(
+                last.instructionReference,
+                last.instructionReferenceOffset,
+                last.instructionOffset + 1,
+                instructionCount
+            );
         }
         return 0;
     }
@@ -344,8 +391,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
             try {
                 this._referenceToMemoryAddress.set(instructionReference, BigInt(s[0].address));
                 return true;
-            }
-            catch {
+            } catch {
                 return false;
             }
         }
@@ -373,7 +419,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                         startLineNumber: instruction.line,
                         startColumn: instruction.column ?? 0,
                         endLineNumber: instruction.endLine ?? instruction.line,
-                        endColumn: instruction.endColumn ?? 0,
+                        endColumn: instruction.endColumn ?? 0
                     };
                     if (!Range.equalsRange(currentLine, lastLine ?? null)) {
                         lastLine = currentLine;
@@ -383,9 +429,10 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 let address;
                 try {
                     address = BigInt(instruction.address);
-                }
-                catch {
-                    console.error(`Could not parse disassembly address ${instruction.address} (in ${JSON.stringify(instruction)})`);
+                } catch {
+                    console.error(
+                        `Could not parse disassembly address ${instruction.address} (in ${JSON.stringify(instruction)})`
+                    );
                     continue;
                 }
                 if (address === -1n) {
@@ -399,7 +446,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                     instructionReferenceOffset: offset,
                     instructionOffset: thisInstructionOffset,
                     instruction,
-                    address,
+                    address
                 };
                 newEntries.push(entry);
                 if (offset === 0 && thisInstructionOffset === 0) {
@@ -417,7 +464,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 }
                 return {
                     enabled: p.enabled,
-                    address: base + BigInt(p.offset || 0),
+                    address: base + BigInt(p.offset || 0)
                 };
             }));
             if (refBaseAddress !== undefined) {
@@ -442,14 +489,15 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
             const toDelete = end - start;
             let lastLocated;
             for (let i = start - 1; i >= 0; i--) {
-                const { instruction } = da.row(i);
+                const {
+                    instruction
+                } = da.row(i);
                 if (instruction.location && instruction.line !== undefined) {
                     lastLocated = instruction;
                     break;
                 }
             }
-            const shouldShowLocation = (instruction) => instruction.line !== undefined && instruction.location !== undefined &&
-                (!lastLocated || !sourcesEqual(instruction.location, lastLocated.location) || instruction.line !== lastLocated.line);
+            const shouldShowLocation = instruction => instruction.line !== undefined && instruction.location !== undefined && (!lastLocated || !sourcesEqual(instruction.location, lastLocated.location) || instruction.line !== lastLocated.line);
             for (const entry of newEntries) {
                 if (shouldShowLocation(entry.instruction)) {
                     entry.showSourceLocation = true;
@@ -485,9 +533,25 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         this._loadingLock = true;
         this.clear();
         this._instructionBpList = this._debugService.getModel().getInstructionBreakpoints();
-        this.loadDisassembledInstructions(instructionReference, offset, -DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 4, DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 8).then(() => {
+        this.loadDisassembledInstructions(
+            instructionReference,
+            offset,
+            -DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 4,
+            DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 8
+        ).then(() => {
             if (this._disassembledInstructions.length > 0) {
-                const targetIndex = Math.floor(this._disassembledInstructions.length / 2);
+                let targetIndex = undefined;
+                const refBaseAddress = this._referenceToMemoryAddress.get(instructionReference);
+                if (refBaseAddress !== undefined) {
+                    const da = this._disassembledInstructions;
+                    targetIndex = binarySearch2(da.length, i => Number(da.row(i).address - refBaseAddress));
+                    if (targetIndex < 0) {
+                        targetIndex = ~targetIndex;
+                    }
+                }
+                if (targetIndex === undefined) {
+                    targetIndex = Math.floor(this._disassembledInstructions.length / 2);
+                }
                 this._disassembledInstructions.reveal(targetIndex, 0.5);
                 this._disassembledInstructions.domFocus();
                 this._disassembledInstructions.setFocus([targetIndex]);
@@ -500,7 +564,9 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         this._disassembledInstructions?.splice(0, this._disassembledInstructions.length, [disassemblyNotAvailable]);
     }
     onContextMenu(e) {
-        const actions = getFlatContextMenuActions(this.menu.getActions({ shouldForwardArgs: true }));
+        const actions = getFlatContextMenuActions(this.menu.getActions({
+            shouldForwardArgs: true
+        }));
         this._contextMenuService.showContextMenu({
             getAnchor: () => e.anchor,
             getActions: () => actions,
@@ -508,65 +574,71 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         });
     }
 };
-DisassemblyView = DisassemblyView_1 = ( __decorate([
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IThemeService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IDebugService)),
-    ( __param(7, IContextMenuService)),
-    ( __param(8, IMenuService)),
-    ( __param(9, IContextKeyService))
-], DisassemblyView));
+DisassemblyView = DisassemblyView_1 = ( __decorate([( __param(1, ITelemetryService)), ( __param(2, IThemeService)), ( __param(3, IStorageService)), ( __param(4, IConfigurationService)), ( __param(5, IInstantiationService)), ( __param(6, IDebugService)), ( __param(7, IContextMenuService)), ( __param(8, IMenuService)), ( __param(9, IContextKeyService))], DisassemblyView));
 let BreakpointRenderer = class BreakpointRenderer {
-    static { BreakpointRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'breakpoint'; }
+    static {
+        BreakpointRenderer_1 = this;
+    }
+    static {
+        this.TEMPLATE_ID = "breakpoint";
+    }
     constructor(_disassemblyView, _debugService) {
         this._disassemblyView = _disassemblyView;
         this._debugService = _debugService;
         this.templateId = BreakpointRenderer_1.TEMPLATE_ID;
-        this._breakpointIcon = 'codicon-' + breakpoint.regular.id;
-        this._breakpointDisabledIcon = 'codicon-' + breakpoint.disabled.id;
-        this._breakpointHintIcon = 'codicon-' + debugBreakpointHint.id;
-        this._debugStackframe = 'codicon-' + debugStackframe.id;
-        this._debugStackframeFocused = 'codicon-' + debugStackframeFocused.id;
+        this._breakpointIcon = "codicon-" + breakpoint.regular.id;
+        this._breakpointDisabledIcon = "codicon-" + breakpoint.disabled.id;
+        this._breakpointHintIcon = "codicon-" + debugBreakpointHint.id;
+        this._debugStackframe = "codicon-" + debugStackframe.id;
+        this._debugStackframeFocused = "codicon-" + debugStackframeFocused.id;
     }
     renderTemplate(container) {
-        container.style.alignSelf = 'flex-end';
-        const icon = append(container, $('.codicon'));
-        icon.style.display = 'flex';
-        icon.style.alignItems = 'center';
-        icon.style.justifyContent = 'center';
-        icon.style.height = this._disassemblyView.fontInfo.lineHeight + 'px';
-        const currentElement = { element: undefined };
+        container.style.alignSelf = "flex-end";
+        const icon = append(container, $(".codicon"));
+        icon.style.display = "flex";
+        icon.style.alignItems = "center";
+        icon.style.justifyContent = "center";
+        icon.style.height = this._disassemblyView.fontInfo.lineHeight + "px";
+        const currentElement = {
+            element: undefined
+        };
         const disposables = [
             this._disassemblyView.onDidChangeStackFrame(() => this.rerenderDebugStackframe(icon, currentElement.element)),
-            addStandardDisposableListener(container, 'mouseover', () => {
+            addStandardDisposableListener(container, "mouseover", () => {
                 if (currentElement.element?.allowBreakpoint) {
                     icon.classList.add(this._breakpointHintIcon);
                 }
             }),
-            addStandardDisposableListener(container, 'mouseout', () => {
+            addStandardDisposableListener(container, "mouseout", () => {
                 if (currentElement.element?.allowBreakpoint) {
                     icon.classList.remove(this._breakpointHintIcon);
                 }
             }),
-            addStandardDisposableListener(container, 'click', () => {
+            addStandardDisposableListener(container, "click", () => {
                 if (currentElement.element?.allowBreakpoint) {
                     icon.classList.add(this._breakpointHintIcon);
                     const reference = currentElement.element.instructionReference;
-                    const offset = Number(currentElement.element.address - this._disassemblyView.getReferenceAddress(reference));
+                    const offset = Number(
+                        currentElement.element.address - this._disassemblyView.getReferenceAddress(reference)
+                    );
                     if (currentElement.element.isBreakpointSet) {
                         this._debugService.removeInstructionBreakpoints(reference, offset);
-                    }
-                    else if (currentElement.element.allowBreakpoint && !currentElement.element.isBreakpointSet) {
-                        this._debugService.addInstructionBreakpoint({ instructionReference: reference, offset, address: currentElement.element.address, canPersist: false });
+                    } else if (currentElement.element.allowBreakpoint && !currentElement.element.isBreakpointSet) {
+                        this._debugService.addInstructionBreakpoint({
+                            instructionReference: reference,
+                            offset,
+                            address: currentElement.element.address,
+                            canPersist: false
+                        });
                     }
                 }
             })
         ];
-        return { currentElement, icon, disposables };
+        return {
+            currentElement,
+            icon,
+            disposables
+        };
     }
     renderElement(element, index, templateData) {
         templateData.currentElement.element = element;
@@ -579,11 +651,9 @@ let BreakpointRenderer = class BreakpointRenderer {
     rerenderDebugStackframe(icon, element) {
         if (element?.address === this._disassemblyView.focusedCurrentInstructionAddress) {
             icon.classList.add(this._debugStackframe);
-        }
-        else if (element?.address === this._disassemblyView.focusedInstructionAddress) {
+        } else if (element?.address === this._disassemblyView.focusedInstructionAddress) {
             icon.classList.add(this._debugStackframeFocused);
-        }
-        else {
+        } else {
             icon.classList.remove(this._debugStackframe);
             icon.classList.remove(this._debugStackframeFocused);
         }
@@ -592,27 +662,38 @@ let BreakpointRenderer = class BreakpointRenderer {
             if (element.isBreakpointEnabled) {
                 icon.classList.add(this._breakpointIcon);
                 icon.classList.remove(this._breakpointDisabledIcon);
-            }
-            else {
+            } else {
                 icon.classList.remove(this._breakpointIcon);
                 icon.classList.add(this._breakpointDisabledIcon);
             }
-        }
-        else {
+        } else {
             icon.classList.remove(this._breakpointIcon);
             icon.classList.remove(this._breakpointDisabledIcon);
         }
     }
 };
-BreakpointRenderer = BreakpointRenderer_1 = ( __decorate([
-    ( __param(1, IDebugService))
-], BreakpointRenderer));
+BreakpointRenderer = BreakpointRenderer_1 = ( __decorate([( __param(1, IDebugService))], BreakpointRenderer));
 let InstructionRenderer = class InstructionRenderer extends Disposable {
-    static { InstructionRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'instruction'; }
-    static { this.INSTRUCTION_ADDR_MIN_LENGTH = 25; }
-    static { this.INSTRUCTION_BYTES_MIN_LENGTH = 30; }
-    constructor(_disassemblyView, themeService, editorService, textModelService, uriService, logService) {
+    static {
+        InstructionRenderer_1 = this;
+    }
+    static {
+        this.TEMPLATE_ID = "instruction";
+    }
+    static {
+        this.INSTRUCTION_ADDR_MIN_LENGTH = 25;
+    }
+    static {
+        this.INSTRUCTION_BYTES_MIN_LENGTH = 30;
+    }
+    constructor(
+        _disassemblyView,
+        themeService,
+        editorService,
+        textModelService,
+        uriService,
+        logService
+    ) {
         super();
         this._disassemblyView = _disassemblyView;
         this.editorService = editorService;
@@ -628,17 +709,28 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
         }));
     }
     renderTemplate(container) {
-        const sourcecode = append(container, $('.sourcecode'));
-        const instruction = append(container, $('.instruction'));
+        const sourcecode = append(container, $(".sourcecode"));
+        const instruction = append(container, $(".instruction"));
         this.applyFontInfo(sourcecode);
         this.applyFontInfo(instruction);
-        const currentElement = { element: undefined };
+        const currentElement = {
+            element: undefined
+        };
         const cellDisposable = [];
-        const disposables = [
-            this._disassemblyView.onDidChangeStackFrame(() => this.rerenderBackground(instruction, sourcecode, currentElement.element)),
-            addStandardDisposableListener(sourcecode, 'dblclick', () => this.openSourceCode(currentElement.element?.instruction)),
-        ];
-        return { currentElement, instruction, sourcecode, cellDisposable, disposables };
+        const disposables = [this._disassemblyView.onDidChangeStackFrame(
+            () => this.rerenderBackground(instruction, sourcecode, currentElement.element)
+        ), addStandardDisposableListener(
+            sourcecode,
+            "dblclick",
+            () => this.openSourceCode(currentElement.element?.instruction)
+        )];
+        return {
+            currentElement,
+            instruction,
+            sourcecode,
+            cellDisposable,
+            disposables
+        };
     }
     renderElement(element, index, templateData) {
         this.renderElementInner(element, index, templateData);
@@ -646,7 +738,7 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
     async renderElementInner(element, index, templateData) {
         templateData.currentElement.element = element;
         const instruction = element.instruction;
-        templateData.sourcecode.innerText = '';
+        templateData.sourcecode.innerText = "";
         const sb = ( new StringBuilder(1000));
         if (this._disassemblyView.isSourceCodeRender && element.showSourceLocation && instruction.location?.path && instruction.line !== undefined) {
             const sourceURI = this.getUriFromSource(instruction);
@@ -664,7 +756,7 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
                     while (lineNumber && lineNumber >= 1 && lineNumber <= textModel.getLineCount()) {
                         const lineContent = textModel.getLineContent(lineNumber);
                         sourceSB.appendString(`  ${lineNumber}: `);
-                        sourceSB.appendString(lineContent + '\n');
+                        sourceSB.appendString(lineContent + "\n");
                         if (instruction.endLine && lineNumber < instruction.endLine) {
                             lineNumber++;
                             continue;
@@ -676,13 +768,13 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
             }
         }
         let spacesToAppend = 10;
-        if (instruction.address !== '-1') {
+        if (instruction.address !== "-1") {
             sb.appendString(instruction.address);
             if (instruction.address.length < InstructionRenderer_1.INSTRUCTION_ADDR_MIN_LENGTH) {
                 spacesToAppend = InstructionRenderer_1.INSTRUCTION_ADDR_MIN_LENGTH - instruction.address.length;
             }
             for (let i = 0; i < spacesToAppend; i++) {
-                sb.appendString(' ');
+                sb.appendString(" ");
             }
         }
         if (instruction.instructionBytes) {
@@ -692,7 +784,7 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
                 spacesToAppend = InstructionRenderer_1.INSTRUCTION_BYTES_MIN_LENGTH - instruction.instructionBytes.length;
             }
             for (let i = 0; i < spacesToAppend; i++) {
-                sb.appendString(' ');
+                sb.appendString(" ");
             }
         }
         sb.appendString(instruction.instruction);
@@ -709,13 +801,11 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
     }
     rerenderBackground(instruction, sourceCode, element) {
         if (element && this._disassemblyView.currentInstructionAddresses.includes(element.address)) {
-            instruction.style.background = this._topStackFrameColor?.toString() || 'transparent';
-        }
-        else if (element?.address === this._disassemblyView.focusedInstructionAddress) {
-            instruction.style.background = this._focusedStackFrameColor?.toString() || 'transparent';
-        }
-        else {
-            instruction.style.background = 'transparent';
+            instruction.style.background = this._topStackFrameColor?.toString() || "transparent";
+        } else if (element?.address === this._disassemblyView.focusedInstructionAddress) {
+            instruction.style.background = this._focusedStackFrameColor?.toString() || "transparent";
+        } else {
+            instruction.style.background = "transparent";
         }
     }
     openSourceCode(instruction) {
@@ -725,22 +815,22 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
                 startLineNumber: instruction.line,
                 endLineNumber: instruction.endLine,
                 startColumn: instruction.column || 1,
-                endColumn: instruction.endColumn || Constants.MAX_SAFE_SMALL_INTEGER,
+                endColumn: instruction.endColumn || Constants.MAX_SAFE_SMALL_INTEGER
             } : {
                 startLineNumber: instruction.line,
                 endLineNumber: instruction.line,
                 startColumn: instruction.column || 1,
-                endColumn: instruction.endColumn || Constants.MAX_SAFE_SMALL_INTEGER,
+                endColumn: instruction.endColumn || Constants.MAX_SAFE_SMALL_INTEGER
             };
             this.editorService.openEditor({
                 resource: sourceURI,
-                description: ( localize(6935, "from disassembly")),
+                description: ( localize(7246, "from disassembly")),
                 options: {
                     preserveFocus: false,
                     selection: selection,
                     revealIfOpened: true,
                     selectionRevealType: TextEditorSelectionRevealType.CenterIfOutsideViewport,
-                    pinned: false,
+                    pinned: false
                 }
             });
         }
@@ -753,34 +843,34 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
         if (path && isAbsolute(path)) {
             return this.uriService.asCanonicalUri(URI.file(path));
         }
-        return getUriFromSource(instruction.location, instruction.location.path, this._disassemblyView.debugSession.getId(), this.uriService, this.logService);
+        return getUriFromSource(
+            instruction.location,
+            instruction.location.path,
+            this._disassemblyView.debugSession.getId(),
+            this.uriService,
+            this.logService
+        );
     }
     applyFontInfo(element) {
         applyFontInfo(element, this._disassemblyView.fontInfo);
-        element.style.whiteSpace = 'pre';
+        element.style.whiteSpace = "pre";
     }
 };
-InstructionRenderer = InstructionRenderer_1 = ( __decorate([
-    ( __param(1, IThemeService)),
-    ( __param(2, IEditorService)),
-    ( __param(3, ITextModelService)),
-    ( __param(4, IUriIdentityService)),
-    ( __param(5, ILogService))
-], InstructionRenderer));
+InstructionRenderer = InstructionRenderer_1 = ( __decorate([( __param(1, IThemeService)), ( __param(2, IEditorService)), ( __param(3, ITextModelService)), ( __param(4, IUriIdentityService)), ( __param(5, ILogService))], InstructionRenderer));
 class AccessibilityProvider {
     getWidgetAriaLabel() {
-        return localize(6936, "Disassembly View");
+        return localize(7247, "Disassembly View");
     }
     getAriaLabel(element) {
-        let label = '';
+        let label = "";
         const instruction = element.instruction;
-        if (instruction.address !== '-1') {
-            label += `${( localize(6937, "Address"))}: ${instruction.address}`;
+        if (instruction.address !== "-1") {
+            label += `${( localize(7248, "Address"))}: ${instruction.address}`;
         }
         if (instruction.instructionBytes) {
-            label += `, ${( localize(6938, "Bytes"))}: ${instruction.instructionBytes}`;
+            label += `, ${( localize(7249, "Bytes"))}: ${instruction.instructionBytes}`;
         }
-        label += `, ${( localize(6939, "Instruction"))}: ${instruction.instruction}`;
+        label += `, ${( localize(7250, "Instruction"))}: ${instruction.instruction}`;
         return label;
     }
 }
@@ -797,12 +887,15 @@ let DisassemblyViewContribution = class DisassemblyViewContribution {
             const activeTextEditorControl = editorService.activeTextEditorControl;
             if (isCodeEditor(activeTextEditorControl)) {
                 const language = activeTextEditorControl.getModel()?.getLanguageId();
-                this._languageSupportsDisassembleRequest?.set(!!language && debugService.getAdapterManager().someDebuggerInterestedInLanguage(language));
+                this._languageSupportsDisassembleRequest?.set(
+                    !!language && debugService.getAdapterManager().someDebuggerInterestedInLanguage(language)
+                );
                 this._onDidChangeModelLanguage = activeTextEditorControl.onDidChangeModelLanguage(e => {
-                    this._languageSupportsDisassembleRequest?.set(debugService.getAdapterManager().someDebuggerInterestedInLanguage(e.newLanguage));
+                    this._languageSupportsDisassembleRequest?.set(
+                        debugService.getAdapterManager().someDebuggerInterestedInLanguage(e.newLanguage)
+                    );
                 });
-            }
-            else {
+            } else {
                 this._languageSupportsDisassembleRequest?.set(false);
             }
         };
@@ -814,14 +907,10 @@ let DisassemblyViewContribution = class DisassemblyViewContribution {
         this._onDidChangeModelLanguage?.dispose();
     }
 };
-DisassemblyViewContribution = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IDebugService)),
-    ( __param(2, IContextKeyService))
-], DisassemblyViewContribution));
+DisassemblyViewContribution = ( __decorate([( __param(0, IEditorService)), ( __param(1, IDebugService)), ( __param(2, IContextKeyService))], DisassemblyViewContribution));
 CommandsRegistry.registerCommand({
     metadata: {
-        description: COPY_ADDRESS_LABEL,
+        description: COPY_ADDRESS_LABEL
     },
     id: COPY_ADDRESS_ID,
     handler: async (accessor, entry) => {