@codingame/monaco-vscode-api 1.69.7 → 1.69.8

package/dist/services2.js

@@ -1,24 +1,305 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { b as __decorate, d as __param, i as insert } from './contextkey.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isWindows, OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { win32, posix } from 'monaco-editor/esm/vs/base/common/path.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { DisposableStore, SafeDisposable, Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { raceCancellation, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/map.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
+import 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import 'monaco-editor/esm/vs/editor/common/services/model.js';
+import 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import 'monaco-editor/esm/vs/base/common/severity.js';
+class EventProfiling {
+    constructor(name) {
+        this._listenerCount = 0;
+        this._invocationCount = 0;
+        this._elapsedOverall = 0;
+        this._name = `${name}_${EventProfiling._idPool++}`;
+    }
+    start(listenerCount) {
+        this._stopWatch = ( new StopWatch(true));
+        this._listenerCount = listenerCount;
+    }
+    stop() {
+        if (this._stopWatch) {
+            const elapsed = this._stopWatch.elapsed();
+            this._elapsedOverall += elapsed;
+            this._invocationCount += 1;
+            console.info(`did FIRE ${this._name}: elapsed_ms: ${elapsed.toFixed(5)}, listener: ${this._listenerCount} (elapsed_overall: ${this._elapsedOverall.toFixed(2)}, invocations: ${this._invocationCount})`);
+            this._stopWatch = undefined;
+        }
+    }
+}
+EventProfiling._idPool = 0;
+class Stacktrace {
+    constructor(value) {
+        this.value = value;
+    }
+    static create() {
+        return ( new Stacktrace(( new Error()).stack ?? ''));
+    }
+    print() {
+        console.warn(this.value.split('\n').slice(2).join('\n'));
+    }
+}
+class Listener {
+    constructor(callback, callbackThis, stack) {
+        this.callback = callback;
+        this.callbackThis = callbackThis;
+        this.stack = stack;
+        this.subscription = ( new SafeDisposable());
+    }
+    invoke(e) {
+        this.callback.call(this.callbackThis, e);
+    }
+}
+class Emitter {
+    constructor(options) {
+        this._disposed = false;
+        this._options = options;
+        this._leakageMon = undefined;
+        this._perfMon = this._options?._profName ? ( new EventProfiling(this._options._profName)) : undefined;
+        this._deliveryQueue = this._options?.deliveryQueue;
+    }
+    dispose() {
+        if (!this._disposed) {
+            this._disposed = true;
+            if (this._listeners) {
+                this._listeners.clear();
+            }
+            this._deliveryQueue?.clear(this);
+            this._options?.onLastListenerRemove?.();
+            this._leakageMon?.dispose();
+        }
+    }
+    get event() {
+        if (!this._event) {
+            this._event = (callback, thisArgs, disposables) => {
+                if (!this._listeners) {
+                    this._listeners = ( new LinkedList());
+                }
+                const firstListener = this._listeners.isEmpty();
+                if (firstListener && this._options?.onFirstListenerAdd) {
+                    this._options.onFirstListenerAdd(this);
+                }
+                let removeMonitor;
+                let stack;
+                if (this._leakageMon && this._listeners.size >= 30) {
+                    stack = Stacktrace.create();
+                    removeMonitor = this._leakageMon.check(stack, this._listeners.size + 1);
+                }
+                const listener = ( new Listener(callback, thisArgs, stack));
+                const removeListener = this._listeners.push(listener);
+                if (firstListener && this._options?.onFirstListenerDidAdd) {
+                    this._options.onFirstListenerDidAdd(this);
+                }
+                if (this._options?.onListenerDidAdd) {
+                    this._options.onListenerDidAdd(this, callback, thisArgs);
+                }
+                const result = listener.subscription.set(() => {
+                    removeMonitor?.();
+                    if (!this._disposed) {
+                        removeListener();
+                        if (this._options && this._options.onLastListenerRemove) {
+                            const hasListeners = (this._listeners && !this._listeners.isEmpty());
+                            if (!hasListeners) {
+                                this._options.onLastListenerRemove(this);
+                            }
+                        }
+                    }
+                });
+                if (disposables instanceof DisposableStore) {
+                    disposables.add(result);
+                }
+                else if (Array.isArray(disposables)) {
+                    disposables.push(result);
+                }
+                return result;
+            };
+        }
+        return this._event;
+    }
+    fire(event) {
+        if (this._listeners) {
+            if (!this._deliveryQueue) {
+                this._deliveryQueue = ( new PrivateEventDeliveryQueue());
+            }
+            for (const listener of this._listeners) {
+                this._deliveryQueue.push(this, listener, event);
+            }
+            this._perfMon?.start(this._deliveryQueue.size);
+            this._deliveryQueue.deliver();
+            this._perfMon?.stop();
+        }
+    }
+    hasListeners() {
+        if (!this._listeners) {
+            return false;
+        }
+        return (!this._listeners.isEmpty());
+    }
+}
+class EventDeliveryQueue {
+    constructor() {
+        this._queue = ( new LinkedList());
+    }
+    get size() {
+        return this._queue.size;
+    }
+    push(emitter, listener, event) {
+        this._queue.push(( new EventDeliveryQueueElement(emitter, listener, event)));
+    }
+    clear(emitter) {
+        const newQueue = ( new LinkedList());
+        for (const element of this._queue) {
+            if (element.emitter !== emitter) {
+                newQueue.push(element);
+            }
+        }
+        this._queue = newQueue;
+    }
+    deliver() {
+        while (this._queue.size > 0) {
+            const element = this._queue.shift();
+            try {
+                element.listener.invoke(element.event);
+            }
+            catch (e) {
+                onUnexpectedError(e);
+            }
+        }
+    }
+}
+class PrivateEventDeliveryQueue extends EventDeliveryQueue {
+    clear(emitter) {
+        this._queue.clear();
+    }
+}
+class EventDeliveryQueueElement {
+    constructor(emitter, listener, event) {
+        this.emitter = emitter;
+        this.listener = listener;
+        this.event = event;
+    }
+}
+class AsyncEmitter extends Emitter {
+    async fireAsync(data, token, promiseJoin) {
+        if (!this._listeners) {
+            return;
+        }
+        if (!this._asyncDeliveryQueue) {
+            this._asyncDeliveryQueue = ( new LinkedList());
+        }
+        for (const listener of this._listeners) {
+            this._asyncDeliveryQueue.push([listener, data]);
+        }
+        while (this._asyncDeliveryQueue.size > 0 && !token.isCancellationRequested) {
+            const [listener, data] = this._asyncDeliveryQueue.shift();
+            const thenables = [];
+            const event = {
+                ...data,
+                token,
+                waitUntil: (p) => {
+                    if (Object.isFrozen(thenables)) {
+                        throw new Error('waitUntil can NOT be called asynchronous');
+                    }
+                    if (promiseJoin) {
+                        p = promiseJoin(p, listener.callback);
+                    }
+                    thenables.push(p);
+                }
+            };
+            try {
+                listener.invoke(event);
+            }
+            catch (e) {
+                onUnexpectedError(e);
+                continue;
+            }
+            await Promise.allSettled(thenables).then(values => {
+                for (const value of values) {
+                    if (value.status === 'rejected') {
+                        onUnexpectedError(value.reason);
+                    }
+                }
+            });
+        }
+    }
+}
 function refineServiceDecorator(serviceIdentifier) {
     return serviceIdentifier;
 }
 const CancellationTokenSource = monaco.CancellationTokenSource;
-const IFileService = ( (createDecorator('fileService')));
+const WINDOWS_INVALID_FILE_CHARS = /[\\/:\*\?"<>\|]/g;
+const UNIX_INVALID_FILE_CHARS = /[\\/]/g;
+const WINDOWS_FORBIDDEN_NAMES = /^(con|prn|aux|clock\$|nul|lpt[0-9]|com[0-9])(\.(.*?))?$/i;
+function isValidBasename(name, isWindowsOS = isWindows) {
+    const invalidFileChars = isWindowsOS ? WINDOWS_INVALID_FILE_CHARS : UNIX_INVALID_FILE_CHARS;
+    if (!name || name.length === 0 || /^\s+$/.test(name)) {
+        return false;
+    }
+    invalidFileChars.lastIndex = 0;
+    if (invalidFileChars.test(name)) {
+        return false;
+    }
+    if (isWindowsOS && WINDOWS_FORBIDDEN_NAMES.test(name)) {
+        return false;
+    }
+    if (name === '.' || name === '..') {
+        return false;
+    }
+    if (isWindowsOS && name[name.length - 1] === '.') {
+        return false;
+    }
+    if (isWindowsOS && name.length !== name.trim().length) {
+        return false;
+    }
+    if (name.length > 255) {
+        return false;
+    }
+    return true;
+}
+const IFileService = ( createDecorator('fileService'));
 var FileType;
-( ((function(FileType) {
+( (function(FileType) {
     FileType[FileType["Unknown"] = 0] = "Unknown";
     FileType[FileType["File"] = 1] = "File";
     FileType[FileType["Directory"] = 2] = "Directory";
     FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
-})(FileType || (FileType = {}))));
+})(FileType || (FileType = {})));
 var FilePermission;
-( ((function(FilePermission) {
+( (function(FilePermission) {
     FilePermission[FilePermission["Readonly"] = 1] = "Readonly";
-})(FilePermission || (FilePermission = {}))));
+})(FilePermission || (FilePermission = {})));
 function hasReadWriteCapability(provider) {
     return !!((provider.capabilities & 2) );
 }
@@ -41,7 +322,7 @@ function hasFileAtomicReadCapability(provider) {
     return !!((provider.capabilities & 16384) );
 }
 var FileSystemProviderErrorCode;
-( ((function(FileSystemProviderErrorCode) {
+( (function(FileSystemProviderErrorCode) {
     FileSystemProviderErrorCode["FileExists"] = "EntryExists";
     FileSystemProviderErrorCode["FileNotFound"] = "EntryNotFound";
     FileSystemProviderErrorCode["FileNotADirectory"] = "EntryNotADirectory";
@@ -52,7 +333,7 @@ var FileSystemProviderErrorCode;
     FileSystemProviderErrorCode["NoPermissions"] = "NoPermissions";
     FileSystemProviderErrorCode["Unavailable"] = "Unavailable";
     FileSystemProviderErrorCode["Unknown"] = "Unknown";
-})(FileSystemProviderErrorCode || (FileSystemProviderErrorCode = {}))));
+})(FileSystemProviderErrorCode || (FileSystemProviderErrorCode = {})));
 class FileSystemProviderError extends Error {
     constructor(message, code) {
         super(message);
@@ -60,13 +341,13 @@ class FileSystemProviderError extends Error {
     }
 }
 function createFileSystemProviderError(error, code) {
-    const providerError = ( (new FileSystemProviderError( (error.toString()), code)));
+    const providerError = ( new FileSystemProviderError(( error.toString()), code));
     markAsFileSystemProviderError(providerError, code);
     return providerError;
 }
 function ensureFileSystemProviderError(error) {
     if (!error) {
-        return createFileSystemProviderError(( (localize('unknownError', "Unknown Error"))), FileSystemProviderErrorCode.Unknown);
+        return createFileSystemProviderError(( localize('unknownError', "Unknown Error")), FileSystemProviderErrorCode.Unknown);
     }
     return error;
 }
@@ -143,7 +424,7 @@ class FileChangesEvent {
         this.rawUpdated = [];
         this.rawDeleted = [];
         this.rawChanges = changes;
-        const entriesByType = ( (new Map()));
+        const entriesByType = ( new Map());
         for (const change of changes) {
             const array = entriesByType.get(change.type);
             if (array) {
@@ -247,34 +528,386 @@ function etag(stat) {
     if (typeof stat.size !== 'number' || typeof stat.mtime !== 'number') {
         return undefined;
     }
-    return ( (stat.mtime.toString(29))) + ( (stat.size.toString(31)));
+    return ( stat.mtime.toString(29)) + ( stat.size.toString(31));
 }
-const IUriIdentityService = ( (createDecorator('IUriIdentityService')));
-const IEditorGroupsService = ( (createDecorator('editorGroupsService')));
+const IUriIdentityService = ( createDecorator('IUriIdentityService'));
+const IEditorGroupsService = ( createDecorator('editorGroupsService'));
 function isEditorGroup(obj) {
     const group = obj;
     return !!group && typeof group.id === 'number' && Array.isArray(group.editors);
 }
-const IEditorService = ( (createDecorator('editorService')));
+const IEditorService = ( createDecorator('editorService'));
 const ACTIVE_GROUP = -1;
 const SIDE_GROUP = -2;
 function isPreferredGroup(obj) {
     const candidate = obj;
     return typeof obj === 'number' || isEditorGroup(candidate);
 }
-const ITextFileService = ( (createDecorator('textFileService')));
+const ITextFileService = ( createDecorator('textFileService'));
 const IWorkbenchEnvironmentService = refineServiceDecorator(IEnvironmentService);
-const IWorkingCopyFileService = ( (createDecorator('workingCopyFileService')));
-const IPathService = ( (createDecorator('pathService')));
-const IPaneCompositePartService = ( (createDecorator('paneCompositePartService')));
-const IProductService = ( (createDecorator('productService')));
+const IWorkingCopyService = ( createDecorator('workingCopyService'));
+let WorkingCopyFileOperationParticipant = class WorkingCopyFileOperationParticipant extends Disposable {
+    constructor(logService, configurationService) {
+        super();
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.participants = ( new LinkedList());
+    }
+    addFileOperationParticipant(participant) {
+        const remove = this.participants.push(participant);
+        return toDisposable(() => remove());
+    }
+    async participate(files, operation, undoInfo, token) {
+        const timeout = this.configurationService.getValue('files.participants.timeout');
+        if (typeof timeout !== 'number' || timeout <= 0) {
+            return;
+        }
+        for (const participant of this.participants) {
+            try {
+                await participant.participate(files, operation, undoInfo, timeout, token);
+            }
+            catch (err) {
+                this.logService.warn(err);
+            }
+        }
+    }
+    dispose() {
+        this.participants.clear();
+    }
+};
+WorkingCopyFileOperationParticipant = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IConfigurationService))
+], WorkingCopyFileOperationParticipant));
+let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySaveParticipant extends Disposable {
+    constructor(progressService, logService) {
+        super();
+        this.progressService = progressService;
+        this.logService = logService;
+        this.saveParticipants = [];
+    }
+    get length() { return this.saveParticipants.length; }
+    addSaveParticipant(participant) {
+        const remove = insert(this.saveParticipants, participant);
+        return toDisposable(() => remove());
+    }
+    participate(workingCopy, context, token) {
+        const cts = ( new CancellationTokenSource(token));
+        return this.progressService.withProgress({
+            title: ( localize('saveParticipants', "Saving '{0}'", workingCopy.name)),
+            location: 15 ,
+            cancellable: true,
+            delay: workingCopy.isDirty() ? 3000 : 5000
+        }, async (progress) => {
+            workingCopy.model?.pushStackElement();
+            for (const saveParticipant of this.saveParticipants) {
+                if (cts.token.isCancellationRequested || workingCopy.isDisposed()) {
+                    break;
+                }
+                try {
+                    const promise = saveParticipant.participate(workingCopy, context, progress, cts.token);
+                    await raceCancellation(promise, cts.token);
+                }
+                catch (err) {
+                    this.logService.warn(err);
+                }
+            }
+            workingCopy.model?.pushStackElement();
+        }, () => {
+            cts.dispose(true);
+        });
+    }
+    dispose() {
+        this.saveParticipants.splice(0, this.saveParticipants.length);
+    }
+};
+StoredFileWorkingCopySaveParticipant = ( __decorate([
+    ( __param(0, IProgressService)),
+    ( __param(1, ILogService))
+], StoredFileWorkingCopySaveParticipant));
+const IWorkingCopyFileService = ( createDecorator('workingCopyFileService'));
+let WorkingCopyFileService = class WorkingCopyFileService extends Disposable {
+    constructor(fileService, workingCopyService, instantiationService, uriIdentityService) {
+        super();
+        this.fileService = fileService;
+        this.workingCopyService = workingCopyService;
+        this.instantiationService = instantiationService;
+        this.uriIdentityService = uriIdentityService;
+        this._onWillRunWorkingCopyFileOperation = this._register(( new AsyncEmitter()));
+        this.onWillRunWorkingCopyFileOperation = this._onWillRunWorkingCopyFileOperation.event;
+        this._onDidFailWorkingCopyFileOperation = this._register(( new AsyncEmitter()));
+        this.onDidFailWorkingCopyFileOperation = this._onDidFailWorkingCopyFileOperation.event;
+        this._onDidRunWorkingCopyFileOperation = this._register(( new AsyncEmitter()));
+        this.onDidRunWorkingCopyFileOperation = this._onDidRunWorkingCopyFileOperation.event;
+        this.correlationIds = 0;
+        this.fileOperationParticipants = this._register(this.instantiationService.createInstance(WorkingCopyFileOperationParticipant));
+        this.saveParticipants = this._register(this.instantiationService.createInstance(StoredFileWorkingCopySaveParticipant));
+        this.workingCopyProviders = [];
+        this._register(this.registerWorkingCopyProvider(resource => {
+            return this.workingCopyService.workingCopies.filter(workingCopy => {
+                if (this.fileService.hasProvider(resource)) {
+                    return this.uriIdentityService.extUri.isEqualOrParent(workingCopy.resource, resource);
+                }
+                return this.uriIdentityService.extUri.isEqual(workingCopy.resource, resource);
+            });
+        }));
+    }
+    create(operations, token, undoInfo) {
+        return this.doCreateFileOrFolder(operations, true, token, undoInfo);
+    }
+    createFolder(operations, token, undoInfo) {
+        return this.doCreateFileOrFolder(operations, false, token, undoInfo);
+    }
+    async doCreateFileOrFolder(operations, isFile, token, undoInfo) {
+        if (operations.length === 0) {
+            return [];
+        }
+        if (isFile) {
+            const validateCreates = await Promises.settled(operations.map(operation => this.fileService.canCreateFile(operation.resource, { overwrite: operation.overwrite })));
+            const error = validateCreates.find(validateCreate => validateCreate instanceof Error);
+            if (error instanceof Error) {
+                throw error;
+            }
+        }
+        const files = operations.map(operation => ({ target: operation.resource }));
+        await this.runFileOperationParticipants(files, 0 , undoInfo, token);
+        const event = { correlationId: this.correlationIds++, operation: 0 , files };
+        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        let stats;
+        try {
+            if (isFile) {
+                stats = await Promises.settled(operations.map(operation => this.fileService.createFile(operation.resource, operation.contents, { overwrite: operation.overwrite })));
+            }
+            else {
+                stats = await Promises.settled(operations.map(operation => this.fileService.createFolder(operation.resource)));
+            }
+        }
+        catch (error) {
+            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+            throw error;
+        }
+        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        return stats;
+    }
+    async move(operations, token, undoInfo) {
+        return this.doMoveOrCopy(operations, true, token, undoInfo);
+    }
+    async copy(operations, token, undoInfo) {
+        return this.doMoveOrCopy(operations, false, token, undoInfo);
+    }
+    async doMoveOrCopy(operations, move, token, undoInfo) {
+        const stats = [];
+        for (const { file: { source, target }, overwrite } of operations) {
+            const validateMoveOrCopy = await (move ? this.fileService.canMove(source, target, overwrite) : this.fileService.canCopy(source, target, overwrite));
+            if (validateMoveOrCopy instanceof Error) {
+                throw validateMoveOrCopy;
+            }
+        }
+        const files = operations.map(o => o.file);
+        await this.runFileOperationParticipants(files, move ? 2  : 3 , undoInfo, token);
+        const event = { correlationId: this.correlationIds++, operation: move ? 2  : 3 , files };
+        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        try {
+            for (const { file: { source, target }, overwrite } of operations) {
+                if (!this.uriIdentityService.extUri.isEqual(source, target)) {
+                    const dirtyWorkingCopies = (move ? [...this.getDirty(source), ...this.getDirty(target)] : this.getDirty(target));
+                    await Promises.settled(dirtyWorkingCopies.map(dirtyWorkingCopy => dirtyWorkingCopy.revert({ soft: true })));
+                }
+                if (move) {
+                    stats.push(await this.fileService.move(source, target, overwrite));
+                }
+                else {
+                    stats.push(await this.fileService.copy(source, target, overwrite));
+                }
+            }
+        }
+        catch (error) {
+            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+            throw error;
+        }
+        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        return stats;
+    }
+    async delete(operations, token, undoInfo) {
+        for (const operation of operations) {
+            const validateDelete = await this.fileService.canDelete(operation.resource, { recursive: operation.recursive, useTrash: operation.useTrash });
+            if (validateDelete instanceof Error) {
+                throw validateDelete;
+            }
+        }
+        const files = operations.map(operation => ({ target: operation.resource }));
+        await this.runFileOperationParticipants(files, 1 , undoInfo, token);
+        const event = { correlationId: this.correlationIds++, operation: 1 , files };
+        await this._onWillRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+        for (const operation of operations) {
+            const dirtyWorkingCopies = this.getDirty(operation.resource);
+            await Promises.settled(dirtyWorkingCopies.map(dirtyWorkingCopy => dirtyWorkingCopy.revert({ soft: true })));
+        }
+        try {
+            for (const operation of operations) {
+                await this.fileService.del(operation.resource, { recursive: operation.recursive, useTrash: operation.useTrash });
+            }
+        }
+        catch (error) {
+            await this._onDidFailWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+            throw error;
+        }
+        await this._onDidRunWorkingCopyFileOperation.fireAsync(event, CancellationToken.None );
+    }
+    addFileOperationParticipant(participant) {
+        return this.fileOperationParticipants.addFileOperationParticipant(participant);
+    }
+    runFileOperationParticipants(files, operation, undoInfo, token) {
+        return this.fileOperationParticipants.participate(files, operation, undoInfo, token);
+    }
+    get hasSaveParticipants() { return this.saveParticipants.length > 0; }
+    addSaveParticipant(participant) {
+        return this.saveParticipants.addSaveParticipant(participant);
+    }
+    runSaveParticipants(workingCopy, context, token) {
+        return this.saveParticipants.participate(workingCopy, context, token);
+    }
+    registerWorkingCopyProvider(provider) {
+        const remove = insert(this.workingCopyProviders, provider);
+        return toDisposable(remove);
+    }
+    getDirty(resource) {
+        const dirtyWorkingCopies = ( new Set());
+        for (const provider of this.workingCopyProviders) {
+            for (const workingCopy of provider(resource)) {
+                if (workingCopy.isDirty()) {
+                    dirtyWorkingCopies.add(workingCopy);
+                }
+            }
+        }
+        return Array.from(dirtyWorkingCopies);
+    }
+};
+WorkingCopyFileService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IWorkingCopyService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IUriIdentityService))
+], WorkingCopyFileService));
+function isVirtualResource(resource) {
+    return resource.scheme !== Schemas.file && resource.scheme !== Schemas.vscodeRemote;
+}
+function getVirtualWorkspaceLocation(workspace) {
+    if (workspace.folders.length) {
+        return workspace.folders.every(f => isVirtualResource(f.uri)) ? workspace.folders[0].uri : undefined;
+    }
+    else if (workspace.configuration && isVirtualResource(workspace.configuration)) {
+        return workspace.configuration;
+    }
+    return undefined;
+}
+function getVirtualWorkspaceScheme(workspace) {
+    return getVirtualWorkspaceLocation(workspace)?.scheme;
+}
+const IRemoteAgentService = ( createDecorator('remoteAgentService'));
+const IPathService = ( createDecorator('pathService'));
+let AbstractPathService = class AbstractPathService {
+    constructor(localUserHome, remoteAgentService, environmentService, contextService) {
+        this.localUserHome = localUserHome;
+        this.remoteAgentService = remoteAgentService;
+        this.environmentService = environmentService;
+        this.contextService = contextService;
+        this.resolveOS = (async () => {
+            const env = await this.remoteAgentService.getEnvironment();
+            return env?.os || OS;
+        })();
+        this.resolveUserHome = (async () => {
+            const env = await this.remoteAgentService.getEnvironment();
+            const userHome = this.maybeUnresolvedUserHome = env?.userHome ?? localUserHome;
+            return userHome;
+        })();
+    }
+    hasValidBasename(resource, arg2, basename) {
+        if (typeof arg2 === 'string' || typeof arg2 === 'undefined') {
+            return this.resolveOS.then(os => this.doHasValidBasename(resource, os, arg2));
+        }
+        return this.doHasValidBasename(resource, arg2, basename);
+    }
+    doHasValidBasename(resource, os, name) {
+        if (resource.scheme === Schemas.file || resource.scheme === Schemas.vscodeRemote) {
+            return isValidBasename(name ?? basename(resource), os === 1 );
+        }
+        return true;
+    }
+    get defaultUriScheme() {
+        return AbstractPathService.findDefaultUriScheme(this.environmentService, this.contextService);
+    }
+    static findDefaultUriScheme(environmentService, contextService) {
+        if (environmentService.remoteAuthority) {
+            return Schemas.vscodeRemote;
+        }
+        const virtualWorkspace = getVirtualWorkspaceScheme(contextService.getWorkspace());
+        if (virtualWorkspace) {
+            return virtualWorkspace;
+        }
+        const firstFolder = contextService.getWorkspace().folders[0];
+        if (firstFolder) {
+            return firstFolder.uri.scheme;
+        }
+        const configuration = contextService.getWorkspace().configuration;
+        if (configuration) {
+            return configuration.scheme;
+        }
+        return Schemas.file;
+    }
+    userHome(options) {
+        return options?.preferLocal ? this.localUserHome : this.resolveUserHome;
+    }
+    get resolvedUserHome() {
+        return this.maybeUnresolvedUserHome;
+    }
+    get path() {
+        return this.resolveOS.then(os => {
+            return os === 1  ?
+                win32 :
+                posix;
+        });
+    }
+    async fileURI(_path) {
+        let authority = '';
+        const os = await this.resolveOS;
+        if (os === 1 ) {
+            _path = _path.replace(/\\/g, '/');
+        }
+        if (_path[0] === '/' && _path[1] === '/') {
+            const idx = _path.indexOf('/', 2);
+            if (idx === -1) {
+                authority = _path.substring(2);
+                _path = '/';
+            }
+            else {
+                authority = _path.substring(2, idx);
+                _path = _path.substring(idx) || '/';
+            }
+        }
+        return ( URI.from({
+            scheme: Schemas.file,
+            authority,
+            path: _path,
+            query: '',
+            fragment: ''
+        }));
+    }
+};
+AbstractPathService = ( __decorate([
+    ( __param(1, IRemoteAgentService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IWorkspaceContextService))
+], AbstractPathService));
+const IPaneCompositePartService = ( createDecorator('paneCompositePartService'));
+const IProductService = ( createDecorator('productService'));
 const productSchemaId = 'vscode://schemas/vscode-product';
