@corellium/corellium-cli 1.4.0 → 1.5.0

package/src/resumable.js

@@ -10,26 +10,26 @@
 const XMLHttpRequest = require('xhr2').XMLHttpRequest;
 
 (function () {
-  'use strict'
+  'use strict';
 
   var Resumable = function (opts) {
     if (!(this instanceof Resumable)) {
-      return new Resumable(opts)
+      return new Resumable(opts);
     }
-    this.version = 1.0
+    this.version = 1.0;
     // SUPPORTED BY BROWSER?
     // Check if these features are support by the browser:
     // - File object type
     // - Blob object type
     // - FileList object type
     // - slicing files
-    this.support = true
-    if (!this.support) return false
-    const window = { setTimeout }
+    this.support = true;
+    if (!this.support) return false;
+    const window = { setTimeout };
 
     // PROPERTIES
-    const $ = this
-    $.files = []
+    const $ = this;
+    $.files = [];
     $.defaults = {
       chunkSize: 1 * 1024 * 1024,
       forceChunkSize: false,
@@ -70,345 +70,329 @@ const XMLHttpRequest = require('xhr2').XMLHttpRequest;
       chunkFormat: 'blob',
       setChunkTypeFromFile: false,
       maxFilesErrorCallback: function (files, errorCount) {
-        const maxFiles = $.getOpt('maxFiles')
-        alert(
-          'Please upload no more than ' +
-                        maxFiles +
-                        ' file' +
-                        (maxFiles === 1 ? '' : 's') +
-                        ' at a time.'
-        )
+        const maxFiles = $.getOpt('maxFiles');
+        alert('Please upload no more than ' + maxFiles + ' file' + (maxFiles === 1 ? '' : 's') + ' at a time.');
       },
       minFileSize: 1,
       minFileSizeErrorCallback: function (file, errorCount) {
         alert(
           file.fileName ||
-                        file.name +
-                            ' is too small, please upload files larger than ' +
-                            $h.formatSize($.getOpt('minFileSize')) +
-                            '.'
-        )
+            file.name +
+              ' is too small, please upload files larger than ' +
+              $h.formatSize($.getOpt('minFileSize')) +
+              '.',
+        );
       },
       maxFileSize: undefined,
       maxFileSizeErrorCallback: function (file, errorCount) {
         alert(
           file.fileName ||
-                        file.name +
-                            ' is too large, please upload files less than ' +
-                            $h.formatSize($.getOpt('maxFileSize')) +
-                            '.'
-        )
+            file.name + ' is too large, please upload files less than ' + $h.formatSize($.getOpt('maxFileSize')) + '.',
+        );
       },
       fileType: [],
       fileTypeErrorCallback: function (file, errorCount) {
         alert(
           file.fileName ||
-                        file.name +
-                            ' has type not allowed, please upload files of type ' +
-                            $.getOpt('fileType') +
-                            '.'
-        )
-      }
-    }
-    $.opts = opts || {}
+            file.name + ' has type not allowed, please upload files of type ' + $.getOpt('fileType') + '.',
+        );
+      },
+    };
+    $.opts = opts || {};
     $.getOpt = function (o) {
-      let $opt = this
+      let $opt = this;
       // Get multiple option if passed an array
       if (o instanceof Array) {
-        const options = {}
+        const options = {};
         $h.each(o, function (option) {
-          options[option] = $opt.getOpt(option)
-        })
-        return options
+          options[option] = $opt.getOpt(option);
+        });
+        return options;
       }
       // Otherwise, just return a simple option
       if ($opt instanceof ResumableChunk) {
         if (typeof $opt.opts[o] !== 'undefined') {
-          return $opt.opts[o]
+          return $opt.opts[o];
         } else {
-          $opt = $opt.fileObj
+          $opt = $opt.fileObj;
         }
       }
       if ($opt instanceof ResumableFile) {
         if (typeof $opt.opts[o] !== 'undefined') {
-          return $opt.opts[o]
+          return $opt.opts[o];
         } else {
-          $opt = $opt.resumableObj
+          $opt = $opt.resumableObj;
         }
       }
       if ($opt instanceof Resumable) {
         if (typeof $opt.opts[o] !== 'undefined') {
-          return $opt.opts[o]
+          return $opt.opts[o];
         } else {
-          return $opt.defaults[o]
+          return $opt.defaults[o];
         }
       }
-    }
+    };
     $.indexOf = function (array, obj) {
       if (array.indexOf) {
-        return array.indexOf(obj)
+        return array.indexOf(obj);
       }
       for (let i = 0; i < array.length; i++) {
         if (array[i] === obj) {
-          return i
+          return i;
         }
       }
-      return -1
-    }
+      return -1;
+    };
 
     // EVENTS
     // catchAll(event, ...)
     // fileSuccess(file), fileProgress(file), fileAdded(file, event), filesAdded(files, filesSkipped), fileRetry(file),
     // fileError(file, message), complete(), progress(), error(message, file), pause()
-    $.events = []
+    $.events = [];
     $.on = function (event, callback) {
-      $.events.push(event.toLowerCase(), callback)
-    }
+      $.events.push(event.toLowerCase(), callback);
+    };
     $.fire = function () {
       // `arguments` is an object, not array, in FF, so:
-      const args = []
-      for (var i = 0; i < arguments.length; i++) args.push(arguments[i])
+      const args = [];
+      for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);
       // Find event listeners, and support pseudo-event `catchAll`
-      const event = args[0].toLowerCase()
+      const event = args[0].toLowerCase();
       for (var i = 0; i <= $.events.length; i += 2) {
-        if ($.events[i] == event) $.events[i + 1].apply($, args.slice(1))
-        if ($.events[i] == 'catchall') $.events[i + 1].apply(null, args)
+        if ($.events[i] == event) $.events[i + 1].apply($, args.slice(1));
+        if ($.events[i] == 'catchall') $.events[i + 1].apply(null, args);
       }
-      if (event == 'fileerror') $.fire('error', args[2], args[1])
-      if (event == 'fileprogress') $.fire('progress')
-    }
+      if (event == 'fileerror') $.fire('error', args[2], args[1]);
+      if (event == 'fileprogress') $.fire('progress');
+    };
 
     // INTERNAL HELPER METHODS (handy, but ultimately not part of uploading)
     var $h = {
       stopEvent: function (e) {
-        e.stopPropagation()
-        e.preventDefault()
+        e.stopPropagation();
+        e.preventDefault();
       },
       each: function (o, callback) {
         if (typeof o.length !== 'undefined') {
           for (var i = 0; i < o.length; i++) {
             // Array or FileList
-            if (callback(o[i]) === false) return
+            if (callback(o[i]) === false) return;
           }
         } else {
           for (i in o) {
             // Object
-            if (callback(i, o[i]) === false) return
+            if (callback(i, o[i]) === false) return;
           }
         }
       },
       generateUniqueIdentifier: function (file, event) {
-        const custom = $.getOpt('generateUniqueIdentifier')
+        const custom = $.getOpt('generateUniqueIdentifier');
         if (typeof custom === 'function') {
-          return custom(file, event)
+          return custom(file, event);
         }
-        const relativePath =
-                    file.webkitRelativePath || file.relativePath || file.fileName || file.name // Some confusion in different versions of Firefox
-        const size = file.size
-        return size + '-' + relativePath.replace(/[^0-9a-zA-Z_-]/gim, '')
+        const relativePath = file.webkitRelativePath || file.relativePath || file.fileName || file.name; // Some confusion in different versions of Firefox
+        const size = file.size;
+        return size + '-' + relativePath.replace(/[^0-9a-zA-Z_-]/gim, '');
       },
       contains: function (array, test) {
-        let result = false
+        let result = false;
 
         $h.each(array, function (value) {
           if (value == test) {
-            result = true
-            return false
+            result = true;
+            return false;
           }
-          return true
-        })
+          return true;
+        });
 
