@codingame/monaco-vscode-timeline-service-override 25.1.2 → 26.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-timeline-service-override",
-  "version": "25.1.2",
+  "version": "26.0.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - timeline service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "25.1.2"
+    "@codingame/monaco-vscode-api": "26.0.1"
   },
   "main": "index.js",
   "module": "index.js",

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

@@ -9,7 +9,13 @@ import { safeIntl } from '@codingame/monaco-vscode-api/vscode/vs/base/common/dat
 let localHistoryDateFormatter = undefined;
 function getLocalHistoryDateFormatter() {
     if (!localHistoryDateFormatter) {
-        const options = { year: 'numeric', month: 'long', day: 'numeric', hour: 'numeric', minute: 'numeric' };
+        const options = {
+            year: "numeric",
+            month: "long",
+            day: "numeric",
+            hour: "numeric",
+            minute: "numeric"
+        };
         const formatter = safeIntl.DateTimeFormat(language, options).value;
         localHistoryDateFormatter = {
             format: date => formatter.format(date)
@@ -17,9 +23,9 @@ function getLocalHistoryDateFormatter() {
     }
     return localHistoryDateFormatter;
 }
-const LOCAL_HISTORY_MENU_CONTEXT_VALUE = 'localHistory:item';
-const LOCAL_HISTORY_MENU_CONTEXT_KEY = ( ContextKeyExpr.equals('timelineItem', LOCAL_HISTORY_MENU_CONTEXT_VALUE));
-const LOCAL_HISTORY_ICON_ENTRY = registerIcon('localHistory-icon', Codicon.circleOutline, ( localize(8531, "Icon for a local history entry in the timeline view.")));
-const LOCAL_HISTORY_ICON_RESTORE = registerIcon('localHistory-restore', Codicon.check, ( localize(8532, "Icon for restoring contents of a local history entry.")));
+const LOCAL_HISTORY_MENU_CONTEXT_VALUE = "localHistory:item";
+const LOCAL_HISTORY_MENU_CONTEXT_KEY = ( ContextKeyExpr.equals("timelineItem", LOCAL_HISTORY_MENU_CONTEXT_VALUE));
+const LOCAL_HISTORY_ICON_ENTRY = registerIcon("localHistory-icon", Codicon.circleOutline, ( localize(8838, "Icon for a local history entry in the timeline view.")));
+const LOCAL_HISTORY_ICON_RESTORE = registerIcon("localHistory-restore", Codicon.check, ( localize(8839, "Icon for restoring contents of a local history entry.")));
 
 export { LOCAL_HISTORY_ICON_ENTRY, LOCAL_HISTORY_ICON_RESTORE, LOCAL_HISTORY_MENU_CONTEXT_KEY, LOCAL_HISTORY_MENU_CONTEXT_VALUE, getLocalHistoryDateFormatter };

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

@@ -31,17 +31,17 @@ import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { IHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/history/common/history.service';
 import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 
-const LOCAL_HISTORY_CATEGORY = ( localize2(8533, 'Local History'));
-const CTX_LOCAL_HISTORY_ENABLED = ( ContextKeyExpr.has('config.workbench.localHistory.enabled'));
-const COMPARE_WITH_FILE_LABEL = ( localize2(8534, 'Compare with File'));
+const LOCAL_HISTORY_CATEGORY = ( localize2(8840, "Local History"));
+const CTX_LOCAL_HISTORY_ENABLED = ( ContextKeyExpr.has("config.workbench.localHistory.enabled"));
+const COMPARE_WITH_FILE_LABEL = ( localize2(8841, "Compare with File"));
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.localHistory.compareWithFile',
+            id: "workbench.action.localHistory.compareWithFile",
             title: COMPARE_WITH_FILE_LABEL,
             menu: {
                 id: MenuId.TimelineItemContext,
-                group: '1_compare',
+                group: "1_compare",
                 order: 1,
                 when: LOCAL_HISTORY_MENU_CONTEXT_KEY
             }
@@ -50,20 +50,25 @@ registerAction2(class extends Action2 {
     async run(accessor, item) {
         const commandService = accessor.get(ICommandService);
         const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        const {
+            entry
+        } = await findLocalHistoryEntry(workingCopyHistoryService, item);
         if (entry) {
-            return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(entry, entry.workingCopy.resource));
+            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: ( localize2(8535, 'Compare with Previous')),
+            id: "workbench.action.localHistory.compareWithPrevious",
+            title: ( localize2(8842, "Compare with Previous")),
             menu: {
                 id: MenuId.TimelineItemContext,
-                group: '1_compare',
+                group: "1_compare",
                 order: 2,
                 when: LOCAL_HISTORY_MENU_CONTEXT_KEY
             }
@@ -73,7 +78,10 @@ registerAction2(class extends Action2 {
         const commandService = accessor.get(ICommandService);
         const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
         const editorService = accessor.get(IEditorService);
-        const { entry, previous } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        const {
+            entry,
+            previous
+        } = await findLocalHistoryEntry(workingCopyHistoryService, item);
         if (entry) {
             if (!previous) {
                 return openEntry(entry, editorService);
@@ -83,15 +91,15 @@ registerAction2(class extends Action2 {
     }
 });
 let itemSelectedForCompare = undefined;
-const LocalHistoryItemSelectedForCompare = ( new RawContextKey('localHistoryItemSelectedForCompare', false, true));
+const LocalHistoryItemSelectedForCompare = ( new RawContextKey("localHistoryItemSelectedForCompare", false, true));
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.localHistory.selectForCompare',
-            title: ( localize2(8536, 'Select for Compare')),
+            id: "workbench.action.localHistory.selectForCompare",
+            title: ( localize2(8843, "Select for Compare")),
             menu: {
                 id: MenuId.TimelineItemContext,
-                group: '2_compare_with',
+                group: "2_compare_with",
                 order: 2,
                 when: LOCAL_HISTORY_MENU_CONTEXT_KEY
             }
@@ -100,7 +108,9 @@ registerAction2(class extends Action2 {
     async run(accessor, item) {
         const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
         const contextKeyService = accessor.get(IContextKeyService);
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        const {
+            entry
+        } = await findLocalHistoryEntry(workingCopyHistoryService, item);
         if (entry) {
             itemSelectedForCompare = item;
             LocalHistoryItemSelectedForCompare.bindTo(contextKeyService).set(true);
@@ -110,11 +120,11 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.localHistory.compareWithSelected',
-            title: ( localize2(8537, 'Compare with Selected')),
+            id: "workbench.action.localHistory.compareWithSelected",
+            title: ( localize2(8844, "Compare with Selected")),
             menu: {
                 id: MenuId.TimelineItemContext,
-                group: '2_compare_with',
+                group: "2_compare_with",
                 order: 1,
                 when: ( ContextKeyExpr.and(LOCAL_HISTORY_MENU_CONTEXT_KEY, LocalHistoryItemSelectedForCompare))
             }
@@ -130,20 +140,25 @@ registerAction2(class extends Action2 {
         if (!selectedEntry) {
             return;
         }
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        const {
+            entry
+        } = await findLocalHistoryEntry(workingCopyHistoryService, item);
         if (entry) {
-            return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(selectedEntry, 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: ( localize2(8538, 'Show Contents')),
+            id: "workbench.action.localHistory.open",
+            title: ( localize2(8845, "Show Contents")),
             menu: {
                 id: MenuId.TimelineItemContext,
-                group: '3_contents',
+                group: "3_contents",
                 order: 1,
                 when: LOCAL_HISTORY_MENU_CONTEXT_KEY
             }
@@ -152,21 +167,23 @@ registerAction2(class extends Action2 {
     async run(accessor, item) {
         const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
         const editorService = accessor.get(IEditorService);
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        const {
+            entry
+        } = await findLocalHistoryEntry(workingCopyHistoryService, item);
         if (entry) {
             return openEntry(entry, editorService);
         }
     }
 });
-const RESTORE_CONTENTS_LABEL = ( localize2(8539, 'Restore Contents'));
+const RESTORE_CONTENTS_LABEL = ( localize2(8846, "Restore Contents"));
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.localHistory.restoreViaEditor',
+            id: "workbench.action.localHistory.restoreViaEditor",
             title: RESTORE_CONTENTS_LABEL,
             menu: {
                 id: MenuId.EditorTitle,
-                group: 'navigation',
+                group: "navigation",
                 order: -10,
                 when: ( ResourceContextKey.Scheme.isEqualTo(LocalHistoryFileSystemProvider.SCHEMA))
             },
@@ -174,18 +191,24 @@ registerAction2(class extends Action2 {
         });
     }
     async run(accessor, uri) {
-        const { associatedResource, location } = LocalHistoryFileSystemProvider.fromLocalHistoryFileSystem(uri);
-        return restore(accessor, { uri: associatedResource, handle: basenameOrAuthority(location) });
+        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',
+            id: "workbench.action.localHistory.restore",
             title: RESTORE_CONTENTS_LABEL,
             menu: {
                 id: MenuId.TimelineItemContext,
-                group: '3_contents',
+                group: "3_contents",
                 order: 2,
                 when: LOCAL_HISTORY_MENU_CONTEXT_KEY
             }
@@ -195,24 +218,28 @@ registerAction2(class extends Action2 {
         return restore(accessor, item);
     }
 });
-const restoreSaveSource = SaveSourceRegistry.registerSource('localHistoryRestore.source', ( localize(8540, "File Restored")));
+const restoreSaveSource = SaveSourceRegistry.registerSource("localHistoryRestore.source", ( localize(8847, "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);
+    const {
+        entry
+    } = await findLocalHistoryEntry(workingCopyHistoryService, item);
     if (entry) {
-        const { confirmed } = await dialogService.confirm({
-            type: 'warning',
+        const {
+            confirmed
+        } = await dialogService.confirm({
+            type: "warning",
             message: ( localize(
-                8541,
+                8848,
                 "Do you want to restore the contents of '{0}'?",
                 basename(entry.workingCopy.resource)
             )),
-            detail: ( localize(8542, "Restoring will discard any unsaved changes.")),
-            primaryButton: ( localize(8543, "&&Restore"))
+            detail: ( localize(8849, "Restoring will discard any unsaved changes.")),
+            primaryButton: ( localize(8850, "&&Restore"))
         });
         if (!confirmed) {
             return;
@@ -221,23 +248,28 @@ async function restore(accessor, item) {
         if (workingCopies) {
             for (const workingCopy of workingCopies) {
                 if (workingCopy.isDirty()) {
-                    await workingCopy.revert({ soft: true });
+                    await workingCopy.revert({
+                        soft: true
+                    });
                 }
             }
         }
         try {
             await fileService.cloneFile(entry.location, entry.workingCopy.resource);
-        }
-        catch (error) {
-            await dialogService.error(( localize(8544, "Unable to restore '{0}'.", basename(entry.workingCopy.resource))), toErrorMessage(error));
+        } catch (error) {
+            await dialogService.error(( localize(8851, "Unable to restore '{0}'.", basename(entry.workingCopy.resource))), toErrorMessage(error));
             return;
         }
         if (workingCopies) {
             for (const workingCopy of workingCopies) {
-                await workingCopy.revert({ force: true });
+                await workingCopy.revert({
+                    force: true
+                });
             }
         }
-        await editorService.openEditor({ resource: entry.workingCopy.resource });
+        await editorService.openEditor({
+            resource: entry.workingCopy.resource
+        });
         await workingCopyHistoryService.addEntry({
             resource: entry.workingCopy.resource,
             source: restoreSaveSource
@@ -248,8 +280,8 @@ async function restore(accessor, item) {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.localHistory.restoreViaPicker',
-            title: ( localize2(8545, 'Find Entry to Restore')),
+            id: "workbench.action.localHistory.restoreViaPicker",
+            title: ( localize2(8852, "Find Entry to Restore")),
             f1: true,
             category: LOCAL_HISTORY_CATEGORY,
             precondition: CTX_LOCAL_HISTORY_ENABLED
@@ -272,7 +304,11 @@ registerAction2(class extends Action2 {
         resourcePicker.busy = true;
         resourcePicker.show();
         const resources = ( new ResourceSet(await workingCopyHistoryService.getAll(cts.token)));
-        const recentEditorResources = ( new ResourceSet(coalesce(( historyService.getHistory().map(({ resource }) => resource)))));
+        const recentEditorResources = ( new ResourceSet(coalesce(( historyService.getHistory().map((
+            {
+                resource
+            }
+        ) => resource)))));
         const resourcesSortedByRecency = [];
         for (const resource of recentEditorResources) {
             if (( resources.has(resource))) {
@@ -282,13 +318,15 @@ registerAction2(class extends Action2 {
         }
         resourcesSortedByRecency.push(...[...resources].sort((r1, r2) => r1.fsPath < r2.fsPath ? -1 : 1));
         resourcePicker.busy = false;
-        resourcePicker.placeholder = ( localize(8546, "Select the file to show local history for"));
+        resourcePicker.placeholder = ( localize(8853, "Select the file to show local history for"));
         resourcePicker.matchOnLabel = true;
         resourcePicker.matchOnDescription = true;
         resourcePicker.items = ( [...resourcesSortedByRecency].map(resource => ({
             resource,
             label: basenameOrAuthority(resource),
-            description: labelService.getUriLabel(dirname(resource), { relative: true }),
+            description: labelService.getUriLabel(dirname(resource), {
+                relative: true
+            }),
             iconClasses: getIconClasses(modelService, languageService, resource)
         })));
         await Event.toPromise(resourcePicker.onDidAccept);
@@ -306,7 +344,7 @@ registerAction2(class extends Action2 {
         const entries = await workingCopyHistoryService.getEntries(resource, cts.token);
         entryPicker.busy = false;
         entryPicker.canAcceptInBackground = true;
-        entryPicker.placeholder = ( localize(8547, "Select the local history entry to open"));
+        entryPicker.placeholder = ( localize(8854, "Select the local history entry to open"));
         entryPicker.matchOnLabel = true;
         entryPicker.matchOnDescription = true;
         entryPicker.items = ( Array.from(entries).reverse().map(entry => ({
@@ -314,7 +352,7 @@ registerAction2(class extends Action2 {
             label: `$(circle-outline) ${SaveSourceRegistry.getSourceLabel(entry.source)}`,
             description: toLocalHistoryEntryDateLabel(entry.timestamp)
         })));
-        entryPickerDisposables.add(entryPicker.onDidAccept(async (e) => {
+        entryPickerDisposables.add(entryPicker.onDidAccept(async e => {
             if (!e.inBackground) {
                 entryPickerDisposables.dispose();
             }
@@ -324,21 +362,36 @@ registerAction2(class extends Action2 {
             }
             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, { preserveFocus: e.inBackground }));
+                return commandService.executeCommand(
+                    API_OPEN_DIFF_EDITOR_COMMAND_ID,
+                    ...toDiffEditorArguments(selectedItem.entry, selectedItem.entry.workingCopy.resource, {
+                        preserveFocus: e.inBackground
+                    })
+                );
             }
-            return openEntry(selectedItem.entry, editorService, { preserveFocus: e.inBackground });
+            return openEntry(selectedItem.entry, editorService, {
+                preserveFocus: e.inBackground
+            });
         }));
     }
 });
-MenuRegistry.appendMenuItem(MenuId.TimelineTitle, { command: { id: 'workbench.action.localHistory.restoreViaPicker', title: ( localize2(8548, 'Local History: Find Entry to Restore...')) }, group: 'submenu', order: 1, when: CTX_LOCAL_HISTORY_ENABLED });
+MenuRegistry.appendMenuItem(MenuId.TimelineTitle, {
+    command: {
+        id: "workbench.action.localHistory.restoreViaPicker",
+        title: ( localize2(8855, "Local History: Find Entry to Restore..."))
+    },
+    group: "submenu",
+    order: 1,
+    when: CTX_LOCAL_HISTORY_ENABLED
+});
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.localHistory.rename',
-            title: ( localize2(8549, 'Rename')),
+            id: "workbench.action.localHistory.rename",
+            title: ( localize2(8856, "Rename")),
             menu: {
                 id: MenuId.TimelineItemContext,
-                group: '5_edit',
+                group: "5_edit",
                 order: 1,
                 when: LOCAL_HISTORY_MENU_CONTEXT_KEY
             }
@@ -347,18 +400,22 @@ registerAction2(class extends Action2 {
     async run(accessor, item) {
         const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
         const quickInputService = accessor.get(IQuickInputService);
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        const {
+            entry
+        } = await findLocalHistoryEntry(workingCopyHistoryService, item);
         if (entry) {
             const disposables = ( new DisposableStore());
             const inputBox = disposables.add(quickInputService.createInputBox());
-            inputBox.title = ( localize(8550, "Rename Local History Entry"));
+            inputBox.title = ( localize(8857, "Rename Local History Entry"));
             inputBox.ignoreFocusOut = true;
-            inputBox.placeholder = ( localize(8551, "Enter the new name of the local history entry"));
+            inputBox.placeholder = ( localize(8858, "Enter the new name of the local history entry"));
             inputBox.value = SaveSourceRegistry.getSourceLabel(entry.source);
             inputBox.show();
             disposables.add(inputBox.onDidAccept(() => {
                 if (inputBox.value) {
-                    workingCopyHistoryService.updateEntry(entry, { source: inputBox.value }, CancellationToken.None);
+                    workingCopyHistoryService.updateEntry(entry, {
+                        source: inputBox.value
+                    }, CancellationToken.None);
                 }
                 disposables.dispose();
             }));
@@ -368,11 +425,11 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.localHistory.delete',
-            title: ( localize2(8552, 'Delete')),
+            id: "workbench.action.localHistory.delete",
+            title: ( localize2(8859, "Delete")),
             menu: {
                 id: MenuId.TimelineItemContext,
-                group: '5_edit',
+                group: "5_edit",
                 order: 2,
                 when: LOCAL_HISTORY_MENU_CONTEXT_KEY
             }
@@ -382,18 +439,22 @@ registerAction2(class extends Action2 {
         const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
         const editorService = accessor.get(IEditorService);
         const dialogService = accessor.get(IDialogService);
-        const { entry } = await findLocalHistoryEntry(workingCopyHistoryService, item);
+        const {
+            entry
+        } = await findLocalHistoryEntry(workingCopyHistoryService, item);
         if (entry) {
-            const { confirmed } = await dialogService.confirm({
-                type: 'warning',
+            const {
+                confirmed
+            } = await dialogService.confirm({
+                type: "warning",
                 message: ( localize(
-                    8553,
+                    8860,
                     "Do you want to delete the local history entry of '{0}' from {1}?",
                     entry.workingCopy.name,
                     toLocalHistoryEntryDateLabel(entry.timestamp)
                 )),
-                detail: ( localize(8554, "This action is irreversible!")),
-                primaryButton: ( localize(8555, "&&Delete")),
+                detail: ( localize(8861, "This action is irreversible!")),
+                primaryButton: ( localize(8862, "&&Delete"))
             });
             if (!confirmed) {
                 return;
@@ -406,8 +467,8 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.localHistory.deleteAll',
-            title: ( localize2(8556, 'Delete All')),
+            id: "workbench.action.localHistory.deleteAll",
+            title: ( localize2(8863, "Delete All")),
             f1: true,
             category: LOCAL_HISTORY_CATEGORY,
             precondition: CTX_LOCAL_HISTORY_ENABLED
@@ -416,11 +477,13 @@ registerAction2(class extends Action2 {
     async run(accessor) {
         const dialogService = accessor.get(IDialogService);
         const workingCopyHistoryService = accessor.get(IWorkingCopyHistoryService);
-        const { confirmed } = await dialogService.confirm({
-            type: 'warning',
-            message: ( localize(8557, "Do you want to delete all entries of all files in local history?")),
-            detail: ( localize(8558, "This action is irreversible!")),
-            primaryButton: ( localize(8559, "&&Delete All")),
+        const {
+            confirmed
+        } = await dialogService.confirm({
+            type: "warning",
+            message: ( localize(8864, "Do you want to delete all entries of all files in local history?")),
+            detail: ( localize(8865, "This action is irreversible!")),
+            primaryButton: ( localize(8866, "&&Delete All"))
         });
         if (!confirmed) {
             return;
@@ -431,8 +494,8 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.localHistory.create',
-            title: ( localize2(8560, 'Create Entry')),
+            id: "workbench.action.localHistory.create",
+            title: ( localize2(8867, "Create Entry")),
             f1: true,
             category: LOCAL_HISTORY_CATEGORY,
             precondition: ( ContextKeyExpr.and(CTX_LOCAL_HISTORY_ENABLED, ActiveEditorContext))
@@ -444,16 +507,18 @@ registerAction2(class extends Action2 {
         const editorService = accessor.get(IEditorService);
         const labelService = accessor.get(ILabelService);
         const pathService = accessor.get(IPathService);
-        const resource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+        const resource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, {
+            supportSideBySide: SideBySideEditor.PRIMARY
+        });
         if (resource?.scheme !== pathService.defaultUriScheme && resource?.scheme !== Schemas.vscodeUserData) {
             return;
         }
         const disposables = ( new DisposableStore());
         const inputBox = disposables.add(quickInputService.createInputBox());
-        inputBox.title = ( localize(8561, "Create Local History Entry"));
+        inputBox.title = ( localize(8868, "Create Local History Entry"));
         inputBox.ignoreFocusOut = true;
         inputBox.placeholder = ( localize(
-            8562,
+            8869,
             "Enter the new name of the local history entry for '{0}'",
             labelService.getUriBasenameLabel(resource)
         ));
@@ -462,17 +527,23 @@ registerAction2(class extends Action2 {
             const entrySource = inputBox.value;
             disposables.dispose();
             if (entrySource) {
-                await workingCopyHistoryService.addEntry({ resource, source: inputBox.value }, CancellationToken.None);
+                await workingCopyHistoryService.addEntry({
+                    resource,
+                    source: inputBox.value
+                }, CancellationToken.None);
             }
         }));
     }
 });
 async function openEntry(entry, editorService, options) {
-    const resource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: entry.location, associatedResource: entry.workingCopy.resource });
+    const resource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({
+        location: entry.location,
+        associatedResource: entry.workingCopy.resource
+    });
     await editorService.openEditor({
         resource,
         label: ( localize(
-            8563,
+            8870,
             "{0} ({1} • {2})",
             entry.workingCopy.name,
             SaveSourceRegistry.getSourceLabel(entry.source),
@@ -482,19 +553,29 @@ async function openEntry(entry, editorService, options) {
     });
 }
 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 });
+    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, options) {
-    const originalResource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: arg1.location, associatedResource: arg1.workingCopy.resource });
+    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 = ( localize(
-            8564,
+            8871,
             "{0} ({1} • {2}) ↔ {3}",
             arg1.workingCopy.name,
             SaveSourceRegistry.getSourceLabel(arg1.source),
@@ -504,9 +585,12 @@ function toDiffEditorArguments(arg1, arg2, options) {
     }
     else {
         const modified = arg2;
-        modifiedResource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({ location: modified.location, associatedResource: modified.workingCopy.resource });
+        modifiedResource = LocalHistoryFileSystemProvider.toLocalHistoryFileSystem({
+            location: modified.location,
+            associatedResource: modified.workingCopy.resource
+        });
         label = ( localize(
-            8565,
+            8872,
             "{0} ({1} • {2}) ↔ {3} ({4} • {5})",
             arg1.workingCopy.name,
             SaveSourceRegistry.getSourceLabel(arg1.source),
@@ -542,7 +626,7 @@ async function findLocalHistoryEntry(workingCopyHistoryService, descriptor) {
 }
 const SEP = /\//g;
 function toLocalHistoryEntryDateLabel(timestamp) {
-    return `${getLocalHistoryDateFormatter().format(timestamp).replace(SEP, '-')}`;
+    return `${getLocalHistoryDateFormatter().format(timestamp).replace(SEP, "-")}`;
 }
 
 export { COMPARE_WITH_FILE_LABEL, findLocalHistoryEntry, toDiffEditorArguments };