@codingame/monaco-vscode-api 1.83.7 → 1.83.9

package/vscode/src/vs/workbench/api/browser/mainThreadErrors.js

@@ -1,22 +0,0 @@
-import { __decorate } from '../../../../../../external/tslib/tslib.es6.js';
-import { ErrorNoTelemetry, onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { MainContext } from '../common/extHost.protocol.js';
-let MainThreadErrors = class MainThreadErrors {
-    dispose() {
-    }
-    $onUnexpectedError(err) {
-        if (err && err.$isError) {
-            const { name, message, stack } = err;
-            err = err.noTelemetry ? ( new ErrorNoTelemetry()) : ( new Error());
-            err.message = message;
-            err.name = name;
-            err.stack = stack;
-        }
-        onUnexpectedError(err);
-    }
-};
-MainThreadErrors = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadErrors)
-], MainThreadErrors);
-export { MainThreadErrors };

package/vscode/src/vs/workbench/api/browser/mainThreadExtensionService.js

@@ -1,315 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { areSameExtensions } from '../../../platform/extensionManagement/common/extensionManagementUtil.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { WebSocketRemoteConnection, ManagedRemoteConnection } from '../../../platform/remote/common/remoteAuthorityResolver.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { IExtensionsWorkbenchService } from '../../contrib/extensions/common/extensions.js';
-import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.js';
-import { IWorkbenchExtensionEnablementService } from '../../services/extensionManagement/common/extensionManagement.js';
-import { IExtensionService } from '../../services/extensions/common/extensions.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IHostService } from '../../services/host/browser/host.js';
-import { ITimerService } from '../../services/timer/browser/timerService.js';
-let MainThreadExtensionService = class MainThreadExtensionService {
-    constructor(extHostContext, _extensionService, _notificationService, _extensionsWorkbenchService, _hostService, _extensionEnablementService, _timerService, _commandService, _environmentService) {
-        this._extensionService = _extensionService;
-        this._notificationService = _notificationService;
-        this._extensionsWorkbenchService = _extensionsWorkbenchService;
-        this._hostService = _hostService;
-        this._extensionEnablementService = _extensionEnablementService;
-        this._timerService = _timerService;
-        this._commandService = _commandService;
-        this._environmentService = _environmentService;
-        this._extensionHostKind = extHostContext.extensionHostKind;
-        const internalExtHostContext = extHostContext;
-        this._internalExtensionService = internalExtHostContext.internalExtensionService;
-        internalExtHostContext._setExtensionHostProxy(( new ExtensionHostProxy(( extHostContext.getProxy(ExtHostContext.ExtHostExtensionService)))));
-        internalExtHostContext._setAllMainProxyIdentifiers(( ( Object.keys(MainContext)).map((key) => MainContext[key])));
-    }
-    dispose() {
-    }
-    $getExtension(extensionId) {
-        return this._extensionService.getExtension(extensionId);
-    }
-    $activateExtension(extensionId, reason) {
-        return this._internalExtensionService._activateById(extensionId, reason);
-    }
-    async $onWillActivateExtension(extensionId) {
-        this._internalExtensionService._onWillActivateExtension(extensionId);
-    }
-    $onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason) {
-        this._internalExtensionService._onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason);
-    }
-    $onExtensionRuntimeError(extensionId, data) {
-        const error = ( new Error());
-        error.name = data.name;
-        error.message = data.message;
-        error.stack = data.stack;
-        this._internalExtensionService._onExtensionRuntimeError(extensionId, error);
-        console.error(`[${extensionId.value}]${error.message}`);
-        console.error(error.stack);
-    }
-    async $onExtensionActivationError(extensionId, data, missingExtensionDependency) {
-        const error = ( new Error());
-        error.name = data.name;
-        error.message = data.message;
-        error.stack = data.stack;
-        this._internalExtensionService._onDidActivateExtensionError(extensionId, error);
-        if (missingExtensionDependency) {
-            const extension = await this._extensionService.getExtension(extensionId.value);
-            if (extension) {
-                const local = await this._extensionsWorkbenchService.queryLocal();
-                const installedDependency = local.find(i => areSameExtensions(i.identifier, { id: missingExtensionDependency.dependency }));
-                if (installedDependency?.local) {
-                    await this._handleMissingInstalledDependency(extension, installedDependency.local);
-                    return;
-                }
-                else {
-                    await this._handleMissingNotInstalledDependency(extension, missingExtensionDependency.dependency);
-                    return;
-                }
-            }
-        }
-        const isDev = !this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment;
-        if (isDev) {
-            this._notificationService.error(error);
-            return;
-        }
-        console.error(error.message);
-    }
-    async _handleMissingInstalledDependency(extension, missingInstalledDependency) {
-        const extName = extension.displayName || extension.name;
-        if (this._extensionEnablementService.isEnabled(missingInstalledDependency)) {
-            this._notificationService.notify({
-                severity: Severity.Error,
-                message: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadExtensionService',
-                    'reload window',
-                    "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
-                    extName,
-                    missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                )),
-                actions: {
-                    primary: [( new Action('reload', ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'reload',
-                        "Reload Window"
-                    )), '', true, () => this._hostService.reload()))]
-                }
-            });
-        }
-        else {
-            const enablementState = this._extensionEnablementService.getEnablementState(missingInstalledDependency);
-            if (enablementState === 4 ) {
-                this._notificationService.notify({
-                    severity: Severity.Error,
-                    message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'notSupportedInWorkspace',
-                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
-                        extName,
-                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
-                });
-            }
-            else if (enablementState === 0 ) {
-                this._notificationService.notify({
-                    severity: Severity.Error,
-                    message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'restrictedMode',
-                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
-                        extName,
-                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
-                    actions: {
-                        primary: [( new Action('manageWorkspaceTrust', ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadExtensionService',
-                            'manageWorkspaceTrust',
-                            "Manage Workspace Trust"
-                        )), '', true, () => this._commandService.executeCommand('workbench.trust.manage')))]
-                    }
-                });
-            }
-            else if (this._extensionEnablementService.canChangeEnablement(missingInstalledDependency)) {
-                this._notificationService.notify({
-                    severity: Severity.Error,
-                    message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'disabledDep',
-                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
-                        extName,
-                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
-                    actions: {
-                        primary: [( new Action('enable', ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadExtensionService',
-                            'enable dep',
-                            "Enable and Reload"
-                        )), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === 6  ? 8  : 9 )
-                                .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
-                    }
-                });
-            }
-            else {
-                this._notificationService.notify({
-                    severity: Severity.Error,
-                    message: ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'disabledDepNoAction',
-                        "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
-                        extName,
-                        missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
-                    )),
-                });
-            }
-        }
-    }
-    async _handleMissingNotInstalledDependency(extension, missingDependency) {
-        const extName = extension.displayName || extension.name;
-        let dependencyExtension = null;
-        try {
-            dependencyExtension = (await this._extensionsWorkbenchService.getExtensions([{ id: missingDependency }], CancellationToken.None))[0];
-        }
-        catch (err) {
-        }
-        if (dependencyExtension) {
-            this._notificationService.notify({
-                severity: Severity.Error,
-                message: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadExtensionService',
-                    'uninstalledDep',
-                    "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
-                    extName,
-                    dependencyExtension.displayName,
-                    dependencyExtension.publisherDisplayName
-                )),
-                actions: {
-                    primary: [( new Action('install', ( localizeWithPath(
-                        'vs/workbench/api/browser/mainThreadExtensionService',
-                        'install missing dep',
-                        "Install and Reload"
-                    )), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
-                            .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
-                }
-            });
-        }
-        else {
-            this._notificationService.error(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadExtensionService',
-                'unknownDep',
-                "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
-                extName,
-                missingDependency
-            )));
-        }
-    }
-    async $setPerformanceMarks(marks) {
-        if (this._extensionHostKind === 1 ) {
-            this._timerService.setPerformanceMarks('localExtHost', marks);
-        }
-        else if (this._extensionHostKind === 2 ) {
-            this._timerService.setPerformanceMarks('workerExtHost', marks);
-        }
-        else {
-            this._timerService.setPerformanceMarks('remoteExtHost', marks);
-        }
-    }
-    async $asBrowserUri(uri) {
-        return FileAccess.uriToBrowserUri(URI.revive(uri));
-    }
-    async $getAllStaticBrowserUris() {
-        return Array.from(FileAccess.getRegisteredBrowserUris(), uri => [
-            uri,
-            FileAccess.uriToBrowserUri(uri)
-        ]);
-    }
-};
-MainThreadExtensionService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadExtensionService),
-    ( __param(1, IExtensionService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IExtensionsWorkbenchService)),
-    ( __param(4, IHostService)),
-    ( __param(5, IWorkbenchExtensionEnablementService)),
-    ( __param(6, ITimerService)),
-    ( __param(7, ICommandService)),
-    ( __param(8, IWorkbenchEnvironmentService))
-], MainThreadExtensionService);
-class ExtensionHostProxy {
-    constructor(_actual) {
-        this._actual = _actual;
-    }
-    async resolveAuthority(remoteAuthority, resolveAttempt) {
-        const resolved = reviveResolveAuthorityResult(await this._actual.$resolveAuthority(remoteAuthority, resolveAttempt));
-        return resolved;
-    }
-    async getCanonicalURI(remoteAuthority, uri) {
-        const uriComponents = await this._actual.$getCanonicalURI(remoteAuthority, uri);
-        return (uriComponents ? URI.revive(uriComponents) : uriComponents);
-    }
-    startExtensionHost(extensionsDelta) {
-        return this._actual.$startExtensionHost(extensionsDelta);
-    }
-    extensionTestsExecute() {
-        return this._actual.$extensionTestsExecute();
-    }
-    activateByEvent(activationEvent, activationKind) {
-        return this._actual.$activateByEvent(activationEvent, activationKind);
-    }
-    activate(extensionId, reason) {
-        return this._actual.$activate(extensionId, reason);
-    }
-    setRemoteEnvironment(env) {
-        return this._actual.$setRemoteEnvironment(env);
-    }
-    updateRemoteConnectionData(connectionData) {
-        return this._actual.$updateRemoteConnectionData(connectionData);
-    }
-    deltaExtensions(extensionsDelta) {
-        return this._actual.$deltaExtensions(extensionsDelta);
-    }
-    test_latency(n) {
-        return this._actual.$test_latency(n);
-    }
-    test_up(b) {
-        return this._actual.$test_up(b);
-    }
-    test_down(size) {
-        return this._actual.$test_down(size);
-    }
-}
-function reviveResolveAuthorityResult(result) {
-    if (result.type === 'ok') {
-        return {
-            type: 'ok',
-            value: {
-                ...result.value,
-                authority: reviveResolvedAuthority(result.value.authority),
-            }
-        };
-    }
-    else {
-        return result;
-    }
-}
-function reviveResolvedAuthority(resolvedAuthority) {
-    return {
-        ...resolvedAuthority,
-        connectTo: reviveConnection(resolvedAuthority.connectTo),
-    };
-}
-function reviveConnection(connection) {
-    if (connection.type === 0 ) {
-        return ( new WebSocketRemoteConnection(connection.host, connection.port));
-    }
-    return ( new ManagedRemoteConnection(connection.id));
-}
-export { MainThreadExtensionService };