-        return result
+        return result;
       },
       formatSize: function (size) {
         if (size < 1024) {
-          return size + ' bytes'
+          return size + ' bytes';
         } else if (size < 1024 * 1024) {
-          return (size / 1024.0).toFixed(0) + ' KB'
+          return (size / 1024.0).toFixed(0) + ' KB';
         } else if (size < 1024 * 1024 * 1024) {
-          return (size / 1024.0 / 1024.0).toFixed(1) + ' MB'
+          return (size / 1024.0 / 1024.0).toFixed(1) + ' MB';
         } else {
-          return (size / 1024.0 / 1024.0 / 1024.0).toFixed(1) + ' GB'
+          return (size / 1024.0 / 1024.0 / 1024.0).toFixed(1) + ' GB';
         }
       },
       getTarget: function (request, params) {
-        let target = $.getOpt('target')
+        let target = $.getOpt('target');
 
         if (request === 'test' && $.getOpt('testTarget')) {
-          target =
-                        $.getOpt('testTarget') === '/'
-                          ? $.getOpt('target')
-                          : $.getOpt('testTarget')
+          target = $.getOpt('testTarget') === '/' ? $.getOpt('target') : $.getOpt('testTarget');
         }
 
         if (typeof target === 'function') {
-          return target(params)
+          return target(params);
         }
 
-        const separator = target.indexOf('?') < 0 ? '?' : '&'
-        const joinedParams = params.join('&')
+        const separator = target.indexOf('?') < 0 ? '?' : '&';
+        const joinedParams = params.join('&');
 
-        if (joinedParams) target = target + separator + joinedParams
+        if (joinedParams) target = target + separator + joinedParams;
 
-        return target
-      }
-    }
+        return target;
+      },
+    };
 
     const onDrop = function (e) {
-      e.currentTarget.classList.remove($.getOpt('dragOverClass'))
-      $h.stopEvent(e)
+      e.currentTarget.classList.remove($.getOpt('dragOverClass'));
+      $h.stopEvent(e);
 
       // handle dropped things as items if we can (this lets us deal with folders nicer in some cases)
       if (e.dataTransfer && e.dataTransfer.items) {
-        loadFiles(e.dataTransfer.items, e)
+        loadFiles(e.dataTransfer.items, e);
       }
       // else handle them as files
       else if (e.dataTransfer && e.dataTransfer.files) {
-        loadFiles(e.dataTransfer.files, e)
+        loadFiles(e.dataTransfer.files, e);
       }
-    }
+    };
     const onDragLeave = function (e) {
-      e.currentTarget.classList.remove($.getOpt('dragOverClass'))
-    }
+      e.currentTarget.classList.remove($.getOpt('dragOverClass'));
+    };
     const onDragOverEnter = function (e) {
-      e.preventDefault()
-      const dt = e.dataTransfer
+      e.preventDefault();
+      const dt = e.dataTransfer;
       if ($.indexOf(dt.types, 'Files') >= 0) {
         // only for file drop
-        e.stopPropagation()
-        dt.dropEffect = 'copy'
-        dt.effectAllowed = 'copy'
-        e.currentTarget.classList.add($.getOpt('dragOverClass'))
+        e.stopPropagation();
+        dt.dropEffect = 'copy';
+        dt.effectAllowed = 'copy';
+        e.currentTarget.classList.add($.getOpt('dragOverClass'));
       } else {
         // not work on IE/Edge....
-        dt.dropEffect = 'none'
-        dt.effectAllowed = 'none'
+        dt.dropEffect = 'none';
+        dt.effectAllowed = 'none';
       }
-    }
+    };
 
     /**
-         * processes a single upload item (file or directory)
-         * @param {Object} item item to upload, may be file or directory entry
-         * @param {string} path current file path
-         * @param {File[]} items list of files to append new items to
-         * @param {Function} cb callback invoked when item is processed
-         */
-    function processItem (item, path, items, cb) {
-      let entry
+     * processes a single upload item (file or directory)
+     * @param {Object} item item to upload, may be file or directory entry
+     * @param {string} path current file path
+     * @param {File[]} items list of files to append new items to
+     * @param {Function} cb callback invoked when item is processed
+     */
+    function processItem(item, path, items, cb) {
+      let entry;
       if (item.isFile) {
         // file provided
         return item.file(function (file) {
-          file.relativePath = path + file.name
-          items.push(file)
-          cb()
-        })
+          file.relativePath = path + file.name;
+          items.push(file);
+          cb();
+        });
       } else if (item.isDirectory) {
         // item is already a directory entry, just assign
-        entry = item
+        entry = item;
       } else if (item instanceof File) {
-        items.push(item)
+        items.push(item);
       }
       if (typeof item.webkitGetAsEntry === 'function') {
         // get entry from file object
-        entry = item.webkitGetAsEntry()
+        entry = item.webkitGetAsEntry();
       }
       if (entry && entry.isDirectory) {
         // directory provided, process it
-        return processDirectory(entry, path + entry.name + '/', items, cb)
+        return processDirectory(entry, path + entry.name + '/', items, cb);
       }
       if (typeof item.getAsFile === 'function') {
         // item represents a File object, convert it
-        item = item.getAsFile()
+        item = item.getAsFile();
         if (item instanceof File) {
-          item.relativePath = path + item.name
-          items.push(item)
+          item.relativePath = path + item.name;
+          items.push(item);
         }
       }
-      cb() // indicate processing is done
+      cb(); // indicate processing is done
     }
 
     /**
-         * cps-style list iteration.
-         * invokes all functions in list and waits for their callback to be
-         * triggered.
-         * @param  {Function[]}   items list of functions expecting callback parameter
-         * @param  {Function} cb    callback to trigger after the last callback has been invoked
-         */
-    function processCallbacks (items, cb) {
+     * cps-style list iteration.
+     * invokes all functions in list and waits for their callback to be
+     * triggered.
+     * @param  {Function[]}   items list of functions expecting callback parameter
+     * @param  {Function} cb    callback to trigger after the last callback has been invoked
+     */
+    function processCallbacks(items, cb) {
       if (!items || items.length === 0) {
         // empty or no list, invoke callback
-        return cb()
+        return cb();
       }
       // invoke current function, pass the next part as continuation
       items[0](function () {
-        processCallbacks(items.slice(1), cb)
-      })
+        processCallbacks(items.slice(1), cb);
+      });
     }
 
     /**
-         * recursively traverse directory and collect files to upload
-         * @param  {Object}   directory directory to process
-         * @param  {string}   path      current path
-         * @param  {File[]}   items     target list of items
-         * @param  {Function} cb        callback invoked after traversing directory
-         */
-    function processDirectory (directory, path, items, cb) {
-      const dirReader = directory.createReader()
-      let allEntries = []
+     * recursively traverse directory and collect files to upload
+     * @param  {Object}   directory directory to process
+     * @param  {string}   path      current path
+     * @param  {File[]}   items     target list of items
+     * @param  {Function} cb        callback invoked after traversing directory
+     */
+    function processDirectory(directory, path, items, cb) {
+      const dirReader = directory.createReader();
+      let allEntries = [];
 
-      function readEntries () {
+      function readEntries() {
         dirReader.readEntries(function (entries) {
           if (entries.length) {
-            allEntries = allEntries.concat(entries)
-            return readEntries()
+            allEntries = allEntries.concat(entries);
+            return readEntries();
           }
 
           // process all conversion callbacks, finally invoke own one
           processCallbacks(
             allEntries.map(function (entry) {
               // bind all properties except for callback
-              return processItem.bind(null, entry, path, items)
+              return processItem.bind(null, entry, path, items);
             }),
-            cb
-          )
-        })
+            cb,
+          );
+        });
       }
 
