@codingame/monaco-vscode-view-common-service-override 11.1.2 → 12.0.0

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

@@ -1,13 +1,16 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { isEditorPaneWithSelection, isEditorInput, EditorResourceAccessor, EditorCloseContext, SideBySideEditor, isSideBySideEditorInput, isResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor';
+import { GroupModelChangeKind, isEditorPaneWithSelection, isEditorInput, EditorResourceAccessor, EditorsOrder, EditorCloseContext, SideBySideEditor, isSideBySideEditorInput, isResourceEditorInput, EditorPaneSelectionCompareResult, EditorPaneSelectionChangeReason } from 'vscode/vscode/vs/workbench/common/editor';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { GoScope, GoFilter } from 'vscode/vscode/vs/workbench/services/history/common/history';
 import { IHistoryService } from 'vscode/vscode/vs/workbench/services/history/common/history.service';
-import { FILES_EXCLUDE_CONFIG, FileChangesEvent, FileOperationEvent } from 'vscode/vscode/vs/platform/files/common/files';
+import { FILES_EXCLUDE_CONFIG, FileChangesEvent, FileOperation, FileOperationEvent, FileChangeType } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { Disposable, DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
@@ -18,14 +21,15 @@ import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/lay
 import { RawContextKey } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { coalesce, remove } from 'vscode/vscode/vs/base/common/arrays';
-import { registerSingleton } from 'vscode/vscode/vs/platform/instantiation/common/extensions';
+import { registerSingleton, InstantiationType } from 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { WindowIdleValue, addDisposableListener, EventType, EventHelper } from 'vscode/vscode/vs/base/browser/dom';
 import { IWorkspacesService } from 'vscode/vscode/vs/platform/workspaces/common/workspaces.service';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
-import { ResourceGlobMatcher } from 'vscode/vscode/vs/workbench/common/resources';
+import { ResourceGlobMatcher } from '@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/common/resources';
 import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { LogLevel } from 'vscode/vscode/vs/platform/log/common/log';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
@@ -49,42 +53,42 @@ 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, ( localize(4201, "Whether it is possible to navigate back in editor history")))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardContextKey = (( (new RawContextKey('canNavigateForward', false, ( localize(4202, "Whether it is possible to navigate forward in editor history")))))).bindTo(this.contextKeyService);
-        this.canNavigateBackInNavigationsContextKey = (( (new RawContextKey('canNavigateBackInNavigationLocations', false, ( localize(
-            4203,
+        this.canNavigateBackContextKey = (( new RawContextKey('canNavigateBack', false, ( localize(11578, "Whether it is possible to navigate back in editor history"))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardContextKey = (( new RawContextKey('canNavigateForward', false, ( localize(11579, "Whether it is possible to navigate forward in editor history"))))).bindTo(this.contextKeyService);
+        this.canNavigateBackInNavigationsContextKey = (( new RawContextKey('canNavigateBackInNavigationLocations', false, ( localize(
+            11580,
             "Whether it is possible to navigate back in editor navigation locations history"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardInNavigationsContextKey = (( (new RawContextKey('canNavigateForwardInNavigationLocations', false, ( localize(
-            4204,
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardInNavigationsContextKey = (( new RawContextKey('canNavigateForwardInNavigationLocations', false, ( localize(
+            11581,
             "Whether it is possible to navigate forward in editor navigation locations history"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateToLastNavigationLocationContextKey = (( (new RawContextKey('canNavigateToLastNavigationLocation', false, ( localize(
-            4205,
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateToLastNavigationLocationContextKey = (( new RawContextKey('canNavigateToLastNavigationLocation', false, ( localize(
+            11582,
             "Whether it is possible to navigate to the last editor navigation location"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateBackInEditsContextKey = (( (new RawContextKey('canNavigateBackInEditLocations', false, ( localize(
-            4206,
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateBackInEditsContextKey = (( new RawContextKey('canNavigateBackInEditLocations', false, ( localize(
+            11583,
             "Whether it is possible to navigate back in editor edit locations history"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardInEditsContextKey = (( (new RawContextKey('canNavigateForwardInEditLocations', false, ( localize(
-            4207,
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardInEditsContextKey = (( new RawContextKey('canNavigateForwardInEditLocations', false, ( localize(
+            11584,
             "Whether it is possible to navigate forward in editor edit locations history"
-        )))))).bindTo(this.contextKeyService);
-        this.canNavigateToLastEditLocationContextKey = (( (new RawContextKey('canNavigateToLastEditLocation', false, ( localize(
-            4208,
+        ))))).bindTo(this.contextKeyService);
+        this.canNavigateToLastEditLocationContextKey = (( new RawContextKey('canNavigateToLastEditLocation', false, ( localize(
+            11585,
             "Whether it is possible to navigate to the last editor edit location"
-        )))))).bindTo(this.contextKeyService);
-        this.canReopenClosedEditorContextKey = (( (new RawContextKey('canReopenClosedEditor', false, ( localize(4209, "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, ( localize(11586, "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.editorNavigationScope = 0 ;
+        this.editorGroupScopedNavigationStacks = ( new Map());
+        this.editorScopedNavigationStacks = ( new Map());
+        this.editorNavigationScope = GoScope.DEFAULT;
         this.recentlyUsedEditorsStack = undefined;
         this.recentlyUsedEditorsStackIndex = 0;
         this.recentlyUsedEditorsInGroupStack = undefined;
@@ -94,12 +98,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();
@@ -124,12 +128,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);
@@ -176,7 +180,7 @@ let HistoryService = class HistoryService extends Disposable {
         else {
             this.logService.trace(`[History]: ignoring transient editor change until becoming non-transient (editor: ${activeEditorPane.input?.resource?.toString()}})`);
             const transientListener = activeEditorGroup.onDidModelChange(e => {
-                if (e.kind === 12  && e.editor === activeEditorPane.input && !activeEditorPane.group.isTransient(activeEditorPane.input)) {
+                if (e.kind === GroupModelChangeKind.EDITOR_TRANSIENT && e.editor === activeEditorPane.input && !activeEditorPane.group.isTransient(activeEditorPane.input)) {
                     transientListener.dispose();
                     this.handleActiveEditorChange(activeEditorGroup, activeEditorPane);
                 }
@@ -202,10 +206,10 @@ let HistoryService = class HistoryService extends Disposable {
             }
         }
         else {
-            if (event.isOperation(1 )) {
+            if (event.isOperation(FileOperation.DELETE)) {
                 this.remove(event);
             }
-            else if (event.isOperation(2 ) && event.target.isFile) {
+            else if (event.isOperation(FileOperation.MOVE) && event.target.isFile) {
                 this.move(event);
             }
         }
@@ -249,14 +253,14 @@ let HistoryService = class HistoryService extends Disposable {
     updateContextKeys() {
         this.contextKeyService.bufferChangeEvents(() => {
             const activeStack = this.getStack();
-            this.canNavigateBackContextKey.set(activeStack.canGoBack(0 ));
-            this.canNavigateForwardContextKey.set(activeStack.canGoForward(0 ));
-            this.canNavigateBackInNavigationsContextKey.set(activeStack.canGoBack(2 ));
-            this.canNavigateForwardInNavigationsContextKey.set(activeStack.canGoForward(2 ));
-            this.canNavigateToLastNavigationLocationContextKey.set(activeStack.canGoLast(2 ));
-            this.canNavigateBackInEditsContextKey.set(activeStack.canGoBack(1 ));
-            this.canNavigateForwardInEditsContextKey.set(activeStack.canGoForward(1 ));
-            this.canNavigateToLastEditLocationContextKey.set(activeStack.canGoLast(1 ));
+            this.canNavigateBackContextKey.set(activeStack.canGoBack(GoFilter.NONE));
+            this.canNavigateForwardContextKey.set(activeStack.canGoForward(GoFilter.NONE));
+            this.canNavigateBackInNavigationsContextKey.set(activeStack.canGoBack(GoFilter.NAVIGATION));
+            this.canNavigateForwardInNavigationsContextKey.set(activeStack.canGoForward(GoFilter.NAVIGATION));
+            this.canNavigateToLastNavigationLocationContextKey.set(activeStack.canGoLast(GoFilter.NAVIGATION));
+            this.canNavigateBackInEditsContextKey.set(activeStack.canGoBack(GoFilter.EDITS));
+            this.canNavigateForwardInEditsContextKey.set(activeStack.canGoForward(GoFilter.EDITS));
+            this.canNavigateToLastEditLocationContextKey.set(activeStack.canGoLast(GoFilter.EDITS));
             this.canReopenClosedEditorContextKey.set(this.recentlyClosedEditors.length > 0);
         });
     }
@@ -265,13 +269,13 @@ let HistoryService = class HistoryService extends Disposable {
             this.disposeEditorNavigationStacks();
             const configuredScope = this.configurationService.getValue(HistoryService_1.NAVIGATION_SCOPE_SETTING);
             if (configuredScope === 'editorGroup') {
-                this.editorNavigationScope = 1 ;
+                this.editorNavigationScope = GoScope.EDITOR_GROUP;
             }
             else if (configuredScope === 'editor') {
-                this.editorNavigationScope = 2 ;
+                this.editorNavigationScope = GoScope.EDITOR;
             }
             else {
-                this.editorNavigationScope = 0 ;
+                this.editorNavigationScope = GoScope.DEFAULT;
             }
         };
         this._register(this.configurationService.onDidChangeConfiguration(event => {
@@ -283,39 +287,37 @@ let HistoryService = class HistoryService extends Disposable {
     }
     getStack(group = this.editorGroupService.activeGroup, editor = group.activeEditor) {
         switch (this.editorNavigationScope) {
-            case 2 : {
+            case GoScope.EDITOR: {
                 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()));
-                    stack = disposable.add(this.instantiationService.createInstance(EditorNavigationStacks, 2 ));
+                    const disposable = ( new DisposableStore());
+                    stack = disposable.add(this.instantiationService.createInstance(EditorNavigationStacks, GoScope.EDITOR));
                     disposable.add(stack.onDidChange(() => this._onDidChangeEditorNavigationStack.fire()));
                     stacksForGroup.set(editor, { stack, disposable });
                 }
                 return stack;
             }
-            case 1 : {
+            case GoScope.EDITOR_GROUP: {
                 let stack = this.editorGroupScopedNavigationStacks.get(group.id)?.stack;
                 if (!stack) {
-                    const disposable = ( (new DisposableStore()));
-                    stack = disposable.add(this.instantiationService.createInstance(EditorNavigationStacks, 1 ));
+                    const disposable = ( new DisposableStore());
+                    stack = disposable.add(this.instantiationService.createInstance(EditorNavigationStacks, GoScope.EDITOR_GROUP));
                     disposable.add(stack.onDidChange(() => this._onDidChangeEditorNavigationStack.fire()));
                     this.editorGroupScopedNavigationStacks.set(group.id, { stack, disposable });
                 }
                 return stack;
             }
-            case 0 : {
+            case GoScope.DEFAULT: {
                 if (!this.defaultScopedEditorNavigationStack) {
-                    this.defaultScopedEditorNavigationStack = this._register(this.instantiationService.createInstance(EditorNavigationStacks, 0 ));
+                    this.defaultScopedEditorNavigationStack = this._register(this.instantiationService.createInstance(EditorNavigationStacks, GoScope.DEFAULT));
                     this._register(this.defaultScopedEditorNavigationStack.onDidChange(() => this._onDidChangeEditorNavigationStack.fire()));
                 }
                 return this.defaultScopedEditorNavigationStack;
@@ -433,11 +435,11 @@ let HistoryService = class HistoryService extends Disposable {
         let index;
         const group = typeof groupId === 'number' ? this.editorGroupService.getGroup(groupId) : undefined;
         if (!group) {
-            editors = this.recentlyUsedEditorsStack || this.editorService.getEditors(0 );
+            editors = this.recentlyUsedEditorsStack || this.editorService.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE);
             index = this.recentlyUsedEditorsStackIndex;
         }
         else {
-            editors = this.recentlyUsedEditorsInGroupStack || ( (group.getEditors(0 ).map(editor => ({ groupId: group.id, editor }))));
+            editors = this.recentlyUsedEditorsInGroupStack || ( group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).map(editor => ({ groupId: group.id, editor })));
             index = this.recentlyUsedEditorsInGroupStackIndex;
         }
         let newIndex = indexModifier(index);
@@ -546,9 +548,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;
@@ -624,7 +626,7 @@ let HistoryService = class HistoryService extends Disposable {
         });
     }
     moveInHistory(event) {
-        if (event.isOperation(2 )) {
+        if (event.isOperation(FileOperation.MOVE)) {
             const removed = this.removeFromHistory(event);
             if (removed) {
                 this.addToHistory({ resource: event.target.resource });
@@ -656,7 +658,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);
             }
         }
@@ -693,29 +695,33 @@ let HistoryService = class HistoryService extends Disposable {
     loadHistory() {
         this.history = [];
         const storedEditorHistory = this.loadHistoryFromStorage();
-        const openedEditorsLru = [...this.editorService.getEditors(0 )].reverse();
-        const handledEditors = ( (new Set()));
+        const openedEditorsLru = [...this.editorService.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)].reverse();
+        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}`);
+                const historyEntryId = `${( editor.resource.toString())}/${editor.editorId}`;
+                if (( handledEditors.has(historyEntryId))) {
+                    continue;
+                }
+                handledEditors.add(historyEntryId);
             }
+            this.addToHistory(editor);
         }
         for (const editor of storedEditorHistory) {
-            if (!( (handledEditors.has(
-                `${( (editor.resource.toString()))}/${editor.options?.override}`
-            ))) &&
+            const historyEntryId = `${( editor.resource.toString())}/${editor.options?.override}`;
+            if (!( handledEditors.has(historyEntryId)) &&
                 this.includeInHistory(editor)) {
+                handledEditors.add(historyEntryId);
                 this.addToHistory(editor, false );
             }
         }
     }
     loadHistoryFromStorage() {
         const entries = [];
-        const entriesRaw = this.storageService.get(HistoryService_1.HISTORY_STORAGE_KEY, 1 );
+        const entriesRaw = this.storageService.get(HistoryService_1.HISTORY_STORAGE_KEY, StorageScope.WORKSPACE);
         if (entriesRaw) {
             try {
                 const entriesParsed = JSON.parse(entriesRaw);
@@ -728,8 +734,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) {
@@ -755,11 +761,11 @@ let HistoryService = class HistoryService extends Disposable {
             entries.push({
                 editor: {
                     ...editor,
-                    resource: ( (editor.resource.toString()))
+                    resource: ( editor.resource.toString())
                 }
             });
         }
-        this.storageService.store(HistoryService_1.HISTORY_STORAGE_KEY, JSON.stringify(entries), 1 , 1 );
+        this.storageService.store(HistoryService_1.HISTORY_STORAGE_KEY, JSON.stringify(entries), StorageScope.WORKSPACE, StorageTarget.MACHINE);
     }
     getLastActiveWorkspaceRoot(schemeFilter, authorityFilter) {
         const folders = this.contextService.getWorkspace().folders;
@@ -826,20 +832,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, InstantiationType.Eager));
 class EditorSelectionState {
     constructor(editorIdentifier, selection, reason) {
         this.editorIdentifier = editorIdentifier;
@@ -857,10 +863,10 @@ class EditorSelectionState {
             return true;
         }
         const result = this.selection.compare(other.selection);
-        if (result === 2  && ((other.reason === 4  || other.reason === 5) )) {
+        if (result === EditorPaneSelectionCompareResult.SIMILAR && (other.reason === EditorPaneSelectionChangeReason.NAVIGATION || other.reason === EditorPaneSelectionChangeReason.JUMP)) {
             return true;
         }
-        return result === 3 ;
+        return result === EditorPaneSelectionCompareResult.DIFFERENT;
     }
 }
 let EditorNavigationStacks = class EditorNavigationStacks extends Disposable {
@@ -868,9 +874,9 @@ let EditorNavigationStacks = class EditorNavigationStacks extends Disposable {
         super();
         this.scope = scope;
         this.instantiationService = instantiationService;
-        this.selectionsStack = this._register(this.instantiationService.createInstance(EditorNavigationStack, 0 , this.scope));
-        this.editsStack = this._register(this.instantiationService.createInstance(EditorNavigationStack, 1 , this.scope));
-        this.navigationsStack = this._register(this.instantiationService.createInstance(EditorNavigationStack, 2 , this.scope));
+        this.selectionsStack = this._register(this.instantiationService.createInstance(EditorNavigationStack, GoFilter.NONE, this.scope));
+        this.editsStack = this._register(this.instantiationService.createInstance(EditorNavigationStack, GoFilter.EDITS, this.scope));
+        this.navigationsStack = this._register(this.instantiationService.createInstance(EditorNavigationStack, GoFilter.NAVIGATION, this.scope));
         this.stacks = [
             this.selectionsStack,
             this.editsStack,
@@ -899,11 +905,11 @@ let EditorNavigationStacks = class EditorNavigationStacks extends Disposable {
     goLast(filter) {
         return this.getStack(filter).goLast();
     }
-    getStack(filter = 0 ) {
+    getStack(filter = GoFilter.NONE) {
         switch (filter) {
-            case 0 : return this.selectionsStack;
-            case 1 : return this.editsStack;
-            case 2 : return this.navigationsStack;
+            case GoFilter.NONE: return this.selectionsStack;
+            case GoFilter.EDITS: return this.editsStack;
+            case GoFilter.NAVIGATION: return this.navigationsStack;
         }
     }
     handleActiveEditorChange(editorPane) {
@@ -912,12 +918,12 @@ let EditorNavigationStacks = class EditorNavigationStacks extends Disposable {
     handleActiveEditorSelectionChange(editorPane, event) {
         const previous = this.selectionsStack.current;
         this.selectionsStack.notifyNavigation(editorPane, event);
-        if (event.reason === 3 ) {
+        if (event.reason === EditorPaneSelectionChangeReason.EDIT) {
             this.editsStack.notifyNavigation(editorPane, event);
         }
-        else if (((event.reason === 4  || event.reason === 5) ) &&
+        else if ((event.reason === EditorPaneSelectionChangeReason.NAVIGATION || event.reason === EditorPaneSelectionChangeReason.JUMP) &&
             !this.selectionsStack.isNavigating()) {
-            if (event.reason === 5  && !this.navigationsStack.isNavigating()) {
+            if (event.reason === EditorPaneSelectionChangeReason.JUMP && !this.navigationsStack.isNavigating()) {
                 if (previous) {
                     this.navigationsStack.addOrReplace(previous.groupId, previous.editor, previous.selection);
                 }
@@ -941,9 +947,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;
@@ -981,10 +987,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;
@@ -1025,25 +1031,25 @@ ${entryLabels.join('\n')}
         }
         let filterLabel;
         switch (this.filter) {
-            case 0 :
+            case GoFilter.NONE:
                 filterLabel = 'global';
                 break;
-            case 1 :
+            case GoFilter.EDITS:
                 filterLabel = 'edits';
                 break;
-            case 2 :
+            case GoFilter.NAVIGATION:
                 filterLabel = 'navigation';
                 break;
         }
         let scopeLabel;
         switch (this.scope) {
-            case 0 :
+            case GoScope.DEFAULT:
                 scopeLabel = 'default';
                 break;
-            case 1 :
+            case GoScope.EDITOR_GROUP:
                 scopeLabel = 'editorGroup';
                 break;
-            case 2 :
+            case GoScope.EDITOR:
                 scopeLabel = 'editor';
                 break;
         }
@@ -1059,15 +1065,15 @@ ${entryLabels.join('\n')}
             return '<none>';
         }
         switch (event.reason) {
-            case 3 : return 'edit';
-            case 4 : return 'navigation';
-            case 5 : return 'jump';
-            case 1 : return 'programmatic';
-            case 2 : return 'user';
+            case EditorPaneSelectionChangeReason.EDIT: return 'edit';
+            case EditorPaneSelectionChangeReason.NAVIGATION: return 'navigation';
+            case EditorPaneSelectionChangeReason.JUMP: return 'jump';
+            case EditorPaneSelectionChangeReason.PROGRAMMATIC: return 'programmatic';
+            case EditorPaneSelectionChangeReason.USER: return 'user';
         }
     }
     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)));
@@ -1076,7 +1082,7 @@ ${entryLabels.join('\n')}
     }
     onWillMoveEditor(e) {
         this.trace('onWillMoveEditor()', e.editor);
-        if (this.scope === 1 ) {
+        if (this.scope === GoScope.EDITOR_GROUP) {
             return;
         }
         for (const entry of this.stack) {
@@ -1097,11 +1103,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);
@@ -1126,7 +1132,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);
         }
@@ -1220,10 +1226,10 @@ ${entryLabels.join('\n')}
         if (!candidate.selection) {
             return false;
         }
-        return entry.selection.compare(candidate.selection) === 1 ;
+        return entry.selection.compare(candidate.selection) === EditorPaneSelectionCompareResult.IDENTICAL;
     }
     move(event) {
-        if (event.isOperation(2 )) {
+        if (event.isOperation(FileOperation.MOVE)) {
             for (const entry of this.stack) {
                 if (this.editorHelper.matchesEditor(event, entry.editor)) {
                     entry.editor = { resource: event.target.resource };
@@ -1331,7 +1337,7 @@ ${entryLabels.join('\n')}
         return this.navigate();
     }
     async maybeGoCurrent() {
-        if (this.filter === 0 ) {
+        if (this.filter === GoFilter.NONE) {
             return false;
         }
         if (this.isCurrentSelectionActive()) {
@@ -1358,7 +1364,7 @@ ${entryLabels.join('\n')}
         if (!paneSelection) {
             return false;
         }
-        return paneSelection.compare(this.current.selection) === 1 ;
+        return paneSelection.compare(this.current.selection) === EditorPaneSelectionCompareResult.IDENTICAL;
     }
     setIndex(newIndex, skipEvent) {
         this.previousIndex = this.index;
@@ -1398,12 +1404,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;
@@ -1436,7 +1442,7 @@ let EditorHelper = class EditorHelper {
                 return false;
             }
             if (arg1 instanceof FileChangesEvent) {
-                return arg1.contains(inputB.resource, 2 );
+                return arg1.contains(inputB.resource, FileChangeType.DELETED);
             }
             return this.matchesFile(inputB.resource, arg1);
         }
@@ -1453,7 +1459,7 @@ let EditorHelper = class EditorHelper {
     }
     matchesFile(resource, arg2) {
         if (arg2 instanceof FileChangesEvent) {
-            return arg2.contains(resource, 2 );
+            return arg2.contains(resource, FileChangeType.DELETED);
         }
         if (arg2 instanceof FileOperationEvent) {
             return this.uriIdentityService.extUri.isEqualOrParent(resource, arg2.resource);
@@ -1463,7 +1469,7 @@ let EditorHelper = class EditorHelper {
             if (!inputResource) {
                 return false;
             }
-            if (this.lifecycleService.phase >= 3  && !this.fileService.hasProvider(inputResource)) {
+            if (this.lifecycleService.phase >= LifecyclePhase.Restored && !this.fileService.hasProvider(inputResource)) {
                 return false;
             }
             return this.uriIdentityService.extUri.isEqual(inputResource, resource);
@@ -1483,7 +1489,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);
@@ -1499,11 +1505,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 };