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

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { isRelativePattern } from 'vscode/vscode/vs/base/common/glob';
 import { insert, distinct } from 'vscode/vscode/vs/base/common/arrays';
 import { Disposable, toDisposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
@@ -9,20 +10,22 @@ import { EditorResolution, EditorActivation } from 'vscode/vscode/vs/platform/ed
 import { isResourceSideBySideEditorInput, EditorResourceAccessor, SideBySideEditor, isEditorInputWithOptions, DEFAULT_EDITOR_ASSOCIATION, isResourceDiffEditorInput, isEditorInputWithOptionsAndGroup, isResourceMergeEditorInput, isResourceMultiDiffEditorInput, isUntitledResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor';
 import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { globMatchesResource, editorsAssociationsSettingId, RegisteredEditorPriority, priorityToRank } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { ResolvedStatus, globMatchesResource, editorsAssociationsSettingId, RegisteredEditorPriority, priorityToRank } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
 import { localize } from 'vscode/vscode/vs/nls';
 import 'vscode/vscode/vs/platform/notification/common/notification';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { findGroup } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupFinder';
-import { SideBySideEditorInput } from 'vscode/vscode/vs/workbench/common/editor/sideBySideEditorInput';
+import { findGroup } from '@codingame/monaco-vscode-b8988f79-16c1-5bff-b0e7-699bab3431da-common/vscode/vs/workbench/services/editor/common/editorGroupFinder';
+import { SideBySideEditorInput } from '@codingame/monaco-vscode-5108c2c9-4ada-52d8-8c4b-fe03b3160e71-common/vscode/vs/workbench/common/editor/sideBySideEditorInput';
 import { PauseableEmitter } from 'vscode/vscode/vs/base/common/event';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 
 var EditorResolverService_1;
 let EditorResolverService = class EditorResolverService extends Disposable {
@@ -41,15 +44,15 @@ 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(
-            JSON.parse(this.storageService.get(EditorResolverService_1.cacheStorageID, 0 , JSON.stringify([])))
-        )));
-        this.storageService.remove(EditorResolverService_1.cacheStorageID, 0 );
+        this.cache = ( new Set(
+            JSON.parse(this.storageService.get(EditorResolverService_1.cacheStorageID, StorageScope.PROFILE, JSON.stringify([])))
+        ));
+        this.storageService.remove(EditorResolverService_1.cacheStorageID, StorageScope.PROFILE);
         this._register(this.storageService.onWillSaveState(() => {
             this.cacheEditors();
         }));
@@ -82,7 +85,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             resolvedUntypedAndGroup = resolvedUntypedAndGroupResult;
         }
         if (!resolvedUntypedAndGroup) {
-            return 2 ;
+            return ResolvedStatus.NONE;
         }
         const [untypedEditor, group, activation] = resolvedUntypedAndGroup;
         if (activation) {
@@ -93,34 +96,34 @@ 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 ;
+            return ResolvedStatus.NONE;
         }
         if (untypedEditor.options?.override === EditorResolution.PICK) {
             const picked = await this.doPickEditor(untypedEditor);
             if (!picked) {
-                return 1 ;
+                return ResolvedStatus.ABORT;
             }
             untypedEditor.options = picked;
         }
         let { editor: selectedEditor, conflictingDefault } = this.getEditor(resource, untypedEditor.options?.override);
         if (!selectedEditor && (untypedEditor.options?.override || isEditorInputWithOptions(editor))) {
-            return 2 ;
+            return ResolvedStatus.NONE;
         }
         else if (!selectedEditor) {
             const resolvedEditor = this.getEditor(resource, DEFAULT_EDITOR_ASSOCIATION.id);
             selectedEditor = resolvedEditor?.editor;
             conflictingDefault = resolvedEditor?.conflictingDefault;
             if (!selectedEditor) {
-                return 2 ;
+                return ResolvedStatus.NONE;
             }
         }
         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) {
@@ -129,12 +132,12 @@ let EditorResolverService = class EditorResolverService extends Disposable {
                 conflictingDefault = conflictingDefaultDiff;
             }
             if (!selectedEditor) {
-                return 2 ;
+                return ResolvedStatus.NONE;
             }
         }
         untypedEditor.options = { override: selectedEditor.editorInfo.id, ...untypedEditor.options };
         if (selectedEditor.editorFactoryObject.createDiffEditorInput === undefined && isResourceDiffEditorInput(untypedEditor)) {
-            return 2 ;
+            return ResolvedStatus.NONE;
         }
         const input = await this.doResolveEditor(untypedEditor, group, selectedEditor);
         if (conflictingDefault && input) {
@@ -147,16 +150,16 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             }
             return { ...input, group };
         }