-      readEntries()
+      readEntries();
     }
 
     /**
-         * process items to extract files to be uploaded
-         * @param  {File[]} items items to process
-         * @param  {Event} event event that led to upload
-         */
-    function loadFiles (items, event) {
+     * process items to extract files to be uploaded
+     * @param  {File[]} items items to process
+     * @param  {Event} event event that led to upload
+     */
+    function loadFiles(items, event) {
       if (!items.length) {
-        return // nothing to do
+        return; // nothing to do
       }
-      $.fire('beforeAdd')
-      const files = []
+      $.fire('beforeAdd');
+      const files = [];
       processCallbacks(
         Array.prototype.map.call(items, function (item) {
           // bind all properties except for callback
-          let entry = item
+          let entry = item;
           if (typeof item.webkitGetAsEntry === 'function') {
-            entry = item.webkitGetAsEntry()
+            entry = item.webkitGetAsEntry();
           }
-          return processItem.bind(null, entry, '', files)
+          return processItem.bind(null, entry, '', files);
         }),
         function () {
           if (files.length) {
             // at least one file found
-            appendFilesFromFileList(files, event)
+            appendFilesFromFileList(files, event);
           }
-        }
-      )
+        },
+      );
     }
 
     var appendFilesFromFileList = function (fileList, event) {
       // check for uploading too many files
-      let errorCount = 0
+      let errorCount = 0;
       const o = $.getOpt([
         'maxFiles',
         'minFileSize',
@@ -417,372 +401,357 @@ const XMLHttpRequest = require('xhr2').XMLHttpRequest;
         'minFileSizeErrorCallback',
         'maxFileSizeErrorCallback',
         'fileType',
-        'fileTypeErrorCallback'
-      ])
-      if (
-        typeof o.maxFiles !== 'undefined' &&
-                o.maxFiles < fileList.length + $.files.length
-      ) {
+        'fileTypeErrorCallback',
+      ]);
+      if (typeof o.maxFiles !== 'undefined' && o.maxFiles < fileList.length + $.files.length) {
         // if single-file upload, file is already added, and trying to add 1 new file, simply replace the already-added file
         if (o.maxFiles === 1 && $.files.length === 1 && fileList.length === 1) {
-          $.removeFile($.files[0])
+          $.removeFile($.files[0]);
         } else {
-          o.maxFilesErrorCallback(fileList, errorCount++)
-          return false
+          o.maxFilesErrorCallback(fileList, errorCount++);
+          return false;
         }
       }
-      const files = []
-      const filesSkipped = []
-      let remaining = fileList.length
+      const files = [];
+      const filesSkipped = [];
+      let remaining = fileList.length;
       const decreaseReamining = function () {
         if (!--remaining) {
           // all files processed, trigger event
           if (!files.length && !filesSkipped.length) {
             // no succeeded files, just skip
-            return
+            return;
           }
           window.setTimeout(function () {
-            $.fire('filesAdded', files, filesSkipped)
-          }, 0)
+            $.fire('filesAdded', files, filesSkipped);
+          }, 0);
         }
-      }
+      };
       $h.each(fileList, function (file) {
-        const fileName = file.name
-        const fileType = file.type // e.g video/mp4
+        const fileName = file.name;
+        const fileType = file.type; // e.g video/mp4
         if (o.fileType.length > 0) {
-          let fileTypeFound = false
+          let fileTypeFound = false;
           for (const index in o.fileType) {
             // For good behaviour we do some inital sanitizing. Remove spaces and lowercase all
-            o.fileType[index] = o.fileType[index].replace(/\s/g, '').toLowerCase()
+            o.fileType[index] = o.fileType[index].replace(/\s/g, '').toLowerCase();
 
             // Allowing for both [extension, .extension, mime/type, mime/*]
-            const extension =
-                            (o.fileType[index].match(/^[^.][^/]+$/) ? '.' : '') + o.fileType[index]
+            const extension = (o.fileType[index].match(/^[^.][^/]+$/) ? '.' : '') + o.fileType[index];
 
             if (
               fileName.substr(-1 * extension.length).toLowerCase() === extension ||
-                            // If MIME type, check for wildcard or if extension matches the files tiletype
-                            (extension.indexOf('/') !== -1 &&
-                                ((extension.indexOf('*') !== -1 &&
-                                    fileType.substr(0, extension.indexOf('*')) ===
-                                        extension.substr(0, extension.indexOf('*'))) ||
-                                    fileType === extension))
+              // If MIME type, check for wildcard or if extension matches the files tiletype
+              (extension.indexOf('/') !== -1 &&
+                ((extension.indexOf('*') !== -1 &&
+                  fileType.substr(0, extension.indexOf('*')) === extension.substr(0, extension.indexOf('*'))) ||
+                  fileType === extension))
             ) {
-              fileTypeFound = true
-              break
+              fileTypeFound = true;
+              break;
             }
           }
           if (!fileTypeFound) {
-            o.fileTypeErrorCallback(file, errorCount++)
-            return true
+            o.fileTypeErrorCallback(file, errorCount++);
+            return true;
           }
         }
 
         if (typeof o.minFileSize !== 'undefined' && file.size < o.minFileSize) {
-          o.minFileSizeErrorCallback(file, errorCount++)
-          return true
+          o.minFileSizeErrorCallback(file, errorCount++);
+          return true;
         }
         if (typeof o.maxFileSize !== 'undefined' && file.size > o.maxFileSize) {
-          o.maxFileSizeErrorCallback(file, errorCount++)
-          return true
+          o.maxFileSizeErrorCallback(file, errorCount++);
+          return true;
         }
 
-        function addFile (uniqueIdentifier) {
+        function addFile(uniqueIdentifier) {
           if (!$.getFromUniqueIdentifier(uniqueIdentifier)) {
             (function () {
-              file.uniqueIdentifier = uniqueIdentifier
-              const f = new ResumableFile($, file, uniqueIdentifier)
-              $.files.push(f)
-              files.push(f)
-              f.container = typeof event !== 'undefined' ? event.srcElement : null
+              file.uniqueIdentifier = uniqueIdentifier;
+              const f = new ResumableFile($, file, uniqueIdentifier);
+              $.files.push(f);
+              files.push(f);
+              f.container = typeof event !== 'undefined' ? event.srcElement : null;
               window.setTimeout(function () {
-                $.fire('fileAdded', f, event)
-              }, 0)
-            })()
+                $.fire('fileAdded', f, event);
+              }, 0);
+            })();
           } else {
-            filesSkipped.push(file)
+            filesSkipped.push(file);
           }
-          decreaseReamining()
+          decreaseReamining();
         }
         // directories have size == 0
-        const uniqueIdentifier = $h.generateUniqueIdentifier(file, event)
+        const uniqueIdentifier = $h.generateUniqueIdentifier(file, event);
         if (uniqueIdentifier && typeof uniqueIdentifier.then === 'function') {
           // Promise or Promise-like object provided as unique identifier
           uniqueIdentifier.then(
             function (uniqueIdentifier) {
               // unique identifier generation succeeded
-              addFile(uniqueIdentifier)
+              addFile(uniqueIdentifier);
             },
             function () {
               // unique identifier generation failed
               // skip further processing, only decrease file count
-              decreaseReamining()
-            }
-          )
+              decreaseReamining();
+            },
+          );
         } else {
           // non-Promise provided as unique identifier, process synchronously
-          addFile(uniqueIdentifier)
+          addFile(uniqueIdentifier);
         }
