diff --git a/dist/flow.js b/dist/flow.js
index e2745e33..3476cc4d 100644
--- a/dist/flow.js
+++ b/dist/flow.js
@@ -520,119 +520,6 @@
 	  }
 	};
 
-	var arrayMethodIsStrict = function (METHOD_NAME, argument) {
-	  var method = [][METHOD_NAME];
-	  return !!method && fails(function () {
-	    // eslint-disable-next-line no-useless-call,no-throw-literal
-	    method.call(null, argument || function () {
-	      throw 1;
-	    }, 1);
-	  });
-	};
-
-	var defineProperty = Object.defineProperty;
-	var cache = {};
-
-	var thrower = function (it) {
-	  throw it;
-	};
-
-	var arrayMethodUsesToLength = function (METHOD_NAME, options) {
-	  if (has(cache, METHOD_NAME)) return cache[METHOD_NAME];
-	  if (!options) options = {};
-	  var method = [][METHOD_NAME];
-	  var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false;
-	  var argument0 = has(options, 0) ? options[0] : thrower;
-	  var argument1 = has(options, 1) ? options[1] : undefined;
-	  return cache[METHOD_NAME] = !!method && !fails(function () {
-	    if (ACCESSORS && !descriptors) return true;
-	    var O = {
-	      length: -1
-	    };
-	    if (ACCESSORS) defineProperty(O, 1, {
-	      enumerable: true,
-	      get: thrower
-	    });else O[1] = 1;
-	    method.call(O, argument0, argument1);
-	  });
-	};
-
-	var $indexOf = arrayIncludes.indexOf;
-	var nativeIndexOf = [].indexOf;
-	var NEGATIVE_ZERO = !!nativeIndexOf && 1 / [1].indexOf(1, -0) < 0;
-	var STRICT_METHOD = arrayMethodIsStrict('indexOf');
-	var USES_TO_LENGTH = arrayMethodUsesToLength('indexOf', {
-	  ACCESSORS: true,
-	  1: 0
-	}); // `Array.prototype.indexOf` method
-	// https://tc39.github.io/ecma262/#sec-array.prototype.indexof
-
-	_export({
-	  target: 'Array',
-	  proto: true,
-	  forced: NEGATIVE_ZERO || !STRICT_METHOD || !USES_TO_LENGTH
-	}, {
-	  indexOf: function indexOf(searchElement
-	  /* , fromIndex = 0 */
-	  ) {
-	    return NEGATIVE_ZERO // convert -0 to +0
-	    ? nativeIndexOf.apply(this, arguments) || 0 : $indexOf(this, searchElement, arguments.length > 1 ? arguments[1] : undefined);
-	  }
-	});
-
-	var nativeJoin = [].join;
-	var ES3_STRINGS = indexedObject != Object;
-	var STRICT_METHOD$1 = arrayMethodIsStrict('join', ','); // `Array.prototype.join` method
-	// https://tc39.github.io/ecma262/#sec-array.prototype.join
-
-	_export({
-	  target: 'Array',
-	  proto: true,
-	  forced: ES3_STRINGS || !STRICT_METHOD$1
-	}, {
-	  join: function join(separator) {
-	    return nativeJoin.call(toIndexedObject(this), separator === undefined ? ',' : separator);
-	  }
-	});
-
-	var min$2 = Math.min;
-	var nativeLastIndexOf = [].lastIndexOf;
-	var NEGATIVE_ZERO$1 = !!nativeLastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0;
-	var STRICT_METHOD$2 = arrayMethodIsStrict('lastIndexOf'); // For preventing possible almost infinite loop in non-standard implementations, test the forward version of the method
-
-	var USES_TO_LENGTH$1 = arrayMethodUsesToLength('indexOf', {
-	  ACCESSORS: true,
-	  1: 0
-	});
-	var FORCED = NEGATIVE_ZERO$1 || !STRICT_METHOD$2 || !USES_TO_LENGTH$1; // `Array.prototype.lastIndexOf` method implementation
-	// https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof
-
-	var arrayLastIndexOf = FORCED ? function lastIndexOf(searchElement
-	/* , fromIndex = @[*-1] */
-	) {
-	  // convert -0 to +0
-	  if (NEGATIVE_ZERO$1) return nativeLastIndexOf.apply(this, arguments) || 0;
-	  var O = toIndexedObject(this);
-	  var length = toLength(O.length);
-	  var index = length - 1;
-	  if (arguments.length > 1) index = min$2(index, toInteger(arguments[1]));
-	  if (index < 0) index = length + index;
-
-	  for (; index >= 0; index--) if (index in O && O[index] === searchElement) return index || 0;
-
-	  return -1;
-	} : nativeLastIndexOf;
-
-	// https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof
-
-	_export({
-	  target: 'Array',
-	  proto: true,
-	  forced: arrayLastIndexOf !== [].lastIndexOf
-	}, {
-	  lastIndexOf: arrayLastIndexOf
-	});
-
 	// https://tc39.github.io/ecma262/#sec-isarray
 
 	var isArray = Array.isArray || function isArray(arg) {
@@ -707,8 +594,35 @@
 	  });
 	};
 
+	var defineProperty = Object.defineProperty;
+	var cache = {};
+
+	var thrower = function (it) {
+	  throw it;
+	};
+
+	var arrayMethodUsesToLength = function (METHOD_NAME, options) {
+	  if (has(cache, METHOD_NAME)) return cache[METHOD_NAME];
+	  if (!options) options = {};
+	  var method = [][METHOD_NAME];
+	  var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false;
+	  var argument0 = has(options, 0) ? options[0] : thrower;
+	  var argument1 = has(options, 1) ? options[1] : undefined;
+	  return cache[METHOD_NAME] = !!method && !fails(function () {
+	    if (ACCESSORS && !descriptors) return true;
+	    var O = {
+	      length: -1
+	    };
+	    if (ACCESSORS) defineProperty(O, 1, {
+	      enumerable: true,
+	      get: thrower
+	    });else O[1] = 1;
+	    method.call(O, argument0, argument1);
+	  });
+	};
+
 	var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');
-	var USES_TO_LENGTH$2 = arrayMethodUsesToLength('slice', {
+	var USES_TO_LENGTH = arrayMethodUsesToLength('slice', {
 	  ACCESSORS: true,
 	  0: 0,
 	  1: 2
@@ -722,7 +636,7 @@
 	_export({
 	  target: 'Array',
 	  proto: true,
-	  forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH$2
+	  forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH
 	}, {
 	  slice: function slice(start, end) {
 	    var O = toIndexedObject(this);
@@ -781,13 +695,13 @@
 	};
 
 	var HAS_SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport('splice');
-	var USES_TO_LENGTH$3 = arrayMethodUsesToLength('splice', {
+	var USES_TO_LENGTH$1 = arrayMethodUsesToLength('splice', {
 	  ACCESSORS: true,
 	  0: 0,
 	  1: 2
 	});
 	var max$2 = Math.max;
-	var min$3 = Math.min;
+	var min$2 = Math.min;
 	var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;
 	var MAXIMUM_ALLOWED_LENGTH_EXCEEDED = 'Maximum allowed length exceeded'; // `Array.prototype.splice` method
 	// https://tc39.github.io/ecma262/#sec-array.prototype.splice
@@ -796,7 +710,7 @@
 	_export({
 	  target: 'Array',
 	  proto: true,
-	  forced: !HAS_SPECIES_SUPPORT$1 || !USES_TO_LENGTH$3
+	  forced: !HAS_SPECIES_SUPPORT$1 || !USES_TO_LENGTH$1
 	}, {
 	  splice: function splice(start, deleteCount
 	  /* , ...items */
@@ -814,7 +728,7 @@
 	      actualDeleteCount = len - actualStart;
 	    } else {
 	      insertCount = argumentsLength - 2;
-	      actualDeleteCount = min$3(max$2(toInteger(deleteCount), 0), len - actualStart);
+	      actualDeleteCount = min$2(max$2(toInteger(deleteCount), 0), len - actualStart);
 	    }
 
 	    if (len + insertCount - actualDeleteCount > MAX_SAFE_INTEGER) {
@@ -1449,7 +1363,7 @@
 	};
 
 	var max$3 = Math.max;
-	var min$4 = Math.min;
+	var min$3 = Math.min;
 	var floor$1 = Math.floor;
 	var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d\d?|<[^>]*>)/g;
 	var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d\d?)/g;
@@ -1505,7 +1419,7 @@
 	    for (var i = 0; i < results.length; i++) {
 	      result = results[i];
 	      var matched = String(result[0]);
-	      var position = max$3(min$4(toInteger(result.index), S.length), 0);
+	      var position = max$3(min$3(toInteger(result.index), S.length), 0);
 	      var captures = []; // NOTE: This is equivalent to
 	      //   captures = result.slice(1).map(maybeToString)
 	      // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
@@ -1583,6 +1497,150 @@
 	  }
 	});
 
+	function _classCallCheck(instance, Constructor) {
+	  if (!(instance instanceof Constructor)) {
+	    throw new TypeError("Cannot call a class as a function");
+	  }
+	}
+
+	function _defineProperties(target, props) {
+	  for (var i = 0; i < props.length; i++) {
+	    var descriptor = props[i];
+	    descriptor.enumerable = descriptor.enumerable || false;
+	    descriptor.configurable = true;
+	    if ("value" in descriptor) descriptor.writable = true;
+	    Object.defineProperty(target, descriptor.key, descriptor);
+	  }
+	}
+
+	function _createClass(Constructor, protoProps, staticProps) {
+	  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+	  if (staticProps) _defineProperties(Constructor, staticProps);
+	  return Constructor;
+	}
+
+	function _unsupportedIterableToArray(o, minLen) {
+	  if (!o) return;
+	  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+	  var n = Object.prototype.toString.call(o).slice(8, -1);
+	  if (n === "Object" && o.constructor) n = o.constructor.name;
+	  if (n === "Map" || n === "Set") return Array.from(o);
+	  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+	}
+
+	function _arrayLikeToArray(arr, len) {
+	  if (len == null || len > arr.length) len = arr.length;
+
+	  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+	  return arr2;
+	}
+
+	function _createForOfIteratorHelper(o, allowArrayLike) {
+	  var it;
+
+	  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+	    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+	      if (it) o = it;
+	      var i = 0;
+
+	      var F = function () {};
+
+	      return {
+	        s: F,
+	        n: function () {
+	          if (i >= o.length) return {
+	            done: true
+	          };
+	          return {
+	            done: false,
+	            value: o[i++]
+	          };
+	        },
+	        e: function (e) {
+	          throw e;
+	        },
+	        f: F
+	      };
+	    }
+
+	    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	  }
+
+	  var normalCompletion = true,
+	      didErr = false,
+	      err;
+	  return {
+	    s: function () {
+	      it = o[Symbol.iterator]();
+	    },
+	    n: function () {
+	      var step = it.next();
+	      normalCompletion = step.done;
+	      return step;
+	    },
+	    e: function (e) {
+	      didErr = true;
+	      err = e;
+	    },
+	    f: function () {
+	      try {
+	        if (!normalCompletion && it.return != null) it.return();
+	      } finally {
+	        if (didErr) throw err;
+	      }
+	    }
+	  };
+	}
+
+	var arrayMethodIsStrict = function (METHOD_NAME, argument) {
+	  var method = [][METHOD_NAME];
+	  return !!method && fails(function () {
+	    // eslint-disable-next-line no-useless-call,no-throw-literal
+	    method.call(null, argument || function () {
+	      throw 1;
+	    }, 1);
+	  });
+	};
+
+	var min$4 = Math.min;
+	var nativeLastIndexOf = [].lastIndexOf;
+	var NEGATIVE_ZERO = !!nativeLastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0;
+	var STRICT_METHOD = arrayMethodIsStrict('lastIndexOf'); // For preventing possible almost infinite loop in non-standard implementations, test the forward version of the method
+
+	var USES_TO_LENGTH$2 = arrayMethodUsesToLength('indexOf', {
+	  ACCESSORS: true,
+	  1: 0
+	});
+	var FORCED = NEGATIVE_ZERO || !STRICT_METHOD || !USES_TO_LENGTH$2; // `Array.prototype.lastIndexOf` method implementation
+	// https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof
+
+	var arrayLastIndexOf = FORCED ? function lastIndexOf(searchElement
+	/* , fromIndex = @[*-1] */
+	) {
+	  // convert -0 to +0
+	  if (NEGATIVE_ZERO) return nativeLastIndexOf.apply(this, arguments) || 0;
+	  var O = toIndexedObject(this);
+	  var length = toLength(O.length);
+	  var index = length - 1;
+	  if (arguments.length > 1) index = min$4(index, toInteger(arguments[1]));
+	  if (index < 0) index = length + index;
+
+	  for (; index >= 0; index--) if (index in O && O[index] === searchElement) return index || 0;
+
+	  return -1;
+	} : nativeLastIndexOf;
+
+	// https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof
+
+	_export({
+	  target: 'Array',
+	  proto: true,
+	  forced: arrayLastIndexOf !== [].lastIndexOf
+	}, {
+	  lastIndexOf: arrayLastIndexOf
+	});
+
 	var MATCH = wellKnownSymbol('match'); // `IsRegExp` abstract operation
 	// https://tc39.github.io/ecma262/#sec-isregexp
 
@@ -1719,1733 +1777,1901 @@
 	  }];
 	}, !SUPPORTS_Y);
 
