@codingame/monaco-vscode-debug-service-override 4.5.1 → 5.0.0

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

@@ -26,7 +26,7 @@ import { InjectedTextCursorStops } from 'vscode/vscode/vs/editor/common/model';
 import { ILanguageFeatureDebounceService } from 'vscode/vscode/vs/editor/common/services/languageFeatureDebounce';
 import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
 import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { HoverController } from 'vscode/vscode/vs/editor/contrib/hover/browser/hover';
+import { HoverController } from 'vscode/vscode/vs/editor/contrib/hover/browser/hoverController';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
@@ -52,6 +52,7 @@ import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/d
 import { Expression } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
 
+const _moduleId = "vs/workbench/contrib/debug/browser/debugEditorContribution";
 const MAX_NUM_INLINE_VALUES = 100;
 const MAX_INLINE_DECORATOR_LENGTH = 150;
 const MAX_TOKENIZATION_LINE_LEN = 500;
@@ -61,21 +62,13 @@ registerColor('editor.inlineValuesForeground', {
     light: '#00000080',
     hcDark: '#ffffff80',
     hcLight: '#00000080'
-}, ( localizeWithPath(
-    'vs/workbench/contrib/debug/browser/debugEditorContribution',
-    'editor.inlineValuesForeground',
-    "Color for the debug inline value text."
-)));
+}, ( localizeWithPath(_moduleId, 0, "Color for the debug inline value text.")));
 registerColor('editor.inlineValuesBackground', {
     dark: '#ffc80033',
     light: '#ffc80033',
     hcDark: '#ffc80033',
     hcLight: '#ffc80033'
-}, ( localizeWithPath(
-    'vs/workbench/contrib/debug/browser/debugEditorContribution',
-    'editor.inlineValuesBackground',
-    "Color for the debug inline value background."
-)));
+}, ( localizeWithPath(_moduleId, 1, "Color for the debug inline value background.")));
 class InlineSegment {
     constructor(column, text) {
         this.column = column;
@@ -127,20 +120,20 @@ function replaceWsWithNoBreakWs(str) {
     return str.replace(/[ \t]/g, noBreakWhitespace);
 }
 function createInlineValueDecorationsInsideRange(expressions, ranges, model, wordToLineNumbersMap) {
-    const nameValueMap = ( new Map());
+    const nameValueMap = ( (new Map()));
     for (const expr of expressions) {
         nameValueMap.set(expr.name, expr.value);
         if (nameValueMap.size >= MAX_NUM_INLINE_VALUES) {
             break;
         }
     }
-    const lineToNamesMap = ( new Map());
+    const lineToNamesMap = ( (new Map()));
     nameValueMap.forEach((_value, name) => {
         const lineNumbers = wordToLineNumbersMap.get(name);
         if (lineNumbers) {
             for (const lineNumber of lineNumbers) {
-                if (( ranges.some(r => lineNumber >= r.startLineNumber && lineNumber <= r.endLineNumber))) {
-                    if (!( lineToNamesMap.has(lineNumber))) {
+                if (( (ranges.some(r => lineNumber >= r.startLineNumber && lineNumber <= r.endLineNumber)))) {
+                    if (!( (lineToNamesMap.has(lineNumber)))) {
                         lineToNamesMap.set(lineNumber, []);
                     }
                     if (lineToNamesMap.get(lineNumber).indexOf(name) === -1) {
@@ -152,10 +145,10 @@ function createInlineValueDecorationsInsideRange(expressions, ranges, model, wor
     });
     const decorations = [];
     lineToNamesMap.forEach((names, line) => {
-        const contentText = ( names.sort((first, second) => {
+        const contentText = ( (names.sort((first, second) => {
             const content = model.getLineContent(line);
             return content.indexOf(first) - content.indexOf(second);
-        }).map(name => `${name} = ${nameValueMap.get(name)}`)).join(', ');
+        }).map(name => `${name} = ${nameValueMap.get(name)}`))).join(', ');
         decorations.push(...createInlineValueDecoration(line, contentText));
     });
     return decorations;
@@ -178,7 +171,7 @@ function getWordToLineNumbersMap(model, lineNumber, result) {
             const wordMatch = DEFAULT_WORD_REGEXP.exec(tokenStr);
             if (wordMatch) {
                 const word = wordMatch[0];
-                if (!( result.has(word))) {
+                if (!( (result.has(word)))) {
                     result.set(word, []);
                 }
                 result.get(word).push(lineNumber);
@@ -199,11 +192,11 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.hoverPosition = null;
         this.mouseDown = false;
         this.gutterIsHovered = false;
-        this.altListener = ( new MutableDisposable());
+        this.altListener = ( (new MutableDisposable()));
         this.altPressed = false;
         this.oldDecorations = this.editor.createDecorationsCollection();
-        this.displayedStore = ( new DisposableStore());
-        this.defaultHoverLockout = ( new MutableDisposable());
+        this.displayedStore = ( (new DisposableStore()));
+        this.defaultHoverLockout = ( (new MutableDisposable()));
         this.debounceInfo = featureDebounceService.for(languageFeaturesService.inlineValuesProvider, 'InlineValues', { min: DEAFULT_INLINE_DEBOUNCE_DELAY });
         this.hoverWidget = this.instantiationService.createInstance(DebugHoverWidget, this.editor);
         this.toDispose = [this.defaultHoverLockout, this.altListener, this.displayedStore];
@@ -244,7 +237,7 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.toDispose.push(this.editor.onDidScrollChange(() => {
             this.hideHoverWidget();
             const model = this.editor.getModel();
-            if (model && ( this.languageFeaturesService.inlineValuesProvider.has(model))) {
+            if (model && ( (this.languageFeaturesService.inlineValuesProvider.has(model)))) {
                 this.updateInlineValuesScheduler.schedule();
             }
         }));
@@ -283,7 +276,7 @@ let DebugEditorContribution = class DebugEditorContribution {
         }
         const ownerDocument = this.editor.getContainerDomNode().ownerDocument;
         this.altListener.value = addDisposableListener(ownerDocument, 'keydown', keydownEvent => {
-            const standardKeyboardEvent = ( new StandardKeyboardEvent(keydownEvent));
+            const standardKeyboardEvent = ( (new StandardKeyboardEvent(keydownEvent)));
             if (standardKeyboardEvent.keyCode === 6 ) {
                 this.altPressed = true;
                 const debugHoverWasVisible = this.hoverWidget.isVisible();
@@ -292,11 +285,11 @@ let DebugEditorContribution = class DebugEditorContribution {
                 if (debugHoverWasVisible && this.hoverPosition) {
                     this.showEditorHover(this.hoverPosition, false);
                 }
-                const onKeyUp = ( new DomEmitter(ownerDocument, 'keyup'));
+                const onKeyUp = ( (new DomEmitter(ownerDocument, 'keyup')));
                 const listener = Event.any(this.hostService.onDidChangeFocus, onKeyUp.event)(keyupEvent => {
                     let standardKeyboardEvent = undefined;
                     if (isKeyboardEvent(keyupEvent)) {
-                        standardKeyboardEvent = ( new StandardKeyboardEvent(keyupEvent));
+                        standardKeyboardEvent = ( (new StandardKeyboardEvent(keyupEvent)));
                     }
                     if (!standardKeyboardEvent || standardKeyboardEvent.keyCode === 6 ) {
                         this.altPressed = false;
@@ -339,7 +332,7 @@ let DebugEditorContribution = class DebugEditorContribution {
     }
     showEditorHover(position, focus) {
         const hoverController = this.editor.getContribution(HoverController.ID);
-        const range = ( new Range(position.lineNumber, position.column, position.lineNumber, position.column));
+        const range = ( (new Range(position.lineNumber, position.column, position.lineNumber, position.column)));
         this.defaultHoverLockout.clear();
         hoverController?.showContentHover(range, 1 , 0 , focus);
     }
@@ -362,11 +355,11 @@ let DebugEditorContribution = class DebugEditorContribution {
         return baseDelay * delayFactor;
     }
     get showHoverScheduler() {
-        const scheduler = ( new RunOnceScheduler(() => {
+        const scheduler = ( (new RunOnceScheduler(() => {
             if (this.hoverPosition && !this.altPressed) {
                 this.showHover(this.hoverPosition, false);
             }
-        }, this.hoverDelay));
+        }, this.hoverDelay)));
         this.toDispose.push(scheduler);
         return scheduler;
     }
@@ -506,12 +499,12 @@ let DebugEditorContribution = class DebugEditorContribution {
                 setProperty(model.getValue(), ['launch'], { 'configurations': [] }, { tabSize, insertSpaces, eol })[0];
             const startPosition = model.getPositionAt(edit.offset);
             const lineNumber = startPosition.lineNumber;
-            const range = ( new Range(
+            const range = ( (new Range(
                 lineNumber,
                 startPosition.column,
                 lineNumber,
                 model.getLineMaxColumn(lineNumber)
-            ));
+            )));
             model.pushEditOperations(null, [EditOperation.replace(range, edit.content)], () => null);
             getConfigurationPosition();
         }
@@ -531,24 +524,28 @@ let DebugEditorContribution = class DebugEditorContribution {
         await this.commandService.executeCommand('editor.action.triggerSuggest');
     }
     get removeInlineValuesScheduler() {
-        return ( new RunOnceScheduler(() => {
-            this.displayedStore.clear();
-        }, 100));
+        return (
+             (new RunOnceScheduler(() => {
+                this.displayedStore.clear();
+            }, 100))
+        );
     }
     get updateInlineValuesScheduler() {
         const model = this.editor.getModel();
-        return ( new RunOnceScheduler(
-            async () => await this.updateInlineValueDecorations(this.debugService.getViewModel().focusedStackFrame),
-            model ? this.debounceInfo.get(model) : DEAFULT_INLINE_DEBOUNCE_DELAY
-        ));
+        return (
+             (new RunOnceScheduler(
+                async () => await this.updateInlineValueDecorations(this.debugService.getViewModel().focusedStackFrame),
+                model ? this.debounceInfo.get(model) : DEAFULT_INLINE_DEBOUNCE_DELAY
+            ))
+        );
     }
     async updateInlineValueDecorations(stackFrame) {
         const var_value_format = '{0} = {1}';
         const separator = ', ';
         const model = this.editor.getModel();
         const inlineValuesSetting = this.configurationService.getValue('debug').inlineValues;
-        const inlineValuesTurnedOn = inlineValuesSetting === true || inlineValuesSetting === 'on' || (inlineValuesSetting === 'auto' && model && ( this.languageFeaturesService.inlineValuesProvider.has(model)));
-        if (!inlineValuesTurnedOn || !model || !stackFrame || ( model.uri.toString()) !== ( stackFrame.source.uri.toString())) {
+        const inlineValuesTurnedOn = inlineValuesSetting === true || inlineValuesSetting === 'on' || (inlineValuesSetting === 'auto' && model && ( (this.languageFeaturesService.inlineValuesProvider.has(model))));
+        if (!inlineValuesTurnedOn || !model || !stackFrame || ( (model.uri.toString())) !== ( (stackFrame.source.uri.toString()))) {
             if (!this.removeInlineValuesScheduler.isScheduled()) {
                 this.removeInlineValuesScheduler.schedule();
             }
@@ -558,9 +555,9 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.displayedStore.clear();
         const viewRanges = this.editor.getVisibleRangesPlusViewportAboveBelow();
         let allDecorations;
-        const cts = ( new CancellationTokenSource());
+        const cts = ( (new CancellationTokenSource()));
         this.displayedStore.add(toDisposable(() => cts.dispose(true)));
-        if (( this.languageFeaturesService.inlineValuesProvider.has(model))) {
+        if (( (this.languageFeaturesService.inlineValuesProvider.has(model)))) {
             const findVariable = async (_key, caseSensitiveLookup) => {
                 const scopes = await stackFrame.getMostSpecificScopes(stackFrame.range);
                 const key = caseSensitiveLookup ? _key : _key.toLowerCase();
@@ -575,17 +572,17 @@ let DebugEditorContribution = class DebugEditorContribution {
             };
             const ctx = {
                 frameId: stackFrame.frameId,
-                stoppedLocation: ( new Range(
+                stoppedLocation: ( (new Range(
                     stackFrame.range.startLineNumber,
                     stackFrame.range.startColumn + 1,
                     stackFrame.range.endLineNumber,
                     stackFrame.range.endColumn + 1
-                ))
+                )))
             };
             const providers = this.languageFeaturesService.inlineValuesProvider.ordered(model).reverse();
             allDecorations = [];
-            const lineDecorations = ( new Map());
-            const promises = providers.flatMap(provider => ( viewRanges.map(
+            const lineDecorations = ( (new Map()));
+            const promises = providers.flatMap(provider => ( (viewRanges.map(
                 range => Promise.resolve(provider.provideInlineValues(model, range, ctx, cts.token)).then(async (result) => {
                     if (result) {
                         for (const iv of result) {
@@ -613,7 +610,7 @@ let DebugEditorContribution = class DebugEditorContribution {
                                         expr = lineContent.substring(iv.range.startColumn - 1, iv.range.endColumn - 1);
                                     }
                                     if (expr) {
-                                        const expression = ( new Expression(expr));
+                                        const expression = ( (new Expression(expr)));
                                         await expression.evaluate(stackFrame.thread.session, stackFrame, 'watch', true);
                                         if (expression.available) {
                                             text = format(var_value_format, expr, expression.value);
@@ -629,8 +626,8 @@ let DebugEditorContribution = class DebugEditorContribution {
                                     lineSegments = [];
                                     lineDecorations.set(line, lineSegments);
                                 }
-                                if (!( lineSegments.some(iv => iv.text === text))) {
-                                    lineSegments.push(( new InlineSegment(iv.range.startColumn, text)));
+                                if (!( (lineSegments.some(iv => iv.text === text)))) {
+                                    lineSegments.push(( (new InlineSegment(iv.range.startColumn, text))));
                                 }
                             }
                         }
@@ -638,33 +635,33 @@ let DebugEditorContribution = class DebugEditorContribution {
                 }, err => {
                     onUnexpectedExternalError(err);
                 })
-            )));
+            ))));
             const startTime = Date.now();
             await Promise.all(promises);
             this.updateInlineValuesScheduler.delay = this.debounceInfo.update(model, Date.now() - startTime);
             lineDecorations.forEach((segments, line) => {
                 if (segments.length > 0) {
                     segments = segments.sort((a, b) => a.column - b.column);
-                    const text = ( segments.map(s => s.text)).join(separator);
+                    const text = ( (segments.map(s => s.text))).join(separator);
                     allDecorations.push(...createInlineValueDecoration(line, text));
                 }
             });
         }
         else {
             const scopes = await stackFrame.getMostSpecificScopes(stackFrame.range);
-            const decorationsPerScope = await Promise.all(( scopes.map(async (scope) => {
+            const decorationsPerScope = await Promise.all(( (scopes.map(async (scope) => {
                 const variables = await scope.getChildren();
-                let scopeRange = ( new Range(0, 0, stackFrame.range.startLineNumber, stackFrame.range.startColumn));
+                let scopeRange = ( (new Range(0, 0, stackFrame.range.startLineNumber, stackFrame.range.startColumn)));
                 if (scope.range) {
                     scopeRange = scopeRange.setStartPosition(scope.range.startLineNumber, scope.range.startColumn);
                 }
-                const ownRanges = ( viewRanges.map(r => r.intersectRanges(scopeRange))).filter(isDefined);
-                this._wordToLineNumbersMap ??= ( new WordsToLineNumbersCache(model));
+                const ownRanges = ( (viewRanges.map(r => r.intersectRanges(scopeRange)))).filter(isDefined);
+                this._wordToLineNumbersMap ??= ( (new WordsToLineNumbersCache(model)));
                 for (const range of ownRanges) {
                     this._wordToLineNumbersMap.ensureRangePopulated(range);
                 }
                 return createInlineValueDecorationsInsideRange(variables, ownRanges, model, this._wordToLineNumbersMap.value);
-            })));
+            }))));
             allDecorations = distinct(decorationsPerScope.flat(),
             decoration => `${decoration.range.startLineNumber}:${decoration?.options.after?.content}`);
         }
@@ -683,31 +680,31 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.toDispose = dispose(this.toDispose);
     }
 };
-DebugEditorContribution.__decorator = ( __decorate([
+DebugEditorContribution.__decorator = ( (__decorate([
     memoize
-], DebugEditorContribution.prototype, "showHoverScheduler", null));
-DebugEditorContribution.__decorator = ( __decorate([
+], DebugEditorContribution.prototype, "showHoverScheduler", null)));
+DebugEditorContribution.__decorator = ( (__decorate([
     memoize
-], DebugEditorContribution.prototype, "removeInlineValuesScheduler", null));
-DebugEditorContribution.__decorator = ( __decorate([
+], DebugEditorContribution.prototype, "removeInlineValuesScheduler", null)));
+DebugEditorContribution.__decorator = ( (__decorate([
     memoize
-], DebugEditorContribution.prototype, "updateInlineValuesScheduler", null));
-DebugEditorContribution = ( __decorate([
-    ( __param(1, IDebugService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ICommandService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IHostService)),
-    ( __param(6, IUriIdentityService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, ILanguageFeaturesService)),
-    ( __param(9, ILanguageFeatureDebounceService))
-], DebugEditorContribution));
+], DebugEditorContribution.prototype, "updateInlineValuesScheduler", null)));
+DebugEditorContribution = ( (__decorate([
+    ( (__param(1, IDebugService))),
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, ICommandService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IHostService))),
+    ( (__param(6, IUriIdentityService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, ILanguageFeaturesService))),
+    ( (__param(9, ILanguageFeatureDebounceService)))
+], DebugEditorContribution)));
 class WordsToLineNumbersCache {
     constructor(model) {
         this.model = model;
-        this.value = ( new Map());
-        this.intervals = ( new Uint8Array(Math.ceil(model.getLineCount() / 8)));
+        this.value = ( (new Map()));
+        this.intervals = ( (new Uint8Array(Math.ceil(model.getLineCount() / 8))));
     }
     ensureRangePopulated(range) {
         for (let lineNumber = range.startLineNumber; lineNumber <= range.endLineNumber; lineNumber++) {
@@ -733,9 +730,9 @@ CommandsRegistry.registerCommand('_executeInlineValueProvider', async (accessor,
     const range = Range.lift(iRange);
     const { inlineValuesProvider } = accessor.get(ILanguageFeaturesService);
     const providers = inlineValuesProvider.ordered(model);
-    const providerResults = await Promise.all(( providers.map(
+    const providerResults = await Promise.all(( (providers.map(
         provider => provider.provideInlineValues(model, range, context, CancellationToken.None)
-    )));
+    ))));
     return providerResults.flat().filter(isDefined);
 });
 

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

@@ -14,6 +14,7 @@ import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
@@ -36,6 +37,7 @@ import { Variable, Expression, VisualizedExpression } from 'vscode/vscode/vs/wor
 import { getEvaluatableExpressionAtPosition } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
 
 var DebugHoverWidget_1;
+const _moduleId = "vs/workbench/contrib/debug/browser/debugHover";
 const $ = $$1;
 async function doFindExpression(container, namesToFind) {
     if (!container) {
@@ -56,7 +58,7 @@ async function doFindExpression(container, namesToFind) {
 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)))));
+    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 {
@@ -65,13 +67,14 @@ let DebugHoverWidget = class DebugHoverWidget {
     get isShowingComplexValue() {
         return this.complexValueContainer?.hidden === false;
     }
-    constructor(editor, debugService, instantiationService, menuService, contextKeyService, contextMenuService) {
+    constructor(editor, debugService, instantiationService, menuService, contextKeyService, contextMenuService, hoverService) {
         this.editor = editor;
         this.debugService = debugService;
         this.instantiationService = instantiationService;
         this.menuService = menuService;
         this.contextKeyService = contextKeyService;
         this.contextMenuService = contextMenuService;
+        this.hoverService = hoverService;
         this.allowEditorOverflow = true;
         this.highlightDecorations = this.editor.createDecorationsCollection();
         this.isUpdatingTree = false;
@@ -89,18 +92,18 @@ let DebugHoverWidget = class DebugHoverWidget {
         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'] },
+            _moduleId,
+            0,
             '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.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'DebugHover', this.treeContainer, ( (new DebugHoverDelegate())), [
             this.instantiationService.createInstance(VariablesRenderer, linkeDetector),
             this.instantiationService.createInstance(VisualizedVariableRenderer, linkeDetector),
         ], dataSource, {
-            accessibilityProvider: ( new DebugHoverAccessibilityProvider()),
+            accessibilityProvider: ( (new DebugHoverAccessibilityProvider())),
             mouseSupport: false,
             horizontalScrolling: true,
             useShadows: false,
@@ -113,7 +116,7 @@ let DebugHoverWidget = class DebugHoverWidget {
         this.valueContainer = $('.value');
         this.valueContainer.tabIndex = 0;
         this.valueContainer.setAttribute('role', 'tooltip');
-        this.scrollbar = ( new DomScrollableElement(this.valueContainer, { horizontal: 2  }));
+        this.scrollbar = ( (new DomScrollableElement(this.valueContainer, { horizontal: 2  })));
         this.domNode.appendChild(this.scrollbar.getDomNode());
         this.toDispose.push(this.scrollbar);
         this.editor.applyFontInfo(this.domNode);
@@ -176,7 +179,7 @@ let DebugHoverWidget = class DebugHoverWidget {
     }
     async showAt(position, focus) {
         this.showCancellationSource?.cancel();
-        const cancellationSource = this.showCancellationSource = ( new CancellationTokenSource());
+        const cancellationSource = this.showCancellationSource = ( (new CancellationTokenSource()));
         const session = this.debugService.getViewModel().focusedSession;
         if (!session || !this.editor.hasModel()) {
             this.hide();
@@ -225,7 +228,7 @@ let DebugHoverWidget = class DebugHoverWidget {
             renderExpressionValue(expression, this.valueContainer, {
                 showChanged: false,
                 colorize: true
-            });
+            }, this.hoverService);
             this.valueContainer.title = '';
             this.editor.layoutContentWidget(this);
             this.scrollbar.scanDomNode();
@@ -312,25 +315,22 @@ let DebugHoverWidget = class DebugHoverWidget {
         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));
+DebugHoverWidget = DebugHoverWidget_1 = ( (__decorate([
+    ( (__param(1, IDebugService))),
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, IMenuService))),
+    ( (__param(4, IContextKeyService))),
+    ( (__param(5, IContextMenuService))),
+    ( (__param(6, IHoverService)))
+], DebugHoverWidget)));
 class DebugHoverAccessibilityProvider {
     getWidgetAriaLabel() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugHover',
-            'treeAriaLabel',
-            "Debug Hover"
-        ));
+        return ( localizeWithPath(_moduleId, 1, "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.'] },
+            _moduleId,
+            2,
             "{0}, value {1}, variables, debug",
             element.name,
             element.value
@@ -387,23 +387,23 @@ let DebugHoverComputer = class DebugHoverComputer {
             return;
         }
         if (session.capabilities.supportsEvaluateForHovers) {
-            const expression = ( new Expression(this._currentExpression));
+            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 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));
+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

@@ -194,7 +194,7 @@ class MemoryRegionView extends Disposable {
     }
     read(fromOffset, toOffset) {
         if (fromOffset < 0) {
-            throw new RangeError(`Invalid fromOffset: ${fromOffset}`);
+            throw ( new RangeError(`Invalid fromOffset: ${fromOffset}`));
         }
         return this.parent.read(this.range.fromOffset + fromOffset, this.range.fromOffset + Math.min(toOffset, this.width));
     }