-      })
-    }
+      });
+    };
 
     // INTERNAL OBJECT TYPES
-    function ResumableFile (resumableObj, file, uniqueIdentifier) {
-      const $ = this
-      $.opts = {}
-      $.getOpt = resumableObj.getOpt
-      $._prevProgress = 0
-      $.resumableObj = resumableObj
-      $.file = file
-      $.fileName = file.fileName || file.name // Some confusion in different versions of Firefox
-      $.size = file.size
-      $.relativePath = file.relativePath || file.webkitRelativePath || $.fileName
-      $.uniqueIdentifier = uniqueIdentifier
-      $._pause = false
-      $.container = ''
-      $.preprocessState = 0 // 0 = unprocessed, 1 = processing, 2 = finished
-      let _error = uniqueIdentifier !== undefined
+    function ResumableFile(resumableObj, file, uniqueIdentifier) {
+      const $ = this;
+      $.opts = {};
+      $.getOpt = resumableObj.getOpt;
+      $._prevProgress = 0;
+      $.resumableObj = resumableObj;
+      $.file = file;
+      $.fileName = file.fileName || file.name; // Some confusion in different versions of Firefox
+      $.size = file.size;
+      $.relativePath = file.relativePath || file.webkitRelativePath || $.fileName;
+      $.uniqueIdentifier = uniqueIdentifier;
+      $._pause = false;
+      $.container = '';
+      $.preprocessState = 0; // 0 = unprocessed, 1 = processing, 2 = finished
+      let _error = uniqueIdentifier !== undefined;
 
       // Callback when something happens within the chunk
       const chunkEvent = function (event, message) {
         // event can be 'progress', 'success', 'error' or 'retry'
         switch (event) {
           case 'progress':
-            $.resumableObj.fire('fileProgress', $, message)
-            break
+            $.resumableObj.fire('fileProgress', $, message);
+            break;
           case 'error':
-            $.abort()
-            _error = true
-            $.chunks = []
-            $.resumableObj.fire('fileError', $, message)
-            break
+            $.abort();
+            _error = true;
+            $.chunks = [];
+            $.resumableObj.fire('fileError', $, message);
+            break;
           case 'success':
-            if (_error) return
-            $.resumableObj.fire('fileProgress', $, message) // it's at least progress
+            if (_error) return;
+            $.resumableObj.fire('fileProgress', $, message); // it's at least progress
             if ($.isComplete()) {
-              $.resumableObj.fire('fileSuccess', $, message)
+              $.resumableObj.fire('fileSuccess', $, message);
             }
-            break
+            break;
           case 'retry':
-            $.resumableObj.fire('fileRetry', $)
-            break
+            $.resumableObj.fire('fileRetry', $);
+            break;
         }
-      }
+      };
 
       // Main code to set up a file object with chunks,
       // packaged to be able to handle retries if needed.
-      $.chunks = []
+      $.chunks = [];
       $.abort = function () {
         // Stop current uploads
-        let abortCount = 0
+        let abortCount = 0;
         $h.each($.chunks, function (c) {
           if (c.status() == 'uploading') {
-            c.abort()
-            abortCount++
+            c.abort();
+            abortCount++;
           }
-        })
-        if (abortCount > 0) $.resumableObj.fire('fileProgress', $)
-      }
+        });
+        if (abortCount > 0) $.resumableObj.fire('fileProgress', $);
+      };
       $.cancel = function () {
         // Reset this file to be void
-        const _chunks = $.chunks
-        $.chunks = []
+        const _chunks = $.chunks;
+        $.chunks = [];
         // Stop current uploads
         $h.each(_chunks, function (c) {
           if (c.status() == 'uploading') {
-            c.abort()
-            $.resumableObj.uploadNextChunk()
+            c.abort();
+            $.resumableObj.uploadNextChunk();
           }
-        })
-        $.resumableObj.removeFile($)
-        $.resumableObj.fire('fileProgress', $)
-      }
+        });
+        $.resumableObj.removeFile($);
+        $.resumableObj.fire('fileProgress', $);
+      };
       $.retry = function () {
-        $.bootstrap()
-        let firedRetry = false
+        $.bootstrap();
+        let firedRetry = false;
         $.resumableObj.on('chunkingComplete', function () {
-          if (!firedRetry) $.resumableObj.upload()
-          firedRetry = true
-        })
-      }
+          if (!firedRetry) $.resumableObj.upload();
+          firedRetry = true;
+        });
+      };
       $.bootstrap = function () {
-        $.abort()
-        _error = false
+        $.abort();
+        _error = false;
         // Rebuild stack of chunks from file
-        $.chunks = []
-        $._prevProgress = 0
-        const round = $.getOpt('forceChunkSize') ? Math.ceil : Math.floor
-        const maxOffset = Math.max(round($.file.size / $.getOpt('chunkSize')), 1)
+        $.chunks = [];
+        $._prevProgress = 0;
+        const round = $.getOpt('forceChunkSize') ? Math.ceil : Math.floor;
+        const maxOffset = Math.max(round($.file.size / $.getOpt('chunkSize')), 1);
         for (let offset = 0; offset < maxOffset; offset++) {
           (function (offset) {
             window.setTimeout(function () {
-              $.chunks.push(
-                new ResumableChunk($.resumableObj, $, offset, chunkEvent)
-              )
-              $.resumableObj.fire('chunkingProgress', $, offset / maxOffset)
-            }, 0)
-          })(offset)
+              $.chunks.push(new ResumableChunk($.resumableObj, $, offset, chunkEvent));
+              $.resumableObj.fire('chunkingProgress', $, offset / maxOffset);
+            }, 0);
+          })(offset);
         }
         window.setTimeout(function () {
-          $.resumableObj.fire('chunkingComplete', $)
-        }, 0)
-      }
+          $.resumableObj.fire('chunkingComplete', $);
+        }, 0);
+      };
       $.progress = function () {
-        if (_error) return 1
+        if (_error) return 1;
         // Sum up progress across everything
-        let ret = 0
-        let error = false
+        let ret = 0;
+        let error = false;
         $h.each($.chunks, function (c) {
-          if (c.status() == 'error') error = true
-          ret += c.progress(true) // get chunk progress relative to entire file
-        })
-        ret = error ? 1 : ret > 0.99999 ? 1 : ret
-        ret = Math.max($._prevProgress, ret) // We don't want to lose percentages when an upload is paused
-        $._prevProgress = ret
-        return ret
-      }
+          if (c.status() == 'error') error = true;
+          ret += c.progress(true); // get chunk progress relative to entire file
+        });
+        ret = error ? 1 : ret > 0.99999 ? 1 : ret;
+        ret = Math.max($._prevProgress, ret); // We don't want to lose percentages when an upload is paused
+        $._prevProgress = ret;
+        return ret;
+      };
       $.isUploading = function () {
-        let uploading = false
+        let uploading = false;
         $h.each($.chunks, function (chunk) {
           if (chunk.status() == 'uploading') {
-            uploading = true
-            return false
+            uploading = true;
+            return false;
           }
-        })
-        return uploading
-      }
+        });
+        return uploading;
+      };
       $.isComplete = function () {
-        let outstanding = false
+        let outstanding = false;
         if ($.preprocessState === 1) {
-          return false
+          return false;
         }
         $h.each($.chunks, function (chunk) {
-          const status = chunk.status()
-          if (
-            status == 'pending' ||
-                        status == 'uploading' ||
-                        chunk.preprocessState === 1
-          ) {
-            outstanding = true
-            return false
+          const status = chunk.status();
+          if (status == 'pending' || status == 'uploading' || chunk.preprocessState === 1) {
+            outstanding = true;
+            return false;
           }
-        })
-        return !outstanding
-      }
+        });
+        return !outstanding;
+      };
       $.pause = function (pause) {
         if (typeof pause === 'undefined') {
-          $._pause = !$._pause
+          $._pause = !$._pause;
         } else {
-          $._pause = pause
+          $._pause = pause;
         }
-      }
+      };
       $.isPaused = function () {
-        return $._pause
-      }
+        return $._pause;
+      };
       $.preprocessFinished = function () {
-        $.preprocessState = 2
-        $.upload()
-      }
+        $.preprocessState = 2;
+        $.upload();
+      };
       $.upload = function () {
-        let found = false
+        let found = false;
         if ($.isPaused() === false) {
-          const preprocess = $.getOpt('preprocessFile')
+          const preprocess = $.getOpt('preprocessFile');
           if (typeof preprocess === 'function') {
             switch ($.preprocessState) {
               case 0:
-                $.preprocessState = 1
-                preprocess($)
-                return true
+                $.preprocessState = 1;
+                preprocess($);
+                return true;
               case 1:
-                return true
+                return true;
               case 2:
-                break
+                break;
             }
           }
           $h.each($.chunks, function (chunk) {
             if (chunk.status() == 'pending' && chunk.preprocessState !== 1) {
-              chunk.send()
-              found = true
-              return false
+              chunk.send();
+              found = true;
+              return false;
             }
-          })
+          });
         }
