@codingame/monaco-vscode-working-copy-service-override 4.0.0 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-working-copy-service-override",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.0.0",
-    "@codingame/monaco-vscode-files-service-override": "4.0.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0",
+    "@codingame/monaco-vscode-files-service-override": "4.1.0"
   }
 }

package/workingCopy.js

@@ -1,10 +1,10 @@
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { BrowserWorkingCopyBackupService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupService.js';
+import { BrowserWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/browser/workingCopyBackupService';
 import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
 import { IWorkingCopyService, WorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
 import { IWorkingCopyEditorService, WorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService';
 import { IWorkingCopyHistoryService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory';
-import { BrowserWorkingCopyHistoryService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyHistoryService.js';
+import { BrowserWorkingCopyHistoryService } from 'vscode/vscode/vs/workbench/services/workingCopy/browser/workingCopyHistoryService';
 import getServiceOverride$1 from '@codingame/monaco-vscode-files-service-override';
 
 function getServiceOverride() {

package/external/tslib/tslib.es6.js

@@ -1,11 +0,0 @@
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function __param(paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-}
-
-export { __decorate, __param };

package/vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupService.js

@@ -1,25 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { WorkingCopyBackupService } from '../common/workingCopyBackupService.js';
-import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { joinPath } from 'vscode/vscode/vs/base/common/resources';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
-import { BrowserWorkingCopyBackupTracker } from './workingCopyBackupTracker.js';
-
-let BrowserWorkingCopyBackupService = class BrowserWorkingCopyBackupService extends WorkingCopyBackupService {
-    constructor(contextService, environmentService, fileService, logService) {
-        super(joinPath(environmentService.userRoamingDataHome, 'Backups', contextService.getWorkspace().id), fileService, logService);
-    }
-};
-BrowserWorkingCopyBackupService = ( __decorate([
-    ( __param(0, IWorkspaceContextService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IFileService)),
-    ( __param(3, ILogService))
-], BrowserWorkingCopyBackupService));
-registerWorkbenchContribution2(BrowserWorkingCopyBackupTracker.ID, BrowserWorkingCopyBackupTracker, 1 );
-
-export { BrowserWorkingCopyBackupService };

package/vscode/src/vs/workbench/services/workingCopy/browser/workingCopyBackupTracker.js

@@ -1,45 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
-import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
-import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
-import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { WorkingCopyBackupTracker } from '../common/workingCopyBackupTracker.js';
-import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
-
-let BrowserWorkingCopyBackupTracker = class BrowserWorkingCopyBackupTracker extends WorkingCopyBackupTracker {
-    static { this.ID = 'workbench.contrib.browserWorkingCopyBackupTracker'; }
-    constructor(workingCopyBackupService, filesConfigurationService, workingCopyService, lifecycleService, logService, workingCopyEditorService, editorService, editorGroupService) {
-        super(workingCopyBackupService, workingCopyService, logService, lifecycleService, filesConfigurationService, workingCopyEditorService, editorService, editorGroupService);
-    }
-    onFinalBeforeShutdown(reason) {
-        const modifiedWorkingCopies = this.workingCopyService.modifiedWorkingCopies;
-        if (!modifiedWorkingCopies.length) {
-            return false;
-        }
-        if (!this.filesConfigurationService.isHotExitEnabled) {
-            return true;
-        }
-        for (const modifiedWorkingCopy of modifiedWorkingCopies) {
-            if (!this.workingCopyBackupService.hasBackupSync(modifiedWorkingCopy, this.getContentVersion(modifiedWorkingCopy))) {
-                this.logService.warn('Unload veto: pending backups');
-                return true;
-            }
-        }
-        return false;
-    }
-};
-BrowserWorkingCopyBackupTracker = ( __decorate([
-    ( __param(0, IWorkingCopyBackupService)),
-    ( __param(1, IFilesConfigurationService)),
-    ( __param(2, IWorkingCopyService)),
-    ( __param(3, ILifecycleService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IWorkingCopyEditorService)),
-    ( __param(6, IEditorService)),
-    ( __param(7, IEditorGroupsService))
-], BrowserWorkingCopyBackupTracker));
-
-export { BrowserWorkingCopyBackupTracker };

package/vscode/src/vs/workbench/services/workingCopy/browser/workingCopyHistoryService.js

@@ -1,30 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { WorkingCopyHistoryService } from '../common/workingCopyHistoryService.js';
-import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-
-let BrowserWorkingCopyHistoryService = class BrowserWorkingCopyHistoryService extends WorkingCopyHistoryService {
-    constructor(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService) {
-        super(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService);
-    }
-    getModelOptions() {
-        return { flushOnChange: true  };
-    }
-};
-BrowserWorkingCopyHistoryService = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IRemoteAgentService)),
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IUriIdentityService)),
-    ( __param(4, ILabelService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IConfigurationService))
-], BrowserWorkingCopyHistoryService));
-
-export { BrowserWorkingCopyHistoryService };

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