-const ILanguageStatusService = ( (createDecorator('ILanguageStatusService')));
-const IHostService = ( (createDecorator('hostService')));
-const ISnippetsService = ( (createDecorator('snippetService')));
+const ILanguageStatusService = ( createDecorator('ILanguageStatusService'));
+const IHostService = ( createDecorator('hostService'));
+const ISnippetsService = ( createDecorator('snippetService'));
 let services;
 var Services;
-( (function(Services) {
+(function (Services) {
     Services.get = () => {
         return services ?? {};
     };
@@ -292,5 +925,5 @@ var Services;
         };
     }
     Services.install = install;
-})(Services || (Services = {})));
-export { ACTIVE_GROUP as A, ensureFileSystemProviderError as B, CancellationTokenSource as C, etag as D, FileOperationEvent as E, FileType as F, toFileOperationResult as G, ETAG_DISABLED as H, IFileService as I, hasFileAtomicReadCapability as J, hasFileFolderCopyCapability as K, hasFileCloneCapability as L, createFileSystemProviderError as M, NotModifiedSinceFileOperationError as N, FILES_ASSOCIATIONS_CONFIG as O, Services as S, FilePermission as a, IUriIdentityService as b, IEditorService as c, IPaneCompositePartService as d, ITextFileService as e, IEditorGroupsService as f, IWorkbenchEnvironmentService as g, IWorkingCopyFileService as h, IPathService as i, IProductService as j, ILanguageStatusService as k, IHostService as l, ISnippetsService as m, markAsFileSystemProviderError as n, FileSystemProviderErrorCode as o, productSchemaId as p, SIDE_GROUP as q, refineServiceDecorator as r, isPreferredGroup as s, FileSystemProviderError as t, FileChangesEvent as u, FileOperationError as v, hasOpenReadWriteCloseCapability as w, hasReadWriteCapability as x, hasFileReadStreamCapability as y, toFileSystemProviderErrorCode as z };
+})(Services || (Services = {}));
+export { ACTIVE_GROUP as A, hasReadWriteCapability as B, CancellationTokenSource as C, hasFileReadStreamCapability as D, toFileSystemProviderErrorCode as E, FileType as F, etag as G, FileOperationEvent as H, ITextFileService as I, toFileOperationResult as J, ETAG_DISABLED as K, hasFileAtomicReadCapability as L, hasFileFolderCopyCapability as M, NotModifiedSinceFileOperationError as N, hasFileCloneCapability as O, FILES_ASSOCIATIONS_CONFIG as P, Services as S, FilePermission as a, FileSystemProviderErrorCode as b, SIDE_GROUP as c, IFileService as d, IWorkbenchEnvironmentService as e, IUriIdentityService as f, IWorkingCopyFileService as g, IPathService as h, IEditorService as i, IEditorGroupsService as j, IPaneCompositePartService as k, IProductService as l, markAsFileSystemProviderError as m, ILanguageStatusService as n, IHostService as o, FileOperationError as p, productSchemaId as q, refineServiceDecorator as r, IRemoteAgentService as s, ISnippetsService as t, isPreferredGroup as u, FileSystemProviderError as v, ensureFileSystemProviderError as w, createFileSystemProviderError as x, FileChangesEvent as y, hasOpenReadWriteCloseCapability as z };