-        return found
-      }
+        return found;
+      };
       $.markChunksCompleted = function (chunkNumber) {
         if (!$.chunks || $.chunks.length <= chunkNumber) {
-          return
+          return;
         }
         for (let num = 0; num < chunkNumber; num++) {
-          $.chunks[num].markComplete = true
+          $.chunks[num].markComplete = true;
         }
-      }
+      };
 
       // Bootstrap and return
-      $.resumableObj.fire('chunkingStart', $)
-      $.bootstrap()
-      return this
+      $.resumableObj.fire('chunkingStart', $);
+      $.bootstrap();
+      return this;
     }
 
-    function ResumableChunk (resumableObj, fileObj, offset, callback) {
-      const $ = this
-      $.opts = {}
-      $.getOpt = resumableObj.getOpt
-      $.resumableObj = resumableObj
-      $.fileObj = fileObj
-      $.fileObjSize = fileObj.size
-      $.fileObjType = fileObj.file.type
-      $.offset = offset
-      $.callback = callback
-      $.lastProgressCallback = new Date()
-      $.tested = false
-      $.retries = 0
-      $.pendingRetry = false
-      $.preprocessState = 0 // 0 = unprocessed, 1 = processing, 2 = finished
-      $.markComplete = false
+    function ResumableChunk(resumableObj, fileObj, offset, callback) {
+      const $ = this;
+      $.opts = {};
+      $.getOpt = resumableObj.getOpt;
+      $.resumableObj = resumableObj;
+      $.fileObj = fileObj;
+      $.fileObjSize = fileObj.size;
+      $.fileObjType = fileObj.file.type;
+      $.offset = offset;
+      $.callback = callback;
+      $.lastProgressCallback = new Date();
+      $.tested = false;
+      $.retries = 0;
+      $.pendingRetry = false;
+      $.preprocessState = 0; // 0 = unprocessed, 1 = processing, 2 = finished
+      $.markComplete = false;
 
       // Computed properties
-      const chunkSize = $.getOpt('chunkSize')
-      $.loaded = 0
-      $.startByte = $.offset * chunkSize
-      $.endByte = Math.min($.fileObjSize, ($.offset + 1) * chunkSize)
+      const chunkSize = $.getOpt('chunkSize');
+      $.loaded = 0;
+      $.startByte = $.offset * chunkSize;
+      $.endByte = Math.min($.fileObjSize, ($.offset + 1) * chunkSize);
       if ($.fileObjSize - $.endByte < chunkSize && !$.getOpt('forceChunkSize')) {
         // The last chunk will be bigger than the chunk size, but less than 2*chunkSize
-        $.endByte = $.fileObjSize
+        $.endByte = $.fileObjSize;
       }
-      $.xhr = null
+      $.xhr = null;
 
       // test() makes a GET request without any data to see if the chunk has already been uploaded in a previous session
       $.test = function () {
         // Set up request and listen for event
-        $.xhr = new XMLHttpRequest()
+        $.xhr = new XMLHttpRequest();
 
         const testHandler = function (e) {
-          $.tested = true
-          const status = $.status()
+          $.tested = true;
+          const status = $.status();
           if (status == 'success') {
-            $.callback(status, $.message())
-            $.resumableObj.uploadNextChunk()
+            $.callback(status, $.message());
+            $.resumableObj.uploadNextChunk();
           } else {
-            $.send()
+            $.send();
           }
-        }
-        $.xhr.addEventListener('load', testHandler, false)
-        $.xhr.addEventListener('error', testHandler, false)
-        $.xhr.addEventListener('timeout', testHandler, false)
+        };
+        $.xhr.addEventListener('load', testHandler, false);
+        $.xhr.addEventListener('error', testHandler, false);
+        $.xhr.addEventListener('timeout', testHandler, false);
 
         // Add data from the query options
-        let params = []
-        const parameterNamespace = $.getOpt('parameterNamespace')
-        let customQuery = $.getOpt('query')
-        if (typeof customQuery === 'function') customQuery = customQuery($.fileObj, $)
+        let params = [];
+        const parameterNamespace = $.getOpt('parameterNamespace');
+        let customQuery = $.getOpt('query');
+        if (typeof customQuery === 'function') customQuery = customQuery($.fileObj, $);
         $h.each(customQuery, function (k, v) {
-          params.push(
-            [encodeURIComponent(parameterNamespace + k), encodeURIComponent(v)].join(
-              '='
-            )
-          )
-        })
+          params.push([encodeURIComponent(parameterNamespace + k), encodeURIComponent(v)].join('='));
+        });
         // Add extra data to identify chunk
         params = params.concat(
           [
@@ -795,105 +764,99 @@ const XMLHttpRequest = require('xhr2').XMLHttpRequest;
             ['identifierParameterName', $.fileObj.uniqueIdentifier],
             ['fileNameParameterName', $.fileObj.fileName],
             ['relativePathParameterName', $.fileObj.relativePath],
-            ['totalChunksParameterName', $.fileObj.chunks.length]
+            ['totalChunksParameterName', $.fileObj.chunks.length],
           ]
             .filter(function (pair) {
               // include items that resolve to truthy values
               // i.e. exclude false, null, undefined and empty strings
-              return $.getOpt(pair[0])
+              return $.getOpt(pair[0]);
             })
             .map(function (pair) {
               // map each key/value pair to its final form
-              return [
-                parameterNamespace + $.getOpt(pair[0]),
-                encodeURIComponent(pair[1])
-              ].join('=')
-            })
-        )
+              return [parameterNamespace + $.getOpt(pair[0]), encodeURIComponent(pair[1])].join('=');
+            }),
+        );
         // Append the relevant chunk and send it
-        $.xhr.open($.getOpt('testMethod'), $h.getTarget('test', params))
-        $.xhr.timeout = $.getOpt('xhrTimeout')
-        $.xhr.withCredentials = $.getOpt('withCredentials')
+        $.xhr.open($.getOpt('testMethod'), $h.getTarget('test', params));
+        $.xhr.timeout = $.getOpt('xhrTimeout');
+        $.xhr.withCredentials = $.getOpt('withCredentials');
         // Add data from header options
