@codingame/monaco-vscode-notebook-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/services/workingCopy/common/abstractFileWorkingCopyManager.js

@@ -54,13 +54,12 @@ let BaseFileWorkingCopyManager = class BaseFileWorkingCopyManager extends Dispos
     }
     async destroy() {
         try {
-            await Promises.settled(( this.workingCopies.map(async (workingCopy) => {
+            await Promises.settled(( this.workingCopies.map(async workingCopy => {
                 if (workingCopy.isDirty()) {
                     await this.saveWithFallback(workingCopy);
                 }
             })));
-        }
-        catch (error) {
+        } catch (error) {
             this.logService.error(error);
         }
         dispose(( this.mapResourceToWorkingCopy.values()));
@@ -70,21 +69,17 @@ let BaseFileWorkingCopyManager = class BaseFileWorkingCopyManager extends Dispos
         let saveSuccess = false;
         try {
             saveSuccess = await workingCopy.save();
-        }
-        catch (error) {
-        }
+        } catch (error) {}
         if (!saveSuccess || workingCopy.isDirty()) {
             const backup = await this.workingCopyBackupService.resolve(workingCopy);
             if (backup) {
-                await this.fileService.writeFile(workingCopy.resource, backup.value, { unlock: true });
+                await this.fileService.writeFile(workingCopy.resource, backup.value, {
+                    unlock: true
+                });
             }
         }
     }
 };
-BaseFileWorkingCopyManager = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, ILogService)),
-    ( __param(2, IWorkingCopyBackupService))
-], BaseFileWorkingCopyManager));
+BaseFileWorkingCopyManager = ( __decorate([( __param(0, IFileService)), ( __param(1, ILogService)), ( __param(2, IWorkingCopyBackupService))], BaseFileWorkingCopyManager));
 
 export { BaseFileWorkingCopyManager };

package/vscode/src/vs/workbench/services/workingCopy/common/fileWorkingCopyManager.js

@@ -47,10 +47,39 @@ import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platfor
 
 var FileWorkingCopyManager_1;
 let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
-    static { FileWorkingCopyManager_1 = this; }
-    static { this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyCreate.source', ( localize(14623, "File Created"))); }
-    static { this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyReplace.source', ( localize(14624, "File Replaced"))); }
-    constructor(workingCopyTypeId, storedWorkingCopyModelFactory, untitledWorkingCopyModelFactory, fileService, lifecycleService, labelService, logService, workingCopyFileService, workingCopyBackupService, uriIdentityService, fileDialogService, filesConfigurationService, workingCopyService, notificationService, workingCopyEditorService, editorService, elevatedFileService, pathService, environmentService, dialogService, decorationsService, progressService) {
+    static {
+        FileWorkingCopyManager_1 = this;
+    }
+    static {
+        this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource("fileWorkingCopyCreate.source", ( localize(15020, "File Created")));
+    }
+    static {
+        this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource("fileWorkingCopyReplace.source", ( localize(15021, "File Replaced")));
+    }
+    constructor(
+        workingCopyTypeId,
+        storedWorkingCopyModelFactory,
+        untitledWorkingCopyModelFactory,
+        fileService,
+        lifecycleService,
+        labelService,
+        logService,
+        workingCopyFileService,
+        workingCopyBackupService,
+        uriIdentityService,
+        fileDialogService,
+        filesConfigurationService,
+        workingCopyService,
+        notificationService,
+        workingCopyEditorService,
+        editorService,
+        elevatedFileService,
+        pathService,
+        environmentService,
+        dialogService,
+        decorationsService,
+        progressService
+    ) {
         super();
         this.workingCopyTypeId = workingCopyTypeId;
         this.storedWorkingCopyModelFactory = storedWorkingCopyModelFactory;
@@ -104,7 +133,7 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
             constructor(stored) {
                 super();
                 this.stored = stored;
-                this.label = ( localize(14625, "File Working Copy Decorations"));
+                this.label = ( localize(15022, "File Working Copy Decorations"));
                 this._onDidChange = this._register(( new Emitter()));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
@@ -115,9 +144,15 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
                         this._onDidChange.fire([workingCopy.resource]);
                     }
                 }));
-                this._register(this.stored.onDidRemove(workingCopyUri => this._onDidChange.fire([workingCopyUri])));
-                this._register(this.stored.onDidChangeReadonly(workingCopy => this._onDidChange.fire([workingCopy.resource])));
-                this._register(this.stored.onDidChangeOrphaned(workingCopy => this._onDidChange.fire([workingCopy.resource])));
+                this._register(
+                    this.stored.onDidRemove(workingCopyUri => this._onDidChange.fire([workingCopyUri]))
+                );
+                this._register(
+                    this.stored.onDidChangeReadonly(workingCopy => this._onDidChange.fire([workingCopy.resource]))
+                );
+                this._register(
+                    this.stored.onDidChangeOrphaned(workingCopy => this._onDidChange.fire([workingCopy.resource]))
+                );
             }
             provideDecorations(uri) {
                 const workingCopy = this.stored.get(uri);
@@ -131,20 +166,20 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localize(14626, "Deleted, Read-only")),
+                        tooltip: ( localize(15023, "Deleted, Read-only"))
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localize(14627, "Read-only")),
+                        tooltip: ( localize(15024, "Read-only"))
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localize(14628, "Deleted")),
+                        tooltip: ( localize(15025, "Deleted"))
                     };
                 }
                 return undefined;
