@codingame/monaco-vscode-view-common-service-override 4.5.0 → 4.5.2

package/vscode/src/vs/workbench/services/editor/browser/editorResolverService.js

@@ -25,6 +25,7 @@ import { PauseableEmitter } from 'vscode/vscode/vs/base/common/event';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
 var EditorResolverService_1;
+const _moduleId = "vs/workbench/services/editor/browser/editorResolverService";
 let EditorResolverService = class EditorResolverService extends Disposable {
     static { EditorResolverService_1 = this; }
     static { this.configureDefaultID = 'promptOpenWith.configureDefault'; }
@@ -41,14 +42,14 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         this.storageService = storageService;
         this.extensionService = extensionService;
         this.logService = logService;
-        this._onDidChangeEditorRegistrations = this._register(( new PauseableEmitter()));
+        this._onDidChangeEditorRegistrations = this._register(( (new PauseableEmitter())));
         this.onDidChangeEditorRegistrations = this._onDidChangeEditorRegistrations.event;
-        this._editors = ( new Map());
-        this._flattenedEditors = ( new Map());
+        this._editors = ( (new Map()));
+        this._flattenedEditors = ( (new Map()));
         this._shouldReFlattenEditors = true;
-        this.cache = ( new Set(
+        this.cache = ( (new Set(
             JSON.parse(this.storageService.get(EditorResolverService_1.cacheStorageID, 0 , JSON.stringify([])))
-        ));
+        )));
         this.storageService.remove(EditorResolverService_1.cacheStorageID, 0 );
         this._register(this.storageService.onWillSaveState(() => {
             this.cacheEditors();
@@ -93,7 +94,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             await this.extensionService.whenInstalledExtensionsRegistered();
         }
         if (resource === undefined) {
-            resource = ( URI.from({ scheme: Schemas.untitled }));
+            resource = ( (URI.from({ scheme: Schemas.untitled })));
         }
         else if (resource.scheme === undefined || resource === null) {
             return 2 ;
@@ -120,7 +121,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         if (isResourceDiffEditorInput(untypedEditor) && untypedEditor.options?.override === undefined) {
             let resource2 = EditorResourceAccessor.getCanonicalUri(untypedEditor, { supportSideBySide: SideBySideEditor.SECONDARY });
             if (!resource2) {
-                resource2 = ( URI.from({ scheme: Schemas.untitled }));
+                resource2 = ( (URI.from({ scheme: Schemas.untitled })));
             }
             const { editor: selectedEditor2 } = this.getEditor(resource2, undefined);
             if (!selectedEditor2 || selectedEditor.editorInfo.id !== selectedEditor2.editorInfo.id) {
@@ -176,7 +177,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
     registerEditor(globPattern, editorInfo, options, editorFactoryObject) {
         let registeredEditor = this._editors.get(globPattern);
         if (registeredEditor === undefined) {
-            registeredEditor = ( new Map());
+            registeredEditor = ( (new Map()));
             this._editors.set(globPattern, registeredEditor);
         }
         let editorsWithId = registeredEditor.get(editorInfo.id);
@@ -234,10 +235,10 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             return this._flattenedEditors;
         }
         this._shouldReFlattenEditors = false;
-        const editors = ( new Map());
+        const editors = ( (new Map()));
         for (const [glob, value] of this._editors) {
             const registeredEditors = [];
-            for (const editors of ( value.values())) {
+            for (const editors of ( (value.values()))) {
                 let registeredEditor = undefined;
                 for (const editor of editors) {
                     if (!registeredEditor) {
@@ -260,7 +261,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         return editors;
     }
     get _registeredEditors() {
-        return flatten(Array.from(( this._flattenedEditors.values())));
+        return flatten(Array.from(( (this._flattenedEditors.values()))));
     }
     updateUserAssociations(globPattern, editorID) {
         const newAssociation = { viewType: editorID, filenamePattern: globPattern };
@@ -298,9 +299,11 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             if (editors.find(e => e.editorInfo.priority === RegisteredEditorPriority.exclusive)) {
                 return [];
             }
-            return ( editors.map(editor => editor.editorInfo));
+            return (
+                 (editors.map(editor => editor.editorInfo))
+            );
         }
-        return distinct(( this._registeredEditors.map(editor => editor.editorInfo)), editor => editor.id);
+        return distinct(( (this._registeredEditors.map(editor => editor.editorInfo))), editor => editor.id);
     }
     getEditor(resource, editorId) {
         const findMatchingEditor = (editors, viewType) => {
@@ -369,7 +372,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             return { editor: inputWithOptions.editor, options: inputWithOptions.options ?? options };
         }
         if (isResourceSideBySideEditorInput(editor)) {
-            throw new Error(`Untyped side by side editor input not supported here.`);
+            throw ( (new Error(`Untyped side by side editor input not supported here.`)));
         }
         if (isUntitledResourceEditorInput(editor)) {
             if (!selectedEditor.editorFactoryObject.createUntitledEditorInput) {
@@ -379,7 +382,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             return { editor: inputWithOptions.editor, options: inputWithOptions.options ?? options };
         }
         if (resource === undefined) {
-            throw new Error(`Undefined resource on non untitled editor input.`);
+            throw ( (new Error(`Undefined resource on non untitled editor input.`)));
         }
         const singleEditorPerResource = typeof selectedEditor.options?.singlePerResource === 'function' ? selectedEditor.options.singlePerResource() : selectedEditor.options?.singlePerResource;
         if (singleEditorPerResource) {
@@ -447,15 +450,11 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             return;
         }
         const handle = this.notificationService.prompt(Severity$1.Warning, ( localizeWithPath(
-            'vs/workbench/services/editor/browser/editorResolverService',
-            'editorResolver.conflictingDefaults',
+            _moduleId,
+            0,
             'There are multiple default editors available for the resource.'
         )), [{
-                label: ( localizeWithPath(
-                    'vs/workbench/services/editor/browser/editorResolverService',
-                    'editorResolver.configureDefault',
-                    'Configure Default'
-                )),
+                label: ( localizeWithPath(_moduleId, 1, 'Configure Default')),
                 run: async () => {
                     const picked = await this.doPickEditor(untypedInput, true);
                     if (!picked) {
@@ -476,12 +475,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
                 }
             },
             {
-                label: ( localizeWithPath(
-                    'vs/workbench/services/editor/browser/editorResolverService',
-                    'editorResolver.keepDefault',
-                    'Keep {0}',
-                    editorName
-                )),
+                label: ( localizeWithPath(_moduleId, 2, 'Keep {0}', editorName)),
                 run: writeCurrentEditorsToStorage
             }
         ]);
@@ -507,21 +501,9 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             }
         });
         const quickPickEntries = [];
-        const currentlyActiveLabel = ( localizeWithPath(
-            'vs/workbench/services/editor/browser/editorResolverService',
-            'promptOpenWith.currentlyActive',
-            "Active"
-        ));
-        const currentDefaultLabel = ( localizeWithPath(
-            'vs/workbench/services/editor/browser/editorResolverService',
-            'promptOpenWith.currentDefault',
-            "Default"
-        ));
-        const currentDefaultAndActiveLabel = ( localizeWithPath(
-            'vs/workbench/services/editor/browser/editorResolverService',
-            'promptOpenWith.currentDefaultAndActive',
-            "Active and Default"
-        ));
+        const currentlyActiveLabel = ( localizeWithPath(_moduleId, 3, "Active"));
+        const currentDefaultLabel = ( localizeWithPath(_moduleId, 4, "Default"));
+        const currentDefaultAndActiveLabel = ( localizeWithPath(_moduleId, 5, "Active and Default"));
         let defaultViewType = defaultSetting;
         if (!defaultViewType && registeredEditors.length > 2 && registeredEditors[1]?.editorInfo.priority !== RegisteredEditorPriority.option) {
             defaultViewType = registeredEditors[1]?.editorInfo.id;
@@ -547,8 +529,8 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             const configureDefaultEntry = {
                 id: EditorResolverService_1.configureDefaultID,
                 label: ( localizeWithPath(
-                    'vs/workbench/services/editor/browser/editorResolverService',
-                    'promptOpenWith.configureDefault',
+                    _moduleId,
+                    6,
                     "Configure default editor for '{0}'...",
                     `*${extname(resource)}`
                 )),
@@ -560,23 +542,18 @@ let EditorResolverService = class EditorResolverService extends Disposable {
     async doPickEditor(editor, showDefaultPicker) {
         let resource = EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY });
         if (resource === undefined) {
-            resource = ( URI.from({ scheme: Schemas.untitled }));
+            resource = ( (URI.from({ scheme: Schemas.untitled })));
         }
         const editorPicks = this.mapEditorsToQuickPickEntry(resource, showDefaultPicker);
         const editorPicker = this.quickInputService.createQuickPick();
         const placeHolderMessage = showDefaultPicker ?
             ( localizeWithPath(
-                'vs/workbench/services/editor/browser/editorResolverService',
-                'promptOpenWith.updateDefaultPlaceHolder',
+                _moduleId,
+                7,
                 "Select new default editor for '{0}'",
                 `*${extname(resource)}`
             )) :
-            ( localizeWithPath(
-                'vs/workbench/services/editor/browser/editorResolverService',
-                'promptOpenWith.placeHolder',
-                "Select editor for '{0}'",
-                basename(resource)
-            ));
+            ( localizeWithPath(_moduleId, 8, "Select editor for '{0}'", basename(resource)));
         editorPicker.placeholder = placeHolderMessage;
         editorPicker.canAcceptInBackground = true;
         editorPicker.items = editorPicks;
@@ -584,7 +561,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         if (firstItem) {
             editorPicker.selectedItems = [firstItem];
         }
-        const picked = await ( new Promise(resolve => {
+        const picked = await ( (new Promise(resolve => {
             editorPicker.onDidAccept(e => {
                 let result = undefined;
                 if (editorPicker.selectedItems.length === 1) {
@@ -607,7 +584,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
                 }
             });
             editorPicker.show();
-        }));
+        })));
         editorPicker.dispose();
         if (picked) {
             if (picked.item.id === EditorResolverService_1.configureDefaultID) {
@@ -628,7 +605,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         }
     }
     cacheEditors() {
-        const cacheStorage = ( new Set());
+        const cacheStorage = ( (new Set()));
         for (const [globPattern, contribPoint] of this._flattenedEditors) {
             const nonOptional = !!contribPoint.find(c => c.editorInfo.priority !== RegisteredEditorPriority.option && c.editorInfo.id !== DEFAULT_EDITOR_ASSOCIATION.id);
             if (!nonOptional) {
@@ -661,16 +638,16 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         return false;
     }
 };
-EditorResolverService = EditorResolverService_1 = ( __decorate([
-    ( __param(0, IEditorGroupsService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IQuickInputService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, IExtensionService)),
-    ( __param(8, ILogService))
-], EditorResolverService));
+EditorResolverService = EditorResolverService_1 = ( (__decorate([
+    ( (__param(0, IEditorGroupsService))),
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IQuickInputService))),
+    ( (__param(4, INotificationService))),
+    ( (__param(5, ITelemetryService))),
+    ( (__param(6, IStorageService))),
+    ( (__param(7, IExtensionService))),
+    ( (__param(8, ILogService)))
+], EditorResolverService)));
 
 export { EditorResolverService };

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

@@ -32,6 +32,7 @@ import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 
 var HistoryService_1, EditorNavigationStack_1;
+const _moduleId = "vs/workbench/services/history/browser/historyService";
 let HistoryService = class HistoryService extends Disposable {
     static { HistoryService_1 = this; }
     static { this.MOUSE_NAVIGATION_SETTING = 'workbench.editor.mouseBackForwardToNavigate'; }
@@ -49,59 +50,51 @@ let HistoryService = class HistoryService extends Disposable {
         this.layoutService = layoutService;
         this.contextKeyService = contextKeyService;
         this.logService = logService;
-        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, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateBack',
-            "Whether it is possible to navigate back in editor history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardContextKey = (( new RawContextKey('canNavigateForward', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateForward',
+        this.canNavigateBackContextKey = (( (new RawContextKey('canNavigateBack', false, ( localizeWithPath(_moduleId, 0, "Whether it is possible to navigate back in editor history")))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardContextKey = (( (new RawContextKey('canNavigateForward', false, ( localizeWithPath(
+            _moduleId,
+            1,
             "Whether it is possible to navigate forward in editor history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateBackInNavigationsContextKey = (( new RawContextKey('canNavigateBackInNavigationLocations', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateBackInNavigationLocations',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateBackInNavigationsContextKey = (( (new RawContextKey('canNavigateBackInNavigationLocations', false, ( localizeWithPath(
+            _moduleId,
+            2,
             "Whether it is possible to navigate back in editor navigation locations history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardInNavigationsContextKey = (( new RawContextKey('canNavigateForwardInNavigationLocations', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateForwardInNavigationLocations',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardInNavigationsContextKey = (( (new RawContextKey('canNavigateForwardInNavigationLocations', false, ( localizeWithPath(
+            _moduleId,
+            3,
             "Whether it is possible to navigate forward in editor navigation locations history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateToLastNavigationLocationContextKey = (( new RawContextKey('canNavigateToLastNavigationLocation', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateToLastNavigationLocation',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateToLastNavigationLocationContextKey = (( (new RawContextKey('canNavigateToLastNavigationLocation', false, ( localizeWithPath(
+            _moduleId,
+            4,
             "Whether it is possible to navigate to the last editor navigation location"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateBackInEditsContextKey = (( new RawContextKey('canNavigateBackInEditLocations', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateBackInEditLocations',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateBackInEditsContextKey = (( (new RawContextKey('canNavigateBackInEditLocations', false, ( localizeWithPath(
+            _moduleId,
+            5,
             "Whether it is possible to navigate back in editor edit locations history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardInEditsContextKey = (( new RawContextKey('canNavigateForwardInEditLocations', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateForwardInEditLocations',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardInEditsContextKey = (( (new RawContextKey('canNavigateForwardInEditLocations', false, ( localizeWithPath(
+            _moduleId,
+            6,
             "Whether it is possible to navigate forward in editor edit locations history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateToLastEditLocationContextKey = (( new RawContextKey('canNavigateToLastEditLocation', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateToLastEditLocation',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateToLastEditLocationContextKey = (( (new RawContextKey('canNavigateToLastEditLocation', false, ( localizeWithPath(
+            _moduleId,
+            7,
             "Whether it is possible to navigate to the last editor edit location"
-        ))))).bindTo(this.contextKeyService);
-        this.canReopenClosedEditorContextKey = (( new RawContextKey('canReopenClosedEditor', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canReopenClosedEditor',
-            "Whether it is possible to reopen the last closed editor"
-        ))))).bindTo(this.contextKeyService);
-        this._onDidChangeEditorNavigationStack = this._register(( new Emitter()));
+        )))))).bindTo(this.contextKeyService);
+        this.canReopenClosedEditorContextKey = (( (new RawContextKey('canReopenClosedEditor', false, ( localizeWithPath(_moduleId, 8, "Whether it is possible to reopen the last closed editor")))))).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;
@@ -112,12 +105,12 @@ let HistoryService = class HistoryService extends Disposable {
         this.recentlyClosedEditors = [];
         this.ignoreEditorCloseEvent = false;
         this.history = undefined;
-        this.editorHistoryListeners = ( new Map());
-        this.resourceExcludeMatcher = this._register(( new WindowIdleValue(mainWindow, () => {
+        this.editorHistoryListeners = ( (new Map()));
+        this.resourceExcludeMatcher = this._register(( (new WindowIdleValue(mainWindow, () => {
             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();
@@ -142,12 +135,12 @@ 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)) {
                 this._register(Event.runAndSubscribe(this.layoutService.onDidAddContainer, ({ container, disposables }) => {
-                    const eventDisposables = disposables.add(( new DisposableStore()));
+                    const eventDisposables = disposables.add(( (new DisposableStore())));
                     eventDisposables.add(addDisposableListener(container, EventType.MOUSE_DOWN, e => this.onMouseDownOrUp(e, true)));
                     eventDisposables.add(addDisposableListener(container, EventType.MOUSE_UP, e => this.onMouseDownOrUp(e, false)));
                     mouseBackForwardSupportListener.add(eventDisposables);
@@ -296,16 +289,18 @@ 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 });
@@ -315,7 +310,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 });
@@ -446,7 +441,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);
@@ -555,9 +550,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;
@@ -665,7 +660,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);
             }
         }
@@ -703,18 +698,20 @@ 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.includeInHistory(editor)) {
                 this.addToHistory(editor, false );
             }
@@ -735,8 +732,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) {
@@ -762,7 +759,7 @@ let HistoryService = class HistoryService extends Disposable {
             entries.push({
                 editor: {
                     ...editor,
-                    resource: ( editor.resource.toString())
+                    resource: ( (editor.resource.toString()))
                 }
             });
         }
@@ -833,20 +830,20 @@ 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)),
-    ( __param(10, ILogService))
-], HistoryService));
-( registerSingleton(IHistoryService, HistoryService, 0 ));
+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))),
+    ( (__param(10, ILogService)))
+], HistoryService)));
+( (registerSingleton(IHistoryService, HistoryService, 0 )));
 class EditorSelectionState {
     constructor(editorIdentifier, selection, reason) {
         this.editorIdentifier = editorIdentifier;
@@ -948,9 +945,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;
@@ -988,10 +985,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;
@@ -1074,7 +1071,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)));
@@ -1104,11 +1101,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);
@@ -1133,7 +1130,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);
         }
@@ -1405,12 +1402,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;
@@ -1490,7 +1487,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);
@@ -1506,11 +1503,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 };