-        let customHeaders = $.getOpt('headers')
+        let customHeaders = $.getOpt('headers');
         if (typeof customHeaders === 'function') {
-          customHeaders = customHeaders($.fileObj, $)
+          customHeaders = customHeaders($.fileObj, $);
         }
         $h.each(customHeaders, function (k, v) {
-          $.xhr.setRequestHeader(k, v)
-        })
-        $.xhr.send(null)
-      }
+          $.xhr.setRequestHeader(k, v);
+        });
+        $.xhr.send(null);
+      };
 
       $.preprocessFinished = function () {
-        $.preprocessState = 2
-        $.send()
-      }
+        $.preprocessState = 2;
+        $.send();
+      };
 
       // send() uploads the actual data in a POST call
       $.send = function () {
-        const preprocess = $.getOpt('preprocess')
+        const preprocess = $.getOpt('preprocess');
         if (typeof preprocess === 'function') {
           switch ($.preprocessState) {
             case 0:
-              $.preprocessState = 1
-              preprocess($)
-              return
+              $.preprocessState = 1;
+              preprocess($);
+              return;
             case 1:
-              return
+              return;
             case 2:
-              break
+              break;
           }
         }
         if ($.getOpt('testChunks') && !$.tested) {
-          $.test()
-          return
+          $.test();
+          return;
         }
 
         // Set up request and listen for event
-        $.xhr = new XMLHttpRequest()
+        $.xhr = new XMLHttpRequest();
 
         // Progress
         $.xhr.upload.addEventListener(
           'progress',
           function (e) {
-            if (
-              new Date() - $.lastProgressCallback >
-                            $.getOpt('throttleProgressCallbacks') * 1000
-            ) {
-              $.callback('progress')
-              $.lastProgressCallback = new Date()
+            if (new Date() - $.lastProgressCallback > $.getOpt('throttleProgressCallbacks') * 1000) {
+              $.callback('progress');
+              $.lastProgressCallback = new Date();
             }
-            $.loaded = e.loaded || 0
+            $.loaded = e.loaded || 0;
           },
-          false
-        )
-        $.loaded = 0
-        $.pendingRetry = false
-        $.callback('progress')
+          false,
+        );
+        $.loaded = 0;
+        $.pendingRetry = false;
+        $.callback('progress');
 
         // Done (either done, failed or retry)
         const doneHandler = function (e) {
-          const status = $.status()
+          const status = $.status();
           if (status == 'success' || status == 'error') {
-            $.callback(status, $.message())
-            $.resumableObj.uploadNextChunk()
+            $.callback(status, $.message());
+            $.resumableObj.uploadNextChunk();
           } else {
-            $.callback('retry', $.message())
-            $.abort()
-            $.retries++
-            const retryInterval = $.getOpt('chunkRetryInterval')
+            $.callback('retry', $.message());
+            $.abort();
+            $.retries++;
+            const retryInterval = $.getOpt('chunkRetryInterval');
             if (retryInterval !== undefined) {
-              $.pendingRetry = true
-              setTimeout($.send, retryInterval)
+              $.pendingRetry = true;
+              setTimeout($.send, retryInterval);
             } else {
-              $.send()
+              $.send();
             }
           }
-        }
-        $.xhr.addEventListener('load', doneHandler, false)
-        $.xhr.addEventListener('error', doneHandler, false)
-        $.xhr.addEventListener('timeout', doneHandler, false)
+        };
+        $.xhr.addEventListener('load', doneHandler, false);
+        $.xhr.addEventListener('error', doneHandler, false);
+        $.xhr.addEventListener('timeout', doneHandler, false);
 
         // Set up the basic query data from Resumable
         const query = [
@@ -905,24 +868,24 @@ const XMLHttpRequest = require('xhr2').XMLHttpRequest;
           ['identifierParameterName', $.fileObj.uniqueIdentifier],
           ['fileNameParameterName', $.fileObj.fileName],
           ['relativePathParameterName', $.fileObj.relativePath],
-          ['totalChunksParameterName', $.fileObj.chunks.length]
+          ['totalChunksParameterName', $.fileObj.chunks.length],
         ]
           .filter(function (pair) {
             // include items that resolve to truthy values
             // i.e. exclude false, null, undefined and empty strings
-            return $.getOpt(pair[0])
+            return $.getOpt(pair[0]);
           })
           .reduce(function (query, pair) {
             // assign query key/value
-            query[$.getOpt(pair[0])] = pair[1]
-            return query
-          }, {})
+            query[$.getOpt(pair[0])] = pair[1];
+            return query;
+          }, {});
         // Mix in custom data
-        let customQuery = $.getOpt('query')
-        if (typeof customQuery === 'function') customQuery = customQuery($.fileObj, $)
+        let customQuery = $.getOpt('query');
+        if (typeof customQuery === 'function') customQuery = customQuery($.fileObj, $);
         $h.each(customQuery, function (k, v) {
-          query[k] = v
-        })
+          query[k] = v;
+        });
 
         const func = $.fileObj.file.slice
           ? 'slice'
@@ -930,385 +893,364 @@ const XMLHttpRequest = require('xhr2').XMLHttpRequest;
             ? 'mozSlice'
             : $.fileObj.file.webkitSlice
               ? 'webkitSlice'
-              : 'slice'
+              : 'slice';
         const bytes = $.fileObj.file[func](
           $.startByte,
           $.endByte,
-          $.getOpt('setChunkTypeFromFile') ? $.fileObj.file.type : ''
-        )
-        let data = null
-        const params = []
+          $.getOpt('setChunkTypeFromFile') ? $.fileObj.file.type : '',
+        );
+        let data = null;
+        const params = [];
 
-        const parameterNamespace = $.getOpt('parameterNamespace')
+        const parameterNamespace = $.getOpt('parameterNamespace');
         if ($.getOpt('method') === 'octet') {
           // Add data from the query options
-          data = bytes
+          data = bytes;
           $h.each(query, function (k, v) {
-            params.push(
-              [
-                encodeURIComponent(parameterNamespace + k),
-                encodeURIComponent(v)
-              ].join('=')
-            )
-          })
+            params.push([encodeURIComponent(parameterNamespace + k), encodeURIComponent(v)].join('='));
+          });
         } else {
           // Add data from the query options
-          data = new FormData()
+          data = new FormData();
           $h.each(query, function (k, v) {
-            data.append(parameterNamespace + k, v)
-            params.push(
-              [
-                encodeURIComponent(parameterNamespace + k),
-                encodeURIComponent(v)
-              ].join('=')
-            )
-          })
+            data.append(parameterNamespace + k, v);
+            params.push([encodeURIComponent(parameterNamespace + k), encodeURIComponent(v)].join('='));
+          });
           if ($.getOpt('chunkFormat') == 'blob') {
-            data.append(
-              parameterNamespace + $.getOpt('fileParameterName'),
-              bytes,
-              $.fileObj.fileName
-            )
+            data.append(parameterNamespace + $.getOpt('fileParameterName'), bytes, $.fileObj.fileName);
           } else if ($.getOpt('chunkFormat') == 'base64') {
-            const fr = new FileReader()
+            const fr = new FileReader();
             fr.onload = function (e) {
-              data.append(
-                parameterNamespace + $.getOpt('fileParameterName'),
-                fr.result
-              )
-              $.xhr.send(data)
-            }
-            fr.readAsDataURL(bytes)
+              data.append(parameterNamespace + $.getOpt('fileParameterName'), fr.result);
+              $.xhr.send(data);
+            };
+            fr.readAsDataURL(bytes);
           }
         }
 
-        const target = $h.getTarget('upload', params)
-        const method = $.getOpt('uploadMethod')
+        const target = $h.getTarget('upload', params);
+        const method = $.getOpt('uploadMethod');
 