@@ -161,7 +196,9 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
     resolve(arg1, arg2) {
         if (URI.isUri(arg1)) {
             if (arg1.scheme === Schemas.untitled) {
-                return this.untitled.resolve({ untitledResource: arg1 });
+                return this.untitled.resolve({
+                    untitledResource: arg1
+                });
             }
             else {
                 return this.stored.resolve(arg1, arg2);
@@ -174,9 +211,11 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
             const workingCopy = this.get(source);
             if (workingCopy instanceof UntitledFileWorkingCopy && workingCopy.hasAssociatedFilePath) {
                 target = await this.suggestSavePath(source);
-            }
-            else {
-                target = await this.fileDialogService.pickFileToSave(await this.suggestSavePath(options?.suggestedTarget ?? source), options?.availableFileSystems);
+            } else {
+                target = await this.fileDialogService.pickFileToSave(
+                    await this.suggestSavePath(options?.suggestedTarget ?? source),
+                    options?.availableFileSystems
+                );
             }
         }
         if (!target) {
@@ -186,16 +225,23 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
             const confirmed = await this.confirmMakeWriteable(target);
             if (!confirmed) {
                 return;
-            }
-            else {
+            } else {
                 this.filesConfigurationService.updateReadonly(target, false);
             }
         }
         if (this.fileService.hasProvider(source) && isEqual(source, target)) {
-            return this.doSave(source, { ...options, force: true  });
+            return this.doSave(source, {
+                ...options,
+                force: true
+            });
         }
         if (this.fileService.hasProvider(source) && this.uriIdentityService.extUri.isEqual(source, target) && (await this.fileService.exists(source))) {
-            await this.workingCopyFileService.move([{ file: { source, target } }], CancellationToken.None);
+            await this.workingCopyFileService.move([{
+                file: {
+                    source,
+                    target
+                }
+            }], CancellationToken.None);
             return (await this.doSave(source, options)) ?? (await this.doSave(target, options));
         }
         return this.doSaveAs(source, target, options);
@@ -219,11 +265,15 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         else {
             sourceContents = (await this.fileService.readFileStream(source)).value;
         }
-        const { targetFileExists, targetStoredFileWorkingCopy } = await this.doResolveSaveTarget(source, target);
-        if (sourceWorkingCopy instanceof UntitledFileWorkingCopy &&
-            sourceWorkingCopy.hasAssociatedFilePath &&
-            targetFileExists &&
-            this.uriIdentityService.extUri.isEqual(target, toLocalResource(sourceWorkingCopy.resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme))) {
+        const {
+            targetFileExists,
+            targetStoredFileWorkingCopy
+        } = await this.doResolveSaveTarget(source, target);
+        if (sourceWorkingCopy instanceof UntitledFileWorkingCopy && sourceWorkingCopy.hasAssociatedFilePath && targetFileExists && this.uriIdentityService.extUri.isEqual(target, toLocalResource(
+            sourceWorkingCopy.resource,
+            this.environmentService.remoteAuthority,
+            this.pathService.defaultUriScheme
+        ))) {
             const overwrite = await this.confirmOverwrite(target);
             if (!overwrite) {
                 return undefined;
@@ -246,8 +296,7 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         }
         try {
             await sourceWorkingCopy?.revert();
-        }
-        catch (error) {
+        } catch (error) {
             this.logService.error(error);
         }
         if (source.scheme === Schemas.untitled) {
@@ -264,45 +313,53 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         else {
             targetFileExists = await this.fileService.exists(target);
             if (!targetFileExists) {
-                await this.workingCopyFileService.create([{ resource: target }], CancellationToken.None);
+                await this.workingCopyFileService.create([{
+                    resource: target
+                }], CancellationToken.None);
             }
             if (this.uriIdentityService.extUri.isEqual(source, target) && this.get(source)) {
                 targetStoredFileWorkingCopy = await this.stored.resolve(source);
-            }
-            else {
+            } else {
                 targetStoredFileWorkingCopy = await this.stored.resolve(target);
             }
         }
-        return { targetFileExists, targetStoredFileWorkingCopy };
+        return {
+            targetFileExists,
+            targetStoredFileWorkingCopy
+        };
     }
     async confirmOverwrite(resource) {
-        const { confirmed } = await this.dialogService.confirm({
-            type: 'warning',
+        const {
+            confirmed
+        } = await this.dialogService.confirm({
+            type: "warning",
             message: ( localize(
-                14629,
+                15026,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localize(
-                14630,
+                15027,
                 "A file or folder with the name '{0}' already exists in the folder '{1}'. Replacing it will overwrite its current contents.",
                 basename(resource),
                 basename(dirname(resource))
             )),
-            primaryButton: ( localize(14631, "&&Replace"))
+            primaryButton: ( localize(15028, "&&Replace"))
         });
         return confirmed;
     }
     async confirmMakeWriteable(resource) {
-        const { confirmed } = await this.dialogService.confirm({
-            type: 'warning',
+        const {
+            confirmed
+        } = await this.dialogService.confirm({
+            type: "warning",
             message: ( localize(
-                14632,
+                15029,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localize(14633, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localize(14634, "&&Save Anyway"))
+            detail: ( localize(15030, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(15031, "&&Save Anyway"))
         });
         return confirmed;
     }
@@ -312,7 +369,11 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         }
         const workingCopy = this.get(resource);
         if (workingCopy instanceof UntitledFileWorkingCopy && workingCopy.hasAssociatedFilePath) {
-            return toLocalResource(resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
+            return toLocalResource(
+                resource,
+                this.environmentService.remoteAuthority,
+                this.pathService.defaultUriScheme
+            );
         }
         const defaultFilePath = await this.fileDialogService.defaultFilePath();
         if (workingCopy) {
@@ -324,32 +385,9 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         return joinPath(defaultFilePath, basename(resource));
     }
     async destroy() {
-        await Promises.settled([
-            this.stored.destroy(),
-            this.untitled.destroy()
-        ]);
+        await Promises.settled([this.stored.destroy(), this.untitled.destroy()]);
     }
 };
-FileWorkingCopyManager = FileWorkingCopyManager_1 = ( __decorate([
-    ( __param(3, IFileService)),
-    ( __param(4, ILifecycleService)),
-    ( __param(5, ILabelService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IWorkingCopyFileService)),
-    ( __param(8, IWorkingCopyBackupService)),
-    ( __param(9, IUriIdentityService)),
-    ( __param(10, IFileDialogService)),
-    ( __param(11, IFilesConfigurationService)),
-    ( __param(12, IWorkingCopyService)),
-    ( __param(13, INotificationService)),
-    ( __param(14, IWorkingCopyEditorService)),
-    ( __param(15, IEditorService)),
-    ( __param(16, IElevatedFileService)),
-    ( __param(17, IPathService)),
-    ( __param(18, IWorkbenchEnvironmentService)),
-    ( __param(19, IDialogService)),
-    ( __param(20, IDecorationsService)),
-    ( __param(21, IProgressService))
-], FileWorkingCopyManager));
+FileWorkingCopyManager = FileWorkingCopyManager_1 = ( __decorate([( __param(3, IFileService)), ( __param(4, ILifecycleService)), ( __param(5, ILabelService)), ( __param(6, ILogService)), ( __param(7, IWorkingCopyFileService)), ( __param(8, IWorkingCopyBackupService)), ( __param(9, IUriIdentityService)), ( __param(10, IFileDialogService)), ( __param(11, IFilesConfigurationService)), ( __param(12, IWorkingCopyService)), ( __param(13, INotificationService)), ( __param(14, IWorkingCopyEditorService)), ( __param(15, IEditorService)), ( __param(16, IElevatedFileService)), ( __param(17, IPathService)), ( __param(18, IWorkbenchEnvironmentService)), ( __param(19, IDialogService)), ( __param(20, IDecorationsService)), ( __param(21, IProgressService))], FileWorkingCopyManager));
 
 export { FileWorkingCopyManager };

package/vscode/src/vs/workbench/services/workingCopy/common/storedFileWorkingCopyManager.js

@@ -30,7 +30,24 @@ import { SnapshotContext } from '@codingame/monaco-vscode-api/vscode/vs/workbenc
 import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
 
 let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends BaseFileWorkingCopyManager {
-    constructor(workingCopyTypeId, modelFactory, fileService, lifecycleService, labelService, logService, workingCopyFileService, workingCopyBackupService, uriIdentityService, filesConfigurationService, workingCopyService, notificationService, workingCopyEditorService, editorService, elevatedFileService, progressService) {
+    constructor(
+        workingCopyTypeId,
+        modelFactory,
+        fileService,
+        lifecycleService,
+        labelService,
+        logService,
+        workingCopyFileService,
+        workingCopyBackupService,
+        uriIdentityService,
+        filesConfigurationService,
+        workingCopyService,
+        notificationService,
+        workingCopyEditorService,
+        editorService,
+        elevatedFileService,
+        progressService
+    ) {
         super(fileService, logService, workingCopyBackupService);
         this.workingCopyTypeId = workingCopyTypeId;
         this.modelFactory = modelFactory;
@@ -69,16 +86,32 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
     }
     registerListeners() {
         this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
-        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onDidChangeFileSystemProviderCapabilities(e)));
-        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onDidChangeFileSystemProviderRegistrations(e)));
-        this._register(this.workingCopyFileService.onWillRunWorkingCopyFileOperation(e => this.onWillRunWorkingCopyFileOperation(e)));
-        this._register(this.workingCopyFileService.onDidFailWorkingCopyFileOperation(e => this.onDidFailWorkingCopyFileOperation(e)));
-        this._register(this.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => this.onDidRunWorkingCopyFileOperation(e)));
+        this._register(
+            this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onDidChangeFileSystemProviderCapabilities(e))
+        );
+        this._register(
+            this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onDidChangeFileSystemProviderRegistrations(e))
+        );
+        this._register(
+            this.workingCopyFileService.onWillRunWorkingCopyFileOperation(e => this.onWillRunWorkingCopyFileOperation(e))
+        );
+        this._register(
+            this.workingCopyFileService.onDidFailWorkingCopyFileOperation(e => this.onDidFailWorkingCopyFileOperation(e))
+        );
+        this._register(
+            this.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => this.onDidRunWorkingCopyFileOperation(e))
+        );
         if (isWeb) {
-            this._register(this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdownWeb(), 'veto.fileWorkingCopyManager')));
-        }
-        else {
-            this._register(this.lifecycleService.onWillShutdown(event => event.join(this.onWillShutdownDesktop(), { id: 'join.fileWorkingCopyManager', label: ( localize(14652, "Saving working copies")) })));
+            this._register(this.lifecycleService.onBeforeShutdown(
+                event => event.veto(this.onBeforeShutdownWeb(), "veto.fileWorkingCopyManager")
+            ));
+        } else {
+            this._register(
+                this.lifecycleService.onWillShutdown(event => event.join(this.onWillShutdownDesktop(), {
+                    id: "join.fileWorkingCopyManager",
+                    label: ( localize(15049, "Saving working copies"))
+                }))
+            );
         }
     }
     onBeforeShutdownWeb() {
@@ -91,7 +124,9 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
     }
     async onWillShutdownDesktop() {
         let pendingSavedWorkingCopies;
-        while ((pendingSavedWorkingCopies = this.workingCopies.filter(workingCopy => workingCopy.hasState(StoredFileWorkingCopyState.PENDING_SAVE))).length > 0) {
+        while ((pendingSavedWorkingCopies = this.workingCopies.filter(
+            workingCopy => workingCopy.hasState(StoredFileWorkingCopyState.PENDING_SAVE)
+        )).length > 0) {
             await Promises.settled(( pendingSavedWorkingCopies.map(
                 workingCopy => workingCopy.joinState(StoredFileWorkingCopyState.PENDING_SAVE)
             )));
@@ -115,10 +150,9 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
                 continue;
             }
             let resolveWorkingCopy = false;
-            if (typeof schemeOrEvent === 'string') {
+            if (typeof schemeOrEvent === "string") {
                 resolveWorkingCopy = schemeOrEvent === workingCopy.resource.scheme;
-            }
-            else {
+            } else {
                 resolveWorkingCopy = schemeOrEvent.contains(workingCopy.resource, FileChangeType.UPDATED, FileChangeType.ADDED);
             }
             if (resolveWorkingCopy) {
@@ -132,8 +166,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
             this.workingCopyResolveQueue.queueFor(workingCopy.resource, async () => {
                 try {
                     await this.reload(workingCopy);
-                }
-                catch (error) {
+                } catch (error) {
                     this.logService.error(error);
                 }
             });
@@ -143,7 +176,10 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         if (e.operation === FileOperation.MOVE || e.operation === FileOperation.COPY) {
             e.waitUntil((async () => {
                 const workingCopiesToRestore = [];
-                for (const { source, target } of e.files) {
+                for (const {
+                    source,
+                    target
+                } of e.files) {
                     if (source) {
                         if (this.uriIdentityService.extUri.isEqual(source, target)) {
                             continue;
@@ -190,32 +226,36 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
     }
     onDidRunWorkingCopyFileOperation(e) {
         switch (e.operation) {
-            case FileOperation.CREATE:
-                e.waitUntil((async () => {
-                    for (const { target } of e.files) {
-                        const workingCopy = this.get(target);
-                        if (workingCopy && !workingCopy.isDisposed()) {
-                            await workingCopy.revert();
-                        }
-                    }
-                })());
-                break;
-            case FileOperation.MOVE:
-            case FileOperation.COPY:
-                e.waitUntil((async () => {
-                    const workingCopiesToRestore = this.mapCorrelationIdToWorkingCopiesToRestore.get(e.correlationId);
-                    if (workingCopiesToRestore) {
-                        this.mapCorrelationIdToWorkingCopiesToRestore.delete(e.correlationId);
-                        await Promises.settled(( workingCopiesToRestore.map(async (workingCopyToRestore) => {
-                            const target = this.uriIdentityService.asCanonicalUri(workingCopyToRestore.target);
-                            await this.resolve(target, {
-                                reload: { async: false },
-                                contents: workingCopyToRestore.snapshot
-                            });
-                        })));
+        case FileOperation.CREATE:
+            e.waitUntil((async () => {
+                for (const {
+                    target
+                } of e.files) {
+                    const workingCopy = this.get(target);
+                    if (workingCopy && !workingCopy.isDisposed()) {
+                        await workingCopy.revert();
                     }
-                })());
-                break;
+                }
+            })());
+            break;
+        case FileOperation.MOVE:
+        case FileOperation.COPY:
+            e.waitUntil((async () => {
+                const workingCopiesToRestore = this.mapCorrelationIdToWorkingCopiesToRestore.get(e.correlationId);
+                if (workingCopiesToRestore) {
+                    this.mapCorrelationIdToWorkingCopiesToRestore.delete(e.correlationId);
+                    await Promises.settled(( workingCopiesToRestore.map(async workingCopyToRestore => {
+                        const target = this.uriIdentityService.asCanonicalUri(workingCopyToRestore.target);
+                        await this.resolve(target, {
+                            reload: {
+                                async: false
+                            },
+                            contents: workingCopyToRestore.snapshot
+                        });
+                    })));
+                }
+            })());
+            break;
         }
     }
     async reload(workingCopy) {
@@ -223,7 +263,11 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         if (workingCopy.isDirty() || workingCopy.isDisposed() || !( this.has(workingCopy.resource))) {
             return;
         }
-        await this.doResolve(workingCopy, { reload: { async: false } });
+        await this.doResolve(workingCopy, {
+            reload: {
+                async: false
+            }
+        });
     }
     async resolve(resource, options) {
         const pendingResolve = this.joinPendingResolves(resource);
@@ -238,8 +282,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         if (URI.isUri(resourceOrWorkingCopy)) {
             resource = resourceOrWorkingCopy;
             workingCopy = this.get(resource);
-        }
-        else {
+        } else {
             resource = resourceOrWorkingCopy.resource;
             workingCopy = resourceOrWorkingCopy;
         }
@@ -260,8 +303,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
                     (async () => {
                         try {
                             await workingCopy.resolve(resolveOptions);
-                        }
-                        catch (error) {
+                        } catch (error) {
                             if (!workingCopy.isDisposed()) {
                                 onUnexpectedError(error);
                             }
@@ -283,7 +325,14 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
                 resource,
                 this.labelService.getUriBasenameLabel(resource),
                 this.modelFactory,
-                async (options) => { await this.resolve(resource, { ...options, reload: { async: false } }); },
+                async options => {
+                    await this.resolve(resource, {
+                        ...options,
+                        reload: {
+                            async: false
+                        }
+                    });
+                },
                 this.fileService,
                 this.logService,
                 this.workingCopyFileService,
@@ -308,14 +357,12 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         }
         try {
             await workingCopyResolve;
-        }
-        catch (error) {
+        } catch (error) {
             if (didCreateWorkingCopy) {
                 workingCopy.dispose();
             }
             throw error;
-        }
-        finally {
+        } finally {
             this.mapResourceToPendingWorkingCopyResolve.delete(resource);
         }
         if (didCreateWorkingCopy && workingCopy.isDirty()) {
@@ -340,19 +387,26 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
             currentWorkingCopyResolve = nextPendingWorkingCopyResolve;
             try {
                 await nextPendingWorkingCopyResolve;
-            }
-            catch (error) {
-            }
+            } catch (error) {}
         }
     }
     registerWorkingCopy(workingCopy) {
         const workingCopyListeners = ( new DisposableStore());
         workingCopyListeners.add(workingCopy.onDidResolve(() => this._onDidResolve.fire(workingCopy)));
-        workingCopyListeners.add(workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(workingCopy)));
-        workingCopyListeners.add(workingCopy.onDidChangeReadonly(() => this._onDidChangeReadonly.fire(workingCopy)));
-        workingCopyListeners.add(workingCopy.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire(workingCopy)));
+        workingCopyListeners.add(
+            workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(workingCopy))
+        );
+        workingCopyListeners.add(
+            workingCopy.onDidChangeReadonly(() => this._onDidChangeReadonly.fire(workingCopy))
+        );
+        workingCopyListeners.add(
+            workingCopy.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire(workingCopy))
+        );
         workingCopyListeners.add(workingCopy.onDidSaveError(() => this._onDidSaveError.fire(workingCopy)));
-        workingCopyListeners.add(workingCopy.onDidSave(e => this._onDidSave.fire({ workingCopy, ...e })));
+        workingCopyListeners.add(workingCopy.onDidSave(e => this._onDidSave.fire({
+            workingCopy,
+            ...e
+        })));
         workingCopyListeners.add(workingCopy.onDidRevert(() => this._onDidRevert.fire(workingCopy)));
         this.mapResourceToWorkingCopyListeners.set(workingCopy.resource, workingCopyListeners);
     }
@@ -369,8 +423,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         return removed;
     }
     canDispose(workingCopy) {
-        if (workingCopy.isDisposed() ||
-            (!( this.mapResourceToPendingWorkingCopyResolve.has(workingCopy.resource)) && !workingCopy.isDirty())) {
+        if (workingCopy.isDisposed() || (!( this.mapResourceToPendingWorkingCopyResolve.has(workingCopy.resource)) && !workingCopy.isDirty())) {
             return true;
         }
         return this.doCanDispose(workingCopy);
@@ -394,21 +447,6 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
         this.mapResourceToWorkingCopyListeners.clear();
     }
 };
-StoredFileWorkingCopyManager = ( __decorate([
-    ( __param(2, IFileService)),
-    ( __param(3, ILifecycleService)),
-    ( __param(4, ILabelService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IWorkingCopyFileService)),
-    ( __param(7, IWorkingCopyBackupService)),
-    ( __param(8, IUriIdentityService)),
-    ( __param(9, IFilesConfigurationService)),
-    ( __param(10, IWorkingCopyService)),
-    ( __param(11, INotificationService)),
-    ( __param(12, IWorkingCopyEditorService)),
-    ( __param(13, IEditorService)),
-    ( __param(14, IElevatedFileService)),
-    ( __param(15, IProgressService))
-], StoredFileWorkingCopyManager));
+StoredFileWorkingCopyManager = ( __decorate([( __param(2, IFileService)), ( __param(3, ILifecycleService)), ( __param(4, ILabelService)), ( __param(5, ILogService)), ( __param(6, IWorkingCopyFileService)), ( __param(7, IWorkingCopyBackupService)), ( __param(8, IUriIdentityService)), ( __param(9, IFilesConfigurationService)), ( __param(10, IWorkingCopyService)), ( __param(11, INotificationService)), ( __param(12, IWorkingCopyEditorService)), ( __param(13, IEditorService)), ( __param(14, IElevatedFileService)), ( __param(15, IProgressService))], StoredFileWorkingCopyManager));
 
 export { StoredFileWorkingCopyManager };