@codingame/monaco-vscode-api 4.5.1 → 4.5.2

package/vscode/src/vs/workbench/contrib/comments/browser/commentsViewActions.js

@@ -8,13 +8,14 @@ import { ViewAction } from '../../../browser/parts/views/viewPane.js';
 import { COMMENTS_VIEW_ID } from './commentsTreeViewer.js';
 import { FocusedViewContext } from '../../../common/contextkeys.js';
 import { viewFilterSubmenu } from '../../../browser/parts/views/viewFilter.js';
-const CONTEXT_KEY_SHOW_RESOLVED = ( new RawContextKey('commentsView.showResolvedFilter', true));
-const CONTEXT_KEY_SHOW_UNRESOLVED = ( new RawContextKey('commentsView.showUnResolvedFilter', true));
+const _moduleId = "vs/workbench/contrib/comments/browser/commentsViewActions";
+const CONTEXT_KEY_SHOW_RESOLVED = ( (new RawContextKey('commentsView.showResolvedFilter', true)));
+const CONTEXT_KEY_SHOW_UNRESOLVED = ( (new RawContextKey('commentsView.showUnResolvedFilter', true)));
 class CommentsFilters extends Disposable {
     constructor(options, contextKeyService) {
         super();
         this.contextKeyService = contextKeyService;
-        this._onDidChange = this._register(( new Emitter()));
+        this._onDidChange = this._register(( (new Emitter())));
         this.onDidChange = this._onDidChange.event;
         this._showUnresolved = CONTEXT_KEY_SHOW_UNRESOLVED.bindTo(this.contextKeyService);
         this._showResolved = CONTEXT_KEY_SHOW_RESOLVED.bindTo(this.contextKeyService);
@@ -44,11 +45,7 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: 'commentsFocusViewFromFilter',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/comments/browser/commentsViewActions',
-                'focusCommentsList',
-                "Focus Comments view"
-            )),
+            title: ( localizeWithPath(_moduleId, 0, "Focus Comments view")),
             keybinding: {
                 when: CommentsViewFilterFocusContextKey,
                 weight: 200 ,
@@ -65,11 +62,7 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: 'commentsClearFilterText',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/comments/browser/commentsViewActions',
-                'commentsClearFilterText',
-                "Clear filter text"
-            )),
+            title: ( localizeWithPath(_moduleId, 1, "Clear filter text")),
             keybinding: {
                 when: CommentsViewFilterFocusContextKey,
                 weight: 200 ,
@@ -86,13 +79,9 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: 'commentsFocusFilter',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/comments/browser/commentsViewActions',
-                'focusCommentsFilter',
-                "Focus comments filter"
-            )),
+            title: ( localizeWithPath(_moduleId, 2, "Focus comments filter")),
             keybinding: {
-                when: ( FocusedViewContext.isEqualTo(COMMENTS_VIEW_ID)),
+                when: ( (FocusedViewContext.isEqualTo(COMMENTS_VIEW_ID))),
                 weight: 200 ,
                 primary: 2048  | 36
             },