-        $.xhr.open(method, target)
+        $.xhr.open(method, target);
         if ($.getOpt('method') === 'octet') {
-          $.xhr.setRequestHeader('Content-Type', 'application/octet-stream')
+          $.xhr.setRequestHeader('Content-Type', 'application/octet-stream');
         }
-        $.xhr.timeout = $.getOpt('xhrTimeout')
-        $.xhr.withCredentials = $.getOpt('withCredentials')
+        $.xhr.timeout = $.getOpt('xhrTimeout');
+        $.xhr.withCredentials = $.getOpt('withCredentials');
         // Add data from header options
-        let customHeaders = $.getOpt('headers')
+        let customHeaders = $.getOpt('headers');
         if (typeof customHeaders === 'function') {
-          customHeaders = customHeaders($.fileObj, $)
+          customHeaders = customHeaders($.fileObj, $);
         }
 
         $h.each(customHeaders, function (k, v) {
-          $.xhr.setRequestHeader(k, v)
-        })
+          $.xhr.setRequestHeader(k, v);
+        });
 
         if ($.getOpt('chunkFormat') == 'blob') {
           if (data.on) {
-            const chunks = []
+            const chunks = [];
             data.on('data', (chunk) => {
-              chunks.push(chunk)
-            })
+              chunks.push(chunk);
+            });
             data.on('end', () => {
-              $.xhr.send(Buffer.concat(chunks))
-            })
+              $.xhr.send(Buffer.concat(chunks));
+            });
             data.on('error', (error) => {
-              doneHandler()
-            })
-          } else $.xhr.send(data)
+              doneHandler();
+            });
+          } else $.xhr.send(data);
         }
-      }
+      };
       $.abort = function () {
         // Abort and reset
-        if ($.xhr) $.xhr.abort()
-        $.xhr = null
-      }
+        if ($.xhr) $.xhr.abort();
+        $.xhr = null;
+      };
       $.status = function () {
         // Returns: 'pending', 'uploading', 'success', 'error'
         if ($.pendingRetry) {
           // if pending retry then that's effectively the same as actively uploading,
           // there might just be a slight delay before the retry starts
-          return 'uploading'
+          return 'uploading';
         } else if ($.markComplete) {
-          return 'success'
+          return 'success';
         } else if (!$.xhr) {
-          return 'pending'
+          return 'pending';
         } else if ($.xhr.readyState < 4) {
           // Status is really 'OPENED', 'HEADERS_RECEIVED' or 'LOADING' - meaning that stuff is happening
-          return 'uploading'
+          return 'uploading';
         } else {
           if ($.xhr.status == 200 || $.xhr.status == 201) {
             // HTTP 200, 201 (created)
-            return 'success'
+            return 'success';
           } else if (
             $h.contains($.getOpt('permanentErrors'), $.xhr.status) ||
-                        $.retries >= $.getOpt('maxChunkRetries')
+            $.retries >= $.getOpt('maxChunkRetries')
           ) {
             // HTTP 400, 404, 409, 415, 500, 501 (permanent error)
-            return 'error'
+            return 'error';
           } else {
             // this should never happen, but we'll reset and queue a retry
             // a likely case for this would be 503 service unavailable
-            $.abort()
-            return 'pending'
+            $.abort();
+            return 'pending';
           }
         }
-      }
+      };
       $.message = function () {
-        return $.xhr ? $.xhr.responseText : ''
-      }
+        return $.xhr ? $.xhr.responseText : '';
+      };
       $.progress = function (relative) {
-        if (typeof relative === 'undefined') relative = false
-        let factor = relative ? ($.endByte - $.startByte) / $.fileObjSize : 1
-        if ($.pendingRetry) return 0
-        if ((!$.xhr || !$.xhr.status) && !$.markComplete) factor *= 0.95
-        const s = $.status()
+        if (typeof relative === 'undefined') relative = false;
+        let factor = relative ? ($.endByte - $.startByte) / $.fileObjSize : 1;
+        if ($.pendingRetry) return 0;
+        if ((!$.xhr || !$.xhr.status) && !$.markComplete) factor *= 0.95;
+        const s = $.status();
         switch (s) {
           case 'success':
           case 'error':
-            return 1 * factor
+            return 1 * factor;
           case 'pending':
-            return 0 * factor
+            return 0 * factor;
           default:
-            return ($.loaded / ($.endByte - $.startByte)) * factor
+            return ($.loaded / ($.endByte - $.startByte)) * factor;
         }
-      }
-      return this
+      };
+      return this;
     }
 
     // QUEUE
     $.uploadNextChunk = function () {
-      let found = false
+      let found = false;
 
       // In some cases (such as videos) it's really handy to upload the first
       // and last chunk of a file quickly; this let's the server check the file's
       // metadata and determine if there's even a point in continuing.
       if ($.getOpt('prioritizeFirstAndLastChunk')) {
         $h.each($.files, function (file) {
-          if (
-            file.chunks.length &&
-                        file.chunks[0].status() == 'pending' &&
-                        file.chunks[0].preprocessState === 0
-          ) {
-            file.chunks[0].send()
-            found = true
-            return false
+          if (file.chunks.length && file.chunks[0].status() == 'pending' && file.chunks[0].preprocessState === 0) {
+            file.chunks[0].send();
+            found = true;
+            return false;
           }
           if (
             file.chunks.length > 1 &&
-                        file.chunks[file.chunks.length - 1].status() == 'pending' &&
-                        file.chunks[file.chunks.length - 1].preprocessState === 0
+            file.chunks[file.chunks.length - 1].status() == 'pending' &&
+            file.chunks[file.chunks.length - 1].preprocessState === 0
           ) {
-            file.chunks[file.chunks.length - 1].send()
-            found = true
-            return false
+            file.chunks[file.chunks.length - 1].send();
+            found = true;
+            return false;
           }
-        })
-        if (found) return true
+        });
+        if (found) return true;
       }
 
       // Now, simply look for the next, best thing to upload
       $h.each($.files, function (file) {
-        found = file.upload()
-        if (found) return false
-      })
-      if (found) return true
+        found = file.upload();
+        if (found) return false;
+      });
+      if (found) return true;
 
       // The are no more outstanding chunks to upload, check is everything is done
-      let outstanding = false
+      let outstanding = false;
       $h.each($.files, function (file) {
         if (!file.isComplete()) {
-          outstanding = true
-          return false
+          outstanding = true;
+          return false;
         }
-      })
+      });
       if (!outstanding) {
         // All chunks have been uploaded, complete
-        $.fire('complete')
+        $.fire('complete');
       }
