@theia/filesystem 1.77.0-next.1 → 1.77.0-next.108

package/lib/browser/file-service.js

@@ -1,4 +1,3 @@
-"use strict";
 // *****************************************************************************
 // Copyright (C) 2020 TypeFox and others.
 //
@@ -23,38 +22,36 @@
 // and https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/workbench/services/textfile/electron-browser/nativeTextFileService.ts
 // and https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/workbench/services/workingCopy/common/workingCopyFileService.ts
 // and https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/workbench/services/workingCopy/common/workingCopyFileOperationParticipant.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileService = exports.TextFileOperationError = exports.FileServiceContribution = void 0;
-const tslib_1 = require("tslib");
+import { __decorate } from "tslib";
 /* eslint-disable max-len */
+/* eslint-disable @stylistic/brace-style, @stylistic/semi-spacing */
 /* eslint-disable @typescript-eslint/no-shadow */
 /* eslint-disable no-null/no-null */
-/* eslint-disable @typescript-eslint/tslint/config */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-const inversify_1 = require("@theia/core/shared/inversify");
-const promise_util_1 = require("@theia/core/lib/common/promise-util");
-const cancellation_1 = require("@theia/core/lib/common/cancellation");
-const disposable_1 = require("@theia/core/lib/common/disposable");
-const event_1 = require("@theia/core/lib/common/event");
-const contribution_provider_1 = require("@theia/core/lib/common/contribution-provider");
-const ternary_search_tree_1 = require("@theia/core/lib/common/ternary-search-tree");
-const files_1 = require("../common/files");
-const buffer_1 = require("@theia/core/lib/common/buffer");
-const stream_1 = require("@theia/core/lib/common/stream");
-const label_provider_1 = require("@theia/core/lib/browser/label-provider");
-const filesystem_preferences_1 = require("../common/filesystem-preferences");
-const progress_service_1 = require("@theia/core/lib/common/progress-service");
-const delegating_file_system_provider_1 = require("../common/delegating-file-system-provider");
-const encoding_registry_1 = require("@theia/core/lib/browser/encoding-registry");
-const encodings_1 = require("@theia/core/lib/common/encodings");
-const encoding_service_1 = require("@theia/core/lib/common/encoding-service");
-const minimatch_1 = require("minimatch");
-const io_1 = require("../common/io");
-const filesystem_watcher_error_handler_1 = require("./filesystem-watcher-error-handler");
-const filesystem_utils_1 = require("../common/filesystem-utils");
-const core_1 = require("@theia/core");
-exports.FileServiceContribution = Symbol('FileServiceContribution');
-class TextFileOperationError extends files_1.FileOperationError {
+import { injectable, inject, named, postConstruct } from '@theia/core/shared/inversify';
+import { timeout, Deferred } from '@theia/core/lib/common/promise-util';
+import { CancellationToken, CancellationTokenSource } from '@theia/core/lib/common/cancellation';
+import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
+import { WaitUntilEvent, Emitter, AsyncEmitter } from '@theia/core/lib/common/event';
+import { ContributionProvider } from '@theia/core/lib/common/contribution-provider';
+import { TernarySearchTree } from '@theia/core/lib/common/ternary-search-tree';
+import { ensureFileSystemProviderError, etag, ETAG_DISABLED, FileChangesEvent, FileOperationError, FileOperationEvent, FileSystemProviderErrorCode, FileType, hasFileFolderCopyCapability, hasOpenReadWriteCloseCapability, hasReadWriteCapability, FileStat, toFileOperationResult, toFileSystemProviderErrorCode, hasAccessCapability, hasUpdateCapability, hasFileReadStreamCapability, ReadOnlyMessageFileSystemProvider } from '../common/files.js';
+import { BinaryBuffer, BinaryBufferReadable, BinaryBufferReadableStream, BinaryBufferReadableBufferedStream, BinaryBufferWriteableStream } from '@theia/core/lib/common/buffer';
+import { isReadableStream, isReadableBufferedStream, transform, consumeStream, peekStream, peekReadable } from '@theia/core/lib/common/stream';
+import { LabelProvider } from '@theia/core/lib/browser/label-provider';
+import { FileSystemPreferences } from '../common/filesystem-preferences.js';
+import { ProgressService } from '@theia/core/lib/common/progress-service';
+import { DelegatingFileSystemProvider } from '../common/delegating-file-system-provider.js';
+import { EncodingRegistry } from '@theia/core/lib/browser/encoding-registry';
+import { UTF8, UTF8_with_bom } from '@theia/core/lib/common/encodings';
+import { EncodingService } from '@theia/core/lib/common/encoding-service';
+import { Minimatch } from 'minimatch';
+import { readFileIntoStream } from '../common/io.js';
+import { FileSystemWatcherErrorHandler } from './filesystem-watcher-error-handler.js';
+import { FileSystemUtils } from '../common/filesystem-utils.js';
+import { nls, ILogger } from '@theia/core';
+export const FileServiceContribution = Symbol('FileServiceContribution');
+export class TextFileOperationError extends FileOperationError {
     constructor(message, textFileOperationResult, options) {
         super(message, 11 /* FileOperationResult.FILE_OTHER_ERROR */);
         this.textFileOperationResult = textFileOperationResult;
@@ -62,7 +59,6 @@ class TextFileOperationError extends files_1.FileOperationError {
         Object.setPrototypeOf(this, TextFileOperationError.prototype);
     }
 }
-exports.TextFileOperationError = TextFileOperationError;
 /**
  * The {@link FileService} is the common facade responsible for all interactions with file systems.
  * It manages all registered {@link FileSystemProvider}s and
@@ -74,19 +70,19 @@ let FileService = class FileService {
         this.BUFFER_SIZE = 64 * 1024;
         // #region Events
         this.correlationIds = 0;
-        this.onWillRunUserOperationEmitter = new event_1.AsyncEmitter();
+        this.onWillRunUserOperationEmitter = new AsyncEmitter();
         /**
          * An event that is emitted when file operation is being performed.
          * This event is triggered by user gestures.
          */
         this.onWillRunUserOperation = this.onWillRunUserOperationEmitter.event;
-        this.onDidFailUserOperationEmitter = new event_1.AsyncEmitter();
+        this.onDidFailUserOperationEmitter = new AsyncEmitter();
         /**
          * An event that is emitted when file operation is failed.
          * This event is triggered by user gestures.
          */
         this.onDidFailUserOperation = this.onDidFailUserOperationEmitter.event;
-        this.onDidRunUserOperationEmitter = new event_1.AsyncEmitter();
+        this.onDidRunUserOperationEmitter = new AsyncEmitter();
         /**
          * An event that is emitted when file operation is finished.
          * This event is triggered by user gestures.
@@ -94,21 +90,21 @@ let FileService = class FileService {
         this.onDidRunUserOperation = this.onDidRunUserOperationEmitter.event;
         // #endregion
         // #region File System Provider
-        this.onDidChangeFileSystemProviderRegistrationsEmitter = new event_1.Emitter();
+        this.onDidChangeFileSystemProviderRegistrationsEmitter = new Emitter();
         this.onDidChangeFileSystemProviderRegistrations = this.onDidChangeFileSystemProviderRegistrationsEmitter.event;
-        this.onWillActivateFileSystemProviderEmitter = new event_1.Emitter();
+        this.onWillActivateFileSystemProviderEmitter = new Emitter();
         /**
          * See `FileServiceContribution.registerProviders`.
          */
         this.onWillActivateFileSystemProvider = this.onWillActivateFileSystemProviderEmitter.event;
-        this.onDidChangeFileSystemProviderCapabilitiesEmitter = new event_1.Emitter();
+        this.onDidChangeFileSystemProviderCapabilitiesEmitter = new Emitter();
         this.onDidChangeFileSystemProviderCapabilities = this.onDidChangeFileSystemProviderCapabilitiesEmitter.event;
-        this.onDidChangeFileSystemProviderReadOnlyMessageEmitter = new event_1.Emitter();
+        this.onDidChangeFileSystemProviderReadOnlyMessageEmitter = new Emitter();
         this.onDidChangeFileSystemProviderReadOnlyMessage = this.onDidChangeFileSystemProviderReadOnlyMessageEmitter.event;
         this.providers = new Map();
         this.activations = new Map();
         // #endregion
-        this.onDidRunOperationEmitter = new event_1.Emitter();
+        this.onDidRunOperationEmitter = new Emitter();
         /**
          * An event that is emitted when operation is finished.
          * This event is triggered by user gestures and programmatically.
@@ -116,7 +112,7 @@ let FileService = class FileService {
         this.onDidRunOperation = this.onDidRunOperationEmitter.event;
         // #endregion
         // #region File Watching
-        this.onDidFilesChangeEmitter = new event_1.Emitter();
+        this.onDidFilesChangeEmitter = new Emitter();
         this.activeWatchers = new Map();
         this.recursiveWatcherIndexes = new Map();
         // #endregion
@@ -144,14 +140,14 @@ let FileService = class FileService {
         }
         this.providers.set(scheme, provider);
         this.onDidChangeFileSystemProviderRegistrationsEmitter.fire({ added: true, scheme, provider });
-        const providerDisposables = new disposable_1.DisposableCollection();
-        providerDisposables.push(provider.onDidChangeFile(changes => this.onDidFilesChangeEmitter.fire(new files_1.FileChangesEvent(changes))));
+        const providerDisposables = new DisposableCollection();
+        providerDisposables.push(provider.onDidChangeFile(changes => this.onDidFilesChangeEmitter.fire(new FileChangesEvent(changes))));
         providerDisposables.push(provider.onFileWatchError(() => this.handleFileWatchError()));
         providerDisposables.push(provider.onDidChangeCapabilities(() => this.onDidChangeFileSystemProviderCapabilitiesEmitter.fire({ provider, scheme })));
-        if (files_1.ReadOnlyMessageFileSystemProvider.is(provider)) {
+        if (ReadOnlyMessageFileSystemProvider.is(provider)) {
             providerDisposables.push(provider.onDidChangeReadOnlyMessage(message => this.onDidChangeFileSystemProviderReadOnlyMessageEmitter.fire({ provider, scheme, message })));
         }
-        return disposable_1.Disposable.create(() => {
+        return Disposable.create(() => {
             this.onDidChangeFileSystemProviderRegistrationsEmitter.fire({ added: false, scheme, provider });
             this.providers.delete(scheme);
             this.recursiveWatcherIndexes.delete(provider);
@@ -171,9 +167,18 @@ let FileService = class FileService {
         }
         let activation = this.activations.get(scheme);
         if (!activation) {
-            const deferredActivation = new promise_util_1.Deferred();
+            const deferredActivation = new Deferred();
             this.activations.set(scheme, activation = deferredActivation.promise);
-            event_1.WaitUntilEvent.fire(this.onWillActivateFileSystemProviderEmitter, { scheme }).then(() => {
+            // Resolve the activation as soon as a provider is registered for the scheme. Otherwise a
+            // slow or dangling `onWillActivateFileSystemProvider` listener whose `waitUntil` promise
+            // never settles would wedge this activation (and everything awaiting it) forever. See #17506.
+            const registration = this.onDidChangeFileSystemProviderRegistrations(event => {
+                if (event.added && event.scheme === scheme && event.provider) {
+                    deferredActivation.resolve(event.provider);
+                }
+            });
+            deferredActivation.promise.then(() => registration.dispose(), () => registration.dispose());
+            WaitUntilEvent.fire(this.onWillActivateFileSystemProviderEmitter, { scheme }).then(() => {
                 provider = this.providers.get(scheme);
                 if (!provider) {
                     const error = new Error();
@@ -202,7 +207,7 @@ let FileService = class FileService {
     }
     getReadOnlyMessage(resource) {
         const provider = this.providers.get(resource.scheme);
-        if (files_1.ReadOnlyMessageFileSystemProvider.is(provider)) {
+        if (ReadOnlyMessageFileSystemProvider.is(provider)) {
             return provider.readOnlyMessage;
         }
         return undefined;
@@ -230,20 +235,20 @@ let FileService = class FileService {
     async withProvider(resource) {
         // Assert path is absolute
         if (!resource.path.isAbsolute) {
-            throw new files_1.FileOperationError(core_1.nls.localizeByDefault("Unable to resolve filesystem provider with relative file path '{0}'", this.resourceForError(resource)), 8 /* FileOperationResult.FILE_INVALID_PATH */);
+            throw new FileOperationError(nls.localizeByDefault("Unable to resolve filesystem provider with relative file path '{0}'", this.resourceForError(resource)), 8 /* FileOperationResult.FILE_INVALID_PATH */);
         }
         return this.activateProvider(resource.scheme);
     }
     async withReadProvider(resource) {
         const provider = await this.withProvider(resource);
-        if ((0, files_1.hasOpenReadWriteCloseCapability)(provider) || (0, files_1.hasReadWriteCapability)(provider)) {
+        if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider)) {
             return provider;
         }
         throw new Error(`Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite, FileReadStream nor FileOpenReadWriteClose capability which is needed for the read operation.`);
     }
     async withWriteProvider(resource) {
         const provider = await this.withProvider(resource);
-        if ((0, files_1.hasOpenReadWriteCloseCapability)(provider) || (0, files_1.hasReadWriteCapability)(provider)) {
+        if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider)) {
             return provider;
         }
         throw new Error(`Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite nor FileOpenReadWriteClose capability which is needed for the write operation.`);
