@codingame/monaco-vscode-api 2.2.2 → 3.0.0

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

@@ -0,0 +1,18 @@
+import '../../../../editor/editor.api.js';
+
+interface IBaseBreakpointOptions {
+    enabled?: boolean;
+    hitCondition?: string;
+    condition?: string;
+    logMessage?: string;
+    mode?: string;
+    modeLabel?: string;
+}
+interface IInstructionBreakpointOptions extends IBaseBreakpointOptions {
+    instructionReference: string;
+    offset: number;
+    canPersist: boolean;
+    address: bigint;
+}
+
+export type { IBaseBreakpointOptions, IInstructionBreakpointOptions };

package/vscode/src/vs/workbench/contrib/debug/common/debugModel.js

@@ -238,6 +238,43 @@ function handleSetResponse(expression, response) {
         expression.indexedVariables = response.body.indexedVariables;
     }
 }
+class VisualizedExpression {
+    evaluateLazy() {
+        return Promise.resolve();
+    }
+    getChildren() {
+        return this.visualizer.getVisualizedChildren(this.treeId, this.treeItem.id);
+    }
+    getId() {
+        return this.id;
+    }
+    get name() {
+        return this.treeItem.label;
+    }
+    get value() {
+        return this.treeItem.description || '';
+    }
+    get hasChildren() {
+        return this.treeItem.collapsibleState !== 0 ;
+    }
+    constructor(visualizer, treeId, treeItem, original) {
+        this.visualizer = visualizer;
+        this.treeId = treeId;
+        this.treeItem = treeItem;
+        this.original = original;
+        this.id = generateUuid();
+    }
+    async edit(newValue) {
+        try {
+            await this.visualizer.editTreeItem(this.treeId, this.treeItem, newValue);
+            return true;
+        }
+        catch (e) {
+            this.errorMessage = e.message;
+            return false;
+        }
+    }
+}
 class Expression extends ExpressionContainer {
     static { this.DEFAULT_VALUE = ( localizeWithPath(
         'vs/workbench/contrib/debug/common/debugModel',
@@ -639,15 +676,14 @@ function toBreakpointSessionData(data, capabilities) {
     }, data);
 }
 class BaseBreakpoint extends Enablement {
-    constructor(enabled, hitCondition, condition, logMessage, id) {
-        super(enabled, id);
-        this.hitCondition = hitCondition;
-        this.condition = condition;
-        this.logMessage = logMessage;
+    constructor(id, opts) {
+        super(opts.enabled ?? true, id);
         this.sessionData = ( new Map());
-        if (enabled === undefined) {
-            this.enabled = true;
-        }
+        this.condition = opts.condition;
+        this.hitCondition = opts.hitCondition;
+        this.logMessage = opts.logMessage;
+        this.mode = opts.mode;
+        this.modeLabel = opts.modeLabel;
     }
     setSessionData(sessionId, data) {
         if (!data) {
@@ -708,26 +744,38 @@ class BaseBreakpoint extends Enablement {
         return undefined;
     }
     toJSON() {
-        const result = Object.create(null);
-        result.id = this.getId();
-        result.enabled = this.enabled;
-        result.condition = this.condition;
-        result.hitCondition = this.hitCondition;
-        result.logMessage = this.logMessage;
-        return result;
+        return {
+            id: this.getId(),
+            enabled: this.enabled,
+            condition: this.condition,
+            hitCondition: this.hitCondition,
+            logMessage: this.logMessage,
+            mode: this.mode,
+            modeLabel: this.modeLabel,
+        };
     }
 }
 class Breakpoint extends BaseBreakpoint {
-    constructor(_uri, _lineNumber, _column, enabled, condition, hitCondition, logMessage, _adapterData, textFileService, uriIdentityService, logService, id = generateUuid(), triggeredBy = undefined) {
-        super(enabled, hitCondition, condition, logMessage, id);
-        this._uri = _uri;
-        this._lineNumber = _lineNumber;
-        this._column = _column;
-        this._adapterData = _adapterData;
+    constructor(opts, textFileService, uriIdentityService, logService, id = generateUuid()) {
+        super(id, opts);
         this.textFileService = textFileService;
         this.uriIdentityService = uriIdentityService;
         this.logService = logService;
-        this.triggeredBy = triggeredBy;
+        this._uri = opts.uri;
+        this._lineNumber = opts.lineNumber;
+        this._column = opts.column;
+        this._adapterData = opts.adapterData;
+        this.triggeredBy = opts.triggeredBy;
+    }
+    toDAP() {
+        return {
+            line: this.sessionAgnosticData.lineNumber,
+            column: this.sessionAgnosticData.column,
+            condition: this.condition,
+            hitCondition: this.hitCondition,
+            logMessage: this.logMessage,
+            mode: this.mode
+        };
     }
     get originalUri() {
         return this._uri;
@@ -800,13 +848,14 @@ class Breakpoint extends BaseBreakpoint {
         }
     }
     toJSON() {
-        const result = super.toJSON();
-        result.uri = this._uri;
-        result.lineNumber = this._lineNumber;
-        result.column = this._column;
-        result.adapterData = this.adapterData;
-        result.triggeredBy = this.triggeredBy;
-        return result;
+        return {
+            ...super.toJSON(),
+            uri: this._uri,
+            lineNumber: this._lineNumber,
+            column: this._column,
+            adapterData: this.adapterData,
+            triggeredBy: this.triggeredBy,
+        };
     }
     toString() {
         return `${basenameOrAuthority(this.uri)} ${this.lineNumber}`;
@@ -834,6 +883,10 @@ class Breakpoint extends BaseBreakpoint {
         if (data.hasOwnProperty('logMessage')) {
             this.logMessage = data.logMessage;
         }
+        if (data.hasOwnProperty('mode')) {
+            this.mode = data.mode;
+            this.modeLabel = data.modeLabel;
+        }
         if (data.hasOwnProperty('triggeredBy')) {
             this.triggeredBy = data.triggeredBy;
             this.sessionsDidTrigger = undefined;
@@ -841,14 +894,22 @@ class Breakpoint extends BaseBreakpoint {
     }
 }
 class FunctionBreakpoint extends BaseBreakpoint {
-    constructor(name, enabled, hitCondition, condition, logMessage, id = generateUuid()) {
-        super(enabled, hitCondition, condition, logMessage, id);
-        this.name = name;
+    constructor(opts, id = generateUuid()) {
+        super(id, opts);
+        this.name = opts.name;
+    }
+    toDAP() {
+        return {
+            name: this.name,
+            condition: this.condition,
+            hitCondition: this.hitCondition,
+        };
     }
     toJSON() {
-        const result = super.toJSON();
-        result.name = this.name;
-        return result;
+        return {
+            ...super.toJSON(),
+            name: this.name,
+        };
     }
     get supported() {
         if (!this.data) {
@@ -861,21 +922,31 @@ class FunctionBreakpoint extends BaseBreakpoint {
     }
 }
 class DataBreakpoint extends BaseBreakpoint {
-    constructor(description, dataId, canPersist, enabled, hitCondition, condition, logMessage, accessTypes, accessType, id = generateUuid()) {
-        super(enabled, hitCondition, condition, logMessage, id);
-        this.description = description;
-        this.dataId = dataId;
-        this.canPersist = canPersist;
-        this.accessTypes = accessTypes;
-        this.accessType = accessType;
+    constructor(opts, id = generateUuid()) {
+        super(id, opts);
+        this.description = opts.description;
+        this.dataId = opts.dataId;
+        this.canPersist = opts.canPersist;
+        this.accessTypes = opts.accessTypes;
+        this.accessType = opts.accessType;
+    }
+    toDAP() {
+        return {
+            dataId: this.dataId,
+            accessType: this.accessType,
+            condition: this.condition,
+            hitCondition: this.hitCondition,
+        };
     }
     toJSON() {
-        const result = super.toJSON();
-        result.description = this.description;
-        result.dataId = this.dataId;
-        result.accessTypes = this.accessTypes;
-        result.accessType = this.accessType;
-        return result;
+        return {
+            ...super.toJSON(),
+            description: this.description,
+            dataId: this.dataId,
+            accessTypes: this.accessTypes,
+            accessType: this.accessType,
+            canPersist: this.canPersist,
+        };
     }
     get supported() {
         if (!this.data) {
@@ -888,27 +959,29 @@ class DataBreakpoint extends BaseBreakpoint {
     }
 }
 class ExceptionBreakpoint extends BaseBreakpoint {
-    constructor(filter, label, enabled, supportsCondition, condition, description, conditionDescription, fallback = false) {
-        super(enabled, undefined, condition, undefined, generateUuid());
-        this.filter = filter;
-        this.label = label;
-        this.supportsCondition = supportsCondition;
-        this.description = description;
-        this.conditionDescription = conditionDescription;
-        this.fallback = fallback;
+    constructor(opts, id = generateUuid()) {
+        super(id, opts);
         this.supportedSessions = ( new Set());
+        this.fallback = false;
+        this.filter = opts.filter;
+        this.label = opts.label;
+        this.supportsCondition = opts.supportsCondition;
+        this.description = opts.description;
+        this.conditionDescription = opts.conditionDescription;
+        this.fallback = opts.fallback || false;
     }
     toJSON() {
-        const result = Object.create(null);
-        result.filter = this.filter;
-        result.label = this.label;
-        result.enabled = this.enabled;
-        result.supportsCondition = this.supportsCondition;
-        result.conditionDescription = this.conditionDescription;
-        result.condition = this.condition;
-        result.fallback = this.fallback;
-        result.description = this.description;
-        return result;
+        return {
+            ...super.toJSON(),
+            filter: this.filter,
+            label: this.label,
+            enabled: this.enabled,
+            supportsCondition: this.supportsCondition,
+            conditionDescription: this.conditionDescription,
+            condition: this.condition,
+            fallback: this.fallback,
+            description: this.description,
+        };
     }
     setSupportedSession(sessionId, supported) {
         if (supported) {
@@ -928,25 +1001,41 @@ class ExceptionBreakpoint extends BaseBreakpoint {
         return sessionId ? ( this.supportedSessions.has(sessionId)) : this.fallback;
     }
     matches(filter) {
-        return this.filter === filter.filter && this.label === filter.label && this.supportsCondition === !!filter.supportsCondition && this.conditionDescription === filter.conditionDescription && this.description === filter.description;
+        return this.filter === filter.filter
+            && this.label === filter.label
+            && this.supportsCondition === !!filter.supportsCondition
+            && this.conditionDescription === filter.conditionDescription
+            && this.description === filter.description;
     }
     toString() {
         return this.label;
     }
 }
 class InstructionBreakpoint extends BaseBreakpoint {
-    constructor(instructionReference, offset, canPersist, enabled, hitCondition, condition, logMessage, address, id = generateUuid()) {
-        super(enabled, hitCondition, condition, logMessage, id);
-        this.instructionReference = instructionReference;
-        this.offset = offset;
-        this.canPersist = canPersist;
-        this.address = address;
+    constructor(opts, id = generateUuid()) {
+        super(id, opts);
+        this.instructionReference = opts.instructionReference;
+        this.offset = opts.offset;
+        this.canPersist = opts.canPersist;
+        this.address = opts.address;
+    }
+    toDAP() {
+        return {
+            instructionReference: this.instructionReference,
+            condition: this.condition,
+            hitCondition: this.hitCondition,
+            mode: this.mode,
+            offset: this.offset,
+        };
     }
     toJSON() {
-        const result = super.toJSON();
-        result.instructionReference = this.instructionReference;
-        result.offset = this.offset;
-        return result;
+        return {
+            ...super.toJSON(),
+            instructionReference: this.instructionReference,
+            offset: this.offset,
+            canPersist: this.canPersist,
+            address: this.address,
+        };
     }
     get supported() {
         if (!this.data) {
@@ -978,6 +1067,7 @@ let DebugModel = class DebugModel extends Disposable {
         this._onDidChangeBreakpoints = this._register(( new Emitter()));
         this._onDidChangeCallStack = this._register(( new Emitter()));
         this._onDidChangeWatchExpressions = this._register(( new Emitter()));
+        this._breakpointModes = ( new Map());
         this._register(autorun(reader => {
             this.breakpoints = debugStorage.breakpoints.read(reader);
             this.functionBreakpoints = debugStorage.functionBreakpoints.read(reader);
@@ -1154,29 +1244,29 @@ let DebugModel = class DebugModel extends Disposable {
     getInstructionBreakpoints() {
         return this.instructionBreakpoints;
     }
-    setExceptionBreakpointsForSession(sessionId, data) {
-        if (data) {
-            let didChangeBreakpoints = false;
-            data.forEach(d => {
-                let ebp = this.exceptionBreakpoints.filter((exbp) => exbp.matches(d)).pop();
-                if (!ebp) {
-                    didChangeBreakpoints = true;
-                    ebp = ( new ExceptionBreakpoint(
-                        d.filter,
-                        d.label,
-                        !!d.default,
-                        !!d.supportsCondition,
-                        undefined ,
-                        d.description,
-                        d.conditionDescription
-                    ));
-                    this.exceptionBreakpoints.push(ebp);
-                }
-                ebp.setSupportedSession(sessionId, true);
-            });
-            if (didChangeBreakpoints) {
-                this._onDidChangeBreakpoints.fire(undefined);
+    setExceptionBreakpointsForSession(sessionId, filters) {
+        if (!filters) {
+            return;
+        }
+        let didChangeBreakpoints = false;
+        filters.forEach((d) => {
+            let ebp = this.exceptionBreakpoints.filter((exbp) => exbp.matches(d)).pop();
+            if (!ebp) {
+                didChangeBreakpoints = true;
+                ebp = ( new ExceptionBreakpoint({
+                    filter: d.filter,
+                    label: d.label,
+                    enabled: !!d.default,
+                    supportsCondition: !!d.supportsCondition,
+                    description: d.description,
+                    conditionDescription: d.conditionDescription,
+                }));
+                this.exceptionBreakpoints.push(ebp);
             }
+            ebp.setSupportedSession(sessionId, true);
+        });
+        if (didChangeBreakpoints) {
+            this._onDidChangeBreakpoints.fire(undefined);
         }
     }
     removeExceptionBreakpointsForSession(sessionId) {
@@ -1198,21 +1288,19 @@ let DebugModel = class DebugModel extends Disposable {
     }
     addBreakpoints(uri, rawData, fireEvent = true) {
         const newBreakpoints = ( rawData.map(rawBp => {
-            return ( new Breakpoint(
+            return ( new Breakpoint({
                 uri,
-                rawBp.lineNumber,
-                rawBp.column,
-                rawBp.enabled === false ? false : true,
-                rawBp.condition,
-                rawBp.hitCondition,
-                rawBp.logMessage,
-                undefined,
-                this.textFileService,
-                this.uriIdentityService,
-                this.logService,
-                rawBp.id,
-                rawBp.triggeredBy
-            ));
+                lineNumber: rawBp.lineNumber,
+                column: rawBp.column,
+                enabled: rawBp.enabled ?? true,
+                condition: rawBp.condition,
+                hitCondition: rawBp.hitCondition,
+                logMessage: rawBp.logMessage,
+                triggeredBy: rawBp.triggeredBy,
+                adapterData: undefined,
+                mode: rawBp.mode,
+                modeLabel: rawBp.modeLabel,
+            }, this.textFileService, this.uriIdentityService, this.logService, rawBp.id));
         }));
         this.breakpoints = this.breakpoints.concat(newBreakpoints);
         this.breakpointsActivated = true;
@@ -1305,6 +1393,35 @@ let DebugModel = class DebugModel extends Disposable {
         }
         return undefined;
     }
+    getBreakpointModes(forBreakpointType) {
+        return [...( this._breakpointModes.values())].filter(mode => mode.appliesTo.includes(forBreakpointType));
+    }
+    registerBreakpointModes(debugType, modes) {
+        for (const mode of modes) {
+            const key = `${mode.mode}/${mode.label}`;
+            const rec = this._breakpointModes.get(key);
+            if (rec) {
+                for (const target of mode.appliesTo) {
+                    if (!rec.appliesTo.includes(target)) {
+                        rec.appliesTo.push(target);
+                    }
+                }
+            }
+            else {
+                const duplicate = [...( this._breakpointModes.values())].find(r => r !== rec && r.label === mode.label);
+                if (duplicate) {
+                    duplicate.label = `${duplicate.label} (${duplicate.firstFromDebugType})`;
+                }
+                this._breakpointModes.set(key, {
+                    mode: mode.mode,
+                    label: duplicate ? `${mode.label} (${debugType})` : mode.label,
+                    firstFromDebugType: debugType,
+                    description: mode.description,
+                    appliesTo: mode.appliesTo.slice(),
+                });
+            }
+        }
+    }
     sortAndDeDup() {
         this.breakpoints = this.breakpoints.sort((first, second) => {
             if (( first.uri.toString()) !== ( second.uri.toString())) {
@@ -1364,8 +1481,8 @@ let DebugModel = class DebugModel extends Disposable {
         }
         this._onDidChangeBreakpoints.fire({ changed: changed, sessionOnly: false });
     }
-    addFunctionBreakpoint(functionName, id) {
-        const newFunctionBreakpoint = ( new FunctionBreakpoint(functionName, true, undefined, undefined, undefined, id));
+    addFunctionBreakpoint(functionName, id, mode) {
+        const newFunctionBreakpoint = ( new FunctionBreakpoint({ name: functionName, mode }, id));
         this.functionBreakpoints.push(newFunctionBreakpoint);
         this._onDidChangeBreakpoints.fire({ added: [newFunctionBreakpoint], sessionOnly: false });
         return newFunctionBreakpoint;
@@ -1397,19 +1514,8 @@ let DebugModel = class DebugModel extends Disposable {
         }
         this._onDidChangeBreakpoints.fire({ removed, sessionOnly: false });
     }
-    addDataBreakpoint(label, dataId, canPersist, accessTypes, accessType, id) {
-        const newDataBreakpoint = ( new DataBreakpoint(
-            label,
-            dataId,
-            canPersist,
-            true,
-            undefined,
-            undefined,
-            undefined,
-            accessTypes,
-            accessType,
-            id
-        ));
+    addDataBreakpoint(opts, id) {
+        const newDataBreakpoint = ( new DataBreakpoint(opts, id));
         this.dataBreakpoints.push(newDataBreakpoint);
         this._onDidChangeBreakpoints.fire({ added: [newDataBreakpoint], sessionOnly: false });
     }
@@ -1437,17 +1543,8 @@ let DebugModel = class DebugModel extends Disposable {
         }
         this._onDidChangeBreakpoints.fire({ removed, sessionOnly: false });
     }
-    addInstructionBreakpoint(instructionReference, offset, address, condition, hitCondition) {
-        const newInstructionBreakpoint = ( new InstructionBreakpoint(
-            instructionReference,
-            offset,
-            false,
-            true,
-            hitCondition,
-            condition,
-            undefined,
-            address
-        ));
+    addInstructionBreakpoint(opts) {
+        const newInstructionBreakpoint = ( new InstructionBreakpoint(opts));
         this.instructionBreakpoints.push(newInstructionBreakpoint);
         this._onDidChangeBreakpoints.fire({ added: [newInstructionBreakpoint], sessionOnly: true });
     }
@@ -1511,4 +1608,4 @@ DebugModel = ( __decorate([
     ( __param(2, IUriIdentityService)),
     ( __param(3, ILogService))
 ], DebugModel));
-export { BaseBreakpoint, Breakpoint, DataBreakpoint, DebugModel, Enablement, ErrorScope, ExceptionBreakpoint, Expression, ExpressionContainer, FunctionBreakpoint, InstructionBreakpoint, MemoryRegion, Scope, StackFrame, Thread, ThreadAndSessionIds, Variable, getUriForDebugMemory };
+export { BaseBreakpoint, Breakpoint, DataBreakpoint, DebugModel, Enablement, ErrorScope, ExceptionBreakpoint, Expression, ExpressionContainer, FunctionBreakpoint, InstructionBreakpoint, MemoryRegion, Scope, StackFrame, Thread, ThreadAndSessionIds, Variable, VisualizedExpression, getUriForDebugMemory };

package/vscode/src/vs/workbench/contrib/debug/common/debugVisualizers.js

@@ -7,7 +7,7 @@ import { createDecorator } from '../../../../platform/instantiation/common/insta
 import { ILogService } from '../../../../platform/log/common/log.js';
 import { CONTEXT_VARIABLE_NAME, CONTEXT_VARIABLE_VALUE, CONTEXT_VARIABLE_TYPE } from './debug.js';
 import { getContextForVariable } from './debugContext.js';
-import { Variable, Scope } from './debugModel.js';
+import { Variable, VisualizedExpression, Scope } from './debugModel.js';
 import { IExtensionService } from '../../../services/extensions/common/extensions.js';
 import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
 const IDebugVisualizerService = ( createDecorator('debugVisualizerService'));
@@ -32,12 +32,14 @@ class DebugVisualizer {
         await this.handle.executeDebugVisualizerCommand(this.viz.id);
     }
 }
+const emptyRef = { object: [], dispose: () => { } };
 let DebugVisualizerService = class DebugVisualizerService {
     constructor(contextKeyService, extensionService, logService) {
         this.contextKeyService = contextKeyService;
         this.extensionService = extensionService;
         this.logService = logService;
         this.handles = ( new Map());
+        this.trees = ( new Map());
         this.didActivate = ( new Map());
         this.registrations = [];
         visualizersExtensionPoint.setHandler((_, { added, removed }) => {
@@ -46,31 +48,14 @@ let DebugVisualizerService = class DebugVisualizerService {
         });
     }
     async getApplicableFor(variable, token) {
+        if (!(variable instanceof Variable)) {
+            return emptyRef;
+        }
         const threadId = variable.getThreadId();
         if (threadId === undefined) {
-            return { object: [], dispose: () => { } };
-        }
-        const context = {
-            sessionId: variable.getSession()?.getId() || '',
-            containerId: variable.parent.getId(),
-            threadId,
-            variable: {
-                name: variable.name,
-                value: variable.value,
-                type: variable.type,
-                evaluateName: variable.evaluateName,
-                variablesReference: variable.reference || 0,
-                indexedVariables: variable.indexedVariables,
-                memoryReference: variable.memoryReference,
-                namedVariables: variable.namedVariables,
-                presentationHint: variable.presentationHint,
-            }
-        };
-        for (let p = variable; p instanceof Variable; p = p.parent) {
-            if (p.parent instanceof Scope) {
-                context.frameId = p.parent.stackFrame.frameId;
-            }
+            return emptyRef;
         }
+        const context = this.getVariableContext(threadId, variable);
         const overlay = getContextForVariable(this.contextKeyService, variable, [
             [CONTEXT_VARIABLE_NAME.key, variable.name],
             [CONTEXT_VARIABLE_VALUE.key, variable.value],
@@ -110,6 +95,68 @@ let DebugVisualizerService = class DebugVisualizerService {
         this.handles.set(key, handle);
         return toDisposable(() => this.handles.delete(key));
     }
+    registerTree(treeId, handle) {
+        this.trees.set(treeId, handle);
+        return toDisposable(() => this.trees.delete(treeId));
+    }
+    async getVisualizedNodeFor(treeId, expr) {
+        if (!(expr instanceof Variable)) {
+            return;
+        }
+        const threadId = expr.getThreadId();
+        if (threadId === undefined) {
+            return;
+        }
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return;
+        }
+        try {
+            const treeItem = await tree.getTreeItem(this.getVariableContext(threadId, expr));
+            if (!treeItem) {
+                return;
+            }
+            return ( new VisualizedExpression(this, treeId, treeItem, expr));
+        }
+        catch (e) {
+            this.logService.warn('Failed to get visualized node', e);
+            return;
+        }
+    }
+    async getVisualizedChildren(treeId, treeElementId) {
+        const children = (await this.trees.get(treeId)?.getChildren(treeElementId)) || [];
+        return ( children.map(c => ( new VisualizedExpression(this, treeId, c, undefined))));
+    }
+    async editTreeItem(treeId, treeItem, newValue) {
+        const newItem = await this.trees.get(treeId)?.editItem?.(treeItem.id, newValue);
+        if (newItem) {
+            Object.assign(treeItem, newItem);
+        }
+    }
+    getVariableContext(threadId, variable) {
+        const context = {
+            sessionId: variable.getSession()?.getId() || '',
+            containerId: (variable.parent instanceof Variable ? variable.reference : undefined),
+            threadId,
+            variable: {
+                name: variable.name,
+                value: variable.value,
+                type: variable.type,
+                evaluateName: variable.evaluateName,
+                variablesReference: variable.reference || 0,
+                indexedVariables: variable.indexedVariables,
+                memoryReference: variable.memoryReference,
+                namedVariables: variable.namedVariables,
+                presentationHint: variable.presentationHint,
+            }
+        };
+        for (let p = variable; p instanceof Variable; p = p.parent) {
+            if (p.parent instanceof Scope) {
+                context.frameId = p.parent.stackFrame.frameId;
+            }
+        }
+        return context;
+    }
     processExtensionRegistration(ext) {
         const viz = ext.contributes?.debugVisualizers;
         if (!(viz instanceof Array)) {
@@ -134,7 +181,7 @@ DebugVisualizerService = ( __decorate([
     ( __param(2, ILogService))
 ], DebugVisualizerService));
 const toKey = (extensionId, id) => `${ExtensionIdentifier.toKey(extensionId)}\0${id}`;
-const visualizersExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const visualizersExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'debugVisualizers',
     jsonSchema: {
         type: 'array',
@@ -160,5 +207,5 @@ const visualizersExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
             }
         }
     }
-}));
+});
 export { DebugVisualizer, DebugVisualizerService, IDebugVisualizerService };