@nativescript/core 8.9.0-napi-es5.0 → 8.9.0-napi.1

package/file-system/index.js

@@ -2,7 +2,7 @@ import { FileSystemAccess, FileSystemAccess29 } from './file-system-access';
 import { SDK_VERSION } from '../utils';
 import { Application } from '../application';
 // The FileSystemAccess implementation, used through all the APIs.
-var fileAccess;
+let fileAccess;
 /**
  * Returns FileSystemAccess, a shared singleton utility class to provide methods to access and work with the file system. This is used under the hood of all the file system apis in @nativescript/core and provided as a lower level convenience if needed.
  * @returns FileSystemAccess
@@ -19,151 +19,129 @@ export function getFileAccess() {
     return fileAccess;
 }
 function createFile(info) {
-    var file = new File();
+    const file = new File();
     file._path = info.path;
     file._name = info.name;
     file._extension = info.extension;
     return file;
 }
 function createFolder(info) {
-    var documents = knownFolders.documents();
+    const documents = knownFolders.documents();
     if (info.path === documents.path) {
         return documents;
     }
-    var temp = knownFolders.temp();
+    const temp = knownFolders.temp();
     if (info.path === temp.path) {
         return temp;
     }
-    var folder = new Folder();
+    const folder = new Folder();
     folder._path = info.path;
     folder._name = info.name;
     return folder;
 }
-var FileSystemEntity = /** @class */ (function () {
-    function FileSystemEntity() {
+export class FileSystemEntity {
+    get parent() {
+        const onError = function (error) {
+            throw error;
+        };
+        const folderInfo = getFileAccess().getParent(this.path, onError);
+        if (!folderInfo) {
+            return undefined;
+        }
+        return createFolder(folderInfo);
     }
-    Object.defineProperty(FileSystemEntity.prototype, "parent", {
-        get: function () {
-            var onError = function (error) {
-                throw error;
-            };
-            var folderInfo = getFileAccess().getParent(this.path, onError);
-            if (!folderInfo) {
-                return undefined;
-            }
-            return createFolder(folderInfo);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    FileSystemEntity.prototype.remove = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var hasError = false;
-            var localError = function (error) {
+    remove() {
+        return new Promise((resolve, reject) => {
+            let hasError = false;
+            const localError = function (error) {
                 hasError = true;
                 reject(error);
             };
-            _this.removeSync(localError);
+            this.removeSync(localError);
             if (!hasError) {
                 resolve(true);
             }
         });
-    };
-    FileSystemEntity.prototype.removeSync = function (onError) {
+    }
+    removeSync(onError) {
         if (this._isKnown) {
             if (onError) {
                 onError({ message: 'Cannot delete known folder.' });
             }
             return;
         }
-        var fileAccess = getFileAccess();
+        const fileAccess = getFileAccess();
         if (this instanceof File) {
             fileAccess.deleteFile(this.path, onError);
         }
         else if (this instanceof Folder) {
             fileAccess.deleteFolder(this.path, onError);
         }
-    };
-    FileSystemEntity.prototype.rename = function (newName) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var hasError = false;
-            var localError = function (error) {
+    }
+    rename(newName) {
+        return new Promise((resolve, reject) => {
+            let hasError = false;
+            const localError = function (error) {
                 hasError = true;
                 reject(error);
             };
-            _this.renameSync(newName, localError);
+            this.renameSync(newName, localError);
             if (!hasError) {
                 resolve(true);
             }
         });
-    };
-    FileSystemEntity.prototype.renameSync = function (newName, onError) {
+    }
+    renameSync(newName, onError) {
         if (this._isKnown) {
             if (onError) {
                 onError(new Error('Cannot rename known folder.'));
             }
             return;
         }
-        var localError = function (error) {
+        const localError = function (error) {
             if (onError) {
                 onError(error);
             }
             return null;
         };
-        var fileAccess = getFileAccess();
+        const fileAccess = getFileAccess();
         // call rename for FileSystemAccess29
         if (fileAccess.__skip) {
             fileAccess.rename(this.path, newName, localError);
-            var fileInfo = getFileAccess().getFile(this.path, null);
+            const fileInfo = getFileAccess().getFile(this.path, null);
             if (fileInfo) {
                 this._name = fileInfo.name;
                 this._extension = fileInfo.extension;
             }
             return;
         }
-        var parentFolder = this.parent;
+        const parentFolder = this.parent;
         if (!parentFolder) {
             if (onError) {
                 onError(new Error('No parent folder.'));
             }
             return;
         }
-        var path = parentFolder.path;
-        var newPath = fileAccess.joinPath(path, newName);
+        const path = parentFolder.path;
+        const newPath = fileAccess.joinPath(path, newName);
         fileAccess.rename(this.path, newPath, localError);
         this._path = newPath;
         this._name = newName;
         if (this instanceof File) {
             this._extension = fileAccess.getFileExtension(newPath);
         }
-    };
-    Object.defineProperty(FileSystemEntity.prototype, "name", {
-        get: function () {
-            return this._name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FileSystemEntity.prototype, "path", {
-        get: function () {
-            return this._path;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FileSystemEntity.prototype, "lastModified", {
-        get: function () {
-            return getFileAccess().getLastModified(this.path);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return FileSystemEntity;
-}());
-export { FileSystemEntity };
-var applicationContext;
+    }
+    get name() {
+        return this._name;
+    }
+    get path() {
+        return this._path;
+    }
+    get lastModified() {
+        return getFileAccess().getLastModified(this.path);
+    }
+}
+let applicationContext;
 function getApplicationContext() {
     if (!applicationContext) {
         applicationContext = Application.android.getNativeApplication().getApplicationContext();
@@ -251,145 +229,113 @@ function getAndroidDirectory(value) {
             return null;
     }
 }
-var Android = /** @class */ (function () {
-    function Android() {
-    }
-    Android.prototype.createFile = function (options) {
+class Android {
+    createFile(options) {
         if (!__ANDROID__) {
-            throw new Error("createFile is available on Android only!");
+            throw new Error(`createFile is available on Android only!`);
         }
-        var context = getApplicationContext();
-        var meta = new android.content.ContentValues();
+        const context = getApplicationContext();
+        const meta = new android.content.ContentValues();
         meta.put(android.provider.MediaStore.MediaColumns.DISPLAY_NAME, options.name);
         meta.put(android.provider.MediaStore.MediaColumns.MIME_TYPE, options.mime);
         //meta.put(android.provider.MediaStore.MediaColumns.DATE_ADDED, java.lang.System.currentTimeMillis() as any);
-        var externalDirectory = getAndroidDirectory(options.directory);
+        const externalDirectory = getAndroidDirectory(options.directory);
         if (SDK_VERSION >= 29) {
-            var relativePath = (options === null || options === void 0 ? void 0 : options.relativePath) ? "/".concat(options.relativePath) : '';
-            meta.put(android.provider.MediaStore.MediaColumns.RELATIVE_PATH, "".concat(externalDirectory.path).concat(relativePath));
+            const relativePath = options?.relativePath ? `/${options.relativePath}` : '';
+            meta.put(android.provider.MediaStore.MediaColumns.RELATIVE_PATH, `${externalDirectory.path}${relativePath}`);
             // todo
             //	meta.put(android.provider.MediaStore.MediaColumns.IS_PENDING, java.lang.Integer.valueOf(1));
         }
         else {
-            var relativePath = (options === null || options === void 0 ? void 0 : options.relativePath) ? "".concat(options.relativePath, "/") : '';
-            var directory = android.os.Environment.getExternalStoragePublicDirectory(externalDirectory.path);
-            var file = new java.io.File(directory, "".concat(relativePath).concat(options.name));
+            const relativePath = options?.relativePath ? `${options.relativePath}/` : '';
+            const directory = android.os.Environment.getExternalStoragePublicDirectory(externalDirectory.path);
+            const file = new java.io.File(directory, `${relativePath}${options.name}`);
             meta.put(android.provider.MediaStore.MediaColumns.DATA, file.getAbsolutePath());
         }
-        var uri = context.getContentResolver().insert(externalDirectory.column, meta);
+        const uri = context.getContentResolver().insert(externalDirectory.column, meta);
         return File.fromPath(uri.toString());
-    };
-    return Android;
-}());
-var ad = new Android();
-var iOS = /** @class */ (function () {
-    function iOS() {
-    }
-    return iOS;
-}());
-var ios = new iOS();
-var File = /** @class */ (function (_super) {
-    __extends(File, _super);
-    function File() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(File, "ios", {
-        get: function () {
-            return ios;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(File, "android", {
-        get: function () {
-            return ad;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    File.fromPath = function (path, copy) {
-        if (copy === void 0) { copy = false; }
-        var onError = function (error) {
+    }
+}
+const ad = new Android();
+class iOS {
+}
+const ios = new iOS();
+export class File extends FileSystemEntity {
+    static get ios() {
+        return ios;
+    }
+    static get android() {
+        return ad;
+    }
+    static fromPath(path, copy = false) {
+        const onError = function (error) {
             throw error;
         };
         if (__ANDROID__ && copy) {
             if (path.startsWith('content:')) {
-                var fileInfo_1 = getFileAccess().getFile(path, onError);
+                const fileInfo = getFileAccess().getFile(path, onError);
                 // falls back to creating a temp file without a known extension.
-                if (!fileInfo_1) {
-                    var tempFile = "".concat(knownFolders.temp().path, "/").concat(java.util.UUID.randomUUID().toString());
+                if (!fileInfo) {
+                    const tempFile = `${knownFolders.temp().path}/${java.util.UUID.randomUUID().toString()}`;
                     org.nativescript.widgets.Async.File.copySync(path, tempFile, getApplicationContext());
                     path = tempFile;
                 }
                 else {
-                    var ext = fileInfo_1.extension;
-                    var name_1 = "".concat(fileInfo_1.name.replace(".".concat(ext), ''), ".").concat(ext);
-                    var tempFile = "".concat(knownFolders.temp().path, "/").concat(name_1);
+                    const ext = fileInfo.extension;
+                    const name = `${fileInfo.name.replace(`.${ext}`, '')}.${ext}`;
+                    const tempFile = `${knownFolders.temp().path}/${name}`;
                     getFileAccess().copySync(path, tempFile);
                     path = tempFile;
                 }
             }
         }
-        var fileInfo = getFileAccess().getFile(path, onError);
+        const fileInfo = getFileAccess().getFile(path, onError);
         if (!fileInfo) {
             return undefined;
         }
         return createFile(fileInfo);
-    };
-    File.exists = function (path) {
+    }
+    static exists(path) {
         return getFileAccess().fileExists(path);
-    };
-    Object.defineProperty(File.prototype, "extension", {
-        get: function () {
-            return this._extension;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(File.prototype, "isLocked", {
-        get: function () {
-            // !! is a boolean conversion/cast, handling undefined as well
-            return !!this._locked;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(File.prototype, "size", {
-        get: function () {
-            return getFileAccess().getFileSize(this.path);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    File.prototype.append = function (content) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
+    }
+    get extension() {
+        return this._extension;
+    }
+    get isLocked() {
+        // !! is a boolean conversion/cast, handling undefined as well
+        return !!this._locked;
+    }
+    get size() {
+        return getFileAccess().getFileSize(this.path);
+    }
+    append(content) {
+        return new Promise((resolve, reject) => {
             try {
-                _this._checkAccess();
+                this._checkAccess();
             }
             catch (ex) {
                 reject(ex);
                 return;
             }
-            _this._locked = true;
+            this._locked = true;
             getFileAccess()
-                .appendAsync(_this.path, content)
-                .then(function () {
+                .appendAsync(this.path, content)
+                .then(() => {
                 resolve();
-                _this._locked = false;
-            }, function (error) {
+                this._locked = false;
+            }, (error) => {
                 reject(error);
-                _this._locked = false;
+                this._locked = false;
             });
         });
-    };
-    File.prototype.appendSync = function (content, onError) {
+    }
+    appendSync(content, onError) {
         this._checkAccess();
         try {
             this._locked = true;
-            var that_1 = this;
-            var localError = function (error) {
-                that_1._locked = false;
+            const that = this;
+            const localError = function (error) {
+                that._locked = false;
                 if (onError) {
                     onError(error);
                 }
@@ -399,36 +345,35 @@ var File = /** @class */ (function (_super) {
         finally {
             this._locked = false;
         }
-    };
-    File.prototype.appendText = function (content, encoding) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
+    }
+    appendText(content, encoding) {
+        return new Promise((resolve, reject) => {
             try {
-                _this._checkAccess();
+                this._checkAccess();
             }
             catch (ex) {
                 reject(ex);
                 return;
             }
-            _this._locked = true;
+            this._locked = true;
             getFileAccess()
-                .appendTextAsync(_this.path, content, encoding)
-                .then(function () {
+                .appendTextAsync(this.path, content, encoding)
+                .then(() => {
                 resolve(true);
-                _this._locked = false;
-            }, function (error) {
+                this._locked = false;
+            }, (error) => {
                 reject(error);
-                _this._locked = false;
+                this._locked = false;
             });
         });
-    };
-    File.prototype.appendTextSync = function (content, onError, encoding) {
+    }
+    appendTextSync(content, onError, encoding) {
         this._checkAccess();
         try {
             this._locked = true;
-            var that_2 = this;
-            var localError = function (error) {
-                that_2._locked = false;
+            const that = this;
+            const localError = function (error) {
+                that._locked = false;
                 if (onError) {
                     onError(error);
                 }
@@ -438,108 +383,105 @@ var File = /** @class */ (function (_super) {
         finally {
             this._locked = false;
         }
-    };
-    File.prototype.copy = function (dest) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
+    }
+    copy(dest) {
+        return new Promise((resolve, reject) => {
             try {
-                _this._checkAccess();
+                this._checkAccess();
             }
             catch (ex) {
                 reject(ex);
                 return;
             }
-            _this._locked = true;
+            this._locked = true;
             getFileAccess()
-                .copyAsync(_this.path, dest)
-                .then(function (result) {
+                .copyAsync(this.path, dest)
+                .then((result) => {
                 resolve(result);
-                _this._locked = false;
-            }, function (error) {
+                this._locked = false;
+            }, (error) => {
                 reject(error);
-                _this._locked = false;
+                this._locked = false;
             });
         });
-    };
-    File.prototype.copySync = function (dest, onError) {
+    }
+    copySync(dest, onError) {
         this._checkAccess();
         this._locked = true;
-        var that = this;
-        var localError = function (error) {
+        const that = this;
+        const localError = (error) => {
             that._locked = false;
             if (onError) {
                 onError(error);
             }
         };
-        var content = getFileAccess().copySync(this.path, dest, localError);
+        const content = getFileAccess().copySync(this.path, dest, localError);
         this._locked = false;
         return content;
-    };
-    File.prototype.read = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
+    }
+    read() {
+        return new Promise((resolve, reject) => {
             try {
-                _this._checkAccess();
+                this._checkAccess();
             }
             catch (ex) {
                 reject(ex);
                 return;
             }
-            _this._locked = true;
+            this._locked = true;
             getFileAccess()
-                .readAsync(_this.path)
-                .then(function (result) {
+                .readAsync(this.path)
+                .then((result) => {
                 resolve(result);
-                _this._locked = false;
-            }, function (error) {
+                this._locked = false;
+            }, (error) => {
                 reject(error);
-                _this._locked = false;
+                this._locked = false;
             });
         });
-    };
-    File.prototype.readSync = function (onError) {
+    }
+    readSync(onError) {
         this._checkAccess();
         this._locked = true;
-        var that = this;
-        var localError = function (error) {
+        const that = this;
+        const localError = (error) => {
             that._locked = false;
             if (onError) {
                 onError(error);
             }
         };
-        var content = getFileAccess().readSync(this.path, localError);
+        const content = getFileAccess().readSync(this.path, localError);
         this._locked = false;
         return content;
-    };
-    File.prototype.write = function (content) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
+    }
+    write(content) {
+        return new Promise((resolve, reject) => {
             try {
-                _this._checkAccess();
+                this._checkAccess();
             }
             catch (ex) {
                 reject(ex);
                 return;
             }
-            _this._locked = true;
+            this._locked = true;
             getFileAccess()
-                .writeAsync(_this.path, content)
-                .then(function () {
+                .writeAsync(this.path, content)
+                .then(() => {
                 resolve();
-                _this._locked = false;
-            }, function (error) {
+                this._locked = false;
+            }, (error) => {
                 reject(error);
-                _this._locked = false;
+                this._locked = false;
             });
         });
-    };
-    File.prototype.writeSync = function (content, onError) {
+    }
+    writeSync(content, onError) {
         this._checkAccess();
         try {
             this._locked = true;
-            var that_3 = this;
-            var localError = function (error) {
-                that_3._locked = false;
+            const that = this;
+            const localError = function (error) {
+                that._locked = false;
                 if (onError) {
                     onError(error);
                 }
@@ -549,72 +491,70 @@ var File = /** @class */ (function (_super) {
         finally {
             this._locked = false;
         }
-    };
-    File.prototype.readText = function (encoding) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
+    }
+    readText(encoding) {
+        return new Promise((resolve, reject) => {
             try {
-                _this._checkAccess();
+                this._checkAccess();
             }
             catch (ex) {
                 reject(ex);
                 return;
             }
-            _this._locked = true;
+            this._locked = true;
             getFileAccess()
-                .readTextAsync(_this.path, encoding)
-                .then(function (result) {
+                .readTextAsync(this.path, encoding)
+                .then((result) => {
                 resolve(result);
-                _this._locked = false;
-            }, function (error) {
+                this._locked = false;
+            }, (error) => {
                 reject(error);
-                _this._locked = false;
+                this._locked = false;
             });
         });
-    };
-    File.prototype.readTextSync = function (onError, encoding) {
+    }
+    readTextSync(onError, encoding) {
         this._checkAccess();
         this._locked = true;
-        var that = this;
-        var localError = function (error) {
+        const that = this;
+        const localError = (error) => {
             that._locked = false;
             if (onError) {
                 onError(error);
             }
         };
-        var content = getFileAccess().readTextSync(this.path, localError, encoding);
+        const content = getFileAccess().readTextSync(this.path, localError, encoding);
         this._locked = false;
         return content;
-    };
-    File.prototype.writeText = function (content, encoding) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
+    }
+    writeText(content, encoding) {
+        return new Promise((resolve, reject) => {
             try {
-                _this._checkAccess();
+                this._checkAccess();
             }
             catch (ex) {
                 reject(ex);
                 return;
             }
-            _this._locked = true;
+            this._locked = true;
             getFileAccess()
-                .writeTextAsync(_this.path, content, encoding)
-                .then(function () {
+                .writeTextAsync(this.path, content, encoding)
+                .then(() => {
                 resolve(true);
-                _this._locked = false;
-            }, function (error) {
+                this._locked = false;
+            }, (error) => {
                 reject(error);
-                _this._locked = false;
+                this._locked = false;
             });
         });
-    };
-    File.prototype.writeTextSync = function (content, onError, encoding) {
+    }
+    writeTextSync(content, onError, encoding) {
         this._checkAccess();
         try {
             this._locked = true;
-            var that_4 = this;
-            var localError = function (error) {
-                that_4._locked = false;
+            const that = this;
+            const localError = function (error) {
+                that._locked = false;
                 if (onError) {
                     onError(error);
                 }
@@ -624,110 +564,98 @@ var File = /** @class */ (function (_super) {
         finally {
             this._locked = false;
         }
-    };
-    File.prototype._checkAccess = function () {
+    }
+    _checkAccess() {
         if (this.isLocked) {
             throw new Error('Cannot access a locked file.');
         }
-    };
-    return File;
-}(FileSystemEntity));
-export { File };
-var Folder = /** @class */ (function (_super) {
-    __extends(Folder, _super);
-    function Folder() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Folder.fromPath = function (path) {
-        var onError = function (error) {
+    }
+}
+export class Folder extends FileSystemEntity {
+    static fromPath(path) {
+        const onError = function (error) {
             throw error;
         };
-        var folderInfo = getFileAccess().getFolder(path, onError);
+        const folderInfo = getFileAccess().getFolder(path, onError);
         if (!folderInfo) {
             return undefined;
         }
         return createFolder(folderInfo);
-    };
-    Folder.exists = function (path) {
+    }
+    static exists(path) {
         return getFileAccess().folderExists(path);
-    };
-    Folder.prototype.contains = function (name) {
-        var fileAccess = getFileAccess();
-        var path = fileAccess.joinPath(this.path, name);
+    }
+    contains(name) {
+        const fileAccess = getFileAccess();
+        const path = fileAccess.joinPath(this.path, name);
         if (fileAccess.fileExists(path)) {
             return true;
         }
         return fileAccess.folderExists(path);
-    };
-    Folder.prototype.clear = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var hasError = false;
-            var onError = function (error) {
+    }
+    clear() {
+        return new Promise((resolve, reject) => {
+            let hasError = false;
+            const onError = function (error) {
                 hasError = true;
                 reject(error);
             };
-            _this.clearSync(onError);
+            this.clearSync(onError);
             if (!hasError) {
                 resolve(true);
             }
         });
-    };
-    Folder.prototype.clearSync = function (onError) {
+    }
+    clearSync(onError) {
         getFileAccess().emptyFolder(this.path, onError);
-    };
-    Object.defineProperty(Folder.prototype, "isKnown", {
-        get: function () {
-            return this._isKnown;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Folder.prototype.getFile = function (name) {
-        var fileAccess = getFileAccess();
-        var path = fileAccess.joinPath(this.path, name);
-        var onError = function (error) {
+    }
+    get isKnown() {
+        return this._isKnown;
+    }
+    getFile(name) {
+        const fileAccess = getFileAccess();
+        const path = fileAccess.joinPath(this.path, name);
+        const onError = function (error) {
             throw error;
         };
-        var fileInfo = fileAccess.getFile(path, onError);
+        const fileInfo = fileAccess.getFile(path, onError);
         if (!fileInfo) {
             return undefined;
         }
         return createFile(fileInfo);
-    };
-    Folder.prototype.getFolder = function (name) {
-        var fileAccess = getFileAccess();
-        var path = fileAccess.joinPath(this.path, name);
-        var onError = function (error) {
+    }
+    getFolder(name) {
+        const fileAccess = getFileAccess();
+        const path = fileAccess.joinPath(this.path, name);
+        const onError = function (error) {
             throw error;
         };
-        var folderInfo = fileAccess.getFolder(path, onError);
+        const folderInfo = fileAccess.getFolder(path, onError);
         if (!folderInfo) {
             return undefined;
         }
         return createFolder(folderInfo);
-    };
-    Folder.prototype.getEntities = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var hasError = false;
-            var localError = function (error) {
+    }
+    getEntities() {
+        return new Promise((resolve, reject) => {
+            let hasError = false;
+            const localError = function (error) {
                 hasError = true;
                 reject(error);
             };
-            var entities = _this.getEntitiesSync(localError);
+            const entities = this.getEntitiesSync(localError);
             if (!hasError) {
                 resolve(entities);
             }
         });
-    };
-    Folder.prototype.getEntitiesSync = function (onError) {
-        var fileInfos = getFileAccess().getEntities(this.path, onError);
+    }
+    getEntitiesSync(onError) {
+        const fileInfos = getFileAccess().getEntities(this.path, onError);
         if (!fileInfos) {
             return null;
         }
-        var entities = new Array();
-        for (var i = 0; i < fileInfos.length; i++) {
+        const entities = new Array();
+        for (let i = 0; i < fileInfos.length; i++) {
             if (fileInfos[i].extension) {
                 entities.push(createFile(fileInfos[i]));
             }
@@ -736,13 +664,13 @@ var Folder = /** @class */ (function (_super) {
             }
         }
         return entities;
-    };
-    Folder.prototype.eachEntity = function (onEntity) {
+    }
+    eachEntity(onEntity) {
         if (!onEntity) {
             return;
         }
-        var onSuccess = function (fileInfo) {
-            var entity;
+        const onSuccess = function (fileInfo) {
+            let entity;
             if (fileInfo.extension) {
                 entity = createFile(fileInfo);
             }
@@ -751,25 +679,23 @@ var Folder = /** @class */ (function (_super) {
             }
             return onEntity(entity);
         };
-        var onError = function (error) {
+        const onError = function (error) {
             throw error;
         };
         getFileAccess().eachEntity(this.path, onSuccess, onError);
-    };
-    return Folder;
-}(FileSystemEntity));
-export { Folder };
+    }
+}
 export var knownFolders;
 (function (knownFolders) {
-    var _documents;
-    var _externalDocuments;
-    var _temp;
-    var _app;
+    let _documents;
+    let _externalDocuments;
+    let _temp;
+    let _app;
     function documents() {
         if (!_documents) {
-            var path_1 = getFileAccess().getDocumentsFolderPath();
+            const path = getFileAccess().getDocumentsFolderPath();
             _documents = new Folder();
-            _documents._path = path_1;
+            _documents._path = path;
             _documents._isKnown = true;
         }
         return _documents;
@@ -777,9 +703,9 @@ export var knownFolders;
     knownFolders.documents = documents;
     function externalDocuments() {
         if (!_externalDocuments) {
-            var path_2 = getFileAccess().getExternalDocumentsFolderPath();
+            const path = getFileAccess().getExternalDocumentsFolderPath();
             _externalDocuments = new Folder();
-            _externalDocuments._path = path_2;
+            _externalDocuments._path = path;
             _externalDocuments._isKnown = true;
         }
         return _externalDocuments;
@@ -787,9 +713,9 @@ export var knownFolders;
     knownFolders.externalDocuments = externalDocuments;
     function temp() {
         if (!_temp) {
-            var path_3 = getFileAccess().getTempFolderPath();
+            const path = getFileAccess().getTempFolderPath();
             _temp = new Folder();
-            _temp._path = path_3;
+            _temp._path = path;
             _temp._isKnown = true;
         }
         return _temp;
@@ -797,26 +723,26 @@ export var knownFolders;
     knownFolders.temp = temp;
     function currentApp() {
         if (!_app) {
-            var path_4 = getFileAccess().getCurrentAppPath();
+            const path = getFileAccess().getCurrentAppPath();
             _app = new Folder();
-            _app._path = path_4;
+            _app._path = path;
             _app._isKnown = true;
         }
         return _app;
     }
     knownFolders.currentApp = currentApp;
-    var ios;
+    let ios;
     (function (ios) {
         function _checkPlatform(knownFolderName) {
             if (!__APPLE__) {
-                throw new Error("The \"".concat(knownFolderName, "\" known folder is available on iOS only!"));
+                throw new Error(`The "${knownFolderName}" known folder is available on iOS only!`);
             }
         }
-        var _library;
+        let _library;
         function library() {
             _checkPlatform('library');
             if (!_library) {
-                var existingFolderInfo = getExistingFolderInfo(5 /* NSSearchPathDirectory.LibraryDirectory */);
+                const existingFolderInfo = getExistingFolderInfo(5 /* NSSearchPathDirectory.LibraryDirectory */);
                 if (existingFolderInfo) {
                     _library = existingFolderInfo.folder;
                     _library._path = existingFolderInfo.path;
@@ -826,11 +752,11 @@ export var knownFolders;
             return _library;
         }
         ios.library = library;
-        var _developer;
+        let _developer;
         function developer() {
             _checkPlatform('developer');
             if (!_developer) {
-                var existingFolderInfo = getExistingFolderInfo(6 /* NSSearchPathDirectory.DeveloperDirectory */);
+                const existingFolderInfo = getExistingFolderInfo(6 /* NSSearchPathDirectory.DeveloperDirectory */);
                 if (existingFolderInfo) {
                     _developer = existingFolderInfo.folder;
                     _developer._path = existingFolderInfo.path;
@@ -840,11 +766,11 @@ export var knownFolders;
             return _developer;
         }
         ios.developer = developer;
-        var _desktop;
+        let _desktop;
         function desktop() {
             _checkPlatform('desktop');
             if (!_desktop) {
-                var existingFolderInfo = getExistingFolderInfo(12 /* NSSearchPathDirectory.DesktopDirectory */);
+                const existingFolderInfo = getExistingFolderInfo(12 /* NSSearchPathDirectory.DesktopDirectory */);
                 if (existingFolderInfo) {
                     _desktop = existingFolderInfo.folder;
                     _desktop._path = existingFolderInfo.path;
@@ -854,11 +780,11 @@ export var knownFolders;
             return _desktop;
         }
         ios.desktop = desktop;
-        var _downloads;
+        let _downloads;
         function downloads() {
             _checkPlatform('downloads');
             if (!_downloads) {
-                var existingFolderInfo = getExistingFolderInfo(15 /* NSSearchPathDirectory.DownloadsDirectory */);
+                const existingFolderInfo = getExistingFolderInfo(15 /* NSSearchPathDirectory.DownloadsDirectory */);
                 if (existingFolderInfo) {
                     _downloads = existingFolderInfo.folder;
                     _downloads._path = existingFolderInfo.path;
@@ -868,11 +794,11 @@ export var knownFolders;
             return _downloads;
         }
         ios.downloads = downloads;
-        var _movies;
+        let _movies;
         function movies() {
             _checkPlatform('movies');
             if (!_movies) {
-                var existingFolderInfo = getExistingFolderInfo(17 /* NSSearchPathDirectory.MoviesDirectory */);
+                const existingFolderInfo = getExistingFolderInfo(17 /* NSSearchPathDirectory.MoviesDirectory */);
                 if (existingFolderInfo) {
                     _movies = existingFolderInfo.folder;
                     _movies._path = existingFolderInfo.path;
@@ -882,11 +808,11 @@ export var knownFolders;
             return _movies;
         }
         ios.movies = movies;
-        var _music;
+        let _music;
         function music() {
             _checkPlatform('music');
             if (!_music) {
-                var existingFolderInfo = getExistingFolderInfo(18 /* NSSearchPathDirectory.MusicDirectory */);
+                const existingFolderInfo = getExistingFolderInfo(18 /* NSSearchPathDirectory.MusicDirectory */);
                 if (existingFolderInfo) {
                     _music = existingFolderInfo.folder;
                     _music._path = existingFolderInfo.path;
@@ -896,11 +822,11 @@ export var knownFolders;
             return _music;
         }
         ios.music = music;
-        var _pictures;
+        let _pictures;
         function pictures() {
             _checkPlatform('pictures');
             if (!_pictures) {
-                var existingFolderInfo = getExistingFolderInfo(19 /* NSSearchPathDirectory.PicturesDirectory */);
+                const existingFolderInfo = getExistingFolderInfo(19 /* NSSearchPathDirectory.PicturesDirectory */);
                 if (existingFolderInfo) {
                     _pictures = existingFolderInfo.folder;
                     _pictures._path = existingFolderInfo.path;
@@ -910,11 +836,11 @@ export var knownFolders;
             return _pictures;
         }
         ios.pictures = pictures;
-        var _sharedPublic;
+        let _sharedPublic;
         function sharedPublic() {
             _checkPlatform('sharedPublic');
             if (!_sharedPublic) {
-                var existingFolderInfo = getExistingFolderInfo(21 /* NSSearchPathDirectory.SharedPublicDirectory */);
+                const existingFolderInfo = getExistingFolderInfo(21 /* NSSearchPathDirectory.SharedPublicDirectory */);
                 if (existingFolderInfo) {
                     _sharedPublic = existingFolderInfo.folder;
                     _sharedPublic._path = existingFolderInfo.path;
@@ -925,9 +851,9 @@ export var knownFolders;
         }
         ios.sharedPublic = sharedPublic;
         function getExistingFolderInfo(pathDirectory /* NSSearchPathDirectory */) {
-            var fileAccess = getFileAccess();
-            var folderPath = fileAccess.getKnownPath(pathDirectory);
-            var folderInfo = fileAccess.getExistingFolder(folderPath);
+            const fileAccess = getFileAccess();
+            const folderPath = fileAccess.getKnownPath(pathDirectory);
+            const folderInfo = fileAccess.getExistingFolder(folderPath);
             if (folderInfo) {
                 return {
                     folder: createFolder(folderInfo),
@@ -939,20 +865,16 @@ export var knownFolders;
     })(ios = knownFolders.ios || (knownFolders.ios = {}));
 })(knownFolders || (knownFolders = {}));
 export var path;
-(function (path_5) {
+(function (path_1) {
     function normalize(path) {
         return getFileAccess().normalizePath(path);
     }
-    path_5.normalize = normalize;
-    function join() {
-        var paths = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            paths[_i] = arguments[_i];
-        }
-        var fileAccess = getFileAccess();
+    path_1.normalize = normalize;
+    function join(...paths) {
+        const fileAccess = getFileAccess();
         return fileAccess.joinPaths(paths);
     }
-    path_5.join = join;
-    path_5.separator = getFileAccess().getPathSeparator();
+    path_1.join = join;
+    path_1.separator = getFileAccess().getPathSeparator();
 })(path || (path = {}));
 //# sourceMappingURL=index.js.map