@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,406 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, addStandardDisposableListener, isAncestorOfActiveElement, $ as $$1 } from '../../../../base/browser/dom.js';
+import { DomScrollableElement } from '../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { coalesce } from '../../../../base/common/arrays.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { dispose } from '../../../../base/common/lifecycle.js';
+import { clamp } from '../../../../base/common/numbers.js';
+import { isMacintosh } from '../../../../base/common/platform.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { ModelDecorationOptions } from '../../../../editor/common/model/textModel.js';
+import { ILanguageFeaturesService } from '../../../../editor/common/services/languageFeatures.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { MenuId, IMenuService } from '../../../../platform/actions/common/actions.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { WorkbenchAsyncDataTree } from '../../../../platform/list/browser/listService.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { asCssVariable } from '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorHoverBackground, editorHoverBorder, editorHoverForeground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { renderExpressionValue, AbstractExpressionDataSource } from './baseDebugView.js';
+import { LinkDetector } from './linkDetector.js';
+import { VariablesRenderer, VisualizedVariableRenderer, openContextMenuForVariableTreeElement } from './variablesView.js';
+import { IDebugService } from '../common/debug.js';
+import { Variable, Expression, VisualizedExpression } from '../common/debugModel.js';
+import { getEvaluatableExpressionAtPosition } from '../common/debugUtils.js';
+var DebugHoverWidget_1;
+const $ = $$1;
+async function doFindExpression(container, namesToFind) {
+    if (!container) {
+        return null;
+    }
+    const children = await container.getChildren();
+    const filtered = children.filter(v => namesToFind[0] === v.name);
+    if (filtered.length !== 1) {
+        return null;
+    }
+    if (namesToFind.length === 1) {
+        return filtered[0];
+    }
+    else {
+        return doFindExpression(filtered[0], namesToFind.slice(1));
+    }
+}
+async function findExpressionInStackFrame(stackFrame, namesToFind) {
+    const scopes = await stackFrame.getScopes();
+    const nonExpensive = scopes.filter(s => !s.expensive);
+    const expressions = coalesce(await Promise.all(( nonExpensive.map(scope => doFindExpression(scope, namesToFind)))));
+    return expressions.length > 0 && expressions.every(e => e.value === expressions[0].value) ? expressions[0] : undefined;
+}
+let DebugHoverWidget = class DebugHoverWidget {
+    static { DebugHoverWidget_1 = this; }
+    static { this.ID = 'debug.hoverWidget'; }
+    get isShowingComplexValue() {
+        return this.complexValueContainer?.hidden === false;
+    }
+    constructor(editor, debugService, instantiationService, menuService, contextKeyService, contextMenuService) {
+        this.editor = editor;
+        this.debugService = debugService;
+        this.instantiationService = instantiationService;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this.contextMenuService = contextMenuService;
+        this.allowEditorOverflow = true;
+        this.highlightDecorations = this.editor.createDecorationsCollection();
+        this.isUpdatingTree = false;
+        this.toDispose = [];
+        this._isVisible = false;
+        this.showAtPosition = null;
+        this.positionPreference = [1 , 2 ];
+        this.debugHoverComputer = this.instantiationService.createInstance(DebugHoverComputer, this.editor);
+    }
+    create() {
+        this.domNode = $('.debug-hover-widget');
+        this.complexValueContainer = append(this.domNode, $('.complex-value'));
+        this.complexValueTitle = append(this.complexValueContainer, $('.title'));
+        this.treeContainer = append(this.complexValueContainer, $('.debug-hover-tree'));
+        this.treeContainer.setAttribute('role', 'tree');
+        const tip = append(this.complexValueContainer, $('.tip'));
+        tip.textContent = ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/debugHover',
+            { key: 'quickTip', comment: ['"switch to editor language hover" means to show the programming language hover widget instead of the debug hover'] },
+            'Hold {0} key to switch to editor language hover',
+            isMacintosh ? 'Option' : 'Alt'
+        ));
+        const dataSource = this.instantiationService.createInstance(DebugHoverDataSource);
+        const linkeDetector = this.instantiationService.createInstance(LinkDetector);
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'DebugHover', this.treeContainer, ( new DebugHoverDelegate()), [
+            this.instantiationService.createInstance(VariablesRenderer, linkeDetector),
+            this.instantiationService.createInstance(VisualizedVariableRenderer, linkeDetector),
+        ], dataSource, {
+            accessibilityProvider: ( new DebugHoverAccessibilityProvider()),
+            mouseSupport: false,
+            horizontalScrolling: true,
+            useShadows: false,
+            keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => e.name },
+            overrideStyles: {
+                listBackground: editorHoverBackground
+            }
+        });
+        this.toDispose.push(VisualizedVariableRenderer.rendererOnVisualizationRange(this.debugService.getViewModel(), this.tree));
+        this.valueContainer = $('.value');
+        this.valueContainer.tabIndex = 0;
+        this.valueContainer.setAttribute('role', 'tooltip');
+        this.scrollbar = ( new DomScrollableElement(this.valueContainer, { horizontal: 2  }));
+        this.domNode.appendChild(this.scrollbar.getDomNode());
+        this.toDispose.push(this.scrollbar);
+        this.editor.applyFontInfo(this.domNode);
+        this.domNode.style.backgroundColor = asCssVariable(editorHoverBackground);
+        this.domNode.style.border = `1px solid ${asCssVariable(editorHoverBorder)}`;
+        this.domNode.style.color = asCssVariable(editorHoverForeground);
+        this.toDispose.push(this.tree.onContextMenu(async (e) => await this.onContextMenu(e)));
+        this.toDispose.push(this.tree.onDidChangeContentHeight(() => {
+            if (!this.isUpdatingTree) {
+                this.layoutTreeAndContainer();
+            }
+        }));
+        this.toDispose.push(this.tree.onDidChangeContentWidth(() => {
+            if (!this.isUpdatingTree) {
+                this.layoutTreeAndContainer();
+            }
+        }));
+        this.registerListeners();
+        this.editor.addContentWidget(this);
+    }
+    async onContextMenu(e) {
+        const variable = e.element;
+        if (!(variable instanceof Variable) || !variable.value) {
+            return;
+        }
+        return openContextMenuForVariableTreeElement(this.contextKeyService, this.menuService, this.contextMenuService, MenuId.DebugHoverContext, e);
+    }
+    registerListeners() {
+        this.toDispose.push(addStandardDisposableListener(this.domNode, 'keydown', (e) => {
+            if (e.equals(9 )) {
+                this.hide();
+            }
+        }));
+        this.toDispose.push(this.editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(50 )) {
+                this.editor.applyFontInfo(this.domNode);
+            }
+        }));
+        this.toDispose.push(this.debugService.getViewModel().onDidEvaluateLazyExpression(async (e) => {
+            if (e instanceof Variable && this.tree.hasNode(e)) {
+                await this.tree.updateChildren(e, false, true);
+                await this.tree.expand(e);
+            }
+        }));
+    }
+    isHovered() {
+        return !!this.domNode?.matches(':hover');
+    }
+    isVisible() {
+        return this._isVisible;
+    }
+    willBeVisible() {
+        return !!this.showCancellationSource;
+    }
+    getId() {
+        return DebugHoverWidget_1.ID;
+    }
+    getDomNode() {
+        return this.domNode;
+    }
+    async showAt(position, focus) {
+        this.showCancellationSource?.cancel();
+        const cancellationSource = this.showCancellationSource = ( new CancellationTokenSource());
+        const session = this.debugService.getViewModel().focusedSession;
+        if (!session || !this.editor.hasModel()) {
+            this.hide();
+            return 1 ;
+        }
+        const result = await this.debugHoverComputer.compute(position, cancellationSource.token);
+        if (cancellationSource.token.isCancellationRequested) {
+            this.hide();
+            return 2 ;
+        }
+        if (!result.range) {
+            this.hide();
+            return 1 ;
+        }
+        if (this.isVisible() && !result.rangeChanged) {
+            return 0 ;
+        }
+        const expression = await this.debugHoverComputer.evaluate(session);
+        if (cancellationSource.token.isCancellationRequested) {
+            this.hide();
+            return 2 ;
+        }
+        if (!expression || (expression instanceof Expression && !expression.available)) {
+            this.hide();
+            return 1 ;
+        }
+        this.highlightDecorations.set([{
+                range: result.range,
+                options: DebugHoverWidget_1._HOVER_HIGHLIGHT_DECORATION_OPTIONS
+            }]);
+        return this.doShow(result.range.getStartPosition(), expression, focus);
+    }
+    static { this._HOVER_HIGHLIGHT_DECORATION_OPTIONS = ModelDecorationOptions.register({
+        description: 'bdebug-hover-highlight',
+        className: 'hoverHighlight'
+    }); }
+    async doShow(position, expression, focus, forceValueHover = false) {
+        if (!this.domNode) {
+            this.create();
+        }
+        this.showAtPosition = position;
+        this._isVisible = true;
+        if (!expression.hasChildren || forceValueHover) {
+            this.complexValueContainer.hidden = true;
+            this.valueContainer.hidden = false;
+            renderExpressionValue(expression, this.valueContainer, {
+                showChanged: false,
+                colorize: true
+            });
+            this.valueContainer.title = '';
+            this.editor.layoutContentWidget(this);
+            this.scrollbar.scanDomNode();
+            if (focus) {
+                this.editor.render();
+                this.valueContainer.focus();
+            }
+            return undefined;
+        }
+        this.valueContainer.hidden = true;
+        this.expressionToRender = expression;
+        this.complexValueTitle.textContent = expression.value;
+        this.complexValueTitle.title = expression.value;
+        this.editor.layoutContentWidget(this);
+        this.tree.scrollTop = 0;
+        this.tree.scrollLeft = 0;
+        this.complexValueContainer.hidden = false;
+        if (focus) {
+            this.editor.render();
+            this.tree.domFocus();
+        }
+    }
+    layoutTreeAndContainer() {
+        this.layoutTree();
+        this.editor.layoutContentWidget(this);
+    }
+    layoutTree() {
+        const scrollBarHeight = 10;
+        let maxHeightToAvoidCursorOverlay = Infinity;
+        if (this.showAtPosition) {
+            const editorTop = this.editor.getDomNode()?.offsetTop || 0;
+            const containerTop = this.treeContainer.offsetTop + editorTop;
+            const hoveredCharTop = this.editor.getTopForLineNumber(this.showAtPosition.lineNumber, true) - this.editor.getScrollTop();
+            if (containerTop < hoveredCharTop) {
+                maxHeightToAvoidCursorOverlay = hoveredCharTop + editorTop - 22;
+            }
+        }
+        const treeHeight = Math.min(Math.max(266, this.editor.getLayoutInfo().height * 0.55), this.tree.contentHeight + scrollBarHeight, maxHeightToAvoidCursorOverlay);
+        const realTreeWidth = this.tree.contentWidth;
+        const treeWidth = clamp(realTreeWidth, 400, 550);
+        this.tree.layout(treeHeight, treeWidth);
+        this.treeContainer.style.height = `${treeHeight}px`;
+        this.scrollbar.scanDomNode();
+    }
+    beforeRender() {
+        if (this.expressionToRender) {
+            const expression = this.expressionToRender;
+            this.expressionToRender = undefined;
+            this.isUpdatingTree = true;
+            this.tree.setInput(expression).finally(() => {
+                this.isUpdatingTree = false;
+            });
+        }
+        return null;
+    }
+    afterRender(positionPreference) {
+        if (positionPreference) {
+            this.positionPreference = [positionPreference];
+        }
+    }
+    hide() {
+        if (this.showCancellationSource) {
+            this.showCancellationSource.cancel();
+            this.showCancellationSource = undefined;
+        }
+        if (!this._isVisible) {
+            return;
+        }
+        if (isAncestorOfActiveElement(this.domNode)) {
+            this.editor.focus();
+        }
+        this._isVisible = false;
+        this.highlightDecorations.clear();
+        this.editor.layoutContentWidget(this);
+        this.positionPreference = [1 , 2 ];
+    }
+    getPosition() {
+        return this._isVisible ? {
+            position: this.showAtPosition,
+            preference: this.positionPreference
+        } : null;
+    }
+    dispose() {
+        this.toDispose = dispose(this.toDispose);
+    }
+};
+DebugHoverWidget = DebugHoverWidget_1 = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IMenuService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IContextMenuService))
+], DebugHoverWidget));
+class DebugHoverAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/debugHover',
+            'treeAriaLabel',
+            "Debug Hover"
+        ));
+    }
+    getAriaLabel(element) {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/debugHover',
+            { key: 'variableAriaLabel', comment: ['Do not translate placeholders. Placeholders are name and value of a variable.'] },
+            "{0}, value {1}, variables, debug",
+            element.name,
+            element.value
+        ));
+    }
+}
+class DebugHoverDataSource extends AbstractExpressionDataSource {
+    hasChildren(element) {
+        return element.hasChildren;
+    }
+    doGetChildren(element) {
+        return element.getChildren();
+    }
+}
+class DebugHoverDelegate {
+    getHeight(element) {
+        return 18;
+    }
+    getTemplateId(element) {
+        if (element instanceof VisualizedExpression) {
+            return VisualizedVariableRenderer.ID;
+        }
+        return VariablesRenderer.ID;
+    }
+}
+let DebugHoverComputer = class DebugHoverComputer {
+    constructor(editor, debugService, languageFeaturesService, logService) {
+        this.editor = editor;
+        this.debugService = debugService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.logService = logService;
+    }
+    async compute(position, token) {
+        const session = this.debugService.getViewModel().focusedSession;
+        if (!session || !this.editor.hasModel()) {
+            return { rangeChanged: false };
+        }
+        const model = this.editor.getModel();
+        const result = await getEvaluatableExpressionAtPosition(this.languageFeaturesService, model, position, token);
+        if (!result) {
+            return { rangeChanged: false };
+        }
+        const { range, matchingExpression } = result;
+        const rangeChanged = this._currentRange ?
+            !this._currentRange.equalsRange(range) :
+            true;
+        this._currentExpression = matchingExpression;
+        this._currentRange = Range.lift(range);
+        return { rangeChanged, range: this._currentRange };
+    }
+    async evaluate(session) {
+        if (!this._currentExpression) {
+            this.logService.error('No expression to evaluate');
+            return;
+        }
+        if (session.capabilities.supportsEvaluateForHovers) {
+            const expression = ( new Expression(this._currentExpression));
+            await expression.evaluate(session, this.debugService.getViewModel().focusedStackFrame, 'hover');
+            return expression;
+        }
+        else {
+            const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+            if (focusedStackFrame) {
+                return await findExpressionInStackFrame(focusedStackFrame, coalesce(( this._currentExpression.split('.').map(word => word.trim()))));
+            }
+        }
+        return undefined;
+    }
+};
+DebugHoverComputer = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, ILanguageFeaturesService)),
+    ( __param(3, ILogService))
+], DebugHoverComputer));
+export { DebugHoverWidget, findExpressionInStackFrame };

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

