@codingame/monaco-vscode-api 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/contrib/localHistory/browser/localHistoryCommands.js

@@ -1,635 +0,0 @@
-import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
-import { URI } from '../../../../base/common/uri.js';
-import { Event } from '../../../../base/common/event.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { toErrorMessage } from '../../../../base/common/errorMessage.js';
-import { CancellationToken, CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { IWorkingCopyHistoryService } from '../../../services/workingCopy/common/workingCopyHistory.js';
-import { API_OPEN_DIFF_EDITOR_COMMAND_ID } from '../../../browser/parts/editor/editorCommands.js';
-import { LocalHistoryFileSystemProvider } from './localHistoryFileSystemProvider.js';
-import { IContextKeyService, ContextKeyExpr, RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
-import { registerAction2, MenuRegistry, MenuId, Action2 } from '../../../../platform/actions/common/actions.js';
-import { basenameOrAuthority, basename, dirname } from '../../../../base/common/resources.js';
-import { ICommandService } from '../../../../platform/commands/common/commands.js';
-import { SaveSourceRegistry, EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { IWorkingCopyService } from '../../../services/workingCopy/common/workingCopyService.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { ResourceContextKey, ActiveEditorContext } from '../../../common/contextkeys.js';
-import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { getIconClasses } from '../../../../editor/common/services/getIconClasses.js';
-import { IModelService } from '../../../../editor/common/services/model.js';
-import { ILanguageService } from '../../../../editor/common/languages/language.js';
-import { ILabelService } from '../../../../platform/label/common/label.js';
-import { firstOrDefault } from '../../../../base/common/arrays.js';
-import { getLocalHistoryDateFormatter, LOCAL_HISTORY_MENU_CONTEXT_KEY, LOCAL_HISTORY_ICON_RESTORE } from './localHistory.js';
-import { IPathService } from '../../../services/path/common/pathService.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-const LOCAL_HISTORY_CATEGORY = ( localize2WithPath(
-    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-    'localHistory.category',
-    'Local History'
-));
-const COMPARE_WITH_FILE_LABEL = ( localize2WithPath(
-    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-    'localHistory.compareWithFile',
-    'Compare with File'
-));
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.compareWithFile',
-            title: COMPARE_WITH_FILE_LABEL,
-            menu: {
-                id: MenuId.TimelineItemContext,
-                group: '1_compare',
-                order: 1,
-                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
-            }
-        });
-    }
-    async run(accessor, item) {
-        const commandService = accessor.get(ICommandService);
-        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
-        if (entry) {
-            return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(entry, entry.workingCopy.resource));
-        }
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.compareWithPrevious',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'localHistory.compareWithPrevious',
-                'Compare with Previous'
-            )),
-            menu: {
-                id: MenuId.TimelineItemContext,
-                group: '1_compare',
-                order: 2,
-                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
-            }
-        });
-    }
-    async run(accessor, item) {
-        const commandService = accessor.get(ICommandService);
-        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const editorService = accessor.get(IEditorService);
-        const { entry, previous } = await findLocalHistoryEntry(workingCopyHistoryService, item);
-        if (entry) {
-            if (!previous) {
-                return openEntry(entry, editorService);
-            }
-            return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(previous, entry));
-        }
-    }
-});
-let itemSelectedForCompare = undefined;
-const LocalHistoryItemSelectedForCompare = ( new RawContextKey('localHistoryItemSelectedForCompare', false, true));
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.selectForCompare',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'localHistory.selectForCompare',
-                'Select for Compare'
-            )),
-            menu: {
-                id: MenuId.TimelineItemContext,
-                group: '2_compare_with',
-                order: 2,
-                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
-            }
-        });
-    }
-    async run(accessor, item) {
-        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const contextKeyService = accessor.get(IContextKeyService);
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
-        if (entry) {
-            itemSelectedForCompare = item;
-            LocalHistoryItemSelectedForCompare.bindTo(contextKeyService).set(true);
-        }
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.compareWithSelected',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'localHistory.compareWithSelected',
-                'Compare with Selected'
-            )),
-            menu: {
-                id: MenuId.TimelineItemContext,
-                group: '2_compare_with',
-                order: 1,
-                when: ( ContextKeyExpr.and(LOCAL_HISTORY_MENU_CONTEXT_KEY, LocalHistoryItemSelectedForCompare))
-            }
-        });
-    }
-    async run(accessor, item) {
-        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const commandService = accessor.get(ICommandService);
-        if (!itemSelectedForCompare) {
-            return;
-        }
-        const selectedEntry = (await findLocalHistoryEntry(workingCopyHistoryService, itemSelectedForCompare)).entry;
-        if (!selectedEntry) {
-            return;
-        }
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
-        if (entry) {
-            return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(selectedEntry, entry));
-        }
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.open',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'localHistory.open',
-                'Show Contents'
-            )),
-            menu: {
-                id: MenuId.TimelineItemContext,
-                group: '3_contents',
-                order: 1,
-                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
-            }
-        });
-    }
-    async run(accessor, item) {
-        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const editorService = accessor.get(IEditorService);
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
-        if (entry) {
-            return openEntry(entry, editorService);
-        }
-    }
-});
-const RESTORE_CONTENTS_LABEL = ( localize2WithPath(
-    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-    'localHistory.restore',
-    'Restore Contents'
-));
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.restoreViaEditor',
-            title: RESTORE_CONTENTS_LABEL,
-            menu: {
-                id: MenuId.EditorTitle,
-                group: 'navigation',
-                order: -10,
-                when: ( ResourceContextKey.Scheme.isEqualTo(LocalHistoryFileSystemProvider.SCHEMA))
-            },
-            icon: LOCAL_HISTORY_ICON_RESTORE
-        });
-    }
-    async run(accessor, uri) {
-        const { associatedResource, location } = LocalHistoryFileSystemProvider.fromLocalHistoryFileSystem(uri);
-        return restore(accessor, { uri: associatedResource, handle: basenameOrAuthority(location) });
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.restore',
-            title: RESTORE_CONTENTS_LABEL,
-            menu: {
-                id: MenuId.TimelineItemContext,
-                group: '3_contents',
-                order: 2,
-                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
-            }
-        });
-    }
-    async run(accessor, item) {
-        return restore(accessor, item);
-    }
-});
-const restoreSaveSource = SaveSourceRegistry.registerSource('localHistoryRestore.source', ( localizeWithPath(
-    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-    'localHistoryRestore.source',
-    "File Restored"
-)));
-async function restore(accessor, item) {
-    const fileService = accessor.get(IFileService);
-    const dialogService = accessor.get(IDialogService);
-    const workingCopyService = accessor.get(IWorkingCopyService);
-    const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-    const editorService = accessor.get(IEditorService);
-    const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
-    if (entry) {
-        const { confirmed } = await dialogService.confirm({
-            type: 'warning',
-            message: ( localizeWithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'confirmRestoreMessage',
-                "Do you want to restore the contents of '{0}'?",
-                basename(entry.workingCopy.resource)
-            )),
-            detail: ( localizeWithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'confirmRestoreDetail',
-                "Restoring will discard any unsaved changes."
-            )),
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                { key: 'restoreButtonLabel', comment: ['&& denotes a mnemonic'] },
-                "&&Restore"
-            ))
-        });
-        if (!confirmed) {
-            return;
-        }
-        const workingCopies = workingCopyService.getAll(entry.workingCopy.resource);
-        if (workingCopies) {
-            for (const workingCopy of workingCopies) {
-                if (workingCopy.isDirty()) {
-                    await workingCopy.revert({ soft: true });
-                }
-            }
-        }
-        try {
-            await fileService.cloneFile(entry.location, entry.workingCopy.resource);
-        }
-        catch (error) {
-            await dialogService.error(( localizeWithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'unableToRestore',
-                "Unable to restore '{0}'.",
-                basename(entry.workingCopy.resource)
-            )), toErrorMessage(error));
-            return;
-        }
-        if (workingCopies) {
-            for (const workingCopy of workingCopies) {
-                await workingCopy.revert({ force: true });
-            }
-        }
-        await editorService.openEditor({ resource: entry.workingCopy.resource });
-        await workingCopyHistoryService.addEntry({
-            resource: entry.workingCopy.resource,
-            source: restoreSaveSource
-        }, CancellationToken.None);
-        await closeEntry(entry, editorService);
-    }
-}
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.restoreViaPicker',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'localHistory.restoreViaPicker',
-                'Find Entry to Restore'
-            )),
-            f1: true,
-            category: LOCAL_HISTORY_CATEGORY
-        });
-    }
-    async run(accessor) {
-        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const quickInputService = accessor.get(IQuickInputService);
-        const modelService = accessor.get(IModelService);
-        const languageService = accessor.get(ILanguageService);
-        const labelService = accessor.get(ILabelService);
-        const editorService = accessor.get(IEditorService);
-        const fileService = accessor.get(IFileService);
-        const commandService = accessor.get(ICommandService);
-        const resourcePicker = quickInputService.createQuickPick();
-        let cts = ( new CancellationTokenSource());
-        resourcePicker.onDidHide(() => cts.dispose(true));
-        resourcePicker.busy = true;
-        resourcePicker.show();
-        const resources = await workingCopyHistoryService.getAll(cts.token);
-        resourcePicker.busy = false;
-        resourcePicker.placeholder = ( localizeWithPath(
-            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-            'restoreViaPicker.filePlaceholder',
-            "Select the file to show local history for"
-        ));
-        resourcePicker.matchOnLabel = true;
-        resourcePicker.matchOnDescription = true;
-        resourcePicker.items = ( resources.map(resource => ({
-            resource,
-            label: basenameOrAuthority(resource),
-            description: labelService.getUriLabel(dirname(resource), { relative: true }),
-            iconClasses: getIconClasses(modelService, languageService, resource)
-        }))).sort((r1, r2) => r1.resource.fsPath < r2.resource.fsPath ? -1 : 1);
-        await Event.toPromise(resourcePicker.onDidAccept);
-        resourcePicker.dispose();
-        const resource = firstOrDefault(resourcePicker.selectedItems)?.resource;
-        if (!resource) {
-            return;
-        }
-        const entryPicker = quickInputService.createQuickPick();
-        cts = ( new CancellationTokenSource());
-        entryPicker.onDidHide(() => cts.dispose(true));
-        entryPicker.busy = true;
-        entryPicker.show();
-        const entries = await workingCopyHistoryService.getEntries(resource, cts.token);
-        entryPicker.busy = false;
-        entryPicker.placeholder = ( localizeWithPath(
-            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-            'restoreViaPicker.entryPlaceholder',
-            "Select the local history entry to open"
-        ));
-        entryPicker.matchOnLabel = true;
-        entryPicker.matchOnDescription = true;
-        entryPicker.items = ( Array.from(entries).reverse().map(entry => ({
-            entry,
-            label: `$(circle-outline) ${SaveSourceRegistry.getSourceLabel(entry.source)}`,
-            description: toLocalHistoryEntryDateLabel(entry.timestamp)
-        })));
-        await Event.toPromise(entryPicker.onDidAccept);
-        entryPicker.dispose();
-        const selectedItem = firstOrDefault(entryPicker.selectedItems);
-        if (!selectedItem) {
-            return;
-        }
-        const resourceExists = await fileService.exists(selectedItem.entry.workingCopy.resource);
-        if (resourceExists) {
-            return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(selectedItem.entry, selectedItem.entry.workingCopy.resource));
-        }
-        return openEntry(selectedItem.entry, editorService);
-    }
-});
-MenuRegistry.appendMenuItem(MenuId.TimelineTitle, { command: { id: 'workbench.action.localHistory.restoreViaPicker', title: ( localize2WithPath(
-    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-    'localHistory.restoreViaPickerMenu',
-    'Local History: Find Entry to Restore...'
-)) }, group: 'submenu', order: 1 });
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.rename',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'localHistory.rename',
-                'Rename'
-            )),
-            menu: {
-                id: MenuId.TimelineItemContext,
-                group: '5_edit',
-                order: 1,
-                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
-            }
-        });
-    }
-    async run(accessor, item) {
-        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const quickInputService = accessor.get(IQuickInputService);
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
-        if (entry) {
-            const inputBox = quickInputService.createInputBox();
-            inputBox.title = ( localizeWithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'renameLocalHistoryEntryTitle',
-                "Rename Local History Entry"
-            ));
-            inputBox.ignoreFocusOut = true;
-            inputBox.placeholder = ( localizeWithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'renameLocalHistoryPlaceholder',
-                "Enter the new name of the local history entry"
-            ));
-            inputBox.value = SaveSourceRegistry.getSourceLabel(entry.source);
-            inputBox.show();
-            inputBox.onDidAccept(() => {
-                if (inputBox.value) {
-                    workingCopyHistoryService.updateEntry(entry, { source: inputBox.value }, CancellationToken.None);
-                }
-                inputBox.dispose();
-            });
-        }
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.delete',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'localHistory.delete',
-                'Delete'
-            )),
-            menu: {
-                id: MenuId.TimelineItemContext,
-                group: '5_edit',
-                order: 2,
-                when: LOCAL_HISTORY_MENU_CONTEXT_KEY
-            }
-        });
-    }
-    async run(accessor, item) {
-        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const editorService = accessor.get(IEditorService);
-        const dialogService = accessor.get(IDialogService);
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
-        if (entry) {
-            const { confirmed } = await dialogService.confirm({
-                type: 'warning',
-                message: ( localizeWithPath(
-                    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                    'confirmDeleteMessage',
-                    "Do you want to delete the local history entry of '{0}' from {1}?",
-                    entry.workingCopy.name,
-                    toLocalHistoryEntryDateLabel(entry.timestamp)
-                )),
-                detail: ( localizeWithPath(
-                    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                    'confirmDeleteDetail',
-                    "This action is irreversible!"
-                )),
-                primaryButton: ( localizeWithPath(
-                    'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                    { key: 'deleteButtonLabel', comment: ['&& denotes a mnemonic'] },
-                    "&&Delete"
-                )),
-            });
-            if (!confirmed) {
-                return;
-            }
-            await workingCopyHistoryService.removeEntry(entry, CancellationToken.None);
-            await closeEntry(entry, editorService);
-        }
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.deleteAll',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'localHistory.deleteAll',
-                'Delete All'
-            )),
-            f1: true,
-            category: LOCAL_HISTORY_CATEGORY
-        });
-    }
-    async run(accessor) {
-        const dialogService = accessor.get(IDialogService);
-        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const { confirmed } = await dialogService.confirm({
-            type: 'warning',
-            message: ( localizeWithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'confirmDeleteAllMessage',
-                "Do you want to delete all entries of all files in local history?"
-            )),
-            detail: ( localizeWithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'confirmDeleteAllDetail',
-                "This action is irreversible!"
-            )),
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                { key: 'deleteAllButtonLabel', comment: ['&& denotes a mnemonic'] },
-                "&&Delete All"
-            )),
-        });
-        if (!confirmed) {
-            return;
-        }
-        await workingCopyHistoryService.removeAll(CancellationToken.None);
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.localHistory.create',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-                'localHistory.create',
-                'Create Entry'
-            )),
-            f1: true,
-            category: LOCAL_HISTORY_CATEGORY,
-            precondition: ActiveEditorContext
-        });
-    }
-    async run(accessor) {
-        const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const quickInputService = accessor.get(IQuickInputService);
-        const editorService = accessor.get(IEditorService);
-        const labelService = accessor.get(ILabelService);
-        const pathService = accessor.get(IPathService);
-        const resource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
-        if (resource?.scheme !== pathService.defaultUriScheme && resource?.scheme !== Schemas.vscodeUserData) {
-            return;
-        }
-        const inputBox = quickInputService.createInputBox();
-        inputBox.title = ( localizeWithPath(
-            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-            'createLocalHistoryEntryTitle',
-            "Create Local History Entry"
-        ));
-        inputBox.ignoreFocusOut = true;
-        inputBox.placeholder = ( localizeWithPath(
-            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-            'createLocalHistoryPlaceholder',
-            "Enter the new name of the local history entry for '{0}'",
-            labelService.getUriBasenameLabel(resource)
-        ));
-        inputBox.show();
-        inputBox.onDidAccept(async () => {
-            const entrySource = inputBox.value;
-            inputBox.dispose();
-            if (entrySource) {
-                await workingCopyHistoryService.addEntry({ resource, source: inputBox.value }, CancellationToken.None);
-            }
-        });
-    }
-});
-async function openEntry(entry, editorService) {
-    const resource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: entry.location, associatedResource: entry.workingCopy.resource });
-    await editorService.openEditor({
-        resource,
-        label: ( localizeWithPath(
-            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-            'localHistoryEditorLabel',
-            "{0} ({1} • {2})",
-            entry.workingCopy.name,
-            SaveSourceRegistry.getSourceLabel(entry.source),
-            toLocalHistoryEntryDateLabel(entry.timestamp)
-        ))
-    });
-}
-async function closeEntry(entry, editorService) {
-    const resource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: entry.location, associatedResource: entry.workingCopy.resource });
-    const editors = editorService.findEditors(resource, { supportSideBySide: SideBySideEditor.ANY });
-    await editorService.closeEditors(editors, { preserveFocus: true });
-}
-function toDiffEditorArguments(arg1, arg2) {
-    const originalResource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: arg1.location, associatedResource: arg1.workingCopy.resource });
-    let label;
-    let modifiedResource;
-    if (URI.isUri(arg2)) {
-        const resource = arg2;
-        modifiedResource = resource;
-        label = ( localizeWithPath(
-            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-            'localHistoryCompareToFileEditorLabel',
-            "{0} ({1} • {2}) ↔ {3}",
-            arg1.workingCopy.name,
-            SaveSourceRegistry.getSourceLabel(arg1.source),
-            toLocalHistoryEntryDateLabel(arg1.timestamp),
-            arg1.workingCopy.name
-        ));
-    }
-    else {
-        const modified = arg2;
-        modifiedResource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: modified.location, associatedResource: modified.workingCopy.resource });
-        label = ( localizeWithPath(
-            'vs/workbench/contrib/localHistory/browser/localHistoryCommands',
-            'localHistoryCompareToPreviousEditorLabel',
-            "{0} ({1} • {2}) ↔ {3} ({4} • {5})",
-            arg1.workingCopy.name,
-            SaveSourceRegistry.getSourceLabel(arg1.source),
-            toLocalHistoryEntryDateLabel(arg1.timestamp),
-            modified.workingCopy.name,
-            SaveSourceRegistry.getSourceLabel(modified.source),
-            toLocalHistoryEntryDateLabel(modified.timestamp)
-        ));
-    }
-    return [
-        originalResource,
-        modifiedResource,
-        label,
-        undefined
-    ];
-}
-async function findLocalHistoryEntry(workingCopyHistoryService, descriptor) {
-    const entries = await workingCopyHistoryService.getEntries(descriptor.uri, CancellationToken.None);
-    let currentEntry = undefined;
-    let previousEntry = undefined;
-    for (let i = 0; i < entries.length; i++) {
-        const entry = entries[i];
-        if (entry.id === descriptor.handle) {
-            currentEntry = entry;
-            previousEntry = entries[i - 1];
-            break;
-        }
-    }
-    return {
-        entry: currentEntry,
-        previous: previousEntry
-    };
-}
-const SEP = /\//g;
-function toLocalHistoryEntryDateLabel(timestamp) {
-    return `${getLocalHistoryDateFormatter().format(timestamp).replace(SEP, '-')}`;
-}
-export { COMPARE_WITH_FILE_LABEL, findLocalHistoryEntry, toDiffEditorArguments };