@codingame/monaco-vscode-views-service-override 1.83.1 → 1.83.2

package/vscode/src/vs/workbench/contrib/webview/browser/webviewElement.js

@@ -30,11 +30,11 @@ import { decodeAuthority, webviewRootResourceAuthority, webviewGenericCspSource
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
 
 var WebviewState;
-( ((function(WebviewState) {
-    ( ((function(Type) {
+( (function(WebviewState) {
+    ( (function(Type) {
         Type[Type["Initializing"] = 0] = "Initializing";
         Type[Type["Ready"] = 1] = "Ready";
-    })(WebviewState.Type || (WebviewState.Type = {}))));
+    })(WebviewState.Type || (WebviewState.Type = {})));
     class Initializing {
         constructor(pendingMessages) {
             this.pendingMessages = pendingMessages;
@@ -43,7 +43,7 @@ var WebviewState;
     }
     WebviewState.Initializing = Initializing;
     WebviewState.Ready = { type: 1  };
-})(WebviewState || (WebviewState = {}))));
+})(WebviewState || (WebviewState = {})));
 const webviewIdContext = 'webviewId';
 let WebviewElement = class WebviewElement extends Disposable {
     get platform() { return 'browser'; }
@@ -70,39 +70,39 @@ let WebviewElement = class WebviewElement extends Disposable {
         this.id = generateUuid();
         this._expectedServiceWorkerVersion = 4;
         this._state = new WebviewState.Initializing([]);
-        this._resourceLoadingCts = this._register(( (new CancellationTokenSource())));
-        this._focusDelayer = this._register(( (new ThrottledDelayer(50))));
-        this._onDidHtmlChange = this._register(( (new Emitter())));
+        this._resourceLoadingCts = this._register(( new CancellationTokenSource()));
+        this._focusDelayer = this._register(( new ThrottledDelayer(50)));
+        this._onDidHtmlChange = this._register(( new Emitter()));
         this.onDidHtmlChange = this._onDidHtmlChange.event;
-        this._messageHandlers = ( (new Map()));
+        this._messageHandlers = ( new Map());
         this.checkImeCompletionState = true;
         this._disposed = false;
-        this._onMissingCsp = this._register(( (new Emitter())));
+        this._onMissingCsp = this._register(( new Emitter()));
         this.onMissingCsp = this._onMissingCsp.event;
-        this._onDidClickLink = this._register(( (new Emitter())));
+        this._onDidClickLink = this._register(( new Emitter()));
         this.onDidClickLink = this._onDidClickLink.event;
-        this._onDidReload = this._register(( (new Emitter())));
+        this._onDidReload = this._register(( new Emitter()));
         this.onDidReload = this._onDidReload.event;
-        this._onMessage = this._register(( (new Emitter())));
+        this._onMessage = this._register(( new Emitter()));
         this.onMessage = this._onMessage.event;
-        this._onDidScroll = this._register(( (new Emitter())));
+        this._onDidScroll = this._register(( new Emitter()));
         this.onDidScroll = this._onDidScroll.event;
-        this._onDidWheel = this._register(( (new Emitter())));
+        this._onDidWheel = this._register(( new Emitter()));
         this.onDidWheel = this._onDidWheel.event;
-        this._onDidUpdateState = this._register(( (new Emitter())));
+        this._onDidUpdateState = this._register(( new Emitter()));
         this.onDidUpdateState = this._onDidUpdateState.event;
-        this._onDidFocus = this._register(( (new Emitter())));
+        this._onDidFocus = this._register(( new Emitter()));
         this.onDidFocus = this._onDidFocus.event;
-        this._onDidBlur = this._register(( (new Emitter())));
+        this._onDidBlur = this._register(( new Emitter()));
         this.onDidBlur = this._onDidBlur.event;
-        this._onFatalError = this._register(( (new Emitter())));
+        this._onFatalError = this._register(( new Emitter()));
         this.onFatalError = this._onFatalError.event;
-        this._onDidDispose = this._register(( (new Emitter())));
+        this._onDidDispose = this._register(( new Emitter()));
         this.onDidDispose = this._onDidDispose.event;
         this._hasAlertedAboutMissingCsp = false;
-        this._hasFindResult = this._register(( (new Emitter())));
+        this._hasFindResult = this._register(( new Emitter()));
         this.hasFindResult = this._hasFindResult.event;
-        this._onDidStopFind = this._register(( (new Emitter())));
+        this._onDidStopFind = this._register(( new Emitter()));
         this.onDidStopFind = this._onDidStopFind.event;
         this.providedViewType = initInfo.providedViewType;
         this.origin = initInfo.origin ?? this.id;
@@ -115,11 +115,11 @@ let WebviewElement = class WebviewElement extends Disposable {
             options: initInfo.contentOptions,
             state: undefined
         };
-        this._portMappingManager = this._register(( (new WebviewPortMappingManager(
+        this._portMappingManager = this._register(( new WebviewPortMappingManager(
             () => this.extension?.location,
             () => this._content.options.portMapping || [],
             this._tunnelService
-        ))));
+        )));
         this._element = this._createElement(initInfo.options, initInfo.contentOptions);
         const subscription = this._register(addDisposableListener(window, 'message', (e) => {
             if (!this._encodedWebviewOrigin || e?.data?.target !== this.id) {
@@ -179,7 +179,7 @@ let WebviewElement = class WebviewElement extends Disposable {
             this._hasFindResult.fire(didFind);
         }));
         this._register(this.on('fatal-error', (e) => {
-            notificationService.error(( (localize('fatalErrorMessage', "Error loading webview: {0}", e.message))));
+            notificationService.error(( localize('fatalErrorMessage', "Error loading webview: {0}", e.message)));
             this._onFatalError.fire({ message: e.message });
         }));
         this._register(this.on('did-keydown', (data) => {
@@ -214,12 +214,12 @@ let WebviewElement = class WebviewElement extends Disposable {
         this._register(this.on('load-resource', async (entry) => {
             try {
                 const authority = decodeAuthority(entry.authority);
-                const uri = ( (URI.from({
+                const uri = ( URI.from({
                     scheme: entry.scheme,
                     authority: authority,
                     path: decodeURIComponent(entry.path),
                     query: entry.query ? decodeURIComponent(entry.query) : entry.query,
-                })));
+                }));
                 this.loadResource(entry.id, uri, entry.ifNoneMatch);
             }
             catch (e) {
@@ -281,7 +281,7 @@ let WebviewElement = class WebviewElement extends Disposable {
     async _send(channel, data, _createElement = []) {
         if (this._state.type === 0 ) {
             let resolve;
-            const promise = ( (new Promise(r => resolve = r)));
+            const promise = ( new Promise(r => resolve = r));
             this._state.pendingMessages.push({ channel, data, transferable: _createElement, resolve: resolve });
             return promise;
         }
@@ -326,13 +326,13 @@ let WebviewElement = class WebviewElement extends Disposable {
         if (options.purpose) {
             params.purpose = options.purpose;
         }
-        params.serviceWorkerUri = ( (( (FileAccess.asBrowserUri('vs/workbench/contrib/webview/browser/pre/service-worker.js'))).toString(true)));
-        params.fakeHtmlUri = ( (( (FileAccess.asBrowserUri('vs/workbench/contrib/webview/browser/pre/fake.html'))).toString(true)));
+        params.serviceWorkerUri = ( ( FileAccess.asBrowserUri('vs/workbench/contrib/webview/browser/pre/service-worker.js')).toString(true));
+        params.fakeHtmlUri = ( ( FileAccess.asBrowserUri('vs/workbench/contrib/webview/browser/pre/fake.html')).toString(true));
         COI.addSearchParam(params, true, true);
-        const queryString = ( (( (new URLSearchParams(params))).toString()));
+        const queryString = ( ( new URLSearchParams(params)).toString());
         const fileName = isFirefox ? 'index-no-csp.html' : 'index.html';
-        const relativeIframeSrc = ( (FileAccess.asBrowserUri(`vs/workbench/contrib/webview/browser/pre/${fileName}`)));
-        this.element.setAttribute('src', `${( ( relativeIframeSrc.toString(true)))}?${queryString}`);
+        const relativeIframeSrc = ( FileAccess.asBrowserUri(`vs/workbench/contrib/webview/browser/pre/${fileName}`));
+        this.element.setAttribute('src', `${( relativeIframeSrc.toString(true))}?${queryString}`);
     }
     mountTo(element) {
         if (!this.element) {
@@ -385,7 +385,7 @@ let WebviewElement = class WebviewElement extends Disposable {
     on(channel, handler) {
         let handlers = this._messageHandlers.get(channel);
         if (!handlers) {
-            handlers = ( (new Set()));
+            handlers = ( new Set());
             this._messageHandlers.set(channel, handlers);
         }
         handlers.add(handler);
@@ -479,7 +479,7 @@ let WebviewElement = class WebviewElement extends Disposable {
         }
     }
     handleKeyEvent(type, event) {
-        const emulatedKeyboardEvent = ( (new KeyboardEvent(type, event)));
+        const emulatedKeyboardEvent = ( new KeyboardEvent(type, event));
         Object.defineProperty(emulatedKeyboardEvent, 'target', {
             get: () => this.element,
         });
@@ -625,18 +625,18 @@ let WebviewElement = class WebviewElement extends Disposable {
         this._webviewFindWidget?.find(previous);
     }
 };
-WebviewElement = ( (__decorate([
-    ( (__param(2, IConfigurationService))),
-    ( (__param(3, IContextMenuService))),
-    ( (__param(4, INotificationService))),
-    ( (__param(5, IWorkbenchEnvironmentService))),
-    ( (__param(6, IFileService))),
-    ( (__param(7, ILogService))),
-    ( (__param(8, IRemoteAuthorityResolverService))),
-    ( (__param(9, ITelemetryService))),
-    ( (__param(10, ITunnelService))),
-    ( (__param(11, IInstantiationService))),
-    ( (__param(12, IAccessibilityService)))
-], WebviewElement)));
+WebviewElement = ( __decorate([
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, IFileService)),
+    ( __param(7, ILogService)),
+    ( __param(8, IRemoteAuthorityResolverService)),
+    ( __param(9, ITelemetryService)),
+    ( __param(10, ITunnelService)),
+    ( __param(11, IInstantiationService)),
+    ( __param(12, IAccessibilityService))
+], WebviewElement));
 
 export { WebviewElement };

package/vscode/src/vs/workbench/services/history/browser/historyService.js

@@ -43,50 +43,50 @@ let HistoryService = class HistoryService extends Disposable {
         this.instantiationService = instantiationService;
         this.layoutService = layoutService;
         this.contextKeyService = contextKeyService;
-        this.activeEditorListeners = this._register(( (new DisposableStore())));
+        this.activeEditorListeners = this._register(( new DisposableStore()));
         this.lastActiveEditor = undefined;
         this.editorHelper = this.instantiationService.createInstance(EditorHelper);
-        this.canNavigateBackContextKey = (( (new RawContextKey('canNavigateBack', false,  (localize(
+        this.canNavigateBackContextKey = (( new RawContextKey('canNavigateBack', false, ( localize(
             'canNavigateBack',
             "Whether it is possible to navigate back in editor history"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardContextKey = (( (new RawContextKey('canNavigateForward', false,  (localize(
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardContextKey = (( new RawContextKey('canNavigateForward', false, ( localize(
             'canNavigateForward',
             "Whether it is possible to navigate forward in editor history"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateBackInNavigationsContextKey = (( (new RawContextKey('canNavigateBackInNavigationLocations', false,  (localize(
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateBackInNavigationsContextKey = (( new RawContextKey('canNavigateBackInNavigationLocations', false, ( localize(
             'canNavigateBackInNavigationLocations',
             "Whether it is possible to navigate back in editor navigation locations history"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardInNavigationsContextKey = (( (new RawContextKey('canNavigateForwardInNavigationLocations', false,  (localize(
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardInNavigationsContextKey = (( new RawContextKey('canNavigateForwardInNavigationLocations', false, ( localize(
             'canNavigateForwardInNavigationLocations',
             "Whether it is possible to navigate forward in editor navigation locations history"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateToLastNavigationLocationContextKey = (( (new RawContextKey('canNavigateToLastNavigationLocation', false,  (localize(
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateToLastNavigationLocationContextKey = (( new RawContextKey('canNavigateToLastNavigationLocation', false, ( localize(
             'canNavigateToLastNavigationLocation',
             "Whether it is possible to navigate to the last editor navigation location"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateBackInEditsContextKey = (( (new RawContextKey('canNavigateBackInEditLocations', false,  (localize(
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateBackInEditsContextKey = (( new RawContextKey('canNavigateBackInEditLocations', false, ( localize(
             'canNavigateBackInEditLocations',
             "Whether it is possible to navigate back in editor edit locations history"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardInEditsContextKey = (( (new RawContextKey('canNavigateForwardInEditLocations', false,  (localize(
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardInEditsContextKey = (( new RawContextKey('canNavigateForwardInEditLocations', false, ( localize(
             'canNavigateForwardInEditLocations',
             "Whether it is possible to navigate forward in editor edit locations history"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateToLastEditLocationContextKey = (( (new RawContextKey('canNavigateToLastEditLocation', false,  (localize(
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateToLastEditLocationContextKey = (( new RawContextKey('canNavigateToLastEditLocation', false, ( localize(
             'canNavigateToLastEditLocation',
             "Whether it is possible to navigate to the last editor edit location"
-        )))))).bindTo(this.contextKeyService);
-        this.canReopenClosedEditorContextKey = (( (new RawContextKey('canReopenClosedEditor', false,  (localize(
+        ))))).bindTo(this.contextKeyService);
+        this.canReopenClosedEditorContextKey = (( new RawContextKey('canReopenClosedEditor', false, ( localize(
             'canReopenClosedEditor',
             "Whether it is possible to reopen the last closed editor"
-        )))))).bindTo(this.contextKeyService);
-        this._onDidChangeEditorNavigationStack = this._register(( (new Emitter())));
+        ))))).bindTo(this.contextKeyService);
+        this._onDidChangeEditorNavigationStack = this._register(( new Emitter()));
         this.onDidChangeEditorNavigationStack = this._onDidChangeEditorNavigationStack.event;
         this.defaultScopedEditorNavigationStack = undefined;
-        this.editorGroupScopedNavigationStacks = ( (new Map()));
-        this.editorScopedNavigationStacks = ( (new Map()));
+        this.editorGroupScopedNavigationStacks = ( new Map());
+        this.editorScopedNavigationStacks = ( new Map());
         this.editorNavigationScope = 0 ;
         this.recentlyUsedEditorsStack = undefined;
         this.recentlyUsedEditorsStackIndex = 0;
@@ -97,12 +97,12 @@ let HistoryService = class HistoryService extends Disposable {
         this.recentlyClosedEditors = [];
         this.ignoreEditorCloseEvent = false;
         this.history = undefined;
-        this.editorHistoryListeners = ( (new Map()));
-        this.resourceExcludeMatcher = this._register(( (new IdleValue(() => {
+        this.editorHistoryListeners = ( new Map());
+        this.resourceExcludeMatcher = this._register(( new IdleValue(() => {
             const matcher = this._register(this.instantiationService.createInstance(ResourceGlobMatcher, root => getExcludes(root ? this.configurationService.getValue({ resource: root }) : this.configurationService.getValue()) || Object.create(null), event => event.affectsConfiguration(FILES_EXCLUDE_CONFIG) || event.affectsConfiguration(SEARCH_EXCLUDE_CONFIG)));
             this._register(matcher.onExpressionChange(() => this.removeExcludedFromHistory()));
             return matcher;
-        }))));
+        })));
         this.registerListeners();
         if (this.editorService.activeEditorPane) {
             this.onDidActiveEditorChange();
@@ -127,7 +127,7 @@ let HistoryService = class HistoryService extends Disposable {
         this.handleEditorCloseEventInReopen(e);
     }
     registerMouseNavigationListener() {
-        const mouseBackForwardSupportListener = this._register(( (new DisposableStore())));
+        const mouseBackForwardSupportListener = this._register(( new DisposableStore()));
         const handleMouseBackForwardSupport = () => {
             mouseBackForwardSupportListener.clear();
             if (this.configurationService.getValue(HistoryService_1.MOUSE_NAVIGATION_SETTING)) {
@@ -265,18 +265,16 @@ let HistoryService = class HistoryService extends Disposable {
         switch (this.editorNavigationScope) {
             case 2 : {
                 if (!editor) {
-                    return (
-                         (new NoOpEditorNavigationStacks())
-                    );
+                    return ( new NoOpEditorNavigationStacks());
                 }
                 let stacksForGroup = this.editorScopedNavigationStacks.get(group.id);
                 if (!stacksForGroup) {
-                    stacksForGroup = ( (new Map()));
+                    stacksForGroup = ( new Map());
                     this.editorScopedNavigationStacks.set(group.id, stacksForGroup);
                 }
                 let stack = stacksForGroup.get(editor)?.stack;
                 if (!stack) {
-                    const disposable = ( (new DisposableStore()));
+                    const disposable = ( new DisposableStore());
                     stack = disposable.add(this.instantiationService.createInstance(EditorNavigationStacks, 2 ));
                     disposable.add(stack.onDidChange(() => this._onDidChangeEditorNavigationStack.fire()));
                     stacksForGroup.set(editor, { stack, disposable });
@@ -286,7 +284,7 @@ let HistoryService = class HistoryService extends Disposable {
             case 1 : {
                 let stack = this.editorGroupScopedNavigationStacks.get(group.id)?.stack;
                 if (!stack) {
-                    const disposable = ( (new DisposableStore()));
+                    const disposable = ( new DisposableStore());
                     stack = disposable.add(this.instantiationService.createInstance(EditorNavigationStacks, 1 ));
                     disposable.add(stack.onDidChange(() => this._onDidChangeEditorNavigationStack.fire()));
                     this.editorGroupScopedNavigationStacks.set(group.id, { stack, disposable });
@@ -417,7 +415,7 @@ let HistoryService = class HistoryService extends Disposable {
             index = this.recentlyUsedEditorsStackIndex;
         }
         else {
-            editors = this.recentlyUsedEditorsInGroupStack || ( (group.getEditors(0 ).map(editor => ({ groupId: group.id, editor }))));
+            editors = this.recentlyUsedEditorsInGroupStack || ( group.getEditors(0 ).map(editor => ({ groupId: group.id, editor })));
             index = this.recentlyUsedEditorsInGroupStackIndex;
         }
         let newIndex = indexModifier(index);
@@ -526,9 +524,9 @@ let HistoryService = class HistoryService extends Disposable {
             if (recentlyClosedEditor.resource && this.editorHelper.matchesFile(recentlyClosedEditor.resource, arg1)) {
                 return false;
             }
-            if (( (recentlyClosedEditor.associatedResources.some(
+            if (( recentlyClosedEditor.associatedResources.some(
                 associatedResource => this.editorHelper.matchesFile(associatedResource, arg1)
-            )))) {
+            ))) {
                 return false;
             }
             return true;
@@ -629,7 +627,7 @@ let HistoryService = class HistoryService extends Disposable {
                     replaced = true;
                 }
             }
-            else if (!( (replacements.some(replacement => this.editorHelper.matchesEditor(replacement, entry))))) {
+            else if (!( replacements.some(replacement => this.editorHelper.matchesEditor(replacement, entry)))) {
                 newHistory.push(entry);
             }
         }
@@ -667,18 +665,18 @@ let HistoryService = class HistoryService extends Disposable {
         this.history = [];
         const storedEditorHistory = this.loadHistoryFromStorage();
         const openedEditorsLru = [...this.editorService.getEditors(0 )].reverse();
-        const handledEditors = ( (new Set()));
+        const handledEditors = ( new Set());
         for (const { editor } of openedEditorsLru) {
             if (!this.includeInHistory(editor)) {
                 continue;
             }
             this.addToHistory(editor);
             if (editor.resource) {
-                handledEditors.add(`${( ( editor.resource.toString()))}/${editor.editorId}`);
+                handledEditors.add(`${( editor.resource.toString())}/${editor.editorId}`);
             }
         }
         for (const editor of storedEditorHistory) {
-            if (!( (handledEditors.has(`${( ( editor.resource.toString()))}/${editor.options?.override}`)))) {
+            if (!( handledEditors.has(`${( editor.resource.toString())}/${editor.options?.override}`))) {
                 this.addToHistory(editor, false );
             }
         }
@@ -698,8 +696,8 @@ let HistoryService = class HistoryService extends Disposable {
                             ...entryParsed.editor,
                             resource: typeof entryParsed.editor.resource === 'string' ?
                                 (
-                                (URI.parse(entryParsed.editor.resource))) :
-                                ( (URI.from(entryParsed.editor.resource)))
+                                URI.parse(entryParsed.editor.resource)) :
+                                ( URI.from(entryParsed.editor.resource))
                         });
                     }
                     catch (error) {
@@ -725,7 +723,7 @@ let HistoryService = class HistoryService extends Disposable {
             entries.push({
                 editor: {
                     ...editor,
-                    resource: ( (editor.resource.toString()))
+                    resource: ( editor.resource.toString())
                 }
             });
         }
@@ -790,18 +788,18 @@ let HistoryService = class HistoryService extends Disposable {
         }
     }
 };
-HistoryService = HistoryService_1 = ( (__decorate([
-    ( (__param(0, IEditorService))),
-    ( (__param(1, IEditorGroupsService))),
-    ( (__param(2, IWorkspaceContextService))),
-    ( (__param(3, IStorageService))),
-    ( (__param(4, IConfigurationService))),
-    ( (__param(5, IFileService))),
-    ( (__param(6, IWorkspacesService))),
-    ( (__param(7, IInstantiationService))),
-    ( (__param(8, IWorkbenchLayoutService))),
-    ( (__param(9, IContextKeyService)))
-], HistoryService)));
+HistoryService = HistoryService_1 = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IFileService)),
+    ( __param(6, IWorkspacesService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IWorkbenchLayoutService)),
+    ( __param(9, IContextKeyService))
+], HistoryService));
 class EditorSelectionState {
     constructor(editorIdentifier, selection, reason) {
         this.editorIdentifier = editorIdentifier;
@@ -903,9 +901,9 @@ let EditorNavigationStacks = class EditorNavigationStacks extends Disposable {
         }
     }
 };
-EditorNavigationStacks = ( (__decorate([
-    ( (__param(1, IInstantiationService)))
-], EditorNavigationStacks)));
+EditorNavigationStacks = ( __decorate([
+    ( __param(1, IInstantiationService))
+], EditorNavigationStacks));
 class NoOpEditorNavigationStacks {
     constructor() {
         this.onDidChange = Event.None;
@@ -943,10 +941,10 @@ let EditorNavigationStack = class EditorNavigationStack extends Disposable {
         this.editorService = editorService;
         this.editorGroupService = editorGroupService;
         this.logService = logService;
-        this._onDidChange = this._register(( (new Emitter())));
+        this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
-        this.mapEditorToDisposable = ( (new Map()));
-        this.mapGroupToDisposable = ( (new Map()));
+        this.mapEditorToDisposable = ( new Map());
+        this.mapGroupToDisposable = ( new Map());
         this.editorHelper = this.instantiationService.createInstance(EditorHelper);
         this.stack = [];
         this.index = -1;
@@ -1029,7 +1027,7 @@ ${entryLabels.join('\n')}
         }
     }
     registerGroupListeners(groupId) {
-        if (!( (this.mapGroupToDisposable.has(groupId)))) {
+        if (!( this.mapGroupToDisposable.has(groupId))) {
             const group = this.editorGroupService.getGroup(groupId);
             if (group) {
                 this.mapGroupToDisposable.set(groupId, group.onWillMoveEditor(e => this.onWillMoveEditor(e)));
@@ -1059,11 +1057,11 @@ ${entryLabels.join('\n')}
             this.trace(`notifyNavigation() ignoring (navigating)`, editorPane?.input, event);
             if (isSelectionAwareEditorPane && hasValidEditor) {
                 this.trace('notifyNavigation() updating current selection state', editorPane?.input, event);
-                this.currentSelectionState = ( (new EditorSelectionState(
+                this.currentSelectionState = ( new EditorSelectionState(
                     { groupId: editorPane.group.id, editor: editorPane.input },
                     editorPane.getSelection(),
                     event?.reason
-                )));
+                ));
             }
             else {
                 this.trace('notifyNavigation() dropping current selection state', editorPane?.input, event);
@@ -1088,7 +1086,7 @@ ${entryLabels.join('\n')}
             return;
         }
         this.trace('onSelectionAwareEditorNavigation()', editor, event);
-        const stateCandidate = ( (new EditorSelectionState({ groupId, editor }, selection, event?.reason)));
+        const stateCandidate = ( new EditorSelectionState({ groupId, editor }, selection, event?.reason));
         if (!this.currentSelectionState || this.currentSelectionState.justifiesNewNavigationEntry(stateCandidate)) {
             this.doAdd(groupId, editor, stateCandidate.selection);
         }
@@ -1356,12 +1354,12 @@ ${entryLabels.join('\n')}
         return this.navigating;
     }
 };
-EditorNavigationStack = EditorNavigationStack_1 = ( (__decorate([
-    ( (__param(2, IInstantiationService))),
-    ( (__param(3, IEditorService))),
-    ( (__param(4, IEditorGroupsService))),
-    ( (__param(5, ILogService)))
-], EditorNavigationStack)));
+EditorNavigationStack = EditorNavigationStack_1 = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IEditorGroupsService)),
+    ( __param(5, ILogService))
+], EditorNavigationStack));
 let EditorHelper = class EditorHelper {
     constructor(uriIdentityService, lifecycleService, fileService, pathService) {
         this.uriIdentityService = uriIdentityService;
@@ -1441,7 +1439,7 @@ let EditorHelper = class EditorHelper {
         const toDispose = Event.once(editor.onWillDispose)(() => listener());
         let disposables = mapEditorToDispose.get(editor);
         if (!disposables) {
-            disposables = ( (new DisposableStore()));
+            disposables = ( new DisposableStore());
             mapEditorToDispose.set(editor, disposables);
         }
         disposables.add(toDispose);
@@ -1457,11 +1455,11 @@ let EditorHelper = class EditorHelper {
         }
     }
 };
-EditorHelper = ( (__decorate([
-    ( (__param(0, IUriIdentityService))),
-    ( (__param(1, ILifecycleService))),
-    ( (__param(2, IFileService))),
-    ( (__param(3, IPathService)))
-], EditorHelper)));
+EditorHelper = ( __decorate([
+    ( __param(0, IUriIdentityService)),
+    ( __param(1, ILifecycleService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IPathService))
+], EditorHelper));
 
 export { EditorNavigationStack, HistoryService };

package/vscode/src/vs/workbench/services/hover/browser/hoverService.js

@@ -34,7 +34,7 @@ let HoverService = class HoverService {
                 this._lastFocusedElementBeforeOpen = undefined;
             }
         }
-        const hoverDisposables = ( (new DisposableStore()));
+        const hoverDisposables = ( new DisposableStore());
         const hover = this._instantiationService.createInstance(HoverWidget, options);
         hover.onDispose(() => {
             this._lastFocusedElementBeforeOpen?.focus();
@@ -44,7 +44,7 @@ let HoverService = class HoverService {
             hoverDisposables.dispose();
         });
         const provider = this._contextViewService;
-        provider.showContextView(( (new HoverContextViewDelegate(hover, focus))), options.container);
+        provider.showContextView(( new HoverContextViewDelegate(hover, focus)), options.container);
         hover.onRequestLayout(() => provider.layout());
         if ('targetElements' in options.target) {
             for (const element of options.target.targetElements) {
@@ -62,7 +62,7 @@ let HoverService = class HoverService {
             hoverDisposables.add(addDisposableListener(document, EventType.KEY_UP, e => this._keyUp(e, hover)));
         }
         if ('IntersectionObserver' in window) {
-            const observer = ( (new IntersectionObserver(e => this._intersectionChange(e, hover), { threshold: 0 })));
+            const observer = ( new IntersectionObserver(e => this._intersectionChange(e, hover), { threshold: 0 }));
             const firstTargetElement = 'targetElements' in options.target ? options.target.targetElements[0] : options.target;
             observer.observe(firstTargetElement);
             hoverDisposables.add(toDisposable(() => observer.disconnect()));
@@ -95,9 +95,9 @@ let HoverService = class HoverService {
             hover.isLocked = true;
             return;
         }
-        const event = ( (new StandardKeyboardEvent(e)));
+        const event = ( new StandardKeyboardEvent(e));
         const keybinding = this._keybindingService.resolveKeyboardEvent(event);
-        if (( (keybinding.getSingleModifierDispatchChords().some(value => !!value))) || this._keybindingService.softDispatch(event, event.target).kind !== 0 ) {
+        if (( keybinding.getSingleModifierDispatchChords().some(value => !!value)) || this._keybindingService.softDispatch(event, event.target).kind !== 0 ) {
             return;
         }
         if (hideOnKeyDown && (!this._currentHoverOptions?.trapFocus || e.key !== 'Tab')) {
@@ -115,13 +115,13 @@ let HoverService = class HoverService {
         }
     }
 };
-HoverService = ( (__decorate([
-    ( (__param(0, IInstantiationService))),
-    ( (__param(1, IContextViewService))),
-    ( (__param(2, IContextMenuService))),
-    ( (__param(3, IKeybindingService))),
-    ( (__param(4, IAccessibilityService)))
-], HoverService)));
+HoverService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IContextViewService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IAccessibilityService))
+], HoverService));
 function getHoverOptionsIdentity(options) {
     if (options === undefined) {
         return undefined;
@@ -156,8 +156,8 @@ class HoverContextViewDelegate {
 registerThemingParticipant((theme, collector) => {
     const hoverBorder = theme.getColor(editorHoverBorder);
     if (hoverBorder) {
-        collector.addRule(`.monaco-workbench .workbench-hover .hover-row:not(:first-child):not(:empty) { border-top: 1px solid ${( ( hoverBorder.transparent(0.5)))}; }`);
-        collector.addRule(`.monaco-workbench .workbench-hover hr { border-top: 1px solid ${( ( hoverBorder.transparent(0.5)))}; }`);
+        collector.addRule(`.monaco-workbench .workbench-hover .hover-row:not(:first-child):not(:empty) { border-top: 1px solid ${( hoverBorder.transparent(0.5))}; }`);
+        collector.addRule(`.monaco-workbench .workbench-hover hr { border-top: 1px solid ${( hoverBorder.transparent(0.5))}; }`);
     }
 });