@@ -107,28 +96,16 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleUnResolvedComments`,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/comments/browser/commentsViewActions',
-                'toggle unresolved',
-                "Show Unresolved"
-            )),
-            category: ( localizeWithPath(
-                'vs/workbench/contrib/comments/browser/commentsViewActions',
-                'comments',
-                "Comments"
-            )),
+            title: ( localizeWithPath(_moduleId, 3, "Show Unresolved")),
+            category: ( localizeWithPath(_moduleId, 4, "Comments")),
             toggled: {
                 condition: CONTEXT_KEY_SHOW_UNRESOLVED,
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/comments/browser/commentsViewActions',
-                    'unresolved',
-                    "Show Unresolved"
-                )),
+                title: ( localizeWithPath(_moduleId, 5, "Show Unresolved")),
             },
             menu: {
                 id: viewFilterSubmenu,
                 group: '1_filter',
-                when: ( ContextKeyExpr.equals('view', COMMENTS_VIEW_ID)),
+                when: ( (ContextKeyExpr.equals('view', COMMENTS_VIEW_ID))),
                 order: 1
             },
             viewId: COMMENTS_VIEW_ID
@@ -142,28 +119,16 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleResolvedComments`,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/comments/browser/commentsViewActions',
-                'toggle resolved',
-                "Show Resolved"
-            )),
-            category: ( localizeWithPath(
-                'vs/workbench/contrib/comments/browser/commentsViewActions',
-                'comments',
-                "Comments"
-            )),
+            title: ( localizeWithPath(_moduleId, 6, "Show Resolved")),
+            category: ( localizeWithPath(_moduleId, 4, "Comments")),
             toggled: {
                 condition: CONTEXT_KEY_SHOW_RESOLVED,
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/comments/browser/commentsViewActions',
-                    'resolved',
-                    "Show Resolved"
-                )),
+                title: ( localizeWithPath(_moduleId, 7, "Show Resolved")),
             },
             menu: {
                 id: viewFilterSubmenu,
                 group: '1_filter',
-                when: ( ContextKeyExpr.equals('view', COMMENTS_VIEW_ID)),
+                when: ( (ContextKeyExpr.equals('view', COMMENTS_VIEW_ID))),
                 order: 1
             },
             viewId: COMMENTS_VIEW_ID

package/vscode/src/vs/workbench/contrib/comments/browser/reactionsAction.js

@@ -3,14 +3,11 @@ import { append, $, asCSSUrl } from '../../../../base/browser/dom.js';
 import { Action } from '../../../../base/common/actions.js';
 import { URI } from '../../../../base/common/uri.js';
 import { ActionViewItem } from '../../../../base/browser/ui/actionbar/actionViewItems.js';