-	var flow = createCommonjsModule(function (module) {
-	  /**
-	   * @license MIT
-	   */
-	  (function (window, document, undefined$1) {
+	var $indexOf = arrayIncludes.indexOf;
+	var nativeIndexOf = [].indexOf;
+	var NEGATIVE_ZERO$1 = !!nativeIndexOf && 1 / [1].indexOf(1, -0) < 0;
+	var STRICT_METHOD$1 = arrayMethodIsStrict('indexOf');
+	var USES_TO_LENGTH$3 = arrayMethodUsesToLength('indexOf', {
+	  ACCESSORS: true,
+	  1: 0
+	}); // `Array.prototype.indexOf` method
+	// https://tc39.github.io/ecma262/#sec-array.prototype.indexof
 
-	    if (!window || !document) {
-	      console.warn('Flowjs needs window and document objects to work');
-	      return;
-	    } // ie10+
-
-
-	    var ie10plus = window.navigator.msPointerEnabled;
-	    /**
-	     * Flow.js is a library providing multiple simultaneous, stable and
-	     * resumable uploads via the HTML5 File API.
-	     * @param [opts]
-	     * @param {number|Function} [opts.chunkSize]
-	     * @param {bool} [opts.forceChunkSize]
-	     * @param {number} [opts.simultaneousUploads]
-	     * @param {bool} [opts.singleFile]
-	     * @param {string} [opts.fileParameterName]
-	     * @param {number} [opts.progressCallbacksInterval]
-	     * @param {number} [opts.speedSmoothingFactor]
-	     * @param {Object|Function} [opts.query]
-	     * @param {Object|Function} [opts.headers]
-	     * @param {bool} [opts.withCredentials]
-	     * @param {Function} [opts.preprocess]
-	     * @param {string} [opts.method]
-	     * @param {string|Function} [opts.testMethod]
-	     * @param {string|Function} [opts.uploadMethod]
-	     * @param {bool} [opts.prioritizeFirstAndLastChunk]
-	     * @param {bool} [opts.allowDuplicateUploads]
-	     * @param {string|Function} [opts.target]
-	     * @param {number} [opts.maxChunkRetries]
-	     * @param {number} [opts.chunkRetryInterval]
-	     * @param {Array.<number>} [opts.permanentErrors]
-	     * @param {Array.<number>} [opts.successStatuses]
-	     * @param {Function} [opts.initFileFn]
-	     * @param {Function} [opts.readFileFn]
-	     * @param {Function} [opts.generateUniqueIdentifier]
-	     * @constructor
-	     */
-
-	    function Flow(opts) {
-	      /**
-	       * Supported by browser?
-	       * @type {boolean}
-	       */
-	      this.support = typeof File !== 'undefined' && typeof Blob !== 'undefined' && typeof FileList !== 'undefined' && (!!Blob.prototype.slice || !!Blob.prototype.webkitSlice || !!Blob.prototype.mozSlice || false) // slicing files support
-	      ;
-
-	      if (!this.support) {
-	        return;
-	      }
-	      /**
-	       * Check if directory upload is supported
-	       * @type {boolean}
-	       */
-
-
-	      this.supportDirectory = /Chrome/.test(window.navigator.userAgent) || /Firefox/.test(window.navigator.userAgent) || /Edge/.test(window.navigator.userAgent);
-	      /**
-	       * List of FlowFile objects
-	       * @type {Array.<FlowFile>}
-	       */
-
-	      this.files = [];
-	      /**
-	       * Default options for flow.js
-	       * @type {Object}
-	       */
-
-	      this.defaults = {
-	        chunkSize: 1024 * 1024,
-	        forceChunkSize: false,
-	        simultaneousUploads: 3,
-	        singleFile: false,
-	        fileParameterName: 'file',
-	        progressCallbacksInterval: 500,
-	        speedSmoothingFactor: 0.1,
-	        query: {},
-	        headers: {},
-	        withCredentials: false,
-	        preprocess: null,
-	        changeRawDataBeforeSend: null,
-	        method: 'multipart',
-	        testMethod: 'GET',
-	        uploadMethod: 'POST',
-	        prioritizeFirstAndLastChunk: false,
-	        allowDuplicateUploads: false,
-	        target: '/',
-	        testChunks: true,
-	        generateUniqueIdentifier: null,
-	        maxChunkRetries: 0,
-	        chunkRetryInterval: null,
-	        permanentErrors: [404, 413, 415, 500, 501],
-	        successStatuses: [200, 201, 202],
-	        onDropStopPropagation: false,
-	        initFileFn: null,
-	        readFileFn: webAPIFileRead
-	      };
-	      /**
-	       * Current options
-	       * @type {Object}
-	       */
-
-	      this.opts = {};
-	      /**
-	       * List of events:
-	       *  key stands for event name
-	       *  value array list of callbacks
-	       * @type {}
-	       */
-
-	      this.events = {};
-	      var $ = this;
-	      /**
-	       * On drop event
-	       * @function
-	       * @param {MouseEvent} event
-	       */
-
-	      this.onDrop = function (event) {
-	        if ($.opts.onDropStopPropagation) {
-	          event.stopPropagation();
-	        }
+	_export({
+	  target: 'Array',
+	  proto: true,
+	  forced: NEGATIVE_ZERO$1 || !STRICT_METHOD$1 || !USES_TO_LENGTH$3
+	}, {
+	  indexOf: function indexOf(searchElement
+	  /* , fromIndex = 0 */
+	  ) {
+	    return NEGATIVE_ZERO$1 // convert -0 to +0
+	    ? nativeIndexOf.apply(this, arguments) || 0 : $indexOf(this, searchElement, arguments.length > 1 ? arguments[1] : undefined);
+	  }
+	});
 
-	        event.preventDefault();
-	        var dataTransfer = event.dataTransfer;
+	var nativeJoin = [].join;
+	var ES3_STRINGS = indexedObject != Object;
+	var STRICT_METHOD$2 = arrayMethodIsStrict('join', ','); // `Array.prototype.join` method
+	// https://tc39.github.io/ecma262/#sec-array.prototype.join
 
-	        if (dataTransfer.items && dataTransfer.items[0] && dataTransfer.items[0].webkitGetAsEntry) {
-	          $.webkitReadDataTransfer(event);
-	        } else {
-	          $.addFiles(dataTransfer.files, event);
-	        }
-	      };
-	      /**
-	       * Prevent default
-	       * @function
-	       * @param {MouseEvent} event
-	       */
+	_export({
+	  target: 'Array',
+	  proto: true,
+	  forced: ES3_STRINGS || !STRICT_METHOD$2
+	}, {
+	  join: function join(separator) {
+	    return nativeJoin.call(toIndexedObject(this), separator === undefined ? ',' : separator);
+	  }
+	});
 
+	/**
+	 * Default read function using the webAPI
+	 *
+	 * @function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk)
+	 *
+	 */
+	function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk) {
+	  var function_name = 'slice';
+	  if (fileObj.file.slice) function_name = 'slice';else if (fileObj.file.mozSlice) function_name = 'mozSlice';else if (fileObj.file.webkitSlice) function_name = 'webkitSlice';
+	  chunk.readFinished(fileObj.file[function_name](startByte, endByte, fileType));
+	}
+	/**
+	 * Remove value from array
+	 * @param array
+	 * @param value
+	 */
 
-	      this.preventEvent = function (event) {
-	        event.preventDefault();
-	      };
-	      /**
-	       * Current options
-	       * @type {Object}
-	       */
-
-
-	      this.opts = Flow.extend({}, this.defaults, opts || {});
-	    }
-
-	    Flow.prototype = {
-	      /**
-	       * Set a callback for an event, possible events:
-	       * fileSuccess(file), fileProgress(file), fileAdded(file, event),
-	       * fileRemoved(file), fileRetry(file), fileError(file, message),
-	       * complete(), progress(), error(message, file), pause()
-	       * @function
-	       * @param {string} event
-	       * @param {Function} callback
-	       */
-	      on: function on(event, callback) {
-	        event = event.toLowerCase();
 
-	        if (!this.events.hasOwnProperty(event)) {
-	          this.events[event] = [];
-	        }
+	function arrayRemove(array, value) {
+	  var index = array.indexOf(value);
 
-	        this.events[event].push(callback);
-	      },
-
-	      /**
-	       * Remove event callback
-	       * @function
-	       * @param {string} [event] removes all events if not specified
-	       * @param {Function} [fn] removes all callbacks of event if not specified
-	       */
-	      off: function off(event, fn) {
-	        if (event !== undefined$1) {
-	          event = event.toLowerCase();
-
-	          if (fn !== undefined$1) {
-	            if (this.events.hasOwnProperty(event)) {
-	              arrayRemove(this.events[event], fn);
-	            }
-	          } else {
-	            delete this.events[event];
-	          }
-	        } else {
-	          this.events = {};
-	        }
-	      },
-
-	      /**
-	       * Fire an event
-	       * @function
-	       * @param {string} event event name
-	       * @param {...} args arguments of a callback
-	       * @return {bool} value is false if at least one of the event handlers which handled this event
-	       * returned false. Otherwise it returns true.
-	       */
-	      fire: function fire(event, args) {
-	        // `arguments` is an object, not array, in FF, so:
-	        args = Array.prototype.slice.call(arguments);
-	        event = event.toLowerCase();
-	        var preventDefault = false;
+	  if (index > -1) {
+	    array.splice(index, 1);
+	  }
+	}
+	/**
+	 * If option is a function, evaluate it with given params
+	 * @param {*} data
+	 * @param {...} args arguments of a callback
+	 * @returns {*}
+	 */
+
+
+	function evalOpts(data, args) {
+	  if (typeof data === "function") {
+	    // `arguments` is an object, not array, in FF, so:
+	    args = Array.prototype.slice.call(arguments);
+	    data = data.apply(null, args.slice(1));
+	  }
 
-	        if (this.events.hasOwnProperty(event)) {
-	          each(this.events[event], function (callback) {
-	            preventDefault = callback.apply(this, args.slice(1)) === false || preventDefault;
-	          }, this);
-	        }
+	  return data;
+	}
+	/**
+	 * Execute function asynchronously
+	 * @param fn
+	 * @param context
+	 */
 
-	        if (event != 'catchall') {
-	          args.unshift('catchAll');
-	          preventDefault = this.fire.apply(this, args) === false || preventDefault;
-	        }
 
-	        return !preventDefault;
-	      },
-
-	      /**
-	       * Read webkit dataTransfer object
-	       * @param event
-	       */
-	      webkitReadDataTransfer: function webkitReadDataTransfer(event) {
-	        var $ = this;
-	        var queue = event.dataTransfer.items.length;
-	        var files = [];
-	        each(event.dataTransfer.items, function (item) {
-	          var entry = item.webkitGetAsEntry();
+	function async(fn, context) {
+	  setTimeout(fn.bind(context), 0);
+	}
+	/**
+	 * Extends the destination object `dst` by copying all of the properties from
+	 * the `src` object(s) to `dst`. You can specify multiple `src` objects.
+	 * @function
+	 * @param {Object} dst Destination object.
+	 * @param {...Object} src Source object(s).
+	 * @returns {Object} Reference to `dst`.
+	 */
+
+
+	function extend(dst, src) {
+	  each(arguments, function (obj) {
+	    if (obj !== dst) {
+	      each(obj, function (value, key) {
+	        dst[key] = value;
+	      });
+	    }
+	  });
+	  return dst;
+	}
+	/**
+	 * Iterate each element of an object
+	 * @function
+	 * @param {Array|Object} obj object or an array to iterate
+	 * @param {Function} callback first argument is a value and second is a key.
+	 * @param {Object=} context Object to become context (`this`) for the iterator function.
+	 */
+
+
+	function each(obj, callback, context) {
+	  if (!obj) {
+	    return;
+	  }
 
-	          if (!entry) {
-	            decrement();
-	            return;
-	          }
+	  var key; // Is Array?
+	  // Array.isArray won't work, not only arrays can be iterated by index https://github.com/flowjs/ng-flow/issues/236#
 
-	          if (entry.isFile) {
-	            // due to a bug in Chrome's File System API impl - #149735
-	            fileReadSuccess(item.getAsFile(), entry.fullPath);
-	          } else {
-	            readDirectory(entry.createReader());
-	          }
-	        });
+	  if (typeof obj.length !== 'undefined') {
+	    for (key = 0; key < obj.length; key++) {
+	      if (callback.call(context, obj[key], key) === false) {
+	        return;
+	      }
+	    }
+	  } else {
+	    for (key in obj) {
+	      if (obj.hasOwnProperty(key) && callback.call(context, obj[key], key) === false) {
+	        return;
+	      }
+	    }
+	  }
+	}
+	/**
+	 * Exclusively for test purposes
+	 * (Until Grunt+Karma+Jasmine can allow test to use (ES) `import` of tools.js)
+	 */
 
-	        function readDirectory(reader) {
-	          reader.readEntries(function (entries) {
-	            if (entries.length) {
-	              queue += entries.length;
-	              each(entries, function (entry) {
-	                if (entry.isFile) {
-	                  var fullPath = entry.fullPath;
-	                  entry.file(function (file) {
-	                    fileReadSuccess(file, fullPath);
-	                  }, readError);
-	                } else if (entry.isDirectory) {
-	                  readDirectory(entry.createReader());
-	                }
-	              });
-	              readDirectory(reader);
-	            } else {
-	              decrement();
-	            }
-	          }, readError);
-	        }
 
-	        function fileReadSuccess(file, fullPath) {
-	          // relative path should not start with "/"
-	          file.relativePath = fullPath.substring(1);
-	          files.push(file);
-	          decrement();
+	var g = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+	g.evalOpts = evalOpts;
+
+	/**
+	 * Class for storing a single chunk
+	 * @name FlowChunk
+	 * @param {Flow} flowObj
+	 * @param {FlowFile} fileObj
+	 * @param {number} offset
+	 * @constructor
+	 */
+
+	var FlowChunk = /*#__PURE__*/function () {
+	  function FlowChunk(flowObj, fileObj, offset) {
+	    _classCallCheck(this, FlowChunk);
+
+	    /**
+	     * Reference to parent flow object
+	     * @type {Flow}
+	     */
+	    this.flowObj = flowObj;
+	    /**
+	     * Reference to parent FlowFile object
+	     * @type {FlowFile}
+	     */
+
+	    this.fileObj = fileObj;
+	    /**
+	     * File offset
+	     * @type {number}
+	     */
+
+	    this.offset = offset;
+	    /**
+	     * Indicates if chunk existence was checked on the server
+	     * @type {boolean}
+	     */
+
+	    this.tested = false;
+	    /**
+	     * Number of retries performed
+	     * @type {number}
+	     */
+
+	    this.retries = 0;
+	    /**
+	     * Pending retry
+	     * @type {boolean}
+	     */
+
+	    this.pendingRetry = false;
+	    /**
+	     * Preprocess state
+	     * @type {number} 0 = unprocessed, 1 = processing, 2 = finished
+	     */
+
+	    this.preprocessState = 0;
+	    /**
+	     * Read state
+	     * @type {number} 0 = not read, 1 = reading, 2 = finished
+	     */
+
+	    this.readState = 0;
+	    /**
+	     * Bytes transferred from total request size
+	     * @type {number}
+	     */
+
+	    this.loaded = 0;
+	    /**
+	     * Total request size
+	     * @type {number}
+	     */
+
+	    this.total = 0;
+	    /**
+	     * Size of a chunk
+	     * @type {number}
+	     */
+
+	    this.chunkSize = this.fileObj.chunkSize;
+	    /**
+	     * Chunk start byte in a file
+	     * @type {number}
+	     */
+
+	    this.startByte = this.offset * this.chunkSize;
+	    /**
+	     * A specific filename for this chunk which otherwise default to the main name
+	     * @type {string}
+	     */
+
+	    this.filename = null;
+	    /**
+	     * Chunk end byte in a file
+	     * @type {number}
+	     */
+
+	    this.endByte = this.computeEndByte();
+	    /**
+	     * XMLHttpRequest
+	     * @type {XMLHttpRequest}
+	     */
+
+	    this.xhr = null;
+	  }
+	  /**
+	   * Compute the endbyte in a file
+	   *
+	   */
+
+
+	  _createClass(FlowChunk, [{
+	    key: "computeEndByte",
+	    value: function computeEndByte() {
+	      var endByte = Math.min(this.fileObj.size, (this.offset + 1) * this.chunkSize);
+
+	      if (this.fileObj.size - endByte < this.chunkSize && !this.flowObj.opts.forceChunkSize) {
+	        // The last chunk will be bigger than the chunk size,
+	        // but less than 2 * this.chunkSize
+	        endByte = this.fileObj.size;
+	      }
+
+	      return endByte;
+	    }
+	    /**
+	     * Send chunk event
+	     * @param event
+	     * @param {...} args arguments of a callback
+	     */
+
+	  }, {
+	    key: "event",
+	    value: function event(_event, args) {
+	      args = Array.prototype.slice.call(arguments);
+	      args.unshift(this);
+	      this.fileObj.chunkEvent.apply(this.fileObj, args);
+	    }
+	    /**
+	     * Catch progress event
+	     * @param {ProgressEvent} event
+	     */
+
+	  }, {
+	    key: "progressHandler",
+	    value: function progressHandler(event) {
+	      if (event.lengthComputable) {
+	        this.loaded = event.loaded;
+	        this.total = event.total;
+	      }
+
+	      this.event('progress', event);
+	    }
+	    /**
+	     * Catch test event
+	     * @param {Event} event
+	     */
+
+	  }, {
+	    key: "testHandler",
+	    value: function testHandler(event) {
+	      var status = this.status(true);
+
+	      if (status === 'error') {
+	        this.event(status, this.message());
+	        this.flowObj.uploadNextChunk();
+	      } else if (status === 'success') {
+	        this.tested = true;
+	        this.event(status, this.message());
+	        this.flowObj.uploadNextChunk();
+	      } else if (!this.fileObj.paused) {
+	        // Error might be caused by file pause method
+	        // Chunks does not exist on the server side
+	        this.tested = true;
+	        this.send();
+	      }
+	    }
+	    /**
+	     * Upload has stopped
+	     * @param {Event} event
+	     */
+
+	  }, {
+	    key: "doneHandler",
+	    value: function doneHandler(event) {
+	      var _this = this;
+
+	      var status = this.status();
+
+	      if (status === 'success' || status === 'error') {
+	        delete this.data;
+	        this.event(status, this.message());
+	        this.flowObj.uploadNextChunk();
+	      } else if (!this.fileObj.paused) {
+	        this.event('retry', this.message());
+	        this.pendingRetry = true;
+	        this.abort();
+	        this.retries++;
+	        var retryInterval = this.flowObj.opts.chunkRetryInterval;
+
+	        if (retryInterval !== null) {
+	          setTimeout(function () {
+	            return _this.send();
+	          }, retryInterval);
+	        } else {
+	          this.send();
 	        }
+	      }
+	    }
+	    /**
+	     * Get params for a request
+	     * @function
+	     */
+
+	  }, {
+	    key: "getParams",
+	    value: function getParams() {
+	      return {
+	        flowChunkNumber: this.offset + 1,
+	        flowChunkSize: this.chunkSize,
+	        flowCurrentChunkSize: this.endByte - this.startByte,
+	        flowTotalSize: this.fileObj.size,
+	        flowIdentifier: this.fileObj.uniqueIdentifier,
+	        flowFilename: this.fileObj.name,
+	        flowRelativePath: this.fileObj.relativePath,
+	        flowTotalChunks: this.fileObj.chunks.length
+	      };
+	    }
+	    /**
+	     * Get target option with query params
+	     * @function
+	     * @param params
+	     * @returns {string}
+	     */
+
+	  }, {
+	    key: "getTarget",
+	    value: function getTarget(target, params) {
+	      if (params.length == 0) {
+	        return target;
+	      }
+
+	      if (target.indexOf('?') < 0) {
+	        target += '?';
+	      } else {
+	        target += '&';
+	      }
+
+	      return target + params.join('&');
+	    }
+	    /**
+	     * Makes a GET request without any data to see if the chunk has already
+	     * been uploaded in a previous session
+	     * @function
+	     */
+
+	  }, {
+	    key: "test",
+	    value: function test() {
+	      // Set up request and listen for event
+	      this.xhr = new XMLHttpRequest();
+	      this.xhr.addEventListener("load", this.testHandler.bind(this), false);
+	      this.xhr.addEventListener("error", this.testHandler.bind(this), false);
+	      var testMethod = evalOpts(this.flowObj.opts.testMethod, this.fileObj, this);
+	      var data = this.prepareXhrRequest(testMethod, true);
+	      this.xhr.send(data);
+	    }
+	    /**
+	     * Finish preprocess state
+	     * @function
+	     */
+
+	  }, {
+	    key: "preprocessFinished",
+	    value: function preprocessFinished() {
+	      // Re-compute the endByte after the preprocess function to allow an
+	      // implementer of preprocess to set the fileObj size
+	      this.endByte = this.computeEndByte();
+	      this.preprocessState = 2;
+	      this.send();
+	    }
+	    /**
+	     * Finish read state
+	     * @function
+	     */
+
+	  }, {
+	    key: "readFinished",
+	    value: function readFinished(bytes) {
+	      this.readState = 2;
+	      this.bytes = bytes;
+	      this.send();
+	    }
+	    /**
+	     * Uploads the actual data in a POST call
+	     * @function
+	     */
 
-	        function readError(fileError) {
-	          decrement();
-	          throw fileError;
+	  }, {
+	    key: "send",
+	    value: function send() {
+	      var preprocess = this.flowObj.opts.preprocess;
+	      var read = this.flowObj.opts.readFileFn;
+
+	      if (typeof preprocess === 'function') {
+	        switch (this.preprocessState) {
+	          case 0:
+	            this.preprocessState = 1;
+	            preprocess(this);
+	            return;
+
+	          case 1:
+	            return;
 	        }
+	      }
 
-	        function decrement() {
-	          if (--queue == 0) {
-	            $.addFiles(files, event);
-	          }
+	      switch (this.readState) {
+	        case 0:
+	          this.readState = 1;
+	          read(this.fileObj, this.startByte, this.endByte, this.fileObj.file.type, this);
+	          return;
+
+	        case 1:
+	          return;
+	      }
+
+	      if (this.flowObj.opts.testChunks && !this.tested) {
+	        this.test();
+	        return;
+	      }
+
+	      this.loaded = 0;
+	      this.total = 0;
+	      this.pendingRetry = false; // Set up request and listen for event
+
+	      this.xhr = new XMLHttpRequest();
+	      this.xhr.upload.addEventListener('progress', this.progressHandler.bind(this), false);
+	      this.xhr.addEventListener('load', this.doneHandler.bind(this), false);
+	      this.xhr.addEventListener('error', this.doneHandler.bind(this), false);
+	      var uploadMethod = evalOpts(this.flowObj.opts.uploadMethod, this.fileObj, this);
+	      var data = this.prepareXhrRequest(uploadMethod, false, this.flowObj.opts.method, this.bytes);
+	      var changeRawDataBeforeSend = this.flowObj.opts.changeRawDataBeforeSend;
+
+	      if (typeof changeRawDataBeforeSend === 'function') {
+	        data = changeRawDataBeforeSend(this, data);
+	      }
+
+	      this.xhr.send(data);
+	    }
+	    /**
+	     * Abort current xhr request
+	     * @function
+	     */
+
+	  }, {
+	    key: "abort",
+	    value: function abort() {
+	      // Abort and reset
+	      var xhr = this.xhr;
+	      this.xhr = null;
+
+	      if (xhr) {
+	        xhr.abort();
+	      }
+	    }
+	    /**
+	     * Retrieve current chunk upload status
+	     * @function
+	     * @returns {string} 'pending', 'uploading', 'success', 'error'
+	     */
+
+	  }, {
+	    key: "status",
+	    value: function status(isTest) {
+	      if (this.readState === 1) {
+	        return 'reading';
+	      } else if (this.pendingRetry || this.preprocessState === 1) {
+	        // 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 (!this.xhr) {
+	        return 'pending';
+	      } else if (this.xhr.readyState < 4) {
+	        // Status is really 'OPENED', 'HEADERS_RECEIVED'
+	        // or 'LOADING' - meaning that stuff is happening
+	        return 'uploading';
+	      } else {
+	        if (this.flowObj.opts.successStatuses.indexOf(this.xhr.status) > -1) {
+	          // HTTP 200, perfect
+	          // HTTP 202 Accepted - The request has been accepted for processing, but the processing has not been completed.
+	          return 'success';
+	        } else if (this.flowObj.opts.permanentErrors.indexOf(this.xhr.status) > -1 || !isTest && this.retries >= this.flowObj.opts.maxChunkRetries) {
+	          // HTTP 413/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
+	          this.abort();
+	          return 'pending';
 	        }
-	      },
-
-	      /**
-	       * Generate unique identifier for a file
-	       * @function
-	       * @param {FlowFile} file
-	       * @returns {string}
-	       */
-	      generateUniqueIdentifier: function generateUniqueIdentifier(file) {
-	        var custom = this.opts.generateUniqueIdentifier;
-
-	        if (typeof custom === 'function') {
-	          return custom(file);
-	        } // Some confusion in different versions of Firefox
-
-
-	        var relativePath = file.relativePath || file.webkitRelativePath || file.fileName || file.name;
-	        return file.size + '-' + relativePath.replace(/[^0-9a-zA-Z_-]/img, '');
-	      },
-
-	      /**
-	       * Upload next chunk from the queue
-	       * @function
-	       * @returns {boolean}
-	       * @private
-	       */
-	      uploadNextChunk: function uploadNextChunk(preventEvents) {
-	        // 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.
-	        var found = false;
-
-	        if (this.opts.prioritizeFirstAndLastChunk) {
-	          each(this.files, function (file) {
-	            if (!file.paused && file.chunks.length && file.chunks[0].status() === 'pending') {
-	              file.chunks[0].send();
-	              found = true;
-	              return false;
-	            }
+	      }
+	    }
+	    /**
+	     * Get response from xhr request
+	     * @function
+	     * @returns {String}
+	     */
 
-	            if (!file.paused && file.chunks.length > 1 && file.chunks[file.chunks.length - 1].status() === 'pending') {
-	              file.chunks[file.chunks.length - 1].send();
-	              found = true;
-	              return false;
-	            }
-	          });
+	  }, {
+	    key: "message",
+	    value: function message() {
+	      return this.xhr ? this.xhr.responseText : '';
+	    }
+	    /**
+	     * Get upload progress
+	     * @function
+	     * @returns {number}
+	     */
 
-	          if (found) {
-	            return found;
-	          }
-	        } // Now, simply look for the next, best thing to upload
+	  }, {
+	    key: "progress",
+	    value: function progress() {
+	      if (this.pendingRetry) {
+	        return 0;
+	      }
 
+	      var s = this.status();
 
-	        each(this.files, function (file) {
-	          if (!file.paused) {
-	            each(file.chunks, function (chunk) {
-	              if (chunk.status() === 'pending') {
-	                chunk.send();
-	                found = true;
-	                return false;
-	              }
-	            });
-	          }
+	      if (s === 'success' || s === 'error') {
+	        return 1;
+	      } else if (s === 'pending') {
+	        return 0;
+	      } else {
+	        return this.total > 0 ? this.loaded / this.total : 0;
+	      }
+	    }
+	    /**
+	     * Count total size uploaded
+	     * @function
+	     * @returns {number}
+	     */
 
-	          if (found) {
-	            return false;
-	          }
-	        });
+	  }, {
+	    key: "sizeUploaded",
+	    value: function sizeUploaded() {
+	      var size = this.endByte - this.startByte; // can't return only chunk.loaded value, because it is bigger than chunk size
 
-	        if (found) {
-	          return true;
-	        } // The are no more outstanding chunks to upload, check is everything is done
+	      if (this.status() !== 'success') {
+	        size = this.progress() * size;
+	      }
 
+	      return size;
+	    }
+	    /**
+	     * Prepare Xhr request. Set query, headers and data
+	     * @param {string} method GET or POST
+	     * @param {bool} isTest is this a test request
+	     * @param {string} [paramsMethod] octet or form
+	     * @param {Blob} [blob] to send
+	     * @returns {FormData|Blob|Null} data to send
+	     */
 
-	        var outstanding = false;
-	        each(this.files, function (file) {
-	          if (!file.isComplete()) {
-	            outstanding = true;
-	            return false;
-	          }
+	  }, {
+	    key: "prepareXhrRequest",
+	    value: function prepareXhrRequest(method, isTest, paramsMethod, blob) {
+	      // Add data from the query options
+	      var query = evalOpts(this.flowObj.opts.query, this.fileObj, this, isTest);
+	      query = extend(query || {}, this.getParams());
+	      var target = evalOpts(this.flowObj.opts.target, this.fileObj, this, isTest);
+	      var data = null;
+
+	      if (method === 'GET' || paramsMethod === 'octet') {
+	        // Add data from the query options
+	        var params = [];
+	        each(query, function (v, k) {
+	          params.push([encodeURIComponent(k), encodeURIComponent(v)].join('='));
+	        });
+	        target = this.getTarget(target, params);
+	        data = blob || null;
+	      } else {
+	        // Add data from the query options
+	        data = new FormData();
+	        each(query, function (v, k) {
+	          data.append(k, v);
 	        });
 
-	        if (!outstanding && !preventEvents) {
-	          // All chunks have been uploaded, complete
-	          async(function () {
-	            this.fire('complete');
-	          }, this);
+	        if (typeof blob !== "undefined") {
+	          data.append(this.flowObj.opts.fileParameterName, blob, this.filename || this.fileObj.file.name);
 	        }
+	      }
 
-	        return false;
-	      },
-
-	      /**
-	       * Assign a browse action to one or more DOM nodes.
-	       * @function
-	       * @param {Element|Array.<Element>} domNodes
-	       * @param {boolean} isDirectory Pass in true to allow directories to
-	       * @param {boolean} singleFile prevent multi file upload
-	       * @param {Object} attributes set custom attributes:
-	       *  http://www.w3.org/TR/html-markup/input.file.html#input.file-attributes
-	       *  eg: accept: 'image/*'
-	       * be selected (Chrome only).
-	       */
-	      assignBrowse: function assignBrowse(domNodes, isDirectory, singleFile, attributes) {
-	        if (domNodes instanceof Element) {
-	          domNodes = [domNodes];
-	        }
+	      this.xhr.open(method, target, true);
+	      this.xhr.withCredentials = this.flowObj.opts.withCredentials; // Add data from header options
 
-	        each(domNodes, function (domNode) {
-	          var input;
+	      each(evalOpts(this.flowObj.opts.headers, this.fileObj, this, isTest), function (v, k) {
+	        this.xhr.setRequestHeader(k, v);
+	      }, this);
+	      return data;
+	    }
+	  }]);
 
-	          if (domNode.tagName === 'INPUT' && domNode.type === 'file') {
-	            input = domNode;
-	          } else {
-	            input = document.createElement('input');
-	            input.setAttribute('type', 'file'); // display:none - not working in opera 12
-
-	            extend(input.style, {
-	              visibility: 'hidden',
-	              position: 'absolute',
-	              width: '1px',
-	              height: '1px'
-	            }); // for opera 12 browser, input must be assigned to a document
-
-	            domNode.appendChild(input); // https://developer.mozilla.org/en/using_files_from_web_applications)
-	            // event listener is executed two times
-	            // first one - original mouse click event
-	            // second - input.click(), input is inside domNode
-
-	            domNode.addEventListener('click', function () {
-	              input.click();
-	            }, false);
+	  return FlowChunk;
+	}();
+
+	/**
+	 * FlowFile class
+	 * @name FlowFile
+	 * @param {Flow} flowObj
+	 * @param {File} file
+	 * @param {string} uniqueIdentifier
+	 * @constructor
+	 */
+
+	var FlowFile = /*#__PURE__*/function () {
+	  function FlowFile(flowObj, file, uniqueIdentifier) {
+	    _classCallCheck(this, FlowFile);
+
+	    /**
+	     * Reference to parent Flow instance
+	     * @type {Flow}
+	     */
+	    this.flowObj = flowObj;
+	    /**
+	     * Used to store the bytes read
+	     * @type {Blob|string}
+	     */
+
+	    this.bytes = null;
+	    /**
+	     * Reference to file
+	     * @type {File}
+	     */
+
+	    this.file = file;
+	    /**
+	     * File name. Some confusion in different versions of Firefox
+	     * @type {string}
+	     */
+
+	    this.name = file.fileName || file.name;
+	    /**
+	     * File size
+	     * @type {number}
+	     */
+
+	    this.size = file.size;
+	    /**
+	     * Relative file path
+	     * @type {string}
+	     */
+
+	    this.relativePath = file.relativePath || file.webkitRelativePath || this.name;
+	    /**
+	     * File unique identifier
+	     * @type {string}
+	     */
+
+	    this.uniqueIdentifier = uniqueIdentifier === undefined ? flowObj.generateUniqueIdentifier(file) : uniqueIdentifier;
+	    /**
+	     * Size of Each Chunk
+	     * @type {number}
+	     */
+
+	    this.chunkSize = 0;
+	    /**
+	     * List of chunks
+	     * @type {Array.<FlowChunk>}
+	     */
+
+	    this.chunks = [];
+	    /**
+	     * Indicated if file is paused
+	     * @type {boolean}
+	     */
+
+	    this.paused = false;
+	    /**
+	     * Indicated if file has encountered an error
+	     * @type {boolean}
+	     */
+
+	    this.error = false;
+	    /**
+	     * Average upload speed
+	     * @type {number}
+	     */
+
+	    this.averageSpeed = 0;
+	    /**
+	     * Current upload speed
+	     * @type {number}
+	     */
+
+	    this.currentSpeed = 0;
+	    /**
+	     * Date then progress was called last time
+	     * @type {number}
+	     * @private
+	     */
+
+	    this._lastProgressCallback = Date.now();
+	    /**
+	     * Previously uploaded file size
+	     * @type {number}
+	     * @private
+	     */
+
+	    this._prevUploadedSize = 0;
+	    /**
+	     * Holds previous progress
+	     * @type {number}
+	     * @private
+	     */
+
+	    this._prevProgress = 0;
+	    this.bootstrap();
+	  }
+	  /**
+	   * Update speed parameters
+	   * @link http://stackoverflow.com/questions/2779600/how-to-estimate-download-time-remaining-accurately
+	   * @function
+	   */
+
+
+	  _createClass(FlowFile, [{
+	    key: "measureSpeed",
+	    value: function measureSpeed() {
+	      var timeSpan = Date.now() - this._lastProgressCallback;
+
+	      if (!timeSpan) {
+	        return;
+	      }
+
+	      var smoothingFactor = this.flowObj.opts.speedSmoothingFactor;
+	      var uploaded = this.sizeUploaded(); // Prevent negative upload speed after file upload resume
+
+	      this.currentSpeed = Math.max((uploaded - this._prevUploadedSize) / timeSpan * 1000, 0);
+	      this.averageSpeed = smoothingFactor * this.currentSpeed + (1 - smoothingFactor) * this.averageSpeed;
+	      this._prevUploadedSize = uploaded;
+	    }
+	    /**
+	     * For internal usage only.
+	     * Callback when something happens within the chunk.
+	     * @function
+	     * @param {FlowChunk} chunk
+	     * @param {string} event can be 'progress', 'success', 'error' or 'retry'
+	     * @param {string} [message]
+	     */
+
+	  }, {
+	    key: "chunkEvent",
+	    value: function chunkEvent(chunk, event, message) {
+	      switch (event) {
+	        case 'progress':
+	          if (Date.now() - this._lastProgressCallback < this.flowObj.opts.progressCallbacksInterval) {
+	            break;
 	          }
 
-	          if (!this.opts.singleFile && !singleFile) {
-	            input.setAttribute('multiple', 'multiple');
+	          this.measureSpeed();
+	          this.flowObj.fire('fileProgress', this, chunk);
+	          this.flowObj.fire('progress');
+	          this._lastProgressCallback = Date.now();
+	          break;
+
+	        case 'error':
+	          this.error = true;
+	          this.abort(true);
+	          this.flowObj.fire('fileError', this, message, chunk);
+	          this.flowObj.fire('error', message, this, chunk);
+	          break;
+
+	        case 'success':
+	          if (this.error) {
+	            return;
 	          }
 
-	          if (isDirectory) {
-	            input.setAttribute('webkitdirectory', 'webkitdirectory');
+	          this.measureSpeed();
+	          this.flowObj.fire('fileProgress', this, chunk);
+	          this.flowObj.fire('progress');
+	          this._lastProgressCallback = Date.now();
+
+	          if (this.isComplete()) {
+	            this.currentSpeed = 0;
+	            this.averageSpeed = 0;
+	            this.flowObj.fire('fileSuccess', this, message, chunk);
 	          }
 
-	          each(attributes, function (value, key) {
-	            input.setAttribute(key, value);
-	          }); // When new files are added, simply append them to the overall list
+	          break;
 
-	          var $ = this;
-	          input.addEventListener('change', function (e) {
-	            if (e.target.value) {
-	              $.addFiles(e.target.files, e);
-	              e.target.value = '';
-	            }
-	          }, false);
-	        }, this);
-	      },
-
-	      /**
-	       * Assign one or more DOM nodes as a drop target.
-	       * @function
-	       * @param {Element|Array.<Element>} domNodes
-	       */
-	      assignDrop: function assignDrop(domNodes) {
-	        if (typeof domNodes.length === 'undefined') {
-	          domNodes = [domNodes];
+	        case 'retry':
+	          this.flowObj.fire('fileRetry', this, chunk);
+	          break;
+	      }
+	    }
+	    /**
+	     * Pause file upload
+	     * @function
+	     */
+
+	  }, {
+	    key: "pause",
+	    value: function pause() {
+	      this.paused = true;
+	      this.abort();
+	    }
+	    /**
+	     * Resume file upload
+	     * @function
+	     */
+
+	  }, {
+	    key: "resume",
+	    value: function resume() {
+	      this.paused = false;
+	      this.flowObj.upload();
+	    }
+	    /**
+	     * Abort current upload
+	     * @function
+	     */
+
+	  }, {
+	    key: "abort",
+	    value: function abort(reset) {
+	      this.currentSpeed = 0;
+	      this.averageSpeed = 0;
+	      var chunks = this.chunks;
+
+	      if (reset) {
+	        this.chunks = [];
+	      }
+
+	      each(chunks, function (c) {
+	        if (c.status() === 'uploading') {
+	          c.abort();
+	          this.flowObj.uploadNextChunk();
 	        }
+	      }, this);
+	    }
+	    /**
+	     * Cancel current upload and remove from a list
+	     * @function
+	     */
 
-	        each(domNodes, function (domNode) {
-	          domNode.addEventListener('dragover', this.preventEvent, false);
-	          domNode.addEventListener('dragenter', this.preventEvent, false);
-	          domNode.addEventListener('drop', this.onDrop, false);
-	        }, this);
-	      },
-
-	      /**
-	       * Un-assign drop event from DOM nodes
-	       * @function
-	       * @param domNodes
-	       */
-	      unAssignDrop: function unAssignDrop(domNodes) {
-	        if (typeof domNodes.length === 'undefined') {
-	          domNodes = [domNodes];
+	  }, {
+	    key: "cancel",
+	    value: function cancel() {
+	      this.flowObj.removeFile(this);
+	    }
+	    /**
+	     * Retry aborted file upload
+	     * @function
+	     */
+
+	  }, {
+	    key: "retry",
+	    value: function retry() {
+	      this.bootstrap();
+	      this.flowObj.upload();
+	    }
+	    /**
+	     * Clear current chunks and slice file again
+	     * @function
+	     */
+
+	  }, {
+	    key: "bootstrap",
+	    value: function bootstrap() {
+	      if (typeof this.flowObj.opts.initFileFn === "function") {
+	        var ret = this.flowObj.opts.initFileFn(this);
+
+	        if (ret && 'then' in ret) {
+	          ret.then(this._bootstrap.bind(this));
+	          return;
 	        }
+	      }
 
-	        each(domNodes, function (domNode) {
-	          domNode.removeEventListener('dragover', this.preventEvent);
-	          domNode.removeEventListener('dragenter', this.preventEvent);
-	          domNode.removeEventListener('drop', this.onDrop);
-	        }, this);
-	      },
-
-	      /**
-	       * Returns a boolean indicating whether or not the instance is currently
-	       * uploading anything.
-	       * @function
-	       * @returns {boolean}
-	       */
-	      isUploading: function isUploading() {
-	        var uploading = false;
-	        each(this.files, function (file) {
-	          if (file.isUploading()) {
-	            uploading = true;
-	            return false;
-	          }
-	        });
-	        return uploading;
-	      },
-
-	      /**
-	       * should upload next chunk
-	       * @function
-	       * @returns {boolean|number}
-	       */
-	      _shouldUploadNext: function _shouldUploadNext() {
-	        var num = 0;
-	        var should = true;
-	        var simultaneousUploads = this.opts.simultaneousUploads;
-	        each(this.files, function (file) {
-	          each(file.chunks, function (chunk) {
-	            if (chunk.status() === 'uploading') {
-	              num++;
+	      this._bootstrap();
+	    }
+	  }, {
+	    key: "_bootstrap",
+	    value: function _bootstrap() {
+	      this.abort(true);
+	      this.error = false; // Rebuild stack of chunks from file
 
-	              if (num >= simultaneousUploads) {
-	                should = false;
-	                return false;
-	              }
-	            }
-	          });
-	        }); // if should is true then return uploading chunks's length
+	      this._prevProgress = 0;
+	      var round = this.flowObj.opts.forceChunkSize ? Math.ceil : Math.floor;
+	      this.chunkSize = evalOpts(this.flowObj.opts.chunkSize, this);
+	      var chunks = Math.max(round(this.size / this.chunkSize), 1);
 
-	        return should && num;
-	      },
+	      for (var offset = 0; offset < chunks; offset++) {
+	        this.chunks.push(new FlowChunk(this.flowObj, this, offset));
+	      }
+	    }
+	    /**
+	     * Get current upload progress status
+	     * @function
+	     * @returns {number} from 0 to 1
+	     */
 
-	      /**
-	       * Start or resume uploading.
-	       * @function
-	       */
-	      upload: function upload() {
-	        // Make sure we don't start too many uploads at once
-	        var ret = this._shouldUploadNext();
+	  }, {
+	    key: "progress",
+	    value: function progress() {
+	      if (this.error) {
+	        return 1;
+	      }
 
-	        if (ret === false) {
-	          return;
-	        } // Kick off the queue
+	      if (this.chunks.length === 1) {
+	        this._prevProgress = Math.max(this._prevProgress, this.chunks[0].progress());
+	        return this._prevProgress;
+	      } // Sum up progress across everything
 
 
-	        this.fire('uploadStart');
-	        var started = false;
+	      var bytesLoaded = 0;
+	      each(this.chunks, function (c) {
+	        // get chunk progress relative to entire file
+	        bytesLoaded += c.progress() * (c.endByte - c.startByte);
+	      });
+	      var percent = bytesLoaded / this.size; // We don't want to lose percentages when an upload is paused
 
-	        for (var num = 1; num <= this.opts.simultaneousUploads - ret; num++) {
-	          started = this.uploadNextChunk(true) || started;
-	        }
+	      this._prevProgress = Math.max(this._prevProgress, percent > 0.9999 ? 1 : percent);
+	      return this._prevProgress;
+	    }
+	    /**
+	     * Indicates if file is being uploaded at the moment
+	     * @function
+	     * @returns {boolean}
+	     */
 
-	        if (!started) {
-	          async(function () {
-	            this.fire('complete');
-	          }, this);
+	  }, {
+	    key: "isUploading",
+	    value: function isUploading() {
+	      var uploading = false;
+	      each(this.chunks, function (chunk) {
+	        if (chunk.status() === 'uploading') {
+	          uploading = true;
+	          return false;
 	        }
-	      },
+	      });
+	      return uploading;
+	    }
+	    /**
+	     * Indicates if file is has finished uploading and received a response
+	     * @function
+	     * @returns {boolean}
+	     */
 
-	      /**
-	       * Resume uploading.
-	       * @function
-	       */
-	      resume: function resume() {
-	        each(this.files, function (file) {
-	          if (!file.isComplete()) {
-	            file.resume();
-	          }
-	        });
-	      },
+	  }, {
+	    key: "isComplete",
+	    value: function isComplete() {
+	      var outstanding = false;
+	      each(this.chunks, function (chunk) {
+	        var status = chunk.status();
 
-	      /**
-	       * Pause uploading.
-	       * @function
-	       */
-	      pause: function pause() {
-	        each(this.files, function (file) {
-	          file.pause();
-	        });
-	      },
-
-	      /**
-	       * Cancel upload of all FlowFile objects and remove them from the list.
-	       * @function
-	       */
-	      cancel: function cancel() {
-	        for (var i = this.files.length - 1; i >= 0; i--) {
-	          this.files[i].cancel();
+	        if (status === 'pending' || status === 'uploading' || status === 'reading' || chunk.preprocessState === 1 || chunk.readState === 1) {
+	          outstanding = true;
+	          return false;
 	        }
-	      },
-
-	      /**
-	       * Returns a number between 0 and 1 indicating the current upload progress
-	       * of all files.
-	       * @function
-	       * @returns {number}
-	       */
-	      progress: function progress() {
-	        var totalDone = 0;
-	        var totalSize = 0; // Resume all chunks currently being uploaded
+	      });
+	      return !outstanding;
+	    }
+	    /**
+	     * Count total size uploaded
+	     * @function
+	     * @returns {number}
+	     */
 
-	        each(this.files, function (file) {
-	          totalDone += file.progress() * file.size;
-	          totalSize += file.size;
-	        });
-	        return totalSize > 0 ? totalDone / totalSize : 0;
-	      },
-
-	      /**
-	       * Add a HTML5 File object to the list of files.
-	       * @function
-	       * @param {File} file
-	       * @param {Event} [event] event is optional
-	       */
-	      addFile: function addFile(file, event) {
-	        this.addFiles([file], event);
-	      },
-
-	      /**
-	       * Add a HTML5 File object to the list of files.
-	       * @function
-	       * @param {FileList|Array} fileList
-	       * @param {Event} [event] event is optional
-	       */
-	      addFiles: function addFiles(fileList, event) {
-	        var files = [];
-	        each(fileList, function (file) {
-	          // https://github.com/flowjs/flow.js/issues/55
-	          if ((!ie10plus || ie10plus && file.size > 0) && !(file.size % 4096 === 0 && (file.name === '.' || file.fileName === '.'))) {
-	            var uniqueIdentifier = this.generateUniqueIdentifier(file);
-
-	            if (this.opts.allowDuplicateUploads || !this.getFromUniqueIdentifier(uniqueIdentifier)) {
-	              var f = new FlowFile(this, file, uniqueIdentifier);
-
-	              if (this.fire('fileAdded', f, event)) {
-	                files.push(f);
-	              }
-	            }
-	          }
-	        }, this);
+	  }, {
+	    key: "sizeUploaded",
+	    value: function sizeUploaded() {
+	      var size = 0;
+	      each(this.chunks, function (chunk) {
+	        size += chunk.sizeUploaded();
+	      });
+	      return size;
+	    }
+	    /**
+	     * Returns remaining time to finish upload file in seconds. Accuracy is based on average speed.
+	     * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`
+	     * @function
+	     * @returns {number}
+	     */
 
-	        if (this.fire('filesAdded', files, event)) {
-	          each(files, function (file) {
-	            if (this.opts.singleFile && this.files.length > 0) {
-	              this.removeFile(this.files[0]);
-	            }
+	  }, {
+	    key: "timeRemaining",
+	    value: function timeRemaining() {
+	      if (this.paused || this.error) {
+	        return 0;
+	      }
 
-	            this.files.push(file);
-	          }, this);
-	          this.fire('filesSubmitted', files, event);
-	        }
-	      },
-
-	      /**
-	       * Cancel upload of a specific FlowFile object from the list.
-	       * @function
-	       * @param {FlowFile} file
-	       */
-	      removeFile: function removeFile(file) {
-	        for (var i = this.files.length - 1; i >= 0; i--) {
-	          if (this.files[i] === file) {
-	            this.files.splice(i, 1);
-	            file.abort();
-	            this.fire('fileRemoved', file);
-	          }
-	        }
-	      },
-
-	      /**
-	       * Look up a FlowFile object by its unique identifier.
-	       * @function
-	       * @param {string} uniqueIdentifier
-	       * @returns {boolean|FlowFile} false if file was not found
-	       */
-	      getFromUniqueIdentifier: function getFromUniqueIdentifier(uniqueIdentifier) {
-	        var ret = false;
-	        each(this.files, function (file) {
-	          if (file.uniqueIdentifier === uniqueIdentifier) {
-	            ret = file;
-	          }
-	        });
-	        return ret;
-	      },
-
-	      /**
-	       * Returns the total size of all files in bytes.
-	       * @function
-	       * @returns {number}
-	       */
-	      getSize: function getSize() {
-	        var totalSize = 0;
-	        each(this.files, function (file) {
-	          totalSize += file.size;
-	        });
-	        return totalSize;
-	      },
-
-	      /**
-	       * Returns the total size uploaded of all files in bytes.
-	       * @function
-	       * @returns {number}
-	       */
-	      sizeUploaded: function sizeUploaded() {
-	        var size = 0;
-	        each(this.files, function (file) {
-	          size += file.sizeUploaded();
-	        });
-	        return size;
-	      },
-
-	      /**
-	       * Returns remaining time to upload all files in seconds. Accuracy is based on average speed.
-	       * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`
-	       * @function
-	       * @returns {number}
-	       */
-	      timeRemaining: function timeRemaining() {
-	        var sizeDelta = 0;
-	        var averageSpeed = 0;
-	        each(this.files, function (file) {
-	          if (!file.paused && !file.error) {
-	            sizeDelta += file.size - file.sizeUploaded();
-	            averageSpeed += file.averageSpeed;
-	          }
-	        });
+	      var delta = this.size - this.sizeUploaded();
+
+	      if (delta && !this.averageSpeed) {
+	        return Number.POSITIVE_INFINITY;
+	      }
+
+	      if (!delta && !this.averageSpeed) {
+	        return 0;
+	      }
+
+	      return Math.floor(delta / this.averageSpeed);
+	    }
+	    /**
+	     * Get file type
+	     * @function
+	     * @returns {string}
+	     */
+
+	  }, {
+	    key: "getType",
+	    value: function getType() {
+	      return this.file.type && this.file.type.split('/')[1];
+	    }
+	    /**
+	     * Get file extension
+	     * @function
+	     * @returns {string}
+	     */
+
+	  }, {
+	    key: "getExtension",
+	    value: function getExtension() {
+	      return this.name.substr((~-this.name.lastIndexOf(".") >>> 0) + 2).toLowerCase();
+	    }
+	  }]);
+
+	  return FlowFile;
+	}();
+	var g$1 = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+	g$1.FlowFile = FlowFile;
+
+	/**
+	 * Flow.js is a library providing multiple simultaneous, stable and
+	 * resumable uploads via the HTML5 File API.
+	 * @param [opts]
+	 * @param {number|Function} [opts.chunkSize]
+	 * @param {bool} [opts.forceChunkSize]
+	 * @param {number} [opts.simultaneousUploads]
+	 * @param {bool} [opts.singleFile]
+	 * @param {string} [opts.fileParameterName]
+	 * @param {number} [opts.progressCallbacksInterval]
+	 * @param {number} [opts.speedSmoothingFactor]
+	 * @param {Object|Function} [opts.query]
+	 * @param {Object|Function} [opts.headers]
+	 * @param {bool} [opts.withCredentials]
+	 * @param {Function} [opts.preprocess]
+	 * @param {string} [opts.method]
+	 * @param {string|Function} [opts.testMethod]
+	 * @param {string|Function} [opts.uploadMethod]
+	 * @param {bool} [opts.prioritizeFirstAndLastChunk]
+	 * @param {bool} [opts.allowDuplicateUploads]
+	 * @param {string|Function} [opts.target]
+	 * @param {number} [opts.maxChunkRetries]
+	 * @param {number} [opts.chunkRetryInterval]
+	 * @param {Array.<number>} [opts.permanentErrors]
+	 * @param {Array.<number>} [opts.successStatuses]
+	 * @param {Function} [opts.initFileFn]
+	 * @param {Function} [opts.readFileFn]
+	 * @param {Function} [opts.generateUniqueIdentifier]
+	 * @constructor
+	 */
+
+	var Flow = /*#__PURE__*/function () {
+	  function Flow(opts) {
+	    _classCallCheck(this, Flow);
+
+	    /**
+	     * Library version
+	     * @type {string}
+	     */
+	    Flow.version = '2.14.1';
+	    /**
+	     * Check if directory upload is supported
+	     * @type {boolean}
+	     */
+
+	    this.supportDirectory = /Chrome/.test(window.navigator.userAgent) || /Firefox/.test(window.navigator.userAgent) || /Edge/.test(window.navigator.userAgent);
+	    /**
+	     * List of FlowFile objects
+	     * @type {Array.<FlowFile>}
+	     */
+
+	    this.files = [];
+	    /**
+	     * Default options for flow.js
+	     * @type {Object}
+	     */
+
+	    this.defaults = {
+	      chunkSize: 1024 * 1024,
+	      forceChunkSize: false,
+	      simultaneousUploads: 3,
+	      singleFile: false,
+	      fileParameterName: 'file',
+	      progressCallbacksInterval: 500,
+	      speedSmoothingFactor: 0.1,
+	      query: {},
+	      headers: {},
+	      withCredentials: false,
+	      preprocess: null,
+	      changeRawDataBeforeSend: null,
+	      method: 'multipart',
+	      testMethod: 'GET',
+	      uploadMethod: 'POST',
+	      prioritizeFirstAndLastChunk: false,
+	      allowDuplicateUploads: false,
+	      target: '/',
+	      testChunks: true,
+	      generateUniqueIdentifier: null,
+	      maxChunkRetries: 0,
+	      chunkRetryInterval: null,
+	      permanentErrors: [404, 413, 415, 500, 501],
+	      successStatuses: [200, 201, 202],
+	      onDropStopPropagation: false,
+	      initFileFn: null,
+	      readFileFn: webAPIFileRead
+	    };
+	    /**
+	     * Current options
+	     * @type {Object}
+	     */
+
+	    this.opts = {};
+	    /**
+	     * List of events:
+	     *  key stands for event name
+	     *  value array list of callbacks
+	     * @type {}
+	     */
+
+	    this.events = {};
+	    /**
+	     * Current options
+	     * @type {Object}
+	     */
+
+	    this.opts = extend({}, this.defaults, opts || {}); // A workaround for using this.method.bind(this) as a (removable) event handler.
+	    // https://stackoverflow.com/questions/11565471
+
+	    this._onDropBound = null;
+	  }
+	  /**
+	   * On drop event
+	   * @function
+	   * @param {MouseEvent} event
+	   */
+
+
+	  _createClass(Flow, [{
+	    key: "onDrop",
+	    value: function onDrop(event) {
+	      if (this.opts.onDropStopPropagation) {
+	        event.stopPropagation();
+	      }
+
+	      event.preventDefault();
+	      var dataTransfer = event.dataTransfer;
+
+	      if (dataTransfer.items && dataTransfer.items[0] && dataTransfer.items[0].webkitGetAsEntry) {
+	        this.webkitReadDataTransfer(event);
+	      } else {
+	        this.addFiles(dataTransfer.files, event);
+	      }
+	    }
+	    /**
+	     * Prevent default
+	     * @function
+	     * @param {MouseEvent} event
+	     */
+
+	  }, {
+	    key: "preventEvent",
+	    value: function preventEvent(event) {
+	      event.preventDefault();
+	    }
+	    /**
+	     * Set a callback for an event, possible events:
+	     * fileSuccess(file), fileProgress(file), fileAdded(file, event),
+	     * fileRemoved(file), fileRetry(file), fileError(file, message),
+	     * complete(), progress(), error(message, file), pause()
+	     * @function
+	     * @param {string} event
+	     * @param {Function} callback
+	     */
+
+	  }, {
+	    key: "on",
+	    value: function on(event, callback) {
+	      event = event.toLowerCase();
+
+	      if (!this.events.hasOwnProperty(event)) {
+	        this.events[event] = [];
+	      }
+
+	      this.events[event].push(callback);
+	    }
+	    /**
+	     * Remove event callback
+	     * @function
+	     * @param {string} [event] removes all events if not specified
+	     * @param {Function} [fn] removes all callbacks of event if not specified
+	     */
 
-	        if (sizeDelta && !averageSpeed) {
-	          return Number.POSITIVE_INFINITY;
-	        }
+	  }, {
+	    key: "off",
+	    value: function off(event, fn) {
+	      if (event !== undefined) {
+	        event = event.toLowerCase();
 
-	        if (!sizeDelta && !averageSpeed) {
-	          return 0;
+	        if (fn !== undefined) {
+	          if (this.events.hasOwnProperty(event)) {
+	            arrayRemove(this.events[event], fn);
+	          }
+	        } else {
+	          delete this.events[event];
 	        }
-
-	        return Math.floor(sizeDelta / averageSpeed);
+	      } else {
+	        this.events = {};
 	      }
-	    };
+	    }
 	    /**
-	     * FlowFile class
-	     * @name FlowFile
-	     * @param {Flow} flowObj
-	     * @param {File} file
-	     * @param {string} uniqueIdentifier
-	     * @constructor
-	     */
-
-	    function FlowFile(flowObj, file, uniqueIdentifier) {
-	      /**
-	       * Reference to parent Flow instance
-	       * @type {Flow}
-	       */
-	      this.flowObj = flowObj;
-	      /**
-	       * Used to store the bytes read
-	       * @type {Blob|string}
-	       */
-
-	      this.bytes = null;
-	      /**
-	       * Reference to file
-	       * @type {File}
-	       */
-
-	      this.file = file;
-	      /**
-	       * File name. Some confusion in different versions of Firefox
-	       * @type {string}
-	       */
-
-	      this.name = file.fileName || file.name;
-	      /**
-	       * File size
-	       * @type {number}
-	       */
-
-	      this.size = file.size;
-	      /**
-	       * Relative file path
-	       * @type {string}
-	       */
-
-	      this.relativePath = file.relativePath || file.webkitRelativePath || this.name;
-	      /**
-	       * File unique identifier
-	       * @type {string}
-	       */
-
-	      this.uniqueIdentifier = uniqueIdentifier === undefined$1 ? flowObj.generateUniqueIdentifier(file) : uniqueIdentifier;
-	      /**
-	       * Size of Each Chunk
-	       * @type {number}
-	       */
-
-	      this.chunkSize = 0;
-	      /**
-	       * List of chunks
-	       * @type {Array.<FlowChunk>}
-	       */
-
-	      this.chunks = [];
-	      /**
-	       * Indicated if file is paused
-	       * @type {boolean}
-	       */
-
-	      this.paused = false;
-	      /**
-	       * Indicated if file has encountered an error
-	       * @type {boolean}
-	       */
-
-	      this.error = false;
-	      /**
-	       * Average upload speed
-	       * @type {number}
-	       */
+	     * Fire an event
+	     * @function
+	     * @param {string} event event name
+	     * @param {...} args arguments of a callback
+	     * @return {bool} value is false if at least one of the event handlers which handled this event
+	     * returned false. Otherwise it returns true.
+	     */
 
-	      this.averageSpeed = 0;
-	      /**
-	       * Current upload speed
-	       * @type {number}
-	       */
+	  }, {
+	    key: "fire",
+	    value: function fire(event, args) {
+	      // `arguments` is an object, not array, in FF, so:
+	      args = Array.prototype.slice.call(arguments);
+	      event = event.toLowerCase();
+	      var preventDefault = false;
+
+	      if (this.events.hasOwnProperty(event)) {
+	        each(this.events[event], function (callback) {
+	          preventDefault = callback.apply(this, args.slice(1)) === false || preventDefault;
+	        }, this);
+	      }
 
-	      this.currentSpeed = 0;
-	      /**
-	       * Date then progress was called last time
-	       * @type {number}
-	       * @private
-	       */
-
-	      this._lastProgressCallback = Date.now();
-	      /**
-	       * Previously uploaded file size
-	       * @type {number}
-	       * @private
-	       */
-
-	      this._prevUploadedSize = 0;
-	      /**
-	       * Holds previous progress
-	       * @type {number}
-	       * @private
-	       */
+	      if (event != 'catchall') {
+	        args.unshift('catchAll');
+	        preventDefault = this.fire.apply(this, args) === false || preventDefault;
+	      }
 
-	      this._prevProgress = 0;
-	      this.bootstrap();
+	      return !preventDefault;
 	    }
+	    /**
+	     * Read webkit dataTransfer object
+	     * @param event
+	     */
 
-	    FlowFile.prototype = {
-	      /**
-	       * Update speed parameters
-	       * @link http://stackoverflow.com/questions/2779600/how-to-estimate-download-time-remaining-accurately
-	       * @function
-	       */
-	      measureSpeed: function measureSpeed() {
-	        var timeSpan = Date.now() - this._lastProgressCallback;
+	  }, {
+	    key: "webkitReadDataTransfer",
+	    value: function webkitReadDataTransfer(event) {
+	      var _this = this;
 
-	        if (!timeSpan) {
-	          return;
+	      var queue = event.dataTransfer.items.length;
+
+	      var decrement = function decrement() {
+	        if (--queue == 0) {
+	          _this.addFiles(files, event);
 	        }
+	      };
 
-	        var smoothingFactor = this.flowObj.opts.speedSmoothingFactor;
-	        var uploaded = this.sizeUploaded(); // Prevent negative upload speed after file upload resume
-
-	        this.currentSpeed = Math.max((uploaded - this._prevUploadedSize) / timeSpan * 1000, 0);
-	        this.averageSpeed = smoothingFactor * this.currentSpeed + (1 - smoothingFactor) * this.averageSpeed;
-	        this._prevUploadedSize = uploaded;
-	      },
-
-	      /**
-	       * For internal usage only.
-	       * Callback when something happens within the chunk.
-	       * @function
-	       * @param {FlowChunk} chunk
-	       * @param {string} event can be 'progress', 'success', 'error' or 'retry'
-	       * @param {string} [message]
-	       */
-	      chunkEvent: function chunkEvent(chunk, event, message) {
-	        switch (event) {
-	          case 'progress':
-	            if (Date.now() - this._lastProgressCallback < this.flowObj.opts.progressCallbacksInterval) {
-	              break;
-	            }
+	      var files = [];
 
-	            this.measureSpeed();
-	            this.flowObj.fire('fileProgress', this, chunk);
-	            this.flowObj.fire('progress');
-	            this._lastProgressCallback = Date.now();
-	            break;
+	      var _iterator = _createForOfIteratorHelper(event.dataTransfer.items),
+	          _step;
 
-	          case 'error':
-	            this.error = true;
-	            this.abort(true);
-	            this.flowObj.fire('fileError', this, message, chunk);
-	            this.flowObj.fire('error', message, this, chunk);
-	            break;
+	      try {
+	        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+	          var item = _step.value;
+	          var entry = item.webkitGetAsEntry();
 
-	          case 'success':
-	            if (this.error) {
-	              return;
-	            }
+	          if (!entry) {
+	            decrement();
+	            return;
+	          }
 
-	            this.measureSpeed();
-	            this.flowObj.fire('fileProgress', this, chunk);
-	            this.flowObj.fire('progress');
-	            this._lastProgressCallback = Date.now();
+	          if (entry.isFile) {
+	            // due to a bug in Chrome's File System API impl - #149735
+	            fileReadSuccess(item.getAsFile(), entry.fullPath);
+	          } else {
+	            readDirectory(entry.createReader());
+	          }
+	        }
+	      } catch (err) {
+	        _iterator.e(err);
+	      } finally {
+	        _iterator.f();
+	      }
 
-	            if (this.isComplete()) {
-	              this.currentSpeed = 0;
-	              this.averageSpeed = 0;
-	              this.flowObj.fire('fileSuccess', this, message, chunk);
-	            }
+	      function readDirectory(reader) {
+	        reader.readEntries(function (entries) {
+	          if (entries.length) {
+	            queue += entries.length;
 
-	            break;
+	            var _iterator2 = _createForOfIteratorHelper(entries),
+	                _step2;
 
-	          case 'retry':
-	            this.flowObj.fire('fileRetry', this, chunk);
-	            break;
-	        }
-	      },
-
-	      /**
-	       * Pause file upload
-	       * @function
-	       */
-	      pause: function pause() {
-	        this.paused = true;
-	        this.abort();
-	      },
-
-	      /**
-	       * Resume file upload
-	       * @function
-	       */
-	      resume: function resume() {
-	        this.paused = false;
-	        this.flowObj.upload();
-	      },
-
-	      /**
-	       * Abort current upload
-	       * @function
-	       */
-	      abort: function abort(reset) {
-	        this.currentSpeed = 0;
-	        this.averageSpeed = 0;
-	        var chunks = this.chunks;
-
-	        if (reset) {
-	          this.chunks = [];
-	        }
+	            try {
+	              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+	                var _entry = _step2.value;
 
-	        each(chunks, function (c) {
-	          if (c.status() === 'uploading') {
-	            c.abort();
-	            this.flowObj.uploadNextChunk();
-	          }
-	        }, this);
-	      },
-
-	      /**
-	       * Cancel current upload and remove from a list
-	       * @function
-	       */
-	      cancel: function cancel() {
-	        this.flowObj.removeFile(this);
-	      },
-
-	      /**
-	       * Retry aborted file upload
-	       * @function
-	       */
-	      retry: function retry() {
-	        this.bootstrap();
-	        this.flowObj.upload();
-	      },
-
-	      /**
-	       * Clear current chunks and slice file again
-	       * @function
-	       */
-	      bootstrap: function bootstrap() {
-	        if (typeof this.flowObj.opts.initFileFn === "function") {
-	          var ret = this.flowObj.opts.initFileFn(this);
-
-	          if (ret && 'then' in ret) {
-	            ret.then(this._bootstrap.bind(this));
-	            return;
+	                if (_entry.isFile) {
+	                  var fullPath = _entry.fullPath;
+
+	                  _entry.file(function (file) {
+	                    return fileReadSuccess(file, fullPath);
+	                  }, readError);
+	                } else if (_entry.isDirectory) {
+	                  readDirectory(_entry.createReader());
+	                }
+	              }
+	            } catch (err) {
+	              _iterator2.e(err);
+	            } finally {
+	              _iterator2.f();
+	            }
+
+	            readDirectory(reader);
+	          } else {
+	            decrement();
 	          }
-	        }
+	        }, readError);
+	      }
 
-	        this._bootstrap();
-	      },
-	      _bootstrap: function _bootstrap() {
-	        this.abort(true);
-	        this.error = false; // Rebuild stack of chunks from file
+	      function fileReadSuccess(file, fullPath) {
+	        // relative path should not start with "/"
+	        file.relativePath = fullPath.substring(1);
+	        files.push(file);
+	        decrement();
+	      }
 
-	        this._prevProgress = 0;
-	        var round = this.flowObj.opts.forceChunkSize ? Math.ceil : Math.floor;
-	        this.chunkSize = evalOpts(this.flowObj.opts.chunkSize, this);
-	        var chunks = Math.max(round(this.size / this.chunkSize), 1);
+	      function readError(fileError) {
+	        decrement();
+	        throw fileError;
+	      }
+	    }
+	    /**
+	     * Generate unique identifier for a file
+	     * @function
+	     * @param {FlowFile} file
+	     * @returns {string}
+	     */
 
-	        for (var offset = 0; offset < chunks; offset++) {
-	          this.chunks.push(new FlowChunk(this.flowObj, this, offset));
-	        }
-	      },
-
-	      /**
-	       * Get current upload progress status
-	       * @function
-	       * @returns {number} from 0 to 1
-	       */
-	      progress: function progress() {
-	        if (this.error) {
-	          return 1;
-	        }
+	  }, {
+	    key: "generateUniqueIdentifier",
+	    value: function generateUniqueIdentifier(file) {
+	      var custom = this.opts.generateUniqueIdentifier;
 
-	        if (this.chunks.length === 1) {
-	          this._prevProgress = Math.max(this._prevProgress, this.chunks[0].progress());
-	          return this._prevProgress;
-	        } // Sum up progress across everything
+	      if (typeof custom === 'function') {
+	        return custom(file);
+	      } // Some confusion in different versions of Firefox
 
 
-	        var bytesLoaded = 0;
-	        each(this.chunks, function (c) {
-	          // get chunk progress relative to entire file
-	          bytesLoaded += c.progress() * (c.endByte - c.startByte);
-	        });
-	        var percent = bytesLoaded / this.size; // We don't want to lose percentages when an upload is paused
+	      var relativePath = file.relativePath || file.webkitRelativePath || file.fileName || file.name;
+	      return file.size + '-' + relativePath.replace(/[^0-9a-zA-Z_-]/img, '');
+	    }
+	    /**
+	     * Upload next chunk from the queue
+	     * @function
+	     * @returns {boolean}
+	     * @private
+	     */
 
-	        this._prevProgress = Math.max(this._prevProgress, percent > 0.9999 ? 1 : percent);
-	        return this._prevProgress;
-	      },
-
-	      /**
-	       * Indicates if file is being uploaded at the moment
-	       * @function
-	       * @returns {boolean}
-	       */
-	      isUploading: function isUploading() {
-	        var uploading = false;
-	        each(this.chunks, function (chunk) {
-	          if (chunk.status() === 'uploading') {
-	            uploading = true;
+	  }, {
+	    key: "uploadNextChunk",
+	    value: function uploadNextChunk(preventEvents) {
+	      // 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.
+	      var found = false;
+
+	      if (this.opts.prioritizeFirstAndLastChunk) {
+	        each(this.files, function (file) {
+	          if (!file.paused && file.chunks.length && file.chunks[0].status() === 'pending') {
+	            file.chunks[0].send();
+	            found = true;
 	            return false;
 	          }
-	        });
-	        return uploading;
-	      },
-
-	      /**
-	       * Indicates if file is has finished uploading and received a response
-	       * @function
-	       * @returns {boolean}
-	       */
-	      isComplete: function isComplete() {
-	        var outstanding = false;
-	        each(this.chunks, function (chunk) {
-	          var status = chunk.status();
-
-	          if (status === 'pending' || status === 'uploading' || status === 'reading' || chunk.preprocessState === 1 || chunk.readState === 1) {
-	            outstanding = true;
+
+	          if (!file.paused && file.chunks.length > 1 && file.chunks[file.chunks.length - 1].status() === 'pending') {
+	            file.chunks[file.chunks.length - 1].send();
+	            found = true;
 	            return false;
 	          }
 	        });
-	        return !outstanding;
-	      },
-
-	      /**
-	       * Count total size uploaded
-	       * @function
-	       * @returns {number}
-	       */
-	      sizeUploaded: function sizeUploaded() {
-	        var size = 0;
-	        each(this.chunks, function (chunk) {
-	          size += chunk.sizeUploaded();
-	        });
-	        return size;
-	      },
-
-	      /**
-	       * Returns remaining time to finish upload file in seconds. Accuracy is based on average speed.
-	       * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`
-	       * @function
-	       * @returns {number}
-	       */
-	      timeRemaining: function timeRemaining() {
-	        if (this.paused || this.error) {
-	          return 0;
+
+	        if (found) {
+	          return found;
 	        }
+	      } // Now, simply look for the next, best thing to upload
 
-	        var delta = this.size - this.sizeUploaded();
 
-	        if (delta && !this.averageSpeed) {
-	          return Number.POSITIVE_INFINITY;
+	      each(this.files, function (file) {
+	        if (!file.paused) {
+	          each(file.chunks, function (chunk) {
+	            if (chunk.status() === 'pending') {
+	              chunk.send();
+	              found = true;
+	              return false;
+	            }
+	          });
 	        }
 
-	        if (!delta && !this.averageSpeed) {
-	          return 0;
+	        if (found) {
+	          return false;
 	        }
+	      });
 
-	        return Math.floor(delta / this.averageSpeed);
-	      },
-
-	      /**
-	       * Get file type
-	       * @function
-	       * @returns {string}
-	       */
-	      getType: function getType() {
-	        return this.file.type && this.file.type.split('/')[1];
-	      },
-
-	      /**
-	       * Get file extension
-	       * @function
-	       * @returns {string}
-	       */
-	      getExtension: function getExtension() {
-	        return this.name.substr((~-this.name.lastIndexOf(".") >>> 0) + 2).toLowerCase();
-	      }
-	    };
-	    /**
-	     * Default read function using the webAPI
-	     *
-	     * @function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk)
-	     *
-	     */
-
-	    function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk) {
-	      var function_name = 'slice';
-	      if (fileObj.file.slice) function_name = 'slice';else if (fileObj.file.mozSlice) function_name = 'mozSlice';else if (fileObj.file.webkitSlice) function_name = 'webkitSlice';
-	      chunk.readFinished(fileObj.file[function_name](startByte, endByte, fileType));
-	    }
-	    /**
-	     * Class for storing a single chunk
-	     * @name FlowChunk
-	     * @param {Flow} flowObj
-	     * @param {FlowFile} fileObj
-	     * @param {number} offset
-	     * @constructor
-	     */
-
-
-	    function FlowChunk(flowObj, fileObj, offset) {
-	      /**
-	       * Reference to parent flow object
-	       * @type {Flow}
-	       */
-	      this.flowObj = flowObj;
-	      /**
-	       * Reference to parent FlowFile object
-	       * @type {FlowFile}
-	       */
-
-	      this.fileObj = fileObj;
-	      /**
-	       * File offset
-	       * @type {number}
-	       */
-
-	      this.offset = offset;
-	      /**
-	       * Indicates if chunk existence was checked on the server
-	       * @type {boolean}
-	       */
-
-	      this.tested = false;
-	      /**
-	       * Number of retries performed
-	       * @type {number}
-	       */
-
-	      this.retries = 0;
-	      /**
-	       * Pending retry
-	       * @type {boolean}
-	       */
-
-	      this.pendingRetry = false;
-	      /**
-	       * Preprocess state
-	       * @type {number} 0 = unprocessed, 1 = processing, 2 = finished
-	       */
-
-	      this.preprocessState = 0;
-	      /**
-	       * Read state
-	       * @type {number} 0 = not read, 1 = reading, 2 = finished
-	       */
-
-	      this.readState = 0;
-	      /**
-	       * Bytes transferred from total request size
-	       * @type {number}
-	       */
+	      if (found) {
+	        return true;
+	      } // The are no more outstanding chunks to upload, check is everything is done
 
-	      this.loaded = 0;
-	      /**
-	       * Total request size
-	       * @type {number}
-	       */
 
-	      this.total = 0;
-	      /**
-	       * Size of a chunk
-	       * @type {number}
-	       */
-
-	      this.chunkSize = this.fileObj.chunkSize;
-	      /**
-	       * Chunk start byte in a file
-	       * @type {number}
-	       */
-
-	      this.startByte = this.offset * this.chunkSize;
-	      /**
-	       * A specific filename for this chunk which otherwise default to the main name
-	       * @type {string}
-	       */
-
-	      this.filename = null;
-	      /**
-	        * Compute the endbyte in a file
-	        *
-	        */
-
-	      this.computeEndByte = function () {
-	        var endByte = Math.min(this.fileObj.size, (this.offset + 1) * this.chunkSize);
-
-	        if (this.fileObj.size - endByte < this.chunkSize && !this.flowObj.opts.forceChunkSize) {
-	          // The last chunk will be bigger than the chunk size,
-	          // but less than 2 * this.chunkSize
-	          endByte = this.fileObj.size;
+	      var outstanding = false;
+	      each(this.files, function (file) {
+	        if (!file.isComplete()) {
+	          outstanding = true;
+	          return false;
 	        }
+	      });
 
-	        return endByte;
-	      };
-	      /**
-	       * Chunk end byte in a file
-	       * @type {number}
-	       */
+	      if (!outstanding && !preventEvents) {
+	        // All chunks have been uploaded, complete
+	        async(function () {
+	          this.fire('complete');
+	        }, this);
+	      }
 
+	      return false;
+	    }
+	    /**
+	     * Assign a browse action to one or more DOM nodes.
+	     * @function
+	     * @param {Element|Array.<Element>} domNodes
+	     * @param {boolean} isDirectory Pass in true to allow directories to
+	     * @param {boolean} singleFile prevent multi file upload
+	     * @param {Object} attributes set custom attributes:
+	     *  http://www.w3.org/TR/html-markup/input.file.html#input.file-attributes
+	     *  eg: accept: 'image/*'
+	     * be selected (Chrome only).
+	     */
 
-	      this.endByte = this.computeEndByte();
-	      /**
-	       * XMLHttpRequest
-	       * @type {XMLHttpRequest}
-	       */
+	  }, {
+	    key: "assignBrowse",
+	    value: function assignBrowse(domNodes, isDirectory, singleFile, attributes) {
+	      if (domNodes instanceof Element) {
+	        domNodes = [domNodes];
+	      }
 
-	      this.xhr = null;
-	      var $ = this;
-	      /**
-	       * Send chunk event
-	       * @param event
-	       * @param {...} args arguments of a callback
-	       */
-
-	      this.event = function (event, args) {
-	        args = Array.prototype.slice.call(arguments);
-	        args.unshift($);
-	        $.fileObj.chunkEvent.apply($.fileObj, args);
-	      };
-	      /**
-	       * Catch progress event
-	       * @param {ProgressEvent} event
-	       */
+	      each(domNodes, function (domNode) {
+	        var _this2 = this;
 
+	        var input;
 
-	      this.progressHandler = function (event) {
-	        if (event.lengthComputable) {
-	          $.loaded = event.loaded;
-	          $.total = event.total;
+	        if (domNode.tagName === 'INPUT' && domNode.type === 'file') {
+	          input = domNode;
+	        } else {
+	          input = document.createElement('input');
+	          input.setAttribute('type', 'file'); // display:none - not working in opera 12
+
+	          extend(input.style, {
+	            visibility: 'hidden',
+	            position: 'absolute',
+	            width: '1px',
+	            height: '1px'
+	          }); // for opera 12 browser, input must be assigned to a document
+
+	          domNode.appendChild(input); // https://developer.mozilla.org/en/using_files_from_web_applications)
+	          // event listener is executed two times
+	          // first one - original mouse click event
+	          // second - input.click(), input is inside domNode
+
+	          domNode.addEventListener('click', function () {
+	            input.click();
+	          }, false);
 	        }
 
-	        $.event('progress', event);
-	      };
-	      /**
-	       * Catch test event
-	       * @param {Event} event
-	       */
-
-
-	      this.testHandler = function (event) {
-	        var status = $.status(true);
-
-	        if (status === 'error') {
-	          $.event(status, $.message());
-	          $.flowObj.uploadNextChunk();
-	        } else if (status === 'success') {
-	          $.tested = true;
-	          $.event(status, $.message());
-	          $.flowObj.uploadNextChunk();
-	        } else if (!$.fileObj.paused) {
-	          // Error might be caused by file pause method
-	          // Chunks does not exist on the server side
-	          $.tested = true;
-	          $.send();
-	        }
-	      };
-	      /**
-	       * Upload has stopped
-	       * @param {Event} event
-	       */
-
-
-	      this.doneHandler = function (event) {
-	        var status = $.status();
-
-	        if (status === 'success' || status === 'error') {
-	          delete this.data;
-	          $.event(status, $.message());
-	          $.flowObj.uploadNextChunk();
-	        } else if (!$.fileObj.paused) {
-	          $.event('retry', $.message());
-	          $.pendingRetry = true;
-	          $.abort();
-	          $.retries++;
-	          var retryInterval = $.flowObj.opts.chunkRetryInterval;
-
-	          if (retryInterval !== null) {
-	            setTimeout(function () {
-	              $.send();
-	            }, retryInterval);
-	          } else {
-	            $.send();
-	          }
+	        if (!this.opts.singleFile && !singleFile) {
+	          input.setAttribute('multiple', 'multiple');
 	        }
-	      };
-	    }
 
-	    FlowChunk.prototype = {
-	      /**
-	       * Get params for a request
-	       * @function
-	       */
-	      getParams: function getParams() {
-	        return {
-	          flowChunkNumber: this.offset + 1,
-	          flowChunkSize: this.chunkSize,
-	          flowCurrentChunkSize: this.endByte - this.startByte,
-	          flowTotalSize: this.fileObj.size,
-	          flowIdentifier: this.fileObj.uniqueIdentifier,
-	          flowFilename: this.fileObj.name,
-	          flowRelativePath: this.fileObj.relativePath,
-	          flowTotalChunks: this.fileObj.chunks.length
-	        };
-	      },
-
-	      /**
-	       * Get target option with query params
-	       * @function
-	       * @param params
-	       * @returns {string}
-	       */
-	      getTarget: function getTarget(target, params) {
-	        if (params.length == 0) {
-	          return target;
+	        if (isDirectory) {
+	          input.setAttribute('webkitdirectory', 'webkitdirectory');
 	        }
 
-	        if (target.indexOf('?') < 0) {
-	          target += '?';
-	        } else {
-	          target += '&';
-	        }
+	        each(attributes, function (value, key) {
+	          input.setAttribute(key, value);
+	        }); // When new files are added, simply append them to the overall list
 
-	        return target + params.join('&');
-	      },
-
-	      /**
-	       * Makes a GET request without any data to see if the chunk has already
-	       * been uploaded in a previous session
-	       * @function
-	       */
-	      test: function test() {
-	        // Set up request and listen for event
-	        this.xhr = new XMLHttpRequest();
-	        this.xhr.addEventListener("load", this.testHandler, false);
-	        this.xhr.addEventListener("error", this.testHandler, false);
-	        var testMethod = evalOpts(this.flowObj.opts.testMethod, this.fileObj, this);
-	        var data = this.prepareXhrRequest(testMethod, true);
-	        this.xhr.send(data);
-	      },
-
-	      /**
-	       * Finish preprocess state
-	       * @function
-	       */
-	      preprocessFinished: function preprocessFinished() {
-	        // Re-compute the endByte after the preprocess function to allow an
-	        // implementer of preprocess to set the fileObj size
-	        this.endByte = this.computeEndByte();
-	        this.preprocessState = 2;
-	        this.send();
-	      },
-
-	      /**
-	       * Finish read state
-	       * @function
-	       */
-	      readFinished: function readFinished(bytes) {
-	        this.readState = 2;
-	        this.bytes = bytes;
-	        this.send();
-	      },
-
-	      /**
-	       * Uploads the actual data in a POST call
-	       * @function
-	       */
-	      send: function send() {
-	        var preprocess = this.flowObj.opts.preprocess;
-	        var read = this.flowObj.opts.readFileFn;
-
-	        if (typeof preprocess === 'function') {
-	          switch (this.preprocessState) {
-	            case 0:
-	              this.preprocessState = 1;
-	              preprocess(this);
-	              return;
-
-	            case 1:
-	              return;
+	        input.addEventListener('change', function (e) {
+	          if (e.target.value) {
+	            _this2.addFiles(e.target.files, e);
+
+	            e.target.value = '';
 	          }
-	        }
+	        }, false);
+	      }, this);
+	    }
+	    /**
+	     * Assign one or more DOM nodes as a drop target.
+	     * @function
+	     * @param {Element|Array.<Element>} domNodes
+	     */
 
-	        switch (this.readState) {
-	          case 0:
-	            this.readState = 1;
-	            read(this.fileObj, this.startByte, this.endByte, this.fileObj.file.type, this);
-	            return;
+	  }, {
+	    key: "assignDrop",
+	    value: function assignDrop(domNodes) {
+	      if (typeof domNodes.length === 'undefined') {
+	        domNodes = [domNodes];
+	      }
 
-	          case 1:
-	            return;
-	        }
+	      this._onDropBound = this.onDrop.bind(this);
 
-	        if (this.flowObj.opts.testChunks && !this.tested) {
-	          this.test();
-	          return;
+	      var _iterator3 = _createForOfIteratorHelper(domNodes),
+	          _step3;
+
+	      try {
+	        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+	          var domNode = _step3.value;
+	          domNode.addEventListener('dragover', this.preventEvent, false);
+	          domNode.addEventListener('dragenter', this.preventEvent, false);
+	          domNode.addEventListener('drop', this._onDropBound, false);
 	        }
+	      } catch (err) {
+	        _iterator3.e(err);
+	      } finally {
+	        _iterator3.f();
+	      }
+	    }
+	    /**
+	     * Un-assign drop event from DOM nodes
+	     * @function
+	     * @param domNodes
+	     */
 
-	        this.loaded = 0;
-	        this.total = 0;
-	        this.pendingRetry = false; // Set up request and listen for event
+	  }, {
+	    key: "unAssignDrop",
+	    value: function unAssignDrop(domNodes) {
+	      if (typeof domNodes.length === 'undefined') {
+	        domNodes = [domNodes];
+	      }
 
-	        this.xhr = new XMLHttpRequest();
-	        this.xhr.upload.addEventListener('progress', this.progressHandler, false);
-	        this.xhr.addEventListener("load", this.doneHandler, false);
-	        this.xhr.addEventListener("error", this.doneHandler, false);
-	        var uploadMethod = evalOpts(this.flowObj.opts.uploadMethod, this.fileObj, this);
-	        var data = this.prepareXhrRequest(uploadMethod, false, this.flowObj.opts.method, this.bytes);
-	        var changeRawDataBeforeSend = this.flowObj.opts.changeRawDataBeforeSend;
+	      var _iterator4 = _createForOfIteratorHelper(domNodes),
+	          _step4;
 
-	        if (typeof changeRawDataBeforeSend === 'function') {
-	          data = changeRawDataBeforeSend(this, data);
+	      try {
+	        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+	          var domNode = _step4.value;
+	          domNode.removeEventListener('dragover', this.preventEvent, false);
+	          domNode.removeEventListener('dragenter', this.preventEvent, false);
+	          domNode.removeEventListener('drop', this._onDropBound, false);
 	        }
+	      } catch (err) {
+	        _iterator4.e(err);
+	      } finally {
+	        _iterator4.f();
+	      }
+	    }
+	    /**
+	     * Returns a boolean indicating whether or not the instance is currently
+	     * uploading anything.
+	     * @function
+	     * @returns {boolean}
+	     */
 
-	        this.xhr.send(data);
-	      },
+	  }, {
+	    key: "isUploading",
+	    value: function isUploading() {
+	      var uploading = false;
+	      each(this.files, function (file) {
+	        if (file.isUploading()) {
+	          uploading = true;
+	          return false;
+	        }
+	      });
+	      return uploading;
+	    }
+	    /**
+	     * should upload next chunk
+	     * @function
+	     * @returns {boolean|number}
+	     */
 
-	      /**
-	       * Abort current xhr request
-	       * @function
-	       */
-	      abort: function abort() {
-	        // Abort and reset
-	        var xhr = this.xhr;
-	        this.xhr = null;
+	  }, {
+	    key: "_shouldUploadNext",
+	    value: function _shouldUploadNext() {
+	      var num = 0;
+	      var should = true;
+	      var simultaneousUploads = this.opts.simultaneousUploads;
+	      each(this.files, function (file) {
+	        each(file.chunks, function (chunk) {
+	          if (chunk.status() === 'uploading') {
+	            num++;
 
-	        if (xhr) {
-	          xhr.abort();
-	        }
-	      },
-
-	      /**
-	       * Retrieve current chunk upload status
-	       * @function
-	       * @returns {string} 'pending', 'uploading', 'success', 'error'
-	       */
-	      status: function status(isTest) {
-	        if (this.readState === 1) {
-	          return 'reading';
-	        } else if (this.pendingRetry || this.preprocessState === 1) {
-	          // 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 (!this.xhr) {
-	          return 'pending';
-	        } else if (this.xhr.readyState < 4) {
-	          // Status is really 'OPENED', 'HEADERS_RECEIVED'
-	          // or 'LOADING' - meaning that stuff is happening
-	          return 'uploading';
-	        } else {
-	          if (this.flowObj.opts.successStatuses.indexOf(this.xhr.status) > -1) {
-	            // HTTP 200, perfect
-	            // HTTP 202 Accepted - The request has been accepted for processing, but the processing has not been completed.
-	            return 'success';
-	          } else if (this.flowObj.opts.permanentErrors.indexOf(this.xhr.status) > -1 || !isTest && this.retries >= this.flowObj.opts.maxChunkRetries) {
-	            // HTTP 413/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
-	            this.abort();
-	            return 'pending';
+	            if (num >= simultaneousUploads) {
+	              should = false;
+	              return false;
+	            }
 	          }
-	        }
-	      },
-
-	      /**
-	       * Get response from xhr request
-	       * @function
-	       * @returns {String}
-	       */
-	      message: function message() {
-	        return this.xhr ? this.xhr.responseText : '';
-	      },
-
-	      /**
-	       * Get upload progress
-	       * @function
-	       * @returns {number}
-	       */
-	      progress: function progress() {
-	        if (this.pendingRetry) {
-	          return 0;
-	        }
+	        });
+	      }); // if should is true then return uploading chunks's length
+
+	      return should && num;
+	    }
+	    /**
+	     * Start or resume uploading.
+	     * @function
+	     */
 
-	        var s = this.status();
+	  }, {
+	    key: "upload",
+	    value: function upload() {
+	      // Make sure we don't start too many uploads at once
+	      var ret = this._shouldUploadNext();
 
-	        if (s === 'success' || s === 'error') {
-	          return 1;
-	        } else if (s === 'pending') {
-	          return 0;
-	        } else {
-	          return this.total > 0 ? this.loaded / this.total : 0;
-	        }
-	      },
-
-	      /**
-	       * Count total size uploaded
-	       * @function
-	       * @returns {number}
-	       */
-	      sizeUploaded: function sizeUploaded() {
-	        var size = this.endByte - this.startByte; // can't return only chunk.loaded value, because it is bigger than chunk size
-
-	        if (this.status() !== 'success') {
-	          size = this.progress() * size;
-	        }
+	      if (ret === false) {
+	        return;
+	      } // Kick off the queue
 
-	        return size;
-	      },
-
-	      /**
-	       * Prepare Xhr request. Set query, headers and data
-	       * @param {string} method GET or POST
-	       * @param {bool} isTest is this a test request
-	       * @param {string} [paramsMethod] octet or form
-	       * @param {Blob} [blob] to send
-	       * @returns {FormData|Blob|Null} data to send
-	       */
-	      prepareXhrRequest: function prepareXhrRequest(method, isTest, paramsMethod, blob) {
-	        // Add data from the query options
-	        var query = evalOpts(this.flowObj.opts.query, this.fileObj, this, isTest);
-	        query = extend(query || {}, this.getParams());
-	        var target = evalOpts(this.flowObj.opts.target, this.fileObj, this, isTest);
-	        var data = null;
-
-	        if (method === 'GET' || paramsMethod === 'octet') {
-	          // Add data from the query options
-	          var params = [];
-	          each(query, function (v, k) {
-	            params.push([encodeURIComponent(k), encodeURIComponent(v)].join('='));
-	          });
-	          target = this.getTarget(target, params);
-	          data = blob || null;
-	        } else {
-	          // Add data from the query options
-	          data = new FormData();
-	          each(query, function (v, k) {
-	            data.append(k, v);
-	          });
 
-	          if (typeof blob !== "undefined") {
-	            data.append(this.flowObj.opts.fileParameterName, blob, this.filename || this.fileObj.file.name);
-	          }
-	        }
+	      this.fire('uploadStart');
+	      var started = false;
 
-	        this.xhr.open(method, target, true);
-	        this.xhr.withCredentials = this.flowObj.opts.withCredentials; // Add data from header options
+	      for (var num = 1; num <= this.opts.simultaneousUploads - ret; num++) {
+	        started = this.uploadNextChunk(true) || started;
+	      }
 
-	        each(evalOpts(this.flowObj.opts.headers, this.fileObj, this, isTest), function (v, k) {
-	          this.xhr.setRequestHeader(k, v);
+	      if (!started) {
+	        async(function () {
+	          this.fire('complete');
 	        }, this);
-	        return data;
 	      }
-	    };
+	    }
 	    /**
-	     * Remove value from array
-	     * @param array
-	     * @param value
+	     * Resume uploading.
+	     * @function
 	     */
 
-	    function arrayRemove(array, value) {
-	      var index = array.indexOf(value);
-
-	      if (index > -1) {
-	        array.splice(index, 1);
-	      }
+	  }, {
+	    key: "resume",
+	    value: function resume() {
+	      each(this.files, function (file) {
+	        if (!file.isComplete()) {
+	          file.resume();
+	        }
+	      });
 	    }
 	    /**
-	     * If option is a function, evaluate it with given params
-	     * @param {*} data
-	     * @param {...} args arguments of a callback
-	     * @returns {*}
+	     * Pause uploading.
+	     * @function
 	     */
 
-
-	    function evalOpts(data, args) {
-	      if (typeof data === "function") {
-	        // `arguments` is an object, not array, in FF, so:
-	        args = Array.prototype.slice.call(arguments);
-	        data = data.apply(null, args.slice(1));
-	      }
-
-	      return data;
+	  }, {
+	    key: "pause",
+	    value: function pause() {
+	      each(this.files, function (file) {
+	        file.pause();
+	      });
 	    }
-
-	    Flow.evalOpts = evalOpts;
 	    /**
-	     * Execute function asynchronously
-	     * @param fn
-	     * @param context
+	     * Cancel upload of all FlowFile objects and remove them from the list.
+	     * @function
 	     */
 
-	    function async(fn, context) {
-	      setTimeout(fn.bind(context), 0);
+	  }, {
+	    key: "cancel",
+	    value: function cancel() {
+	      for (var i = this.files.length - 1; i >= 0; i--) {
+	        this.files[i].cancel();
+	      }
 	    }
 	    /**
-	     * Extends the destination object `dst` by copying all of the properties from
-	     * the `src` object(s) to `dst`. You can specify multiple `src` objects.
+	     * Returns a number between 0 and 1 indicating the current upload progress
+	     * of all files.
 	     * @function
-	     * @param {Object} dst Destination object.
-	     * @param {...Object} src Source object(s).
-	     * @returns {Object} Reference to `dst`.
+	     * @returns {number}
 	     */
 
+	  }, {
+	    key: "progress",
+	    value: function progress() {
+	      var totalDone = 0;
+	      var totalSize = 0; // Resume all chunks currently being uploaded
 
-	    function extend(dst, src) {
-	      each(arguments, function (obj) {
-	        if (obj !== dst) {
-	          each(obj, function (value, key) {
-	            dst[key] = value;
-	          });
-	        }
+	      each(this.files, function (file) {
+	        totalDone += file.progress() * file.size;
+	        totalSize += file.size;
 	      });
-	      return dst;
+	      return totalSize > 0 ? totalDone / totalSize : 0;
 	    }
+	    /**
+	     * Add a HTML5 File object to the list of files.
+	     * @function
+	     * @param {File} file
+	     * @param {Event} [event] event is optional
+	     */
 
-	    Flow.extend = extend;
+	  }, {
+	    key: "addFile",
+	    value: function addFile(file, event) {
+	      this.addFiles([file], event);
+	    }
 	    /**
-	     * Iterate each element of an object
+	     * Add a HTML5 File object to the list of files.
 	     * @function
-	     * @param {Array|Object} obj object or an array to iterate
-	     * @param {Function} callback first argument is a value and second is a key.
-	     * @param {Object=} context Object to become context (`this`) for the iterator function.
+	     * @param {FileList|Array} fileList
+	     * @param {Event} [event] event is optional
 	     */
 
-	    function each(obj, callback, context) {
-	      if (!obj) {
-	        return;
-	      }
+	  }, {
+	    key: "addFiles",
+	    value: function addFiles(fileList, event) {
+	      var files = []; // ie10+
 
-	      var key; // Is Array?
-	      // Array.isArray won't work, not only arrays can be iterated by index https://github.com/flowjs/ng-flow/issues/236#
+	      var ie10plus = window.navigator.msPointerEnabled;
+	      each(fileList, function (file) {
+	        // https://github.com/flowjs/flow.js/issues/55
+	        if ((!ie10plus || ie10plus && file.size > 0) && !(file.size % 4096 === 0 && (file.name === '.' || file.fileName === '.'))) {
+	          var uniqueIdentifier = this.generateUniqueIdentifier(file);
 
-	      if (typeof obj.length !== 'undefined') {
-	        for (key = 0; key < obj.length; key++) {
-	          if (callback.call(context, obj[key], key) === false) {
-	            return;
+	          if (this.opts.allowDuplicateUploads || !this.getFromUniqueIdentifier(uniqueIdentifier)) {
+	            var f = new FlowFile(this, file, uniqueIdentifier);
+
+	            if (this.fire('fileAdded', f, event)) {
+	              files.push(f);
+	            }
 	          }
 	        }
-	      } else {
-	        for (key in obj) {
-	          if (obj.hasOwnProperty(key) && callback.call(context, obj[key], key) === false) {
-	            return;
+	      }, this);
+
+	      if (this.fire('filesAdded', files, event)) {
+	        each(files, function (file) {
+	          if (this.opts.singleFile && this.files.length > 0) {
+	            this.removeFile(this.files[0]);
 	          }
+
+	          this.files.push(file);
+	        }, this);
+	        this.fire('filesSubmitted', files, event);
+	      }
+	    }
+	    /**
+	     * Cancel upload of a specific FlowFile object from the list.
+	     * @function
+	     * @param {FlowFile} file
+	     */
+
+	  }, {
+	    key: "removeFile",
+	    value: function removeFile(file) {
+	      for (var i = this.files.length - 1; i >= 0; i--) {
+	        if (this.files[i] === file) {
+	          this.files.splice(i, 1);
+	          file.abort();
+	          this.fire('fileRemoved', file);
 	        }
 	      }
 	    }
+	    /**
+	     * Look up a FlowFile object by its unique identifier.
+	     * @function
+	     * @param {string} uniqueIdentifier
+	     * @returns {boolean|FlowFile} false if file was not found
+	     */
 
-	    Flow.each = each;
+	  }, {
+	    key: "getFromUniqueIdentifier",
+	    value: function getFromUniqueIdentifier(uniqueIdentifier) {
+	      var ret = false;
+	      each(this.files, function (file) {
+	        if (file.uniqueIdentifier === uniqueIdentifier) {
+	          ret = file;
+	        }
+	      });
+	      return ret;
+	    }
 	    /**
-	     * FlowFile constructor
-	     * @type {FlowFile}
+	     * Returns the total size of all files in bytes.
+	     * @function
+	     * @returns {number}
 	     */
 
-	    Flow.FlowFile = FlowFile;
+	  }, {
+	    key: "getSize",
+	    value: function getSize() {
+	      var totalSize = 0;
+	      each(this.files, function (file) {
+	        totalSize += file.size;
+	      });
+	      return totalSize;
+	    }
 	    /**
-	     * FlowFile constructor
-	     * @type {FlowChunk}
+	     * Returns the total size uploaded of all files in bytes.
+	     * @function
+	     * @returns {number}
 	     */
 
-	    Flow.FlowChunk = FlowChunk;
+	  }, {
+	    key: "sizeUploaded",
+	    value: function sizeUploaded() {
+	      var size = 0;
+	      each(this.files, function (file) {
+	        size += file.sizeUploaded();
+	      });
+	      return size;
+	    }
 	    /**
-	     * Library version
-	     * @type {string}
+	     * Returns remaining time to upload all files in seconds. Accuracy is based on average speed.
+	     * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`
+	     * @function
+	     * @returns {number}
 	     */
 
-	    Flow.version = '2.14.1';
+	  }, {
+	    key: "timeRemaining",
+	    value: function timeRemaining() {
+	      var sizeDelta = 0;
+	      var averageSpeed = 0;
+	      each(this.files, function (file) {
+	        if (!file.paused && !file.error) {
+	          sizeDelta += file.size - file.sizeUploaded();
+	          averageSpeed += file.averageSpeed;
+	        }
+	      });
 
-	    if ( module && 'object' === "object") {
-	      // Expose Flow as module.exports in loaders that implement the Node
-	      // module pattern (including browserify). Do not create the global, since
-	      // the user will be storing it themselves locally, and globals are frowned
-	      // upon in the Node module world.
-	      module.exports = Flow;
-	    } else {
-	      // Otherwise expose Flow to the global object as usual
-	      window.Flow = Flow; // Register as a named AMD module, since Flow can be concatenated with other
-	      // files that may use define, but not via a proper concatenation script that
-	      // understands anonymous AMD modules. A named AMD is safest and most robust
-	      // way to register. Lowercase flow is used because AMD module names are
-	      // derived from file names, and Flow is normally delivered in a lowercase
-	      // file name. Do this after creating the global so that if an AMD module wants
-	      // to call noConflict to hide this version of Flow, it will work.
-
-	      if (typeof undefined$1 === "function" && undefined$1.amd) {
-	        undefined$1("flow", [], function () {
-	          return Flow;
-	        });
+	      if (sizeDelta && !averageSpeed) {
+	        return Number.POSITIVE_INFINITY;
+	      }
+
+	      if (!sizeDelta && !averageSpeed) {
+	        return 0;
 	      }
+
+	      return Math.floor(sizeDelta / averageSpeed);
 	    }
-	  })(typeof window !== 'undefined' && window, typeof document !== 'undefined' && document);
-	});
+	  }]);
+
+	  return Flow;
+	}();
 
-	return flow;
+	return Flow;
 
 })));
 //# sourceMappingURL=flow.js.map
diff --git a/dist/flow.min.js b/dist/flow.min.js
index ca59840b..1230b6d7 100644
--- a/dist/flow.min.js
+++ b/dist/flow.min.js
@@ -1,7 +1,3 @@
 /*! @flowjs/flow.js 2.14.1 */
-var t="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function e(t,e,n){return t(n={path:e,exports:{},require:function(t,e){return function(){throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs")}(null==e&&n.path)}},n.exports),n.exports}var n=function(t){return t&&t.Math==Math&&t},r=n("object"==typeof globalThis&&globalThis)||n("object"==typeof window&&window)||n("object"==typeof self&&self)||n("object"==typeof t&&t)||Function("return this")(),i=function(t){try{return!!t()}catch(t){return!0}},s=!i((function(){return 7!=Object.defineProperty({},1,{get:function(){return 7}})[1]})),o={}.propertyIsEnumerable,a=Object.getOwnPropertyDescriptor,u={f:a&&!o.call({1:2},1)?function(t){var e=a(this,t);return!!e&&e.enumerable}:o},l=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}},f={}.toString,c=function(t){return f.call(t).slice(8,-1)},h="".split,p=i((function(){return!Object("z").propertyIsEnumerable(0)}))?function(t){return"String"==c(t)?h.call(t,""):Object(t)}:Object,d=function(t){if(null==t)throw TypeError("Can't call method on "+t);return t},v=function(t){return p(d(t))},g=function(t){return"object"==typeof t?null!==t:"function"==typeof t},y=function(t,e){if(!g(t))return t;var n,r;if(e&&"function"==typeof(n=t.toString)&&!g(r=n.call(t)))return r;if("function"==typeof(n=t.valueOf)&&!g(r=n.call(t)))return r;if(!e&&"function"==typeof(n=t.toString)&&!g(r=n.call(t)))return r;throw TypeError("Can't convert object to primitive value")},b={}.hasOwnProperty,m=function(t,e){return b.call(t,e)},w=r.document,S=g(w)&&g(w.createElement),O=function(t){return S?w.createElement(t):{}},x=!s&&!i((function(){return 7!=Object.defineProperty(O("div"),"a",{get:function(){return 7}}).a})),E=Object.getOwnPropertyDescriptor,j={f:s?E:function(t,e){if(t=v(t),e=y(e,!0),x)try{return E(t,e)}catch(t){}if(m(t,e))return l(!u.f.call(t,e),t[e])}},k=function(t){if(!g(t))throw TypeError(String(t)+" is not an object");return t},I=Object.defineProperty,C={f:s?I:function(t,e,n){if(k(t),e=y(e,!0),k(n),x)try{return I(t,e,n)}catch(t){}if("get"in n||"set"in n)throw TypeError("Accessors not supported");return"value"in n&&(t[e]=n.value),t}},P=s?function(t,e,n){return C.f(t,e,l(1,n))}:function(t,e,n){return t[e]=n,t},A=function(t,e){try{P(r,t,e)}catch(n){r[t]=e}return e},_=r["__core-js_shared__"]||A("__core-js_shared__",{}),R=Function.toString;"function"!=typeof _.inspectSource&&(_.inspectSource=function(t){return R.call(t)});var F,N,T,z=_.inspectSource,U=r.WeakMap,M="function"==typeof U&&/native code/.test(z(U)),D=e((function(t){(t.exports=function(t,e){return _[t]||(_[t]=void 0!==e?e:{})})("versions",[]).push({version:"3.6.5",mode:"global",copyright:"© 2020 Denis Pushkarev (zloirock.ru)"})})),L=0,B=Math.random(),q=function(t){return"Symbol("+String(void 0===t?"":t)+")_"+(++L+B).toString(36)},$=D("keys"),G=function(t){return $[t]||($[t]=q(t))},H={},X=r.WeakMap;if(M){var V=new X,Y=V.get,K=V.has,W=V.set;F=function(t,e){return W.call(V,t,e),e},N=function(t){return Y.call(V,t)||{}},T=function(t){return K.call(V,t)}}else{var Z=G("state");H[Z]=!0,F=function(t,e){return P(t,Z,e),e},N=function(t){return m(t,Z)?t[Z]:{}},T=function(t){return m(t,Z)}}var J={set:F,get:N,has:T,enforce:function(t){return T(t)?N(t):F(t,{})},getterFor:function(t){return function(e){var n;if(!g(e)||(n=N(e)).type!==t)throw TypeError("Incompatible receiver, "+t+" required");return n}}},Q=e((function(t){var e=J.get,n=J.enforce,i=String(String).split("String");(t.exports=function(t,e,s,o){var a=!!o&&!!o.unsafe,u=!!o&&!!o.enumerable,l=!!o&&!!o.noTargetGet;"function"==typeof s&&("string"!=typeof e||m(s,"name")||P(s,"name",e),n(s).source=i.join("string"==typeof e?e:"")),t!==r?(a?!l&&t[e]&&(u=!0):delete t[e],u?t[e]=s:P(t,e,s)):u?t[e]=s:A(e,s)})(Function.prototype,"toString",(function(){return"function"==typeof this&&e(this).source||z(this)}))})),tt=r,et=function(t){return"function"==typeof t?t:void 0},nt=function(t,e){return arguments.length<2?et(tt[t])||et(r[t]):tt[t]&&tt[t][e]||r[t]&&r[t][e]},rt=Math.ceil,it=Math.floor,st=function(t){return isNaN(t=+t)?0:(t>0?it:rt)(t)},ot=Math.min,at=function(t){return t>0?ot(st(t),9007199254740991):0},ut=Math.max,lt=Math.min,ft=function(t,e){var n=st(t);return n<0?ut(n+e,0):lt(n,e)},ct=function(t){return function(e,n,r){var i,s=v(e),o=at(s.length),a=ft(r,o);if(t&&n!=n){for(;o>a;)if((i=s[a++])!=i)return!0}else for(;o>a;a++)if((t||a in s)&&s[a]===n)return t||a||0;return!t&&-1}},ht={includes:ct(!0),indexOf:ct(!1)},pt=ht.indexOf,dt=function(t,e){var n,r=v(t),i=0,s=[];for(n in r)!m(H,n)&&m(r,n)&&s.push(n);for(;e.length>i;)m(r,n=e[i++])&&(~pt(s,n)||s.push(n));return s},vt=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],gt=vt.concat("length","prototype"),yt={f:Object.getOwnPropertyNames||function(t){return dt(t,gt)}},bt={f:Object.getOwnPropertySymbols},mt=nt("Reflect","ownKeys")||function(t){var e=yt.f(k(t)),n=bt.f;return n?e.concat(n(t)):e},wt=function(t,e){for(var n=mt(e),r=C.f,i=j.f,s=0;s<n.length;s++){var o=n[s];m(t,o)||r(t,o,i(e,o))}},St=/#|\.prototype\./,Ot=function(t,e){var n=Et[xt(t)];return n==kt||n!=jt&&("function"==typeof e?i(e):!!e)},xt=Ot.normalize=function(t){return String(t).replace(St,".").toLowerCase()},Et=Ot.data={},jt=Ot.NATIVE="N",kt=Ot.POLYFILL="P",It=Ot,Ct=j.f,Pt=function(t,e){var n,i,s,o,a,u=t.target,l=t.global,f=t.stat;if(n=l?r:f?r[u]||A(u,{}):(r[u]||{}).prototype)for(i in e){if(o=e[i],s=t.noTargetGet?(a=Ct(n,i))&&a.value:n[i],!It(l?i:u+(f?".":"#")+i,t.forced)&&void 0!==s){if(typeof o==typeof s)continue;wt(o,s)}(t.sham||s&&s.sham)&&P(o,"sham",!0),Q(n,i,o,t)}},At=function(t,e){var n=[][t];return!!n&&i((function(){n.call(null,e||function(){throw 1},1)}))},_t=Object.defineProperty,Rt={},Ft=function(t){throw t},Nt=function(t,e){if(m(Rt,t))return Rt[t];e||(e={});var n=[][t],r=!!m(e,"ACCESSORS")&&e.ACCESSORS,o=m(e,0)?e[0]:Ft,a=m(e,1)?e[1]:void 0;return Rt[t]=!!n&&!i((function(){if(r&&!s)return!0;var t={length:-1};r?_t(t,1,{enumerable:!0,get:Ft}):t[1]=1,n.call(t,o,a)}))},Tt=ht.indexOf,zt=[].indexOf,Ut=!!zt&&1/[1].indexOf(1,-0)<0,Mt=At("indexOf"),Dt=Nt("indexOf",{ACCESSORS:!0,1:0});Pt({target:"Array",proto:!0,forced:Ut||!Mt||!Dt},{indexOf:function(t){return Ut?zt.apply(this,arguments)||0:Tt(this,t,arguments.length>1?arguments[1]:void 0)}});var Lt=[].join,Bt=p!=Object,qt=At("join",",");Pt({target:"Array",proto:!0,forced:Bt||!qt},{join:function(t){return Lt.call(v(this),void 0===t?",":t)}});var $t=Math.min,Gt=[].lastIndexOf,Ht=!!Gt&&1/[1].lastIndexOf(1,-0)<0,Xt=At("lastIndexOf"),Vt=Nt("indexOf",{ACCESSORS:!0,1:0}),Yt=Ht||!Xt||!Vt?function(t){if(Ht)return Gt.apply(this,arguments)||0;var e=v(this),n=at(e.length),r=n-1;for(arguments.length>1&&(r=$t(r,st(arguments[1]))),r<0&&(r=n+r);r>=0;r--)if(r in e&&e[r]===t)return r||0;return-1}:Gt;Pt({target:"Array",proto:!0,forced:Yt!==[].lastIndexOf},{lastIndexOf:Yt});var Kt,Wt,Zt=Array.isArray||function(t){return"Array"==c(t)},Jt=function(t,e,n){var r=y(e);r in t?C.f(t,r,l(0,n)):t[r]=n},Qt=!!Object.getOwnPropertySymbols&&!i((function(){return!String(Symbol())})),te=Qt&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,ee=D("wks"),ne=r.Symbol,re=te?ne:ne&&ne.withoutSetter||q,ie=function(t){return m(ee,t)||(Qt&&m(ne,t)?ee[t]=ne[t]:ee[t]=re("Symbol."+t)),ee[t]},se=nt("navigator","userAgent")||"",oe=r.process,ae=oe&&oe.versions,ue=ae&&ae.v8;ue?Wt=(Kt=ue.split("."))[0]+Kt[1]:se&&(!(Kt=se.match(/Edge\/(\d+)/))||Kt[1]>=74)&&(Kt=se.match(/Chrome\/(\d+)/))&&(Wt=Kt[1]);var le=Wt&&+Wt,fe=ie("species"),ce=function(t){return le>=51||!i((function(){var e=[];return(e.constructor={})[fe]=function(){return{foo:1}},1!==e[t](Boolean).foo}))},he=ce("slice"),pe=Nt("slice",{ACCESSORS:!0,0:0,1:2}),de=ie("species"),ve=[].slice,ge=Math.max;Pt({target:"Array",proto:!0,forced:!he||!pe},{slice:function(t,e){var n,r,i,s=v(this),o=at(s.length),a=ft(t,o),u=ft(void 0===e?o:e,o);if(Zt(s)&&("function"!=typeof(n=s.constructor)||n!==Array&&!Zt(n.prototype)?g(n)&&null===(n=n[de])&&(n=void 0):n=void 0,n===Array||void 0===n))return ve.call(s,a,u);for(r=new(void 0===n?Array:n)(ge(u-a,0)),i=0;a<u;a++,i++)a in s&&Jt(r,i,s[a]);return r.length=i,r}});var ye=function(t){return Object(d(t))},be=ie("species"),me=function(t,e){var n;return Zt(t)&&("function"!=typeof(n=t.constructor)||n!==Array&&!Zt(n.prototype)?g(n)&&null===(n=n[be])&&(n=void 0):n=void 0),new(void 0===n?Array:n)(0===e?0:e)},we=ce("splice"),Se=Nt("splice",{ACCESSORS:!0,0:0,1:2}),Oe=Math.max,xe=Math.min;Pt({target:"Array",proto:!0,forced:!we||!Se},{splice:function(t,e){var n,r,i,s,o,a,u=ye(this),l=at(u.length),f=ft(t,l),c=arguments.length;if(0===c?n=r=0:1===c?(n=0,r=l-f):(n=c-2,r=xe(Oe(st(e),0),l-f)),l+n-r>9007199254740991)throw TypeError("Maximum allowed length exceeded");for(i=me(u,r),s=0;s<r;s++)(o=f+s)in u&&Jt(i,s,u[o]);if(i.length=r,n<r){for(s=f;s<l-r;s++)a=s+n,(o=s+r)in u?u[a]=u[o]:delete u[a];for(s=l;s>l-r+n;s--)delete u[s-1]}else if(n>r)for(s=l-r;s>f;s--)a=s+n-1,(o=s+r-1)in u?u[a]=u[o]:delete u[a];for(s=0;s<n;s++)u[s+f]=arguments[s+2];return u.length=l-r+n,i}});var Ee=C.f,je=Function.prototype,ke=je.toString,Ie=/^\s*function ([^ (]*)/;s&&!("name"in je)&&Ee(je,"name",{configurable:!0,get:function(){try{return ke.call(this).match(Ie)[1]}catch(t){return""}}});var Ce,Pe=Object.setPrototypeOf||("__proto__"in{}?function(){var t,e=!1,n={};try{(t=Object.getOwnPropertyDescriptor(Object.prototype,"__proto__").set).call(n,[]),e=n instanceof Array}catch(t){}return function(n,r){return k(n),function(t){if(!g(t)&&null!==t)throw TypeError("Can't set "+String(t)+" as a prototype")}(r),e?t.call(n,r):n.__proto__=r,n}}():void 0),Ae=function(t,e,n){var r,i;return Pe&&"function"==typeof(r=e.constructor)&&r!==n&&g(i=r.prototype)&&i!==n.prototype&&Pe(t,i),t},_e=Object.keys||function(t){return dt(t,vt)},Re=s?Object.defineProperties:function(t,e){k(t);for(var n,r=_e(e),i=r.length,s=0;i>s;)C.f(t,n=r[s++],e[n]);return t},Fe=nt("document","documentElement"),Ne=G("IE_PROTO"),Te=function(){},ze=function(t){return"<script>"+t+"<\/script>"},Ue=function(){try{Ce=document.domain&&new ActiveXObject("htmlfile")}catch(t){}var t,e;Ue=Ce?function(t){t.write(ze("")),t.close();var e=t.parentWindow.Object;return t=null,e}(Ce):((e=O("iframe")).style.display="none",Fe.appendChild(e),e.src=String("javascript:"),(t=e.contentWindow.document).open(),t.write(ze("document.F=Object")),t.close(),t.F);for(var n=vt.length;n--;)delete Ue.prototype[vt[n]];return Ue()};H[Ne]=!0;var Me=Object.create||function(t,e){var n;return null!==t?(Te.prototype=k(t),n=new Te,Te.prototype=null,n[Ne]=t):n=Ue(),void 0===e?n:Re(n,e)},De="[\t\n\v\f\r                　\u2028\u2029\ufeff]",Le=RegExp("^"+De+De+"*"),Be=RegExp(De+De+"*$"),qe=function(t){return function(e){var n=String(d(e));return 1&t&&(n=n.replace(Le,"")),2&t&&(n=n.replace(Be,"")),n}},$e={start:qe(1),end:qe(2),trim:qe(3)},Ge=yt.f,He=j.f,Xe=C.f,Ve=$e.trim,Ye=r.Number,Ke=Ye.prototype,We="Number"==c(Me(Ke)),Ze=function(t){var e,n,r,i,s,o,a,u,l=y(t,!1);if("string"==typeof l&&l.length>2)if(43===(e=(l=Ve(l)).charCodeAt(0))||45===e){if(88===(n=l.charCodeAt(2))||120===n)return NaN}else if(48===e){switch(l.charCodeAt(1)){case 66:case 98:r=2,i=49;break;case 79:case 111:r=8,i=55;break;default:return+l}for(o=(s=l.slice(2)).length,a=0;a<o;a++)if((u=s.charCodeAt(a))<48||u>i)return NaN;return parseInt(s,r)}return+l};if(It("Number",!Ye(" 0o1")||!Ye("0b1")||Ye("+0x1"))){for(var Je,Qe=function(t){var e=arguments.length<1?0:t,n=this;return n instanceof Qe&&(We?i((function(){Ke.valueOf.call(n)})):"Number"!=c(n))?Ae(new Ye(Ze(e)),n,Qe):Ze(e)},tn=s?Ge(Ye):"MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger".split(","),en=0;tn.length>en;en++)m(Ye,Je=tn[en])&&!m(Qe,Je)&&Xe(Qe,Je,He(Ye,Je));Qe.prototype=Ke,Ke.constructor=Qe,Q(r,"Number",Qe)}var nn=function(){var t=k(this),e="";return t.global&&(e+="g"),t.ignoreCase&&(e+="i"),t.multiline&&(e+="m"),t.dotAll&&(e+="s"),t.unicode&&(e+="u"),t.sticky&&(e+="y"),e};function rn(t,e){return RegExp(t,e)}var sn,on,an={UNSUPPORTED_Y:i((function(){var t=rn("a","y");return t.lastIndex=2,null!=t.exec("abcd")})),BROKEN_CARET:i((function(){var t=rn("^r","gy");return t.lastIndex=2,null!=t.exec("str")}))},un=RegExp.prototype.exec,ln=String.prototype.replace,fn=un,cn=(sn=/a/,on=/b*/g,un.call(sn,"a"),un.call(on,"a"),0!==sn.lastIndex||0!==on.lastIndex),hn=an.UNSUPPORTED_Y||an.BROKEN_CARET,pn=void 0!==/()??/.exec("")[1];(cn||pn||hn)&&(fn=function(t){var e,n,r,i,s=this,o=hn&&s.sticky,a=nn.call(s),u=s.source,l=0,f=t;return o&&(-1===(a=a.replace("y","")).indexOf("g")&&(a+="g"),f=String(t).slice(s.lastIndex),s.lastIndex>0&&(!s.multiline||s.multiline&&"\n"!==t[s.lastIndex-1])&&(u="(?: "+u+")",f=" "+f,l++),n=new RegExp("^(?:"+u+")",a)),pn&&(n=new RegExp("^"+u+"$(?!\\s)",a)),cn&&(e=s.lastIndex),r=un.call(o?n:s,f),o?r?(r.input=r.input.slice(l),r[0]=r[0].slice(l),r.index=s.lastIndex,s.lastIndex+=r[0].length):s.lastIndex=0:cn&&r&&(s.lastIndex=s.global?r.index+r[0].length:e),pn&&r&&r.length>1&&ln.call(r[0],n,(function(){for(i=1;i<arguments.length-2;i++)void 0===arguments[i]&&(r[i]=void 0)})),r});var dn=fn;Pt({target:"RegExp",proto:!0,forced:/./.exec!==dn},{exec:dn});var vn=ie("species"),gn=!i((function(){var t=/./;return t.exec=function(){var t=[];return t.groups={a:"7"},t},"7"!=="".replace(t,"$<a>")})),yn="$0"==="a".replace(/./,"$0"),bn=ie("replace"),mn=!!/./[bn]&&""===/./[bn]("a","$0"),wn=!i((function(){var t=/(?:)/,e=t.exec;t.exec=function(){return e.apply(this,arguments)};var n="ab".split(t);return 2!==n.length||"a"!==n[0]||"b"!==n[1]})),Sn=function(t,e,n,r){var s=ie(t),o=!i((function(){var e={};return e[s]=function(){return 7},7!=""[t](e)})),a=o&&!i((function(){var e=!1,n=/a/;return"split"===t&&((n={}).constructor={},n.constructor[vn]=function(){return n},n.flags="",n[s]=/./[s]),n.exec=function(){return e=!0,null},n[s](""),!e}));if(!o||!a||"replace"===t&&(!gn||!yn||mn)||"split"===t&&!wn){var u=/./[s],l=n(s,""[t],(function(t,e,n,r,i){return e.exec===dn?o&&!i?{done:!0,value:u.call(e,n,r)}:{done:!0,value:t.call(n,e,r)}:{done:!1}}),{REPLACE_KEEPS_$0:yn,REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE:mn}),f=l[0],c=l[1];Q(String.prototype,t,f),Q(RegExp.prototype,s,2==e?function(t,e){return c.call(t,this,e)}:function(t){return c.call(t,this)})}r&&P(RegExp.prototype[s],"sham",!0)},On=function(t){return function(e,n){var r,i,s=String(d(e)),o=st(n),a=s.length;return o<0||o>=a?t?"":void 0:(r=s.charCodeAt(o))<55296||r>56319||o+1===a||(i=s.charCodeAt(o+1))<56320||i>57343?t?s.charAt(o):r:t?s.slice(o,o+2):i-56320+(r-55296<<10)+65536}},xn={codeAt:On(!1),charAt:On(!0)}.charAt,En=function(t,e,n){return e+(n?xn(t,e).length:1)},jn=function(t,e){var n=t.exec;if("function"==typeof n){var r=n.call(t,e);if("object"!=typeof r)throw TypeError("RegExp exec method returned something other than an Object or null");return r}if("RegExp"!==c(t))throw TypeError("RegExp#exec called on incompatible receiver");return dn.call(t,e)},kn=Math.max,In=Math.min,Cn=Math.floor,Pn=/\$([$&'`]|\d\d?|<[^>]*>)/g,An=/\$([$&'`]|\d\d?)/g;Sn("replace",2,(function(t,e,n,r){var i=r.REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE,s=r.REPLACE_KEEPS_$0,o=i?"$":"$0";return[function(n,r){var i=d(this),s=null==n?void 0:n[t];return void 0!==s?s.call(n,i,r):e.call(String(i),n,r)},function(t,r){if(!i&&s||"string"==typeof r&&-1===r.indexOf(o)){var u=n(e,t,this,r);if(u.done)return u.value}var l=k(t),f=String(this),c="function"==typeof r;c||(r=String(r));var h=l.global;if(h){var p=l.unicode;l.lastIndex=0}for(var d=[];;){var v=jn(l,f);if(null===v)break;if(d.push(v),!h)break;""===String(v[0])&&(l.lastIndex=En(f,at(l.lastIndex),p))}for(var g,y="",b=0,m=0;m<d.length;m++){v=d[m];for(var w=String(v[0]),S=kn(In(st(v.index),f.length),0),O=[],x=1;x<v.length;x++)O.push(void 0===(g=v[x])?g:String(g));var E=v.groups;if(c){var j=[w].concat(O,S,f);void 0!==E&&j.push(E);var I=String(r.apply(void 0,j))}else I=a(w,f,S,O,E,r);S>=b&&(y+=f.slice(b,S)+I,b=S+w.length)}return y+f.slice(b)}];function a(t,n,r,i,s,o){var a=r+t.length,u=i.length,l=An;return void 0!==s&&(s=ye(s),l=Pn),e.call(o,l,(function(e,o){var l;switch(o.charAt(0)){case"$":return"$";case"&":return t;case"`":return n.slice(0,r);case"'":return n.slice(a);case"<":l=s[o.slice(1,-1)];break;default:var f=+o;if(0===f)return e;if(f>u){var c=Cn(f/10);return 0===c?e:c<=u?void 0===i[c-1]?o.charAt(1):i[c-1]+o.charAt(1):e}l=i[f-1]}return void 0===l?"":l}))}}));var _n=ie("match"),Rn=ie("species"),Fn=function(t,e){var n,r=k(t).constructor;return void 0===r||null==(n=k(r)[Rn])?e:function(t){if("function"!=typeof t)throw TypeError(String(t)+" is not a function");return t}(n)},Nn=[].push,Tn=Math.min,zn=!i((function(){return!RegExp(4294967295,"y")}));Sn("split",2,(function(t,e,n){var r;return r="c"=="abbc".split(/(b)*/)[1]||4!="test".split(/(?:)/,-1).length||2!="ab".split(/(?:ab)*/).length||4!=".".split(/(.?)(.?)/).length||".".split(/()()/).length>1||"".split(/.?/).length?function(t,n){var r,i,s=String(d(this)),o=void 0===n?4294967295:n>>>0;if(0===o)return[];if(void 0===t)return[s];if(!g(r=t)||!(void 0!==(i=r[_n])?i:"RegExp"==c(r)))return e.call(s,t,o);for(var a,u,l,f=[],h=(t.ignoreCase?"i":"")+(t.multiline?"m":"")+(t.unicode?"u":"")+(t.sticky?"y":""),p=0,v=new RegExp(t.source,h+"g");(a=dn.call(v,s))&&!((u=v.lastIndex)>p&&(f.push(s.slice(p,a.index)),a.length>1&&a.index<s.length&&Nn.apply(f,a.slice(1)),l=a[0].length,p=u,f.length>=o));)v.lastIndex===a.index&&v.lastIndex++;return p===s.length?!l&&v.test("")||f.push(""):f.push(s.slice(p)),f.length>o?f.slice(0,o):f}:"0".split(void 0,0).length?function(t,n){return void 0===t&&0===n?[]:e.call(this,t,n)}:e,[function(e,n){var i=d(this),s=null==e?void 0:e[t];return void 0!==s?s.call(e,i,n):r.call(String(i),e,n)},function(t,i){var s=n(r,t,this,i,r!==e);if(s.done)return s.value;var o=k(t),a=String(this),u=Fn(o,RegExp),l=o.unicode,f=(o.ignoreCase?"i":"")+(o.multiline?"m":"")+(o.unicode?"u":"")+(zn?"y":"g"),c=new u(zn?o:"^(?:"+o.source+")",f),h=void 0===i?4294967295:i>>>0;if(0===h)return[];if(0===a.length)return null===jn(c,a)?[a]:[];for(var p=0,d=0,v=[];d<a.length;){c.lastIndex=zn?d:0;var g,y=jn(c,zn?a:a.slice(d));if(null===y||(g=Tn(at(c.lastIndex+(zn?0:d)),a.length))===p)d=En(a,d,l);else{if(v.push(a.slice(p,d)),v.length===h)return v;for(var b=1;b<=y.length-1;b++)if(v.push(y[b]),v.length===h)return v;d=p=g}}return v.push(a.slice(p)),v}]}),!zn);var Un=e((function(t){
-/**
-   * @license MIT
-   */
-!function(e,n,r){if(e&&n){var i=e.navigator.msPointerEnabled;s.prototype={on:function(t,e){t=t.toLowerCase(),this.events.hasOwnProperty(t)||(this.events[t]=[]),this.events[t].push(e)},off:function(t,e){var n,i,s;t!==r?(t=t.toLowerCase(),e!==r?this.events.hasOwnProperty(t)&&(n=this.events[t],i=e,(s=n.indexOf(i))>-1&&n.splice(s,1)):delete this.events[t]):this.events={}},fire:function(t,e){e=Array.prototype.slice.call(arguments),t=t.toLowerCase();var n=!1;return this.events.hasOwnProperty(t)&&h(this.events[t],(function(t){n=!1===t.apply(this,e.slice(1))||n}),this),"catchall"!=t&&(e.unshift("catchAll"),n=!1===this.fire.apply(this,e)||n),!n},webkitReadDataTransfer:function(t){var e=this,n=t.dataTransfer.items.length,r=[];function i(t){t.readEntries((function(e){e.length?(n+=e.length,h(e,(function(t){if(t.isFile){var e=t.fullPath;t.file((function(t){s(t,e)}),o)}else t.isDirectory&&i(t.createReader())})),i(t)):a()}),o)}function s(t,e){t.relativePath=e.substring(1),r.push(t),a()}function o(t){throw a(),t}function a(){0==--n&&e.addFiles(r,t)}h(t.dataTransfer.items,(function(t){var e=t.webkitGetAsEntry();e?e.isFile?s(t.getAsFile(),e.fullPath):i(e.createReader()):a()}))},generateUniqueIdentifier:function(t){var e=this.opts.generateUniqueIdentifier;if("function"==typeof e)return e(t);var n=t.relativePath||t.webkitRelativePath||t.fileName||t.name;return t.size+"-"+n.replace(/[^0-9a-zA-Z_-]/gim,"")},uploadNextChunk:function(t){var e=!1;if(this.opts.prioritizeFirstAndLastChunk&&(h(this.files,(function(t){return!t.paused&&t.chunks.length&&"pending"===t.chunks[0].status()?(t.chunks[0].send(),e=!0,!1):!t.paused&&t.chunks.length>1&&"pending"===t.chunks[t.chunks.length-1].status()?(t.chunks[t.chunks.length-1].send(),e=!0,!1):void 0})),e))return e;if(h(this.files,(function(t){if(t.paused||h(t.chunks,(function(t){if("pending"===t.status())return t.send(),e=!0,!1})),e)return!1})),e)return!0;var n=!1;return h(this.files,(function(t){if(!t.isComplete())return n=!0,!1})),n||t||f((function(){this.fire("complete")}),this),!1},assignBrowse:function(t,e,r,i){t instanceof Element&&(t=[t]),h(t,(function(t){var s;"INPUT"===t.tagName&&"file"===t.type?s=t:((s=n.createElement("input")).setAttribute("type","file"),c(s.style,{visibility:"hidden",position:"absolute",width:"1px",height:"1px"}),t.appendChild(s),t.addEventListener("click",(function(){s.click()}),!1)),this.opts.singleFile||r||s.setAttribute("multiple","multiple"),e&&s.setAttribute("webkitdirectory","webkitdirectory"),h(i,(function(t,e){s.setAttribute(e,t)}));var o=this;s.addEventListener("change",(function(t){t.target.value&&(o.addFiles(t.target.files,t),t.target.value="")}),!1)}),this)},assignDrop:function(t){void 0===t.length&&(t=[t]),h(t,(function(t){t.addEventListener("dragover",this.preventEvent,!1),t.addEventListener("dragenter",this.preventEvent,!1),t.addEventListener("drop",this.onDrop,!1)}),this)},unAssignDrop:function(t){void 0===t.length&&(t=[t]),h(t,(function(t){t.removeEventListener("dragover",this.preventEvent),t.removeEventListener("dragenter",this.preventEvent),t.removeEventListener("drop",this.onDrop)}),this)},isUploading:function(){var t=!1;return h(this.files,(function(e){if(e.isUploading())return t=!0,!1})),t},_shouldUploadNext:function(){var t=0,e=!0,n=this.opts.simultaneousUploads;return h(this.files,(function(r){h(r.chunks,(function(r){if("uploading"===r.status()&&++t>=n)return e=!1,!1}))})),e&&t},upload:function(){var t=this._shouldUploadNext();if(!1!==t){this.fire("uploadStart");for(var e=!1,n=1;n<=this.opts.simultaneousUploads-t;n++)e=this.uploadNextChunk(!0)||e;e||f((function(){this.fire("complete")}),this)}},resume:function(){h(this.files,(function(t){t.isComplete()||t.resume()}))},pause:function(){h(this.files,(function(t){t.pause()}))},cancel:function(){for(var t=this.files.length-1;t>=0;t--)this.files[t].cancel()},progress:function(){var t=0,e=0;return h(this.files,(function(n){t+=n.progress()*n.size,e+=n.size})),e>0?t/e:0},addFile:function(t,e){this.addFiles([t],e)},addFiles:function(t,e){var n=[];h(t,(function(t){if((!i||i&&t.size>0)&&(t.size%4096!=0||"."!==t.name&&"."!==t.fileName)){var r=this.generateUniqueIdentifier(t);if(this.opts.allowDuplicateUploads||!this.getFromUniqueIdentifier(r)){var s=new o(this,t,r);this.fire("fileAdded",s,e)&&n.push(s)}}}),this),this.fire("filesAdded",n,e)&&(h(n,(function(t){this.opts.singleFile&&this.files.length>0&&this.removeFile(this.files[0]),this.files.push(t)}),this),this.fire("filesSubmitted",n,e))},removeFile:function(t){for(var e=this.files.length-1;e>=0;e--)this.files[e]===t&&(this.files.splice(e,1),t.abort(),this.fire("fileRemoved",t))},getFromUniqueIdentifier:function(t){var e=!1;return h(this.files,(function(n){n.uniqueIdentifier===t&&(e=n)})),e},getSize:function(){var t=0;return h(this.files,(function(e){t+=e.size})),t},sizeUploaded:function(){var t=0;return h(this.files,(function(e){t+=e.sizeUploaded()})),t},timeRemaining:function(){var t=0,e=0;return h(this.files,(function(n){n.paused||n.error||(t+=n.size-n.sizeUploaded(),e+=n.averageSpeed)})),t&&!e?Number.POSITIVE_INFINITY:t||e?Math.floor(t/e):0}},o.prototype={measureSpeed:function(){var t=Date.now()-this._lastProgressCallback;if(t){var e=this.flowObj.opts.speedSmoothingFactor,n=this.sizeUploaded();this.currentSpeed=Math.max((n-this._prevUploadedSize)/t*1e3,0),this.averageSpeed=e*this.currentSpeed+(1-e)*this.averageSpeed,this._prevUploadedSize=n}},chunkEvent:function(t,e,n){switch(e){case"progress":if(Date.now()-this._lastProgressCallback<this.flowObj.opts.progressCallbacksInterval)break;this.measureSpeed(),this.flowObj.fire("fileProgress",this,t),this.flowObj.fire("progress"),this._lastProgressCallback=Date.now();break;case"error":this.error=!0,this.abort(!0),this.flowObj.fire("fileError",this,n,t),this.flowObj.fire("error",n,this,t);break;case"success":if(this.error)return;this.measureSpeed(),this.flowObj.fire("fileProgress",this,t),this.flowObj.fire("progress"),this._lastProgressCallback=Date.now(),this.isComplete()&&(this.currentSpeed=0,this.averageSpeed=0,this.flowObj.fire("fileSuccess",this,n,t));break;case"retry":this.flowObj.fire("fileRetry",this,t)}},pause:function(){this.paused=!0,this.abort()},resume:function(){this.paused=!1,this.flowObj.upload()},abort:function(t){this.currentSpeed=0,this.averageSpeed=0;var e=this.chunks;t&&(this.chunks=[]),h(e,(function(t){"uploading"===t.status()&&(t.abort(),this.flowObj.uploadNextChunk())}),this)},cancel:function(){this.flowObj.removeFile(this)},retry:function(){this.bootstrap(),this.flowObj.upload()},bootstrap:function(){if("function"==typeof this.flowObj.opts.initFileFn){var t=this.flowObj.opts.initFileFn(this);if(t&&"then"in t)return void t.then(this._bootstrap.bind(this))}this._bootstrap()},_bootstrap:function(){this.abort(!0),this.error=!1,this._prevProgress=0;var t=this.flowObj.opts.forceChunkSize?Math.ceil:Math.floor;this.chunkSize=l(this.flowObj.opts.chunkSize,this);for(var e=Math.max(t(this.size/this.chunkSize),1),n=0;n<e;n++)this.chunks.push(new u(this.flowObj,this,n))},progress:function(){if(this.error)return 1;if(1===this.chunks.length)return this._prevProgress=Math.max(this._prevProgress,this.chunks[0].progress()),this._prevProgress;var t=0;h(this.chunks,(function(e){t+=e.progress()*(e.endByte-e.startByte)}));var e=t/this.size;return this._prevProgress=Math.max(this._prevProgress,e>.9999?1:e),this._prevProgress},isUploading:function(){var t=!1;return h(this.chunks,(function(e){if("uploading"===e.status())return t=!0,!1})),t},isComplete:function(){var t=!1;return h(this.chunks,(function(e){var n=e.status();if("pending"===n||"uploading"===n||"reading"===n||1===e.preprocessState||1===e.readState)return t=!0,!1})),!t},sizeUploaded:function(){var t=0;return h(this.chunks,(function(e){t+=e.sizeUploaded()})),t},timeRemaining:function(){if(this.paused||this.error)return 0;var t=this.size-this.sizeUploaded();return t&&!this.averageSpeed?Number.POSITIVE_INFINITY:t||this.averageSpeed?Math.floor(t/this.averageSpeed):0},getType:function(){return this.file.type&&this.file.type.split("/")[1]},getExtension:function(){return this.name.substr(2+(~-this.name.lastIndexOf(".")>>>0)).toLowerCase()}},u.prototype={getParams:function(){return{flowChunkNumber:this.offset+1,flowChunkSize:this.chunkSize,flowCurrentChunkSize:this.endByte-this.startByte,flowTotalSize:this.fileObj.size,flowIdentifier:this.fileObj.uniqueIdentifier,flowFilename:this.fileObj.name,flowRelativePath:this.fileObj.relativePath,flowTotalChunks:this.fileObj.chunks.length}},getTarget:function(t,e){return 0==e.length?t:(t.indexOf("?")<0?t+="?":t+="&",t+e.join("&"))},test:function(){this.xhr=new XMLHttpRequest,this.xhr.addEventListener("load",this.testHandler,!1),this.xhr.addEventListener("error",this.testHandler,!1);var t=l(this.flowObj.opts.testMethod,this.fileObj,this),e=this.prepareXhrRequest(t,!0);this.xhr.send(e)},preprocessFinished:function(){this.endByte=this.computeEndByte(),this.preprocessState=2,this.send()},readFinished:function(t){this.readState=2,this.bytes=t,this.send()},send:function(){var t=this.flowObj.opts.preprocess,e=this.flowObj.opts.readFileFn;if("function"==typeof t)switch(this.preprocessState){case 0:return this.preprocessState=1,void t(this);case 1:return}switch(this.readState){case 0:return this.readState=1,void e(this.fileObj,this.startByte,this.endByte,this.fileObj.file.type,this);case 1:return}if(!this.flowObj.opts.testChunks||this.tested){this.loaded=0,this.total=0,this.pendingRetry=!1,this.xhr=new XMLHttpRequest,this.xhr.upload.addEventListener("progress",this.progressHandler,!1),this.xhr.addEventListener("load",this.doneHandler,!1),this.xhr.addEventListener("error",this.doneHandler,!1);var n=l(this.flowObj.opts.uploadMethod,this.fileObj,this),r=this.prepareXhrRequest(n,!1,this.flowObj.opts.method,this.bytes),i=this.flowObj.opts.changeRawDataBeforeSend;"function"==typeof i&&(r=i(this,r)),this.xhr.send(r)}else this.test()},abort:function(){var t=this.xhr;this.xhr=null,t&&t.abort()},status:function(t){return 1===this.readState?"reading":this.pendingRetry||1===this.preprocessState?"uploading":this.xhr?this.xhr.readyState<4?"uploading":this.flowObj.opts.successStatuses.indexOf(this.xhr.status)>-1?"success":this.flowObj.opts.permanentErrors.indexOf(this.xhr.status)>-1||!t&&this.retries>=this.flowObj.opts.maxChunkRetries?"error":(this.abort(),"pending"):"pending"},message:function(){return this.xhr?this.xhr.responseText:""},progress:function(){if(this.pendingRetry)return 0;var t=this.status();return"success"===t||"error"===t?1:"pending"===t?0:this.total>0?this.loaded/this.total:0},sizeUploaded:function(){var t=this.endByte-this.startByte;return"success"!==this.status()&&(t=this.progress()*t),t},prepareXhrRequest:function(t,e,n,r){var i=l(this.flowObj.opts.query,this.fileObj,this,e);i=c(i||{},this.getParams());var s=l(this.flowObj.opts.target,this.fileObj,this,e),o=null;if("GET"===t||"octet"===n){var a=[];h(i,(function(t,e){a.push([encodeURIComponent(e),encodeURIComponent(t)].join("="))})),s=this.getTarget(s,a),o=r||null}else o=new FormData,h(i,(function(t,e){o.append(e,t)})),void 0!==r&&o.append(this.flowObj.opts.fileParameterName,r,this.filename||this.fileObj.file.name);return this.xhr.open(t,s,!0),this.xhr.withCredentials=this.flowObj.opts.withCredentials,h(l(this.flowObj.opts.headers,this.fileObj,this,e),(function(t,e){this.xhr.setRequestHeader(e,t)}),this),o}},s.evalOpts=l,s.extend=c,s.each=h,s.FlowFile=o,s.FlowChunk=u,s.version="2.14.1",t?t.exports=s:e.Flow=s}else console.warn("Flowjs needs window and document objects to work");function s(t){if(this.support=!("undefined"==typeof File||"undefined"==typeof Blob||"undefined"==typeof FileList||!Blob.prototype.slice&&!Blob.prototype.webkitSlice&&!Blob.prototype.mozSlice),this.support){this.supportDirectory=/Chrome/.test(e.navigator.userAgent)||/Firefox/.test(e.navigator.userAgent)||/Edge/.test(e.navigator.userAgent),this.files=[],this.defaults={chunkSize:1048576,forceChunkSize:!1,simultaneousUploads:3,singleFile:!1,fileParameterName:"file",progressCallbacksInterval:500,speedSmoothingFactor:.1,query:{},headers:{},withCredentials:!1,preprocess:null,changeRawDataBeforeSend:null,method:"multipart",testMethod:"GET",uploadMethod:"POST",prioritizeFirstAndLastChunk:!1,allowDuplicateUploads:!1,target:"/",testChunks:!0,generateUniqueIdentifier:null,maxChunkRetries:0,chunkRetryInterval:null,permanentErrors:[404,413,415,500,501],successStatuses:[200,201,202],onDropStopPropagation:!1,initFileFn:null,readFileFn:a},this.opts={},this.events={};var n=this;this.onDrop=function(t){n.opts.onDropStopPropagation&&t.stopPropagation(),t.preventDefault();var e=t.dataTransfer;e.items&&e.items[0]&&e.items[0].webkitGetAsEntry?n.webkitReadDataTransfer(t):n.addFiles(e.files,t)},this.preventEvent=function(t){t.preventDefault()},this.opts=s.extend({},this.defaults,t||{})}}function o(t,e,n){this.flowObj=t,this.bytes=null,this.file=e,this.name=e.fileName||e.name,this.size=e.size,this.relativePath=e.relativePath||e.webkitRelativePath||this.name,this.uniqueIdentifier=n===r?t.generateUniqueIdentifier(e):n,this.chunkSize=0,this.chunks=[],this.paused=!1,this.error=!1,this.averageSpeed=0,this.currentSpeed=0,this._lastProgressCallback=Date.now(),this._prevUploadedSize=0,this._prevProgress=0,this.bootstrap()}function a(t,e,n,r,i){var s="slice";t.file.slice?s="slice":t.file.mozSlice?s="mozSlice":t.file.webkitSlice&&(s="webkitSlice"),i.readFinished(t.file[s](e,n,r))}function u(t,e,n){this.flowObj=t,this.fileObj=e,this.offset=n,this.tested=!1,this.retries=0,this.pendingRetry=!1,this.preprocessState=0,this.readState=0,this.loaded=0,this.total=0,this.chunkSize=this.fileObj.chunkSize,this.startByte=this.offset*this.chunkSize,this.filename=null,this.computeEndByte=function(){var t=Math.min(this.fileObj.size,(this.offset+1)*this.chunkSize);return this.fileObj.size-t<this.chunkSize&&!this.flowObj.opts.forceChunkSize&&(t=this.fileObj.size),t},this.endByte=this.computeEndByte(),this.xhr=null;var r=this;this.event=function(t,e){(e=Array.prototype.slice.call(arguments)).unshift(r),r.fileObj.chunkEvent.apply(r.fileObj,e)},this.progressHandler=function(t){t.lengthComputable&&(r.loaded=t.loaded,r.total=t.total),r.event("progress",t)},this.testHandler=function(t){var e=r.status(!0);"error"===e?(r.event(e,r.message()),r.flowObj.uploadNextChunk()):"success"===e?(r.tested=!0,r.event(e,r.message()),r.flowObj.uploadNextChunk()):r.fileObj.paused||(r.tested=!0,r.send())},this.doneHandler=function(t){var e=r.status();if("success"===e||"error"===e)delete this.data,r.event(e,r.message()),r.flowObj.uploadNextChunk();else if(!r.fileObj.paused){r.event("retry",r.message()),r.pendingRetry=!0,r.abort(),r.retries++;var n=r.flowObj.opts.chunkRetryInterval;null!==n?setTimeout((function(){r.send()}),n):r.send()}}}function l(t,e){return"function"==typeof t&&(e=Array.prototype.slice.call(arguments),t=t.apply(null,e.slice(1))),t}function f(t,e){setTimeout(t.bind(e),0)}function c(t,e){return h(arguments,(function(e){e!==t&&h(e,(function(e,n){t[n]=e}))})),t}function h(t,e,n){var r;if(t)if(void 0!==t.length){for(r=0;r<t.length;r++)if(!1===e.call(n,t[r],r))return}else for(r in t)if(t.hasOwnProperty(r)&&!1===e.call(n,t[r],r))return}}("undefined"!=typeof window&&window,"undefined"!=typeof document&&document)}));export default Un;
+var e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function t(e,t,n){return e(n={path:t,exports:{},require:function(e,t){return function(){throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs")}(null==t&&n.path)}},n.exports),n.exports}var n=function(e){return e&&e.Math==Math&&e},r=n("object"==typeof globalThis&&globalThis)||n("object"==typeof window&&window)||n("object"==typeof self&&self)||n("object"==typeof e&&e)||Function("return this")(),i=function(e){try{return!!e()}catch(e){return!0}},s=!i((function(){return 7!=Object.defineProperty({},1,{get:function(){return 7}})[1]})),o={}.propertyIsEnumerable,a=Object.getOwnPropertyDescriptor,u={f:a&&!o.call({1:2},1)?function(e){var t=a(this,e);return!!t&&t.enumerable}:o},l=function(e,t){return{enumerable:!(1&e),configurable:!(2&e),writable:!(4&e),value:t}},f={}.toString,c=function(e){return f.call(e).slice(8,-1)},h="".split,p=i((function(){return!Object("z").propertyIsEnumerable(0)}))?function(e){return"String"==c(e)?h.call(e,""):Object(e)}:Object,d=function(e){if(null==e)throw TypeError("Can't call method on "+e);return e},v=function(e){return p(d(e))},g=function(e){return"object"==typeof e?null!==e:"function"==typeof e},y=function(e,t){if(!g(e))return e;var n,r;if(t&&"function"==typeof(n=e.toString)&&!g(r=n.call(e)))return r;if("function"==typeof(n=e.valueOf)&&!g(r=n.call(e)))return r;if(!t&&"function"==typeof(n=e.toString)&&!g(r=n.call(e)))return r;throw TypeError("Can't convert object to primitive value")},b={}.hasOwnProperty,m=function(e,t){return b.call(e,t)},w=r.document,S=g(w)&&g(w.createElement),k=function(e){return S?w.createElement(e):{}},O=!s&&!i((function(){return 7!=Object.defineProperty(k("div"),"a",{get:function(){return 7}}).a})),x=Object.getOwnPropertyDescriptor,E={f:s?x:function(e,t){if(e=v(e),t=y(t,!0),O)try{return x(e,t)}catch(e){}if(m(e,t))return l(!u.f.call(e,t),e[t])}},j=function(e){if(!g(e))throw TypeError(String(e)+" is not an object");return e},I=Object.defineProperty,C={f:s?I:function(e,t,n){if(j(e),t=y(t,!0),j(n),O)try{return I(e,t,n)}catch(e){}if("get"in n||"set"in n)throw TypeError("Accessors not supported");return"value"in n&&(e[t]=n.value),e}},A=s?function(e,t,n){return C.f(e,t,l(1,n))}:function(e,t,n){return e[t]=n,e},P=function(e,t){try{A(r,e,t)}catch(n){r[e]=t}return t},_=r["__core-js_shared__"]||P("__core-js_shared__",{}),R=Function.toString;"function"!=typeof _.inspectSource&&(_.inspectSource=function(e){return R.call(e)});var T,N,F,z=_.inspectSource,U=r.WeakMap,M="function"==typeof U&&/native code/.test(z(U)),D=t((function(e){(e.exports=function(e,t){return _[e]||(_[e]=void 0!==t?t:{})})("versions",[]).push({version:"3.6.5",mode:"global",copyright:"© 2020 Denis Pushkarev (zloirock.ru)"})})),L=0,B=Math.random(),q=function(e){return"Symbol("+String(void 0===e?"":e)+")_"+(++L+B).toString(36)},$=D("keys"),G=function(e){return $[e]||($[e]=q(e))},H={},X=r.WeakMap;if(M){var V=new X,Y=V.get,K=V.has,W=V.set;T=function(e,t){return W.call(V,e,t),t},N=function(e){return Y.call(V,e)||{}},F=function(e){return K.call(V,e)}}else{var Z=G("state");H[Z]=!0,T=function(e,t){return A(e,Z,t),t},N=function(e){return m(e,Z)?e[Z]:{}},F=function(e){return m(e,Z)}}var J,Q,ee={set:T,get:N,has:F,enforce:function(e){return F(e)?N(e):T(e,{})},getterFor:function(e){return function(t){var n;if(!g(t)||(n=N(t)).type!==e)throw TypeError("Incompatible receiver, "+e+" required");return n}}},te=t((function(e){var t=ee.get,n=ee.enforce,i=String(String).split("String");(e.exports=function(e,t,s,o){var a=!!o&&!!o.unsafe,u=!!o&&!!o.enumerable,l=!!o&&!!o.noTargetGet;"function"==typeof s&&("string"!=typeof t||m(s,"name")||A(s,"name",t),n(s).source=i.join("string"==typeof t?t:"")),e!==r?(a?!l&&e[t]&&(u=!0):delete e[t],u?e[t]=s:A(e,t,s)):u?e[t]=s:P(t,s)})(Function.prototype,"toString",(function(){return"function"==typeof this&&t(this).source||z(this)}))})),ne=r,re=function(e){return"function"==typeof e?e:void 0},ie=function(e,t){return arguments.length<2?re(ne[e])||re(r[e]):ne[e]&&ne[e][t]||r[e]&&r[e][t]},se=Math.ceil,oe=Math.floor,ae=function(e){return isNaN(e=+e)?0:(e>0?oe:se)(e)},ue=Math.min,le=function(e){return e>0?ue(ae(e),9007199254740991):0},fe=Math.max,ce=Math.min,he=function(e,t){var n=ae(e);return n<0?fe(n+t,0):ce(n,t)},pe=function(e){return function(t,n,r){var i,s=v(t),o=le(s.length),a=he(r,o);if(e&&n!=n){for(;o>a;)if((i=s[a++])!=i)return!0}else for(;o>a;a++)if((e||a in s)&&s[a]===n)return e||a||0;return!e&&-1}},de={includes:pe(!0),indexOf:pe(!1)},ve=de.indexOf,ge=function(e,t){var n,r=v(e),i=0,s=[];for(n in r)!m(H,n)&&m(r,n)&&s.push(n);for(;t.length>i;)m(r,n=t[i++])&&(~ve(s,n)||s.push(n));return s},ye=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],be=ye.concat("length","prototype"),me={f:Object.getOwnPropertyNames||function(e){return ge(e,be)}},we={f:Object.getOwnPropertySymbols},Se=ie("Reflect","ownKeys")||function(e){var t=me.f(j(e)),n=we.f;return n?t.concat(n(e)):t},ke=function(e,t){for(var n=Se(t),r=C.f,i=E.f,s=0;s<n.length;s++){var o=n[s];m(e,o)||r(e,o,i(t,o))}},Oe=/#|\.prototype\./,xe=function(e,t){var n=je[Ee(e)];return n==Ce||n!=Ie&&("function"==typeof t?i(t):!!t)},Ee=xe.normalize=function(e){return String(e).replace(Oe,".").toLowerCase()},je=xe.data={},Ie=xe.NATIVE="N",Ce=xe.POLYFILL="P",Ae=xe,Pe=E.f,_e=function(e,t){var n,i,s,o,a,u=e.target,l=e.global,f=e.stat;if(n=l?r:f?r[u]||P(u,{}):(r[u]||{}).prototype)for(i in t){if(o=t[i],s=e.noTargetGet?(a=Pe(n,i))&&a.value:n[i],!Ae(l?i:u+(f?".":"#")+i,e.forced)&&void 0!==s){if(typeof o==typeof s)continue;ke(o,s)}(e.sham||s&&s.sham)&&A(o,"sham",!0),te(n,i,o,e)}},Re=Array.isArray||function(e){return"Array"==c(e)},Te=function(e,t,n){var r=y(t);r in e?C.f(e,r,l(0,n)):e[r]=n},Ne=!!Object.getOwnPropertySymbols&&!i((function(){return!String(Symbol())})),Fe=Ne&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,ze=D("wks"),Ue=r.Symbol,Me=Fe?Ue:Ue&&Ue.withoutSetter||q,De=function(e){return m(ze,e)||(Ne&&m(Ue,e)?ze[e]=Ue[e]:ze[e]=Me("Symbol."+e)),ze[e]},Le=ie("navigator","userAgent")||"",Be=r.process,qe=Be&&Be.versions,$e=qe&&qe.v8;$e?Q=(J=$e.split("."))[0]+J[1]:Le&&(!(J=Le.match(/Edge\/(\d+)/))||J[1]>=74)&&(J=Le.match(/Chrome\/(\d+)/))&&(Q=J[1]);var Ge=Q&&+Q,He=De("species"),Xe=function(e){return Ge>=51||!i((function(){var t=[];return(t.constructor={})[He]=function(){return{foo:1}},1!==t[e](Boolean).foo}))},Ve=Object.defineProperty,Ye={},Ke=function(e){throw e},We=function(e,t){if(m(Ye,e))return Ye[e];t||(t={});var n=[][e],r=!!m(t,"ACCESSORS")&&t.ACCESSORS,o=m(t,0)?t[0]:Ke,a=m(t,1)?t[1]:void 0;return Ye[e]=!!n&&!i((function(){if(r&&!s)return!0;var e={length:-1};r?Ve(e,1,{enumerable:!0,get:Ke}):e[1]=1,n.call(e,o,a)}))},Ze=Xe("slice"),Je=We("slice",{ACCESSORS:!0,0:0,1:2}),Qe=De("species"),et=[].slice,tt=Math.max;_e({target:"Array",proto:!0,forced:!Ze||!Je},{slice:function(e,t){var n,r,i,s=v(this),o=le(s.length),a=he(e,o),u=he(void 0===t?o:t,o);if(Re(s)&&("function"!=typeof(n=s.constructor)||n!==Array&&!Re(n.prototype)?g(n)&&null===(n=n[Qe])&&(n=void 0):n=void 0,n===Array||void 0===n))return et.call(s,a,u);for(r=new(void 0===n?Array:n)(tt(u-a,0)),i=0;a<u;a++,i++)a in s&&Te(r,i,s[a]);return r.length=i,r}});var nt=function(e){return Object(d(e))},rt=De("species"),it=function(e,t){var n;return Re(e)&&("function"!=typeof(n=e.constructor)||n!==Array&&!Re(n.prototype)?g(n)&&null===(n=n[rt])&&(n=void 0):n=void 0),new(void 0===n?Array:n)(0===t?0:t)},st=Xe("splice"),ot=We("splice",{ACCESSORS:!0,0:0,1:2}),at=Math.max,ut=Math.min;_e({target:"Array",proto:!0,forced:!st||!ot},{splice:function(e,t){var n,r,i,s,o,a,u=nt(this),l=le(u.length),f=he(e,l),c=arguments.length;if(0===c?n=r=0:1===c?(n=0,r=l-f):(n=c-2,r=ut(at(ae(t),0),l-f)),l+n-r>9007199254740991)throw TypeError("Maximum allowed length exceeded");for(i=it(u,r),s=0;s<r;s++)(o=f+s)in u&&Te(i,s,u[o]);if(i.length=r,n<r){for(s=f;s<l-r;s++)a=s+n,(o=s+r)in u?u[a]=u[o]:delete u[a];for(s=l;s>l-r+n;s--)delete u[s-1]}else if(n>r)for(s=l-r;s>f;s--)a=s+n-1,(o=s+r-1)in u?u[a]=u[o]:delete u[a];for(s=0;s<n;s++)u[s+f]=arguments[s+2];return u.length=l-r+n,i}});var lt=C.f,ft=Function.prototype,ct=ft.toString,ht=/^\s*function ([^ (]*)/;s&&!("name"in ft)&&lt(ft,"name",{configurable:!0,get:function(){try{return ct.call(this).match(ht)[1]}catch(e){return""}}});var pt,dt=Object.setPrototypeOf||("__proto__"in{}?function(){var e,t=!1,n={};try{(e=Object.getOwnPropertyDescriptor(Object.prototype,"__proto__").set).call(n,[]),t=n instanceof Array}catch(e){}return function(n,r){return j(n),function(e){if(!g(e)&&null!==e)throw TypeError("Can't set "+String(e)+" as a prototype")}(r),t?e.call(n,r):n.__proto__=r,n}}():void 0),vt=function(e,t,n){var r,i;return dt&&"function"==typeof(r=t.constructor)&&r!==n&&g(i=r.prototype)&&i!==n.prototype&&dt(e,i),e},gt=Object.keys||function(e){return ge(e,ye)},yt=s?Object.defineProperties:function(e,t){j(e);for(var n,r=gt(t),i=r.length,s=0;i>s;)C.f(e,n=r[s++],t[n]);return e},bt=ie("document","documentElement"),mt=G("IE_PROTO"),wt=function(){},St=function(e){return"<script>"+e+"<\/script>"},kt=function(){try{pt=document.domain&&new ActiveXObject("htmlfile")}catch(e){}var e,t;kt=pt?function(e){e.write(St("")),e.close();var t=e.parentWindow.Object;return e=null,t}(pt):((t=k("iframe")).style.display="none",bt.appendChild(t),t.src=String("javascript:"),(e=t.contentWindow.document).open(),e.write(St("document.F=Object")),e.close(),e.F);for(var n=ye.length;n--;)delete kt.prototype[ye[n]];return kt()};H[mt]=!0;var Ot=Object.create||function(e,t){var n;return null!==e?(wt.prototype=j(e),n=new wt,wt.prototype=null,n[mt]=e):n=kt(),void 0===t?n:yt(n,t)},xt="[\t\n\v\f\r                　\u2028\u2029\ufeff]",Et=RegExp("^"+xt+xt+"*"),jt=RegExp(xt+xt+"*$"),It=function(e){return function(t){var n=String(d(t));return 1&e&&(n=n.replace(Et,"")),2&e&&(n=n.replace(jt,"")),n}},Ct={start:It(1),end:It(2),trim:It(3)},At=me.f,Pt=E.f,_t=C.f,Rt=Ct.trim,Tt=r.Number,Nt=Tt.prototype,Ft="Number"==c(Ot(Nt)),zt=function(e){var t,n,r,i,s,o,a,u,l=y(e,!1);if("string"==typeof l&&l.length>2)if(43===(t=(l=Rt(l)).charCodeAt(0))||45===t){if(88===(n=l.charCodeAt(2))||120===n)return NaN}else if(48===t){switch(l.charCodeAt(1)){case 66:case 98:r=2,i=49;break;case 79:case 111:r=8,i=55;break;default:return+l}for(o=(s=l.slice(2)).length,a=0;a<o;a++)if((u=s.charCodeAt(a))<48||u>i)return NaN;return parseInt(s,r)}return+l};if(Ae("Number",!Tt(" 0o1")||!Tt("0b1")||Tt("+0x1"))){for(var Ut,Mt=function(e){var t=arguments.length<1?0:e,n=this;return n instanceof Mt&&(Ft?i((function(){Nt.valueOf.call(n)})):"Number"!=c(n))?vt(new Tt(zt(t)),n,Mt):zt(t)},Dt=s?At(Tt):"MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger".split(","),Lt=0;Dt.length>Lt;Lt++)m(Tt,Ut=Dt[Lt])&&!m(Mt,Ut)&&_t(Mt,Ut,Pt(Tt,Ut));Mt.prototype=Nt,Nt.constructor=Mt,te(r,"Number",Mt)}var Bt=function(){var e=j(this),t="";return e.global&&(t+="g"),e.ignoreCase&&(t+="i"),e.multiline&&(t+="m"),e.dotAll&&(t+="s"),e.unicode&&(t+="u"),e.sticky&&(t+="y"),t};function qt(e,t){return RegExp(e,t)}var $t,Gt,Ht={UNSUPPORTED_Y:i((function(){var e=qt("a","y");return e.lastIndex=2,null!=e.exec("abcd")})),BROKEN_CARET:i((function(){var e=qt("^r","gy");return e.lastIndex=2,null!=e.exec("str")}))},Xt=RegExp.prototype.exec,Vt=String.prototype.replace,Yt=Xt,Kt=($t=/a/,Gt=/b*/g,Xt.call($t,"a"),Xt.call(Gt,"a"),0!==$t.lastIndex||0!==Gt.lastIndex),Wt=Ht.UNSUPPORTED_Y||Ht.BROKEN_CARET,Zt=void 0!==/()??/.exec("")[1];(Kt||Zt||Wt)&&(Yt=function(e){var t,n,r,i,s=this,o=Wt&&s.sticky,a=Bt.call(s),u=s.source,l=0,f=e;return o&&(-1===(a=a.replace("y","")).indexOf("g")&&(a+="g"),f=String(e).slice(s.lastIndex),s.lastIndex>0&&(!s.multiline||s.multiline&&"\n"!==e[s.lastIndex-1])&&(u="(?: "+u+")",f=" "+f,l++),n=new RegExp("^(?:"+u+")",a)),Zt&&(n=new RegExp("^"+u+"$(?!\\s)",a)),Kt&&(t=s.lastIndex),r=Xt.call(o?n:s,f),o?r?(r.input=r.input.slice(l),r[0]=r[0].slice(l),r.index=s.lastIndex,s.lastIndex+=r[0].length):s.lastIndex=0:Kt&&r&&(s.lastIndex=s.global?r.index+r[0].length:t),Zt&&r&&r.length>1&&Vt.call(r[0],n,(function(){for(i=1;i<arguments.length-2;i++)void 0===arguments[i]&&(r[i]=void 0)})),r});var Jt=Yt;_e({target:"RegExp",proto:!0,forced:/./.exec!==Jt},{exec:Jt});var Qt=De("species"),en=!i((function(){var e=/./;return e.exec=function(){var e=[];return e.groups={a:"7"},e},"7"!=="".replace(e,"$<a>")})),tn="$0"==="a".replace(/./,"$0"),nn=De("replace"),rn=!!/./[nn]&&""===/./[nn]("a","$0"),sn=!i((function(){var e=/(?:)/,t=e.exec;e.exec=function(){return t.apply(this,arguments)};var n="ab".split(e);return 2!==n.length||"a"!==n[0]||"b"!==n[1]})),on=function(e,t,n,r){var s=De(e),o=!i((function(){var t={};return t[s]=function(){return 7},7!=""[e](t)})),a=o&&!i((function(){var t=!1,n=/a/;return"split"===e&&((n={}).constructor={},n.constructor[Qt]=function(){return n},n.flags="",n[s]=/./[s]),n.exec=function(){return t=!0,null},n[s](""),!t}));if(!o||!a||"replace"===e&&(!en||!tn||rn)||"split"===e&&!sn){var u=/./[s],l=n(s,""[e],(function(e,t,n,r,i){return t.exec===Jt?o&&!i?{done:!0,value:u.call(t,n,r)}:{done:!0,value:e.call(n,t,r)}:{done:!1}}),{REPLACE_KEEPS_$0:tn,REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE:rn}),f=l[0],c=l[1];te(String.prototype,e,f),te(RegExp.prototype,s,2==t?function(e,t){return c.call(e,this,t)}:function(e){return c.call(e,this)})}r&&A(RegExp.prototype[s],"sham",!0)},an=function(e){return function(t,n){var r,i,s=String(d(t)),o=ae(n),a=s.length;return o<0||o>=a?e?"":void 0:(r=s.charCodeAt(o))<55296||r>56319||o+1===a||(i=s.charCodeAt(o+1))<56320||i>57343?e?s.charAt(o):r:e?s.slice(o,o+2):i-56320+(r-55296<<10)+65536}},un={codeAt:an(!1),charAt:an(!0)}.charAt,ln=function(e,t,n){return t+(n?un(e,t).length:1)},fn=function(e,t){var n=e.exec;if("function"==typeof n){var r=n.call(e,t);if("object"!=typeof r)throw TypeError("RegExp exec method returned something other than an Object or null");return r}if("RegExp"!==c(e))throw TypeError("RegExp#exec called on incompatible receiver");return Jt.call(e,t)},cn=Math.max,hn=Math.min,pn=Math.floor,dn=/\$([$&'`]|\d\d?|<[^>]*>)/g,vn=/\$([$&'`]|\d\d?)/g;function gn(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function yn(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function bn(e,t,n){return t&&yn(e.prototype,t),n&&yn(e,n),e}function mn(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function wn(e,t){var n;if("undefined"==typeof Symbol||null==e[Symbol.iterator]){if(Array.isArray(e)||(n=function(e,t){if(e){if("string"==typeof e)return mn(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);return"Object"===n&&e.constructor&&(n=e.constructor.name),"Map"===n||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?mn(e,t):void 0}}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var s,o=!0,a=!1;return{s:function(){n=e[Symbol.iterator]()},n:function(){var e=n.next();return o=e.done,e},e:function(e){a=!0,s=e},f:function(){try{o||null==n.return||n.return()}finally{if(a)throw s}}}}on("replace",2,(function(e,t,n,r){var i=r.REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE,s=r.REPLACE_KEEPS_$0,o=i?"$":"$0";return[function(n,r){var i=d(this),s=null==n?void 0:n[e];return void 0!==s?s.call(n,i,r):t.call(String(i),n,r)},function(e,r){if(!i&&s||"string"==typeof r&&-1===r.indexOf(o)){var u=n(t,e,this,r);if(u.done)return u.value}var l=j(e),f=String(this),c="function"==typeof r;c||(r=String(r));var h=l.global;if(h){var p=l.unicode;l.lastIndex=0}for(var d=[];;){var v=fn(l,f);if(null===v)break;if(d.push(v),!h)break;""===String(v[0])&&(l.lastIndex=ln(f,le(l.lastIndex),p))}for(var g,y="",b=0,m=0;m<d.length;m++){v=d[m];for(var w=String(v[0]),S=cn(hn(ae(v.index),f.length),0),k=[],O=1;O<v.length;O++)k.push(void 0===(g=v[O])?g:String(g));var x=v.groups;if(c){var E=[w].concat(k,S,f);void 0!==x&&E.push(x);var I=String(r.apply(void 0,E))}else I=a(w,f,S,k,x,r);S>=b&&(y+=f.slice(b,S)+I,b=S+w.length)}return y+f.slice(b)}];function a(e,n,r,i,s,o){var a=r+e.length,u=i.length,l=vn;return void 0!==s&&(s=nt(s),l=dn),t.call(o,l,(function(t,o){var l;switch(o.charAt(0)){case"$":return"$";case"&":return e;case"`":return n.slice(0,r);case"'":return n.slice(a);case"<":l=s[o.slice(1,-1)];break;default:var f=+o;if(0===f)return t;if(f>u){var c=pn(f/10);return 0===c?t:c<=u?void 0===i[c-1]?o.charAt(1):i[c-1]+o.charAt(1):t}l=i[f-1]}return void 0===l?"":l}))}}));var Sn=function(e,t){var n=[][e];return!!n&&i((function(){n.call(null,t||function(){throw 1},1)}))},kn=Math.min,On=[].lastIndexOf,xn=!!On&&1/[1].lastIndexOf(1,-0)<0,En=Sn("lastIndexOf"),jn=We("indexOf",{ACCESSORS:!0,1:0}),In=xn||!En||!jn?function(e){if(xn)return On.apply(this,arguments)||0;var t=v(this),n=le(t.length),r=n-1;for(arguments.length>1&&(r=kn(r,ae(arguments[1]))),r<0&&(r=n+r);r>=0;r--)if(r in t&&t[r]===e)return r||0;return-1}:On;_e({target:"Array",proto:!0,forced:In!==[].lastIndexOf},{lastIndexOf:In});var Cn=De("match"),An=De("species"),Pn=function(e,t){var n,r=j(e).constructor;return void 0===r||null==(n=j(r)[An])?t:function(e){if("function"!=typeof e)throw TypeError(String(e)+" is not a function");return e}(n)},_n=[].push,Rn=Math.min,Tn=!i((function(){return!RegExp(4294967295,"y")}));on("split",2,(function(e,t,n){var r;return r="c"=="abbc".split(/(b)*/)[1]||4!="test".split(/(?:)/,-1).length||2!="ab".split(/(?:ab)*/).length||4!=".".split(/(.?)(.?)/).length||".".split(/()()/).length>1||"".split(/.?/).length?function(e,n){var r,i,s=String(d(this)),o=void 0===n?4294967295:n>>>0;if(0===o)return[];if(void 0===e)return[s];if(!g(r=e)||!(void 0!==(i=r[Cn])?i:"RegExp"==c(r)))return t.call(s,e,o);for(var a,u,l,f=[],h=(e.ignoreCase?"i":"")+(e.multiline?"m":"")+(e.unicode?"u":"")+(e.sticky?"y":""),p=0,v=new RegExp(e.source,h+"g");(a=Jt.call(v,s))&&!((u=v.lastIndex)>p&&(f.push(s.slice(p,a.index)),a.length>1&&a.index<s.length&&_n.apply(f,a.slice(1)),l=a[0].length,p=u,f.length>=o));)v.lastIndex===a.index&&v.lastIndex++;return p===s.length?!l&&v.test("")||f.push(""):f.push(s.slice(p)),f.length>o?f.slice(0,o):f}:"0".split(void 0,0).length?function(e,n){return void 0===e&&0===n?[]:t.call(this,e,n)}:t,[function(t,n){var i=d(this),s=null==t?void 0:t[e];return void 0!==s?s.call(t,i,n):r.call(String(i),t,n)},function(e,i){var s=n(r,e,this,i,r!==t);if(s.done)return s.value;var o=j(e),a=String(this),u=Pn(o,RegExp),l=o.unicode,f=(o.ignoreCase?"i":"")+(o.multiline?"m":"")+(o.unicode?"u":"")+(Tn?"y":"g"),c=new u(Tn?o:"^(?:"+o.source+")",f),h=void 0===i?4294967295:i>>>0;if(0===h)return[];if(0===a.length)return null===fn(c,a)?[a]:[];for(var p=0,d=0,v=[];d<a.length;){c.lastIndex=Tn?d:0;var g,y=fn(c,Tn?a:a.slice(d));if(null===y||(g=Rn(le(c.lastIndex+(Tn?0:d)),a.length))===p)d=ln(a,d,l);else{if(v.push(a.slice(p,d)),v.length===h)return v;for(var b=1;b<=y.length-1;b++)if(v.push(y[b]),v.length===h)return v;d=p=g}}return v.push(a.slice(p)),v}]}),!Tn);var Nn=de.indexOf,Fn=[].indexOf,zn=!!Fn&&1/[1].indexOf(1,-0)<0,Un=Sn("indexOf"),Mn=We("indexOf",{ACCESSORS:!0,1:0});_e({target:"Array",proto:!0,forced:zn||!Un||!Mn},{indexOf:function(e){return zn?Fn.apply(this,arguments)||0:Nn(this,e,arguments.length>1?arguments[1]:void 0)}});var Dn=[].join,Ln=p!=Object,Bn=Sn("join",",");function qn(e,t,n,r,i){var s="slice";e.file.slice?s="slice":e.file.mozSlice?s="mozSlice":e.file.webkitSlice&&(s="webkitSlice"),i.readFinished(e.file[s](t,n,r))}function $n(e,t){return"function"==typeof e&&(t=Array.prototype.slice.call(arguments),e=e.apply(null,t.slice(1))),e}function Gn(e,t){setTimeout(e.bind(t),0)}function Hn(e,t){return Xn(arguments,(function(t){t!==e&&Xn(t,(function(t,n){e[n]=t}))})),e}function Xn(e,t,n){var r;if(e)if(void 0!==e.length){for(r=0;r<e.length;r++)if(!1===t.call(n,e[r],r))return}else for(r in e)if(e.hasOwnProperty(r)&&!1===t.call(n,e[r],r))return}_e({target:"Array",proto:!0,forced:Ln||!Bn},{join:function(e){return Dn.call(v(this),void 0===e?",":e)}}),("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{}).evalOpts=$n;var Vn=function(){function e(t,n,r){gn(this,e),this.flowObj=t,this.fileObj=n,this.offset=r,this.tested=!1,this.retries=0,this.pendingRetry=!1,this.preprocessState=0,this.readState=0,this.loaded=0,this.total=0,this.chunkSize=this.fileObj.chunkSize,this.startByte=this.offset*this.chunkSize,this.filename=null,this.endByte=this.computeEndByte(),this.xhr=null}return bn(e,[{key:"computeEndByte",value:function(){var e=Math.min(this.fileObj.size,(this.offset+1)*this.chunkSize);return this.fileObj.size-e<this.chunkSize&&!this.flowObj.opts.forceChunkSize&&(e=this.fileObj.size),e}},{key:"event",value:function(e,t){(t=Array.prototype.slice.call(arguments)).unshift(this),this.fileObj.chunkEvent.apply(this.fileObj,t)}},{key:"progressHandler",value:function(e){e.lengthComputable&&(this.loaded=e.loaded,this.total=e.total),this.event("progress",e)}},{key:"testHandler",value:function(e){var t=this.status(!0);"error"===t?(this.event(t,this.message()),this.flowObj.uploadNextChunk()):"success"===t?(this.tested=!0,this.event(t,this.message()),this.flowObj.uploadNextChunk()):this.fileObj.paused||(this.tested=!0,this.send())}},{key:"doneHandler",value:function(e){var t=this,n=this.status();if("success"===n||"error"===n)delete this.data,this.event(n,this.message()),this.flowObj.uploadNextChunk();else if(!this.fileObj.paused){this.event("retry",this.message()),this.pendingRetry=!0,this.abort(),this.retries++;var r=this.flowObj.opts.chunkRetryInterval;null!==r?setTimeout((function(){return t.send()}),r):this.send()}}},{key:"getParams",value:function(){return{flowChunkNumber:this.offset+1,flowChunkSize:this.chunkSize,flowCurrentChunkSize:this.endByte-this.startByte,flowTotalSize:this.fileObj.size,flowIdentifier:this.fileObj.uniqueIdentifier,flowFilename:this.fileObj.name,flowRelativePath:this.fileObj.relativePath,flowTotalChunks:this.fileObj.chunks.length}}},{key:"getTarget",value:function(e,t){return 0==t.length?e:(e.indexOf("?")<0?e+="?":e+="&",e+t.join("&"))}},{key:"test",value:function(){this.xhr=new XMLHttpRequest,this.xhr.addEventListener("load",this.testHandler.bind(this),!1),this.xhr.addEventListener("error",this.testHandler.bind(this),!1);var e=$n(this.flowObj.opts.testMethod,this.fileObj,this),t=this.prepareXhrRequest(e,!0);this.xhr.send(t)}},{key:"preprocessFinished",value:function(){this.endByte=this.computeEndByte(),this.preprocessState=2,this.send()}},{key:"readFinished",value:function(e){this.readState=2,this.bytes=e,this.send()}},{key:"send",value:function(){var e=this.flowObj.opts.preprocess,t=this.flowObj.opts.readFileFn;if("function"==typeof e)switch(this.preprocessState){case 0:return this.preprocessState=1,void e(this);case 1:return}switch(this.readState){case 0:return this.readState=1,void t(this.fileObj,this.startByte,this.endByte,this.fileObj.file.type,this);case 1:return}if(!this.flowObj.opts.testChunks||this.tested){this.loaded=0,this.total=0,this.pendingRetry=!1,this.xhr=new XMLHttpRequest,this.xhr.upload.addEventListener("progress",this.progressHandler.bind(this),!1),this.xhr.addEventListener("load",this.doneHandler.bind(this),!1),this.xhr.addEventListener("error",this.doneHandler.bind(this),!1);var n=$n(this.flowObj.opts.uploadMethod,this.fileObj,this),r=this.prepareXhrRequest(n,!1,this.flowObj.opts.method,this.bytes),i=this.flowObj.opts.changeRawDataBeforeSend;"function"==typeof i&&(r=i(this,r)),this.xhr.send(r)}else this.test()}},{key:"abort",value:function(){var e=this.xhr;this.xhr=null,e&&e.abort()}},{key:"status",value:function(e){return 1===this.readState?"reading":this.pendingRetry||1===this.preprocessState?"uploading":this.xhr?this.xhr.readyState<4?"uploading":this.flowObj.opts.successStatuses.indexOf(this.xhr.status)>-1?"success":this.flowObj.opts.permanentErrors.indexOf(this.xhr.status)>-1||!e&&this.retries>=this.flowObj.opts.maxChunkRetries?"error":(this.abort(),"pending"):"pending"}},{key:"message",value:function(){return this.xhr?this.xhr.responseText:""}},{key:"progress",value:function(){if(this.pendingRetry)return 0;var e=this.status();return"success"===e||"error"===e?1:"pending"===e?0:this.total>0?this.loaded/this.total:0}},{key:"sizeUploaded",value:function(){var e=this.endByte-this.startByte;return"success"!==this.status()&&(e=this.progress()*e),e}},{key:"prepareXhrRequest",value:function(e,t,n,r){var i=$n(this.flowObj.opts.query,this.fileObj,this,t);i=Hn(i||{},this.getParams());var s=$n(this.flowObj.opts.target,this.fileObj,this,t),o=null;if("GET"===e||"octet"===n){var a=[];Xn(i,(function(e,t){a.push([encodeURIComponent(t),encodeURIComponent(e)].join("="))})),s=this.getTarget(s,a),o=r||null}else o=new FormData,Xn(i,(function(e,t){o.append(t,e)})),void 0!==r&&o.append(this.flowObj.opts.fileParameterName,r,this.filename||this.fileObj.file.name);return this.xhr.open(e,s,!0),this.xhr.withCredentials=this.flowObj.opts.withCredentials,Xn($n(this.flowObj.opts.headers,this.fileObj,this,t),(function(e,t){this.xhr.setRequestHeader(t,e)}),this),o}}]),e}(),Yn=function(){function e(t,n,r){gn(this,e),this.flowObj=t,this.bytes=null,this.file=n,this.name=n.fileName||n.name,this.size=n.size,this.relativePath=n.relativePath||n.webkitRelativePath||this.name,this.uniqueIdentifier=void 0===r?t.generateUniqueIdentifier(n):r,this.chunkSize=0,this.chunks=[],this.paused=!1,this.error=!1,this.averageSpeed=0,this.currentSpeed=0,this._lastProgressCallback=Date.now(),this._prevUploadedSize=0,this._prevProgress=0,this.bootstrap()}return bn(e,[{key:"measureSpeed",value:function(){var e=Date.now()-this._lastProgressCallback;if(e){var t=this.flowObj.opts.speedSmoothingFactor,n=this.sizeUploaded();this.currentSpeed=Math.max((n-this._prevUploadedSize)/e*1e3,0),this.averageSpeed=t*this.currentSpeed+(1-t)*this.averageSpeed,this._prevUploadedSize=n}}},{key:"chunkEvent",value:function(e,t,n){switch(t){case"progress":if(Date.now()-this._lastProgressCallback<this.flowObj.opts.progressCallbacksInterval)break;this.measureSpeed(),this.flowObj.fire("fileProgress",this,e),this.flowObj.fire("progress"),this._lastProgressCallback=Date.now();break;case"error":this.error=!0,this.abort(!0),this.flowObj.fire("fileError",this,n,e),this.flowObj.fire("error",n,this,e);break;case"success":if(this.error)return;this.measureSpeed(),this.flowObj.fire("fileProgress",this,e),this.flowObj.fire("progress"),this._lastProgressCallback=Date.now(),this.isComplete()&&(this.currentSpeed=0,this.averageSpeed=0,this.flowObj.fire("fileSuccess",this,n,e));break;case"retry":this.flowObj.fire("fileRetry",this,e)}}},{key:"pause",value:function(){this.paused=!0,this.abort()}},{key:"resume",value:function(){this.paused=!1,this.flowObj.upload()}},{key:"abort",value:function(e){this.currentSpeed=0,this.averageSpeed=0;var t=this.chunks;e&&(this.chunks=[]),Xn(t,(function(e){"uploading"===e.status()&&(e.abort(),this.flowObj.uploadNextChunk())}),this)}},{key:"cancel",value:function(){this.flowObj.removeFile(this)}},{key:"retry",value:function(){this.bootstrap(),this.flowObj.upload()}},{key:"bootstrap",value:function(){if("function"==typeof this.flowObj.opts.initFileFn){var e=this.flowObj.opts.initFileFn(this);if(e&&"then"in e)return void e.then(this._bootstrap.bind(this))}this._bootstrap()}},{key:"_bootstrap",value:function(){this.abort(!0),this.error=!1,this._prevProgress=0;var e=this.flowObj.opts.forceChunkSize?Math.ceil:Math.floor;this.chunkSize=$n(this.flowObj.opts.chunkSize,this);for(var t=Math.max(e(this.size/this.chunkSize),1),n=0;n<t;n++)this.chunks.push(new Vn(this.flowObj,this,n))}},{key:"progress",value:function(){if(this.error)return 1;if(1===this.chunks.length)return this._prevProgress=Math.max(this._prevProgress,this.chunks[0].progress()),this._prevProgress;var e=0;Xn(this.chunks,(function(t){e+=t.progress()*(t.endByte-t.startByte)}));var t=e/this.size;return this._prevProgress=Math.max(this._prevProgress,t>.9999?1:t),this._prevProgress}},{key:"isUploading",value:function(){var e=!1;return Xn(this.chunks,(function(t){if("uploading"===t.status())return e=!0,!1})),e}},{key:"isComplete",value:function(){var e=!1;return Xn(this.chunks,(function(t){var n=t.status();if("pending"===n||"uploading"===n||"reading"===n||1===t.preprocessState||1===t.readState)return e=!0,!1})),!e}},{key:"sizeUploaded",value:function(){var e=0;return Xn(this.chunks,(function(t){e+=t.sizeUploaded()})),e}},{key:"timeRemaining",value:function(){if(this.paused||this.error)return 0;var e=this.size-this.sizeUploaded();return e&&!this.averageSpeed?Number.POSITIVE_INFINITY:e||this.averageSpeed?Math.floor(e/this.averageSpeed):0}},{key:"getType",value:function(){return this.file.type&&this.file.type.split("/")[1]}},{key:"getExtension",value:function(){return this.name.substr(2+(~-this.name.lastIndexOf(".")>>>0)).toLowerCase()}}]),e}();("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{}).FlowFile=Yn;var Kn=function(){function e(t){gn(this,e),e.version="2.14.1",this.supportDirectory=/Chrome/.test(window.navigator.userAgent)||/Firefox/.test(window.navigator.userAgent)||/Edge/.test(window.navigator.userAgent),this.files=[],this.defaults={chunkSize:1048576,forceChunkSize:!1,simultaneousUploads:3,singleFile:!1,fileParameterName:"file",progressCallbacksInterval:500,speedSmoothingFactor:.1,query:{},headers:{},withCredentials:!1,preprocess:null,changeRawDataBeforeSend:null,method:"multipart",testMethod:"GET",uploadMethod:"POST",prioritizeFirstAndLastChunk:!1,allowDuplicateUploads:!1,target:"/",testChunks:!0,generateUniqueIdentifier:null,maxChunkRetries:0,chunkRetryInterval:null,permanentErrors:[404,413,415,500,501],successStatuses:[200,201,202],onDropStopPropagation:!1,initFileFn:null,readFileFn:qn},this.opts={},this.events={},this.opts=Hn({},this.defaults,t||{}),this._onDropBound=null}return bn(e,[{key:"onDrop",value:function(e){this.opts.onDropStopPropagation&&e.stopPropagation(),e.preventDefault();var t=e.dataTransfer;t.items&&t.items[0]&&t.items[0].webkitGetAsEntry?this.webkitReadDataTransfer(e):this.addFiles(t.files,e)}},{key:"preventEvent",value:function(e){e.preventDefault()}},{key:"on",value:function(e,t){e=e.toLowerCase(),this.events.hasOwnProperty(e)||(this.events[e]=[]),this.events[e].push(t)}},{key:"off",value:function(e,t){var n,r,i;void 0!==e?(e=e.toLowerCase(),void 0!==t?this.events.hasOwnProperty(e)&&(n=this.events[e],r=t,(i=n.indexOf(r))>-1&&n.splice(i,1)):delete this.events[e]):this.events={}}},{key:"fire",value:function(e,t){t=Array.prototype.slice.call(arguments),e=e.toLowerCase();var n=!1;return this.events.hasOwnProperty(e)&&Xn(this.events[e],(function(e){n=!1===e.apply(this,t.slice(1))||n}),this),"catchall"!=e&&(t.unshift("catchAll"),n=!1===this.fire.apply(this,t)||n),!n}},{key:"webkitReadDataTransfer",value:function(e){var t,n=this,r=e.dataTransfer.items.length,i=function(){0==--r&&n.addFiles(s,e)},s=[],o=wn(e.dataTransfer.items);try{for(o.s();!(t=o.n()).done;){var a=t.value,u=a.webkitGetAsEntry();if(!u)return void i();u.isFile?f(a.getAsFile(),u.fullPath):l(u.createReader())}}catch(e){o.e(e)}finally{o.f()}function l(e){e.readEntries((function(t){if(t.length){r+=t.length;var n,s=wn(t);try{for(s.s();!(n=s.n()).done;){var o=n.value;if(o.isFile){var a=o.fullPath;o.file((function(e){return f(e,a)}),c)}else o.isDirectory&&l(o.createReader())}}catch(e){s.e(e)}finally{s.f()}l(e)}else i()}),c)}function f(e,t){e.relativePath=t.substring(1),s.push(e),i()}function c(e){throw i(),e}}},{key:"generateUniqueIdentifier",value:function(e){var t=this.opts.generateUniqueIdentifier;if("function"==typeof t)return t(e);var n=e.relativePath||e.webkitRelativePath||e.fileName||e.name;return e.size+"-"+n.replace(/[^0-9a-zA-Z_-]/gim,"")}},{key:"uploadNextChunk",value:function(e){var t=!1;if(this.opts.prioritizeFirstAndLastChunk&&(Xn(this.files,(function(e){return!e.paused&&e.chunks.length&&"pending"===e.chunks[0].status()?(e.chunks[0].send(),t=!0,!1):!e.paused&&e.chunks.length>1&&"pending"===e.chunks[e.chunks.length-1].status()?(e.chunks[e.chunks.length-1].send(),t=!0,!1):void 0})),t))return t;if(Xn(this.files,(function(e){if(e.paused||Xn(e.chunks,(function(e){if("pending"===e.status())return e.send(),t=!0,!1})),t)return!1})),t)return!0;var n=!1;return Xn(this.files,(function(e){if(!e.isComplete())return n=!0,!1})),n||e||Gn((function(){this.fire("complete")}),this),!1}},{key:"assignBrowse",value:function(e,t,n,r){e instanceof Element&&(e=[e]),Xn(e,(function(e){var i,s=this;"INPUT"===e.tagName&&"file"===e.type?i=e:((i=document.createElement("input")).setAttribute("type","file"),Hn(i.style,{visibility:"hidden",position:"absolute",width:"1px",height:"1px"}),e.appendChild(i),e.addEventListener("click",(function(){i.click()}),!1)),this.opts.singleFile||n||i.setAttribute("multiple","multiple"),t&&i.setAttribute("webkitdirectory","webkitdirectory"),Xn(r,(function(e,t){i.setAttribute(t,e)})),i.addEventListener("change",(function(e){e.target.value&&(s.addFiles(e.target.files,e),e.target.value="")}),!1)}),this)}},{key:"assignDrop",value:function(e){void 0===e.length&&(e=[e]),this._onDropBound=this.onDrop.bind(this);var t,n=wn(e);try{for(n.s();!(t=n.n()).done;){var r=t.value;r.addEventListener("dragover",this.preventEvent,!1),r.addEventListener("dragenter",this.preventEvent,!1),r.addEventListener("drop",this._onDropBound,!1)}}catch(e){n.e(e)}finally{n.f()}}},{key:"unAssignDrop",value:function(e){void 0===e.length&&(e=[e]);var t,n=wn(e);try{for(n.s();!(t=n.n()).done;){var r=t.value;r.removeEventListener("dragover",this.preventEvent,!1),r.removeEventListener("dragenter",this.preventEvent,!1),r.removeEventListener("drop",this._onDropBound,!1)}}catch(e){n.e(e)}finally{n.f()}}},{key:"isUploading",value:function(){var e=!1;return Xn(this.files,(function(t){if(t.isUploading())return e=!0,!1})),e}},{key:"_shouldUploadNext",value:function(){var e=0,t=!0,n=this.opts.simultaneousUploads;return Xn(this.files,(function(r){Xn(r.chunks,(function(r){if("uploading"===r.status()&&++e>=n)return t=!1,!1}))})),t&&e}},{key:"upload",value:function(){var e=this._shouldUploadNext();if(!1!==e){this.fire("uploadStart");for(var t=!1,n=1;n<=this.opts.simultaneousUploads-e;n++)t=this.uploadNextChunk(!0)||t;t||Gn((function(){this.fire("complete")}),this)}}},{key:"resume",value:function(){Xn(this.files,(function(e){e.isComplete()||e.resume()}))}},{key:"pause",value:function(){Xn(this.files,(function(e){e.pause()}))}},{key:"cancel",value:function(){for(var e=this.files.length-1;e>=0;e--)this.files[e].cancel()}},{key:"progress",value:function(){var e=0,t=0;return Xn(this.files,(function(n){e+=n.progress()*n.size,t+=n.size})),t>0?e/t:0}},{key:"addFile",value:function(e,t){this.addFiles([e],t)}},{key:"addFiles",value:function(e,t){var n=[],r=window.navigator.msPointerEnabled;Xn(e,(function(e){if((!r||r&&e.size>0)&&(e.size%4096!=0||"."!==e.name&&"."!==e.fileName)){var i=this.generateUniqueIdentifier(e);if(this.opts.allowDuplicateUploads||!this.getFromUniqueIdentifier(i)){var s=new Yn(this,e,i);this.fire("fileAdded",s,t)&&n.push(s)}}}),this),this.fire("filesAdded",n,t)&&(Xn(n,(function(e){this.opts.singleFile&&this.files.length>0&&this.removeFile(this.files[0]),this.files.push(e)}),this),this.fire("filesSubmitted",n,t))}},{key:"removeFile",value:function(e){for(var t=this.files.length-1;t>=0;t--)this.files[t]===e&&(this.files.splice(t,1),e.abort(),this.fire("fileRemoved",e))}},{key:"getFromUniqueIdentifier",value:function(e){var t=!1;return Xn(this.files,(function(n){n.uniqueIdentifier===e&&(t=n)})),t}},{key:"getSize",value:function(){var e=0;return Xn(this.files,(function(t){e+=t.size})),e}},{key:"sizeUploaded",value:function(){var e=0;return Xn(this.files,(function(t){e+=t.sizeUploaded()})),e}},{key:"timeRemaining",value:function(){var e=0,t=0;return Xn(this.files,(function(n){n.paused||n.error||(e+=n.size-n.sizeUploaded(),t+=n.averageSpeed)})),e&&!t?Number.POSITIVE_INFINITY:e||t?Math.floor(e/t):0}}]),e}();export default Kn;
 //# sourceMappingURL=flow.min.js.map
diff --git a/rollup.config.js b/rollup.config.js
index ab09ce5c..8881623e 100644
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -18,7 +18,7 @@ let plugins = [
 
 export default [
     {
-        input: 'src/flow.js',
+        input: 'src/Flow.js',
         plugins,
         output: {
             name: 'Flow',
@@ -28,7 +28,7 @@ export default [
 	},
     },
     {
-        input: 'src/flow.js',
+        input: 'src/Flow.js',
         plugins: plugins.concat([terser()]),
         output: {
             name: 'Flow',
diff --git a/src/Flow.js b/src/Flow.js
new file mode 100644
index 00000000..e1e17d61
--- /dev/null
+++ b/src/Flow.js
@@ -0,0 +1,686 @@
+/**
+ * @license MIT
+ */
+
+import FlowFile from './FlowFile';
+import {each, async, arrayRemove, extend, webAPIFileRead} from './tools';
+
+/**
+ * Flow.js is a library providing multiple simultaneous, stable and
+ * resumable uploads via the HTML5 File API.
+ * @param [opts]
+ * @param {number|Function} [opts.chunkSize]
+ * @param {bool} [opts.forceChunkSize]
+ * @param {number} [opts.simultaneousUploads]
+ * @param {bool} [opts.singleFile]
+ * @param {string} [opts.fileParameterName]
+ * @param {number} [opts.progressCallbacksInterval]
+ * @param {number} [opts.speedSmoothingFactor]
+ * @param {Object|Function} [opts.query]
+ * @param {Object|Function} [opts.headers]
+ * @param {bool} [opts.withCredentials]
+ * @param {Function} [opts.preprocess]
+ * @param {string} [opts.method]
+ * @param {string|Function} [opts.testMethod]
+ * @param {string|Function} [opts.uploadMethod]
+ * @param {bool} [opts.prioritizeFirstAndLastChunk]
+ * @param {bool} [opts.allowDuplicateUploads]
+ * @param {string|Function} [opts.target]
+ * @param {number} [opts.maxChunkRetries]
+ * @param {number} [opts.chunkRetryInterval]
+ * @param {Array.<number>} [opts.permanentErrors]
+ * @param {Array.<number>} [opts.successStatuses]
+ * @param {Function} [opts.initFileFn]
+ * @param {Function} [opts.readFileFn]
+ * @param {Function} [opts.generateUniqueIdentifier]
+ * @constructor
+ */
+export default class Flow {
+
+  constructor(opts) {
+    /**
+     * Library version
+     * @type {string}
+     */
+    Flow.version = '<%= version %>';
+
+    /**
+     * Check if directory upload is supported
+     * @type {boolean}
+     */
+    this.supportDirectory = (
+      /Chrome/.test(window.navigator.userAgent) ||
+      /Firefox/.test(window.navigator.userAgent) ||
+      /Edge/.test(window.navigator.userAgent)
+    );
+
+    /**
+     * List of FlowFile objects
+     * @type {Array.<FlowFile>}
+     */
+    this.files = [];
+
+    /**
+     * Default options for flow.js
+     * @type {Object}
+     */
+    this.defaults = {
+      chunkSize: 1024 * 1024,
+      forceChunkSize: false,
+      simultaneousUploads: 3,
+      singleFile: false,
+      fileParameterName: 'file',
+      progressCallbacksInterval: 500,
+      speedSmoothingFactor: 0.1,
+      query: {},
+      headers: {},
+      withCredentials: false,
+      preprocess: null,
+      changeRawDataBeforeSend: null,
+      method: 'multipart',
+      testMethod: 'GET',
+      uploadMethod: 'POST',
+      prioritizeFirstAndLastChunk: false,
+      allowDuplicateUploads: false,
+      target: '/',
+      testChunks: true,
+      generateUniqueIdentifier: null,
+      maxChunkRetries: 0,
+      chunkRetryInterval: null,
+      permanentErrors: [404, 413, 415, 500, 501],
+      successStatuses: [200, 201, 202],
+      onDropStopPropagation: false,
+      initFileFn: null,
+      readFileFn: webAPIFileRead
+    };
+
+    /**
+     * Current options
+     * @type {Object}
+     */
+    this.opts = {};
+
+    /**
+     * List of events:
+     *  key stands for event name
+     *  value array list of callbacks
+     * @type {}
+     */
+    this.events = {};
+
+    /**
+     * Current options
+     * @type {Object}
+     */
+    this.opts = extend({}, this.defaults, opts || {});
+
+    // A workaround for using this.method.bind(this) as a (removable) event handler.
+    // https://stackoverflow.com/questions/11565471
+    this._onDropBound = null;
+  }
+
+  /**
+   * On drop event
+   * @function
+   * @param {MouseEvent} event
+   */
+  onDrop(event) {
+    if (this.opts.onDropStopPropagation) {
+      event.stopPropagation();
+    }
+    event.preventDefault();
+    var dataTransfer = event.dataTransfer;
+    if (dataTransfer.items && dataTransfer.items[0] &&
+        dataTransfer.items[0].webkitGetAsEntry) {
+      this.webkitReadDataTransfer(event);
+    } else {
+      this.addFiles(dataTransfer.files, event);
+    }
+  }
+
+  /**
+   * Prevent default
+   * @function
+   * @param {MouseEvent} event
+   */
+  preventEvent(event) {
+    event.preventDefault();
+  }
+
+  /**
+   * Set a callback for an event, possible events:
+   * fileSuccess(file), fileProgress(file), fileAdded(file, event),
+   * fileRemoved(file), fileRetry(file), fileError(file, message),
+   * complete(), progress(), error(message, file), pause()
+   * @function
+   * @param {string} event
+   * @param {Function} callback
+   */
+  on(event, callback) {
+    event = event.toLowerCase();
+    if (!this.events.hasOwnProperty(event)) {
+      this.events[event] = [];
+    }
+    this.events[event].push(callback);
+  }
+
+  /**
+   * Remove event callback
+   * @function
+   * @param {string} [event] removes all events if not specified
+   * @param {Function} [fn] removes all callbacks of event if not specified
+   */
+  off(event, fn) {
+    if (event !== undefined) {
+      event = event.toLowerCase();
+      if (fn !== undefined) {
+        if (this.events.hasOwnProperty(event)) {
+          arrayRemove(this.events[event], fn);
+        }
+      } else {
+        delete this.events[event];
+      }
+    } else {
+      this.events = {};
+    }
+  }
+
+  /**
+   * Fire an event
+   * @function
+   * @param {string} event event name
+   * @param {...} args arguments of a callback
+   * @return {bool} value is false if at least one of the event handlers which handled this event
+   * returned false. Otherwise it returns true.
+   */
+  fire(event, args) {
+    // `arguments` is an object, not array, in FF, so:
+    args = Array.prototype.slice.call(arguments);
+    event = event.toLowerCase();
+    var preventDefault = false;
+    if (this.events.hasOwnProperty(event)) {
+      each(this.events[event], function (callback) {
+        preventDefault = callback.apply(this, args.slice(1)) === false || preventDefault;
+      }, this);
+    }
+    if (event != 'catchall') {
+      args.unshift('catchAll');
+      preventDefault = this.fire.apply(this, args) === false || preventDefault;
+    }
+    return !preventDefault;
+  }
+
+  /**
+   * Read webkit dataTransfer object
+   * @param event
+   */
+  webkitReadDataTransfer(event) {
+    var queue = event.dataTransfer.items.length;
+    var decrement = () => {
+      if (--queue == 0) {
+        this.addFiles(files, event);
+      }
+    };
+
+    var files = [];
+    for (let item of event.dataTransfer.items) {
+      var entry = item.webkitGetAsEntry();
+      if (!entry) {
+        decrement();
+        return ;
+      }
+      if (entry.isFile) {
+        // due to a bug in Chrome's File System API impl - #149735
+        fileReadSuccess(item.getAsFile(), entry.fullPath);
+      } else {
+        readDirectory(entry.createReader());
+      }
+    }
+
+    function readDirectory(reader) {
+      reader.readEntries((entries) => {
+        if (entries.length) {
+          queue += entries.length;
+          for (let entry of entries) {
+            if (entry.isFile) {
+              var fullPath = entry.fullPath;
+              entry.file((file) => fileReadSuccess(file, fullPath), readError);
+            } else if (entry.isDirectory) {
+              readDirectory(entry.createReader());
+            }
+          }
+          readDirectory(reader);
+        } else {
+          decrement();
+        }
+      }, readError);
+    }
+    function fileReadSuccess(file, fullPath) {
+      // relative path should not start with "/"
+      file.relativePath = fullPath.substring(1);
+      files.push(file);
+      decrement();
+    }
+    function readError(fileError) {
+      decrement();
+      throw fileError;
+    }
+  }
+
+  /**
+   * Generate unique identifier for a file
+   * @function
+   * @param {FlowFile} file
+   * @returns {string}
+   */
+  generateUniqueIdentifier(file) {
+    var custom = this.opts.generateUniqueIdentifier;
+    if (typeof custom === 'function') {
+      return custom(file);
+    }
+    // Some confusion in different versions of Firefox
+    var relativePath = file.relativePath || file.webkitRelativePath || file.fileName || file.name;
+    return file.size + '-' + relativePath.replace(/[^0-9a-zA-Z_-]/img, '');
+  }
+
+  /**
+   * Upload next chunk from the queue
+   * @function
+   * @returns {boolean}
+   * @private
+   */
+  uploadNextChunk(preventEvents) {
+    // 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.
+    var found = false;
+    if (this.opts.prioritizeFirstAndLastChunk) {
+      each(this.files, function (file) {
+        if (!file.paused && file.chunks.length &&
+            file.chunks[0].status() === 'pending') {
+          file.chunks[0].send();
+          found = true;
+          return false;
+        }
+        if (!file.paused && file.chunks.length > 1 &&
+            file.chunks[file.chunks.length - 1].status() === 'pending') {
+          file.chunks[file.chunks.length - 1].send();
+          found = true;
+          return false;
+        }
+      });
+      if (found) {
+        return found;
+      }
+    }
+
+    // Now, simply look for the next, best thing to upload
+    each(this.files, function (file) {
+      if (!file.paused) {
+        each(file.chunks, function (chunk) {
+          if (chunk.status() === 'pending') {
+            chunk.send();
+            found = true;
+            return false;
+          }
+        });
+      }
+      if (found) {
+        return false;
+      }
+    });
+    if (found) {
+      return true;
+    }
+
+    // The are no more outstanding chunks to upload, check is everything is done
+    var outstanding = false;
+    each(this.files, function (file) {
+      if (!file.isComplete()) {
+        outstanding = true;
+        return false;
+      }
+    });
+    if (!outstanding && !preventEvents) {
+      // All chunks have been uploaded, complete
+      async(function () {
+        this.fire('complete');
+      }, this);
+    }
+    return false;
+  }
+
+
+  /**
+   * Assign a browse action to one or more DOM nodes.
+   * @function
+   * @param {Element|Array.<Element>} domNodes
+   * @param {boolean} isDirectory Pass in true to allow directories to
+   * @param {boolean} singleFile prevent multi file upload
+   * @param {Object} attributes set custom attributes:
+   *  http://www.w3.org/TR/html-markup/input.file.html#input.file-attributes
+   *  eg: accept: 'image/*'
+   * be selected (Chrome only).
+   */
+  assignBrowse(domNodes, isDirectory, singleFile, attributes) {
+    if (domNodes instanceof Element) {
+      domNodes = [domNodes];
+    }
+
+    each(domNodes, function (domNode) {
+      var input;
+      if (domNode.tagName === 'INPUT' && domNode.type === 'file') {
+        input = domNode;
+      } else {
+        input = document.createElement('input');
+        input.setAttribute('type', 'file');
+        // display:none - not working in opera 12
+        extend(input.style, {
+          visibility: 'hidden',
+          position: 'absolute',
+          width: '1px',
+          height: '1px'
+        });
+        // for opera 12 browser, input must be assigned to a document
+        domNode.appendChild(input);
+        // https://developer.mozilla.org/en/using_files_from_web_applications)
+        // event listener is executed two times
+        // first one - original mouse click event
+        // second - input.click(), input is inside domNode
+        domNode.addEventListener('click', function() {
+          input.click();
+        }, false);
+      }
+      if (!this.opts.singleFile && !singleFile) {
+        input.setAttribute('multiple', 'multiple');
+      }
+      if (isDirectory) {
+        input.setAttribute('webkitdirectory', 'webkitdirectory');
+      }
+      each(attributes, function (value, key) {
+        input.setAttribute(key, value);
+      });
+      // When new files are added, simply append them to the overall list
+      input.addEventListener('change', (e) => {
+        if (e.target.value) {
+          this.addFiles(e.target.files, e);
+          e.target.value = '';
+        }
+      }, false);
+    }, this);
+  }
+
+  /**
+   * Assign one or more DOM nodes as a drop target.
+   * @function
+   * @param {Element|Array.<Element>} domNodes
+   */
+  assignDrop(domNodes) {
+    if (typeof domNodes.length === 'undefined') {
+      domNodes = [domNodes];
+    }
+
+    this._onDropBound = this.onDrop.bind(this);
+    for (let domNode of domNodes) {
+      domNode.addEventListener('dragover', this.preventEvent, false);
+      domNode.addEventListener('dragenter', this.preventEvent, false);
+      domNode.addEventListener('drop', this._onDropBound, false);
+    }
+  }
+
+  /**
+   * Un-assign drop event from DOM nodes
+   * @function
+   * @param domNodes
+   */
+  unAssignDrop(domNodes) {
+    if (typeof domNodes.length === 'undefined') {
+      domNodes = [domNodes];
+    }
+
+    for (let domNode of domNodes) {
+      domNode.removeEventListener('dragover', this.preventEvent, false);
+      domNode.removeEventListener('dragenter', this.preventEvent, false);
+      domNode.removeEventListener('drop', this._onDropBound, false);
+    }
+  }
+
+  /**
+   * Returns a boolean indicating whether or not the instance is currently
+   * uploading anything.
+   * @function
+   * @returns {boolean}
+   */
+  isUploading() {
+    var uploading = false;
+    each(this.files, function (file) {
+      if (file.isUploading()) {
+        uploading = true;
+        return false;
+      }
+    });
+    return uploading;
+  }
+
+  /**
+   * should upload next chunk
+   * @function
+   * @returns {boolean|number}
+   */
+  _shouldUploadNext() {
+    var num = 0;
+    var should = true;
+    var simultaneousUploads = this.opts.simultaneousUploads;
+    each(this.files, function (file) {
+      each(file.chunks, function(chunk) {
+        if (chunk.status() === 'uploading') {
+          num++;
+          if (num >= simultaneousUploads) {
+            should = false;
+            return false;
+          }
+        }
+      });
+    });
+    // if should is true then return uploading chunks's length
+    return should && num;
+  }
+
+  /**
+   * Start or resume uploading.
+   * @function
+   */
+  upload() {
+    // Make sure we don't start too many uploads at once
+    var ret = this._shouldUploadNext();
+    if (ret === false) {
+      return;
+    }
+    // Kick off the queue
+    this.fire('uploadStart');
+    var started = false;
+    for (var num = 1; num <= this.opts.simultaneousUploads - ret; num++) {
+      started = this.uploadNextChunk(true) || started;
+    }
+    if (!started) {
+      async(function () {
+        this.fire('complete');
+      }, this);
+    }
+  }
+
+  /**
+   * Resume uploading.
+   * @function
+   */
+  resume() {
+    each(this.files, function (file) {
+      if (!file.isComplete()) {
+        file.resume();
+      }
+    });
+  }
+
+  /**
+   * Pause uploading.
+   * @function
+   */
+  pause() {
+    each(this.files, function (file) {
+      file.pause();
+    });
+  }
+
+  /**
+   * Cancel upload of all FlowFile objects and remove them from the list.
+   * @function
+   */
+  cancel() {
+    for (var i = this.files.length - 1; i >= 0; i--) {
+      this.files[i].cancel();
+    }
+  }
+
+  /**
+   * Returns a number between 0 and 1 indicating the current upload progress
+   * of all files.
+   * @function
+   * @returns {number}
+   */
+  progress() {
+    var totalDone = 0;
+    var totalSize = 0;
+    // Resume all chunks currently being uploaded
+    each(this.files, function (file) {
+      totalDone += file.progress() * file.size;
+      totalSize += file.size;
+    });
+    return totalSize > 0 ? totalDone / totalSize : 0;
+  }
+
+  /**
+   * Add a HTML5 File object to the list of files.
+   * @function
+   * @param {File} file
+   * @param {Event} [event] event is optional
+   */
+  addFile(file, event) {
+    this.addFiles([file], event);
+  }
+
+  /**
+   * Add a HTML5 File object to the list of files.
+   * @function
+   * @param {FileList|Array} fileList
+   * @param {Event} [event] event is optional
+   */
+  addFiles(fileList, event) {
+    var files = [];
+    // ie10+
+    var ie10plus = window.navigator.msPointerEnabled;
+
+    each(fileList, function (file) {
+      // https://github.com/flowjs/flow.js/issues/55
+      if ((!ie10plus || ie10plus && file.size > 0) && !(file.size % 4096 === 0 && (file.name === '.' || file.fileName === '.'))) {
+        var uniqueIdentifier = this.generateUniqueIdentifier(file);
+        if (this.opts.allowDuplicateUploads || !this.getFromUniqueIdentifier(uniqueIdentifier)) {
+          var f = new FlowFile(this, file, uniqueIdentifier);
+          if (this.fire('fileAdded', f, event)) {
+            files.push(f);
+          }
+        }
+      }
+    }, this);
+    if (this.fire('filesAdded', files, event)) {
+      each(files, function (file) {
+        if (this.opts.singleFile && this.files.length > 0) {
+          this.removeFile(this.files[0]);
+        }
+        this.files.push(file);
+      }, this);
+      this.fire('filesSubmitted', files, event);
+    }
+  }
+
+
+  /**
+   * Cancel upload of a specific FlowFile object from the list.
+   * @function
+   * @param {FlowFile} file
+   */
+  removeFile(file) {
+    for (var i = this.files.length - 1; i >= 0; i--) {
+      if (this.files[i] === file) {
+        this.files.splice(i, 1);
+        file.abort();
+        this.fire('fileRemoved', file);
+      }
+    }
+  }
+
+  /**
+   * Look up a FlowFile object by its unique identifier.
+   * @function
+   * @param {string} uniqueIdentifier
+   * @returns {boolean|FlowFile} false if file was not found
+   */
+  getFromUniqueIdentifier(uniqueIdentifier) {
+    var ret = false;
+    each(this.files, function (file) {
+      if (file.uniqueIdentifier === uniqueIdentifier) {
+        ret = file;
+      }
+    });
+    return ret;
+  }
+
+  /**
+   * Returns the total size of all files in bytes.
+   * @function
+   * @returns {number}
+   */
+  getSize() {
+    var totalSize = 0;
+    each(this.files, function (file) {
+      totalSize += file.size;
+    });
+    return totalSize;
+  }
+
+  /**
+   * Returns the total size uploaded of all files in bytes.
+   * @function
+   * @returns {number}
+   */
+  sizeUploaded() {
+    var size = 0;
+    each(this.files, function (file) {
+      size += file.sizeUploaded();
+    });
+    return size;
+  }
+
+  /**
+   * Returns remaining time to upload all files in seconds. Accuracy is based on average speed.
+   * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`
+   * @function
+   * @returns {number}
+   */
+  timeRemaining() {
+    var sizeDelta = 0;
+    var averageSpeed = 0;
+    each(this.files, function (file) {
+      if (!file.paused && !file.error) {
+        sizeDelta += file.size - file.sizeUploaded();
+        averageSpeed += file.averageSpeed;
+      }
+    });
+    if (sizeDelta && !averageSpeed) {
+      return Number.POSITIVE_INFINITY;
+    }
+    if (!sizeDelta && !averageSpeed) {
+      return 0;
+    }
+    return Math.floor(sizeDelta / averageSpeed);
+  }
+};
diff --git a/src/FlowChunk.js b/src/FlowChunk.js
new file mode 100644
index 00000000..0bcff137
--- /dev/null
+++ b/src/FlowChunk.js
@@ -0,0 +1,447 @@
+import {evalOpts, each, extend} from './tools';
+
+/**
+ * Class for storing a single chunk
+ * @name FlowChunk
+ * @param {Flow} flowObj
+ * @param {FlowFile} fileObj
+ * @param {number} offset
+ * @constructor
+ */
+export default class FlowChunk {
+
+  constructor(flowObj, fileObj, offset) {
+
+    /**
+     * Reference to parent flow object
+     * @type {Flow}
+     */
+    this.flowObj = flowObj;
+
+    /**
+     * Reference to parent FlowFile object
+     * @type {FlowFile}
+     */
+    this.fileObj = fileObj;
+
+    /**
+     * File offset
+     * @type {number}
+     */
+    this.offset = offset;
+
+    /**
+     * Indicates if chunk existence was checked on the server
+     * @type {boolean}
+     */
+    this.tested = false;
+
+    /**
+     * Number of retries performed
+     * @type {number}
+     */
+    this.retries = 0;
+
+    /**
+     * Pending retry
+     * @type {boolean}
+     */
+    this.pendingRetry = false;
+
+    /**
+     * Preprocess state
+     * @type {number} 0 = unprocessed, 1 = processing, 2 = finished
+     */
+    this.preprocessState = 0;
+
+    /**
+     * Read state
+     * @type {number} 0 = not read, 1 = reading, 2 = finished
+     */
+    this.readState = 0;
+
+
+    /**
+     * Bytes transferred from total request size
+     * @type {number}
+     */
+    this.loaded = 0;
+
+    /**
+     * Total request size
+     * @type {number}
+     */
+    this.total = 0;
+
+    /**
+     * Size of a chunk
+     * @type {number}
+     */
+    this.chunkSize = this.fileObj.chunkSize;
+
+    /**
+     * Chunk start byte in a file
+     * @type {number}
+     */
+    this.startByte = this.offset * this.chunkSize;
+
+    /**
+     * A specific filename for this chunk which otherwise default to the main name
+     * @type {string}
+     */
+    this.filename = null;
+
+    /**
+     * Chunk end byte in a file
+     * @type {number}
+     */
+    this.endByte = this.computeEndByte();
+
+    /**
+     * XMLHttpRequest
+     * @type {XMLHttpRequest}
+     */
+    this.xhr = null;
+  }
+
+  /**
+   * Compute the endbyte in a file
+   *
+   */
+  computeEndByte() {
+    var endByte = Math.min(this.fileObj.size, (this.offset + 1) * this.chunkSize);
+    if (this.fileObj.size - endByte < this.chunkSize && !this.flowObj.opts.forceChunkSize) {
+      // The last chunk will be bigger than the chunk size,
+      // but less than 2 * this.chunkSize
+      endByte = this.fileObj.size;
+    }
+    return endByte;
+  }
+
+  /**
+   * Send chunk event
+   * @param event
+   * @param {...} args arguments of a callback
+   */
+  event(event, args) {
+    args = Array.prototype.slice.call(arguments);
+    args.unshift(this);
+    this.fileObj.chunkEvent.apply(this.fileObj, args);
+  }
+
+  /**
+   * Catch progress event
+   * @param {ProgressEvent} event
+   */
+  progressHandler(event) {
+    if (event.lengthComputable) {
+      this.loaded = event.loaded ;
+      this.total = event.total;
+    }
+    this.event('progress', event);
+  }
+
+  /**
+   * Catch test event
+   * @param {Event} event
+   */
+  testHandler(event) {
+    var status = this.status(true);
+    if (status === 'error') {
+      this.event(status, this.message());
+      this.flowObj.uploadNextChunk();
+    } else if (status === 'success') {
+      this.tested = true;
+      this.event(status, this.message());
+      this.flowObj.uploadNextChunk();
+    } else if (!this.fileObj.paused) {
+      // Error might be caused by file pause method
+      // Chunks does not exist on the server side
+      this.tested = true;
+      this.send();
+    }
+  }
+
+  /**
+   * Upload has stopped
+   * @param {Event} event
+   */
+  doneHandler(event) {
+    var status = this.status();
+    if (status === 'success' || status === 'error') {
+      delete this.data;
+      this.event(status, this.message());
+      this.flowObj.uploadNextChunk();
+    } else if (!this.fileObj.paused) {
+      this.event('retry', this.message());
+      this.pendingRetry = true;
+      this.abort();
+      this.retries++;
+      var retryInterval = this.flowObj.opts.chunkRetryInterval;
+      if (retryInterval !== null) {
+        setTimeout(() => this.send(), retryInterval);
+      } else {
+        this.send();
+      }
+    }
+  }
+
+  /**
+   * Get params for a request
+   * @function
+   */
+  getParams () {
+    return {
+      flowChunkNumber: this.offset + 1,
+      flowChunkSize: this.chunkSize,
+      flowCurrentChunkSize: this.endByte - this.startByte,
+      flowTotalSize: this.fileObj.size,
+      flowIdentifier: this.fileObj.uniqueIdentifier,
+      flowFilename: this.fileObj.name,
+      flowRelativePath: this.fileObj.relativePath,
+      flowTotalChunks: this.fileObj.chunks.length
+    };
+  }
+
+  /**
+   * Get target option with query params
+   * @function
+   * @param params
+   * @returns {string}
+   */
+  getTarget(target, params){
+    if (params.length == 0) {
+      return target;
+    }
+
+    if(target.indexOf('?') < 0) {
+      target += '?';
+    } else {
+      target += '&';
+    }
+    return target + params.join('&');
+  }
+
+  /**
+   * Makes a GET request without any data to see if the chunk has already
+   * been uploaded in a previous session
+   * @function
+   */
+  test() {
+    // Set up request and listen for event
+    this.xhr = new XMLHttpRequest();
+    this.xhr.addEventListener("load", this.testHandler.bind(this), false);
+    this.xhr.addEventListener("error", this.testHandler.bind(this), false);
+    var testMethod = evalOpts(this.flowObj.opts.testMethod, this.fileObj, this);
+    var data = this.prepareXhrRequest(testMethod, true);
+    this.xhr.send(data);
+  }
+
+  /**
+   * Finish preprocess state
+   * @function
+   */
+  preprocessFinished() {
+    // Re-compute the endByte after the preprocess function to allow an
+    // implementer of preprocess to set the fileObj size
+    this.endByte = this.computeEndByte();
+
+    this.preprocessState = 2;
+    this.send();
+  }
+
+  /**
+   * Finish read state
+   * @function
+   */
+  readFinished(bytes) {
+    this.readState = 2;
+    this.bytes = bytes;
+    this.send();
+  }
+
+  /**
+   * Uploads the actual data in a POST call
+   * @function
+   */
+  send() {
+    var preprocess = this.flowObj.opts.preprocess;
+    var read = this.flowObj.opts.readFileFn;
+    if (typeof preprocess === 'function') {
+      switch (this.preprocessState) {
+        case 0:
+          this.preprocessState = 1;
+          preprocess(this);
+          return;
+        case 1:
+          return;
+      }
+    }
+    switch (this.readState) {
+      case 0:
+        this.readState = 1;
+        read(this.fileObj, this.startByte, this.endByte, this.fileObj.file.type, this);
+        return;
+      case 1:
+        return;
+    }
+    if (this.flowObj.opts.testChunks && !this.tested) {
+      this.test();
+      return;
+    }
+
+    this.loaded = 0;
+    this.total = 0;
+    this.pendingRetry = false;
+
+    // Set up request and listen for event
+    this.xhr = new XMLHttpRequest();
+    this.xhr.upload.addEventListener('progress', this.progressHandler.bind(this), false);
+    this.xhr.addEventListener('load', this.doneHandler.bind(this), false);
+    this.xhr.addEventListener('error', this.doneHandler.bind(this), false);
+
+    var uploadMethod = evalOpts(this.flowObj.opts.uploadMethod, this.fileObj, this);
+    var data = this.prepareXhrRequest(uploadMethod, false, this.flowObj.opts.method, this.bytes);
+    var changeRawDataBeforeSend = this.flowObj.opts.changeRawDataBeforeSend;
+    if (typeof changeRawDataBeforeSend === 'function') {
+      data = changeRawDataBeforeSend(this, data);
+    }
+    this.xhr.send(data);
+  }
+
+  /**
+   * Abort current xhr request
+   * @function
+   */
+  abort() {
+    // Abort and reset
+    var xhr = this.xhr;
+    this.xhr = null;
+    if (xhr) {
+      xhr.abort();
+    }
+  }
+
+  /**
+   * Retrieve current chunk upload status
+   * @function
+   * @returns {string} 'pending', 'uploading', 'success', 'error'
+   */
+  status(isTest) {
+    if (this.readState === 1) {
+      return 'reading';
+    } else if (this.pendingRetry || this.preprocessState === 1) {
+      // 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 (!this.xhr) {
+      return 'pending';
+    } else if (this.xhr.readyState < 4) {
+      // Status is really 'OPENED', 'HEADERS_RECEIVED'
+      // or 'LOADING' - meaning that stuff is happening
+      return 'uploading';
+    } else {
+      if (this.flowObj.opts.successStatuses.indexOf(this.xhr.status) > -1) {
+        // HTTP 200, perfect
+	// HTTP 202 Accepted - The request has been accepted for processing, but the processing has not been completed.
+        return 'success';
+      } else if (this.flowObj.opts.permanentErrors.indexOf(this.xhr.status) > -1 ||
+                 !isTest && this.retries >= this.flowObj.opts.maxChunkRetries) {
+        // HTTP 413/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
+        this.abort();
+        return 'pending';
+      }
+    }
+  }
+
+  /**
+   * Get response from xhr request
+   * @function
+   * @returns {String}
+   */
+  message() {
+    return this.xhr ? this.xhr.responseText : '';
+  }
+
+  /**
+   * Get upload progress
+   * @function
+   * @returns {number}
+   */
+  progress() {
+    if (this.pendingRetry) {
+      return 0;
+    }
+    var s = this.status();
+    if (s === 'success' || s === 'error') {
+      return 1;
+    } else if (s === 'pending') {
+      return 0;
+    } else {
+      return this.total > 0 ? this.loaded / this.total : 0;
+    }
+  }
+
+  /**
+   * Count total size uploaded
+   * @function
+   * @returns {number}
+   */
+  sizeUploaded() {
+    var size = this.endByte - this.startByte;
+    // can't return only chunk.loaded value, because it is bigger than chunk size
+    if (this.status() !== 'success') {
+      size = this.progress() * size;
+    }
+    return size;
+  }
+
+  /**
+   * Prepare Xhr request. Set query, headers and data
+   * @param {string} method GET or POST
+   * @param {bool} isTest is this a test request
+   * @param {string} [paramsMethod] octet or form
+   * @param {Blob} [blob] to send
+   * @returns {FormData|Blob|Null} data to send
+   */
+  prepareXhrRequest(method, isTest, paramsMethod, blob) {
+    // Add data from the query options
+    var query = evalOpts(this.flowObj.opts.query, this.fileObj, this, isTest);
+    query = extend(query || {}, this.getParams());
+
+    var target = evalOpts(this.flowObj.opts.target, this.fileObj, this, isTest);
+    var data = null;
+    if (method === 'GET' || paramsMethod === 'octet') {
+      // Add data from the query options
+      var params = [];
+      each(query, function (v, k) {
+        params.push([encodeURIComponent(k), encodeURIComponent(v)].join('='));
+      });
+      target = this.getTarget(target, params);
+      data = blob || null;
+    } else {
+      // Add data from the query options
+      data = new FormData();
+      each(query, function (v, k) {
+        data.append(k, v);
+      });
+      if (typeof blob !== "undefined") {
+        data.append(this.flowObj.opts.fileParameterName, blob, this.filename || this.fileObj.file.name);
+      }
+    }
+
+    this.xhr.open(method, target, true);
+    this.xhr.withCredentials = this.flowObj.opts.withCredentials;
+
+    // Add data from header options
+    each(evalOpts(this.flowObj.opts.headers, this.fileObj, this, isTest), function (v, k) {
+      this.xhr.setRequestHeader(k, v);
+    }, this);
+
+    return data;
+  }
+}
diff --git a/src/FlowFile.js b/src/FlowFile.js
new file mode 100644
index 00000000..33661971
--- /dev/null
+++ b/src/FlowFile.js
@@ -0,0 +1,385 @@
+import FlowChunk from './FlowChunk';
+import {evalOpts, each} from './tools';
+
+/**
+ * FlowFile class
+ * @name FlowFile
+ * @param {Flow} flowObj
+ * @param {File} file
+ * @param {string} uniqueIdentifier
+ * @constructor
+ */
+export default class FlowFile {
+
+  constructor(flowObj, file, uniqueIdentifier) {
+
+    /**
+     * Reference to parent Flow instance
+     * @type {Flow}
+     */
+    this.flowObj = flowObj;
+
+    /**
+     * Used to store the bytes read
+     * @type {Blob|string}
+     */
+    this.bytes = null;
+
+    /**
+     * Reference to file
+     * @type {File}
+     */
+    this.file = file;
+
+    /**
+     * File name. Some confusion in different versions of Firefox
+     * @type {string}
+     */
+    this.name = file.fileName || file.name;
+
+    /**
+     * File size
+     * @type {number}
+     */
+    this.size = file.size;
+
+    /**
+     * Relative file path
+     * @type {string}
+     */
+    this.relativePath = file.relativePath || file.webkitRelativePath || this.name;
+
+    /**
+     * File unique identifier
+     * @type {string}
+     */
+    this.uniqueIdentifier = (uniqueIdentifier === undefined ? flowObj.generateUniqueIdentifier(file) : uniqueIdentifier);
+
+    /**
+     * Size of Each Chunk
+     * @type {number}
+     */
+    this.chunkSize = 0;
+
+    /**
+     * List of chunks
+     * @type {Array.<FlowChunk>}
+     */
+    this.chunks = [];
+
+    /**
+     * Indicated if file is paused
+     * @type {boolean}
+     */
+    this.paused = false;
+
+    /**
+     * Indicated if file has encountered an error
+     * @type {boolean}
+     */
+    this.error = false;
+
+    /**
+     * Average upload speed
+     * @type {number}
+     */
+    this.averageSpeed = 0;
+
+    /**
+     * Current upload speed
+     * @type {number}
+     */
+    this.currentSpeed = 0;
+
+    /**
+     * Date then progress was called last time
+     * @type {number}
+     * @private
+     */
+    this._lastProgressCallback = Date.now();
+
+    /**
+     * Previously uploaded file size
+     * @type {number}
+     * @private
+     */
+    this._prevUploadedSize = 0;
+
+    /**
+     * Holds previous progress
+     * @type {number}
+     * @private
+     */
+    this._prevProgress = 0;
+
+    this.bootstrap();
+  }
+
+  /**
+   * Update speed parameters
+   * @link http://stackoverflow.com/questions/2779600/how-to-estimate-download-time-remaining-accurately
+   * @function
+   */
+  measureSpeed() {
+    var timeSpan = Date.now() - this._lastProgressCallback;
+    if (!timeSpan) {
+      return ;
+    }
+    var smoothingFactor = this.flowObj.opts.speedSmoothingFactor;
+    var uploaded = this.sizeUploaded();
+    // Prevent negative upload speed after file upload resume
+    this.currentSpeed = Math.max((uploaded - this._prevUploadedSize) / timeSpan * 1000, 0);
+    this.averageSpeed = smoothingFactor * this.currentSpeed + (1 - smoothingFactor) * this.averageSpeed;
+    this._prevUploadedSize = uploaded;
+  }
+
+  /**
+   * For internal usage only.
+   * Callback when something happens within the chunk.
+   * @function
+   * @param {FlowChunk} chunk
+   * @param {string} event can be 'progress', 'success', 'error' or 'retry'
+   * @param {string} [message]
+   */
+  chunkEvent(chunk, event, message) {
+    switch (event) {
+      case 'progress':
+        if (Date.now() - this._lastProgressCallback <
+            this.flowObj.opts.progressCallbacksInterval) {
+          break;
+        }
+        this.measureSpeed();
+        this.flowObj.fire('fileProgress', this, chunk);
+        this.flowObj.fire('progress');
+        this._lastProgressCallback = Date.now();
+        break;
+      case 'error':
+        this.error = true;
+        this.abort(true);
+        this.flowObj.fire('fileError', this, message, chunk);
+        this.flowObj.fire('error', message, this, chunk);
+        break;
+      case 'success':
+        if (this.error) {
+          return;
+        }
+        this.measureSpeed();
+        this.flowObj.fire('fileProgress', this, chunk);
+        this.flowObj.fire('progress');
+        this._lastProgressCallback = Date.now();
+        if (this.isComplete()) {
+          this.currentSpeed = 0;
+          this.averageSpeed = 0;
+          this.flowObj.fire('fileSuccess', this, message, chunk);
+        }
+        break;
+      case 'retry':
+        this.flowObj.fire('fileRetry', this, chunk);
+        break;
+    }
+  }
+
+  /**
+   * Pause file upload
+   * @function
+   */
+  pause() {
+    this.paused = true;
+    this.abort();
+  }
+
+  /**
+   * Resume file upload
+   * @function
+   */
+  resume() {
+    this.paused = false;
+    this.flowObj.upload();
+  }
+
+  /**
+   * Abort current upload
+   * @function
+   */
+  abort(reset) {
+    this.currentSpeed = 0;
+    this.averageSpeed = 0;
+    var chunks = this.chunks;
+    if (reset) {
+      this.chunks = [];
+    }
+    each(chunks, function (c) {
+      if (c.status() === 'uploading') {
+        c.abort();
+        this.flowObj.uploadNextChunk();
+      }
+    }, this);
+  }
+
+  /**
+   * Cancel current upload and remove from a list
+   * @function
+   */
+  cancel() {
+    this.flowObj.removeFile(this);
+  }
+
+  /**
+   * Retry aborted file upload
+   * @function
+   */
+  retry() {
+    this.bootstrap();
+    this.flowObj.upload();
+  }
+
+  /**
+   * Clear current chunks and slice file again
+   * @function
+   */
+  bootstrap() {
+    if (typeof this.flowObj.opts.initFileFn === "function") {
+      var ret = this.flowObj.opts.initFileFn(this);
+      if (ret && 'then' in ret) {
+        ret.then(this._bootstrap.bind(this));
+        return;
+      }
+    }
+    this._bootstrap();
+  }
+
+  _bootstrap() {
+    this.abort(true);
+    this.error = false;
+    // Rebuild stack of chunks from file
+    this._prevProgress = 0;
+    var round = this.flowObj.opts.forceChunkSize ? Math.ceil : Math.floor;
+    this.chunkSize = evalOpts(this.flowObj.opts.chunkSize, this);
+    var chunks = Math.max(
+      round(this.size / this.chunkSize), 1
+    );
+    for (var offset = 0; offset < chunks; offset++) {
+      this.chunks.push(
+        new FlowChunk(this.flowObj, this, offset)
+      );
+    }
+  }
+
+  /**
+   * Get current upload progress status
+   * @function
+   * @returns {number} from 0 to 1
+   */
+  progress() {
+    if (this.error) {
+      return 1;
+    }
+    if (this.chunks.length === 1) {
+      this._prevProgress = Math.max(this._prevProgress, this.chunks[0].progress());
+      return this._prevProgress;
+    }
+    // Sum up progress across everything
+    var bytesLoaded = 0;
+    each(this.chunks, function (c) {
+      // get chunk progress relative to entire file
+      bytesLoaded += c.progress() * (c.endByte - c.startByte);
+    });
+    var percent = bytesLoaded / this.size;
+    // We don't want to lose percentages when an upload is paused
+    this._prevProgress = Math.max(this._prevProgress, percent > 0.9999 ? 1 : percent);
+    return this._prevProgress;
+  }
+
+  /**
+   * Indicates if file is being uploaded at the moment
+   * @function
+   * @returns {boolean}
+   */
+  isUploading() {
+    var uploading = false;
+    each(this.chunks, function (chunk) {
+      if (chunk.status() === 'uploading') {
+        uploading = true;
+        return false;
+      }
+    });
+    return uploading;
+  }
+
+  /**
+   * Indicates if file is has finished uploading and received a response
+   * @function
+   * @returns {boolean}
+   */
+  isComplete() {
+    var outstanding = false;
+    each(this.chunks, function (chunk) {
+      var status = chunk.status();
+      if (status === 'pending' || status === 'uploading' || status === 'reading' || chunk.preprocessState === 1 || chunk.readState === 1) {
+        outstanding = true;
+        return false;
+      }
+    });
+    return !outstanding;
+  }
+
+  /**
+   * Count total size uploaded
+   * @function
+   * @returns {number}
+   */
+  sizeUploaded() {
+    var size = 0;
+    each(this.chunks, function (chunk) {
+      size += chunk.sizeUploaded();
+    });
+    return size;
+  }
+
+  /**
+   * Returns remaining time to finish upload file in seconds. Accuracy is based on average speed.
+   * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`
+   * @function
+   * @returns {number}
+   */
+  timeRemaining() {
+    if (this.paused || this.error) {
+      return 0;
+    }
+    var delta = this.size - this.sizeUploaded();
+    if (delta && !this.averageSpeed) {
+      return Number.POSITIVE_INFINITY;
+    }
+    if (!delta && !this.averageSpeed) {
+      return 0;
+    }
+    return Math.floor(delta / this.averageSpeed);
+  }
+
+  /**
+   * Get file type
+   * @function
+   * @returns {string}
+   */
+  getType() {
+    return this.file.type && this.file.type.split('/')[1];
+  }
+
+  /**
+   * Get file extension
+   * @function
+   * @returns {string}
+   */
+  getExtension() {
+    return this.name.substr((~-this.name.lastIndexOf(".") >>> 0) + 2).toLowerCase();
+  }
+}
+
+/**
+ * Exclusively for test purposes
+ * (Until Grunt+Karma+Jasmine can allow test to use (ES) `import` of tools.js)
+ */
+var g = typeof window !== 'undefined' ? window
+    : typeof global !== 'undefined' ? global
+    : typeof self !== 'undefined' ? self : {};
+g.FlowFile = FlowFile;
diff --git a/src/flow.js b/src/flow.js
deleted file mode 100644
index 2b592d3e..00000000
--- a/src/flow.js
+++ /dev/null
@@ -1,1671 +0,0 @@
-/**
- * @license MIT
- */
-(function(window, document, undefined) {'use strict';
-  if (!window || !document) {
-    console.warn('Flowjs needs window and document objects to work');
-    return;
-  }
-  // ie10+
-  var ie10plus = window.navigator.msPointerEnabled;
-  /**
-   * Flow.js is a library providing multiple simultaneous, stable and
-   * resumable uploads via the HTML5 File API.
-   * @param [opts]
-   * @param {number|Function} [opts.chunkSize]
-   * @param {bool} [opts.forceChunkSize]
-   * @param {number} [opts.simultaneousUploads]
-   * @param {bool} [opts.singleFile]
-   * @param {string} [opts.fileParameterName]
-   * @param {number} [opts.progressCallbacksInterval]
-   * @param {number} [opts.speedSmoothingFactor]
-   * @param {Object|Function} [opts.query]
-   * @param {Object|Function} [opts.headers]
-   * @param {bool} [opts.withCredentials]
-   * @param {Function} [opts.preprocess]
-   * @param {string} [opts.method]
-   * @param {string|Function} [opts.testMethod]
-   * @param {string|Function} [opts.uploadMethod]
-   * @param {bool} [opts.prioritizeFirstAndLastChunk]
-   * @param {bool} [opts.allowDuplicateUploads]
-   * @param {string|Function} [opts.target]
-   * @param {number} [opts.maxChunkRetries]
-   * @param {number} [opts.chunkRetryInterval]
-   * @param {Array.<number>} [opts.permanentErrors]
-   * @param {Array.<number>} [opts.successStatuses]
-   * @param {Function} [opts.initFileFn]
-   * @param {Function} [opts.readFileFn]
-   * @param {Function} [opts.generateUniqueIdentifier]
-   * @constructor
-   */
-  function Flow(opts) {
-    /**
-     * Supported by browser?
-     * @type {boolean}
-     */
-    this.support = (
-        typeof File !== 'undefined' &&
-        typeof Blob !== 'undefined' &&
-        typeof FileList !== 'undefined' &&
-        (
-          !!Blob.prototype.slice || !!Blob.prototype.webkitSlice || !!Blob.prototype.mozSlice ||
-          false
-        ) // slicing files support
-    );
-
-    if (!this.support) {
-      return ;
-    }
-
-    /**
-     * Check if directory upload is supported
-     * @type {boolean}
-     */
-    this.supportDirectory = (
-        /Chrome/.test(window.navigator.userAgent) ||
-        /Firefox/.test(window.navigator.userAgent) ||
-        /Edge/.test(window.navigator.userAgent)
-    );
-
-    /**
-     * List of FlowFile objects
-     * @type {Array.<FlowFile>}
-     */
-    this.files = [];
-
-    /**
-     * Default options for flow.js
-     * @type {Object}
-     */
-    this.defaults = {
-      chunkSize: 1024 * 1024,
-      forceChunkSize: false,
-      simultaneousUploads: 3,
-      singleFile: false,
-      fileParameterName: 'file',
-      progressCallbacksInterval: 500,
-      speedSmoothingFactor: 0.1,
-      query: {},
-      headers: {},
-      withCredentials: false,
-      preprocess: null,
-      changeRawDataBeforeSend: null,
-      method: 'multipart',
-      testMethod: 'GET',
-      uploadMethod: 'POST',
-      prioritizeFirstAndLastChunk: false,
-      allowDuplicateUploads: false,
-      target: '/',
-      testChunks: true,
-      generateUniqueIdentifier: null,
-      maxChunkRetries: 0,
-      chunkRetryInterval: null,
-      permanentErrors: [404, 413, 415, 500, 501],
-      successStatuses: [200, 201, 202],
-      onDropStopPropagation: false,
-      initFileFn: null,
-      readFileFn: webAPIFileRead
-    };
-
-    /**
-     * Current options
-     * @type {Object}
-     */
-    this.opts = {};
-
-    /**
-     * List of events:
-     *  key stands for event name
-     *  value array list of callbacks
-     * @type {}
-     */
-    this.events = {};
-
-    var $ = this;
-
-    /**
-     * On drop event
-     * @function
-     * @param {MouseEvent} event
-     */
-    this.onDrop = function (event) {
-      if ($.opts.onDropStopPropagation) {
-        event.stopPropagation();
-      }
-      event.preventDefault();
-      var dataTransfer = event.dataTransfer;
-      if (dataTransfer.items && dataTransfer.items[0] &&
-        dataTransfer.items[0].webkitGetAsEntry) {
-        $.webkitReadDataTransfer(event);
-      } else {
-        $.addFiles(dataTransfer.files, event);
-      }
-    };
-
-    /**
-     * Prevent default
-     * @function
-     * @param {MouseEvent} event
-     */
-    this.preventEvent = function (event) {
-      event.preventDefault();
-    };
-
-
-    /**
-     * Current options
-     * @type {Object}
-     */
-    this.opts = Flow.extend({}, this.defaults, opts || {});
-
-  }
-
-  Flow.prototype = {
-    /**
-     * Set a callback for an event, possible events:
-     * fileSuccess(file), fileProgress(file), fileAdded(file, event),
-     * fileRemoved(file), fileRetry(file), fileError(file, message),
-     * complete(), progress(), error(message, file), pause()
-     * @function
-     * @param {string} event
-     * @param {Function} callback
-     */
-    on: function (event, callback) {
-      event = event.toLowerCase();
-      if (!this.events.hasOwnProperty(event)) {
-        this.events[event] = [];
-      }
-      this.events[event].push(callback);
-    },
-
-    /**
-     * Remove event callback
-     * @function
-     * @param {string} [event] removes all events if not specified
-     * @param {Function} [fn] removes all callbacks of event if not specified
-     */
-    off: function (event, fn) {
-      if (event !== undefined) {
-        event = event.toLowerCase();
-        if (fn !== undefined) {
-          if (this.events.hasOwnProperty(event)) {
-            arrayRemove(this.events[event], fn);
-          }
-        } else {
-          delete this.events[event];
-        }
-      } else {
-        this.events = {};
-      }
-    },
-
-    /**
-     * Fire an event
-     * @function
-     * @param {string} event event name
-     * @param {...} args arguments of a callback
-     * @return {bool} value is false if at least one of the event handlers which handled this event
-     * returned false. Otherwise it returns true.
-     */
-    fire: function (event, args) {
-      // `arguments` is an object, not array, in FF, so:
-      args = Array.prototype.slice.call(arguments);
-      event = event.toLowerCase();
-      var preventDefault = false;
-      if (this.events.hasOwnProperty(event)) {
-        each(this.events[event], function (callback) {
-          preventDefault = callback.apply(this, args.slice(1)) === false || preventDefault;
-        }, this);
-      }
-      if (event != 'catchall') {
-        args.unshift('catchAll');
-        preventDefault = this.fire.apply(this, args) === false || preventDefault;
-      }
-      return !preventDefault;
-    },
-
-    /**
-     * Read webkit dataTransfer object
-     * @param event
-     */
-    webkitReadDataTransfer: function (event) {
-      var $ = this;
-      var queue = event.dataTransfer.items.length;
-      var files = [];
-      each(event.dataTransfer.items, function (item) {
-        var entry = item.webkitGetAsEntry();
-        if (!entry) {
-          decrement();
-          return ;
-        }
-        if (entry.isFile) {
-          // due to a bug in Chrome's File System API impl - #149735
-          fileReadSuccess(item.getAsFile(), entry.fullPath);
-        } else {
-          readDirectory(entry.createReader());
-        }
-      });
-      function readDirectory(reader) {
-        reader.readEntries(function (entries) {
-          if (entries.length) {
-            queue += entries.length;
-            each(entries, function(entry) {
-              if (entry.isFile) {
-                var fullPath = entry.fullPath;
-                entry.file(function (file) {
-                  fileReadSuccess(file, fullPath);
-                }, readError);
-              } else if (entry.isDirectory) {
-                readDirectory(entry.createReader());
-              }
-            });
-            readDirectory(reader);
-          } else {
-            decrement();
-          }
-        }, readError);
-      }
-      function fileReadSuccess(file, fullPath) {
-        // relative path should not start with "/"
-        file.relativePath = fullPath.substring(1);
-        files.push(file);
-        decrement();
-      }
-      function readError(fileError) {
-        decrement();
-        throw fileError;
-      }
-      function decrement() {
-        if (--queue == 0) {
-          $.addFiles(files, event);
-        }
-      }
-    },
-
-    /**
-     * Generate unique identifier for a file
-     * @function
-     * @param {FlowFile} file
-     * @returns {string}
-     */
-    generateUniqueIdentifier: function (file) {
-      var custom = this.opts.generateUniqueIdentifier;
-      if (typeof custom === 'function') {
-        return custom(file);
-      }
-      // Some confusion in different versions of Firefox
-      var relativePath = file.relativePath || file.webkitRelativePath || file.fileName || file.name;
-      return file.size + '-' + relativePath.replace(/[^0-9a-zA-Z_-]/img, '');
-    },
-
-    /**
-     * Upload next chunk from the queue
-     * @function
-     * @returns {boolean}
-     * @private
-     */
-    uploadNextChunk: function (preventEvents) {
-      // 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.
-      var found = false;
-      if (this.opts.prioritizeFirstAndLastChunk) {
-        each(this.files, function (file) {
-          if (!file.paused && file.chunks.length &&
-            file.chunks[0].status() === 'pending') {
-            file.chunks[0].send();
-            found = true;
-            return false;
-          }
-          if (!file.paused && file.chunks.length > 1 &&
-            file.chunks[file.chunks.length - 1].status() === 'pending') {
-            file.chunks[file.chunks.length - 1].send();
-            found = true;
-            return false;
-          }
-        });
-        if (found) {
-          return found;
-        }
-      }
-
-      // Now, simply look for the next, best thing to upload
-      each(this.files, function (file) {
-        if (!file.paused) {
-          each(file.chunks, function (chunk) {
-            if (chunk.status() === 'pending') {
-              chunk.send();
-              found = true;
-              return false;
-            }
-          });
-        }
-        if (found) {
-          return false;
-        }
-      });
-      if (found) {
-        return true;
-      }
-
-      // The are no more outstanding chunks to upload, check is everything is done
-      var outstanding = false;
-      each(this.files, function (file) {
-        if (!file.isComplete()) {
-          outstanding = true;
-          return false;
-        }
-      });
-      if (!outstanding && !preventEvents) {
-        // All chunks have been uploaded, complete
-        async(function () {
-          this.fire('complete');
-        }, this);
-      }
-      return false;
-    },
-
-
-    /**
-     * Assign a browse action to one or more DOM nodes.
-     * @function
-     * @param {Element|Array.<Element>} domNodes
-     * @param {boolean} isDirectory Pass in true to allow directories to
-     * @param {boolean} singleFile prevent multi file upload
-     * @param {Object} attributes set custom attributes:
-     *  http://www.w3.org/TR/html-markup/input.file.html#input.file-attributes
-     *  eg: accept: 'image/*'
-     * be selected (Chrome only).
-     */
-    assignBrowse: function (domNodes, isDirectory, singleFile, attributes) {
-      if (domNodes instanceof Element) {
-        domNodes = [domNodes];
-      }
-
-      each(domNodes, function (domNode) {
-        var input;
-        if (domNode.tagName === 'INPUT' && domNode.type === 'file') {
-          input = domNode;
-        } else {
-          input = document.createElement('input');
-          input.setAttribute('type', 'file');
-          // display:none - not working in opera 12
-          extend(input.style, {
-            visibility: 'hidden',
-            position: 'absolute',
-            width: '1px',
-            height: '1px'
-          });
-          // for opera 12 browser, input must be assigned to a document
-          domNode.appendChild(input);
-          // https://developer.mozilla.org/en/using_files_from_web_applications)
-          // event listener is executed two times
-          // first one - original mouse click event
-          // second - input.click(), input is inside domNode
-          domNode.addEventListener('click', function() {
-            input.click();
-          }, false);
-        }
-        if (!this.opts.singleFile && !singleFile) {
-          input.setAttribute('multiple', 'multiple');
-        }
-        if (isDirectory) {
-          input.setAttribute('webkitdirectory', 'webkitdirectory');
-        }
-        each(attributes, function (value, key) {
-          input.setAttribute(key, value);
-        });
-        // When new files are added, simply append them to the overall list
-        var $ = this;
-        input.addEventListener('change', function (e) {
-       	  if (e.target.value) {
-            $.addFiles(e.target.files, e);
-            e.target.value = '';
-       	  }
-        }, false);
-      }, this);
-    },
-
-    /**
-     * Assign one or more DOM nodes as a drop target.
-     * @function
-     * @param {Element|Array.<Element>} domNodes
-     */
-    assignDrop: function (domNodes) {
-      if (typeof domNodes.length === 'undefined') {
-        domNodes = [domNodes];
-      }
-      each(domNodes, function (domNode) {
-        domNode.addEventListener('dragover', this.preventEvent, false);
-        domNode.addEventListener('dragenter', this.preventEvent, false);
-        domNode.addEventListener('drop', this.onDrop, false);
-      }, this);
-    },
-
-    /**
-     * Un-assign drop event from DOM nodes
-     * @function
-     * @param domNodes
-     */
-    unAssignDrop: function (domNodes) {
-      if (typeof domNodes.length === 'undefined') {
-        domNodes = [domNodes];
-      }
-      each(domNodes, function (domNode) {
-        domNode.removeEventListener('dragover', this.preventEvent);
-        domNode.removeEventListener('dragenter', this.preventEvent);
-        domNode.removeEventListener('drop', this.onDrop);
-      }, this);
-    },
-
-    /**
-     * Returns a boolean indicating whether or not the instance is currently
-     * uploading anything.
-     * @function
-     * @returns {boolean}
-     */
-    isUploading: function () {
-      var uploading = false;
-      each(this.files, function (file) {
-        if (file.isUploading()) {
-          uploading = true;
-          return false;
-        }
-      });
-      return uploading;
-    },
-
-    /**
-     * should upload next chunk
-     * @function
-     * @returns {boolean|number}
-     */
-    _shouldUploadNext: function () {
-      var num = 0;
-      var should = true;
-      var simultaneousUploads = this.opts.simultaneousUploads;
-      each(this.files, function (file) {
-        each(file.chunks, function(chunk) {
-          if (chunk.status() === 'uploading') {
-            num++;
-            if (num >= simultaneousUploads) {
-              should = false;
-              return false;
-            }
-          }
-        });
-      });
-      // if should is true then return uploading chunks's length
-      return should && num;
-    },
-
-    /**
-     * Start or resume uploading.
-     * @function
-     */
-    upload: function () {
-      // Make sure we don't start too many uploads at once
-      var ret = this._shouldUploadNext();
-      if (ret === false) {
-        return;
-      }
-      // Kick off the queue
-      this.fire('uploadStart');
-      var started = false;
-      for (var num = 1; num <= this.opts.simultaneousUploads - ret; num++) {
-        started = this.uploadNextChunk(true) || started;
-      }
-      if (!started) {
-        async(function () {
-          this.fire('complete');
-        }, this);
-      }
-    },
-
-    /**
-     * Resume uploading.
-     * @function
-     */
-    resume: function () {
-      each(this.files, function (file) {
-        if (!file.isComplete()) {
-          file.resume();
-        }
-      });
-    },
-
-    /**
-     * Pause uploading.
-     * @function
-     */
-    pause: function () {
-      each(this.files, function (file) {
-        file.pause();
-      });
-    },
-
-    /**
-     * Cancel upload of all FlowFile objects and remove them from the list.
-     * @function
-     */
-    cancel: function () {
-      for (var i = this.files.length - 1; i >= 0; i--) {
-        this.files[i].cancel();
-      }
-    },
-
-    /**
-     * Returns a number between 0 and 1 indicating the current upload progress
-     * of all files.
-     * @function
-     * @returns {number}
-     */
-    progress: function () {
-      var totalDone = 0;
-      var totalSize = 0;
-      // Resume all chunks currently being uploaded
-      each(this.files, function (file) {
-        totalDone += file.progress() * file.size;
-        totalSize += file.size;
-      });
-      return totalSize > 0 ? totalDone / totalSize : 0;
-    },
-
-    /**
-     * Add a HTML5 File object to the list of files.
-     * @function
-     * @param {File} file
-     * @param {Event} [event] event is optional
-     */
-    addFile: function (file, event) {
-      this.addFiles([file], event);
-    },
-
-    /**
-     * Add a HTML5 File object to the list of files.
-     * @function
-     * @param {FileList|Array} fileList
-     * @param {Event} [event] event is optional
-     */
-    addFiles: function (fileList, event) {
-      var files = [];
-      each(fileList, function (file) {
-        // https://github.com/flowjs/flow.js/issues/55
-        if ((!ie10plus || ie10plus && file.size > 0) && !(file.size % 4096 === 0 && (file.name === '.' || file.fileName === '.'))) {
-          var uniqueIdentifier = this.generateUniqueIdentifier(file);
-          if (this.opts.allowDuplicateUploads || !this.getFromUniqueIdentifier(uniqueIdentifier)) {
-            var f = new FlowFile(this, file, uniqueIdentifier);
-            if (this.fire('fileAdded', f, event)) {
-              files.push(f);
-            }
-          }
-        }
-      }, this);
-      if (this.fire('filesAdded', files, event)) {
-        each(files, function (file) {
-          if (this.opts.singleFile && this.files.length > 0) {
-            this.removeFile(this.files[0]);
-          }
-          this.files.push(file);
-        }, this);
-        this.fire('filesSubmitted', files, event);
-      }
-    },
-
-
-    /**
-     * Cancel upload of a specific FlowFile object from the list.
-     * @function
-     * @param {FlowFile} file
-     */
-    removeFile: function (file) {
-      for (var i = this.files.length - 1; i >= 0; i--) {
-        if (this.files[i] === file) {
-          this.files.splice(i, 1);
-          file.abort();
-          this.fire('fileRemoved', file);
-        }
-      }
-    },
-
-    /**
-     * Look up a FlowFile object by its unique identifier.
-     * @function
-     * @param {string} uniqueIdentifier
-     * @returns {boolean|FlowFile} false if file was not found
-     */
-    getFromUniqueIdentifier: function (uniqueIdentifier) {
-      var ret = false;
-      each(this.files, function (file) {
-        if (file.uniqueIdentifier === uniqueIdentifier) {
-          ret = file;
-        }
-      });
-      return ret;
-    },
-
-    /**
-     * Returns the total size of all files in bytes.
-     * @function
-     * @returns {number}
-     */
-    getSize: function () {
-      var totalSize = 0;
-      each(this.files, function (file) {
-        totalSize += file.size;
-      });
-      return totalSize;
-    },
-
-    /**
-     * Returns the total size uploaded of all files in bytes.
-     * @function
-     * @returns {number}
-     */
-    sizeUploaded: function () {
-      var size = 0;
-      each(this.files, function (file) {
-        size += file.sizeUploaded();
-      });
-      return size;
-    },
-
-    /**
-     * Returns remaining time to upload all files in seconds. Accuracy is based on average speed.
-     * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`
-     * @function
-     * @returns {number}
-     */
-    timeRemaining: function () {
-      var sizeDelta = 0;
-      var averageSpeed = 0;
-      each(this.files, function (file) {
-        if (!file.paused && !file.error) {
-          sizeDelta += file.size - file.sizeUploaded();
-          averageSpeed += file.averageSpeed;
-        }
-      });
-      if (sizeDelta && !averageSpeed) {
-        return Number.POSITIVE_INFINITY;
-      }
-      if (!sizeDelta && !averageSpeed) {
-        return 0;
-      }
-      return Math.floor(sizeDelta / averageSpeed);
-    }
-  };
-
-
-
-
-
-
-  /**
-   * FlowFile class
-   * @name FlowFile
-   * @param {Flow} flowObj
-   * @param {File} file
-   * @param {string} uniqueIdentifier
-   * @constructor
-   */
-  function FlowFile(flowObj, file, uniqueIdentifier) {
-
-    /**
-     * Reference to parent Flow instance
-     * @type {Flow}
-     */
-    this.flowObj = flowObj;
-
-    /**
-     * Used to store the bytes read
-     * @type {Blob|string}
-     */
-    this.bytes = null;
-
-    /**
-     * Reference to file
-     * @type {File}
-     */
-    this.file = file;
-
-    /**
-     * File name. Some confusion in different versions of Firefox
-     * @type {string}
-     */
-    this.name = file.fileName || file.name;
-
-    /**
-     * File size
-     * @type {number}
-     */
-    this.size = file.size;
-
-    /**
-     * Relative file path
-     * @type {string}
-     */
-    this.relativePath = file.relativePath || file.webkitRelativePath || this.name;
-
-    /**
-     * File unique identifier
-     * @type {string}
-     */
-    this.uniqueIdentifier = (uniqueIdentifier === undefined ? flowObj.generateUniqueIdentifier(file) : uniqueIdentifier);
-
-    /**
-     * Size of Each Chunk
-     * @type {number}
-     */
-    this.chunkSize = 0;
-
-    /**
-     * List of chunks
-     * @type {Array.<FlowChunk>}
-     */
-    this.chunks = [];
-
-    /**
-     * Indicated if file is paused
-     * @type {boolean}
-     */
-    this.paused = false;
-
-    /**
-     * Indicated if file has encountered an error
-     * @type {boolean}
-     */
-    this.error = false;
-
-    /**
-     * Average upload speed
-     * @type {number}
-     */
-    this.averageSpeed = 0;
-
-    /**
-     * Current upload speed
-     * @type {number}
-     */
-    this.currentSpeed = 0;
-
-    /**
-     * Date then progress was called last time
-     * @type {number}
-     * @private
-     */
-    this._lastProgressCallback = Date.now();
-
-    /**
-     * Previously uploaded file size
-     * @type {number}
-     * @private
-     */
-    this._prevUploadedSize = 0;
-
-    /**
-     * Holds previous progress
-     * @type {number}
-     * @private
-     */
-    this._prevProgress = 0;
-
-    this.bootstrap();
-  }
-
-  FlowFile.prototype = {
-    /**
-     * Update speed parameters
-     * @link http://stackoverflow.com/questions/2779600/how-to-estimate-download-time-remaining-accurately
-     * @function
-     */
-    measureSpeed: function () {
-      var timeSpan = Date.now() - this._lastProgressCallback;
-      if (!timeSpan) {
-        return ;
-      }
-      var smoothingFactor = this.flowObj.opts.speedSmoothingFactor;
-      var uploaded = this.sizeUploaded();
-      // Prevent negative upload speed after file upload resume
-      this.currentSpeed = Math.max((uploaded - this._prevUploadedSize) / timeSpan * 1000, 0);
-      this.averageSpeed = smoothingFactor * this.currentSpeed + (1 - smoothingFactor) * this.averageSpeed;
-      this._prevUploadedSize = uploaded;
-    },
-
-    /**
-     * For internal usage only.
-     * Callback when something happens within the chunk.
-     * @function
-     * @param {FlowChunk} chunk
-     * @param {string} event can be 'progress', 'success', 'error' or 'retry'
-     * @param {string} [message]
-     */
-    chunkEvent: function (chunk, event, message) {
-      switch (event) {
-        case 'progress':
-          if (Date.now() - this._lastProgressCallback <
-            this.flowObj.opts.progressCallbacksInterval) {
-            break;
-          }
-          this.measureSpeed();
-          this.flowObj.fire('fileProgress', this, chunk);
-          this.flowObj.fire('progress');
-          this._lastProgressCallback = Date.now();
-          break;
-        case 'error':
-          this.error = true;
-          this.abort(true);
-          this.flowObj.fire('fileError', this, message, chunk);
-          this.flowObj.fire('error', message, this, chunk);
-          break;
-        case 'success':
-          if (this.error) {
-            return;
-          }
-          this.measureSpeed();
-          this.flowObj.fire('fileProgress', this, chunk);
-          this.flowObj.fire('progress');
-          this._lastProgressCallback = Date.now();
-          if (this.isComplete()) {
-            this.currentSpeed = 0;
-            this.averageSpeed = 0;
-            this.flowObj.fire('fileSuccess', this, message, chunk);
-          }
-          break;
-        case 'retry':
-          this.flowObj.fire('fileRetry', this, chunk);
-          break;
-      }
-    },
-
-    /**
-     * Pause file upload
-     * @function
-     */
-    pause: function() {
-      this.paused = true;
-      this.abort();
-    },
-
-    /**
-     * Resume file upload
-     * @function
-     */
-    resume: function() {
-      this.paused = false;
-      this.flowObj.upload();
-    },
-
-    /**
-     * Abort current upload
-     * @function
-     */
-    abort: function (reset) {
-      this.currentSpeed = 0;
-      this.averageSpeed = 0;
-      var chunks = this.chunks;
-      if (reset) {
-        this.chunks = [];
-      }
-      each(chunks, function (c) {
-        if (c.status() === 'uploading') {
-          c.abort();
-          this.flowObj.uploadNextChunk();
-        }
-      }, this);
-    },
-
-    /**
-     * Cancel current upload and remove from a list
-     * @function
-     */
-    cancel: function () {
-      this.flowObj.removeFile(this);
-    },
-
-    /**
-     * Retry aborted file upload
-     * @function
-     */
-    retry: function () {
-      this.bootstrap();
-      this.flowObj.upload();
-    },
-
-    /**
-     * Clear current chunks and slice file again
-     * @function
-     */
-    bootstrap: function () {
-      if (typeof this.flowObj.opts.initFileFn === "function") {
-        var ret = this.flowObj.opts.initFileFn(this);
-        if (ret && 'then' in ret) {
-          ret.then(this._bootstrap.bind(this));
-          return;
-        }
-      }
-      this._bootstrap();
-    },
-
-    _bootstrap: function () {
-      this.abort(true);
-      this.error = false;
-      // Rebuild stack of chunks from file
-      this._prevProgress = 0;
-      var round = this.flowObj.opts.forceChunkSize ? Math.ceil : Math.floor;
-      this.chunkSize = evalOpts(this.flowObj.opts.chunkSize, this);
-      var chunks = Math.max(
-        round(this.size / this.chunkSize), 1
-      );
-      for (var offset = 0; offset < chunks; offset++) {
-        this.chunks.push(
-          new FlowChunk(this.flowObj, this, offset)
-        );
-      }
-    },
-
-    /**
-     * Get current upload progress status
-     * @function
-     * @returns {number} from 0 to 1
-     */
-    progress: function () {
-      if (this.error) {
-        return 1;
-      }
-      if (this.chunks.length === 1) {
-        this._prevProgress = Math.max(this._prevProgress, this.chunks[0].progress());
-        return this._prevProgress;
-      }
-      // Sum up progress across everything
-      var bytesLoaded = 0;
-      each(this.chunks, function (c) {
-        // get chunk progress relative to entire file
-        bytesLoaded += c.progress() * (c.endByte - c.startByte);
-      });
-      var percent = bytesLoaded / this.size;
-      // We don't want to lose percentages when an upload is paused
-      this._prevProgress = Math.max(this._prevProgress, percent > 0.9999 ? 1 : percent);
-      return this._prevProgress;
-    },
-
-    /**
-     * Indicates if file is being uploaded at the moment
-     * @function
-     * @returns {boolean}
-     */
-    isUploading: function () {
-      var uploading = false;
-      each(this.chunks, function (chunk) {
-        if (chunk.status() === 'uploading') {
-          uploading = true;
-          return false;
-        }
-      });
-      return uploading;
-    },
-
-    /**
-     * Indicates if file is has finished uploading and received a response
-     * @function
-     * @returns {boolean}
-     */
-    isComplete: function () {
-      var outstanding = false;
-      each(this.chunks, function (chunk) {
-        var status = chunk.status();
-        if (status === 'pending' || status === 'uploading' || status === 'reading' || chunk.preprocessState === 1 || chunk.readState === 1) {
-          outstanding = true;
-          return false;
-        }
-      });
-      return !outstanding;
-    },
-
-    /**
-     * Count total size uploaded
-     * @function
-     * @returns {number}
-     */
-    sizeUploaded: function () {
-      var size = 0;
-      each(this.chunks, function (chunk) {
-        size += chunk.sizeUploaded();
-      });
-      return size;
-    },
-
-    /**
-     * Returns remaining time to finish upload file in seconds. Accuracy is based on average speed.
-     * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`
-     * @function
-     * @returns {number}
-     */
-    timeRemaining: function () {
-      if (this.paused || this.error) {
-        return 0;
-      }
-      var delta = this.size - this.sizeUploaded();
-      if (delta && !this.averageSpeed) {
-        return Number.POSITIVE_INFINITY;
-      }
-      if (!delta && !this.averageSpeed) {
-        return 0;
-      }
-      return Math.floor(delta / this.averageSpeed);
-    },
-
-    /**
-     * Get file type
-     * @function
-     * @returns {string}
-     */
-    getType: function () {
-      return this.file.type && this.file.type.split('/')[1];
-    },
-
-    /**
-     * Get file extension
-     * @function
-     * @returns {string}
-     */
-    getExtension: function () {
-      return this.name.substr((~-this.name.lastIndexOf(".") >>> 0) + 2).toLowerCase();
-    }
-  };
-
-  /**
-   * Default read function using the webAPI
-   *
-   * @function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk)
-   *
-   */
-  function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk) {
-    var function_name = 'slice';
-
-    if (fileObj.file.slice)
-      function_name =  'slice';
-    else if (fileObj.file.mozSlice)
-      function_name = 'mozSlice';
-    else if (fileObj.file.webkitSlice)
-      function_name = 'webkitSlice';
-
-    chunk.readFinished(fileObj.file[function_name](startByte, endByte, fileType));
-  }
-
-
-  /**
-   * Class for storing a single chunk
-   * @name FlowChunk
-   * @param {Flow} flowObj
-   * @param {FlowFile} fileObj
-   * @param {number} offset
-   * @constructor
-   */
-  function FlowChunk(flowObj, fileObj, offset) {
-
-    /**
-     * Reference to parent flow object
-     * @type {Flow}
-     */
-    this.flowObj = flowObj;
-
-    /**
-     * Reference to parent FlowFile object
-     * @type {FlowFile}
-     */
-    this.fileObj = fileObj;
-
-    /**
-     * File offset
-     * @type {number}
-     */
-    this.offset = offset;
-
-    /**
-     * Indicates if chunk existence was checked on the server
-     * @type {boolean}
-     */
-    this.tested = false;
-
-    /**
-     * Number of retries performed
-     * @type {number}
-     */
-    this.retries = 0;
-
-    /**
-     * Pending retry
-     * @type {boolean}
-     */
-    this.pendingRetry = false;
-
-    /**
-     * Preprocess state
-     * @type {number} 0 = unprocessed, 1 = processing, 2 = finished
-     */
-    this.preprocessState = 0;
-
-    /**
-     * Read state
-     * @type {number} 0 = not read, 1 = reading, 2 = finished
-     */
-    this.readState = 0;
-
-
-    /**
-     * Bytes transferred from total request size
-     * @type {number}
-     */
-    this.loaded = 0;
-
-    /**
-     * Total request size
-     * @type {number}
-     */
-    this.total = 0;
-
-    /**
-     * Size of a chunk
-     * @type {number}
-     */
-    this.chunkSize = this.fileObj.chunkSize;
-
-    /**
-     * Chunk start byte in a file
-     * @type {number}
-     */
-    this.startByte = this.offset * this.chunkSize;
-
-    /**
-     * A specific filename for this chunk which otherwise default to the main name
-     * @type {string}
-     */
-    this.filename = null;
-
-    /**
-      * Compute the endbyte in a file
-      *
-      */
-    this.computeEndByte = function() {
-      var endByte = Math.min(this.fileObj.size, (this.offset + 1) * this.chunkSize);
-      if (this.fileObj.size - endByte < this.chunkSize && !this.flowObj.opts.forceChunkSize) {
-        // The last chunk will be bigger than the chunk size,
-        // but less than 2 * this.chunkSize
-        endByte = this.fileObj.size;
-      }
-      return endByte;
-    }
-
-    /**
-     * Chunk end byte in a file
-     * @type {number}
-     */
-    this.endByte = this.computeEndByte();
-
-    /**
-     * XMLHttpRequest
-     * @type {XMLHttpRequest}
-     */
-    this.xhr = null;
-
-    var $ = this;
-
-    /**
-     * Send chunk event
-     * @param event
-     * @param {...} args arguments of a callback
-     */
-    this.event = function (event, args) {
-      args = Array.prototype.slice.call(arguments);
-      args.unshift($);
-      $.fileObj.chunkEvent.apply($.fileObj, args);
-    };
-    /**
-     * Catch progress event
-     * @param {ProgressEvent} event
-     */
-    this.progressHandler = function(event) {
-      if (event.lengthComputable) {
-        $.loaded = event.loaded ;
-        $.total = event.total;
-      }
-      $.event('progress', event);
-    };
-
-    /**
-     * Catch test event
-     * @param {Event} event
-     */
-    this.testHandler = function(event) {
-      var status = $.status(true);
-      if (status === 'error') {
-        $.event(status, $.message());
-        $.flowObj.uploadNextChunk();
-      } else if (status === 'success') {
-        $.tested = true;
-        $.event(status, $.message());
-        $.flowObj.uploadNextChunk();
-      } else if (!$.fileObj.paused) {
-        // Error might be caused by file pause method
-        // Chunks does not exist on the server side
-        $.tested = true;
-        $.send();
-      }
-    };
-
-    /**
-     * Upload has stopped
-     * @param {Event} event
-     */
-    this.doneHandler = function(event) {
-      var status = $.status();
-      if (status === 'success' || status === 'error') {
-        delete this.data;
-        $.event(status, $.message());
-        $.flowObj.uploadNextChunk();
-      } else if (!$.fileObj.paused) {
-        $.event('retry', $.message());
-        $.pendingRetry = true;
-        $.abort();
-        $.retries++;
-        var retryInterval = $.flowObj.opts.chunkRetryInterval;
-        if (retryInterval !== null) {
-          setTimeout(function () {
-            $.send();
-          }, retryInterval);
-        } else {
-          $.send();
-        }
-      }
-    };
-  }
-
-  FlowChunk.prototype = {
-    /**
-     * Get params for a request
-     * @function
-     */
-    getParams: function () {
-      return {
-        flowChunkNumber: this.offset + 1,
-        flowChunkSize: this.chunkSize,
-        flowCurrentChunkSize: this.endByte - this.startByte,
-        flowTotalSize: this.fileObj.size,
-        flowIdentifier: this.fileObj.uniqueIdentifier,
-        flowFilename: this.fileObj.name,
-        flowRelativePath: this.fileObj.relativePath,
-        flowTotalChunks: this.fileObj.chunks.length
-      };
-    },
-
-    /**
-     * Get target option with query params
-     * @function
-     * @param params
-     * @returns {string}
-     */
-    getTarget: function(target, params){
-      if (params.length == 0) {
-	return target;
-      }
-
-      if(target.indexOf('?') < 0) {
-        target += '?';
-      } else {
-        target += '&';
-      }
-      return target + params.join('&');
-    },
-
-    /**
-     * Makes a GET request without any data to see if the chunk has already
-     * been uploaded in a previous session
-     * @function
-     */
-    test: function () {
-      // Set up request and listen for event
-      this.xhr = new XMLHttpRequest();
-      this.xhr.addEventListener("load", this.testHandler, false);
-      this.xhr.addEventListener("error", this.testHandler, false);
-      var testMethod = evalOpts(this.flowObj.opts.testMethod, this.fileObj, this);
-      var data = this.prepareXhrRequest(testMethod, true);
-      this.xhr.send(data);
-    },
-
-    /**
-     * Finish preprocess state
-     * @function
-     */
-    preprocessFinished: function () {
-      // Re-compute the endByte after the preprocess function to allow an
-      // implementer of preprocess to set the fileObj size
-      this.endByte = this.computeEndByte();
-
-      this.preprocessState = 2;
-      this.send();
-    },
-
-    /**
-     * Finish read state
-     * @function
-     */
-    readFinished: function (bytes) {
-      this.readState = 2;
-      this.bytes = bytes;
-      this.send();
-    },
-
-
-    /**
-     * Uploads the actual data in a POST call
-     * @function
-     */
-    send: function () {
-      var preprocess = this.flowObj.opts.preprocess;
-      var read = this.flowObj.opts.readFileFn;
-      if (typeof preprocess === 'function') {
-        switch (this.preprocessState) {
-          case 0:
-            this.preprocessState = 1;
-            preprocess(this);
-            return;
-          case 1:
-            return;
-        }
-      }
-      switch (this.readState) {
-        case 0:
-          this.readState = 1;
-          read(this.fileObj, this.startByte, this.endByte, this.fileObj.file.type, this);
-          return;
-        case 1:
-          return;
-      }
-      if (this.flowObj.opts.testChunks && !this.tested) {
-        this.test();
-        return;
-      }
-
-      this.loaded = 0;
-      this.total = 0;
-      this.pendingRetry = false;
-
-      // Set up request and listen for event
-      this.xhr = new XMLHttpRequest();
-      this.xhr.upload.addEventListener('progress', this.progressHandler, false);
-      this.xhr.addEventListener("load", this.doneHandler, false);
-      this.xhr.addEventListener("error", this.doneHandler, false);
-
-      var uploadMethod = evalOpts(this.flowObj.opts.uploadMethod, this.fileObj, this);
-      var data = this.prepareXhrRequest(uploadMethod, false, this.flowObj.opts.method, this.bytes);
-      var changeRawDataBeforeSend = this.flowObj.opts.changeRawDataBeforeSend;
-      if (typeof changeRawDataBeforeSend === 'function') {
-        data = changeRawDataBeforeSend(this, data);
-      }
-      this.xhr.send(data);
-    },
-
-    /**
-     * Abort current xhr request
-     * @function
-     */
-    abort: function () {
-      // Abort and reset
-      var xhr = this.xhr;
-      this.xhr = null;
-      if (xhr) {
-        xhr.abort();
-      }
-    },
-
-    /**
-     * Retrieve current chunk upload status
-     * @function
-     * @returns {string} 'pending', 'uploading', 'success', 'error'
-     */
-    status: function (isTest) {
-      if (this.readState === 1) {
-        return 'reading';
-      } else if (this.pendingRetry || this.preprocessState === 1) {
-        // 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 (!this.xhr) {
-        return 'pending';
-      } else if (this.xhr.readyState < 4) {
-        // Status is really 'OPENED', 'HEADERS_RECEIVED'
-        // or 'LOADING' - meaning that stuff is happening
-        return 'uploading';
-      } else {
-        if (this.flowObj.opts.successStatuses.indexOf(this.xhr.status) > -1) {
-          // HTTP 200, perfect
-		      // HTTP 202 Accepted - The request has been accepted for processing, but the processing has not been completed.
-          return 'success';
-        } else if (this.flowObj.opts.permanentErrors.indexOf(this.xhr.status) > -1 ||
-            !isTest && this.retries >= this.flowObj.opts.maxChunkRetries) {
-          // HTTP 413/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
-          this.abort();
-          return 'pending';
-        }
-      }
-    },
-
-    /**
-     * Get response from xhr request
-     * @function
-     * @returns {String}
-     */
-    message: function () {
-      return this.xhr ? this.xhr.responseText : '';
-    },
-
-    /**
-     * Get upload progress
-     * @function
-     * @returns {number}
-     */
-    progress: function () {
-      if (this.pendingRetry) {
-        return 0;
-      }
-      var s = this.status();
-      if (s === 'success' || s === 'error') {
-        return 1;
-      } else if (s === 'pending') {
-        return 0;
-      } else {
-        return this.total > 0 ? this.loaded / this.total : 0;
-      }
-    },
-
-    /**
-     * Count total size uploaded
-     * @function
-     * @returns {number}
-     */
-    sizeUploaded: function () {
-      var size = this.endByte - this.startByte;
-      // can't return only chunk.loaded value, because it is bigger than chunk size
-      if (this.status() !== 'success') {
-        size = this.progress() * size;
-      }
-      return size;
-    },
-
-    /**
-     * Prepare Xhr request. Set query, headers and data
-     * @param {string} method GET or POST
-     * @param {bool} isTest is this a test request
-     * @param {string} [paramsMethod] octet or form
-     * @param {Blob} [blob] to send
-     * @returns {FormData|Blob|Null} data to send
-     */
-    prepareXhrRequest: function(method, isTest, paramsMethod, blob) {
-      // Add data from the query options
-      var query = evalOpts(this.flowObj.opts.query, this.fileObj, this, isTest);
-      query = extend(query || {}, this.getParams());
-
-      var target = evalOpts(this.flowObj.opts.target, this.fileObj, this, isTest);
-      var data = null;
-      if (method === 'GET' || paramsMethod === 'octet') {
-        // Add data from the query options
-        var params = [];
-        each(query, function (v, k) {
-          params.push([encodeURIComponent(k), encodeURIComponent(v)].join('='));
-        });
-        target = this.getTarget(target, params);
-        data = blob || null;
-      } else {
-        // Add data from the query options
-        data = new FormData();
-        each(query, function (v, k) {
-          data.append(k, v);
-        });
-        if (typeof blob !== "undefined") {
-            data.append(this.flowObj.opts.fileParameterName, blob, this.filename || this.fileObj.file.name);
-        }
-      }
-
-      this.xhr.open(method, target, true);
-      this.xhr.withCredentials = this.flowObj.opts.withCredentials;
-
-      // Add data from header options
-      each(evalOpts(this.flowObj.opts.headers, this.fileObj, this, isTest), function (v, k) {
-        this.xhr.setRequestHeader(k, v);
-      }, this);
-
-      return data;
-    }
-  };
-
-  /**
-   * Remove value from array
-   * @param array
-   * @param value
-   */
-  function arrayRemove(array, value) {
-    var index = array.indexOf(value);
-    if (index > -1) {
-      array.splice(index, 1);
-    }
-  }
-
-  /**
-   * If option is a function, evaluate it with given params
-   * @param {*} data
-   * @param {...} args arguments of a callback
-   * @returns {*}
-   */
-  function evalOpts(data, args) {
-    if (typeof data === "function") {
-      // `arguments` is an object, not array, in FF, so:
-      args = Array.prototype.slice.call(arguments);
-      data = data.apply(null, args.slice(1));
-    }
-    return data;
-  }
-  Flow.evalOpts = evalOpts;
-
-  /**
-   * Execute function asynchronously
-   * @param fn
-   * @param context
-   */
-  function async(fn, context) {
-    setTimeout(fn.bind(context), 0);
-  }
-
-  /**
-   * Extends the destination object `dst` by copying all of the properties from
-   * the `src` object(s) to `dst`. You can specify multiple `src` objects.
-   * @function
-   * @param {Object} dst Destination object.
-   * @param {...Object} src Source object(s).
-   * @returns {Object} Reference to `dst`.
-   */
-  function extend(dst, src) {
-    each(arguments, function(obj) {
-      if (obj !== dst) {
-        each(obj, function(value, key){
-          dst[key] = value;
-        });
-      }
-    });
-    return dst;
-  }
-  Flow.extend = extend;
-
-  /**
-   * Iterate each element of an object
-   * @function
-   * @param {Array|Object} obj object or an array to iterate
-   * @param {Function} callback first argument is a value and second is a key.
-   * @param {Object=} context Object to become context (`this`) for the iterator function.
-   */
-  function each(obj, callback, context) {
-    if (!obj) {
-      return ;
-    }
-    var key;
-    // Is Array?
-    // Array.isArray won't work, not only arrays can be iterated by index https://github.com/flowjs/ng-flow/issues/236#
-    if (typeof(obj.length) !== 'undefined') {
-      for (key = 0; key < obj.length; key++) {
-        if (callback.call(context, obj[key], key) === false) {
-          return ;
-        }
-      }
-    } else {
-      for (key in obj) {
-        if (obj.hasOwnProperty(key) && callback.call(context, obj[key], key) === false) {
-          return ;
-        }
-      }
-    }
-  }
-  Flow.each = each;
-
-  /**
-   * FlowFile constructor
-   * @type {FlowFile}
-   */
-  Flow.FlowFile = FlowFile;
-
-  /**
-   * FlowFile constructor
-   * @type {FlowChunk}
-   */
-  Flow.FlowChunk = FlowChunk;
-
-  /**
-   * Library version
-   * @type {string}
-   */
-  Flow.version = '<%= version %>';
-
-  if ( typeof module === "object" && module && typeof module.exports === "object" ) {
-    // Expose Flow as module.exports in loaders that implement the Node
-    // module pattern (including browserify). Do not create the global, since
-    // the user will be storing it themselves locally, and globals are frowned
-    // upon in the Node module world.
-    module.exports = Flow;
-  } else {
-    // Otherwise expose Flow to the global object as usual
-    window.Flow = Flow;
-
-    // Register as a named AMD module, since Flow can be concatenated with other
-    // files that may use define, but not via a proper concatenation script that
-    // understands anonymous AMD modules. A named AMD is safest and most robust
-    // way to register. Lowercase flow is used because AMD module names are
-    // derived from file names, and Flow is normally delivered in a lowercase
-    // file name. Do this after creating the global so that if an AMD module wants
-    // to call noConflict to hide this version of Flow, it will work.
-    if ( typeof define === "function" && define.amd ) {
-      define( "flow", [], function () { return Flow; } );
-    }
-  }
-})(typeof window !== 'undefined' && window, typeof document !== 'undefined' && document);
diff --git a/src/tools.js b/src/tools.js
new file mode 100644
index 00000000..9ce5ed30
--- /dev/null
+++ b/src/tools.js
@@ -0,0 +1,120 @@
+/**
+ * Default read function using the webAPI
+ *
+ * @function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk)
+ *
+ */
+function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk) {
+  var function_name = 'slice';
+
+  if (fileObj.file.slice)
+    function_name =  'slice';
+  else if (fileObj.file.mozSlice)
+    function_name = 'mozSlice';
+  else if (fileObj.file.webkitSlice)
+    function_name = 'webkitSlice';
+
+  chunk.readFinished(fileObj.file[function_name](startByte, endByte, fileType));
+}
+
+/**
+ * Remove value from array
+ * @param array
+ * @param value
+ */
+function arrayRemove(array, value) {
+  var index = array.indexOf(value);
+  if (index > -1) {
+    array.splice(index, 1);
+  }
+}
+
+/**
+ * If option is a function, evaluate it with given params
+ * @param {*} data
+ * @param {...} args arguments of a callback
+ * @returns {*}
+ */
+function evalOpts(data, args) {
+  if (typeof data === "function") {
+    // `arguments` is an object, not array, in FF, so:
+    args = Array.prototype.slice.call(arguments);
+    data = data.apply(null, args.slice(1));
+  }
+  return data;
+}
+
+/**
+ * Execute function asynchronously
+ * @param fn
+ * @param context
+ */
+function async(fn, context) {
+  setTimeout(fn.bind(context), 0);
+}
+
+/**
+ * Extends the destination object `dst` by copying all of the properties from
+ * the `src` object(s) to `dst`. You can specify multiple `src` objects.
+ * @function
+ * @param {Object} dst Destination object.
+ * @param {...Object} src Source object(s).
+ * @returns {Object} Reference to `dst`.
+ */
+function extend(dst, src) {
+  each(arguments, function(obj) {
+    if (obj !== dst) {
+      each(obj, function(value, key){
+        dst[key] = value;
+      });
+    }
+  });
+  return dst;
+}
+
+/**
+ * Iterate each element of an object
+ * @function
+ * @param {Array|Object} obj object or an array to iterate
+ * @param {Function} callback first argument is a value and second is a key.
+ * @param {Object=} context Object to become context (`this`) for the iterator function.
+ */
+function each(obj, callback, context) {
+  if (!obj) {
+    return ;
+  }
+  var key;
+  // Is Array?
+  // Array.isArray won't work, not only arrays can be iterated by index https://github.com/flowjs/ng-flow/issues/236#
+  if (typeof(obj.length) !== 'undefined') {
+    for (key = 0; key < obj.length; key++) {
+      if (callback.call(context, obj[key], key) === false) {
+        return ;
+      }
+    }
+  } else {
+    for (key in obj) {
+      if (obj.hasOwnProperty(key) && callback.call(context, obj[key], key) === false) {
+        return ;
+      }
+    }
+  }
+}
+
+/**
+ * Exclusively for test purposes
+ * (Until Grunt+Karma+Jasmine can allow test to use (ES) `import` of tools.js)
+ */
+var g = typeof window !== 'undefined' ? window
+    : typeof global !== 'undefined' ? global
+    : typeof self !== 'undefined' ? self : {};
+g.evalOpts = evalOpts;
+
+export {
+  arrayRemove,
+  async,
+  each,
+  evalOpts,
+  extend,
+  webAPIFileRead
+};
diff --git a/test/evalOptsSpec.js b/test/evalOptsSpec.js
index 7593ddfc..aff0f844 100644
--- a/test/evalOptsSpec.js
+++ b/test/evalOptsSpec.js
@@ -1,17 +1,19 @@
+// import evalOpts from '/test/../src/tools';
+
 describe('evalOpts', function () {
 
   it('should return same object for non functions', function() {
     var obj = {};
-    expect(Flow.evalOpts(obj)).toBe(obj);
+    expect(evalOpts(obj)).toBe(obj);
   });
   it('should return same type for non functions', function() {
-    expect(Flow.evalOpts(5)).toBe(5);
+    expect(evalOpts(5)).toBe(5);
   });
   it('should evaluate function', function() {
-    expect(Flow.evalOpts(function () {return 5;})).toBe(5);
+    expect(evalOpts(function () {return 5;})).toBe(5);
   });
   it('should evaluate function with given arguments', function() {
     var obj = {};
-    expect(Flow.evalOpts(function (a) {return a;}, obj)).toBe(obj);
+    expect(evalOpts(function (a) {return a;}, obj)).toBe(obj);
   });
-});
\ No newline at end of file
+});
diff --git a/test/fileSpec.js b/test/fileSpec.js
index 190c031a..fedfea14 100644
--- a/test/fileSpec.js
+++ b/test/fileSpec.js
@@ -12,7 +12,7 @@ describe('FlowFile functions', function() {
   beforeEach(function () {
     flow = new Flow({
     });
-    file = new Flow.FlowFile(flow, {
+    file = new FlowFile(flow, {
       name: 'image.jpg',
       type: 'image/png'
     });
diff --git a/test/setupSpec.js b/test/setupSpec.js
index bf4040d6..24b15727 100644
--- a/test/setupSpec.js
+++ b/test/setupSpec.js
@@ -12,10 +12,6 @@ describe('setup', function() {
     });
   });
 
-  it('should be supported', function() {
-    expect(flow.support).toBeTruthy();
-  });
-
   it('files should be empty', function() {
     expect(flow.files).toBeDefined();
     expect(flow.files.length).toBe(0);
@@ -103,20 +99,19 @@ describe('setup', function() {
 
   describe('assignDrop', function() {
     it('assign to div', function() {
-      var div = document.createElement('div');
-      var onDrop = jasmine.createSpy('onDrop');
-      flow.onDrop = onDrop;
-      flow.assignDrop(div);
-      var event = document.createEvent('MouseEvents');
+      var div = document.createElement('div'),
+          event = document.createEvent('MouseEvents');
       event.initEvent('drop', true, true);
       event.dataTransfer = {files: []};
+
+      spyOn(flow, 'onDrop').and.callThrough();
+      flow.assignDrop(div);
       div.dispatchEvent(event);
-      expect(onDrop).toHaveBeenCalled();
-      expect(onDrop.calls.count()).toBe(1);
+      expect(flow.onDrop).toHaveBeenCalledTimes(1);
 
       flow.unAssignDrop(div);
       div.dispatchEvent(event);
-      expect(onDrop.calls.count()).toBe(1);
+      expect(flow.onDrop).toHaveBeenCalledTimes(1);
     });
   });