@@ -1,454 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { joinPath } from 'vscode/vscode/vs/base/common/resources';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
-import { deepClone, equals } from 'vscode/vscode/vs/base/common/objects';
-import { ResourceQueue, Promises } from 'vscode/vscode/vs/base/common/async';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { isReadableStream, peekStream } from 'vscode/vscode/vs/base/common/stream';
-import { VSBuffer, prefixedBufferStream, prefixedBufferReadable, bufferToStream, streamToBuffer, readableToBuffer } from 'vscode/vscode/vs/base/common/buffer';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { hash } from 'vscode/vscode/vs/base/common/hash';
-import { isEmptyObject } from 'vscode/vscode/vs/base/common/types';
-import { NO_TYPE_ID } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopy';
-
-var WorkingCopyBackupServiceImpl_1;
-class WorkingCopyBackupsModel {
-    static async create(backupRoot, fileService) {
-        const model = ( new WorkingCopyBackupsModel(backupRoot, fileService));
-        await model.resolve();
-        return model;
-    }
-    constructor(backupRoot, fileService) {
-        this.backupRoot = backupRoot;
-        this.fileService = fileService;
-        this.cache = ( new ResourceMap());
-    }
-    async resolve() {
-        try {
-            const backupRootStat = await this.fileService.resolve(this.backupRoot);
-            if (backupRootStat.children) {
-                await Promises.settled(( backupRootStat.children
-                    .filter(child => child.isDirectory)
-                    .map(async (backupSchemaFolder) => {
-                    const backupSchemaFolderStat = await this.fileService.resolve(backupSchemaFolder.resource);
-                    if (backupSchemaFolderStat.children) {
-                        for (const backupForSchema of backupSchemaFolderStat.children) {
-                            if (!backupForSchema.isDirectory) {
-                                this.add(backupForSchema.resource);
-                            }
-                        }
-                    }
-                })));
-            }
-        }
-        catch (error) {
-        }
-    }
-    add(resource, versionId = 0, meta) {
-        this.cache.set(resource, {
-            versionId,
-            meta: deepClone(meta)
-        });
-    }
-    update(resource, meta) {
-        const entry = this.cache.get(resource);
-        if (entry) {
-            entry.meta = deepClone(meta);
-        }
-    }
-    count() {
-        return this.cache.size;
-    }
-    has(resource, versionId, meta) {
-        const entry = this.cache.get(resource);
-        if (!entry) {
-            return false;
-        }
-        if (typeof versionId === 'number' && versionId !== entry.versionId) {
-            return false;
-        }
-        if (meta && !equals(meta, entry.meta)) {
-            return false;
-        }
-        return true;
-    }
-    get() {
-        return Array.from(( this.cache.keys()));
-    }
-    remove(resource) {
-        this.cache.delete(resource);
-    }
-    clear() {
-        this.cache.clear();
-    }
-}
-let WorkingCopyBackupService = class WorkingCopyBackupService extends Disposable {
-    constructor(backupWorkspaceHome, fileService, logService) {
-        super();
-        this.fileService = fileService;
-        this.logService = logService;
-        this.impl = this._register(this.initialize(backupWorkspaceHome));
-    }
-    initialize(backupWorkspaceHome) {
-        if (backupWorkspaceHome) {
-            return ( new WorkingCopyBackupServiceImpl(backupWorkspaceHome, this.fileService, this.logService));
-        }
-        return ( new InMemoryWorkingCopyBackupService());
-    }
-    reinitialize(backupWorkspaceHome) {
-        if (this.impl instanceof WorkingCopyBackupServiceImpl) {
-            if (backupWorkspaceHome) {
-                this.impl.initialize(backupWorkspaceHome);
-            }
-            else {
-                this.impl = ( new InMemoryWorkingCopyBackupService());
-            }
-        }
-    }
-    hasBackups() {
-        return this.impl.hasBackups();
-    }
-    hasBackupSync(identifier, versionId, meta) {
-        return this.impl.hasBackupSync(identifier, versionId, meta);
-    }
-    backup(identifier, content, versionId, meta, token) {
-        return this.impl.backup(identifier, content, versionId, meta, token);
-    }
-    discardBackup(identifier, token) {
-        return this.impl.discardBackup(identifier, token);
-    }
-    discardBackups(filter) {
-        return this.impl.discardBackups(filter);
-    }
-    getBackups() {
-        return this.impl.getBackups();
-    }
-    resolve(identifier) {
-        return this.impl.resolve(identifier);
-    }
-    toBackupResource(identifier) {
-        return this.impl.toBackupResource(identifier);
-    }
-    joinBackups() {
-        return this.impl.joinBackups();
-    }
-};
-WorkingCopyBackupService = ( __decorate([
-    ( __param(1, IFileService)),
-    ( __param(2, ILogService))
-], WorkingCopyBackupService));
-let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Disposable {
-    static { WorkingCopyBackupServiceImpl_1 = this; }
-    static { this.PREAMBLE_END_MARKER = '\n'; }
-    static { this.PREAMBLE_END_MARKER_CHARCODE = '\n'.charCodeAt(0); }
-    static { this.PREAMBLE_META_SEPARATOR = ' '; }
-    static { this.PREAMBLE_MAX_LENGTH = 10000; }
-    constructor(backupWorkspaceHome, fileService, logService) {
-        super();
-        this.backupWorkspaceHome = backupWorkspaceHome;
-        this.fileService = fileService;
-        this.logService = logService;
-        this.ioOperationQueues = this._register(( new ResourceQueue()));
-        this.model = undefined;
-        this.initialize(backupWorkspaceHome);
-    }
-    initialize(backupWorkspaceResource) {
-        this.backupWorkspaceHome = backupWorkspaceResource;
-        this.ready = this.doInitialize();
-    }
-    async doInitialize() {
-        this.model = await WorkingCopyBackupsModel.create(this.backupWorkspaceHome, this.fileService);
-        return this.model;
-    }
-    async hasBackups() {
-        const model = await this.ready;
-        await this.joinBackups();
-        return model.count() > 0;
-    }
-    hasBackupSync(identifier, versionId, meta) {
-        if (!this.model) {
-            return false;
-        }
-        const backupResource = this.toBackupResource(identifier);
-        return ( this.model.has(backupResource, versionId, meta));
-    }
-    async backup(identifier, content, versionId, meta, token) {
-        const model = await this.ready;
-        if (token?.isCancellationRequested) {
-            return;
-        }
-        const backupResource = this.toBackupResource(identifier);
-        if (( model.has(backupResource, versionId, meta))) {
-            return;
-        }
-        return this.ioOperationQueues.queueFor(backupResource, async () => {
-            if (token?.isCancellationRequested) {
-                return;
-            }
-            if (( model.has(backupResource, versionId, meta))) {
-                return;
-            }
-            let preamble = this.createPreamble(identifier, meta);
-            if (preamble.length >= WorkingCopyBackupServiceImpl_1.PREAMBLE_MAX_LENGTH) {
-                preamble = this.createPreamble(identifier);
-            }
-            const preambleBuffer = VSBuffer.fromString(preamble);
-            let backupBuffer;
-            if (isReadableStream(content)) {
-                backupBuffer = prefixedBufferStream(preambleBuffer, content);
-            }
-            else if (content) {
-                backupBuffer = prefixedBufferReadable(preambleBuffer, content);
-            }
-            else {
-                backupBuffer = VSBuffer.concat([preambleBuffer, VSBuffer.fromString('')]);
-            }
-            await this.fileService.writeFile(backupResource, backupBuffer);
-            model.add(backupResource, versionId, meta);
-        });
-    }
-    createPreamble(identifier, meta) {
-        return `${( identifier.resource.toString())}${WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR}${JSON.stringify({ ...meta, typeId: identifier.typeId })}${WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER}`;
-    }
-    async discardBackups(filter) {
-        const model = await this.ready;
-        const except = filter?.except;
-        if (Array.isArray(except) && except.length > 0) {
-            const exceptMap = ( new ResourceMap());
-            for (const exceptWorkingCopy of except) {
-                exceptMap.set(this.toBackupResource(exceptWorkingCopy), true);
-            }
-            await Promises.settled(( model.get().map(async (backupResource) => {
-                if (!( exceptMap.has(backupResource))) {
-                    await this.doDiscardBackup(backupResource);
-                }
-            })));
-        }
-        else {
-            await this.deleteIgnoreFileNotFound(this.backupWorkspaceHome);
-            model.clear();
-        }
-    }
-    discardBackup(identifier, token) {
-        const backupResource = this.toBackupResource(identifier);
-        return this.doDiscardBackup(backupResource, token);
-    }
-    async doDiscardBackup(backupResource, token) {
-        const model = await this.ready;
-        if (token?.isCancellationRequested) {
-            return;
-        }
-        return this.ioOperationQueues.queueFor(backupResource, async () => {
-            if (token?.isCancellationRequested) {
-                return;
-            }
-            await this.deleteIgnoreFileNotFound(backupResource);
-            model.remove(backupResource);
-        });
-    }
-    async deleteIgnoreFileNotFound(backupResource) {
-        try {
-            await this.fileService.del(backupResource, { recursive: true });
-        }
-        catch (error) {
-            if (error.fileOperationResult !== 1 ) {
-                throw error;
-            }
-        }
-    }
-    async getBackups() {
-        const model = await this.ready;
-        await this.joinBackups();
-        const backups = await Promise.all(( model.get().map(backupResource => this.resolveIdentifier(backupResource, model))));
-        return coalesce(backups);
-    }
-    async resolveIdentifier(backupResource, model) {
-        let res = undefined;
-        await this.ioOperationQueues.queueFor(backupResource, async () => {
-            if (!( model.has(backupResource))) {
-                return;
-            }
-            const backupPreamble = await this.readToMatchingString(backupResource, WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER, WorkingCopyBackupServiceImpl_1.PREAMBLE_MAX_LENGTH);
-            if (!backupPreamble) {
-                return;
-            }
-            const metaStartIndex = backupPreamble.indexOf(WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR);
-            let resourcePreamble;
-            let metaPreamble;
-            if (metaStartIndex > 0) {
-                resourcePreamble = backupPreamble.substring(0, metaStartIndex);
-                metaPreamble = backupPreamble.substr(metaStartIndex + 1);
-            }
-            else {
-                resourcePreamble = backupPreamble;
-                metaPreamble = undefined;
-            }
-            const { typeId, meta } = this.parsePreambleMeta(metaPreamble);
-            model.update(backupResource, meta);
-            res = {
-                typeId: typeId ?? NO_TYPE_ID,
-                resource: ( URI.parse(resourcePreamble))
-            };
-        });
-        return res;
-    }
-    async readToMatchingString(backupResource, matchingString, maximumBytesToRead) {
-        const contents = ( (await this.fileService.readFile(backupResource, { length: maximumBytesToRead })).value.toString());
-        const matchingStringIndex = contents.indexOf(matchingString);
-        if (matchingStringIndex >= 0) {
-            return contents.substr(0, matchingStringIndex);
-        }
-        return undefined;
-    }
-    async resolve(identifier) {
-        const backupResource = this.toBackupResource(identifier);
-        const model = await this.ready;
-        let res = undefined;
-        await this.ioOperationQueues.queueFor(backupResource, async () => {
-            if (!( model.has(backupResource))) {
-                return;
-            }
-            const backupStream = await this.fileService.readFileStream(backupResource);
-            const peekedBackupStream = await peekStream(backupStream.value, 1);
-            const firstBackupChunk = VSBuffer.concat(peekedBackupStream.buffer);
-            const preambleEndIndex = firstBackupChunk.buffer.indexOf(WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER_CHARCODE);
-            if (preambleEndIndex === -1) {
-                this.logService.trace(`Backup: Could not find meta end marker in ${backupResource}. The file is probably corrupt (filesize: ${backupStream.size}).`);
-                return undefined;
-            }
-            const preambelRaw = ( firstBackupChunk.slice(0, preambleEndIndex).toString());
-            let meta;
-            const metaStartIndex = preambelRaw.indexOf(WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR);
-            if (metaStartIndex !== -1) {
-                meta = this.parsePreambleMeta(preambelRaw.substr(metaStartIndex + 1)).meta;
-            }
-            model.update(backupResource, meta);
-            const firstBackupChunkWithoutPreamble = firstBackupChunk.slice(preambleEndIndex + 1);
-            let value;
-            if (peekedBackupStream.ended) {
-                value = bufferToStream(firstBackupChunkWithoutPreamble);
-            }
-            else {
-                value = prefixedBufferStream(firstBackupChunkWithoutPreamble, peekedBackupStream.stream);
-            }
-            res = { value, meta };
-        });
-        return res;
-    }
-    parsePreambleMeta(preambleMetaRaw) {
-        let typeId = undefined;
-        let meta = undefined;
-        if (preambleMetaRaw) {
-            try {
-                meta = JSON.parse(preambleMetaRaw);
-                typeId = meta?.typeId;
-                if (typeof meta?.typeId === 'string') {
-                    delete meta.typeId;
-                    if (isEmptyObject(meta)) {
-                        meta = undefined;
-                    }
-                }
-            }
-            catch (error) {
-            }
-        }
-        return { typeId, meta };
-    }
-    toBackupResource(identifier) {
-        return joinPath(this.backupWorkspaceHome, identifier.resource.scheme, hashIdentifier(identifier));
-    }
-    joinBackups() {
-        return this.ioOperationQueues.whenDrained();
-    }
-};
-WorkingCopyBackupServiceImpl = WorkingCopyBackupServiceImpl_1 = ( __decorate([
-    ( __param(1, IFileService)),
-    ( __param(2, ILogService))
-], WorkingCopyBackupServiceImpl));
-class InMemoryWorkingCopyBackupService extends Disposable {
-    constructor() {
-        super();
-        this.backups = ( new ResourceMap());
-    }
-    async hasBackups() {
-        return this.backups.size > 0;
-    }
-    hasBackupSync(identifier, versionId) {
-        const backupResource = this.toBackupResource(identifier);
-        return ( this.backups.has(backupResource));
-    }
-    async backup(identifier, content, versionId, meta, token) {
-        const backupResource = this.toBackupResource(identifier);
-        this.backups.set(backupResource, {
-            typeId: identifier.typeId,
-            content: content instanceof VSBuffer ? content : content ? isReadableStream(content) ? await streamToBuffer(content) : readableToBuffer(content) : VSBuffer.fromString(''),
-            meta
-        });
-    }
-    async resolve(identifier) {
-        const backupResource = this.toBackupResource(identifier);
-        const backup = this.backups.get(backupResource);
-        if (backup) {
-            return { value: bufferToStream(backup.content), meta: backup.meta };
-        }
-        return undefined;
-    }
-    async getBackups() {
-        return ( Array.from(this.backups.entries()).map(([resource, backup]) => ({ typeId: backup.typeId, resource })));
-    }
-    async discardBackup(identifier) {
-        this.backups.delete(this.toBackupResource(identifier));
-    }
-    async discardBackups(filter) {
-        const except = filter?.except;
-        if (Array.isArray(except) && except.length > 0) {
-            const exceptMap = ( new ResourceMap());
-            for (const exceptWorkingCopy of except) {
-                exceptMap.set(this.toBackupResource(exceptWorkingCopy), true);
-            }
-            for (const backup of await this.getBackups()) {
-                if (!( exceptMap.has(this.toBackupResource(backup)))) {
-                    await this.discardBackup(backup);
-                }
-            }
-        }
-        else {
-            this.backups.clear();
-        }
-    }
-    toBackupResource(identifier) {
-        return ( URI.from({ scheme: Schemas.inMemory, path: hashIdentifier(identifier) }));
-    }
-    async joinBackups() {
-        return;
-    }
-}
-function hashIdentifier(identifier) {
-    let resource;
-    if (identifier.typeId.length > 0) {
-        const typeIdHash = hashString(identifier.typeId);
-        if (identifier.resource.path) {
-            resource = joinPath(identifier.resource, typeIdHash);
-        }
-        else {
-            resource = identifier.resource.with({ path: typeIdHash });
-        }
-    }
-    else {
-        resource = identifier.resource;
-    }
-    return hashPath(resource);
-}
-function hashPath(resource) {
-    const str = resource.scheme === Schemas.file || resource.scheme === Schemas.untitled ? resource.fsPath : ( resource.toString());
-    return hashString(str);
-}
-function hashString(str) {
-    return ( hash(str).toString(16));
-}
-
-export { InMemoryWorkingCopyBackupService, WorkingCopyBackupService, WorkingCopyBackupsModel, hashIdentifier };