@@ -254,11 +259,11 @@ let FileService = class FileService {
         }
         catch (error) {
             // Specially handle file not found case as file operation result
-            if ((0, files_1.toFileSystemProviderErrorCode)(error) === files_1.FileSystemProviderErrorCode.FileNotFound) {
-                throw new files_1.FileOperationError(core_1.nls.localizeByDefault("Unable to resolve nonexistent file '{0}'", this.resourceForError(resource)), 1 /* FileOperationResult.FILE_NOT_FOUND */);
+            if (toFileSystemProviderErrorCode(error) === FileSystemProviderErrorCode.FileNotFound) {
+                throw new FileOperationError(nls.localizeByDefault("Unable to resolve nonexistent file '{0}'", this.resourceForError(resource)), 1 /* FileOperationResult.FILE_NOT_FOUND */);
             }
             // Bubble up any other error as is
-            throw (0, files_1.ensureFileSystemProviderError)(error);
+            throw ensureFileSystemProviderError(error);
         }
     }
     async doResolveFile(resource, options) {
@@ -271,7 +276,7 @@ let FileService = class FileService {
         return this.toFileStat(provider, resource, stat, undefined, !!resolveMetadata, (stat, siblings) => {
             // lazy trie to check for recursive resolving
             if (!trie) {
-                trie = ternary_search_tree_1.TernarySearchTree.forUris(!!(provider.capabilities & 1024 /* FileSystemProviderCapabilities.PathCaseSensitive */));
+                trie = TernarySearchTree.forUris(!!(provider.capabilities & 1024 /* FileSystemProviderCapabilities.PathCaseSensitive */));
                 trie.set(resource, true);
                 if (Array.isArray(resolveTo) && resolveTo.length) {
                     resolveTo.forEach(uri => trie.set(uri, true));
@@ -289,7 +294,7 @@ let FileService = class FileService {
         });
     }
     async toFileStat(provider, resource, stat, siblings, resolveMetadata, recurse) {
-        const fileStat = files_1.FileStat.fromStat(resource, stat);
+        const fileStat = FileStat.fromStat(resource, stat);
         // check to recurse for directories
         if (fileStat.isDirectory && recurse(fileStat, siblings)) {
             try {
@@ -354,7 +359,7 @@ let FileService = class FileService {
      */
     async access(resource, mode) {
         const provider = await this.withProvider(resource);
-        if (!(0, files_1.hasAccessCapability)(provider)) {
+        if (!hasAccessCapability(provider)) {
             return false;
         }
         try {
@@ -380,7 +385,7 @@ let FileService = class FileService {
      */
     async fsPath(resource) {
         const provider = await this.withProvider(resource);
-        if (!(0, files_1.hasAccessCapability)(provider)) {
+        if (!hasAccessCapability(provider)) {
             return resource.path.toString();
         }
         return provider.fsPath(resource);
@@ -421,15 +426,15 @@ let FileService = class FileService {
         });
         return {
             ...bufferStream,
-            encoding: decoder.detected.encoding || encodings_1.UTF8,
-            value: await (0, stream_1.consumeStream)(decoder.stream, strings => strings.join(''))
+            encoding: decoder.detected.encoding || UTF8,
+            value: await consumeStream(decoder.stream, strings => strings.join(''))
         };
     }
     async readStream(resource, options) {
         const [bufferStream, decoder] = await this.doRead(resource, options);
         return {
             ...bufferStream,
-            encoding: decoder.detected.encoding || encodings_1.UTF8,
+            encoding: decoder.detected.encoding || UTF8,
             value: decoder.stream
         };
     }
@@ -441,7 +446,7 @@ let FileService = class FileService {
             const content = await this.readFile(resource, options);
             bufferStream = {
                 ...content,
-                value: buffer_1.BinaryBufferReadableStream.fromBuffer(content.value)
+                value: BinaryBufferReadableStream.fromBuffer(content.value)
             };
         }
         else {
@@ -453,7 +458,7 @@ let FileService = class FileService {
         });
         // validate binary
         if (options?.acceptTextOnly && decoder.detected.seemsBinary) {
-            throw new TextFileOperationError(core_1.nls.localizeByDefault('File seems to be binary and cannot be opened as text'), 0 /* TextFileOperationResult.FILE_IS_BINARY */, options);
+            throw new TextFileOperationError(nls.localizeByDefault('File seems to be binary and cannot be opened as text'), 0 /* TextFileOperationResult.FILE_IS_BINARY */, options);
         }
         return [bufferStream, decoder];
     }
@@ -472,7 +477,7 @@ let FileService = class FileService {
         const provider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(resource), resource);
         try {
             await this.validateWriteFile(provider, resource, options);
-            if ((0, files_1.hasUpdateCapability)(provider)) {
+            if (hasUpdateCapability(provider)) {
                 const encoding = await this.getEncodingForResource(resource, options ? options.encoding : undefined);
                 ;
                 const stat = await provider.updateFile(resource, changes, {
@@ -480,7 +485,7 @@ let FileService = class FileService {
                     writeEncoding: encoding,
                     overwriteEncoding: options.overwriteEncoding || false
                 });
-                return Object.assign(files_1.FileStat.fromStat(resource, stat), { encoding: stat.encoding });
+                return Object.assign(FileStat.fromStat(resource, stat), { encoding: stat.encoding });
             }
             else {
                 throw new Error('incremental file update is not supported');
@@ -492,15 +497,15 @@ let FileService = class FileService {
     }
     // #endregion
     // #region File Reading/Writing
-    async createFile(resource, bufferOrReadableOrStream = buffer_1.BinaryBuffer.fromString(''), options) {
+    async createFile(resource, bufferOrReadableOrStream = BinaryBuffer.fromString(''), options) {
         // validate overwrite
         if (!options?.overwrite && await this.exists(resource)) {
-            throw new files_1.FileOperationError(core_1.nls.localizeByDefault("Unable to create file '{0}' that already exists when overwrite flag is not set", this.resourceForError(resource)), 3 /* FileOperationResult.FILE_MODIFIED_SINCE */, options);
+            throw new FileOperationError(nls.localizeByDefault("Unable to create file '{0}' that already exists when overwrite flag is not set", this.resourceForError(resource)), 3 /* FileOperationResult.FILE_MODIFIED_SINCE */, options);
         }
         // do write into file (this will create it too)
         const fileStat = await this.writeFile(resource, bufferOrReadableOrStream);
         // events
-        this.onDidRunOperationEmitter.fire(new files_1.FileOperationEvent(resource, 0 /* FileOperation.CREATE */, fileStat));
+        this.onDidRunOperationEmitter.fire(new FileOperationEvent(resource, 0 /* FileOperation.CREATE */, fileStat));
         return fileStat;
     }
     async writeFile(resource, bufferOrReadableOrStream, options) {
@@ -517,30 +522,30 @@ let FileService = class FileService {
             // unbuffered to reduce the overhead. If the Readable has more data to provide
             // we continue to write buffered.
             let bufferOrReadableOrStreamOrBufferedStream;
-            if ((0, files_1.hasReadWriteCapability)(provider) && !(bufferOrReadableOrStream instanceof buffer_1.BinaryBuffer)) {
-                if ((0, stream_1.isReadableStream)(bufferOrReadableOrStream)) {
-                    const bufferedStream = await (0, stream_1.peekStream)(bufferOrReadableOrStream, 3);
+            if (hasReadWriteCapability(provider) && !(bufferOrReadableOrStream instanceof BinaryBuffer)) {
+                if (isReadableStream(bufferOrReadableOrStream)) {
+                    const bufferedStream = await peekStream(bufferOrReadableOrStream, 3);
                     if (bufferedStream.ended) {
-                        bufferOrReadableOrStreamOrBufferedStream = buffer_1.BinaryBuffer.concat(bufferedStream.buffer);
+                        bufferOrReadableOrStreamOrBufferedStream = BinaryBuffer.concat(bufferedStream.buffer);
                     }
                     else {
                         bufferOrReadableOrStreamOrBufferedStream = bufferedStream;
                     }
                 }
                 else {
-                    bufferOrReadableOrStreamOrBufferedStream = (0, stream_1.peekReadable)(bufferOrReadableOrStream, data => buffer_1.BinaryBuffer.concat(data), 3);
+                    bufferOrReadableOrStreamOrBufferedStream = peekReadable(bufferOrReadableOrStream, data => BinaryBuffer.concat(data), 3);
                 }
             }
             else {
                 bufferOrReadableOrStreamOrBufferedStream = bufferOrReadableOrStream;
             }
             // write file: unbuffered (only if data to write is a buffer, or the provider has no buffered write capability)
-            if (!(0, files_1.hasOpenReadWriteCloseCapability)(provider) || ((0, files_1.hasReadWriteCapability)(provider) && bufferOrReadableOrStreamOrBufferedStream instanceof buffer_1.BinaryBuffer)) {
+            if (!hasOpenReadWriteCloseCapability(provider) || (hasReadWriteCapability(provider) && bufferOrReadableOrStreamOrBufferedStream instanceof BinaryBuffer)) {
                 await this.doWriteUnbuffered(provider, resource, bufferOrReadableOrStreamOrBufferedStream);
             }
             // write file: buffered
             else {
-                await this.doWriteBuffered(provider, resource, bufferOrReadableOrStreamOrBufferedStream instanceof buffer_1.BinaryBuffer ? buffer_1.BinaryBufferReadable.fromBuffer(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream);
+                await this.doWriteBuffered(provider, resource, bufferOrReadableOrStreamOrBufferedStream instanceof BinaryBuffer ? BinaryBufferReadable.fromBuffer(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream);
             }
         }
         catch (error) {
@@ -557,11 +562,11 @@ let FileService = class FileService {
             return undefined; // file might not exist
         }
         // file cannot be directory
-        if ((stat.type & files_1.FileType.Directory) !== 0) {
-            throw new files_1.FileOperationError(core_1.nls.localizeByDefault("Unable to write file '{0}' that is actually a directory", this.resourceForError(resource)), 0 /* FileOperationResult.FILE_IS_DIRECTORY */, options);
+        if ((stat.type & FileType.Directory) !== 0) {
+            throw new FileOperationError(nls.localizeByDefault("Unable to write file '{0}' that is actually a directory", this.resourceForError(resource)), 0 /* FileOperationResult.FILE_IS_DIRECTORY */, options);
         }
         if (this.modifiedSince(stat, options)) {
-            throw new files_1.FileOperationError(core_1.nls.localizeByDefault('File Modified Since'), 3 /* FileOperationResult.FILE_MODIFIED_SINCE */, options);
+            throw new FileOperationError(nls.localizeByDefault('File Modified Since'), 3 /* FileOperationResult.FILE_MODIFIED_SINCE */, options);
         }
         return stat;
     }
@@ -580,9 +585,9 @@ let FileService = class FileService {
      * the file content for comparison which would be much slower to compute.
      */
     modifiedSince(stat, options) {
-        return !!options && typeof options.mtime === 'number' && typeof options.etag === 'string' && options.etag !== files_1.ETAG_DISABLED &&
+        return !!options && typeof options.mtime === 'number' && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED &&
             typeof stat.mtime === 'number' && typeof stat.size === 'number' &&
-            options.mtime < stat.mtime && options.etag !== (0, files_1.etag)({ mtime: options.mtime /* not using stat.mtime for a reason, see above */, size: stat.size });
+            options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime /* not using stat.mtime for a reason, see above */, size: stat.size });
     }
     shouldReadUnbuffered(options) {
         // optimization: since we know that the caller does not
@@ -604,7 +609,7 @@ let FileService = class FileService {
         });
         return {
             ...stream,
-            value: await buffer_1.BinaryBufferReadableStream.toBuffer(stream.value)
+            value: await BinaryBufferReadableStream.toBuffer(stream.value)
         };
     }
     async readFileStream(resource, options) {
@@ -616,7 +621,7 @@ let FileService = class FileService {
         // when any error occurs. this allows us to resolve
         // the content of the file while resolving metadata
         // but still cancel the operation in certain cases.
-        const cancellableSource = new cancellation_1.CancellationTokenSource();
+        const cancellableSource = new CancellationTokenSource();
         // validate read operation
         const statPromise = this.validateReadFile(resource, options).then(stat => stat, error => {
             cancellableSource.cancel();
@@ -627,16 +632,16 @@ let FileService = class FileService {
             // due to the likelyhood of hitting a NOT_MODIFIED_SINCE result.
             // otherwise, we let it run in parallel to the file reading for
             // optimal startup performance.
-            if (options && typeof options.etag === 'string' && options.etag !== files_1.ETAG_DISABLED) {
+            if (options && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED) {
                 await statPromise;
             }
             let fileStreamPromise;
             // read unbuffered (only if either preferred, or the provider has no buffered read capability)
-            if (!((0, files_1.hasOpenReadWriteCloseCapability)(provider) || (0, files_1.hasFileReadStreamCapability)(provider)) || ((0, files_1.hasReadWriteCapability)(provider) && options?.preferUnbuffered)) {
+            if (!(hasOpenReadWriteCloseCapability(provider) || hasFileReadStreamCapability(provider)) || (hasReadWriteCapability(provider) && options?.preferUnbuffered)) {
                 fileStreamPromise = this.readFileUnbuffered(provider, resource, options);
             }
             // read streamed (always prefer over primitive buffered read)
-            else if ((0, files_1.hasFileReadStreamCapability)(provider)) {
+            else if (hasFileReadStreamCapability(provider)) {
                 fileStreamPromise = Promise.resolve(this.readFileStreamed(provider, resource, cancellableSource.token, options));
             }
             // read buffered
@@ -655,14 +660,14 @@ let FileService = class FileService {
     }
     readFileStreamed(provider, resource, token, options = Object.create(null)) {
         const fileStream = provider.readFileStream(resource, options, token);
-        return (0, stream_1.transform)(fileStream, {
-            data: data => data instanceof buffer_1.BinaryBuffer ? data : buffer_1.BinaryBuffer.wrap(data),
+        return transform(fileStream, {
+            data: data => data instanceof BinaryBuffer ? data : BinaryBuffer.wrap(data),
             error: error => this.asFileOperationError("Unable to read file '{0}' ({1})", resource, error, options)
-        }, data => buffer_1.BinaryBuffer.concat(data));
+        }, data => BinaryBuffer.concat(data));
     }
     readFileBuffered(provider, resource, token, options = Object.create(null)) {
-        const stream = buffer_1.BinaryBufferWriteableStream.create();
-        (0, io_1.readFileIntoStream)(provider, resource, stream, data => data, {
+        const stream = BinaryBufferWriteableStream.create();
+        readFileIntoStream(provider, resource, stream, data => data, {
             ...options,
             bufferSize: this.BUFFER_SIZE,
             errorTransformer: error => this.asFileOperationError("Unable to read file '{0}' ({1})", resource, error, options)
@@ -673,7 +678,7 @@ let FileService = class FileService {
         throw this.asFileOperationError(message, resource, error, options);
     }
     asFileOperationError(message, resource, error, options) {
-        const fileOperationError = new files_1.FileOperationError(core_1.nls.localizeByDefault(message, this.resourceForError(resource), (0, files_1.ensureFileSystemProviderError)(error).toString()), (0, files_1.toFileOperationResult)(error), options);
+        const fileOperationError = new FileOperationError(nls.localizeByDefault(message, this.resourceForError(resource), ensureFileSystemProviderError(error).toString()), toFileOperationResult(error), options);
         fileOperationError.stack = `${fileOperationError.stack}\nCaused by: ${error.stack}`;
         return fileOperationError;
     }
@@ -689,17 +694,17 @@ let FileService = class FileService {
         }
         // Throw if file is too large to load
         this.validateReadFileLimits(resource, buffer.byteLength, options);
-        return buffer_1.BinaryBufferReadableStream.fromBuffer(buffer_1.BinaryBuffer.wrap(buffer));
+        return BinaryBufferReadableStream.fromBuffer(BinaryBuffer.wrap(buffer));
     }
     async validateReadFile(resource, options) {
         const stat = await this.resolve(resource, { resolveMetadata: true });
         // Throw if resource is a directory
         if (stat.isDirectory) {
-            throw new files_1.FileOperationError(core_1.nls.localizeByDefault("Unable to read file '{0}' that is actually a directory", this.resourceForError(resource)), 0 /* FileOperationResult.FILE_IS_DIRECTORY */, options);
+            throw new FileOperationError(nls.localizeByDefault("Unable to read file '{0}' that is actually a directory", this.resourceForError(resource)), 0 /* FileOperationResult.FILE_IS_DIRECTORY */, options);
         }
         // Throw if file not modified since (unless disabled)
-        if (options && typeof options.etag === 'string' && options.etag !== files_1.ETAG_DISABLED && options.etag === stat.etag) {
-            throw new files_1.FileOperationError(core_1.nls.localizeByDefault('File not modified since'), 2 /* FileOperationResult.FILE_NOT_MODIFIED_SINCE */, options);
+        if (options && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED && options.etag === stat.etag) {
+            throw new FileOperationError(nls.localizeByDefault('File not modified since'), 2 /* FileOperationResult.FILE_NOT_MODIFIED_SINCE */, options);
         }
         // Throw if file is too large to load
         this.validateReadFileLimits(resource, stat.size, options);
@@ -715,7 +720,7 @@ let FileService = class FileService {
                 tooLargeErrorResult = 7 /* FileOperationResult.FILE_TOO_LARGE */;
             }
             if (typeof tooLargeErrorResult === 'number') {
-                throw new files_1.FileOperationError(core_1.nls.localizeByDefault("Unable to read file '{0}' that is too large to open", this.resourceForError(resource)), tooLargeErrorResult);
+                throw new FileOperationError(nls.localizeByDefault("Unable to read file '{0}' that is too large to open", this.resourceForError(resource)), tooLargeErrorResult);
             }
         }
     }
@@ -746,7 +751,7 @@ let FileService = class FileService {
         const mode = await this.doMoveCopy(sourceProvider, source, targetProvider, target, 'move', !!overwrite);
         // resolve and send events
         const fileStat = await this.resolve(target, { resolveMetadata: true });
-        this.onDidRunOperationEmitter.fire(new files_1.FileOperationEvent(source, mode === 'move' ? 2 /* FileOperation.MOVE */ : 3 /* FileOperation.COPY */, fileStat));
+        this.onDidRunOperationEmitter.fire(new FileOperationEvent(source, mode === 'move' ? 2 /* FileOperation.MOVE */ : 3 /* FileOperation.COPY */, fileStat));
         return fileStat;
     }
     async copy(source, target, options) {
@@ -774,7 +779,7 @@ let FileService = class FileService {
         const mode = await this.doMoveCopy(sourceProvider, source, targetProvider, target, 'copy', !!overwrite);
         // resolve and send events
         const fileStat = await this.resolve(target, { resolveMetadata: true });
-        this.onDidRunOperationEmitter.fire(new files_1.FileOperationEvent(source, mode === 'copy' ? 3 /* FileOperation.COPY */ : 2 /* FileOperation.MOVE */, fileStat));
+        this.onDidRunOperationEmitter.fire(new FileOperationEvent(source, mode === 'copy' ? 3 /* FileOperation.COPY */ : 2 /* FileOperation.MOVE */, fileStat));
         return fileStat;
     }
     async doMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite) {
@@ -787,7 +792,7 @@ let FileService = class FileService {
         if (exists && !overwrite) {
             const parent = await this.resolve(target.parent);
             const targetFileStat = await this.resolve(target);
-            target = filesystem_utils_1.FileSystemUtils.generateUniqueResourceURI(parent, target, targetFileStat.isDirectory, isSameResourceWithDifferentPathCase ? 'copy' : undefined);
+            target = FileSystemUtils.generateUniqueResourceURI(parent, target, targetFileStat.isDirectory, isSameResourceWithDifferentPathCase ? 'copy' : undefined);
         }
         // delete as needed (unless target is same resource with different path case)
         if (exists && !isSameResourceWithDifferentPathCase && overwrite) {
@@ -798,7 +803,7 @@ let FileService = class FileService {
         // copy source => target
         if (mode === 'copy') {
             // same provider with fast copy: leverage copy() functionality
-            if (sourceProvider === targetProvider && (0, files_1.hasFileFolderCopyCapability)(sourceProvider)) {
+            if (sourceProvider === targetProvider && hasFileFolderCopyCapability(sourceProvider)) {
                 await sourceProvider.copy(source, target, { overwrite });
             }
             // when copying via buffer/unbuffered, we have to manually
@@ -831,19 +836,19 @@ let FileService = class FileService {
     }
     async doCopyFile(sourceProvider, source, targetProvider, target) {
         // copy: source (buffered) => target (buffered)
-        if ((0, files_1.hasOpenReadWriteCloseCapability)(sourceProvider) && (0, files_1.hasOpenReadWriteCloseCapability)(targetProvider)) {
+        if (hasOpenReadWriteCloseCapability(sourceProvider) && hasOpenReadWriteCloseCapability(targetProvider)) {
             return this.doPipeBuffered(sourceProvider, source, targetProvider, target);
         }
         // copy: source (buffered) => target (unbuffered)
-        if ((0, files_1.hasOpenReadWriteCloseCapability)(sourceProvider) && (0, files_1.hasReadWriteCapability)(targetProvider)) {
+        if (hasOpenReadWriteCloseCapability(sourceProvider) && hasReadWriteCapability(targetProvider)) {
             return this.doPipeBufferedToUnbuffered(sourceProvider, source, targetProvider, target);
         }
         // copy: source (unbuffered) => target (buffered)
-        if ((0, files_1.hasReadWriteCapability)(sourceProvider) && (0, files_1.hasOpenReadWriteCloseCapability)(targetProvider)) {
+        if (hasReadWriteCapability(sourceProvider) && hasOpenReadWriteCloseCapability(targetProvider)) {
             return this.doPipeUnbufferedToBuffered(sourceProvider, source, targetProvider, target);
         }
         // copy: source (unbuffered) => target (unbuffered)
-        if ((0, files_1.hasReadWriteCapability)(sourceProvider) && (0, files_1.hasReadWriteCapability)(targetProvider)) {
+        if (hasReadWriteCapability(sourceProvider) && hasReadWriteCapability(targetProvider)) {
             return this.doPipeUnbuffered(sourceProvider, source, targetProvider, target);
         }
     }
@@ -872,10 +877,10 @@ let FileService = class FileService {
                 isSameResourceWithDifferentPathCase = source.toString().toLowerCase() === target.toString().toLowerCase();
             }
             if (isSameResourceWithDifferentPathCase && mode === 'copy') {
-                throw new Error(core_1.nls.localizeByDefault("Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
+                throw new Error(nls.localizeByDefault("Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
             }
-            if (!isSameResourceWithDifferentPathCase && target.isEqualOrParent(source, isPathCaseSensitive)) {
-                throw new Error(core_1.nls.localizeByDefault("Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
+            if (!isSameResourceWithDifferentPathCase && source.isEqualOrParent(target, isPathCaseSensitive)) {
+                throw new Error(nls.localizeByDefault("Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
             }
         }
         // Extra checks if target exists and this is not a rename
@@ -885,8 +890,8 @@ let FileService = class FileService {
             // it as it would delete the source as well. In this case we have to throw
             if (sourceProvider === targetProvider) {
                 const isPathCaseSensitive = !!(sourceProvider.capabilities & 1024 /* FileSystemProviderCapabilities.PathCaseSensitive */);
-                if (source.isEqualOrParent(target, isPathCaseSensitive)) {
-                    throw new Error(core_1.nls.localizeByDefault("Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.", this.resourceForError(source), this.resourceForError(target)));
+                if (target.isEqualOrParent(source, isPathCaseSensitive)) {
+                    throw new Error(nls.localizeByDefault("Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.", this.resourceForError(source), this.resourceForError(target)));
                 }
             }
         }
@@ -903,7 +908,7 @@ let FileService = class FileService {
             this.onDidRunUserOperationEmitter.fire({ correlationId: this.correlationIds++, operation: 0 /* FileOperation.CREATE */, target: resource });
         }
         else {
-            this.onDidRunOperationEmitter.fire(new files_1.FileOperationEvent(resource, 0 /* FileOperation.CREATE */, fileStat));
+            this.onDidRunOperationEmitter.fire(new FileOperationEvent(resource, 0 /* FileOperation.CREATE */, fileStat));
         }
         return fileStat;
     }
@@ -913,14 +918,14 @@ let FileService = class FileService {
         while (!directory.path.isRoot) {
             try {
                 const stat = await provider.stat(directory);
-                if ((stat.type & files_1.FileType.Directory) === 0) {
-                    throw new Error(core_1.nls.localizeByDefault("Unable to create folder '{0}' that already exists but is not a directory", this.resourceForError(directory)));
+                if ((stat.type & FileType.Directory) === 0) {
+                    throw new Error(nls.localizeByDefault("Unable to create folder '{0}' that already exists but is not a directory", this.resourceForError(directory)));
                 }
                 break; // we have hit a directory that exists -> good
             }
             catch (error) {
                 // Bubble up any other error that is not file not found
-                if ((0, files_1.toFileSystemProviderErrorCode)(error) !== files_1.FileSystemProviderErrorCode.FileNotFound) {
+                if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileNotFound) {
                     throw error;
                 }
                 // Upon error, remember directories that need to be created
@@ -936,7 +941,7 @@ let FileService = class FileService {
                 await provider.mkdir(directory);
             }
             catch (error) {
-                if ((0, files_1.toFileSystemProviderErrorCode)(error) !== files_1.FileSystemProviderErrorCode.FileExists) {
+                if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileExists) {
                     // For mkdirp() we tolerate that the mkdir() call fails
                     // in case the folder already exists. This follows node.js
                     // own implementation of fs.mkdir({ recursive: true }) and
@@ -971,25 +976,25 @@ let FileService = class FileService {
         // Validate trash support
         const useTrash = !!options?.useTrash;
         if (useTrash && !(provider.capabilities & 4096 /* FileSystemProviderCapabilities.Trash */)) {
-            throw new Error(core_1.nls.localizeByDefault("Unable to delete file '{0}' via trash because provider does not support it.", this.resourceForError(resource)));
+            throw new Error(nls.localizeByDefault("Unable to delete file '{0}' via trash because provider does not support it.", this.resourceForError(resource)));
         }
         // Validate delete
         const exists = await this.exists(resource);
         if (!exists) {
-            throw new files_1.FileOperationError(core_1.nls.localizeByDefault("Unable to delete nonexistent file '{0}'", this.resourceForError(resource)), 1 /* FileOperationResult.FILE_NOT_FOUND */);
+            throw new FileOperationError(nls.localizeByDefault("Unable to delete nonexistent file '{0}'", this.resourceForError(resource)), 1 /* FileOperationResult.FILE_NOT_FOUND */);
         }
         // Validate recursive
         const recursive = !!options?.recursive;
         if (!recursive && exists) {
             const stat = await this.resolve(resource);
             if (stat.isDirectory && Array.isArray(stat.children) && stat.children.length > 0) {
-                throw new Error(core_1.nls.localizeByDefault("Unable to delete non-empty folder '{0}'.", this.resourceForError(resource)));
+                throw new Error(nls.localizeByDefault("Unable to delete non-empty folder '{0}'.", this.resourceForError(resource)));
             }
         }
         // Delete through provider
         await provider.delete(resource, { recursive, useTrash });
         // Events
-        this.onDidRunOperationEmitter.fire(new files_1.FileOperationEvent(resource, 1 /* FileOperation.DELETE */));
+        this.onDidRunOperationEmitter.fire(new FileOperationEvent(resource, 1 /* FileOperation.DELETE */));
     }
     /**
      * An event that is emitted when files are changed on the disk.
@@ -1003,7 +1008,7 @@ let FileService = class FileService {
             excludes: this.resolveWatcherExcludes(resource, options.excludes)
         };
         let watchDisposed = false;
-        let watchDisposable = disposable_1.Disposable.create(() => watchDisposed = true);
+        let watchDisposable = Disposable.create(() => watchDisposed = true);
         // Watch and wire in disposable which is async but
         // check if we got disposed meanwhile and forward
         this.doWatch(resource, resolvedOptions).then(disposable => {
@@ -1014,7 +1019,7 @@ let FileService = class FileService {
                 watchDisposable = disposable;
             }
         }, error => this.logger.error(error));
-        return disposable_1.Disposable.create(() => watchDisposable.dispose());
+        return Disposable.create(() => watchDisposable.dispose());
     }
     /**
      * Resolve the effective exclude globs for a watcher: the caller-supplied `excludes`, the
@@ -1079,7 +1084,7 @@ let FileService = class FileService {
                 realWatcher,
                 subsumingParent: undefined,
                 subsumedChildren: new Set(),
-                compiledExcludes: options.excludes.map(pattern => new minimatch_1.Minimatch(pattern, { dot: true })),
+                compiledExcludes: options.excludes.map(pattern => new Minimatch(pattern, { dot: true })),
             };
             return recursiveEntry;
         }
@@ -1091,7 +1096,7 @@ let FileService = class FileService {
         };
     }
     createWatcherDisposable(key, entry) {
-        return disposable_1.Disposable.create(() => {
+        return Disposable.create(() => {
             entry.count--;
             if (entry.count === 0) {
                 this.disposeWatcherEntry(key, entry);
@@ -1283,7 +1288,7 @@ let FileService = class FileService {
         let tree = this.recursiveWatcherIndexes.get(provider);
         if (!tree) {
             const caseSensitive = !!(provider.capabilities & 1024 /* FileSystemProviderCapabilities.PathCaseSensitive */);
-            tree = ternary_search_tree_1.TernarySearchTree.forUris(caseSensitive);
+            tree = TernarySearchTree.forUris(caseSensitive);
             this.recursiveWatcherIndexes.set(provider, tree);
         }
         return tree;
@@ -1325,7 +1330,7 @@ let FileService = class FileService {
             const handle = await provider.open(resource, { create: true });
             // write into handle until all bytes from buffer have been written
             try {
-                if ((0, stream_1.isReadableStream)(readableOrStreamOrBufferedStream) || (0, stream_1.isReadableBufferedStream)(readableOrStreamOrBufferedStream)) {
+                if (isReadableStream(readableOrStreamOrBufferedStream) || isReadableBufferedStream(readableOrStreamOrBufferedStream)) {
                     await this.doWriteStreamBufferedQueued(provider, handle, readableOrStreamOrBufferedStream);
                 }
                 else {
@@ -1333,7 +1338,7 @@ let FileService = class FileService {
                 }
             }
             catch (error) {
-                throw (0, files_1.ensureFileSystemProviderError)(error);
+                throw ensureFileSystemProviderError(error);
             }
             finally {
                 // close handle always
@@ -1346,9 +1351,9 @@ let FileService = class FileService {
         let stream;
         // Buffered stream: consume the buffer first by writing
         // it to the target before reading from the stream.
-        if ((0, stream_1.isReadableBufferedStream)(streamOrBufferedStream)) {
+        if (isReadableBufferedStream(streamOrBufferedStream)) {
             if (streamOrBufferedStream.buffer.length > 0) {
-                const chunk = buffer_1.BinaryBuffer.concat(streamOrBufferedStream.buffer);
+                const chunk = BinaryBuffer.concat(streamOrBufferedStream.buffer);
                 await this.doWriteBuffer(provider, handle, chunk, chunk.byteLength, posInFile, 0);
                 posInFile += chunk.byteLength;
             }
@@ -1403,17 +1408,17 @@ let FileService = class FileService {
     }
     async doWriteUnbufferedQueued(provider, resource, bufferOrReadableOrStreamOrBufferedStream) {
         let buffer;
-        if (bufferOrReadableOrStreamOrBufferedStream instanceof buffer_1.BinaryBuffer) {
+        if (bufferOrReadableOrStreamOrBufferedStream instanceof BinaryBuffer) {
             buffer = bufferOrReadableOrStreamOrBufferedStream;
         }
-        else if ((0, stream_1.isReadableStream)(bufferOrReadableOrStreamOrBufferedStream)) {
-            buffer = await buffer_1.BinaryBufferReadableStream.toBuffer(bufferOrReadableOrStreamOrBufferedStream);
+        else if (isReadableStream(bufferOrReadableOrStreamOrBufferedStream)) {
+            buffer = await BinaryBufferReadableStream.toBuffer(bufferOrReadableOrStreamOrBufferedStream);
         }
-        else if ((0, stream_1.isReadableBufferedStream)(bufferOrReadableOrStreamOrBufferedStream)) {
-            buffer = await buffer_1.BinaryBufferReadableBufferedStream.toBuffer(bufferOrReadableOrStreamOrBufferedStream);
+        else if (isReadableBufferedStream(bufferOrReadableOrStreamOrBufferedStream)) {
+            buffer = await BinaryBufferReadableBufferedStream.toBuffer(bufferOrReadableOrStreamOrBufferedStream);
         }
         else {
-            buffer = buffer_1.BinaryBufferReadable.toBuffer(bufferOrReadableOrStreamOrBufferedStream);
+            buffer = BinaryBufferReadable.toBuffer(bufferOrReadableOrStreamOrBufferedStream);
         }
         return provider.writeFile(resource, buffer.buffer, { create: true, overwrite: true });
     }
@@ -1427,7 +1432,7 @@ let FileService = class FileService {
             // Open handles
             sourceHandle = await sourceProvider.open(source, { create: false });
             targetHandle = await targetProvider.open(target, { create: true });
-            const buffer = buffer_1.BinaryBuffer.alloc(this.BUFFER_SIZE);
+            const buffer = BinaryBuffer.alloc(this.BUFFER_SIZE);
             let posInFile = 0;
             let posInBuffer = 0;
             let bytesRead = 0;
@@ -1447,7 +1452,7 @@ let FileService = class FileService {
             } while (bytesRead > 0);
         }
         catch (error) {
-            throw (0, files_1.ensureFileSystemProviderError)(error);
+            throw ensureFileSystemProviderError(error);
         }
         finally {
             await Promise.all([
@@ -1471,10 +1476,10 @@ let FileService = class FileService {
         // Read entire buffer from source and write buffered
         try {
             const buffer = await sourceProvider.readFile(source);
-            await this.doWriteBuffer(targetProvider, targetHandle, buffer_1.BinaryBuffer.wrap(buffer), buffer.byteLength, 0, 0);
+            await this.doWriteBuffer(targetProvider, targetHandle, BinaryBuffer.wrap(buffer), buffer.byteLength, 0, 0);
         }
         catch (error) {
-            throw (0, files_1.ensureFileSystemProviderError)(error);
+            throw ensureFileSystemProviderError(error);
         }
         finally {
             await targetProvider.close(targetHandle);
@@ -1482,13 +1487,13 @@ let FileService = class FileService {
     }
     async doPipeBufferedToUnbuffered(sourceProvider, source, targetProvider, target) {
         // Read buffer via stream buffered
-        const buffer = await buffer_1.BinaryBufferReadableStream.toBuffer(this.readFileBuffered(sourceProvider, source, cancellation_1.CancellationToken.None));
+        const buffer = await BinaryBufferReadableStream.toBuffer(this.readFileBuffered(sourceProvider, source, CancellationToken.None));
         // Write buffer into target at once
         await this.doWriteUnbuffered(targetProvider, target, buffer);
     }
     throwIfFileSystemIsReadonly(provider, resource) {
         if (provider.capabilities & 2048 /* FileSystemProviderCapabilities.Readonly */) {
-            throw new files_1.FileOperationError(core_1.nls.localizeByDefault("Unable to modify read-only file '{0}'", this.resourceForError(resource)), 6 /* FileOperationResult.FILE_PERMISSION_DENIED */);
+            throw new FileOperationError(nls.localizeByDefault("Unable to modify read-only file '{0}'", this.resourceForError(resource)), 6 /* FileOperationResult.FILE_PERMISSION_DENIED */);
         }
         return provider;
     }
@@ -1497,7 +1502,7 @@ let FileService = class FileService {
     }
     addFileOperationParticipant(participant) {
         this.participants.push(participant);
-        return disposable_1.Disposable.create(() => {
+        return Disposable.create(() => {
             const index = this.participants.indexOf(participant);
             if (index > -1) {
                 this.participants.splice(index, 1);
@@ -1509,7 +1514,7 @@ let FileService = class FileService {
         if (participantsTimeout <= 0 || this.participants.length === 0) {
             return;
         }
-        const cancellationTokenSource = new cancellation_1.CancellationTokenSource();
+        const cancellationTokenSource = new CancellationTokenSource();
         return this.progressService.withProgress(this.progressLabel(operation), 'notification', async () => {
             for (const participant of this.participants) {
                 if (cancellationTokenSource.token.isCancellationRequested) {
@@ -1519,7 +1524,7 @@ let FileService = class FileService {
                     const promise = participant.participate(target, source, operation, participantsTimeout, cancellationTokenSource.token);
                     await Promise.race([
                         promise,
-                        (0, promise_util_1.timeout)(participantsTimeout, cancellationTokenSource.token).then(() => cancellationTokenSource.dispose(), () => { })
+                        timeout(participantsTimeout, cancellationTokenSource.token).then(() => cancellationTokenSource.dispose(), () => { })
                     ]);
                 }
                 catch (err) {
@@ -1533,13 +1538,13 @@ let FileService = class FileService {
     progressLabel(operation) {
         switch (operation) {
             case 0 /* FileOperation.CREATE */:
-                return core_1.nls.localizeByDefault("Running 'File Create' participants...");
+                return nls.localizeByDefault("Running 'File Create' participants...");
             case 2 /* FileOperation.MOVE */:
-                return core_1.nls.localizeByDefault("Running 'File Rename' participants...");
+                return nls.localizeByDefault("Running 'File Rename' participants...");
             case 3 /* FileOperation.COPY */:
-                return core_1.nls.localizeByDefault("Running 'File Copy' participants...");
+                return nls.localizeByDefault("Running 'File Copy' participants...");
             case 1 /* FileOperation.DELETE */:
-                return core_1.nls.localizeByDefault("Running 'File Delete' participants...");
+                return nls.localizeByDefault("Running 'File Delete' participants...");
         }
     }
     // #endregion
@@ -1549,7 +1554,7 @@ let FileService = class FileService {
         return this.encodingService.toResourceEncoding(encoding, {
             overwriteEncoding: options?.overwriteEncoding,
             read: async (length) => {
-                const buffer = await buffer_1.BinaryBufferReadableStream.toBuffer((await this.readFileStream(resource, { length })).value);
+                const buffer = await BinaryBufferReadableStream.toBuffer((await this.readFileStream(resource, { length })).value);
                 return buffer.buffer;
             }
         });
@@ -1558,8 +1563,8 @@ let FileService = class FileService {
         let preferredEncoding;
         // Encoding passed in as option
         if (options?.encoding) {
-            if (detectedEncoding === encodings_1.UTF8_with_bom && options.encoding === encodings_1.UTF8) {
-                preferredEncoding = encodings_1.UTF8_with_bom; // indicate the file has BOM if we are to resolve with UTF 8
+            if (detectedEncoding === UTF8_with_bom && options.encoding === UTF8) {
+                preferredEncoding = UTF8_with_bom; // indicate the file has BOM if we are to resolve with UTF 8
             }
             else {
                 preferredEncoding = options.encoding; // give passed in encoding highest priority
@@ -1568,6 +1573,9 @@ let FileService = class FileService {
         else if (detectedEncoding) {
             preferredEncoding = detectedEncoding;
         }
+        else if (this.preferences.get('files.encoding', undefined, resource.toString()) === UTF8_with_bom) {
+            preferredEncoding = UTF8; // if we did not detect UTF 8 BOM before, this can only be UTF 8 then
+        }
         return this.getEncodingForResource(resource, preferredEncoding);
     }
     async getEncodingForResource(resource, preferredEncoding) {
@@ -1582,7 +1590,7 @@ let FileService = class FileService {
      */
     async toUnderlyingResource(resource) {
         let provider = await this.withProvider(resource);
-        while (provider instanceof delegating_file_system_provider_1.DelegatingFileSystemProvider) {
+        while (provider instanceof DelegatingFileSystemProvider) {
             resource = provider.toUnderlyingResource(resource);
             provider = await this.withProvider(resource);
         }
@@ -1593,48 +1601,37 @@ let FileService = class FileService {
         this.watcherErrorHandler.handleError();
     }
 };
-exports.FileService = FileService;
-tslib_1.__decorate([
-    (0, inversify_1.inject)(label_provider_1.LabelProvider),
-    tslib_1.__metadata("design:type", label_provider_1.LabelProvider)
+__decorate([
+    inject(LabelProvider)
 ], FileService.prototype, "labelProvider", void 0);
-tslib_1.__decorate([
-    (0, inversify_1.inject)(filesystem_preferences_1.FileSystemPreferences),
-    tslib_1.__metadata("design:type", Object)
+__decorate([
+    inject(FileSystemPreferences)
 ], FileService.prototype, "preferences", void 0);
-tslib_1.__decorate([
-    (0, inversify_1.inject)(progress_service_1.ProgressService),
-    tslib_1.__metadata("design:type", progress_service_1.ProgressService)
+__decorate([
+    inject(ProgressService)
 ], FileService.prototype, "progressService", void 0);
-tslib_1.__decorate([
-    (0, inversify_1.inject)(encoding_registry_1.EncodingRegistry),
-    tslib_1.__metadata("design:type", encoding_registry_1.EncodingRegistry)
+__decorate([
+    inject(EncodingRegistry)
 ], FileService.prototype, "encodingRegistry", void 0);
-tslib_1.__decorate([
-    (0, inversify_1.inject)(encoding_service_1.EncodingService),
-    tslib_1.__metadata("design:type", encoding_service_1.EncodingService)
+__decorate([
+    inject(EncodingService)
 ], FileService.prototype, "encodingService", void 0);
-tslib_1.__decorate([
-    (0, inversify_1.inject)(contribution_provider_1.ContributionProvider),
-    (0, inversify_1.named)(exports.FileServiceContribution),
-    tslib_1.__metadata("design:type", Object)
+__decorate([
+    inject(ContributionProvider),
+    named(FileServiceContribution)
 ], FileService.prototype, "contributions", void 0);
-tslib_1.__decorate([
-    (0, inversify_1.inject)(filesystem_watcher_error_handler_1.FileSystemWatcherErrorHandler),
-    tslib_1.__metadata("design:type", filesystem_watcher_error_handler_1.FileSystemWatcherErrorHandler)
+__decorate([
+    inject(FileSystemWatcherErrorHandler)
 ], FileService.prototype, "watcherErrorHandler", void 0);
-tslib_1.__decorate([
-    (0, inversify_1.inject)(core_1.ILogger),
-    (0, inversify_1.named)('filesystem:FileService'),
-    tslib_1.__metadata("design:type", Object)
+__decorate([
+    inject(ILogger),
+    named('filesystem:FileService')
 ], FileService.prototype, "logger", void 0);
-tslib_1.__decorate([
-    (0, inversify_1.postConstruct)(),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", void 0)
+__decorate([
+    postConstruct()
 ], FileService.prototype, "init", null);
-exports.FileService = FileService = tslib_1.__decorate([
-    (0, inversify_1.injectable)()
+FileService = __decorate([
+    injectable()
 ], FileService);
+export { FileService };
 //# sourceMappingURL=file-service.js.map