package/vscode/src/vs/workbench/api/browser/mainThreadFileSystem.js

@@ -1,278 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { DisposableMap, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { FilePermission, FileSystemProviderErrorCode, FileOperationError, toFileSystemProviderErrorCode, FileType } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.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 { IWorkbenchFileService } from '../../services/files/common/files.js';
-import { normalizeWatcherPattern } from '../../../platform/files/common/watcher.js';
-import { GLOBSTAR } from 'monaco-editor/esm/vs/base/common/glob.js';
-import { rtrim } from 'monaco-editor/esm/vs/base/common/strings.js';
-var MainThreadFileSystem_1;
-let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
-    constructor(extHostContext, _fileService, _contextService, _logService, _configurationService) {
-        this._fileService = _fileService;
-        this._contextService = _contextService;
-        this._logService = _logService;
-        this._configurationService = _configurationService;
-        this._fileProvider = ( new DisposableMap());
-        this._disposables = ( new DisposableStore());
-        this._watches = ( new DisposableMap());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystem));
-        const infoProxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemInfo));
-        for (const entry of _fileService.listCapabilities()) {
-            infoProxy.$acceptProviderInfos(( URI.from({ scheme: entry.scheme, path: '/dummy' })), entry.capabilities);
-        }
-        this._disposables.add(_fileService.onDidChangeFileSystemProviderRegistrations(e => infoProxy.$acceptProviderInfos(( URI.from({ scheme: e.scheme, path: '/dummy' })), e.provider?.capabilities ?? null)));
-        this._disposables.add(_fileService.onDidChangeFileSystemProviderCapabilities(e => infoProxy.$acceptProviderInfos(( URI.from({ scheme: e.scheme, path: '/dummy' })), e.provider.capabilities)));
-    }
-    dispose() {
-        this._disposables.dispose();
-        this._fileProvider.dispose();
-        this._watches.dispose();
-    }
-    async $registerFileSystemProvider(handle, scheme, capabilities, readonlyMessage) {
-        this._fileProvider.set(handle, ( new RemoteFileSystemProvider(
-            this._fileService,
-            scheme,
-            capabilities,
-            readonlyMessage,
-            handle,
-            this._proxy
-        )));
-    }
-    $unregisterProvider(handle) {
-        this._fileProvider.deleteAndDispose(handle);
-    }
-    $onFileSystemChange(handle, changes) {
-        const fileProvider = this._fileProvider.get(handle);
-        if (!fileProvider) {
-            throw new Error('Unknown file provider');
-        }
-        fileProvider.$onFileSystemChange(changes);
-    }
-    $stat(uri) {
-        return this._fileService.stat(URI.revive(uri)).then(stat => {
-            return {
-                ctime: stat.ctime,
-                mtime: stat.mtime,
-                size: stat.size,
-                permissions: stat.readonly ? FilePermission.Readonly : undefined,
-                type: MainThreadFileSystem_1._asFileType(stat)
-            };
-        }).catch(MainThreadFileSystem_1._handleError);
-    }
-    $readdir(uri) {
-        return this._fileService.resolve(URI.revive(uri), { resolveMetadata: false }).then(stat => {
-            if (!stat.isDirectory) {
-                const err = ( new Error(stat.name));
-                err.name = FileSystemProviderErrorCode.FileNotADirectory;
-                throw err;
-            }
-            return !stat.children ? [] : ( stat.children.map(child => [child.name, MainThreadFileSystem_1._asFileType(child)]));
-        }).catch(MainThreadFileSystem_1._handleError);
-    }
-    static _asFileType(stat) {
-        let res = 0;
-        if (stat.isFile) {
-            res += FileType.File;
-        }
-        else if (stat.isDirectory) {
-            res += FileType.Directory;
-        }
-        if (stat.isSymbolicLink) {
-            res += FileType.SymbolicLink;
-        }
-        return res;
-    }
-    $readFile(uri) {
-        return this._fileService.readFile(URI.revive(uri)).then(file => file.value).catch(MainThreadFileSystem_1._handleError);
-    }
-    $writeFile(uri, content) {
-        return this._fileService.writeFile(URI.revive(uri), content)
-            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
-    }
-    $rename(source, target, opts) {
-        return this._fileService.move(URI.revive(source), URI.revive(target), opts.overwrite)
-            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
-    }
-    $copy(source, target, opts) {
-        return this._fileService.copy(URI.revive(source), URI.revive(target), opts.overwrite)
-            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
-    }
-    $mkdir(uri) {
-        return this._fileService.createFolder(URI.revive(uri))
-            .then(() => undefined).catch(MainThreadFileSystem_1._handleError);
-    }
-    $delete(uri, opts) {
-        return this._fileService.del(URI.revive(uri), opts).catch(MainThreadFileSystem_1._handleError);
-    }
-    static _handleError(err) {
-        if (err instanceof FileOperationError) {
-            switch (err.fileOperationResult) {
-                case 1 :
-                    err.name = FileSystemProviderErrorCode.FileNotFound;
-                    break;
-                case 0 :
-                    err.name = FileSystemProviderErrorCode.FileIsADirectory;
-                    break;
-                case 6 :
-                    err.name = FileSystemProviderErrorCode.NoPermissions;
-                    break;
-                case 4 :
-                    err.name = FileSystemProviderErrorCode.FileExists;
-                    break;
-            }
-        }
-        else if (err instanceof Error) {
-            const code = toFileSystemProviderErrorCode(err);
-            if (code !== FileSystemProviderErrorCode.Unknown) {
-                err.name = code;
-            }
-        }
-        throw err;
-    }
-    $ensureActivation(scheme) {
-        return this._fileService.activateProvider(scheme);
-    }
-    async $watch(extensionId, session, resource, unvalidatedOpts) {
-        const uri = URI.revive(resource);
-        const workspaceFolder = this._contextService.getWorkspaceFolder(uri);
-        const opts = { ...unvalidatedOpts };
-        if (opts.recursive) {
-            try {
-                const stat = await this._fileService.stat(uri);
-                if (!stat.isDirectory) {
-                    opts.recursive = false;
-                }
-            }
-            catch (error) {
-                this._logService.error(`MainThreadFileSystem#$watch(): failed to stat a resource for file watching (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session}): ${error}`);
-            }
-        }
-        if (workspaceFolder && opts.recursive) {
-            this._logService.trace(`MainThreadFileSystem#$watch(): ignoring request to start watching because path is inside workspace (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
-            return;
-        }
-        this._logService.trace(`MainThreadFileSystem#$watch(): request to start watching (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
-        if (opts.recursive) {
-            const config = this._configurationService.getValue();
-            if (config.files?.watcherExclude) {
-                for (const key in config.files.watcherExclude) {
-                    if (config.files.watcherExclude[key] === true) {
-                        opts.excludes.push(key);
-                    }
-                }
-            }
-        }
-        else if (workspaceFolder) {
-            const config = this._configurationService.getValue();
-            if (config.files?.watcherExclude) {
-                for (const key in config.files.watcherExclude) {
-                    if (config.files.watcherExclude[key] === true) {
-                        if (!opts.includes) {
-                            opts.includes = [];
-                        }
-                        const includePattern = `${rtrim(key, '/')}/${GLOBSTAR}`;
-                        opts.includes.push(normalizeWatcherPattern(workspaceFolder.uri.fsPath, includePattern));
-                    }
-                }
-            }
-            if (!opts.includes || opts.includes.length === 0) {
-                this._logService.trace(`MainThreadFileSystem#$watch(): ignoring request to start watching because path is inside workspace and no excludes are configured (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
-                return;
-            }
-        }
-        const subscription = this._fileService.watch(uri, opts);
-        this._watches.set(session, subscription);
-    }
-    $unwatch(session) {
-        if (( this._watches.has(session))) {
-            this._logService.trace(`MainThreadFileSystem#$unwatch(): request to stop watching (session: ${session})`);
-            this._watches.deleteAndDispose(session);
-        }
-    }
-};
-MainThreadFileSystem = MainThreadFileSystem_1 = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadFileSystem),
-    ( __param(1, IWorkbenchFileService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IConfigurationService))
-], MainThreadFileSystem);
-class RemoteFileSystemProvider {
-    constructor(fileService, scheme, capabilities, readOnlyMessage, _handle, _proxy) {
-        this.readOnlyMessage = readOnlyMessage;
-        this._handle = _handle;
-        this._proxy = _proxy;
-        this._onDidChange = ( new Emitter());
-        this.onDidChangeFile = this._onDidChange.event;
-        this.onDidChangeCapabilities = Event.None;
-        this.capabilities = capabilities;
-        this._registration = fileService.registerProvider(scheme, this);
-    }
-    dispose() {
-        this._registration.dispose();
-        this._onDidChange.dispose();
-    }
-    watch(resource, opts) {
-        const session = Math.random();
-        this._proxy.$watch(this._handle, session, resource, opts);
-        return toDisposable(() => {
-            this._proxy.$unwatch(this._handle, session);
-        });
-    }
-    $onFileSystemChange(changes) {
-        this._onDidChange.fire(( changes.map(RemoteFileSystemProvider._createFileChange)));
-    }
-    static _createFileChange(dto) {
-        return { resource: URI.revive(dto.resource), type: dto.type };
-    }
-    stat(resource) {
-        return this._proxy.$stat(this._handle, resource).then(undefined, err => {
-            throw err;
-        });
-    }
-    readFile(resource) {
-        return this._proxy.$readFile(this._handle, resource).then(buffer => buffer.buffer);
-    }
-    writeFile(resource, content, opts) {
-        return this._proxy.$writeFile(this._handle, resource, VSBuffer.wrap(content), opts);
-    }
-    delete(resource, opts) {
-        return this._proxy.$delete(this._handle, resource, opts);
-    }
-    mkdir(resource) {
-        return this._proxy.$mkdir(this._handle, resource);
-    }
-    readdir(resource) {
-        return this._proxy.$readdir(this._handle, resource);
-    }
-    rename(resource, target, opts) {
-        return this._proxy.$rename(this._handle, resource, target, opts);
-    }
-    copy(resource, target, opts) {
-        return this._proxy.$copy(this._handle, resource, target, opts);
-    }
-    open(resource, opts) {
-        return this._proxy.$open(this._handle, resource, opts);
-    }
-    close(fd) {
-        return this._proxy.$close(this._handle, fd);
-    }
-    read(fd, pos, data, offset, length) {
-        return this._proxy.$read(this._handle, fd, pos, length).then(readData => {
-            data.set(readData.buffer, offset);
-            return readData.byteLength;
-        });
-    }
-    write(fd, pos, data, offset, length) {
-        return this._proxy.$write(this._handle, fd, pos, VSBuffer.wrap(data).slice(offset, offset + length));
-    }
-}
-export { MainThreadFileSystem };