@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

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

@@ -0,0 +1,317 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import * as lifecycle from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { WorkbenchAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { editorHoverBackground, asCssVariable, editorHoverBorder, editorHoverForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { renderExpressionValue } from './baseDebugView.js';
+import { LinkDetector } from './linkDetector.js';
+import { VariablesRenderer } from './variablesView.js';
+import { IDebugService } from '../common/debug.js';
+import { Variable, Expression } from '../common/debugModel.js';
+import { getEvaluatableExpressionAtPosition } from '../common/debugUtils.js';
+const $ = dom.$;
+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 {
+    constructor(editor, debugService, instantiationService) {
+        this.editor = editor;
+        this.debugService = debugService;
+        this.instantiationService = instantiationService;
+        this.allowEditorOverflow = true;
+        this.highlightDecorations = this.editor.createDecorationsCollection();
+        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 = dom.append(this.domNode, $('.complex-value'));
+        this.complexValueTitle = dom.append(this.complexValueContainer, $('.title'));
+        this.treeContainer = dom.append(this.complexValueContainer, $('.debug-hover-tree'));
+        this.treeContainer.setAttribute('role', 'tree');
+        const tip = dom.append(this.complexValueContainer, $('.tip'));
+        tip.textContent = ( nls.localize(
+            { 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 = ( new DebugHoverDataSource());
+        const linkeDetector = this.instantiationService.createInstance(LinkDetector);
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'DebugHover', this.treeContainer, ( new DebugHoverDelegate()), [this.instantiationService.createInstance(VariablesRenderer, linkeDetector)], dataSource, {
+            accessibilityProvider: ( new DebugHoverAccessibilityProvider()),
+            mouseSupport: false,
+            horizontalScrolling: true,
+            useShadows: false,
+            keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => e.name },
+            overrideStyles: {
+                listBackground: editorHoverBackground
+            }
+        });
+        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.onDidChangeContentHeight(() => this.layoutTreeAndContainer(false)));
+        this.registerListeners();
+        this.editor.addContentWidget(this);
+    }
+    registerListeners() {
+        this.toDispose.push(dom.addStandardDisposableListener(this.domNode, 'keydown', (e) => {
+            if (e.equals(9 )) {
+                this.hide();
+            }
+        }));
+        this.toDispose.push(this.editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(48 )) {
+                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.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;
+        }
+        const result = await this.debugHoverComputer.compute(position, cancellationSource.token);
+        if (this.isVisible() && !result.rangeChanged) {
+            return;
+        }
+        if (!result.range || cancellationSource.token.isCancellationRequested) {
+            this.hide();
+            return;
+        }
+        const expression = await this.debugHoverComputer.evaluate(session);
+        if (cancellationSource.token.isCancellationRequested || !expression || (expression instanceof Expression && !expression.available)) {
+            this.hide();
+            return;
+        }
+        this.highlightDecorations.set([{
+                range: result.range,
+                options: DebugHoverWidget._HOVER_HIGHLIGHT_DECORATION_OPTIONS
+            }]);
+        return this.doShow(result.range.getStartPosition(), expression, focus);
+    }
+    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;
+        await this.tree.setInput(expression);
+        this.complexValueTitle.textContent = expression.value;
+        this.complexValueTitle.title = expression.value;
+        this.layoutTreeAndContainer(true);
+        this.tree.scrollTop = 0;
+        this.tree.scrollLeft = 0;
+        this.complexValueContainer.hidden = false;
+        if (focus) {
+            this.editor.render();
+            this.tree.domFocus();
+        }
+    }
+    layoutTreeAndContainer(initialLayout) {
+        const scrollBarHeight = 10;
+        const treeHeight = Math.min(Math.max(266, this.editor.getLayoutInfo().height * 0.55), this.tree.contentHeight + scrollBarHeight);
+        this.treeContainer.style.height = `${treeHeight}px`;
+        this.tree.layout(treeHeight, initialLayout ? 400 : undefined);
+        this.editor.layoutContentWidget(this);
+        this.scrollbar.scanDomNode();
+    }
+    afterRender(positionPreference) {
+        if (positionPreference) {
+            this.positionPreference = [positionPreference];
+        }
+    }
+    hide() {
+        if (this.showCancellationSource) {
+            this.showCancellationSource.cancel();
+            this.showCancellationSource = undefined;
+        }
+        if (!this._isVisible) {
+            return;
+        }
+        if (dom.isAncestor(document.activeElement, 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 = lifecycle.dispose(this.toDispose);
+    }
+};
+DebugHoverWidget.ID = 'debug.hoverWidget';
+DebugHoverWidget._HOVER_HIGHLIGHT_DECORATION_OPTIONS = ModelDecorationOptions.register({
+    description: 'bdebug-hover-highlight',
+    className: 'hoverHighlight'
+});
+DebugHoverWidget = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, IInstantiationService))
+], DebugHoverWidget));
+class DebugHoverAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( nls.localize('treeAriaLabel', "Debug Hover"));
+    }
+    getAriaLabel(element) {
+        return ( nls.localize(
+            { 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 {
+    hasChildren(element) {
+        return element.hasChildren;
+    }
+    getChildren(element) {
+        return element.getChildren();
+    }
+}
+class DebugHoverDelegate {
+    getHeight(element) {
+        return 18;
+    }
+    getTemplateId(element) {
+        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/dist/vscode/vs/workbench/contrib/debug/browser/debugIcons.js

@@ -0,0 +1,135 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+const breakpoint = {
+    regular: ( registerIcon('debug-breakpoint', Codicon.debugBreakpoint, ( localize('debugBreakpoint', 'Icon for breakpoints.')))),
+    disabled: ( registerIcon(
+        'debug-breakpoint-disabled',
+        Codicon.debugBreakpointDisabled,
+        ( localize('debugBreakpointDisabled', 'Icon for disabled breakpoints.'))
+    )),
+    unverified: ( registerIcon(
+        'debug-breakpoint-unverified',
+        Codicon.debugBreakpointUnverified,
+        ( localize('debugBreakpointUnverified', 'Icon for unverified breakpoints.'))
+    ))
+};
+const functionBreakpoint = {
+    regular: ( registerIcon(
+        'debug-breakpoint-function',
+        Codicon.debugBreakpointFunction,
+        ( localize('debugBreakpointFunction', 'Icon for function breakpoints.'))
+    )),
+    disabled: ( registerIcon(
+        'debug-breakpoint-function-disabled',
+        Codicon.debugBreakpointFunctionDisabled,
+        ( localize(
+            'debugBreakpointFunctionDisabled',
+            'Icon for disabled function breakpoints.'
+        ))
+    )),
+    unverified: ( registerIcon(
+        'debug-breakpoint-function-unverified',
+        Codicon.debugBreakpointFunctionUnverified,
+        ( localize(
+            'debugBreakpointFunctionUnverified',
+            'Icon for unverified function breakpoints.'
+        ))
+    ))
+};
+const conditionalBreakpoint = {
+    regular: ( registerIcon(
+        'debug-breakpoint-conditional',
+        Codicon.debugBreakpointConditional,
+        ( localize('debugBreakpointConditional', 'Icon for conditional breakpoints.'))
+    )),
+    disabled: ( registerIcon(
+        'debug-breakpoint-conditional-disabled',
+        Codicon.debugBreakpointConditionalDisabled,
+        ( localize(
+            'debugBreakpointConditionalDisabled',
+            'Icon for disabled conditional breakpoints.'
+        ))
+    )),
+    unverified: ( registerIcon(
+        'debug-breakpoint-conditional-unverified',
+        Codicon.debugBreakpointConditionalUnverified,
+        ( localize(
+            'debugBreakpointConditionalUnverified',
+            'Icon for unverified conditional breakpoints.'
+        ))
+    ))
+};
+const dataBreakpoint = {
+    regular: ( registerIcon('debug-breakpoint-data', Codicon.debugBreakpointData, ( localize('debugBreakpointData', 'Icon for data breakpoints.')))),
+    disabled: ( registerIcon(
+        'debug-breakpoint-data-disabled',
+        Codicon.debugBreakpointDataDisabled,
+        ( localize('debugBreakpointDataDisabled', 'Icon for disabled data breakpoints.'))
+    )),
+    unverified: ( registerIcon(
+        'debug-breakpoint-data-unverified',
+        Codicon.debugBreakpointDataUnverified,
+        ( localize('debugBreakpointDataUnverified', 'Icon for unverified data breakpoints.'))
+    )),
+};
+const logBreakpoint = {
+    regular: ( registerIcon('debug-breakpoint-log', Codicon.debugBreakpointLog, ( localize('debugBreakpointLog', 'Icon for log breakpoints.')))),
+    disabled: ( registerIcon(
+        'debug-breakpoint-log-disabled',
+        Codicon.debugBreakpointLogDisabled,
+        ( localize('debugBreakpointLogDisabled', 'Icon for disabled log breakpoint.'))
+    )),
+    unverified: ( registerIcon(
+        'debug-breakpoint-log-unverified',
+        Codicon.debugBreakpointLogUnverified,
+        ( localize('debugBreakpointLogUnverified', 'Icon for unverified log breakpoints.'))
+    )),
+};
+const debugBreakpointHint = ( registerIcon('debug-hint', Codicon.debugHint, ( localize(
+    'debugBreakpointHint',
+    'Icon for breakpoint hints shown on hover in editor glyph margin.'
+))));
+const debugBreakpointUnsupported = ( registerIcon(
+    'debug-breakpoint-unsupported',
+    Codicon.debugBreakpointUnsupported,
+    ( localize('debugBreakpointUnsupported', 'Icon for unsupported breakpoints.'))
+));
+const allBreakpoints = [breakpoint, functionBreakpoint, conditionalBreakpoint, dataBreakpoint, logBreakpoint];
+const debugStackframe = ( registerIcon('debug-stackframe', Codicon.debugStackframe, ( localize(
+    'debugStackframe',
+    'Icon for a stackframe shown in the editor glyph margin.'
+))));
+const debugStackframeFocused = ( registerIcon('debug-stackframe-focused', Codicon.debugStackframeFocused, ( localize(
+    'debugStackframeFocused',
+    'Icon for a focused stackframe  shown in the editor glyph margin.'
+))));
+const debugGripper = ( registerIcon('debug-gripper', Codicon.gripper, ( localize('debugGripper', 'Icon for the debug bar gripper.'))));
+const debugRestartFrame = ( registerIcon('debug-restart-frame', Codicon.debugRestartFrame, ( localize('debugRestartFrame', 'Icon for the debug restart frame action.'))));
+const debugStop = ( registerIcon('debug-stop', Codicon.debugStop, ( localize('debugStop', 'Icon for the debug stop action.'))));
+const debugDisconnect = ( registerIcon('debug-disconnect', Codicon.debugDisconnect, ( localize('debugDisconnect', 'Icon for the debug disconnect action.'))));
+const debugRestart = ( registerIcon('debug-restart', Codicon.debugRestart, ( localize('debugRestart', 'Icon for the debug restart action.'))));
+const debugStepOver = ( registerIcon('debug-step-over', Codicon.debugStepOver, ( localize('debugStepOver', 'Icon for the debug step over action.'))));
+const debugStepInto = ( registerIcon('debug-step-into', Codicon.debugStepInto, ( localize('debugStepInto', 'Icon for the debug step into action.'))));
+const debugStepOut = ( registerIcon('debug-step-out', Codicon.debugStepOut, ( localize('debugStepOut', 'Icon for the debug step out action.'))));
+const debugStepBack = ( registerIcon('debug-step-back', Codicon.debugStepBack, ( localize('debugStepBack', 'Icon for the debug step back action.'))));
+const debugPause = ( registerIcon('debug-pause', Codicon.debugPause, ( localize('debugPause', 'Icon for the debug pause action.'))));
+const debugContinue = ( registerIcon('debug-continue', Codicon.debugContinue, ( localize('debugContinue', 'Icon for the debug continue action.'))));
+const debugReverseContinue = ( registerIcon('debug-reverse-continue', Codicon.debugReverseContinue, ( localize('debugReverseContinue', 'Icon for the debug reverse continue action.'))));
+const debugRun = ( registerIcon('debug-run', Codicon.run, ( localize('debugRun', 'Icon for the run or debug action.'))));
+const debugStart = ( registerIcon('debug-start', Codicon.debugStart, ( localize('debugStart', 'Icon for the debug start action.'))));
+const debugConfigure = ( registerIcon('debug-configure', Codicon.gear, ( localize('debugConfigure', 'Icon for the debug configure action.'))));
+const debugRemoveConfig = ( registerIcon('debug-remove-config', Codicon.trash, ( localize('debugRemoveConfig', 'Icon for removing debug configurations.'))));
+const watchExpressionsAddFuncBreakpoint = ( registerIcon('watch-expressions-add-function-breakpoint', Codicon.add, ( localize(
+    'watchExpressionsAddFuncBreakpoint',
+    'Icon for the add function breakpoint action in the watch view.'
+))));
+const breakpointsRemoveAll = ( registerIcon('breakpoints-remove-all', Codicon.closeAll, ( localize(
+    'breakpointsRemoveAll',
+    'Icon for the Remove All action in the breakpoints view.'
+))));
+const breakpointsActivate = ( registerIcon('breakpoints-activate', Codicon.activateBreakpoints, ( localize(
+    'breakpointsActivate',
+    'Icon for the activate action in the breakpoints view.'
+))));
+export { allBreakpoints, breakpoint, breakpointsActivate, breakpointsRemoveAll, conditionalBreakpoint, dataBreakpoint, debugBreakpointHint, debugBreakpointUnsupported, debugConfigure, debugContinue, debugDisconnect, debugGripper, debugPause, debugRemoveConfig, debugRestart, debugRestartFrame, debugReverseContinue, debugRun, debugStackframe, debugStackframeFocused, debugStart, debugStepBack, debugStepInto, debugStepOut, debugStepOver, debugStop, functionBreakpoint, logBreakpoint, watchExpressionsAddFuncBreakpoint };

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

@@ -0,0 +1,204 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { toDisposable, DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { clamp } from 'monaco-editor/esm/vs/base/common/numbers.js';
+import { assertNever } from 'monaco-editor/esm/vs/base/common/assert.js';
+import { FileType, FilePermission, createFileSystemProviderError, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/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(range);
+            }
+        }
+        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 };