@codingame/monaco-vscode-api 1.79.0 → 1.79.1

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

@@ -0,0 +1,1451 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isEditorPaneWithSelection, isEditorInput, EditorResourceAccessor, EditorCloseContext, SideBySideEditor, isSideBySideEditorInput, isResourceEditorInput } from '../../../common/editor.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { FILES_EXCLUDE_CONFIG, FileChangesEvent, FileOperationEvent, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { Disposable, DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IEditorGroupsService } from '../../editor/common/editorGroupsService.js';
+import { getExcludes, SEARCH_EXCLUDE_CONFIG } from '../../search/common/search.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IWorkbenchLayoutService } from '../../layout/browser/layoutService.js';
+import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { coalesce, remove } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { EventHelper, addDisposableListener, EventType } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IWorkspacesService } from '../../../../platform/workspaces/common/workspaces.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IdleValue } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ResourceGlobMatcher } from '../../../common/resources.js';
+import { IPathService } from '../../path/common/pathService.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
+import { LogLevel, ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+let HistoryService = class HistoryService extends Disposable {
+    constructor(editorService, editorGroupService, contextService, storageService, configurationService, fileService, workspacesService, instantiationService, layoutService, contextKeyService) {
+        super();
+        this.editorService = editorService;
+        this.editorGroupService = editorGroupService;
+        this.contextService = contextService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.fileService = fileService;
+        this.workspacesService = workspacesService;
+        this.instantiationService = instantiationService;
+        this.layoutService = layoutService;
+        this.contextKeyService = contextKeyService;
+        this.activeEditorListeners = this._register(( (new DisposableStore())));
+        this.lastActiveEditor = undefined;
+        this.editorHelper = this.instantiationService.createInstance(EditorHelper);
+        this.canNavigateBackContextKey = (( (new RawContextKey('canNavigateBack', false,  (localize(
+            'canNavigateBack',
+            "Whether it is possible to navigate back in editor history"
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardContextKey = (( (new RawContextKey('canNavigateForward', false,  (localize(
+            'canNavigateForward',
+            "Whether it is possible to navigate forward in editor history"
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateBackInNavigationsContextKey = (( (new RawContextKey('canNavigateBackInNavigationLocations', false,  (localize(
+            'canNavigateBackInNavigationLocations',
+            "Whether it is possible to navigate back in editor navigation locations history"
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardInNavigationsContextKey = (( (new RawContextKey('canNavigateForwardInNavigationLocations', false,  (localize(
+            'canNavigateForwardInNavigationLocations',
+            "Whether it is possible to navigate forward in editor navigation locations history"
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateToLastNavigationLocationContextKey = (( (new RawContextKey('canNavigateToLastNavigationLocation', false,  (localize(
+            'canNavigateToLastNavigationLocation',
+            "Whether it is possible to navigate to the last editor navigation location"
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateBackInEditsContextKey = (( (new RawContextKey('canNavigateBackInEditLocations', false,  (localize(
+            'canNavigateBackInEditLocations',
+            "Whether it is possible to navigate back in editor edit locations history"
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardInEditsContextKey = (( (new RawContextKey('canNavigateForwardInEditLocations', false,  (localize(
+            'canNavigateForwardInEditLocations',
+            "Whether it is possible to navigate forward in editor edit locations history"
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateToLastEditLocationContextKey = (( (new RawContextKey('canNavigateToLastEditLocation', false,  (localize(
+            'canNavigateToLastEditLocation',
+            "Whether it is possible to navigate to the last editor edit location"
+        )))))).bindTo(this.contextKeyService);
+        this.canReopenClosedEditorContextKey = (( (new RawContextKey('canReopenClosedEditor', false,  (localize(
+            'canReopenClosedEditor',
+            "Whether it is possible to reopen the last closed editor"
+        )))))).bindTo(this.contextKeyService);
+        this._onDidChangeEditorNavigationStack = this._register(( (new Emitter())));
+        this.onDidChangeEditorNavigationStack = this._onDidChangeEditorNavigationStack.event;
+        this.defaultScopedEditorNavigationStack = undefined;
+        this.editorGroupScopedNavigationStacks = ( (new Map()));
+        this.editorScopedNavigationStacks = ( (new Map()));
+        this.editorNavigationScope = 0 ;
+        this.recentlyUsedEditorsStack = undefined;
+        this.recentlyUsedEditorsStackIndex = 0;
+        this.recentlyUsedEditorsInGroupStack = undefined;
+        this.recentlyUsedEditorsInGroupStackIndex = 0;
+        this.navigatingInRecentlyUsedEditorsStack = false;
+        this.navigatingInRecentlyUsedEditorsInGroupStack = false;
+        this.recentlyClosedEditors = [];
+        this.ignoreEditorCloseEvent = false;
+        this.history = undefined;
+        this.editorHistoryListeners = ( (new Map()));
+        this.resourceExcludeMatcher = this._register(( (new IdleValue(() => {
+            const matcher = this._register(this.instantiationService.createInstance(ResourceGlobMatcher, root => getExcludes(root ? this.configurationService.getValue({ resource: root }) : this.configurationService.getValue()) || Object.create(null), event => event.affectsConfiguration(FILES_EXCLUDE_CONFIG) || event.affectsConfiguration(SEARCH_EXCLUDE_CONFIG)));
+            this._register(matcher.onExpressionChange(() => this.removeExcludedFromHistory()));
+            return matcher;
+        }))));
+        this.registerListeners();
+        if (this.editorService.activeEditorPane) {
+            this.onDidActiveEditorChange();
+        }
+    }
+    registerListeners() {
+        this.registerMouseNavigationListener();
+        this._register(this.editorService.onDidActiveEditorChange(() => this.onDidActiveEditorChange()));
+        this._register(this.editorService.onDidOpenEditorFail(event => this.remove(event.editor)));
+        this._register(this.editorService.onDidCloseEditor(event => this.onDidCloseEditor(event)));
+        this._register(this.editorService.onDidMostRecentlyActiveEditorsChange(() => this.handleEditorEventInRecentEditorsStack()));
+        this._register(this.editorGroupService.onDidRemoveGroup(e => this.onDidRemoveGroup(e)));
+        this._register(this.fileService.onDidFilesChange(event => this.onDidFilesChange(event)));
+        this._register(this.fileService.onDidRunOperation(event => this.onDidFilesChange(event)));
+        this._register(this.storageService.onWillSaveState(() => this.saveState()));
+        this.registerEditorNavigationScopeChangeListener();
+        this._register(this.onDidChangeEditorNavigationStack(() => this.updateContextKeys()));
+        this._register(this.editorGroupService.onDidChangeActiveGroup(() => this.updateContextKeys()));
+    }
+    onDidCloseEditor(e) {
+        this.handleEditorCloseEventInHistory(e);
+        this.handleEditorCloseEventInReopen(e);
+    }
+    registerMouseNavigationListener() {
+        const mouseBackForwardSupportListener = this._register(( (new DisposableStore())));
+        const handleMouseBackForwardSupport = () => {
+            mouseBackForwardSupportListener.clear();
+            if (this.configurationService.getValue(HistoryService.MOUSE_NAVIGATION_SETTING)) {
+                mouseBackForwardSupportListener.add(addDisposableListener(this.layoutService.container, EventType.MOUSE_DOWN, e => this.onMouseDownOrUp(e, true)));
+                mouseBackForwardSupportListener.add(addDisposableListener(this.layoutService.container, EventType.MOUSE_UP, e => this.onMouseDownOrUp(e, false)));
+            }
+        };
+        this._register(this.configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(HistoryService.MOUSE_NAVIGATION_SETTING)) {
+                handleMouseBackForwardSupport();
+            }
+        }));
+        handleMouseBackForwardSupport();
+    }
+    onMouseDownOrUp(event, isMouseDown) {
+        switch (event.button) {
+            case 3:
+                EventHelper.stop(event);
+                if (isMouseDown) {
+                    this.goBack();
+                }
+                break;
+            case 4:
+                EventHelper.stop(event);
+                if (isMouseDown) {
+                    this.goForward();
+                }
+                break;
+        }
+    }
+    onDidRemoveGroup(group) {
+        this.handleEditorGroupRemoveInNavigationStacks(group);
+    }
+    onDidActiveEditorChange() {
+        const activeEditorGroup = this.editorGroupService.activeGroup;
+        const activeEditorPane = activeEditorGroup.activeEditorPane;
+        if (this.lastActiveEditor && this.editorHelper.matchesEditorIdentifier(this.lastActiveEditor, activeEditorPane)) {
+            return;
+        }
+        this.lastActiveEditor = activeEditorPane?.input && activeEditorPane.group ? { editor: activeEditorPane.input, groupId: activeEditorPane.group.id } : undefined;
+        this.activeEditorListeners.clear();
+        this.handleActiveEditorChange(activeEditorGroup, activeEditorPane);
+        if (isEditorPaneWithSelection(activeEditorPane)) {
+            this.activeEditorListeners.add(activeEditorPane.onDidChangeSelection(e => this.handleActiveEditorSelectionChangeEvent(activeEditorGroup, activeEditorPane, e)));
+        }
+        this.updateContextKeys();
+    }
+    onDidFilesChange(event) {
+        if (event instanceof FileChangesEvent) {
+            if (event.gotDeleted()) {
+                this.remove(event);
+            }
+        }
+        else {
+            if (event.isOperation(1 )) {
+                this.remove(event);
+            }
+            else if (event.isOperation(2 ) && event.target.isFile) {
+                this.move(event);
+            }
+        }
+    }
+    handleActiveEditorChange(group, editorPane) {
+        this.handleActiveEditorChangeInHistory(editorPane);
+        this.handleActiveEditorChangeInNavigationStacks(group, editorPane);
+    }
+    handleActiveEditorSelectionChangeEvent(group, editorPane, event) {
+        this.handleActiveEditorSelectionChangeInNavigationStacks(group, editorPane, event);
+    }
+    move(event) {
+        this.moveInHistory(event);
+        this.moveInEditorNavigationStacks(event);
+    }
+    remove(arg1) {
+        this.removeFromHistory(arg1);
+        this.removeFromEditorNavigationStacks(arg1);
+        this.removeFromRecentlyClosedEditors(arg1);
+        this.removeFromRecentlyOpened(arg1);
+    }
+    removeFromRecentlyOpened(arg1) {
+        let resource = undefined;
+        if (isEditorInput(arg1)) {
+            resource = EditorResourceAccessor.getOriginalUri(arg1);
+        }
+        else if (arg1 instanceof FileChangesEvent) ;
+        else {
+            resource = arg1.resource;
+        }
+        if (resource) {
+            this.workspacesService.removeRecentlyOpened([resource]);
+        }
+    }
+    clear() {
+        this.clearRecentlyOpened();
+        this.clearEditorNavigationStacks();
+        this.recentlyClosedEditors = [];
+        this.updateContextKeys();
+    }
+    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.canReopenClosedEditorContextKey.set(this.recentlyClosedEditors.length > 0);
+        });
+    }
+    registerEditorNavigationScopeChangeListener() {
+        const handleEditorNavigationScopeChange = () => {
+            this.disposeEditorNavigationStacks();
+            const configuredScope = this.configurationService.getValue(HistoryService.NAVIGATION_SCOPE_SETTING);
+            if (configuredScope === 'editorGroup') {
+                this.editorNavigationScope = 1 ;
+            }
+            else if (configuredScope === 'editor') {
+                this.editorNavigationScope = 2 ;
+            }
+            else {
+                this.editorNavigationScope = 0 ;
+            }
+        };
+        this._register(this.configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(HistoryService.NAVIGATION_SCOPE_SETTING)) {
+                handleEditorNavigationScopeChange();
+            }
+        }));
+        handleEditorNavigationScopeChange();
+    }
+    getStack(group = this.editorGroupService.activeGroup, editor = group.activeEditor) {
+        switch (this.editorNavigationScope) {
+            case 2 : {
+                if (!editor) {
+                    return (
+                         (new NoOpEditorNavigationStacks())
+                    );
+                }
+                let stacksForGroup = this.editorScopedNavigationStacks.get(group.id);
+                if (!stacksForGroup) {
+                    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 ));
+                    disposable.add(stack.onDidChange(() => this._onDidChangeEditorNavigationStack.fire()));
+                    stacksForGroup.set(editor, { stack, disposable });
+                }
+                return stack;
+            }
+            case 1 : {
+                let stack = this.editorGroupScopedNavigationStacks.get(group.id)?.stack;
+                if (!stack) {
+                    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 });
+                }
+                return stack;
+            }
+            case 0 : {
+                if (!this.defaultScopedEditorNavigationStack) {
+                    this.defaultScopedEditorNavigationStack = this._register(this.instantiationService.createInstance(EditorNavigationStacks, 0 ));
+                    this._register(this.defaultScopedEditorNavigationStack.onDidChange(() => this._onDidChangeEditorNavigationStack.fire()));
+                }
+                return this.defaultScopedEditorNavigationStack;
+            }
+        }
+    }
+    goForward(filter) {
+        return this.getStack().goForward(filter);
+    }
+    goBack(filter) {
+        return this.getStack().goBack(filter);
+    }
+    goPrevious(filter) {
+        return this.getStack().goPrevious(filter);
+    }
+    goLast(filter) {
+        return this.getStack().goLast(filter);
+    }
+    handleActiveEditorChangeInNavigationStacks(group, editorPane) {
+        this.getStack(group, editorPane?.input).handleActiveEditorChange(editorPane);
+    }
+    handleActiveEditorSelectionChangeInNavigationStacks(group, editorPane, event) {
+        this.getStack(group, editorPane.input).handleActiveEditorSelectionChange(editorPane, event);
+    }
+    handleEditorCloseEventInHistory(e) {
+        const editors = this.editorScopedNavigationStacks.get(e.groupId);
+        if (editors) {
+            const editorStack = editors.get(e.editor);
+            if (editorStack) {
+                editorStack.disposable.dispose();
+                editors.delete(e.editor);
+            }
+            if (editors.size === 0) {
+                this.editorScopedNavigationStacks.delete(e.groupId);
+            }
+        }
+    }
+    handleEditorGroupRemoveInNavigationStacks(group) {
+        this.defaultScopedEditorNavigationStack?.remove(group.id);
+        const editorGroupStack = this.editorGroupScopedNavigationStacks.get(group.id);
+        if (editorGroupStack) {
+            editorGroupStack.disposable.dispose();
+            this.editorGroupScopedNavigationStacks.delete(group.id);
+        }
+    }
+    clearEditorNavigationStacks() {
+        this.withEachEditorNavigationStack(stack => stack.clear());
+    }
+    removeFromEditorNavigationStacks(arg1) {
+        this.withEachEditorNavigationStack(stack => stack.remove(arg1));
+    }
+    moveInEditorNavigationStacks(event) {
+        this.withEachEditorNavigationStack(stack => stack.move(event));
+    }
+    withEachEditorNavigationStack(fn) {
+        if (this.defaultScopedEditorNavigationStack) {
+            fn(this.defaultScopedEditorNavigationStack);
+        }
+        for (const [, entry] of this.editorGroupScopedNavigationStacks) {
+            fn(entry.stack);
+        }
+        for (const [, entries] of this.editorScopedNavigationStacks) {
+            for (const [, entry] of entries) {
+                fn(entry.stack);
+            }
+        }
+    }
+    disposeEditorNavigationStacks() {
+        this.defaultScopedEditorNavigationStack?.dispose();
+        this.defaultScopedEditorNavigationStack = undefined;
+        for (const [, stack] of this.editorGroupScopedNavigationStacks) {
+            stack.disposable.dispose();
+        }
+        this.editorGroupScopedNavigationStacks.clear();
+        for (const [, stacks] of this.editorScopedNavigationStacks) {
+            for (const [, stack] of stacks) {
+                stack.disposable.dispose();
+            }
+        }
+        this.editorScopedNavigationStacks.clear();
+    }
+    openNextRecentlyUsedEditor(groupId) {
+        const [stack, index] = this.ensureRecentlyUsedStack(index => index - 1, groupId);
+        return this.doNavigateInRecentlyUsedEditorsStack(stack[index], groupId);
+    }
+    openPreviouslyUsedEditor(groupId) {
+        const [stack, index] = this.ensureRecentlyUsedStack(index => index + 1, groupId);
+        return this.doNavigateInRecentlyUsedEditorsStack(stack[index], groupId);
+    }
+    async doNavigateInRecentlyUsedEditorsStack(editorIdentifier, groupId) {
+        if (editorIdentifier) {
+            const acrossGroups = typeof groupId !== 'number' || !this.editorGroupService.getGroup(groupId);
+            if (acrossGroups) {
+                this.navigatingInRecentlyUsedEditorsStack = true;
+            }
+            else {
+                this.navigatingInRecentlyUsedEditorsInGroupStack = true;
+            }
+            const group = this.editorGroupService.getGroup(editorIdentifier.groupId) ?? this.editorGroupService.activeGroup;
+            try {
+                await group.openEditor(editorIdentifier.editor);
+            }
+            finally {
+                if (acrossGroups) {
+                    this.navigatingInRecentlyUsedEditorsStack = false;
+                }
+                else {
+                    this.navigatingInRecentlyUsedEditorsInGroupStack = false;
+                }
+            }
+        }
+    }
+    ensureRecentlyUsedStack(indexModifier, groupId) {
+        let editors;
+        let index;
+        const group = typeof groupId === 'number' ? this.editorGroupService.getGroup(groupId) : undefined;
+        if (!group) {
+            editors = this.recentlyUsedEditorsStack || this.editorService.getEditors(0 );
+            index = this.recentlyUsedEditorsStackIndex;
+        }
+        else {
+            editors = this.recentlyUsedEditorsInGroupStack || ( (group.getEditors(0 ).map(editor => ({ groupId: group.id, editor }))));
+            index = this.recentlyUsedEditorsInGroupStackIndex;
+        }
+        let newIndex = indexModifier(index);
+        if (newIndex < 0) {
+            newIndex = 0;
+        }
+        else if (newIndex > editors.length - 1) {
+            newIndex = editors.length - 1;
+        }
+        if (!group) {
+            this.recentlyUsedEditorsStack = editors;
+            this.recentlyUsedEditorsStackIndex = newIndex;
+        }
+        else {
+            this.recentlyUsedEditorsInGroupStack = editors;
+            this.recentlyUsedEditorsInGroupStackIndex = newIndex;
+        }
+        return [editors, newIndex];
+    }
+    handleEditorEventInRecentEditorsStack() {
+        if (!this.navigatingInRecentlyUsedEditorsStack) {
+            this.recentlyUsedEditorsStack = undefined;
+            this.recentlyUsedEditorsStackIndex = 0;
+        }
+        if (!this.navigatingInRecentlyUsedEditorsInGroupStack) {
+            this.recentlyUsedEditorsInGroupStack = undefined;
+            this.recentlyUsedEditorsInGroupStackIndex = 0;
+        }
+    }
+    handleEditorCloseEventInReopen(event) {
+        if (this.ignoreEditorCloseEvent) {
+            return;
+        }
+        const { editor, context } = event;
+        if (context === EditorCloseContext.REPLACE || context === EditorCloseContext.MOVE) {
+            return;
+        }
+        const untypedEditor = editor.toUntyped();
+        if (!untypedEditor) {
+            return;
+        }
+        const associatedResources = [];
+        const editorResource = EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.BOTH });
+        if (URI.isUri(editorResource)) {
+            associatedResources.push(editorResource);
+        }
+        else if (editorResource) {
+            associatedResources.push(...coalesce([editorResource.primary, editorResource.secondary]));
+        }
+        this.removeFromRecentlyClosedEditors(editor);
+        this.recentlyClosedEditors.push({
+            editorId: editor.editorId,
+            editor: untypedEditor,
+            resource: EditorResourceAccessor.getOriginalUri(editor),
+            associatedResources,
+            index: event.index,
+            sticky: event.sticky
+        });
+        if (this.recentlyClosedEditors.length > HistoryService.MAX_RECENTLY_CLOSED_EDITORS) {
+            this.recentlyClosedEditors.shift();
+        }
+        this.canReopenClosedEditorContextKey.set(true);
+    }
+    async reopenLastClosedEditor() {
+        const lastClosedEditor = this.recentlyClosedEditors.pop();
+        let reopenClosedEditorPromise = undefined;
+        if (lastClosedEditor) {
+            reopenClosedEditorPromise = this.doReopenLastClosedEditor(lastClosedEditor);
+        }
+        this.canReopenClosedEditorContextKey.set(this.recentlyClosedEditors.length > 0);
+        return reopenClosedEditorPromise;
+    }
+    async doReopenLastClosedEditor(lastClosedEditor) {
+        const options = { pinned: true, sticky: lastClosedEditor.sticky, index: lastClosedEditor.index, ignoreError: true };
+        if ((lastClosedEditor.sticky && !this.editorGroupService.activeGroup.isSticky(lastClosedEditor.index)) ||
+            (!lastClosedEditor.sticky && this.editorGroupService.activeGroup.isSticky(lastClosedEditor.index))) {
+            options.index = undefined;
+        }
+        let editorPane = undefined;
+        if (!this.editorGroupService.activeGroup.contains(lastClosedEditor.editor)) {
+            this.ignoreEditorCloseEvent = true;
+            try {
+                editorPane = await this.editorService.openEditor({
+                    ...lastClosedEditor.editor,
+                    options: {
+                        ...lastClosedEditor.editor.options,
+                        ...options
+                    }
+                });
+            }
+            finally {
+                this.ignoreEditorCloseEvent = false;
+            }
+        }
+        if (!editorPane) {
+            remove(this.recentlyClosedEditors, lastClosedEditor);
+            this.reopenLastClosedEditor();
+        }
+    }
+    removeFromRecentlyClosedEditors(arg1) {
+        this.recentlyClosedEditors = this.recentlyClosedEditors.filter(recentlyClosedEditor => {
+            if (isEditorInput(arg1) && recentlyClosedEditor.editorId !== arg1.editorId) {
+                return true;
+            }
+            if (recentlyClosedEditor.resource && this.editorHelper.matchesFile(recentlyClosedEditor.resource, arg1)) {
+                return false;
+            }
+            if (( (recentlyClosedEditor.associatedResources.some(
+                associatedResource => this.editorHelper.matchesFile(associatedResource, arg1)
+            )))) {
+                return false;
+            }
+            return true;
+        });
+        this.canReopenClosedEditorContextKey.set(this.recentlyClosedEditors.length > 0);
+    }
+    handleActiveEditorChangeInHistory(editorPane) {
+        const editor = editorPane?.input;
+        if (!editor || editor.isDisposed() || !this.includeInHistory(editor)) {
+            return;
+        }
+        this.removeFromHistory(editor);
+        this.addToHistory(editor);
+    }
+    addToHistory(editor, insertFirst = true) {
+        this.ensureHistoryLoaded(this.history);
+        const historyInput = this.editorHelper.preferResourceEditorInput(editor);
+        if (!historyInput) {
+            return;
+        }
+        if (insertFirst) {
+            this.history.unshift(historyInput);
+        }
+        else {
+            this.history.push(historyInput);
+        }
+        if (this.history.length > HistoryService.MAX_HISTORY_ITEMS) {
+            this.editorHelper.clearOnEditorDispose(this.history.pop(), this.editorHistoryListeners);
+        }
+        if (isEditorInput(historyInput)) {
+            this.editorHelper.onEditorDispose(historyInput, () => this.updateHistoryOnEditorDispose(historyInput), this.editorHistoryListeners);
+        }
+    }
+    updateHistoryOnEditorDispose(editor) {
+        if (!isSideBySideEditorInput(editor)) {
+            this.removeFromHistory(editor);
+        }
+        else {
+            const resourceInputs = [];
+            const sideInputs = editor.primary.matches(editor.secondary) ? [editor.primary] : [editor.primary, editor.secondary];
+            for (const sideInput of sideInputs) {
+                const candidateResourceInput = this.editorHelper.preferResourceEditorInput(sideInput);
+                if (isResourceEditorInput(candidateResourceInput)) {
+                    resourceInputs.push(candidateResourceInput);
+                }
+            }
+            this.replaceInHistory(editor, ...resourceInputs);
+        }
+    }
+    includeInHistory(editor) {
+        if (isEditorInput(editor)) {
+            return true;
+        }
+        return !this.resourceExcludeMatcher.value.matches(editor.resource);
+    }
+    removeExcludedFromHistory() {
+        this.ensureHistoryLoaded(this.history);
+        this.history = this.history.filter(entry => {
+            const include = this.includeInHistory(entry);
+            if (!include) {
+                this.editorHelper.clearOnEditorDispose(entry, this.editorHistoryListeners);
+            }
+            return include;
+        });
+    }
+    moveInHistory(event) {
+        if (event.isOperation(2 )) {
+            const removed = this.removeFromHistory(event);
+            if (removed) {
+                this.addToHistory({ resource: event.target.resource });
+            }
+        }
+    }
+    removeFromHistory(arg1) {
+        let removed = false;
+        this.ensureHistoryLoaded(this.history);
+        this.history = this.history.filter(entry => {
+            const matches = this.editorHelper.matchesEditor(arg1, entry);
+            if (matches) {
+                this.editorHelper.clearOnEditorDispose(arg1, this.editorHistoryListeners);
+                removed = true;
+            }
+            return !matches;
+        });
+        return removed;
+    }
+    replaceInHistory(editor, ...replacements) {
+        this.ensureHistoryLoaded(this.history);
+        let replaced = false;
+        const newHistory = [];
+        for (const entry of this.history) {
+            if (this.editorHelper.matchesEditor(editor, entry)) {
+                this.editorHelper.clearOnEditorDispose(editor, this.editorHistoryListeners);
+                if (!replaced) {
+                    newHistory.push(...replacements);
+                    replaced = true;
+                }
+            }
+            else if (!( (replacements.some(replacement => this.editorHelper.matchesEditor(replacement, entry))))) {
+                newHistory.push(entry);
+            }
+        }
+        if (!replaced) {
+            newHistory.push(...replacements);
+        }
+        this.history = newHistory;
+    }
+    clearRecentlyOpened() {
+        this.history = [];
+        for (const [, disposable] of this.editorHistoryListeners) {
+            dispose(disposable);
+        }
+        this.editorHistoryListeners.clear();
+    }
+    getHistory() {
+        this.ensureHistoryLoaded(this.history);
+        return this.history;
+    }
+    ensureHistoryLoaded(history) {
+        if (!this.history) {
+            this.history = [];
+            if (this.editorGroupService.isReady) {
+                this.loadHistory();
+            }
+            else {
+                (async () => {
+                    await this.editorGroupService.whenReady;
+                    this.loadHistory();
+                })();
+            }
+        }
+    }
+    loadHistory() {
+        this.history = [];
+        const storedEditorHistory = this.loadHistoryFromStorage();
+        const openedEditorsLru = [...this.editorService.getEditors(0 )].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}`);
+            }
+        }
+        for (const editor of storedEditorHistory) {
+            if (!( (handledEditors.has(`${( ( editor.resource.toString()))}/${editor.options?.override}`)))) {
+                this.addToHistory(editor, false );
+            }
+        }
+    }
+    loadHistoryFromStorage() {
+        const entries = [];
+        const entriesRaw = this.storageService.get(HistoryService.HISTORY_STORAGE_KEY, 1 );
+        if (entriesRaw) {
+            try {
+                const entriesParsed = JSON.parse(entriesRaw);
+                for (const entryParsed of entriesParsed) {
+                    if (!entryParsed.editor || !entryParsed.editor.resource) {
+                        continue;
+                    }
+                    try {
+                        entries.push({
+                            ...entryParsed.editor,
+                            resource: typeof entryParsed.editor.resource === 'string' ?
+                                (
+                                (URI.parse(entryParsed.editor.resource))) :
+                                ( (URI.from(entryParsed.editor.resource)))
+                        });
+                    }
+                    catch (error) {
+                        onUnexpectedError(error);
+                    }
+                }
+            }
+            catch (error) {
+                onUnexpectedError(error);
+            }
+        }
+        return entries;
+    }
+    saveState() {
+        if (!this.history) {
+            return;
+        }
+        const entries = [];
+        for (const editor of this.history) {
+            if (isEditorInput(editor) || !isResourceEditorInput(editor)) {
+                continue;
+            }
+            entries.push({
+                editor: {
+                    ...editor,
+                    resource: ( (editor.resource.toString()))
+                }
+            });
+        }
+        this.storageService.store(HistoryService.HISTORY_STORAGE_KEY, JSON.stringify(entries), 1 , 1 );
+    }
+    getLastActiveWorkspaceRoot(schemeFilter) {
+        const folders = this.contextService.getWorkspace().folders;
+        if (folders.length === 0) {
+            return undefined;
+        }
+        if (folders.length === 1) {
+            const resource = folders[0].uri;
+            if (!schemeFilter || resource.scheme === schemeFilter) {
+                return resource;
+            }
+            return undefined;
+        }
+        for (const input of this.getHistory()) {
+            if (isEditorInput(input)) {
+                continue;
+            }
+            if (schemeFilter && input.resource.scheme !== schemeFilter) {
+                continue;
+            }
+            const resourceWorkspace = this.contextService.getWorkspaceFolder(input.resource);
+            if (resourceWorkspace) {
+                return resourceWorkspace.uri;
+            }
+        }
+        for (const folder of folders) {
+            const resource = folder.uri;
+            if (!schemeFilter || resource.scheme === schemeFilter) {
+                return resource;
+            }
+        }
+        return undefined;
+    }
+    getLastActiveFile(filterByScheme) {
+        for (const input of this.getHistory()) {
+            let resource;
+            if (isEditorInput(input)) {
+                resource = EditorResourceAccessor.getOriginalUri(input, { filterByScheme });
+            }
+            else {
+                resource = input.resource;
+            }
+            if (resource?.scheme === filterByScheme) {
+                return resource;
+            }
+        }
+        return undefined;
+    }
+};
+HistoryService.MOUSE_NAVIGATION_SETTING = 'workbench.editor.mouseBackForwardToNavigate';
+HistoryService.NAVIGATION_SCOPE_SETTING = 'workbench.editor.navigationScope';
+HistoryService.MAX_RECENTLY_CLOSED_EDITORS = 20;
+HistoryService.MAX_HISTORY_ITEMS = 200;
+HistoryService.HISTORY_STORAGE_KEY = 'history.entries';
+HistoryService = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, IEditorGroupsService))),
+    ( (__param(2, IWorkspaceContextService))),
+    ( (__param(3, IStorageService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IFileService))),
+    ( (__param(6, IWorkspacesService))),
+    ( (__param(7, IInstantiationService))),
+    ( (__param(8, IWorkbenchLayoutService))),
+    ( (__param(9, IContextKeyService)))
+], HistoryService)));
+class EditorSelectionState {
+    constructor(editorIdentifier, selection, reason) {
+        this.editorIdentifier = editorIdentifier;
+        this.selection = selection;
+        this.reason = reason;
+    }
+    justifiesNewNavigationEntry(other) {
+        if (this.editorIdentifier.groupId !== other.editorIdentifier.groupId) {
+            return true;
+        }
+        if (!this.editorIdentifier.editor.matches(other.editorIdentifier.editor)) {
+            return true;
+        }
+        if (!this.selection || !other.selection) {
+            return true;
+        }
+        const result = this.selection.compare(other.selection);
+        if (result === 2  && ((other.reason === 4  || other.reason === 5) )) {
+            return true;
+        }
+        return result === 3 ;
+    }
+}
+let EditorNavigationStacks = class EditorNavigationStacks extends Disposable {
+    constructor(scope, instantiationService) {
+        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.stacks = [
+            this.selectionsStack,
+            this.editsStack,
+            this.navigationsStack
+        ];
+        this.onDidChange = Event.any(this.selectionsStack.onDidChange, this.editsStack.onDidChange, this.navigationsStack.onDidChange);
+    }
+    canGoForward(filter) {
+        return this.getStack(filter).canGoForward();
+    }
+    goForward(filter) {
+        return this.getStack(filter).goForward();
+    }
+    canGoBack(filter) {
+        return this.getStack(filter).canGoBack();
+    }
+    goBack(filter) {
+        return this.getStack(filter).goBack();
+    }
+    goPrevious(filter) {
+        return this.getStack(filter).goPrevious();
+    }
+    canGoLast(filter) {
+        return this.getStack(filter).canGoLast();
+    }
+    goLast(filter) {
+        return this.getStack(filter).goLast();
+    }
+    getStack(filter = 0 ) {
+        switch (filter) {
+            case 0 : return this.selectionsStack;
+            case 1 : return this.editsStack;
+            case 2 : return this.navigationsStack;
+        }
+    }
+    handleActiveEditorChange(editorPane) {
+        this.selectionsStack.notifyNavigation(editorPane);
+    }
+    handleActiveEditorSelectionChange(editorPane, event) {
+        const previous = this.selectionsStack.current;
+        this.selectionsStack.notifyNavigation(editorPane, event);
+        if (event.reason === 3 ) {
+            this.editsStack.notifyNavigation(editorPane, event);
+        }
+        else if (((event.reason === 4  || event.reason === 5) ) &&
+            !this.selectionsStack.isNavigating()) {
+            if (event.reason === 5  && !this.navigationsStack.isNavigating()) {
+                if (previous) {
+                    this.navigationsStack.addOrReplace(previous.groupId, previous.editor, previous.selection);
+                }
+            }
+            this.navigationsStack.notifyNavigation(editorPane, event);
+        }
+    }
+    clear() {
+        for (const stack of this.stacks) {
+            stack.clear();
+        }
+    }
+    remove(arg1) {
+        for (const stack of this.stacks) {
+            stack.remove(arg1);
+        }
+    }
+    move(event) {
+        for (const stack of this.stacks) {
+            stack.move(event);
+        }
+    }
+};
+EditorNavigationStacks = ( (__decorate([
+    ( (__param(1, IInstantiationService)))
+], EditorNavigationStacks)));
+class NoOpEditorNavigationStacks {
+    constructor() {
+        this.onDidChange = Event.None;
+    }
+    canGoForward() { return false; }
+    async goForward() { }
+    canGoBack() { return false; }
+    async goBack() { }
+    async goPrevious() { }
+    canGoLast() { return false; }
+    async goLast() { }
+    handleActiveEditorChange() { }
+    handleActiveEditorSelectionChange() { }
+    clear() { }
+    remove() { }
+    move() { }
+    dispose() { }
+}
+let EditorNavigationStack = class EditorNavigationStack extends Disposable {
+    get current() {
+        return this.stack[this.index];
+    }
+    set current(entry) {
+        if (entry) {
+            this.stack[this.index] = entry;
+        }
+    }
+    constructor(filter, scope, instantiationService, editorService, editorGroupService, logService) {
+        super();
+        this.filter = filter;
+        this.scope = scope;
+        this.instantiationService = instantiationService;
+        this.editorService = editorService;
+        this.editorGroupService = editorGroupService;
+        this.logService = logService;
+        this._onDidChange = this._register(( (new Emitter())));
+        this.onDidChange = this._onDidChange.event;
+        this.mapEditorToDisposable = ( (new Map()));
+        this.mapGroupToDisposable = ( (new Map()));
+        this.editorHelper = this.instantiationService.createInstance(EditorHelper);
+        this.stack = [];
+        this.index = -1;
+        this.previousIndex = -1;
+        this.navigating = false;
+        this.currentSelectionState = undefined;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.onDidChange(() => this.traceStack()));
+        this._register(this.logService.onDidChangeLogLevel(() => this.traceStack()));
+    }
+    traceStack() {
+        if (this.logService.getLevel() !== LogLevel.Trace) {
+            return;
+        }
+        const entryLabels = [];
+        for (const entry of this.stack) {
+            if (typeof entry.selection?.log === 'function') {
+                entryLabels.push(`- group: ${entry.groupId}, editor: ${entry.editor.resource?.toString()}, selection: ${entry.selection.log()}`);
+            }
+            else {
+                entryLabels.push(`- group: ${entry.groupId}, editor: ${entry.editor.resource?.toString()}, selection: <none>`);
+            }
+        }
+        if (entryLabels.length === 0) {
+            this.trace(`index: ${this.index}, navigating: ${this.isNavigating()}: <empty>`);
+        }
+        else {
+            this.trace(`index: ${this.index}, navigating: ${this.isNavigating()}
+${entryLabels.join('\n')}
+			`);
+        }
+    }
+    trace(msg, editor = null, event) {
+        if (this.logService.getLevel() !== LogLevel.Trace) {
+            return;
+        }
+        let filterLabel;
+        switch (this.filter) {
+            case 0 :
+                filterLabel = 'global';
+                break;
+            case 1 :
+                filterLabel = 'edits';
+                break;
+            case 2 :
+                filterLabel = 'navigation';
+                break;
+        }
+        let scopeLabel;
+        switch (this.scope) {
+            case 0 :
+                scopeLabel = 'default';
+                break;
+            case 1 :
+                scopeLabel = 'editorGroup';
+                break;
+            case 2 :
+                scopeLabel = 'editor';
+                break;
+        }
+        if (editor !== null) {
+            this.logService.trace(`[History stack ${filterLabel}-${scopeLabel}]: ${msg} (editor: ${editor?.resource?.toString()}, event: ${this.traceEvent(event)})`);
+        }
+        else {
+            this.logService.trace(`[History stack ${filterLabel}-${scopeLabel}]: ${msg}`);
+        }
+    }
+    traceEvent(event) {
+        if (!event) {
+            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';
+        }
+    }
+    registerGroupListeners(groupId) {
+        if (!( (this.mapGroupToDisposable.has(groupId)))) {
+            const group = this.editorGroupService.getGroup(groupId);
+            if (group) {
+                this.mapGroupToDisposable.set(groupId, group.onWillMoveEditor(e => this.onWillMoveEditor(e)));
+            }
+        }
+    }
+    onWillMoveEditor(e) {
+        this.trace('onWillMoveEditor()', e.editor);
+        if (this.scope === 1 ) {
+            return;
+        }
+        for (const entry of this.stack) {
+            if (entry.groupId !== e.groupId) {
+                continue;
+            }
+            if (!this.editorHelper.matchesEditor(e.editor, entry.editor)) {
+                continue;
+            }
+            entry.groupId = e.target;
+        }
+    }
+    notifyNavigation(editorPane, event) {
+        this.trace('notifyNavigation()', editorPane?.input, event);
+        const isSelectionAwareEditorPane = isEditorPaneWithSelection(editorPane);
+        const hasValidEditor = editorPane?.group && editorPane.input && !editorPane.input.isDisposed();
+        if (this.navigating) {
+            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(
+                    { groupId: editorPane.group.id, editor: editorPane.input },
+                    editorPane.getSelection(),
+                    event?.reason
+                )));
+            }
+            else {
+                this.trace('notifyNavigation() dropping current selection state', editorPane?.input, event);
+                this.currentSelectionState = undefined;
+            }
+        }
+        else {
+            this.trace(`notifyNavigation() not ignoring`, editorPane?.input, event);
+            if (isSelectionAwareEditorPane && hasValidEditor) {
+                this.onSelectionAwareEditorNavigation(editorPane.group.id, editorPane.input, editorPane.getSelection(), event);
+            }
+            else {
+                this.currentSelectionState = undefined;
+                if (hasValidEditor) {
+                    this.onNonSelectionAwareEditorNavigation(editorPane.group.id, editorPane.input);
+                }
+            }
+        }
+    }
+    onSelectionAwareEditorNavigation(groupId, editor, selection, event) {
+        if (this.current?.groupId === groupId && !selection && this.editorHelper.matchesEditor(this.current.editor, editor)) {
+            return;
+        }
+        this.trace('onSelectionAwareEditorNavigation()', editor, event);
+        const stateCandidate = ( (new EditorSelectionState({ groupId, editor }, selection, event?.reason)));
+        if (!this.currentSelectionState || this.currentSelectionState.justifiesNewNavigationEntry(stateCandidate)) {
+            this.doAdd(groupId, editor, stateCandidate.selection);
+        }
+        else {
+            this.doReplace(groupId, editor, stateCandidate.selection);
+        }
+        this.currentSelectionState = stateCandidate;
+    }
+    onNonSelectionAwareEditorNavigation(groupId, editor) {
+        if (this.current?.groupId === groupId && this.editorHelper.matchesEditor(this.current.editor, editor)) {
+            return;
+        }
+        this.trace('onNonSelectionAwareEditorNavigation()', editor);
+        this.doAdd(groupId, editor);
+    }
+    doAdd(groupId, editor, selection) {
+        if (!this.navigating) {
+            this.addOrReplace(groupId, editor, selection);
+        }
+    }
+    doReplace(groupId, editor, selection) {
+        if (!this.navigating) {
+            this.addOrReplace(groupId, editor, selection, true );
+        }
+    }
+    addOrReplace(groupId, editorCandidate, selection, forceReplace) {
+        this.registerGroupListeners(groupId);
+        let replace = false;
+        if (this.current) {
+            if (forceReplace) {
+                replace = true;
+            }
+            else if (this.shouldReplaceStackEntry(this.current, { groupId, editor: editorCandidate, selection })) {
+                replace = true;
+            }
+        }
+        const editor = this.editorHelper.preferResourceEditorInput(editorCandidate);
+        if (!editor) {
+            return;
+        }
+        if (replace) {
+            this.trace('replace()', editor);
+        }
+        else {
+            this.trace('add()', editor);
+        }
+        const newStackEntry = { groupId, editor, selection };
+        const removedEntries = [];
+        if (replace) {
+            if (this.current) {
+                removedEntries.push(this.current);
+            }
+            this.current = newStackEntry;
+        }
+        else {
+            if (this.stack.length > this.index + 1) {
+                for (let i = this.index + 1; i < this.stack.length; i++) {
+                    removedEntries.push(this.stack[i]);
+                }
+                this.stack = this.stack.slice(0, this.index + 1);
+            }
+            this.stack.splice(this.index + 1, 0, newStackEntry);
+            if (this.stack.length > EditorNavigationStack.MAX_STACK_SIZE) {
+                removedEntries.push(this.stack.shift());
+                if (this.previousIndex >= 0) {
+                    this.previousIndex--;
+                }
+            }
+            else {
+                this.setIndex(this.index + 1, true );
+            }
+        }
+        for (const removedEntry of removedEntries) {
+            this.editorHelper.clearOnEditorDispose(removedEntry.editor, this.mapEditorToDisposable);
+        }
+        if (isEditorInput(editor)) {
+            this.editorHelper.onEditorDispose(editor, () => this.remove(editor), this.mapEditorToDisposable);
+        }
+        this._onDidChange.fire();
+    }
+    shouldReplaceStackEntry(entry, candidate) {
+        if (entry.groupId !== candidate.groupId) {
+            return false;
+        }
+        if (!this.editorHelper.matchesEditor(entry.editor, candidate.editor)) {
+            return false;
+        }
+        if (!entry.selection) {
+            return true;
+        }
+        if (!candidate.selection) {
+            return false;
+        }
+        return entry.selection.compare(candidate.selection) === 1 ;
+    }
+    move(event) {
+        if (event.isOperation(2 )) {
+            for (const entry of this.stack) {
+                if (this.editorHelper.matchesEditor(event, entry.editor)) {
+                    entry.editor = { resource: event.target.resource };
+                }
+            }
+        }
+    }
+    remove(arg1) {
+        this.stack = this.stack.filter(entry => {
+            const matches = typeof arg1 === 'number' ? entry.groupId === arg1 : this.editorHelper.matchesEditor(arg1, entry.editor);
+            if (matches) {
+                this.editorHelper.clearOnEditorDispose(entry.editor, this.mapEditorToDisposable);
+            }
+            return !matches;
+        });
+        this.flatten();
+        this.index = this.stack.length - 1;
+        this.previousIndex = -1;
+        if (typeof arg1 === 'number') {
+            this.mapGroupToDisposable.get(arg1)?.dispose();
+            this.mapGroupToDisposable.delete(arg1);
+        }
+        this._onDidChange.fire();
+    }
+    flatten() {
+        const flattenedStack = [];
+        let previousEntry = undefined;
+        for (const entry of this.stack) {
+            if (previousEntry && this.shouldReplaceStackEntry(entry, previousEntry)) {
+                continue;
+            }
+            previousEntry = entry;
+            flattenedStack.push(entry);
+        }
+        this.stack = flattenedStack;
+    }
+    clear() {
+        this.index = -1;
+        this.previousIndex = -1;
+        this.stack.splice(0);
+        for (const [, disposable] of this.mapEditorToDisposable) {
+            dispose(disposable);
+        }
+        this.mapEditorToDisposable.clear();
+        for (const [, disposable] of this.mapGroupToDisposable) {
+            dispose(disposable);
+        }
+        this.mapGroupToDisposable.clear();
+    }
+    dispose() {
+        super.dispose();
+        this.clear();
+    }
+    canGoForward() {
+        return this.stack.length > this.index + 1;
+    }
+    async goForward() {
+        const navigated = await this.maybeGoCurrent();
+        if (navigated) {
+            return;
+        }
+        if (!this.canGoForward()) {
+            return;
+        }
+        this.setIndex(this.index + 1);
+        return this.navigate();
+    }
+    canGoBack() {
+        return this.index > 0;
+    }
+    async goBack() {
+        const navigated = await this.maybeGoCurrent();
+        if (navigated) {
+            return;
+        }
+        if (!this.canGoBack()) {
+            return;
+        }
+        this.setIndex(this.index - 1);
+        return this.navigate();
+    }
+    async goPrevious() {
+        const navigated = await this.maybeGoCurrent();
+        if (navigated) {
+            return;
+        }
+        if (this.previousIndex === -1) {
+            return this.goBack();
+        }
+        this.setIndex(this.previousIndex);
+        return this.navigate();
+    }
+    canGoLast() {
+        return this.stack.length > 0;
+    }
+    async goLast() {
+        if (!this.canGoLast()) {
+            return;
+        }
+        this.setIndex(this.stack.length - 1);
+        return this.navigate();
+    }
+    async maybeGoCurrent() {
+        if (this.filter === 0 ) {
+            return false;
+        }
+        if (this.isCurrentSelectionActive()) {
+            return false;
+        }
+        await this.navigate();
+        return true;
+    }
+    isCurrentSelectionActive() {
+        if (!this.current?.selection) {
+            return false;
+        }
+        const pane = this.editorService.activeEditorPane;
+        if (!isEditorPaneWithSelection(pane)) {
+            return false;
+        }
+        if (pane.group?.id !== this.current.groupId) {
+            return false;
+        }
+        if (!pane.input || !this.editorHelper.matchesEditor(pane.input, this.current.editor)) {
+            return false;
+        }
+        const paneSelection = pane.getSelection();
+        if (!paneSelection) {
+            return false;
+        }
+        return paneSelection.compare(this.current.selection) === 1 ;
+    }
+    setIndex(newIndex, skipEvent) {
+        this.previousIndex = this.index;
+        this.index = newIndex;
+        if (!skipEvent) {
+            this._onDidChange.fire();
+        }
+    }
+    async navigate() {
+        this.navigating = true;
+        try {
+            if (this.current) {
+                await this.doNavigate(this.current);
+            }
+        }
+        finally {
+            this.navigating = false;
+        }
+    }
+    doNavigate(location) {
+        let options = Object.create(null);
+        if (location.selection) {
+            options = location.selection.restore(options);
+        }
+        if (isEditorInput(location.editor)) {
+            return this.editorService.openEditor(location.editor, options, location.groupId);
+        }
+        return this.editorService.openEditor({
+            ...location.editor,
+            options: {
+                ...location.editor.options,
+                ...options
+            }
+        }, location.groupId);
+    }
+    isNavigating() {
+        return this.navigating;
+    }
+};
+EditorNavigationStack.MAX_STACK_SIZE = 50;
+EditorNavigationStack = ( (__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;
+        this.lifecycleService = lifecycleService;
+        this.fileService = fileService;
+        this.pathService = pathService;
+    }
+    preferResourceEditorInput(editor) {
+        const resource = EditorResourceAccessor.getOriginalUri(editor);
+        const hasValidResourceEditorInputScheme = resource?.scheme === Schemas.file ||
+            resource?.scheme === Schemas.vscodeRemote ||
+            resource?.scheme === Schemas.vscodeUserData ||
+            resource?.scheme === this.pathService.defaultUriScheme;
+        if (hasValidResourceEditorInputScheme) {
+            if (isEditorInput(editor)) {
+                const untypedInput = editor.toUntyped();
+                if (isResourceEditorInput(untypedInput)) {
+                    return untypedInput;
+                }
+            }
+            return editor;
+        }
+        else {
+            return isEditorInput(editor) ? editor : undefined;
+        }
+    }
+    matchesEditor(arg1, inputB) {
+        if (arg1 instanceof FileChangesEvent || arg1 instanceof FileOperationEvent) {
+            if (isEditorInput(inputB)) {
+                return false;
+            }
+            if (arg1 instanceof FileChangesEvent) {
+                return arg1.contains(inputB.resource, 2 );
+            }
+            return this.matchesFile(inputB.resource, arg1);
+        }
+        if (isEditorInput(arg1)) {
+            if (isEditorInput(inputB)) {
+                return arg1.matches(inputB);
+            }
+            return this.matchesFile(inputB.resource, arg1);
+        }
+        if (isEditorInput(inputB)) {
+            return this.matchesFile(arg1.resource, inputB);
+        }
+        return arg1 && inputB && this.uriIdentityService.extUri.isEqual(arg1.resource, inputB.resource);
+    }
+    matchesFile(resource, arg2) {
+        if (arg2 instanceof FileChangesEvent) {
+            return arg2.contains(resource, 2 );
+        }
+        if (arg2 instanceof FileOperationEvent) {
+            return this.uriIdentityService.extUri.isEqualOrParent(resource, arg2.resource);
+        }
+        if (isEditorInput(arg2)) {
+            const inputResource = arg2.resource;
+            if (!inputResource) {
+                return false;
+            }
+            if (this.lifecycleService.phase >= 3  && !this.fileService.hasProvider(inputResource)) {
+                return false;
+            }
+            return this.uriIdentityService.extUri.isEqual(inputResource, resource);
+        }
+        return this.uriIdentityService.extUri.isEqual(arg2?.resource, resource);
+    }
+    matchesEditorIdentifier(identifier, editorPane) {
+        if (!editorPane?.group) {
+            return false;
+        }
+        if (identifier.groupId !== editorPane.group.id) {
+            return false;
+        }
+        return editorPane.input ? identifier.editor.matches(editorPane.input) : false;
+    }
+    onEditorDispose(editor, listener, mapEditorToDispose) {
+        const toDispose = Event.once(editor.onWillDispose)(() => listener());
+        let disposables = mapEditorToDispose.get(editor);
+        if (!disposables) {
+            disposables = ( (new DisposableStore()));
+            mapEditorToDispose.set(editor, disposables);
+        }
+        disposables.add(toDispose);
+    }
+    clearOnEditorDispose(editor, mapEditorToDispose) {
+        if (!isEditorInput(editor)) {
+            return;
+        }
+        const disposables = mapEditorToDispose.get(editor);
+        if (disposables) {
+            dispose(disposables);
+            mapEditorToDispose.delete(editor);
+        }
+    }
+};
+EditorHelper = ( (__decorate([
+    ( (__param(0, IUriIdentityService))),
+    ( (__param(1, ILifecycleService))),
+    ( (__param(2, IFileService))),
+    ( (__param(3, IPathService)))
+], EditorHelper)));
+export { EditorNavigationStack, HistoryService };