@codingame/monaco-vscode-api 1.67.7 → 1.67.9

package/dist/services-ac6b4b50.js

@@ -0,0 +1,747 @@
+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 { 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 { 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/base/common/severity.js';
+function readonly(name) {
+    return name
+        ?  new Error(`readonly property '${name} cannot be changed'`)
+        :  new Error('readonly property cannot be changed');
+}
+function disposed(what) {
+    const result =  new Error(`${what} has been disposed`);
+    result.name = 'DISPOSED';
+    return result;
+}
+class ErrorNoTelemetry extends Error {
+    constructor() {
+        super(...arguments);
+        this.logTelemetry = false;
+    }
+}
+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;
+    }
+    dispose() {
+        if (!this._disposed) {
+            this._disposed = true;
+            if (this._listeners) {
+                this._listeners.clear();
+            }
+            this._deliveryQueue?.clear();
+            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(() => {
+                    if (removeMonitor) {
+                        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 LinkedList();
+            }
+            for (let listener of this._listeners) {
+                this._deliveryQueue.push([listener, event]);
+            }
+            this._perfMon?.start(this._deliveryQueue.size);
+            while (this._deliveryQueue.size > 0) {
+                const [listener, event] = this._deliveryQueue.shift();
+                try {
+                    listener.invoke(event);
+                }
+                catch (e) {
+                    onUnexpectedError(e);
+                }
+            }
+            this._perfMon?.stop();
+        }
+    }
+    hasListeners() {
+        if (!this._listeners) {
+            return false;
+        }
+        return (!this._listeners.isEmpty());
+    }
+}
+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 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;
+}
+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); }
+}
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+function coalesceInPlace(array) {
+    let to = 0;
+    for (let i = 0; i < array.length; i++) {
+        if (!!array[i]) {
+            array[to] = array[i];
+            to += 1;
+        }
+    }
+    array.length = to;
+}
+function insert(array, element) {
+    array.push(element);
+    return () => remove(array, element);
+}
+function remove(array, element) {
+    const index = array.indexOf(element);
+    if (index > -1) {
+        array.splice(index, 1);
+        return element;
+    }
+    return undefined;
+}
+const IFileService =  createDecorator('fileService');
+var 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 = {}));
+var FilePermission;
+ (function(FilePermission) {
+    FilePermission[FilePermission["Readonly"] = 1] = "Readonly";
+})(FilePermission || (FilePermission = {}));
+var FileSystemProviderErrorCode;
+ (function(FileSystemProviderErrorCode) {
+    FileSystemProviderErrorCode["FileExists"] = "EntryExists";
+    FileSystemProviderErrorCode["FileNotFound"] = "EntryNotFound";
+    FileSystemProviderErrorCode["FileNotADirectory"] = "EntryNotADirectory";
+    FileSystemProviderErrorCode["FileIsADirectory"] = "EntryIsADirectory";
+    FileSystemProviderErrorCode["FileExceedsMemoryLimit"] = "EntryExceedsMemoryLimit";
+    FileSystemProviderErrorCode["FileTooLarge"] = "EntryTooLarge";
+    FileSystemProviderErrorCode["FileWriteLocked"] = "EntryWriteLocked";
+    FileSystemProviderErrorCode["NoPermissions"] = "NoPermissions";
+    FileSystemProviderErrorCode["Unavailable"] = "Unavailable";
+    FileSystemProviderErrorCode["Unknown"] = "Unknown";
+})(FileSystemProviderErrorCode || (FileSystemProviderErrorCode = {}));
+function markAsFileSystemProviderError(error, code) {
+    error.name = code ? `${code} (FileSystemError)` : `FileSystemError`;
+    return error;
+}
+class FileOperationError extends ErrorNoTelemetry {
+    constructor(message, fileOperationResult, options) {
+        super(message);
+        this.fileOperationResult = fileOperationResult;
+        this.options = options;
+    }
+}
+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 ACTIVE_GROUP = -1;
+const SIDE_GROUP = -2;
+function isPreferredGroup(obj) {
+    const candidate = obj;
+    return typeof obj === 'number' || isEditorGroup(candidate);
+}
+const IProgressService =  createDecorator('progressService');
+const ITextFileService =  createDecorator('textFileService');
+const IWorkbenchEnvironmentService = refineServiceDecorator(IEnvironmentService);
+const IWorkingCopyService =  createDecorator('workingCopyService');
+const IUriIdentityService =  createDecorator('IUriIdentityService');
+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;
+    }
+    async 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 ILanguageStatusService =  createDecorator('ILanguageStatusService');
+const IHostService =  createDecorator('hostService');
+let services;
+var Services;
+(function (Services) {
+    Services.get = () => {
+        if (services == null) {
+            throw new Error('Services has not been installed');
+        }
+        return services;
+    };
+    function install(_services) {
+        if (services != null) {
+            console.warn('Services have been overridden');
+        }
+        services = _services;
+        return {
+            dispose: () => {
+                if (services === _services) {
+                    services = undefined;
+                }
+            }
+        };
+    }
+    Services.install = install;
+})(Services || (Services = {}));
+export { ACTIVE_GROUP as A, CancellationTokenSource as C, FileSystemProviderErrorCode as F, IProgressService as I, SIDE_GROUP as S, __classPrivateFieldSet as _, __classPrivateFieldGet as a, __decorate as b, coalesceInPlace as c, __param as d, ITextFileService as e, IFileService as f, IWorkbenchEnvironmentService as g, IUriIdentityService as h, IWorkingCopyFileService as i, IPathService as j, disposed as k, IEditorService as l, markAsFileSystemProviderError as m, IEditorGroupsService as n, IPaneCompositePartService as o, IProductService as p, ILanguageStatusService as q, readonly as r, IHostService as s, Services as t, FileType as u, FilePermission as v, refineServiceDecorator as w, isPreferredGroup as x };