@codingame/monaco-vscode-api 1.79.0-next.0 → 1.79.1

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

@@ -0,0 +1,620 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { PixelRatio } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { append, $, addStandardDisposableListener } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { BareFontInfo } from 'monaco-editor/esm/vs/editor/common/config/fontInfo.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { WorkbenchTable } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
+import { DISASSEMBLY_VIEW_ID, IDebugService } from '../common/debug.js';
+import { breakpoint, debugBreakpointHint, debugStackframe, debugStackframeFocused } from './debugIcons.js';
+import { StringBuilder } from 'monaco-editor/esm/vs/editor/common/core/stringBuilder.js';
+import { dispose, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { topStackFrameColor, focusedStackFrameColor } from './callStackEditorContribution.js';
+import { InstructionBreakpoint } from '../common/debugModel.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { getUriFromSource } from '../common/debugSource.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isUri } from '../common/debugUtils.js';
+import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
+import { applyFontInfo } from 'monaco-editor/esm/vs/editor/browser/config/domFontInfo.js';
+import { binarySearch2 } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+const disassemblyNotAvailable = {
+    allowBreakpoint: false,
+    isBreakpointSet: false,
+    isBreakpointEnabled: false,
+    instruction: {
+        address: '-1',
+        instruction: ( (localize('instructionNotAvailable', "Disassembly not available.")))
+    },
+    instructionAddress: BigInt(-1)
+};
+let DisassemblyView = class DisassemblyView extends EditorPane {
+    constructor(telemetryService, themeService, storageService, _configurationService, _instantiationService, _debugService) {
+        super(DISASSEMBLY_VIEW_ID, telemetryService, themeService, storageService);
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._debugService = _debugService;
+        this._instructionBpList = [];
+        this._enableSourceCodeRender = true;
+        this._loadingLock = false;
+        this._disassembledInstructions = undefined;
+        this._onDidChangeStackFrame = ( (new Emitter()));
+        this._previousDebuggingState = _debugService.state;
+        this._fontInfo = BareFontInfo.createFromRawSettings(_configurationService.getValue('editor'), PixelRatio.value);
+        this._register(_configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('editor')) {
+                this._fontInfo = BareFontInfo.createFromRawSettings(_configurationService.getValue('editor'), PixelRatio.value);
+            }
+            if (e.affectsConfiguration('debug')) {
+                const newValue = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
+                if (this._enableSourceCodeRender !== newValue) {
+                    this._enableSourceCodeRender = newValue;
+                    this.reloadDisassembly(undefined);
+                }
+                else {
+                    this._disassembledInstructions?.rerender();
+                }
+            }
+        }));
+    }
+    get fontInfo() { return this._fontInfo; }
+    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))
+        );
+    }
+    get focusedCurrentInstructionAddress() {
+        return this._debugService.getViewModel().focusedStackFrame?.thread.getTopStackFrame()?.instructionPointerReference;
+    }
+    get focusedInstructionAddress() {
+        return this._debugService.getViewModel().focusedStackFrame?.instructionPointerReference;
+    }
+    get isSourceCodeRender() { return this._enableSourceCodeRender; }
+    get debugSession() {
+        return this._debugService.getViewModel().focusedSession;
+    }
+    get onDidChangeStackFrame() { return this._onDidChangeStackFrame.event; }
+    createEditor(parent) {
+        this._enableSourceCodeRender = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
+        const lineHeight = this.fontInfo.lineHeight;
+        const thisOM = this;
+        const delegate = new class {
+            constructor() {
+                this.headerRowHeight = 0;
+            }
+            getHeight(row) {
+                if (thisOM.isSourceCodeRender && row.instruction.location?.path && row.instruction.line) {
+                    if (row.instruction.endLine) {
+                        return lineHeight * (row.instruction.endLine - row.instruction.line + 2);
+                    }
+                    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: '',
+                weight: 0,
+                minimumWidth: this.fontInfo.lineHeight,
+                maximumWidth: this.fontInfo.lineHeight,
+                templateId: BreakpointRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            },
+            {
+                label: ( (localize('disassemblyTableColumnLabel', "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.reloadDisassembly();
+        this._register(this._disassembledInstructions.onDidScroll(e => {
+            if (this._loadingLock) {
+                return;
+            }
+            if (e.oldScrollTop > e.scrollTop && e.scrollTop < e.height) {
+                this._loadingLock = true;
+                const topElement = Math.floor(e.scrollTop / this.fontInfo.lineHeight) + DisassemblyView.NUM_INSTRUCTIONS_TO_LOAD;
+                this.scrollUp_LoadDisassembledInstructions(DisassemblyView.NUM_INSTRUCTIONS_TO_LOAD).then((success) => {
+                    if (success) {
+                        this._disassembledInstructions.reveal(topElement, 0);
+                    }
+                    this._loadingLock = false;
+                });
+            }
+            else if (e.oldScrollTop < e.scrollTop && e.scrollTop + e.height > e.scrollHeight - e.height) {
+                this._loadingLock = true;
+                this.scrollDown_LoadDisassembledInstructions(DisassemblyView.NUM_INSTRUCTIONS_TO_LOAD).then(() => { this._loadingLock = false; });
+            }
+        }));
+        this._register(this._debugService.getViewModel().onDidFocusStackFrame((stackFrame) => {
+            if (this._disassembledInstructions) {
+                this.goToAddress();
+                this._onDidChangeStackFrame.fire();
+            }
+        }));
+        this._register(this._debugService.getModel().onDidChangeBreakpoints(bpEvent => {
+            if (bpEvent && this._disassembledInstructions) {
+                let changed = false;
+                bpEvent.added?.forEach((bp) => {
+                    if (bp instanceof InstructionBreakpoint) {
+                        const index = this.getIndexFromAddress(bp.instructionReference);
+                        if (index >= 0) {
+                            this._disassembledInstructions.row(index).isBreakpointSet = true;
+                            this._disassembledInstructions.row(index).isBreakpointEnabled = bp.enabled;
+                            changed = true;
+                        }
+                    }
+                });
+                bpEvent.removed?.forEach((bp) => {
+                    if (bp instanceof InstructionBreakpoint) {
+                        const index = this.getIndexFromAddress(bp.instructionReference);
+                        if (index >= 0) {
+                            this._disassembledInstructions.row(index).isBreakpointSet = false;
+                            changed = true;
+                        }
+                    }
+                });
+                bpEvent.changed?.forEach((bp) => {
+                    if (bp instanceof InstructionBreakpoint) {
+                        const index = this.getIndexFromAddress(bp.instructionReference);
+                        if (index >= 0) {
+                            if (this._disassembledInstructions.row(index).isBreakpointEnabled !== bp.enabled) {
+                                this._disassembledInstructions.row(index).isBreakpointEnabled = bp.enabled;
+                                changed = true;
+                            }
+                        }
+                    }
+                });
+                this._instructionBpList = this._debugService.getModel().getInstructionBreakpoints();
+                if (changed) {
+                    this._onDidChangeStackFrame.fire();
+                }
+            }
+        }));
+        this._register(this._debugService.onDidChangeState(e => {
+            if (((e === 3  || e === 2) ) &&
+                ((this._previousDebuggingState !== 3  && this._previousDebuggingState !== 2) )) {
+                this._disassembledInstructions?.splice(0, this._disassembledInstructions.length, [disassemblyNotAvailable]);
+                this._enableSourceCodeRender = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
+            }
+            this._previousDebuggingState = e;
+        }));
+    }
+    layout(dimension) {
+        this._disassembledInstructions?.layout(dimension.height);
+    }
+    goToAddress(address, focus) {
+        if (!this._disassembledInstructions) {
+            return;
+        }
+        if (!address) {
+            address = this.focusedInstructionAddress;
+        }
+        if (!address) {
+            return;
+        }
+        const index = this.getIndexFromAddress(address);
+        if (index >= 0) {
+            this._disassembledInstructions.reveal(index);
+            if (focus) {
+                this._disassembledInstructions.domFocus();
+                this._disassembledInstructions.setFocus([index]);
+            }
+        }
+        else if (this._debugService.state === 2 ) {
+            this.reloadDisassembly(address);
+        }
+    }
+    async scrollUp_LoadDisassembledInstructions(instructionCount) {
+        if (this._disassembledInstructions && this._disassembledInstructions.length > 0) {
+            const address = this._disassembledInstructions?.row(0).instruction.address;
+            return this.loadDisassembledInstructions(address, -instructionCount, instructionCount);
+        }
+        return false;
+    }
+    async scrollDown_LoadDisassembledInstructions(instructionCount) {
+        if (this._disassembledInstructions && this._disassembledInstructions.length > 0) {
+            const address = this._disassembledInstructions?.row(this._disassembledInstructions?.length - 1).instruction.address;
+            return this.loadDisassembledInstructions(address, 1, instructionCount);
+        }
+        return false;
+    }
+    async loadDisassembledInstructions(address, instructionOffset, instructionCount) {
+        if (!address || address === '-1') {
+            address = this.focusedInstructionAddress;
+        }
+        if (!address) {
+            return false;
+        }
+        const session = this.debugSession;
+        const resultEntries = await session?.disassemble(address, 0, instructionOffset, instructionCount);
+        if (session && resultEntries && this._disassembledInstructions) {
+            const newEntries = [];
+            let lastLocation;
+            let lastLine;
+            for (let i = 0; i < resultEntries.length; i++) {
+                const found = this._instructionBpList.find(p => p.instructionReference === resultEntries[i].address);
+                const instruction = resultEntries[i];
+                if (instruction.location) {
+                    lastLocation = instruction.location;
+                    lastLine = undefined;
+                }
+                if (instruction.line) {
+                    const currentLine = {
+                        startLineNumber: instruction.line,
+                        startColumn: instruction.column ?? 0,
+                        endLineNumber: instruction.endLine ?? instruction.line,
+                        endColumn: instruction.endColumn ?? 0,
+                    };
+                    if (!Range.equalsRange(currentLine, lastLine ?? null)) {
+                        lastLine = currentLine;
+                        instruction.location = lastLocation;
+                    }
+                }
+                newEntries.push({ allowBreakpoint: true, isBreakpointSet: found !== undefined, isBreakpointEnabled: !!found?.enabled, instruction: instruction });
+            }
+            const specialEntriesToRemove = this._disassembledInstructions.length === 1 ? 1 : 0;
+            if (instructionOffset >= 0) {
+                this._disassembledInstructions.splice(this._disassembledInstructions.length, specialEntriesToRemove, newEntries);
+            }
+            else {
+                this._disassembledInstructions.splice(0, specialEntriesToRemove, newEntries);
+            }
+            return true;
+        }
+        return false;
+    }
+    getIndexFromAddress(instructionAddress) {
+        const disassembledInstructions = this._disassembledInstructions;
+        if (disassembledInstructions && disassembledInstructions.length > 0) {
+            const address = BigInt(instructionAddress);
+            if (address) {
+                return binarySearch2(disassembledInstructions.length, index => {
+                    const row = disassembledInstructions.row(index);
+                    this.ensureAddressParsed(row);
+                    if (row.instructionAddress > address) {
+                        return 1;
+                    }
+                    else if (row.instructionAddress < address) {
+                        return -1;
+                    }
+                    else {
+                        return 0;
+                    }
+                });
+            }
+        }
+        return -1;
+    }
+    ensureAddressParsed(entry) {
+        if (entry.instructionAddress !== undefined) {
+            return;
+        }
+        else {
+            entry.instructionAddress = BigInt(entry.instruction.address);
+        }
+    }
+    reloadDisassembly(targetAddress) {
+        if (this._disassembledInstructions) {
+            this._loadingLock = true;
+            this._disassembledInstructions.splice(0, this._disassembledInstructions.length, [disassemblyNotAvailable]);
+            this._instructionBpList = this._debugService.getModel().getInstructionBreakpoints();
+            this.loadDisassembledInstructions(targetAddress, -DisassemblyView.NUM_INSTRUCTIONS_TO_LOAD * 4, DisassemblyView.NUM_INSTRUCTIONS_TO_LOAD * 8).then(() => {
+                if (this._disassembledInstructions.length > 0) {
+                    const targetIndex = Math.floor(this._disassembledInstructions.length / 2);
+                    this._disassembledInstructions.reveal(targetIndex, 0.5);
+                    this._disassembledInstructions.domFocus();
+                    this._disassembledInstructions.setFocus([targetIndex]);
+                }
+                this._loadingLock = false;
+            });
+        }
+    }
+};
+DisassemblyView.NUM_INSTRUCTIONS_TO_LOAD = 50;
+DisassemblyView = ( (__decorate([
+    ( (__param(0, ITelemetryService))),
+    ( (__param(1, IThemeService))),
+    ( (__param(2, IStorageService))),
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IDebugService)))
+], DisassemblyView)));
+let BreakpointRenderer = class BreakpointRenderer {
+    constructor(_disassemblyView, _debugService) {
+        this._disassemblyView = _disassemblyView;
+        this._debugService = _debugService;
+        this.templateId = BreakpointRenderer.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;
+    }
+    renderTemplate(container) {
+        container.style.alignSelf = 'flex-end';
+        const icon = append(container, $('.disassembly-view'));
+        icon.classList.add('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', () => {
+                if (currentElement.element?.allowBreakpoint) {
+                    icon.classList.add(this._breakpointHintIcon);
+                }
+            }),
+            addStandardDisposableListener(container, 'mouseout', () => {
+                if (currentElement.element?.allowBreakpoint) {
+                    icon.classList.remove(this._breakpointHintIcon);
+                }
+            }),
+            addStandardDisposableListener(container, 'click', () => {
+                if (currentElement.element?.allowBreakpoint) {
+                    icon.classList.add(this._breakpointHintIcon);
+                    if (currentElement.element.isBreakpointSet) {
+                        this._debugService.removeInstructionBreakpoints(currentElement.element.instruction.address);
+                    }
+                    else if (currentElement.element.allowBreakpoint && !currentElement.element.isBreakpointSet) {
+                        this._debugService.addInstructionBreakpoint(currentElement.element.instruction.address, 0);
+                    }
+                }
+            })
+        ];
+        return { currentElement, icon, disposables };
+    }
+    renderElement(element, index, templateData, height) {
+        templateData.currentElement.element = element;
+        this.rerenderDebugStackframe(templateData.icon, element);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.disposables);
+        templateData.disposables = [];
+    }
+    rerenderDebugStackframe(icon, element) {
+        if (element?.instruction.address === this._disassemblyView.focusedCurrentInstructionAddress) {
+            icon.classList.add(this._debugStackframe);
+        }
+        else if (element?.instruction.address === this._disassemblyView.focusedInstructionAddress) {
+            icon.classList.add(this._debugStackframeFocused);
+        }
+        else {
+            icon.classList.remove(this._debugStackframe);
+            icon.classList.remove(this._debugStackframeFocused);
+        }
+        icon.classList.remove(this._breakpointHintIcon);
+        if (element?.isBreakpointSet) {
+            if (element.isBreakpointEnabled) {
+                icon.classList.add(this._breakpointIcon);
+                icon.classList.remove(this._breakpointDisabledIcon);
+            }
+            else {
+                icon.classList.remove(this._breakpointIcon);
+                icon.classList.add(this._breakpointDisabledIcon);
+            }
+        }
+        else {
+            icon.classList.remove(this._breakpointIcon);
+            icon.classList.remove(this._breakpointDisabledIcon);
+        }
+    }
+};
+BreakpointRenderer.TEMPLATE_ID = 'breakpoint';
+BreakpointRenderer = ( (__decorate([
+    ( (__param(1, IDebugService)))
+], BreakpointRenderer)));
+let InstructionRenderer = class InstructionRenderer extends Disposable {
+    constructor(_disassemblyView, themeService, editorService, textModelService, uriService, logService) {
+        super();
+        this._disassemblyView = _disassemblyView;
+        this.editorService = editorService;
+        this.textModelService = textModelService;
+        this.uriService = uriService;
+        this.logService = logService;
+        this.templateId = InstructionRenderer.TEMPLATE_ID;
+        this._topStackFrameColor = themeService.getColorTheme().getColor(topStackFrameColor);
+        this._focusedStackFrameColor = themeService.getColorTheme().getColor(focusedStackFrameColor);
+        this._register(themeService.onDidColorThemeChange(e => {
+            this._topStackFrameColor = e.getColor(topStackFrameColor);
+            this._focusedStackFrameColor = e.getColor(focusedStackFrameColor);
+        }));
+    }
+    renderTemplate(container) {
+        const sourcecode = append(container, $('.sourcecode'));
+        const instruction = append(container, $('.instruction'));
+        this.applyFontInfo(sourcecode);
+        this.applyFontInfo(instruction);
+        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 };
+    }
+    renderElement(element, index, templateData, height) {
+        this.renderElementInner(element, index, templateData, height);
+    }
+    async renderElementInner(element, index, templateData, height) {
+        templateData.currentElement.element = element;
+        const instruction = element.instruction;
+        templateData.sourcecode.innerText = '';
+        const sb = ( (new StringBuilder(1000)));
+        if (this._disassemblyView.isSourceCodeRender && instruction.location?.path && instruction.line) {
+            const sourceURI = this.getUriFromSource(instruction);
+            if (sourceURI) {
+                let textModel = undefined;
+                const sourceSB = ( (new StringBuilder(10000)));
+                const ref = await this.textModelService.createModelReference(sourceURI);
+                textModel = ref.object.textEditorModel;
+                templateData.cellDisposable.push(ref);
+                if (textModel && templateData.currentElement.element === element) {
+                    let lineNumber = instruction.line;
+                    while (lineNumber && lineNumber >= 1 && lineNumber <= textModel.getLineCount()) {
+                        const lineContent = textModel.getLineContent(lineNumber);
+                        sourceSB.appendString(`  ${lineNumber}: `);
+                        sourceSB.appendString(lineContent + '\n');
+                        if (instruction.endLine && lineNumber < instruction.endLine) {
+                            lineNumber++;
+                            continue;
+                        }
+                        break;
+                    }
+                    templateData.sourcecode.innerText = sourceSB.build();
+                }
+            }
+        }
+        let spacesToAppend = 10;
+        if (instruction.address !== '-1') {
+            sb.appendString(instruction.address);
+            if (instruction.address.length < InstructionRenderer.INSTRUCTION_ADDR_MIN_LENGTH) {
+                spacesToAppend = InstructionRenderer.INSTRUCTION_ADDR_MIN_LENGTH - instruction.address.length;
+            }
+            for (let i = 0; i < spacesToAppend; i++) {
+                sb.appendString(' ');
+            }
+        }
+        if (instruction.instructionBytes) {
+            sb.appendString(instruction.instructionBytes);
+            spacesToAppend = 10;
+            if (instruction.instructionBytes.length < InstructionRenderer.INSTRUCTION_BYTES_MIN_LENGTH) {
+                spacesToAppend = InstructionRenderer.INSTRUCTION_BYTES_MIN_LENGTH - instruction.instructionBytes.length;
+            }
+            for (let i = 0; i < spacesToAppend; i++) {
+                sb.appendString(' ');
+            }
+        }
+        sb.appendString(instruction.instruction);
+        templateData.instruction.innerText = sb.build();
+        this.rerenderBackground(templateData.instruction, templateData.sourcecode, element);
+    }
+    disposeElement(element, index, templateData, height) {
+        dispose(templateData.cellDisposable);
+        templateData.cellDisposable = [];
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.disposables);
+        templateData.disposables = [];
+    }
+    rerenderBackground(instruction, sourceCode, element) {
+        if (element && this._disassemblyView.currentInstructionAddresses.includes(element.instruction.address)) {
+            instruction.style.background = this._topStackFrameColor?.toString() || 'transparent';
+        }
+        else if (element?.instruction.address === this._disassemblyView.focusedInstructionAddress) {
+            instruction.style.background = this._focusedStackFrameColor?.toString() || 'transparent';
+        }
+        else {
+            instruction.style.background = 'transparent';
+        }
+    }
+    openSourceCode(instruction) {
+        if (instruction) {
+            const sourceURI = this.getUriFromSource(instruction);
+            const selection = instruction.endLine ? {
+                startLineNumber: instruction.line,
+                endLineNumber: instruction.endLine,
+                startColumn: instruction.column || 1,
+                endColumn: instruction.endColumn || 1073741824 ,
+            } : {
+                startLineNumber: instruction.line,
+                endLineNumber: instruction.line,
+                startColumn: instruction.column || 1,
+                endColumn: instruction.endColumn || 1073741824 ,
+            };
+            this.editorService.openEditor({
+                resource: sourceURI,
+                description: ( (localize('editorOpenedFromDisassemblyDescription', "from disassembly"))),
+                options: {
+                    preserveFocus: false,
+                    selection: selection,
+                    revealIfOpened: true,
+                    selectionRevealType: 1 ,
+                    pinned: false,
+                }
+            });
+        }
+    }
+    getUriFromSource(instruction) {
+        const path = instruction.location.path;
+        if (path && isUri(path)) {
+            return this.uriService.asCanonicalUri(( (URI.parse(path))));
+        }
+        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);
+    }
+    applyFontInfo(element) {
+        applyFontInfo(element, this._disassemblyView.fontInfo);
+        element.style.whiteSpace = 'pre';
+    }
+};
+InstructionRenderer.TEMPLATE_ID = 'instruction';
+InstructionRenderer.INSTRUCTION_ADDR_MIN_LENGTH = 25;
+InstructionRenderer.INSTRUCTION_BYTES_MIN_LENGTH = 30;
+InstructionRenderer = ( (__decorate([
+    ( (__param(1, IThemeService))),
+    ( (__param(2, IEditorService))),
+    ( (__param(3, ITextModelService))),
+    ( (__param(4, IUriIdentityService))),
+    ( (__param(5, ILogService)))
+], InstructionRenderer)));
+class AccessibilityProvider {
+    getWidgetAriaLabel() {
+        return (
+             (localize('disassemblyView', "Disassembly View"))
+        );
+    }
+    getAriaLabel(element) {
+        let label = '';
+        const instruction = element.instruction;
+        if (instruction.address !== '-1') {
+            label += `${( ( localize('instructionAddress', "Address")))}: ${instruction.address}`;
+        }
+        if (instruction.instructionBytes) {
+            label += `, ${( ( localize('instructionBytes', "Bytes")))}: ${instruction.instructionBytes}`;
+        }
+        label += `, ${( ( localize(`instructionText`, "Instruction")))}: ${instruction.instruction}`;
+        return label;
+    }
+}
+export { DisassemblyView };

