@nativescript/core 8.9.0-alpha.3 → 8.9.0-napi-es5.0

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