@theia/filesystem 1.77.0-next.99 → 1.77.0

package/lib/node/disk-file-system-provider.js

@@ -1,4 +1,3 @@
-"use strict";
 // *****************************************************************************
 // Copyright (C) 2020 TypeFox and others.
 //
@@ -19,45 +18,44 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 // based on https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/platform/files/node/diskFileSystemProvider.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiskFileSystemProvider = void 0;
-const tslib_1 = require("tslib");
+import { __decorate } from "tslib";
 /* eslint-disable no-null/no-null */
 /* eslint-disable @typescript-eslint/no-shadow */
-const inversify_1 = require("@theia/core/shared/inversify");
-const core_1 = require("@theia/core");
-const path_1 = require("path");
-const uuid_1 = require("@theia/core/lib/common/uuid");
-const os = tslib_1.__importStar(require("os"));
-const fs = tslib_1.__importStar(require("fs"));
-const fs_1 = require("fs");
-const util_1 = require("util");
-const uri_1 = tslib_1.__importDefault(require("@theia/core/lib/common/uri"));
-const path_2 = require("@theia/core/lib/common/path");
-const file_uri_1 = require("@theia/core/lib/common/file-uri");
-const event_1 = require("@theia/core/lib/common/event");
-const disposable_1 = require("@theia/core/lib/common/disposable");
-const os_1 = require("@theia/core/lib/common/os");
-const promise_util_1 = require("@theia/core/lib/common/promise-util");
-const files_1 = require("../common/files");
-const filesystem_watcher_protocol_1 = require("../common/filesystem-watcher-protocol");
-const trash = require("trash");
-const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
-const encoding_service_1 = require("@theia/core/lib/common/encoding-service");
-const buffer_1 = require("@theia/core/lib/common/buffer");
-const stream_1 = require("@theia/core/lib/common/stream");
-const io_1 = require("../common/io");
-const stat_mode_1 = require("stat-mode");
+import { injectable, inject, postConstruct, named } from '@theia/core/shared/inversify';
+import { ILogger } from '@theia/core';
+import { basename, dirname, normalize, join } from 'path';
+import { generateUuid } from '@theia/core/lib/common/uuid';
+import * as os from 'os';
+import * as fs from 'fs';
+import { mkdir, open, close, read, write, fdatasync, lstat, stat, readdir, readFile, exists, chmod, rmdir, unlink, rename, futimes, truncate } from 'fs';
+import { promisify } from 'util';
+import URI from '@theia/core/lib/common/uri';
+import { Path } from '@theia/core/lib/common/path';
+import { FileUri } from '@theia/core/lib/common/file-uri';
+import { Event, Emitter } from '@theia/core/lib/common/event';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import { OS, isWindows } from '@theia/core/lib/common/os';
+import { retry } from '@theia/core/lib/common/promise-util';
+import { FileType, createFileSystemProviderError, FileSystemProviderErrorCode, FileSystemProviderError, FilePermission } from '../common/files.js';
+import { FileSystemWatcherServer } from '../common/filesystem-watcher-protocol.js';
+import trash from 'trash';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { EncodingService } from '@theia/core/lib/common/encoding-service';
+import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { newWriteableStream } from '@theia/core/lib/common/stream';
+import { readFileIntoStream } from '../common/io.js';
+// A CommonJS module whose exports cannot be detected statically, so it is imported as a whole.
+import statMode from 'stat-mode';
 let DiskFileSystemProvider = class DiskFileSystemProvider {
     constructor() {
         this.BUFFER_SIZE = 64 * 1024;
-        this.onDidChangeFileEmitter = new event_1.Emitter();
+        this.onDidChangeFileEmitter = new Emitter();
         this.onDidChangeFile = this.onDidChangeFileEmitter.event;
-        this.onFileWatchErrorEmitter = new event_1.Emitter();
+        this.onFileWatchErrorEmitter = new Emitter();
         this.onFileWatchError = this.onFileWatchErrorEmitter.event;
-        this.toDispose = new disposable_1.DisposableCollection(this.onDidChangeFileEmitter);
+        this.toDispose = new DisposableCollection(this.onDidChangeFileEmitter);
         // #region File Capabilities
-        this.onDidChangeCapabilities = event_1.Event.None;
+        this.onDidChangeCapabilities = Event.None;
         this.mapHandleToPos = new Map();
         this.writeHandles = new Set();
         this.canFlush = true;
@@ -66,7 +64,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
         this.toDispose.push(this.watcher);
         this.watcher.setClient({
             onDidFilesChanged: params => this.onDidChangeFileEmitter.fire(params.changes.map(({ uri, type }) => ({
-                resource: new uri_1.default(uri),
+                resource: new URI(uri),
                 type
             }))),
             onError: () => this.onFileWatchErrorEmitter.fire()
@@ -82,7 +80,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
                     16777216 /* FileSystemProviderCapabilities.Access */ |
                     4096 /* FileSystemProviderCapabilities.Trash */ |
                     33554432 /* FileSystemProviderCapabilities.Update */;
-            if (os_1.OS.type() === os_1.OS.Type.Linux) {
+            if (OS.type() === OS.Type.Linux) {
                 this._capabilities |= 1024 /* FileSystemProviderCapabilities.PathCaseSensitive */;
             }
         }
@@ -93,13 +91,13 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
     async stat(resource) {
         try {
             const { stat, symbolicLink } = await this.statLink(this.toFilePath(resource)); // cannot use fs.stat() here to support links properly
-            const mode = new stat_mode_1.Mode(stat);
+            const mode = new statMode.Mode(stat);
             return {
                 type: this.toType(stat, symbolicLink),
                 ctime: stat.birthtime.getTime(), // intentionally not using ctime here, we want the creation time
                 mtime: stat.mtime.getTime(),
                 size: stat.size,
-                permissions: !mode.owner.write ? files_1.FilePermission.Readonly : undefined,
+                permissions: !mode.owner.write ? FilePermission.Readonly : undefined,
             };
         }
         catch (error) {
@@ -108,20 +106,20 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
     }
     async access(resource, mode) {
         try {
-            await (0, util_1.promisify)(fs.access)(this.toFilePath(resource), mode);
+            await promisify(fs.access)(this.toFilePath(resource), mode);
         }
         catch (error) {
             throw this.toFileSystemProviderError(error);
         }
     }
     async fsPath(resource) {
-        return file_uri_1.FileUri.fsPath(resource);
+        return FileUri.fsPath(resource);
     }
     async statLink(path) {
         // First stat the link
         let lstats;
         try {
-            lstats = await (0, util_1.promisify)(fs_1.lstat)(path);
+            lstats = await promisify(lstat)(path);
             // Return early if the stat is not a symbolic link at all
             if (!lstats.isSymbolicLink()) {
                 return { stat: lstats };
@@ -133,7 +131,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
         // If the stat is a symbolic link or failed to stat, use fs.stat()
         // which for symbolic links will stat the target they point to
         try {
-            const stats = await (0, util_1.promisify)(fs_1.stat)(path);
+            const stats = await promisify(stat)(path);
             return { stat: stats, symbolicLink: lstats?.isSymbolicLink() ? { dangling: false } : undefined };
         }
         catch (error) {
@@ -147,7 +145,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
     }
     async readdir(resource) {
         try {
-            const children = await (0, util_1.promisify)(fs.readdir)(this.toFilePath(resource));
+            const children = await promisify(fs.readdir)(this.toFilePath(resource));
             const result = [];
             await Promise.all(children.map(async (child) => {
                 try {
@@ -170,20 +168,20 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
         // - files that are neither file nor directory are FileType.Unknown
         let type;
         if (symbolicLink?.dangling) {
-            type = files_1.FileType.Unknown;
+            type = FileType.Unknown;
         }
         else if (entry.isFile()) {
-            type = files_1.FileType.File;
+            type = FileType.File;
         }
         else if (entry.isDirectory()) {
-            type = files_1.FileType.Directory;
+            type = FileType.Directory;
         }
         else {
-            type = files_1.FileType.Unknown;
+            type = FileType.Unknown;
         }
         // Always signal symbolic link as file type additionally
         if (symbolicLink) {
-            type |= files_1.FileType.SymbolicLink;
+            type |= FileType.SymbolicLink;
         }
         return type;
     }
@@ -192,15 +190,15 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
     async readFile(resource) {
         try {
             const filePath = this.toFilePath(resource);
-            return await (0, util_1.promisify)(fs_1.readFile)(filePath);
+            return await promisify(readFile)(filePath);
         }
         catch (error) {
             throw this.toFileSystemProviderError(error);
         }
     }
     readFileStream(resource, opts, token) {
-        const stream = (0, stream_1.newWriteableStream)(data => buffer_1.BinaryBuffer.concat(data.map(data => buffer_1.BinaryBuffer.wrap(data))).buffer);
-        (0, io_1.readFileIntoStream)(this, resource, stream, data => data.buffer, {
+        const stream = newWriteableStream(data => BinaryBuffer.concat(data.map(data => BinaryBuffer.wrap(data))).buffer);
+        readFileIntoStream(this, resource, stream, data => data.buffer, {
             ...opts,
             bufferSize: this.BUFFER_SIZE
         }, token);
@@ -212,14 +210,14 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
             const filePath = this.toFilePath(resource);
             // Validate target unless { create: true, overwrite: true }
             if (!opts.create || !opts.overwrite) {
-                const fileExists = await (0, util_1.promisify)(fs_1.exists)(filePath);
+                const fileExists = await promisify(exists)(filePath);
                 if (fileExists) {
                     if (!opts.overwrite) {
-                        throw (0, files_1.createFileSystemProviderError)('File already exists', files_1.FileSystemProviderErrorCode.FileExists);
+                        throw createFileSystemProviderError('File already exists', FileSystemProviderErrorCode.FileExists);
                     }
                 }
                 else if (!opts.create) {
-                    throw (0, files_1.createFileSystemProviderError)('File does not exist', files_1.FileSystemProviderErrorCode.FileNotFound);
+                    throw createFileSystemProviderError('File does not exist', FileSystemProviderErrorCode.FileNotFound);
                 }
             }
             // Open
@@ -241,13 +239,13 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
             const filePath = this.toFilePath(resource);
             let flags = undefined;
             if (opts.create) {
-                if (os_1.isWindows && await (0, util_1.promisify)(fs_1.exists)(filePath)) {
+                if (isWindows && await promisify(exists)(filePath)) {
                     try {
                         // On Windows and if the file exists, we use a different strategy of saving the file
                         // by first truncating the file and then writing with r+ flag. This helps to save hidden files on Windows
                         // (see https://github.com/Microsoft/vscode/issues/931) and prevent removing alternate data streams
                         // (see https://github.com/Microsoft/vscode/issues/6363)
-                        await (0, util_1.promisify)(fs_1.truncate)(filePath, 0);
+                        await promisify(truncate)(filePath, 0);
                         // After a successful truncate() the flag can be set to 'r+' which will not truncate.
                         flags = 'r+';
                     }
@@ -268,7 +266,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
                 // the file.
                 flags = 'r';
             }
-            const handle = await (0, util_1.promisify)(fs_1.open)(filePath, flags);
+            const handle = await promisify(open)(filePath, flags);
             // remember this handle to track file position of the handle
             // we init the position to 0 since the file descriptor was
             // just created and the position was not moved so far (see
@@ -293,7 +291,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
             // to flush the contents to disk if possible.
             if (this.writeHandles.delete(fd) && this.canFlush) {
                 try {
-                    await (0, util_1.promisify)(fs_1.fdatasync)(fd);
+                    await promisify(fdatasync)(fd);
                 }
                 catch (error) {
                     // In some exotic setups it is well possible that node fails to sync
@@ -302,7 +300,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
                     this.logger.error(error);
                 }
             }
-            return await (0, util_1.promisify)(fs_1.close)(fd);
+            return await promisify(close)(fd);
         }
         catch (error) {
             throw this.toFileSystemProviderError(error);
@@ -312,7 +310,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
         const normalizedPos = this.normalizePos(fd, pos);
         let bytesRead = null;
         try {
-            const result = await (0, util_1.promisify)(fs_1.read)(fd, data, offset, length, normalizedPos);
+            const result = await promisify(read)(fd, data, offset, length, normalizedPos);
             if (typeof result === 'number') {
                 bytesRead = result; // node.d.ts fail
             }
@@ -367,13 +365,13 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
         // we know at this point that the file to write to is truncated and thus empty
         // if the write now fails, the file remains empty. as such we really try hard
         // to ensure the write succeeds by retrying up to three times.
-        return (0, promise_util_1.retry)(() => this.doWrite(fd, pos, data, offset, length), 100 /* ms delay */, 3 /* retries */);
+        return retry(() => this.doWrite(fd, pos, data, offset, length), 100 /* ms delay */, 3 /* retries */);
     }
     async doWrite(fd, pos, data, offset, length) {
         const normalizedPos = this.normalizePos(fd, pos);
         let bytesWritten = null;
         try {
-            const result = await (0, util_1.promisify)(fs_1.write)(fd, data, offset, length, normalizedPos);
+            const result = await promisify(write)(fd, data, offset, length, normalizedPos);
             if (typeof result === 'number') {
                 bytesWritten = result; // node.d.ts fail
             }
@@ -393,7 +391,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
     // #region Move/Copy/Delete/Create Folder
     async mkdir(resource) {
         try {
-            await (0, util_1.promisify)(fs_1.mkdir)(this.toFilePath(resource));
+            await promisify(mkdir)(this.toFilePath(resource));
         }
         catch (error) {
             throw this.toFileSystemProviderError(error);
@@ -414,12 +412,12 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
                 await this.rimraf(filePath);
             }
             else {
-                const stat = await (0, util_1.promisify)(fs_1.lstat)(filePath);
+                const stat = await promisify(lstat)(filePath);
                 if (stat.isDirectory() && !stat.isSymbolicLink()) {
-                    await (0, util_1.promisify)(fs_1.rmdir)(filePath);
+                    await promisify(rmdir)(filePath);
                 }
                 else {
-                    await (0, util_1.promisify)(fs_1.unlink)(filePath);
+                    await promisify(unlink)(filePath);
                 }
             }
         }
@@ -428,16 +426,16 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
         }
     }
     rimraf(path) {
-        if (new path_2.Path(path).isRoot) {
+        if (new Path(path).isRoot) {
             throw new Error('rimraf - will refuse to recursively delete root');
         }
         return this.rimrafMove(path);
     }
     async rimrafMove(path) {
         try {
-            const pathInTemp = (0, path_1.join)(os.tmpdir(), (0, uuid_1.generateUuid)());
+            const pathInTemp = join(os.tmpdir(), generateUuid());
             try {
-                await (0, util_1.promisify)(fs_1.rename)(path, pathInTemp);
+                await promisify(rename)(path, pathInTemp);
             }
             catch (error) {
                 return this.rimrafUnlink(path); // if rename fails, delete without tmp dir
@@ -455,22 +453,22 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
     }
     async rimrafUnlink(path) {
         try {
-            const stat = await (0, util_1.promisify)(fs_1.lstat)(path);
+            const stat = await promisify(lstat)(path);
             // Folder delete (recursive) - NOT for symbolic links though!
             if (stat.isDirectory() && !stat.isSymbolicLink()) {
                 // Children
-                const children = await (0, util_1.promisify)(fs_1.readdir)(path);
-                await Promise.all(children.map(child => this.rimrafUnlink((0, path_1.join)(path, child))));
+                const children = await promisify(readdir)(path);
+                await Promise.all(children.map(child => this.rimrafUnlink(join(path, child))));
                 // Folder
-                await (0, util_1.promisify)(fs_1.rmdir)(path);
+                await promisify(rmdir)(path);
             }
             else {
                 // chmod as needed to allow for unlink
                 const mode = stat.mode;
                 if (!(mode & 128)) { // 128 === 0200
-                    await (0, util_1.promisify)(fs_1.chmod)(path, mode | 128);
+                    await promisify(chmod)(path, mode | 128);
                 }
-                return (0, util_1.promisify)(fs_1.unlink)(path);
+                return promisify(unlink)(path);
             }
         }
         catch (error) {
@@ -495,7 +493,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
             // rewrite some typical errors that can happen especially around symlinks
             // to something the user can better understand
             if (error.code === 'EINVAL' || error.code === 'EBUSY' || error.code === 'ENAMETOOLONG') {
-                error = new Error(`Unable to move '${(0, path_1.basename)(fromFilePath)}' into '${(0, path_1.basename)((0, path_1.dirname)(toFilePath))}' (${error.toString()}).`);
+                error = new Error(`Unable to move '${basename(fromFilePath)}' into '${basename(dirname(toFilePath))}' (${error.toString()}).`);
             }
             throw this.toFileSystemProviderError(error);
         }
@@ -505,21 +503,21 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
             return Promise.resolve();
         }
         async function updateMtime(path) {
-            const stat = await (0, util_1.promisify)(fs_1.lstat)(path);
+            const stat = await promisify(lstat)(path);
             if (stat.isDirectory() || stat.isSymbolicLink()) {
                 return Promise.resolve(); // only for files
             }
-            const fd = await (0, util_1.promisify)(fs_1.open)(path, 'a');
+            const fd = await promisify(open)(path, 'a');
             try {
-                await (0, util_1.promisify)(fs_1.futimes)(fd, stat.atime, new Date());
+                await promisify(futimes)(fd, stat.atime, new Date());
             }
             catch (error) {
                 // ignore
             }
-            return (0, util_1.promisify)(fs_1.close)(fd);
+            return promisify(close)(fd);
         }
         try {
-            await (0, util_1.promisify)(fs_1.rename)(source, target);
+            await promisify(rename)(source, target);
             await updateMtime(target);
         }
         catch (error) {
@@ -557,7 +555,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
             // rewrite some typical errors that can happen especially around symlinks
             // to something the user can better understand
             if (error.code === 'EINVAL' || error.code === 'EBUSY' || error.code === 'ENAMETOOLONG') {
-                error = new Error(`Unable to copy '${(0, path_1.basename)(fromFilePath)}' into '${(0, path_1.basename)((0, path_1.dirname)(toFilePath))}' (${error.toString()}).`);
+                error = new Error(`Unable to copy '${basename(fromFilePath)}' into '${basename(dirname(toFilePath))}' (${error.toString()}).`);
             }
             throw this.toFileSystemProviderError(error);
         }
@@ -571,12 +569,12 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
             isSameResourceWithDifferentPathCase = fromFilePath.toLowerCase() === toFilePath.toLowerCase();
         }
         if (isSameResourceWithDifferentPathCase && mode === 'copy') {
-            throw (0, files_1.createFileSystemProviderError)("'File cannot be copied to same path with different path case", files_1.FileSystemProviderErrorCode.FileExists);
+            throw createFileSystemProviderError("'File cannot be copied to same path with different path case", FileSystemProviderErrorCode.FileExists);
         }
         // handle existing target (unless this is a case change)
-        if (!isSameResourceWithDifferentPathCase && await (0, util_1.promisify)(fs_1.exists)(toFilePath)) {
+        if (!isSameResourceWithDifferentPathCase && await promisify(exists)(toFilePath)) {
             if (!overwrite) {
-                throw (0, files_1.createFileSystemProviderError)('File at target already exists', files_1.FileSystemProviderErrorCode.FileExists);
+                throw createFileSystemProviderError('File at target already exists', FileSystemProviderErrorCode.FileExists);
             }
             // Delete target
             await this.delete(to, { recursive: true, useTrash: false });
@@ -584,7 +582,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
     }
     async doCopy(source, target, copiedSourcesIn) {
         const copiedSources = copiedSourcesIn ? copiedSourcesIn : Object.create(null);
-        const fileStat = await (0, util_1.promisify)(fs_1.stat)(source);
+        const fileStat = await promisify(stat)(source);
         if (!fileStat.isDirectory()) {
             return this.doCopyFile(source, target, fileStat.mode & 511);
         }
@@ -595,16 +593,16 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
         // Create folder
         await this.mkdirp(target, fileStat.mode & 511);
         // Copy each file recursively
-        const files = await (0, util_1.promisify)(fs_1.readdir)(source);
+        const files = await promisify(readdir)(source);
         for (let i = 0; i < files.length; i++) {
             const file = files[i];
-            await this.doCopy((0, path_1.join)(source, file), (0, path_1.join)(target, file), copiedSources);
+            await this.doCopy(join(source, file), join(target, file), copiedSources);
         }
     }
     async mkdirp(path, mode) {
         const mkdir = async () => {
             try {
-                await (0, util_1.promisify)(fs.mkdir)(path, mode);
+                await promisify(fs.mkdir)(path, mode);
             }
             catch (error) {
                 // ENOENT: a parent folder does not exist yet
@@ -615,7 +613,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
                 // return normally in that case if its a folder
                 let targetIsFile = false;
                 try {
-                    const fileStat = await (0, util_1.promisify)(fs.stat)(path);
+                    const fileStat = await promisify(fs.stat)(path);
                     targetIsFile = !fileStat.isDirectory();
                 }
                 catch (statError) {
@@ -627,7 +625,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
             }
         };
         // stop at root
-        if (path === (0, path_1.dirname)(path)) {
+        if (path === dirname(path)) {
             return;
         }
         try {
@@ -637,7 +635,7 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
             // ENOENT: a parent folder does not exist yet, continue
             // to create the parent folder and then try again.
             if (error.code === 'ENOENT') {
-                await this.mkdirp((0, path_1.dirname)(path), mode);
+                await this.mkdirp(dirname(path), mode);
                 return mkdir();
             }
             // Any other error
@@ -708,8 +706,8 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
     async updateFile(resource, changes, opts) {
         try {
             const content = await this.readFile(resource);
-            const decoded = this.encodingService.decode(buffer_1.BinaryBuffer.wrap(content), opts.readEncoding);
-            const newContent = vscode_languageserver_textdocument_1.TextDocument.update(vscode_languageserver_textdocument_1.TextDocument.create('', '', 1, decoded), changes, 2).getText();
+            const decoded = this.encodingService.decode(BinaryBuffer.wrap(content), opts.readEncoding);
+            const newContent = TextDocument.update(TextDocument.create('', '', 1, decoded), changes, 2).getText();
             const encoding = await this.encodingService.toResourceEncoding(opts.writeEncoding, {
                 overwriteEncoding: opts.overwriteEncoding,
                 read: async (length) => {
@@ -735,61 +733,55 @@ let DiskFileSystemProvider = class DiskFileSystemProvider {
     }
     // #region Helpers
     toFilePath(resource) {
-        return (0, path_1.normalize)(file_uri_1.FileUri.fsPath(resource));
+        return normalize(FileUri.fsPath(resource));
     }
     toFileSystemProviderError(error) {
-        if (error instanceof files_1.FileSystemProviderError) {
+        if (error instanceof FileSystemProviderError) {
             return error; // avoid double conversion
         }
         let code;
         switch (error.code) {
             case 'ENOENT':
-                code = files_1.FileSystemProviderErrorCode.FileNotFound;
+                code = FileSystemProviderErrorCode.FileNotFound;
                 break;
             case 'EISDIR':
-                code = files_1.FileSystemProviderErrorCode.FileIsADirectory;
+                code = FileSystemProviderErrorCode.FileIsADirectory;
                 break;
             case 'ENOTDIR':
-                code = files_1.FileSystemProviderErrorCode.FileNotADirectory;
+                code = FileSystemProviderErrorCode.FileNotADirectory;
                 break;
             case 'EEXIST':
-                code = files_1.FileSystemProviderErrorCode.FileExists;
+                code = FileSystemProviderErrorCode.FileExists;
                 break;
             case 'EPERM':
             case 'EACCES':
-                code = files_1.FileSystemProviderErrorCode.NoPermissions;
+                code = FileSystemProviderErrorCode.NoPermissions;
                 break;
             default:
-                code = files_1.FileSystemProviderErrorCode.Unknown;
+                code = FileSystemProviderErrorCode.Unknown;
         }
-        return (0, files_1.createFileSystemProviderError)(error, code);
+        return createFileSystemProviderError(error, code);
     }
     // #endregion
     dispose() {
         this.toDispose.dispose();
     }
 };
-exports.DiskFileSystemProvider = DiskFileSystemProvider;
-tslib_1.__decorate([
-    (0, inversify_1.inject)(filesystem_watcher_protocol_1.FileSystemWatcherServer),
-    tslib_1.__metadata("design:type", Object)
+__decorate([
+    inject(FileSystemWatcherServer)
 ], DiskFileSystemProvider.prototype, "watcher", 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)
 ], DiskFileSystemProvider.prototype, "encodingService", void 0);
-tslib_1.__decorate([
-    (0, inversify_1.inject)(core_1.ILogger),
-    (0, inversify_1.named)('filesystem:DiskFileSystemProvider'),
-    tslib_1.__metadata("design:type", Object)
+__decorate([
+    inject(ILogger),
+    named('filesystem:DiskFileSystemProvider')
 ], DiskFileSystemProvider.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()
 ], DiskFileSystemProvider.prototype, "init", null);
-exports.DiskFileSystemProvider = DiskFileSystemProvider = tslib_1.__decorate([
-    (0, inversify_1.injectable)()
+DiskFileSystemProvider = __decorate([
+    injectable()
 ], DiskFileSystemProvider);
+export { DiskFileSystemProvider };
 //# sourceMappingURL=disk-file-system-provider.js.map