package/dist/vscode/vs/workbench/contrib/debug/browser/exceptionWidget.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/exceptionWidget.css";
+import './media/exceptionWidget.css.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { ZoneWidget } from 'monaco-editor/esm/vs/editor/contrib/zoneWidget/browser/zoneWidget.js';

package/dist/vscode/vs/workbench/contrib/debug/browser/media/breakpointWidget.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .zone-widget .zone-widget-container.breakpoint-widget{border-color:#007acc;display:flex}.monaco-editor .zone-widget .zone-widget-container.breakpoint-widget .breakpoint-select-container{display:flex;flex-direction:column;flex-shrink:0;justify-content:center;padding:0 10px}.monaco-editor .zone-widget .zone-widget-container.breakpoint-widget .breakpoint-select-container .monaco-select-box{min-height:18px;min-width:100px;padding:2px 20px 2px 8px}.monaco-editor .zone-widget .zone-widget-container.breakpoint-widget .breakpoint-select-container:after{right:14px}.monaco-editor .zone-widget .zone-widget-container.breakpoint-widget .inputContainer{flex:1}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/contrib/debug/browser/media/callStackEditorContribution.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .view-overlays .debug-top-stack-frame-line{background-color:var(--vscode-editor-stackFrameHighlightBackground)}.monaco-editor .view-overlays .debug-focused-stack-frame-line{background-color:var(--vscode-editor-focusedStackFrameHighlightBackground)}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".codicon-debug-hint{cursor:pointer}.codicon-debug-hint:not([class*=codicon-debug-breakpoint]):not([class*=codicon-debug-stackframe]){opacity:.4!important}.inline-breakpoint-widget.codicon{align-items:center;display:flex!important}.inline-breakpoint-widget.codicon-debug-breakpoint-disabled{opacity:.7}.monaco-editor .inline-breakpoint-widget.line-start{left:-8px!important}.monaco-editor .debug-breakpoint-placeholder{display:inline-flex;margin-top:-1px;vertical-align:middle;width:.9em}.codicon-debug-breakpoint.codicon-debug-stackframe-focused:after,.codicon-debug-breakpoint.codicon-debug-stackframe:after{content:\"\\eb8a\";position:absolute}.monaco-editor .debug-top-stack-frame-column{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;align-items:center;display:inline-flex;font:normal normal normal 16px/1 codicon;margin-left:0;margin-right:4px;margin-top:-1px;text-rendering:auto;vertical-align:middle;width:.9em}.monaco-editor .debug-top-stack-frame-column.start-of-line{margin-top:0;position:absolute;top:50%;transform:translate(-17px,-50%)}.monaco-editor .inline-breakpoint-widget{cursor:pointer}.monaco-workbench .debug-view-content .monaco-list-row .monaco-tl-contents{overflow:hidden;text-overflow:ellipsis}.monaco-workbench .monaco-list-row .expression{display:flex}.monaco-workbench .debug-hover-widget .monaco-list-row .expression,.monaco-workbench .debug-pane .monaco-list-row .expression{font-family:var(--monaco-monospace-font);font-size:13px;overflow:hidden;text-overflow:ellipsis;white-space:pre}.monaco-workbench.mac .debug-hover-widget .monaco-list-row .expression,.monaco-workbench.mac .debug-pane .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{align-self:center;border-radius:5px;display:none;margin-left:3px}.monaco-workbench .monaco-list-row .expression.lazy .lazy-button{display:inline}.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}.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.internal,.monaco-workbench .monaco-list-row .expression .name.virtual{opacity:.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)}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .debug-hover-widget{animation-duration:.15s;animation-name:fadeIn;position:absolute;user-select:text;-webkit-user-select:text;white-space:pre;word-break:break-all;z-index:50}.monaco-editor .debug-hover-widget .complex-value{max-width:550px}.monaco-editor .debug-hover-widget .complex-value .tip,.monaco-editor .debug-hover-widget .complex-value .title{font-size:11px;height:18px;line-height:18px;overflow:hidden;padding-left:15px;padding-right:2px;text-overflow:ellipsis;white-space:pre;word-break:normal}.monaco-editor .debug-hover-widget .complex-value .title{border-bottom:1px solid hsla(0,0%,50%,.35)}.monaco-editor .debug-hover-widget .complex-value .tip{border-top:1px solid hsla(0,0%,50%,.35);opacity:.5}.monaco-editor .debug-hover-widget .debug-hover-tree{cursor:pointer;line-height:18px}.monaco-editor .debug-hover-widget .debug-hover-tree .monaco-list-row .monaco-tl-contents{user-select:text;-webkit-user-select:text;white-space:pre}.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-bottom:0;margin-top:0}.monaco-editor .debugHoverHighlight{background-color:rgba(173,214,255,.15)}.monaco-editor .debug-hover-widget>.monaco-scrollable-element>.value{color:hsla(0,0%,42%,.8);font-family:var(--monaco-monospace-font);max-height:500px;overflow:auto;padding:4px 5px;white-space:pre-wrap}.monaco-editor.hc-theme .debugHoverHighlight,.monaco-editor.vs-dark .debugHoverHighlight{background-color:rgba(38,79,120,.25)}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .debug-toolbar{border-radius:4px;display:flex;height:32px;padding-left:7px;position:absolute;z-index:39}.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{align-items:center;cursor:grab;display:flex;justify-content:center;opacity:.5;width:16px}.monaco-workbench .debug-toolbar .drag-area.dragged{cursor:grabbing}.monaco-workbench .debug-toolbar .monaco-action-bar .action-item .action-label{align-items:center;background-position:50%;background-repeat:no-repeat;background-size:16px;display:flex;justify-content:center;margin-right:0}";
+n(css,{});
+export { css, css as default };