@@ -0,0 +1,204 @@
+import { VSBuffer } from '../../../../base/common/buffer.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { toDisposable, DisposableStore, Disposable } from '../../../../base/common/lifecycle.js';
+import { clamp } from '../../../../base/common/numbers.js';
+import { assertNever } from '../../../../base/common/assert.js';
+import { FileType, FilePermission, createFileSystemProviderError, FileSystemProviderErrorCode } from '../../../../platform/files/common/files.js';
+import { DEBUG_MEMORY_SCHEME } from '../common/debug.js';
+const rangeRe = /range=([0-9]+):([0-9]+)/;
+class DebugMemoryFileSystemProvider {
+    constructor(debugService) {
+        this.debugService = debugService;
+        this.memoryFdCounter = 0;
+        this.fdMemory = ( new Map());
+        this.changeEmitter = ( new Emitter());
+        this.onDidChangeCapabilities = Event.None;
+        this.onDidChangeFile = this.changeEmitter.event;
+        this.capabilities = 0
+            | 1024
+            | 4 ;
+        debugService.onDidEndSession(({ session }) => {
+            for (const [fd, memory] of this.fdMemory) {
+                if (memory.session === session) {
+                    this.close(fd);
+                }
+            }
+        });
+    }
+    watch(resource, opts) {
+        if (opts.recursive) {
+            return toDisposable(() => { });
+        }
+        const { session, memoryReference, offset } = this.parseUri(resource);
+        const disposable = ( new DisposableStore());
+        disposable.add(session.onDidChangeState(() => {
+            if (session.state === 3  || session.state === 0 ) {
+                this.changeEmitter.fire([{ type: 2 , resource }]);
+            }
+        }));
+        disposable.add(session.onDidInvalidateMemory(e => {
+            if (e.body.memoryReference !== memoryReference) {
+                return;
+            }
+            if (offset && (e.body.offset >= offset.toOffset || e.body.offset + e.body.count < offset.fromOffset)) {
+                return;
+            }
+            this.changeEmitter.fire([{ resource, type: 0  }]);
+        }));
+        return disposable;
+    }
+    stat(file) {
+        const { readOnly } = this.parseUri(file);
+        return Promise.resolve({
+            type: FileType.File,
+            mtime: 0,
+            ctime: 0,
+            size: 0,
+            permissions: readOnly ? FilePermission.Readonly : undefined,
+        });
+    }
+    mkdir() {
+        throw createFileSystemProviderError(`Not allowed`, FileSystemProviderErrorCode.NoPermissions);
+    }
+    readdir() {
+        throw createFileSystemProviderError(`Not allowed`, FileSystemProviderErrorCode.NoPermissions);
+    }
+    delete() {
+        throw createFileSystemProviderError(`Not allowed`, FileSystemProviderErrorCode.NoPermissions);
+    }
+    rename() {
+        throw createFileSystemProviderError(`Not allowed`, FileSystemProviderErrorCode.NoPermissions);
+    }
+    open(resource, _opts) {
+        const { session, memoryReference, offset } = this.parseUri(resource);
+        const fd = this.memoryFdCounter++;
+        let region = session.getMemory(memoryReference);
+        if (offset) {
+            region = ( new MemoryRegionView(region, offset));
+        }
+        this.fdMemory.set(fd, { session, region });
+        return Promise.resolve(fd);
+    }
+    close(fd) {
+        this.fdMemory.get(fd)?.region.dispose();
+        this.fdMemory.delete(fd);
+        return Promise.resolve();
+    }
+    async writeFile(resource, content) {
+        const { offset } = this.parseUri(resource);
+        if (!offset) {
+            throw createFileSystemProviderError(`Range must be present to read a file`, FileSystemProviderErrorCode.FileNotFound);
+        }
+        const fd = await this.open(resource, { create: false });
+        try {
+            await this.write(fd, offset.fromOffset, content, 0, content.length);
+        }
+        finally {
+            this.close(fd);
+        }
+    }
+    async readFile(resource) {
+        const { offset } = this.parseUri(resource);
+        if (!offset) {
+            throw createFileSystemProviderError(`Range must be present to read a file`, FileSystemProviderErrorCode.FileNotFound);
+        }
+        const data = ( new Uint8Array(offset.toOffset - offset.fromOffset));
+        const fd = await this.open(resource, { create: false });
+        try {
+            await this.read(fd, offset.fromOffset, data, 0, data.length);
+            return data;
+        }
+        finally {
+            this.close(fd);
+        }
+    }
+    async read(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (!memory) {
+            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+        }
+        const ranges = await memory.region.read(pos, length);
+        let readSoFar = 0;
+        for (const range of ranges) {
+            switch (range.type) {
+                case 1 :
+                    return readSoFar;
+                case 2 :
+                    if (readSoFar > 0) {
+                        return readSoFar;
+                    }
+                    else {
+                        throw createFileSystemProviderError(range.error, FileSystemProviderErrorCode.Unknown);
+                    }
+                case 0 : {
+                    const start = Math.max(0, pos - range.offset);
+                    const toWrite = range.data.slice(start, Math.min(range.data.byteLength, start + (length - readSoFar)));
+                    data.set(toWrite.buffer, offset + readSoFar);
+                    readSoFar += toWrite.byteLength;
+                    break;
+                }
+                default:
+                    assertNever();
+            }
+        }
+        return readSoFar;
+    }
+    write(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (!memory) {
+            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+        }
+        return memory.region.write(pos, VSBuffer.wrap(data).slice(offset, offset + length));
+    }
+    parseUri(uri) {
+        if (uri.scheme !== DEBUG_MEMORY_SCHEME) {
+            throw createFileSystemProviderError(`Cannot open file with scheme ${uri.scheme}`, FileSystemProviderErrorCode.FileNotFound);
+        }
+        const session = this.debugService.getModel().getSession(uri.authority);
+        if (!session) {
+            throw createFileSystemProviderError(`Debug session not found`, FileSystemProviderErrorCode.FileNotFound);
+        }
+        let offset;
+        const rangeMatch = rangeRe.exec(uri.query);
+        if (rangeMatch) {
+            offset = { fromOffset: Number(rangeMatch[1]), toOffset: Number(rangeMatch[2]) };
+        }
+        const [, memoryReference] = uri.path.split('/');
+        return {
+            session,
+            offset,
+            readOnly: !session.capabilities.supportsWriteMemoryRequest,
+            sessionId: uri.authority,
+            memoryReference: decodeURIComponent(memoryReference),
+        };
+    }
+}
+class MemoryRegionView extends Disposable {
+    constructor(parent, range) {
+        super();
+        this.parent = parent;
+        this.range = range;
+        this.invalidateEmitter = ( new Emitter());
+        this.onDidInvalidate = this.invalidateEmitter.event;
+        this.width = this.range.toOffset - this.range.fromOffset;
+        this.writable = parent.writable;
+        this._register(parent);
+        this._register(parent.onDidInvalidate(e => {
+            const fromOffset = clamp(e.fromOffset - range.fromOffset, 0, this.width);
+            const toOffset = clamp(e.toOffset - range.fromOffset, 0, this.width);
+            if (toOffset > fromOffset) {
+                this.invalidateEmitter.fire({ fromOffset, toOffset });
+            }
+        }));
+    }
+    read(fromOffset, toOffset) {
+        if (fromOffset < 0) {
+            throw new RangeError(`Invalid fromOffset: ${fromOffset}`);
+        }
+        return this.parent.read(this.range.fromOffset + fromOffset, this.range.fromOffset + Math.min(toOffset, this.width));
+    }
+    write(offset, data) {
+        return this.parent.write(this.range.fromOffset + offset, data);
+    }
+}
+export { DebugMemoryFileSystemProvider };

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