+const _moduleId = "vs/workbench/contrib/comments/browser/reactionsAction";
 class ToggleReactionsAction extends Action {
     static { this.ID = 'toolbar.toggle.pickReactions'; }
     constructor(toggleDropdownMenu, title) {
-        super(ToggleReactionsAction.ID, title || ( localizeWithPath(
-            'vs/workbench/contrib/comments/browser/reactionsAction',
-            'pickReactions',
-            "Pick Reactions..."
-        )), 'toggle-reactions', true);
+        super(ToggleReactionsAction.ID, title || ( localizeWithPath(_moduleId, 0, "Pick Reactions...")), 'toggle-reactions', true);
         this._menuActions = [];
         this.toggleDropdownMenu = toggleDropdownMenu;
     }
@@ -53,58 +50,47 @@ class ReactionActionViewItem extends ActionViewItem {
     }
     getTooltip() {
         const action = this.action;
-        const toggleMessage = action.enabled ? ( localizeWithPath(
-            'vs/workbench/contrib/comments/browser/reactionsAction',
-            'comment.toggleableReaction',
-            "Toggle reaction, "
-        )) : '';
+        const toggleMessage = action.enabled ? ( localizeWithPath(_moduleId, 1, "Toggle reaction, ")) : '';
         if (action.count === undefined) {
-            return ( localizeWithPath('vs/workbench/contrib/comments/browser/reactionsAction', {
-                key: 'comment.reactionLabelNone', comment: [
-                    'This is a tooltip for an emoji button so that the current user can toggle their reaction to a comment.',
-                    'The first arg is localized message "Toggle reaction" or empty if the user doesn\'t have permission to toggle the reaction, the second is the name of the reaction.'
-                ]
-            }, "{0}{1} reaction", toggleMessage, action.label));
+            return ( localizeWithPath(_moduleId, 2, "{0}{1} reaction", toggleMessage, action.label));
         }
         else if (action.reactors === undefined || action.reactors.length === 0) {
             if (action.count === 1) {
-                return ( localizeWithPath('vs/workbench/contrib/comments/browser/reactionsAction', {
-                    key: 'comment.reactionLabelOne', comment: [
-                        'This is a tooltip for an emoji that is a "reaction" to a comment where the count of the reactions is 1.',
-                        'The emoji is also a button so that the current user can also toggle their own emoji reaction.',
-                        'The first arg is localized message "Toggle reaction" or empty if the user doesn\'t have permission to toggle the reaction, the second is the name of the reaction.'
-                    ]
-                }, "{0}1 reaction with {1}", toggleMessage, action.label));
+                return ( localizeWithPath(_moduleId, 3, "{0}1 reaction with {1}", toggleMessage, action.label));
             }
             else if (action.count > 1) {
-                return ( localizeWithPath('vs/workbench/contrib/comments/browser/reactionsAction', {
-                    key: 'comment.reactionLabelMany', comment: [
-                        'This is a tooltip for an emoji that is a "reaction" to a comment where the count of the reactions is greater than 1.',
-                        'The emoji is also a button so that the current user can also toggle their own emoji reaction.',
-                        'The first arg is localized message "Toggle reaction" or empty if the user doesn\'t have permission to toggle the reaction, the second is number of users who have reacted with that reaction, and the third is the name of the reaction.'
-                    ]
-                }, "{0}{1} reactions with {2}", toggleMessage, action.count, action.label));
+                return ( localizeWithPath(
+                    _moduleId,
+                    4,
+                    "{0}{1} reactions with {2}",
+                    toggleMessage,
+                    action.count,
+                    action.label
+                ));
             }
         }
         else {
             if (action.reactors.length <= 10 && action.reactors.length === action.count) {
-                return ( localizeWithPath('vs/workbench/contrib/comments/browser/reactionsAction', {
-                    key: 'comment.reactionLessThanTen', comment: [
-                        'This is a tooltip for an emoji that is a "reaction" to a comment where the count of the reactions is less than or equal to 10.',
-                        'The emoji is also a button so that the current user can also toggle their own emoji reaction.',
-                        'The first arg is localized message "Toggle reaction" or empty if the user doesn\'t have permission to toggle the reaction, the second iis a list of the reactors, and the third is the name of the reaction.'
-                    ]
-                }, "{0}{1} reacted with {2}", toggleMessage, action.reactors.join(', '), action.label));
+                return ( localizeWithPath(
+                    _moduleId,
+                    5,
+                    "{0}{1} reacted with {2}",
+                    toggleMessage,
+                    action.reactors.join(', '),
+                    action.label
+                ));
             }
             else if (action.count > 1) {
                 const displayedReactors = action.reactors.slice(0, 10);
-                return ( localizeWithPath('vs/workbench/contrib/comments/browser/reactionsAction', {
-                    key: 'comment.reactionMoreThanTen', comment: [
-                        'This is a tooltip for an emoji that is a "reaction" to a comment where the count of the reactions is less than or equal to 10.',
-                        'The emoji is also a button so that the current user can also toggle their own emoji reaction.',
-                        'The first arg is localized message "Toggle reaction" or empty if the user doesn\'t have permission to toggle the reaction, the second iis a list of the reactors, and the third is the name of the reaction.'
-                    ]
-                }, "{0}{1} and {2} more reacted with {3}", toggleMessage, displayedReactors.join(', '), action.count - displayedReactors.length, action.label));
+                return ( localizeWithPath(
+                    _moduleId,
+                    6,
+                    "{0}{1} and {2} more reacted with {3}",
+                    toggleMessage,
+                    displayedReactors.join(', '),
+                    action.count - displayedReactors.length,
+                    action.label
+                ));
             }
         }
         return undefined;

package/vscode/src/vs/workbench/contrib/comments/common/commentContextKeys.js

@@ -1,68 +1,41 @@
 import { localizeWithPath } from '../../../../nls.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+const _moduleId = "vs/workbench/contrib/comments/common/commentContextKeys";
 var CommentContextKeys;
-( (function(CommentContextKeys) {
-    CommentContextKeys.activeCursorHasCommentingRange = ( new RawContextKey('activeCursorHasCommentingRange', false, {
+( ((function(CommentContextKeys) {
+    CommentContextKeys.activeCursorHasCommentingRange = ( (new RawContextKey('activeCursorHasCommentingRange', false, {
         description: ( localizeWithPath(
-         'vs/workbench/contrib/comments/common/commentContextKeys',
-         'hasCommentingRange',
+         _moduleId,
+         0,
          "Whether the position at the active cursor has a commenting range"
         )),
         type: 'boolean'
-    }));
-    CommentContextKeys.activeEditorHasCommentingRange = ( new RawContextKey('activeEditorHasCommentingRange', false, {
-        description: ( localizeWithPath(
-         'vs/workbench/contrib/comments/common/commentContextKeys',
-         'editorHasCommentingRange',
-         "Whether the active editor has a commenting range"
-        )),
+    })));
+    CommentContextKeys.activeEditorHasCommentingRange = ( (new RawContextKey('activeEditorHasCommentingRange', false, {
+        description: ( localizeWithPath(_moduleId, 1, "Whether the active editor has a commenting range")),
         type: 'boolean'
-    }));
-    CommentContextKeys.WorkspaceHasCommenting = ( new RawContextKey('workspaceHasCommenting', false, {
+    })));
+    CommentContextKeys.WorkspaceHasCommenting = ( (new RawContextKey('workspaceHasCommenting', false, {
         description: ( localizeWithPath(
-         'vs/workbench/contrib/comments/common/commentContextKeys',
-         'hasCommentingProvider',
+         _moduleId,
+         2,
          "Whether the open workspace has either comments or commenting ranges."
         )),
         type: 'boolean'
-    }));
-    CommentContextKeys.commentThreadIsEmpty = ( new RawContextKey(
+    })));
+    CommentContextKeys.commentThreadIsEmpty = ( (new RawContextKey(
      'commentThreadIsEmpty',
      false,
-     { type: 'boolean', description: ( localizeWithPath(
-      'vs/workbench/contrib/comments/common/commentContextKeys',
-      'commentThreadIsEmpty',
-      "Set when the comment thread has no comments"
-     )) }
-    ));
-    CommentContextKeys.commentIsEmpty = ( new RawContextKey('commentIsEmpty', false, { type: 'boolean', description: ( localizeWithPath(
-     'vs/workbench/contrib/comments/common/commentContextKeys',
-     'commentIsEmpty',
-     "Set when the comment has no input"
-    )) }));
-    CommentContextKeys.commentContext = ( new RawContextKey('comment', undefined, { type: 'string', description: ( localizeWithPath(
-     'vs/workbench/contrib/comments/common/commentContextKeys',
-     'comment',
-     "The context value of the comment"
-    )) }));
-    CommentContextKeys.commentThreadContext = ( new RawContextKey('commentThread', undefined, { type: 'string', description: ( localizeWithPath(
-     'vs/workbench/contrib/comments/common/commentContextKeys',
-     'commentThread',
-     "The context value of the comment thread"
-    )) }));
-    CommentContextKeys.commentControllerContext = ( new RawContextKey(
+     { type: 'boolean', description: ( localizeWithPath(_moduleId, 3, "Set when the comment thread has no comments")) }
+    )));
+    CommentContextKeys.commentIsEmpty = ( (new RawContextKey('commentIsEmpty', false, { type: 'boolean', description: ( localizeWithPath(_moduleId, 4, "Set when the comment has no input")) })));
+    CommentContextKeys.commentContext = ( (new RawContextKey('comment', undefined, { type: 'string', description: ( localizeWithPath(_moduleId, 5, "The context value of the comment")) })));
+    CommentContextKeys.commentThreadContext = ( (new RawContextKey('commentThread', undefined, { type: 'string', description: ( localizeWithPath(_moduleId, 6, "The context value of the comment thread")) })));
+    CommentContextKeys.commentControllerContext = ( (new RawContextKey(
      'commentController',
      undefined,
-     { type: 'string', description: ( localizeWithPath(
-      'vs/workbench/contrib/comments/common/commentContextKeys',
-      'commentController',
-      "The comment controller id associated with a comment thread"
-     )) }
-    ));
-    CommentContextKeys.commentFocused = ( new RawContextKey('commentFocused', false, { type: 'boolean', description: ( localizeWithPath(
-     'vs/workbench/contrib/comments/common/commentContextKeys',
-     'commentFocused',
-     "Set when the comment is focused"
-    )) }));
-})(CommentContextKeys || (CommentContextKeys = {})));
+     { type: 'string', description: ( localizeWithPath(_moduleId, 7, "The comment controller id associated with a comment thread")) }
+    )));
+    CommentContextKeys.commentFocused = ( (new RawContextKey('commentFocused', false, { type: 'boolean', description: ( localizeWithPath(_moduleId, 8, "Set when the comment is focused")) })));
+})(CommentContextKeys || (CommentContextKeys = {}))));
 export { CommentContextKeys };

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditorInput.js

@@ -23,6 +23,7 @@ import { IFilesConfigurationService } from '../../../services/filesConfiguration
 import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.service.js';
 import { IUntitledTextEditorService } from '../../../services/untitled/common/untitledTextEditorService.service.js';
 var CustomEditorInput_1;
+const _moduleId = "vs/workbench/contrib/customEditor/browser/customEditorInput";
 let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEditorInput {
     static { CustomEditorInput_1 = this; }
     static create(instantiationService, resource, viewType, group, options) {
@@ -303,10 +304,14 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
     }
     claim(claimant, targetWindow, scopedContextKeyService) {
         if (this.doCanMove(targetWindow.vscodeWindowId) !== true) {
-            throw createEditorOpenError(localizeWithPath('vs/workbench/contrib/customEditor/browser/customEditorInput', 'editorUnsupportedInWindow', "Unable to open the editor in this window, it contains modifications that can only be saved in the original window."), [
+            throw createEditorOpenError(localizeWithPath(
+                _moduleId,
+                0,
+                "Unable to open the editor in this window, it contains modifications that can only be saved in the original window."
+            ), [
                 toAction({
                     id: 'openInOriginalWindow',
-                    label: localizeWithPath('vs/workbench/contrib/customEditor/browser/customEditorInput', 'reopenInOriginalWindow', "Open in Original Window"),
+                    label: localizeWithPath(_moduleId, 1, "Open in Original Window"),
                     run: async () => {
                         const originalPart = this.editorGroupsService.getPart(this.layoutService.getContainer(getWindow(this.webview.container).window));
                         const currentPart = this.editorGroupsService.getPart(this.layoutService.getContainer(targetWindow.window));
@@ -332,8 +337,8 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
             const sourceWindowId = getWindow(this.webview.container).vscodeWindowId;
             if (sourceWindowId !== targetWindowId) {
                 return ( localizeWithPath(
-                    'vs/workbench/contrib/customEditor/browser/customEditorInput',
-                    'editorCannotMove',
+                    _moduleId,
+                    2,
                     "Unable to move '{0}': The editor contains changes that can only be saved in its current window.",
                     this.getName()
                 ));
@@ -342,17 +347,17 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
         return true;
     }
 };
-CustomEditorInput = CustomEditorInput_1 = ( __decorate([
-    ( __param(3, IWebviewWorkbenchService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, ILabelService)),
-    ( __param(6, ICustomEditorService)),
-    ( __param(7, IFileDialogService)),
-    ( __param(8, IUndoRedoService)),
-    ( __param(9, IFileService)),
-    ( __param(10, IFilesConfigurationService)),
-    ( __param(11, IEditorGroupsService)),
-    ( __param(12, IWorkbenchLayoutService)),
-    ( __param(13, ICustomEditorLabelService))
-], CustomEditorInput));
+CustomEditorInput = CustomEditorInput_1 = ( (__decorate([
+    ( (__param(3, IWebviewWorkbenchService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, ILabelService))),
+    ( (__param(6, ICustomEditorService))),
+    ( (__param(7, IFileDialogService))),
+    ( (__param(8, IUndoRedoService))),
+    ( (__param(9, IFileService))),
+    ( (__param(10, IFilesConfigurationService))),
+    ( (__param(11, IEditorGroupsService))),
+    ( (__param(12, IWorkbenchLayoutService))),
+    ( (__param(13, ICustomEditorLabelService)))
+], CustomEditorInput)));
 export { CustomEditorInput };

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

@@ -17,6 +17,7 @@ import { IDebugService } from '../common/debug.service.js';
 import { Expression, Variable, ExpressionContainer } from '../common/debugModel.js';
 import { IDebugVisualizerService } from '../common/debugVisualizers.service.js';
 import { ReplEvaluationResult } from '../common/replModel.js';
+const _moduleId = "vs/workbench/contrib/debug/browser/baseDebugView";
 const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
 const booleanRegex = /^(true|false)$/i;
 const stringRegex = /^(['"]).*\1$/;
@@ -104,7 +105,7 @@ let AbstractExpressionDataSource = class AbstractExpressionDataSource {
     async getChildren(element) {
         const vm = this.debugService.getViewModel();
         const children = await this.doGetChildren(element);
-        return Promise.all(( children.map(async (r) => {
+        return Promise.all(( (children.map(async (r) => {
             const vizOrTree = vm.getVisualizedExpression(r);
             if (typeof vizOrTree === 'string') {
                 const viz = await this.debugVisualizer.getVisualizedNodeFor(vizOrTree, r);
@@ -117,38 +118,34 @@ let AbstractExpressionDataSource = class AbstractExpressionDataSource {
                 return vizOrTree;
             }
             return r;
-        })));
+        }))));
     }
 };
-AbstractExpressionDataSource = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IDebugVisualizerService))
-], AbstractExpressionDataSource));
+AbstractExpressionDataSource = ( (__decorate([
+    ( (__param(0, IDebugService))),
+    ( (__param(1, IDebugVisualizerService)))
+], AbstractExpressionDataSource)));
 let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
     constructor(debugService, contextViewService) {
         this.debugService = debugService;
         this.contextViewService = contextViewService;
     }
     renderTemplate(container) {
-        const templateDisposable = ( new DisposableStore());
+        const templateDisposable = ( (new DisposableStore()));
         const expression = append(container, $('.expression'));
         const name = append(expression, $('span.name'));
         const lazyButton = append(expression, $('span.lazy-button'));
         lazyButton.classList.add(...ThemeIcon.asClassNameArray(Codicon.eye));
-        templateDisposable.add(setupCustomHover(getDefaultHoverDelegate('mouse'), lazyButton, ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/baseDebugView',
-            'debug.lazyButton.tooltip',
-            "Click to expand"
-        ))));
+        templateDisposable.add(setupCustomHover(getDefaultHoverDelegate('mouse'), lazyButton, ( localizeWithPath(_moduleId, 0, "Click to expand"))));
         const value = append(expression, $('span.value'));
-        const label = templateDisposable.add(( new HighlightedLabel(name)));
+        const label = templateDisposable.add(( (new HighlightedLabel(name))));
         const inputBoxContainer = append(expression, $('.inputBoxContainer'));
         let actionBar;
         if (this.renderActionBar) {
             append(expression, $('.span.actionbar-spacer'));
-            actionBar = templateDisposable.add(( new ActionBar(expression)));
+            actionBar = templateDisposable.add(( (new ActionBar(expression))));
         }
-        const template = { expression, name, value, label, inputBoxContainer, actionBar, elementDisposable: ( new DisposableStore()), templateDisposable, lazyButton, currentElement: undefined };
+        const template = { expression, name, value, label, inputBoxContainer, actionBar, elementDisposable: ( (new DisposableStore())), templateDisposable, lazyButton, currentElement: undefined };
         templateDisposable.add(addDisposableListener(lazyButton, EventType.CLICK, () => {
             if (template.currentElement) {
                 this.debugService.getViewModel().evaluateLazyExpression(template.currentElement);
@@ -176,11 +173,11 @@ let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
         valueElement.style.display = 'none';
         inputBoxContainer.style.display = 'initial';
         clearNode(inputBoxContainer);
-        const inputBox = ( new InputBox(
+        const inputBox = ( (new InputBox(
             inputBoxContainer,
             this.contextViewService,
             { ...options, inputBoxStyles: defaultInputBoxStyles }
-        ));
+        )));
         inputBox.value = options.initialValue;
         inputBox.focus();
         inputBox.select();
@@ -226,8 +223,8 @@ let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
         templateData.templateDisposable.dispose();
     }
 };
-AbstractExpressionsRenderer = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IContextViewService))
-], AbstractExpressionsRenderer));
+AbstractExpressionsRenderer = ( (__decorate([
+    ( (__param(0, IDebugService))),
+    ( (__param(1, IContextViewService)))
+], AbstractExpressionsRenderer)));
 export { AbstractExpressionDataSource, AbstractExpressionsRenderer, renderExpressionValue, renderVariable, renderViewTree };