-      return false
-    }
+      return false;
+    };
 
     // PUBLIC METHODS FOR RESUMABLE.JS
     $.assignBrowse = function (domNodes, isDirectory) {
-      if (typeof domNodes.length === 'undefined') domNodes = [domNodes]
+      if (typeof domNodes.length === 'undefined') domNodes = [domNodes];
       $h.each(domNodes, function (domNode) {
-        let input
+        let input;
         if (domNode.tagName === 'INPUT' && domNode.type === 'file') {
-          input = domNode
+          input = domNode;
         } else {
-          input = document.createElement('input')
-          input.setAttribute('type', 'file')
-          input.style.display = 'none'
+          input = document.createElement('input');
+          input.setAttribute('type', 'file');
+          input.style.display = 'none';
           domNode.addEventListener(
             'click',
             function () {
-              input.style.opacity = 0
-              input.style.display = 'block'
-              input.focus()
-              input.click()
-              input.style.display = 'none'
+              input.style.opacity = 0;
+              input.style.display = 'block';
+              input.focus();
+              input.click();
+              input.style.display = 'none';
             },
-            false
-          )
-          domNode.appendChild(input)
+            false,
+          );
+          domNode.appendChild(input);
         }
-        const maxFiles = $.getOpt('maxFiles')
+        const maxFiles = $.getOpt('maxFiles');
         if (typeof maxFiles === 'undefined' || maxFiles != 1) {
-          input.setAttribute('multiple', 'multiple')
+          input.setAttribute('multiple', 'multiple');
         } else {
-          input.removeAttribute('multiple')
+          input.removeAttribute('multiple');
         }
         if (isDirectory) {
-          input.setAttribute('webkitdirectory', 'webkitdirectory')
+          input.setAttribute('webkitdirectory', 'webkitdirectory');
         } else {
-          input.removeAttribute('webkitdirectory')
+          input.removeAttribute('webkitdirectory');
         }
-        const fileTypes = $.getOpt('fileType')
+        const fileTypes = $.getOpt('fileType');
         if (typeof fileTypes !== 'undefined' && fileTypes.length >= 1) {
           input.setAttribute(
             'accept',
             fileTypes
               .map(function (e) {
-                e = e.replace(/\s/g, '').toLowerCase()
+                e = e.replace(/\s/g, '').toLowerCase();
                 if (e.match(/^[^.][^/]+$/)) {
-                  e = '.' + e
+                  e = '.' + e;
                 }
-                return e
+                return e;
               })
-              .join(',')
-          )
+              .join(','),
+          );
         } else {
-          input.removeAttribute('accept')
+          input.removeAttribute('accept');
         }
         // When new files are added, simply append them to the overall list
         input.addEventListener(
           'change',
           function (e) {
-            appendFilesFromFileList(e.target.files, e)
-            const clearInput = $.getOpt('clearInput')
+            appendFilesFromFileList(e.target.files, e);
+            const clearInput = $.getOpt('clearInput');
             if (clearInput) {
-              e.target.value = ''
+              e.target.value = '';
             }
           },
-          false
-        )
-      })
-    }
+          false,
+        );
+      });
+    };
     $.assignDrop = function (domNodes) {
-      if (typeof domNodes.length === 'undefined') domNodes = [domNodes]
+      if (typeof domNodes.length === 'undefined') domNodes = [domNodes];
 
       $h.each(domNodes, function (domNode) {
-        domNode.addEventListener('dragover', onDragOverEnter, false)
-        domNode.addEventListener('dragenter', onDragOverEnter, false)
-        domNode.addEventListener('dragleave', onDragLeave, false)
-        domNode.addEventListener('drop', onDrop, false)
-      })
-    }
+        domNode.addEventListener('dragover', onDragOverEnter, false);
+        domNode.addEventListener('dragenter', onDragOverEnter, false);
+        domNode.addEventListener('dragleave', onDragLeave, false);
+        domNode.addEventListener('drop', onDrop, false);
+      });
+    };
     $.unAssignDrop = function (domNodes) {
-      if (typeof domNodes.length === 'undefined') domNodes = [domNodes]
+      if (typeof domNodes.length === 'undefined') domNodes = [domNodes];
 
       $h.each(domNodes, function (domNode) {
-        domNode.removeEventListener('dragover', onDragOverEnter)
-        domNode.removeEventListener('dragenter', onDragOverEnter)
-        domNode.removeEventListener('dragleave', onDragLeave)
-        domNode.removeEventListener('drop', onDrop)
-      })
-    }
+        domNode.removeEventListener('dragover', onDragOverEnter);
+        domNode.removeEventListener('dragenter', onDragOverEnter);
+        domNode.removeEventListener('dragleave', onDragLeave);
+        domNode.removeEventListener('drop', onDrop);
+      });
+    };
     $.isUploading = function () {
-      let uploading = false
+      let uploading = false;
       $h.each($.files, function (file) {
         if (file.isUploading()) {
-          uploading = true
-          return false
+          uploading = true;
+          return false;
         }
-      })
-      return uploading
-    }
+      });
+      return uploading;
+    };
     $.upload = function () {
       // Make sure we don't start too many uploads at once
-      if ($.isUploading()) return
+      if ($.isUploading()) return;
       // Kick off the queue
-      $.fire('uploadStart')
+      $.fire('uploadStart');
       for (let num = 1; num <= $.getOpt('simultaneousUploads'); num++) {
-        $.uploadNextChunk()
+        $.uploadNextChunk();
       }
-    }
+    };
     $.pause = function () {
       // Resume all chunks currently being uploaded
       $h.each($.files, function (file) {
-        file.abort()
-      })
-      $.fire('pause')
-    }
+        file.abort();
+      });
+      $.fire('pause');
+    };
     $.cancel = function () {
-      $.fire('beforeCancel')
+      $.fire('beforeCancel');
       for (let i = $.files.length - 1; i >= 0; i--) {
-        $.files[i].cancel()
+        $.files[i].cancel();
       }
-      $.fire('cancel')
-    }
+      $.fire('cancel');
+    };
     $.progress = function () {
-      let totalDone = 0
-      let totalSize = 0
+      let totalDone = 0;
+      let totalSize = 0;
       // Resume all chunks currently being uploaded
       $h.each($.files, function (file) {
-        totalDone += file.progress() * file.size
-        totalSize += file.size
-      })
-      return totalSize > 0 ? totalDone / totalSize : 0
-    }
+        totalDone += file.progress() * file.size;
+        totalSize += file.size;
+      });
+      return totalSize > 0 ? totalDone / totalSize : 0;
+    };
     $.addFile = function (file, event) {
-      appendFilesFromFileList([file], event)
-    }
+      appendFilesFromFileList([file], event);
+    };
     $.addFiles = function (files, event) {
-      appendFilesFromFileList(files, event)
-    }
+      appendFilesFromFileList(files, event);
+    };
     $.removeFile = function (file) {
       for (let i = $.files.length - 1; i >= 0; i--) {
         if ($.files[i] === file) {
-          $.files.splice(i, 1)
+          $.files.splice(i, 1);
         }
       }
-    }
+    };
     $.getFromUniqueIdentifier = function (uniqueIdentifier) {
-      let ret = false
+      let ret = false;
       $h.each($.files, function (f) {
-        if (f.uniqueIdentifier == uniqueIdentifier) ret = f
-      })
-      return ret
-    }
+        if (f.uniqueIdentifier == uniqueIdentifier) ret = f;
+      });
+      return ret;
+    };
     $.getSize = function () {
-      let totalSize = 0
+      let totalSize = 0;
       $h.each($.files, function (file) {
-        totalSize += file.size
-      })
-      return totalSize
-    }
+        totalSize += file.size;
+      });
+      return totalSize;
+    };
     $.handleDropEvent = function (e) {
-      onDrop(e)
-    }
+      onDrop(e);
+    };
     $.handleChangeEvent = function (e) {
-      appendFilesFromFileList(e.target.files, e)
-      e.target.value = ''
-    }
+      appendFilesFromFileList(e.target.files, e);
+      e.target.value = '';
+    };
     $.updateQuery = function (query) {
-      $.opts.query = query
-    }
+      $.opts.query = query;
+    };
 
-    return this
-  }
+    return this;
+  };
 
   // Node.js-style export for Node and Component
   if (typeof module !== 'undefined') {
     // left here for backwards compatibility
-    module.exports = Resumable
-    module.exports.Resumable = Resumable
+    module.exports = Resumable;
+    module.exports.Resumable = Resumable;
   } else if (typeof define === 'function' && define.amd) {
     // AMD/requirejs: Define the module
     define(function () {
-      return Resumable
-    })
+      return Resumable;
+    });
   } else {
     // Browser: Expose to window
-    window.Resumable = Resumable
+    window.Resumable = Resumable;
   }
-})()
+})();