@@ -0,0 +1,78 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../../base/common/event.js';
+import { dispose } from '../../../../base/common/lifecycle.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { VIEWLET_ID, IDebugService } from '../common/debug.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+let DebugProgressContribution = class DebugProgressContribution {
+    constructor(debugService, progressService, viewsService) {
+        this.toDispose = [];
+        let progressListener;
+        const listenOnProgress = (session) => {
+            if (progressListener) {
+                progressListener.dispose();
+                progressListener = undefined;
+            }
+            if (session) {
+                progressListener = session.onDidProgressStart(async (progressStartEvent) => {
+                    const promise = ( new Promise(r => {
+                        const listener = Event.any(Event.filter(session.onDidProgressEnd, e => e.body.progressId === progressStartEvent.body.progressId), session.onDidEndAdapter)(() => {
+                            listener.dispose();
+                            r();
+                        });
+                    }));
+                    if (viewsService.isViewContainerVisible(VIEWLET_ID)) {
+                        progressService.withProgress({ location: VIEWLET_ID }, () => promise);
+                    }
+                    const source = debugService.getAdapterManager().getDebuggerLabel(session.configuration.type);
+                    progressService.withProgress({
+                        location: 15 ,
+                        title: progressStartEvent.body.title,
+                        cancellable: progressStartEvent.body.cancellable,
+                        source,
+                        delay: 500
+                    }, progressStep => {
+                        let total = 0;
+                        const reportProgress = (progress) => {
+                            let increment = undefined;
+                            if (typeof progress.percentage === 'number') {
+                                increment = progress.percentage - total;
+                                total += increment;
+                            }
+                            progressStep.report({
+                                message: progress.message,
+                                increment,
+                                total: typeof increment === 'number' ? 100 : undefined,
+                            });
+                        };
+                        if (progressStartEvent.body.message) {
+                            reportProgress(progressStartEvent.body);
+                        }
+                        const progressUpdateListener = session.onDidProgressUpdate(e => {
+                            if (e.body.progressId === progressStartEvent.body.progressId) {
+                                reportProgress(e.body);
+                            }
+                        });
+                        return promise.then(() => progressUpdateListener.dispose());
+                    }, () => session.cancel(progressStartEvent.body.progressId));
+                });
+            }
+        };
+        this.toDispose.push(debugService.getViewModel().onDidFocusSession(listenOnProgress));
+        listenOnProgress(debugService.getViewModel().focusedSession);
+        this.toDispose.push(debugService.onWillNewSession(session => {
+            if (!progressListener) {
+                listenOnProgress(session);
+            }
+        }));
+    }
+    dispose() {
+        dispose(this.toDispose);
+    }
+};
+DebugProgressContribution = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IProgressService)),
+    ( __param(2, IViewsService))
+], DebugProgressContribution));
+export { DebugProgressContribution };