-        return 1 ;
+        return ResolvedStatus.ABORT;
     }
     async doResolveSideBySideEditor(editor, preferredGroup) {
         const primaryResolvedEditor = await this.resolveEditor(editor.primary, preferredGroup);
         if (!isEditorInputWithOptionsAndGroup(primaryResolvedEditor)) {
-            return 2 ;
+            return ResolvedStatus.NONE;
         }
         const secondaryResolvedEditor = await this.resolveEditor(editor.secondary, primaryResolvedEditor.group ?? preferredGroup);
         if (!isEditorInputWithOptionsAndGroup(secondaryResolvedEditor)) {
-            return 2 ;
+            return ResolvedStatus.NONE;
         }
         return {
             group: primaryResolvedEditor.group ?? secondaryResolvedEditor.group,
@@ -176,7 +179,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 +237,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 +263,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         return editors;
     }
     get _registeredEditors() {
-        return Array.from(( (this._flattenedEditors.values()))).flat();
+        return Array.from(( this._flattenedEditors.values())).flat();
     }
     updateUserAssociations(globPattern, editorID) {
         const newAssociation = { viewType: editorID, filenamePattern: globPattern };
@@ -298,11 +301,9 @@ 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) => {
@@ -371,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) {
@@ -381,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) {
@@ -438,18 +439,18 @@ let EditorResolverService = class EditorResolverService extends Disposable {
     }
     async doHandleConflictingDefaults(resource, editorName, untypedInput, currentEditor, group) {
         const editors = this.findMatchingEditors(resource);
-        const storedChoices = JSON.parse(this.storageService.get(EditorResolverService_1.conflictingDefaultsStorageID, 0 , '{}'));
+        const storedChoices = JSON.parse(this.storageService.get(EditorResolverService_1.conflictingDefaultsStorageID, StorageScope.PROFILE, '{}'));
         const globForResource = `*${extname(resource)}`;
         const writeCurrentEditorsToStorage = () => {
             storedChoices[globForResource] = [];
             editors.forEach(editor => storedChoices[globForResource].push(editor.editorInfo.id));
-            this.storageService.store(EditorResolverService_1.conflictingDefaultsStorageID, JSON.stringify(storedChoices), 0 , 1 );
+            this.storageService.store(EditorResolverService_1.conflictingDefaultsStorageID, JSON.stringify(storedChoices), StorageScope.PROFILE, StorageTarget.MACHINE);
         };
         if (storedChoices[globForResource] && storedChoices[globForResource].find(editorID => editorID === currentEditor.editorId)) {
             return;
         }
-        const handle = this.notificationService.prompt(Severity$1.Warning, ( localize(4151, 'There are multiple default editors available for the resource.')), [{
-                label: ( localize(4152, 'Configure Default')),
+        const handle = this.notificationService.prompt(Severity.Warning, ( localize(11383, 'There are multiple default editors available for the resource.')), [{
+                label: ( localize(11384, 'Configure Default')),
                 run: async () => {
                     const picked = await this.doPickEditor(untypedInput, true);
                     if (!picked) {
@@ -457,7 +458,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
                     }
                     untypedInput.options = picked;
                     const replacementEditor = await this.resolveEditor(untypedInput, group);
-                    if (replacementEditor === 1  || replacementEditor === 2 ) {
+                    if (replacementEditor === ResolvedStatus.ABORT || replacementEditor === ResolvedStatus.NONE) {
                         return;
                     }
                     group.replaceEditors([
@@ -470,7 +471,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
                 }
             },
             {
-                label: ( localize(4153, 'Keep {0}', editorName)),
+                label: ( localize(11385, 'Keep {0}', editorName)),
                 run: writeCurrentEditorsToStorage
             }
         ]);
@@ -496,9 +497,9 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             }
         });
         const quickPickEntries = [];
-        const currentlyActiveLabel = ( localize(4154, "Active"));
-        const currentDefaultLabel = ( localize(4155, "Default"));
-        const currentDefaultAndActiveLabel = ( localize(4156, "Active and Default"));
+        const currentlyActiveLabel = ( localize(11386, "Active"));
+        const currentDefaultLabel = ( localize(11387, "Default"));
+        const currentDefaultAndActiveLabel = ( localize(11388, "Active and Default"));
         let defaultViewType = defaultSetting;
         if (!defaultViewType && registeredEditors.length > 2 && registeredEditors[1]?.editorInfo.priority !== RegisteredEditorPriority.option) {
             defaultViewType = registeredEditors[1]?.editorInfo.id;
@@ -523,7 +524,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             quickPickEntries.push(separator);
             const configureDefaultEntry = {
                 id: EditorResolverService_1.configureDefaultID,
-                label: ( localize(4157, "Configure default editor for '{0}'...", `*${extname(resource)}`)),
+                label: ( localize(11389, "Configure default editor for '{0}'...", `*${extname(resource)}`)),
             };
             quickPickEntries.push(configureDefaultEntry);
         }
@@ -532,14 +533,14 @@ 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 disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         const editorPicker = disposables.add(this.quickInputService.createQuickPick({ useSeparators: true }));
         const placeHolderMessage = showDefaultPicker ?
-            ( localize(4158, "Select new default editor for '{0}'", `*${extname(resource)}`)) :
-            ( localize(4159, "Select editor for '{0}'", basename(resource)));
+            ( localize(11390, "Select new default editor for '{0}'", `*${extname(resource)}`)) :
+            ( localize(11391, "Select editor for '{0}'", basename(resource)));
         editorPicker.placeholder = placeHolderMessage;
         editorPicker.canAcceptInBackground = true;
         editorPicker.items = editorPicks;
@@ -547,7 +548,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         if (firstItem) {
             editorPicker.selectedItems = [firstItem];
         }
-        const picked = await ( (new Promise(resolve => {
+        const picked = await ( new Promise(resolve => {
             disposables.add(editorPicker.onDidAccept(e => {
                 let result = undefined;
                 if (editorPicker.selectedItems.length === 1) {
@@ -573,7 +574,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
                 }
             }));
             editorPicker.show();
-        })));
+        }));
         editorPicker.dispose();
         if (picked) {
             if (picked.item.id === EditorResolverService_1.configureDefaultID) {
@@ -594,7 +595,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) {
@@ -613,7 +614,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
                 cacheStorage.add(association.filenamePattern);
             }
         }
-        this.storageService.store(EditorResolverService_1.cacheStorageID, JSON.stringify(Array.from(cacheStorage)), 0 , 1 );
+        this.storageService.store(EditorResolverService_1.cacheStorageID, JSON.stringify(Array.from(cacheStorage)), StorageScope.PROFILE, StorageTarget.MACHINE);
     }
     resourceMatchesCache(resource) {
         if (!this.cache) {
@@ -627,16 +628,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.d.ts

@@ -0,0 +1,184 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IResourceEditorInput } from "vscode/vscode/vs/platform/editor/common/editor";
+import { IEditorPane, GroupIdentifier, IEditorPaneSelection, IEditorPaneSelectionChangeEvent } from "vscode/vscode/vs/workbench/common/editor";
+import { EditorInput } from "vscode/vscode/vs/workbench/common/editor/editorInput";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { GoFilter, GoScope } from "vscode/vscode/vs/workbench/services/history/common/history";
+import { IHistoryService } from "vscode/vscode/vs/workbench/services/history/common/history.service";
+import { FileChangesEvent, FileOperationEvent } 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 } from "vscode/vscode/vs/base/common/lifecycle";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IEditorGroupsService } from "vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { EditorServiceImpl } from "vscode/vscode/vs/workbench/browser/parts/editor/editor";
+import { IWorkbenchLayoutService } from "vscode/vscode/vs/workbench/services/layout/browser/layoutService.service";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IWorkspacesService } from "vscode/vscode/vs/platform/workspaces/common/workspaces.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+export declare class HistoryService extends Disposable implements IHistoryService {
+    private readonly editorService;
+    private readonly editorGroupService;
+    private readonly contextService;
+    private readonly storageService;
+    private readonly configurationService;
+    private readonly fileService;
+    private readonly workspacesService;
+    private readonly instantiationService;
+    private readonly layoutService;
+    private readonly contextKeyService;
+    private readonly logService;
+    readonly _serviceBrand: undefined;
+    private static readonly MOUSE_NAVIGATION_SETTING;
+    private static readonly NAVIGATION_SCOPE_SETTING;
+    private readonly activeEditorListeners;
+    private lastActiveEditor;
+    private readonly editorHelper;
+    constructor(editorService: EditorServiceImpl, editorGroupService: IEditorGroupsService, contextService: IWorkspaceContextService, storageService: IStorageService, configurationService: IConfigurationService, fileService: IFileService, workspacesService: IWorkspacesService, instantiationService: IInstantiationService, layoutService: IWorkbenchLayoutService, contextKeyService: IContextKeyService, logService: ILogService);
+    private registerListeners;
+    private onDidCloseEditor;
+    private registerMouseNavigationListener;
+    private onMouseDownOrUp;
+    private onDidRemoveGroup;
+    private onDidActiveEditorChange;
+    private onDidFilesChange;
+    private handleActiveEditorChange;
+    private handleActiveEditorSelectionChangeEvent;
+    private move;
+    private remove;
+    private removeFromRecentlyOpened;
+    clear(): void;
+    private readonly canNavigateBackContextKey;
+    private readonly canNavigateForwardContextKey;
+    private readonly canNavigateBackInNavigationsContextKey;
+    private readonly canNavigateForwardInNavigationsContextKey;
+    private readonly canNavigateToLastNavigationLocationContextKey;
+    private readonly canNavigateBackInEditsContextKey;
+    private readonly canNavigateForwardInEditsContextKey;
+    private readonly canNavigateToLastEditLocationContextKey;
+    private readonly canReopenClosedEditorContextKey;
+    updateContextKeys(): void;
+    private readonly _onDidChangeEditorNavigationStack;
+    readonly onDidChangeEditorNavigationStack: Event<void>;
+    private defaultScopedEditorNavigationStack;
+    private readonly editorGroupScopedNavigationStacks;
+    private readonly editorScopedNavigationStacks;
+    private editorNavigationScope;
+    private registerEditorNavigationScopeChangeListener;
+    private getStack;
+    goForward(filter?: GoFilter): Promise<void>;
+    goBack(filter?: GoFilter): Promise<void>;
+    goPrevious(filter?: GoFilter): Promise<void>;
+    goLast(filter?: GoFilter): Promise<void>;
+    private handleActiveEditorChangeInNavigationStacks;
+    private handleActiveEditorSelectionChangeInNavigationStacks;
+    private handleEditorCloseEventInHistory;
+    private handleEditorGroupRemoveInNavigationStacks;
+    private clearEditorNavigationStacks;
+    private removeFromEditorNavigationStacks;
+    private moveInEditorNavigationStacks;
+    private withEachEditorNavigationStack;
+    private disposeEditorNavigationStacks;
+    private recentlyUsedEditorsStack;
+    private recentlyUsedEditorsStackIndex;
+    private recentlyUsedEditorsInGroupStack;
+    private recentlyUsedEditorsInGroupStackIndex;
+    private navigatingInRecentlyUsedEditorsStack;
+    private navigatingInRecentlyUsedEditorsInGroupStack;
+    openNextRecentlyUsedEditor(groupId?: GroupIdentifier): Promise<void>;
+    openPreviouslyUsedEditor(groupId?: GroupIdentifier): Promise<void>;
+    private doNavigateInRecentlyUsedEditorsStack;
+    private ensureRecentlyUsedStack;
+    private handleEditorEventInRecentEditorsStack;
+    private static readonly MAX_RECENTLY_CLOSED_EDITORS;
+    private recentlyClosedEditors;
+    private ignoreEditorCloseEvent;
+    private handleEditorCloseEventInReopen;
+    reopenLastClosedEditor(): Promise<void>;
+    private doReopenLastClosedEditor;
+    private removeFromRecentlyClosedEditors;
+    private static readonly MAX_HISTORY_ITEMS;
+    private static readonly HISTORY_STORAGE_KEY;
+    private history;
+    private readonly editorHistoryListeners;
+    private readonly resourceExcludeMatcher;
+    private handleActiveEditorChangeInHistory;
+    private addToHistory;
+    private updateHistoryOnEditorDispose;
+    private includeInHistory;
+    private removeExcludedFromHistory;
+    private moveInHistory;
+    removeFromHistory(arg1: EditorInput | IResourceEditorInput | FileChangesEvent | FileOperationEvent): boolean;
+    private replaceInHistory;
+    clearRecentlyOpened(): void;
+    getHistory(): readonly (EditorInput | IResourceEditorInput)[];
+    private ensureHistoryLoaded;
+    private loadHistory;
+    private loadHistoryFromStorage;
+    private saveState;
+    getLastActiveWorkspaceRoot(schemeFilter?: string, authorityFilter?: string): URI | undefined;
+    getLastActiveFile(filterByScheme: string, filterByAuthority?: string): URI | undefined;
+    dispose(): void;
+}
+interface IEditorNavigationStackEntry {
+    groupId: GroupIdentifier;
+    editor: EditorInput | IResourceEditorInput;
+    selection?: IEditorPaneSelection;
+}
+export declare class EditorNavigationStack extends Disposable {
+    private readonly filter;
+    private readonly scope;
+    private readonly instantiationService;
+    private readonly editorService;
+    private readonly editorGroupService;
+    private readonly logService;
+    private static readonly MAX_STACK_SIZE;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    private readonly mapEditorToDisposable;
+    private readonly mapGroupToDisposable;
+    private readonly editorHelper;
+    private stack;
+    private index;
+    private previousIndex;
+    private navigating;
+    private currentSelectionState;
+    get current(): IEditorNavigationStackEntry | undefined;
+    private set current(value);
+    constructor(filter: GoFilter, scope: GoScope, instantiationService: IInstantiationService, editorService: IEditorService, editorGroupService: IEditorGroupsService, logService: ILogService);
+    private registerListeners;
+    private traceStack;
+    private trace;
+    private traceEvent;
+    private registerGroupListeners;
+    private onWillMoveEditor;
+    notifyNavigation(editorPane: IEditorPane | undefined, event?: IEditorPaneSelectionChangeEvent): void;
+    private onSelectionAwareEditorNavigation;
+    private onNonSelectionAwareEditorNavigation;
+    private doAdd;
+    private doReplace;
+    addOrReplace(groupId: GroupIdentifier, editorCandidate: EditorInput | IResourceEditorInput, selection?: IEditorPaneSelection, forceReplace?: boolean): void;
+    private shouldReplaceStackEntry;
+    move(event: FileOperationEvent): void;
+    remove(arg1: EditorInput | FileChangesEvent | FileOperationEvent | GroupIdentifier): void;
+    private flatten;
+    clear(): void;
+    dispose(): void;
+    canGoForward(): boolean;
+    goForward(): Promise<void>;
+    canGoBack(): boolean;
+    goBack(): Promise<void>;
+    goPrevious(): Promise<void>;
+    canGoLast(): boolean;
+    goLast(): Promise<void>;
+    private maybeGoCurrent;
+    private isCurrentSelectionActive;
+    private setIndex;
+    private navigate;
+    private doNavigate;
+    isNavigating(): boolean;
+}
+export {};