@corellium/corellium-cli 1.0.3 → 1.0.6

package/src/resumable.js

@@ -0,0 +1,1314 @@
+/*
+ * MIT Licensed
+ * http://www.23developer.com/opensource
+ * http://github.com/23/resumable.js
+ * Steffen Tiedemann Christensen, steffen@23company.com
+ */
+
+/* eslint-disable */
+
+const XMLHttpRequest = require('xhr2').XMLHttpRequest;
+
+(function () {
+  'use strict'
+
+  var Resumable = function (opts) {
+    if (!(this instanceof Resumable)) {
+      return new Resumable(opts)
+    }
+    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 }
+
+    // PROPERTIES
+    const $ = this
+    $.files = []
+    $.defaults = {
+      chunkSize: 1 * 1024 * 1024,
+      forceChunkSize: false,
+      simultaneousUploads: 3,
+      fileParameterName: 'file',
+      chunkNumberParameterName: 'resumableChunkNumber',
+      chunkSizeParameterName: 'resumableChunkSize',
+      currentChunkSizeParameterName: 'resumableCurrentChunkSize',
+      totalSizeParameterName: 'resumableTotalSize',
+      typeParameterName: 'resumableType',
+      identifierParameterName: 'resumableIdentifier',
+      fileNameParameterName: 'resumableFilename',
+      relativePathParameterName: 'resumableRelativePath',
+      totalChunksParameterName: 'resumableTotalChunks',
+      dragOverClass: 'dragover',
+      throttleProgressCallbacks: 0.5,
+      query: {},
+      headers: {},
+      preprocess: null,
+      preprocessFile: null,
+      method: 'multipart',
+      uploadMethod: 'POST',
+      testMethod: 'GET',
+      prioritizeFirstAndLastChunk: false,
+      target: '/',
+      testTarget: null,
+      parameterNamespace: '',
+      testChunks: true,
+      generateUniqueIdentifier: null,
+      getTarget: null,
+      maxChunkRetries: 100,
+      chunkRetryInterval: undefined,
+      permanentErrors: [400, 401, 403, 404, 409, 415, 500, 501],
+      maxFiles: undefined,
+      withCredentials: false,
+      xhrTimeout: 0,
+      clearInput: true,
+      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.'
+        )
+      },
+      minFileSize: 1,
+      minFileSizeErrorCallback: function (file, errorCount) {
+        alert(
+          file.fileName ||
+                        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')) +
+                            '.'
+        )
+      },
+      fileType: [],
+      fileTypeErrorCallback: function (file, errorCount) {
+        alert(
+          file.fileName ||
+                        file.name +
+                            ' has type not allowed, please upload files of type ' +
+                            $.getOpt('fileType') +
+                            '.'
+        )
+      }
+    }
+    $.opts = opts || {}
+    $.getOpt = function (o) {
+      let $opt = this
+      // Get multiple option if passed an array
+      if (o instanceof Array) {
+        const options = {}
+        $h.each(o, function (option) {
+          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]
+        } else {
+          $opt = $opt.fileObj
+        }
+      }
+      if ($opt instanceof ResumableFile) {
+        if (typeof $opt.opts[o] !== 'undefined') {
+          return $opt.opts[o]
+        } else {
+          $opt = $opt.resumableObj
+        }
+      }
+      if ($opt instanceof Resumable) {
+        if (typeof $opt.opts[o] !== 'undefined') {
+          return $opt.opts[o]
+        } else {
+          return $opt.defaults[o]
+        }
+      }
+    }
+    $.indexOf = function (array, obj) {
+      if (array.indexOf) {
+        return array.indexOf(obj)
+      }
+      for (let i = 0; i < array.length; i++) {
+        if (array[i] === obj) {
+          return i
+        }
+      }
+      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 = []
+    $.on = function (event, 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])
+      // Find event listeners, and support pseudo-event `catchAll`
+      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 (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()
+      },
+      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
+          }
+        } else {
+          for (i in o) {
+            // Object
+            if (callback(i, o[i]) === false) return
+          }
+        }
+      },
+      generateUniqueIdentifier: function (file, event) {
+        const custom = $.getOpt('generateUniqueIdentifier')
+        if (typeof custom === 'function') {
+          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, '')
+      },
+      contains: function (array, test) {
+        let result = false
+
+        $h.each(array, function (value) {
+          if (value == test) {
+            result = true
+            return false
+          }
+          return true
+        })
+
+        return result
+      },
+      formatSize: function (size) {
+        if (size < 1024) {
+          return size + ' bytes'
+        } else if (size < 1024 * 1024) {
+          return (size / 1024.0).toFixed(0) + ' KB'
+        } else if (size < 1024 * 1024 * 1024) {
+          return (size / 1024.0 / 1024.0).toFixed(1) + ' MB'
+        } else {
+          return (size / 1024.0 / 1024.0 / 1024.0).toFixed(1) + ' GB'
+        }
+      },
+      getTarget: function (request, params) {
+        let target = $.getOpt('target')
+
+        if (request === 'test' && $.getOpt('testTarget')) {
+          target =
+                        $.getOpt('testTarget') === '/'
+                          ? $.getOpt('target')
+                          : $.getOpt('testTarget')
+        }
+
+        if (typeof target === 'function') {
+          return target(params)
+        }
+
+        const separator = target.indexOf('?') < 0 ? '?' : '&'
+        const joinedParams = params.join('&')
+
+        if (joinedParams) target = target + separator + joinedParams
+
+        return target
+      }
+    }
+
+    const onDrop = function (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)
+      }
+      // else handle them as files
+      else if (e.dataTransfer && e.dataTransfer.files) {
+        loadFiles(e.dataTransfer.files, e)
+      }
+    }
+    const onDragLeave = function (e) {
+      e.currentTarget.classList.remove($.getOpt('dragOverClass'))
+    }
+    const onDragOverEnter = function (e) {
+      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'))
+      } else {
+        // not work on IE/Edge....
+        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
+      if (item.isFile) {
+        // file provided
+        return item.file(function (file) {
+          file.relativePath = path + file.name
+          items.push(file)
+          cb()
+        })
+      } else if (item.isDirectory) {
+        // item is already a directory entry, just assign
+        entry = item
+      } else if (item instanceof File) {
+        items.push(item)
+      }
+      if (typeof item.webkitGetAsEntry === 'function') {
+        // get entry from file object
+        entry = item.webkitGetAsEntry()
+      }
+      if (entry && entry.isDirectory) {
+        // directory provided, process it
+        return processDirectory(entry, path + entry.name + '/', items, cb)
+      }
+      if (typeof item.getAsFile === 'function') {
+        // item represents a File object, convert it
+        item = item.getAsFile()
+        if (item instanceof File) {
+          item.relativePath = path + item.name
+          items.push(item)
+        }
+      }
+      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) {
+      if (!items || items.length === 0) {
+        // empty or no list, invoke callback
+        return cb()
+      }
+      // invoke current function, pass the next part as continuation
+      items[0](function () {
+        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 = []
+
+      function readEntries () {
+        dirReader.readEntries(function (entries) {
+          if (entries.length) {
+            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)
+            }),
+            cb
+          )
+        })
+      }
+
+      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) {
+      if (!items.length) {
+        return // nothing to do
+      }
+      $.fire('beforeAdd')
+      const files = []
+      processCallbacks(
+        Array.prototype.map.call(items, function (item) {
+          // bind all properties except for callback
+          let entry = item
+          if (typeof item.webkitGetAsEntry === 'function') {
+            entry = item.webkitGetAsEntry()
+          }
+          return processItem.bind(null, entry, '', files)
+        }),
+        function () {
+          if (files.length) {
+            // at least one file found
+            appendFilesFromFileList(files, event)
+          }
+        }
+      )
+    }
+
+    var appendFilesFromFileList = function (fileList, event) {
+      // check for uploading too many files
+      let errorCount = 0
+      const o = $.getOpt([
+        'maxFiles',
+        'minFileSize',
+        'maxFileSize',
+        'maxFilesErrorCallback',
+        'minFileSizeErrorCallback',
+        'maxFileSizeErrorCallback',
+        'fileType',
+        '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])
+        } else {
+          o.maxFilesErrorCallback(fileList, errorCount++)
+          return false
+        }
+      }
+      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
+          }
+          window.setTimeout(function () {
+            $.fire('filesAdded', files, filesSkipped)
+          }, 0)
+        }
+      }
+      $h.each(fileList, function (file) {
+        const fileName = file.name
+        const fileType = file.type // e.g video/mp4
+        if (o.fileType.length > 0) {
+          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()
+
+            // Allowing for both [extension, .extension, mime/type, mime/*]
+            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))
+            ) {
+              fileTypeFound = true
+              break
+            }
+          }
+          if (!fileTypeFound) {
+            o.fileTypeErrorCallback(file, errorCount++)
+            return true
+          }
+        }
+
+        if (typeof o.minFileSize !== 'undefined' && file.size < o.minFileSize) {
+          o.minFileSizeErrorCallback(file, errorCount++)
+          return true
+        }
+        if (typeof o.maxFileSize !== 'undefined' && file.size > o.maxFileSize) {
+          o.maxFileSizeErrorCallback(file, errorCount++)
+          return true
+        }
+
+        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
+              window.setTimeout(function () {
+                $.fire('fileAdded', f, event)
+              }, 0)
+            })()
+          } else {
+            filesSkipped.push(file)
+          }
+          decreaseReamining()
+        }
+        // directories have size == 0
+        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)
+            },
+            function () {
+              // unique identifier generation failed
+              // skip further processing, only decrease file count
+              decreaseReamining()
+            }
+          )
+        } else {
+          // non-Promise provided as unique identifier, process synchronously
+          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
+
+      // 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
+          case 'error':
+            $.abort()
+            _error = true
+            $.chunks = []
+            $.resumableObj.fire('fileError', $, message)
+            break
+          case 'success':
+            if (_error) return
+            $.resumableObj.fire('fileProgress', $, message) // it's at least progress
+            if ($.isComplete()) {
+              $.resumableObj.fire('fileSuccess', $, message)
+            }
+            break
+          case 'retry':
+            $.resumableObj.fire('fileRetry', $)
+            break
+        }
+      }
+
+      // Main code to set up a file object with chunks,
+      // packaged to be able to handle retries if needed.
+      $.chunks = []
+      $.abort = function () {
+        // Stop current uploads
+        let abortCount = 0
+        $h.each($.chunks, function (c) {
+          if (c.status() == 'uploading') {
+            c.abort()
+            abortCount++
+          }
+        })
+        if (abortCount > 0) $.resumableObj.fire('fileProgress', $)
+      }
+      $.cancel = function () {
+        // Reset this file to be void
+        const _chunks = $.chunks
+        $.chunks = []
+        // Stop current uploads
+        $h.each(_chunks, function (c) {
+          if (c.status() == 'uploading') {
+            c.abort()
+            $.resumableObj.uploadNextChunk()
+          }
+        })
+        $.resumableObj.removeFile($)
+        $.resumableObj.fire('fileProgress', $)
+      }
+      $.retry = function () {
+        $.bootstrap()
+        let firedRetry = false
+        $.resumableObj.on('chunkingComplete', function () {
+          if (!firedRetry) $.resumableObj.upload()
+          firedRetry = true
+        })
+      }
+      $.bootstrap = function () {
+        $.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)
+        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)
+        }
+        window.setTimeout(function () {
+          $.resumableObj.fire('chunkingComplete', $)
+        }, 0)
+      }
+      $.progress = function () {
+        if (_error) return 1
+        // Sum up progress across everything
+        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
+      }
+      $.isUploading = function () {
+        let uploading = false
+        $h.each($.chunks, function (chunk) {
+          if (chunk.status() == 'uploading') {
+            uploading = true
+            return false
+          }
+        })
+        return uploading
+      }
+      $.isComplete = function () {
+        let outstanding = false
+        if ($.preprocessState === 1) {
+          return false
+        }
+        $h.each($.chunks, function (chunk) {
+          const status = chunk.status()
+          if (
+            status == 'pending' ||
+                        status == 'uploading' ||
+                        chunk.preprocessState === 1
+          ) {
+            outstanding = true
+            return false
+          }
+        })
+        return !outstanding
+      }
+      $.pause = function (pause) {
+        if (typeof pause === 'undefined') {
+          $._pause = !$._pause
+        } else {
+          $._pause = pause
+        }
+      }
+      $.isPaused = function () {
+        return $._pause
+      }
+      $.preprocessFinished = function () {
+        $.preprocessState = 2
+        $.upload()
+      }
+      $.upload = function () {
+        let found = false
+        if ($.isPaused() === false) {
+          const preprocess = $.getOpt('preprocessFile')
+          if (typeof preprocess === 'function') {
+            switch ($.preprocessState) {
+              case 0:
+                $.preprocessState = 1
+                preprocess($)
+                return true
+              case 1:
+                return true
+              case 2:
+                break
+            }
+          }
+          $h.each($.chunks, function (chunk) {
+            if (chunk.status() == 'pending' && chunk.preprocessState !== 1) {
+              chunk.send()
+              found = true
+              return false
+            }
+          })
+        }
+        return found
+      }
+      $.markChunksCompleted = function (chunkNumber) {
+        if (!$.chunks || $.chunks.length <= chunkNumber) {
+          return
+        }
+        for (let num = 0; num < chunkNumber; num++) {
+          $.chunks[num].markComplete = true
+        }
+      }
+
+      // Bootstrap and return
+      $.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
+
+      // Computed properties
+      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
+      }
+      $.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()
+
+        const testHandler = function (e) {
+          $.tested = true
+          const status = $.status()
+          if (status == 'success') {
+            $.callback(status, $.message())
+            $.resumableObj.uploadNextChunk()
+          } else {
+            $.send()
+          }
+        }
+        $.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, $)
+        $h.each(customQuery, function (k, v) {
+          params.push(
+            [encodeURIComponent(parameterNamespace + k), encodeURIComponent(v)].join(
+              '='
+            )
+          )
+        })
+        // Add extra data to identify chunk
+        params = params.concat(
+          [
+            // define key/value pairs for additional parameters
+            ['chunkNumberParameterName', $.offset + 1],
+            ['chunkSizeParameterName', $.getOpt('chunkSize')],
+            ['currentChunkSizeParameterName', $.endByte - $.startByte],
+            ['totalSizeParameterName', $.fileObjSize],
+            ['typeParameterName', $.fileObjType],
+            ['identifierParameterName', $.fileObj.uniqueIdentifier],
+            ['fileNameParameterName', $.fileObj.fileName],
+            ['relativePathParameterName', $.fileObj.relativePath],
+            ['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])
+            })
+            .map(function (pair) {
+              // map each key/value pair to its final form
+              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')
+        // Add data from header options
+        let customHeaders = $.getOpt('headers')
+        if (typeof customHeaders === 'function') {
+          customHeaders = customHeaders($.fileObj, $)
+        }
+        $h.each(customHeaders, function (k, v) {
+          $.xhr.setRequestHeader(k, v)
+        })
+        $.xhr.send(null)
+      }
+
+      $.preprocessFinished = function () {
+        $.preprocessState = 2
+        $.send()
+      }
+
+      // send() uploads the actual data in a POST call
+      $.send = function () {
+        const preprocess = $.getOpt('preprocess')
+        if (typeof preprocess === 'function') {
+          switch ($.preprocessState) {
+            case 0:
+              $.preprocessState = 1
+              preprocess($)
+              return
+            case 1:
+              return
+            case 2:
+              break
+          }
+        }
+        if ($.getOpt('testChunks') && !$.tested) {
+          $.test()
+          return
+        }
+
+        // Set up request and listen for event
+        $.xhr = new XMLHttpRequest()
+
+        // Progress
+        $.xhr.upload.addEventListener(
+          'progress',
+          function (e) {
+            if (
+              new Date() - $.lastProgressCallback >
+                            $.getOpt('throttleProgressCallbacks') * 1000
+            ) {
+              $.callback('progress')
+              $.lastProgressCallback = new Date()
+            }
+            $.loaded = e.loaded || 0
+          },
+          false
+        )
+        $.loaded = 0
+        $.pendingRetry = false
+        $.callback('progress')
+
+        // Done (either done, failed or retry)
+        const doneHandler = function (e) {
+          const status = $.status()
+          if (status == 'success' || status == 'error') {
+            $.callback(status, $.message())
+            $.resumableObj.uploadNextChunk()
+          } else {
+            $.callback('retry', $.message())
+            $.abort()
+            $.retries++
+            const retryInterval = $.getOpt('chunkRetryInterval')
+            if (retryInterval !== undefined) {
+              $.pendingRetry = true
+              setTimeout($.send, retryInterval)
+            } else {
+              $.send()
+            }
+          }
+        }
+        $.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 = [
+          ['chunkNumberParameterName', $.offset + 1],
+          ['chunkSizeParameterName', $.getOpt('chunkSize')],
+          ['currentChunkSizeParameterName', $.endByte - $.startByte],
+          ['totalSizeParameterName', $.fileObjSize],
+          ['typeParameterName', $.fileObjType],
+          ['identifierParameterName', $.fileObj.uniqueIdentifier],
+          ['fileNameParameterName', $.fileObj.fileName],
+          ['relativePathParameterName', $.fileObj.relativePath],
+          ['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])
+          })
+          .reduce(function (query, pair) {
+            // assign query key/value
+            query[$.getOpt(pair[0])] = pair[1]
+            return query
+          }, {})
+        // Mix in custom data
+        let customQuery = $.getOpt('query')
+        if (typeof customQuery === 'function') customQuery = customQuery($.fileObj, $)
+        $h.each(customQuery, function (k, v) {
+          query[k] = v
+        })
+
+        const func = $.fileObj.file.slice
+          ? 'slice'
+          : $.fileObj.file.mozSlice
+            ? 'mozSlice'
+            : $.fileObj.file.webkitSlice
+              ? 'webkitSlice'
+              : 'slice'
+        const bytes = $.fileObj.file[func](
+          $.startByte,
+          $.endByte,
+          $.getOpt('setChunkTypeFromFile') ? $.fileObj.file.type : ''
+        )
+        let data = null
+        const params = []
+
+        const parameterNamespace = $.getOpt('parameterNamespace')
+        if ($.getOpt('method') === 'octet') {
+          // Add data from the query options
+          data = bytes
+          $h.each(query, function (k, v) {
+            params.push(
+              [
+                encodeURIComponent(parameterNamespace + k),
+                encodeURIComponent(v)
+              ].join('=')
+            )
+          })
+        } else {
+          // Add data from the query options
+          data = new FormData()
+          $h.each(query, function (k, v) {
+            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
+            )
+          } else if ($.getOpt('chunkFormat') == 'base64') {
+            const fr = new FileReader()
+            fr.onload = function (e) {
+              data.append(
+                parameterNamespace + $.getOpt('fileParameterName'),
+                fr.result
+              )
+              $.xhr.send(data)
+            }
+            fr.readAsDataURL(bytes)
+          }
+        }
+
+        const target = $h.getTarget('upload', params)
+        const method = $.getOpt('uploadMethod')
+
+        $.xhr.open(method, target)
+        if ($.getOpt('method') === 'octet') {
+          $.xhr.setRequestHeader('Content-Type', 'application/octet-stream')
+        }
+        $.xhr.timeout = $.getOpt('xhrTimeout')
+        $.xhr.withCredentials = $.getOpt('withCredentials')
+        // Add data from header options
+        let customHeaders = $.getOpt('headers')
+        if (typeof customHeaders === 'function') {
+          customHeaders = customHeaders($.fileObj, $)
+        }
+
+        $h.each(customHeaders, function (k, v) {
+          $.xhr.setRequestHeader(k, v)
+        })
+
+        if ($.getOpt('chunkFormat') == 'blob') {
+          if (data.on) {
+            const chunks = []
+            data.on('data', (chunk) => {
+              chunks.push(chunk)
+            })
+            data.on('end', () => {
+              $.xhr.send(Buffer.concat(chunks))
+            })
+            data.on('error', (error) => {
+              doneHandler()
+            })
+          } else $.xhr.send(data)
+        }
+      }
+      $.abort = function () {
+        // Abort and reset
+        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'
+        } else if ($.markComplete) {
+          return 'success'
+        } else if (!$.xhr) {
+          return 'pending'
+        } else if ($.xhr.readyState < 4) {
+          // Status is really 'OPENED', 'HEADERS_RECEIVED' or 'LOADING' - meaning that stuff is happening
+          return 'uploading'
+        } else {
+          if ($.xhr.status == 200 || $.xhr.status == 201) {
+            // HTTP 200, 201 (created)
+            return 'success'
+          } else if (
+            $h.contains($.getOpt('permanentErrors'), $.xhr.status) ||
+                        $.retries >= $.getOpt('maxChunkRetries')
+          ) {
+            // HTTP 400, 404, 409, 415, 500, 501 (permanent 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'
+          }
+        }
+      }
+      $.message = function () {
+        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()
+        switch (s) {
+          case 'success':
+          case 'error':
+            return 1 * factor
+          case 'pending':
+            return 0 * factor
+          default:
+            return ($.loaded / ($.endByte - $.startByte)) * factor
+        }
+      }
+      return this
+    }
+
+    // QUEUE
+    $.uploadNextChunk = function () {
+      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 > 1 &&
+                        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
+          }
+        })
+        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
+
+      // The are no more outstanding chunks to upload, check is everything is done
+      let outstanding = false
+      $h.each($.files, function (file) {
+        if (!file.isComplete()) {
+          outstanding = true
+          return false
+        }
+      })
+      if (!outstanding) {
+        // All chunks have been uploaded, complete
+        $.fire('complete')
+      }
+      return false
+    }
+
+    // PUBLIC METHODS FOR RESUMABLE.JS
+    $.assignBrowse = function (domNodes, isDirectory) {
+      if (typeof domNodes.length === 'undefined') domNodes = [domNodes]
+      $h.each(domNodes, function (domNode) {
+        let input
+        if (domNode.tagName === 'INPUT' && domNode.type === 'file') {
+          input = domNode
+        } else {
+          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'
+            },
+            false
+          )
+          domNode.appendChild(input)
+        }
+        const maxFiles = $.getOpt('maxFiles')
+        if (typeof maxFiles === 'undefined' || maxFiles != 1) {
+          input.setAttribute('multiple', 'multiple')
+        } else {
+          input.removeAttribute('multiple')
+        }
+        if (isDirectory) {
+          input.setAttribute('webkitdirectory', 'webkitdirectory')
+        } else {
+          input.removeAttribute('webkitdirectory')
+        }
+        const fileTypes = $.getOpt('fileType')
+        if (typeof fileTypes !== 'undefined' && fileTypes.length >= 1) {
+          input.setAttribute(
+            'accept',
+            fileTypes
+              .map(function (e) {
+                e = e.replace(/\s/g, '').toLowerCase()
+                if (e.match(/^[^.][^/]+$/)) {
+                  e = '.' + e
+                }
+                return e
+              })
+              .join(',')
+          )
+        } else {
+          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')
+            if (clearInput) {
+              e.target.value = ''
+            }
+          },
+          false
+        )
+      })
+    }
+    $.assignDrop = function (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)
+      })
+    }
+    $.unAssignDrop = function (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)
+      })
+    }
+    $.isUploading = function () {
+      let uploading = false
+      $h.each($.files, function (file) {
+        if (file.isUploading()) {
+          uploading = true
+          return false
+        }
+      })
+      return uploading
+    }
+    $.upload = function () {
+      // Make sure we don't start too many uploads at once
+      if ($.isUploading()) return
+      // Kick off the queue
+      $.fire('uploadStart')
+      for (let num = 1; num <= $.getOpt('simultaneousUploads'); num++) {
+        $.uploadNextChunk()
+      }
+    }
+    $.pause = function () {
+      // Resume all chunks currently being uploaded
+      $h.each($.files, function (file) {
+        file.abort()
+      })
+      $.fire('pause')
+    }
+    $.cancel = function () {
+      $.fire('beforeCancel')
+      for (let i = $.files.length - 1; i >= 0; i--) {
+        $.files[i].cancel()
+      }
+      $.fire('cancel')
+    }
+    $.progress = function () {
+      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
+    }
+    $.addFile = function (file, event) {
+      appendFilesFromFileList([file], event)
+    }
+    $.addFiles = function (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)
+        }
+      }
+    }
+    $.getFromUniqueIdentifier = function (uniqueIdentifier) {
+      let ret = false
+      $h.each($.files, function (f) {
+        if (f.uniqueIdentifier == uniqueIdentifier) ret = f
+      })
+      return ret
+    }
+    $.getSize = function () {
+      let totalSize = 0
+      $h.each($.files, function (file) {
+        totalSize += file.size
+      })
+      return totalSize
+    }
+    $.handleDropEvent = function (e) {
+      onDrop(e)
+    }
+    $.handleChangeEvent = function (e) {
+      appendFilesFromFileList(e.target.files, e)
+      e.target.value = ''
+    }
+    $.updateQuery = function (query) {
+      $.opts.query = query
+    }
+
+    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
+  } else if (typeof define === 'function' && define.amd) {
+    // AMD/requirejs: Define the module
+    define(function () {
+      return Resumable
+    })
+  } else {
+    // Browser: Expose to window
+    window.Resumable = Resumable
+  }
+})()