{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/@flowjs/flow.js/src/flow.js","webpack:///./vendor/assets/libs/flow-js/flow.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","webpackPolyfill","deprecate","paths","children","_typeof","iterator","obj","constructor","window","document","undefined","ie10plus","navigator","msPointerEnabled","Flow","on","event","callback","toLowerCase","this","events","push","off","fn","array","index","indexOf","splice","fire","args","Array","slice","arguments","preventDefault","each","apply","unshift","webkitReadDataTransfer","$","queue","dataTransfer","items","length","files","fileReadSuccess","file","fullPath","relativePath","substring","decrement","readError","fileError","addFiles","item","entry","webkitGetAsEntry","isFile","getAsFile","readDirectory","reader","readEntries","entries","isDirectory","createReader","generateUniqueIdentifier","custom","opts","webkitRelativePath","fileName","size","replace","uploadNextChunk","preventEvents","found","prioritizeFirstAndLastChunk","paused","chunks","status","send","chunk","outstanding","isComplete","async","assignBrowse","domNodes","singleFile","attributes","Element","domNode","input","tagName","type","createElement","setAttribute","extend","style","visibility","position","width","height","appendChild","addEventListener","click","e","target","assignDrop","preventEvent","onDrop","unAssignDrop","removeEventListener","isUploading","uploading","_shouldUploadNext","num","should","simultaneousUploads","upload","ret","started","resume","pause","cancel","progress","totalDone","totalSize","addFile","fileList","uniqueIdentifier","allowDuplicateUploads","getFromUniqueIdentifier","f","FlowFile","removeFile","abort","getSize","sizeUploaded","timeRemaining","sizeDelta","averageSpeed","error","Number","POSITIVE_INFINITY","Math","floor","measureSpeed","timeSpan","Date","now","_lastProgressCallback","smoothingFactor","flowObj","speedSmoothingFactor","uploaded","currentSpeed","max","_prevUploadedSize","chunkEvent","message","progressCallbacksInterval","reset","retry","bootstrap","initFileFn","_prevProgress","round","forceChunkSize","ceil","chunkSize","evalOpts","offset","FlowChunk","bytesLoaded","endByte","startByte","percent","preprocessState","readState","delta","getType","split","getExtension","substr","lastIndexOf","getParams","flowChunkNumber","flowChunkSize","flowCurrentChunkSize","flowTotalSize","fileObj","flowIdentifier","flowFilename","flowRelativePath","flowTotalChunks","getTarget","params","join","test","xhr","XMLHttpRequest","testHandler","testMethod","data","prepareXhrRequest","preprocessFinished","computeEndByte","readFinished","bytes","preprocess","read","readFileFn","testChunks","tested","loaded","total","pendingRetry","progressHandler","doneHandler","uploadMethod","method","changeRawDataBeforeSend","isTest","readyState","successStatuses","permanentErrors","retries","maxChunkRetries","responseText","paramsMethod","blob","query","v","k","encodeURIComponent","FormData","append","fileParameterName","open","withCredentials","headers","setRequestHeader","version","console","warn","support","File","Blob","FileList","webkitSlice","mozSlice","supportDirectory","userAgent","defaults","chunkRetryInterval","onDropStopPropagation","webAPIFileRead","stopPropagation","fileType","function_name","min","lengthComputable","retryInterval","setTimeout","context","dst","src"],"mappings":"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","file":"js/vendor/libs/flow-js/flow-7eafa736820b55146548.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"https://optimal.seneris.com/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 834);\n","module.exports = function (module) {\n  if (!module.webpackPolyfill) {\n    module.deprecate = function () {};\n\n    module.paths = []; // module.parent = undefined by default\n\n    if (!module.children) module.children = [];\n    Object.defineProperty(module, \"loaded\", {\n      enumerable: true,\n      get: function get() {\n        return module.l;\n      }\n    });\n    Object.defineProperty(module, \"id\", {\n      enumerable: true,\n      get: function get() {\n        return module.i;\n      }\n    });\n    module.webpackPolyfill = 1;\n  }\n\n  return module;\n};","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/**\n * @license MIT\n */\n(function (window, document, undefined) {\n  'use strict';\n\n  if (!window || !document) {\n    console.warn('Flowjs needs window and document objects to work');\n    return;\n  } // ie10+\n\n\n  var ie10plus = window.navigator.msPointerEnabled;\n  /**\n   * Flow.js is a library providing multiple simultaneous, stable and\n   * resumable uploads via the HTML5 File API.\n   * @param [opts]\n   * @param {number|Function} [opts.chunkSize]\n   * @param {bool} [opts.forceChunkSize]\n   * @param {number} [opts.simultaneousUploads]\n   * @param {bool} [opts.singleFile]\n   * @param {string} [opts.fileParameterName]\n   * @param {number} [opts.progressCallbacksInterval]\n   * @param {number} [opts.speedSmoothingFactor]\n   * @param {Object|Function} [opts.query]\n   * @param {Object|Function} [opts.headers]\n   * @param {bool} [opts.withCredentials]\n   * @param {Function} [opts.preprocess]\n   * @param {string} [opts.method]\n   * @param {string|Function} [opts.testMethod]\n   * @param {string|Function} [opts.uploadMethod]\n   * @param {bool} [opts.prioritizeFirstAndLastChunk]\n   * @param {bool} [opts.allowDuplicateUploads]\n   * @param {string|Function} [opts.target]\n   * @param {number} [opts.maxChunkRetries]\n   * @param {number} [opts.chunkRetryInterval]\n   * @param {Array.<number>} [opts.permanentErrors]\n   * @param {Array.<number>} [opts.successStatuses]\n   * @param {Function} [opts.initFileFn]\n   * @param {Function} [opts.readFileFn]\n   * @param {Function} [opts.generateUniqueIdentifier]\n   * @constructor\n   */\n\n  function Flow(opts) {\n    /**\n     * Supported by browser?\n     * @type {boolean}\n     */\n    this.support = typeof File !== 'undefined' && typeof Blob !== 'undefined' && typeof FileList !== 'undefined' && (!!Blob.prototype.slice || !!Blob.prototype.webkitSlice || !!Blob.prototype.mozSlice || false) // slicing files support\n    ;\n\n    if (!this.support) {\n      return;\n    }\n    /**\n     * Check if directory upload is supported\n     * @type {boolean}\n     */\n\n\n    this.supportDirectory = /Chrome/.test(window.navigator.userAgent) || /Firefox/.test(window.navigator.userAgent) || /Edge/.test(window.navigator.userAgent);\n    /**\n     * List of FlowFile objects\n     * @type {Array.<FlowFile>}\n     */\n\n    this.files = [];\n    /**\n     * Default options for flow.js\n     * @type {Object}\n     */\n\n    this.defaults = {\n      chunkSize: 1024 * 1024,\n      forceChunkSize: false,\n      simultaneousUploads: 3,\n      singleFile: false,\n      fileParameterName: 'file',\n      progressCallbacksInterval: 500,\n      speedSmoothingFactor: 0.1,\n      query: {},\n      headers: {},\n      withCredentials: false,\n      preprocess: null,\n      changeRawDataBeforeSend: null,\n      method: 'multipart',\n      testMethod: 'GET',\n      uploadMethod: 'POST',\n      prioritizeFirstAndLastChunk: false,\n      allowDuplicateUploads: false,\n      target: '/',\n      testChunks: true,\n      generateUniqueIdentifier: null,\n      maxChunkRetries: 0,\n      chunkRetryInterval: null,\n      permanentErrors: [404, 413, 415, 500, 501],\n      successStatuses: [200, 201, 202],\n      onDropStopPropagation: false,\n      initFileFn: null,\n      readFileFn: webAPIFileRead\n    };\n    /**\n     * Current options\n     * @type {Object}\n     */\n\n    this.opts = {};\n    /**\n     * List of events:\n     *  key stands for event name\n     *  value array list of callbacks\n     * @type {}\n     */\n\n    this.events = {};\n    var $ = this;\n    /**\n     * On drop event\n     * @function\n     * @param {MouseEvent} event\n     */\n\n    this.onDrop = function (event) {\n      if ($.opts.onDropStopPropagation) {\n        event.stopPropagation();\n      }\n\n      event.preventDefault();\n      var dataTransfer = event.dataTransfer;\n\n      if (dataTransfer.items && dataTransfer.items[0] && dataTransfer.items[0].webkitGetAsEntry) {\n        $.webkitReadDataTransfer(event);\n      } else {\n        $.addFiles(dataTransfer.files, event);\n      }\n    };\n    /**\n     * Prevent default\n     * @function\n     * @param {MouseEvent} event\n     */\n\n\n    this.preventEvent = function (event) {\n      event.preventDefault();\n    };\n    /**\n     * Current options\n     * @type {Object}\n     */\n\n\n    this.opts = Flow.extend({}, this.defaults, opts || {});\n  }\n\n  Flow.prototype = {\n    /**\n     * Set a callback for an event, possible events:\n     * fileSuccess(file), fileProgress(file), fileAdded(file, event),\n     * fileRemoved(file), fileRetry(file), fileError(file, message),\n     * complete(), progress(), error(message, file), pause()\n     * @function\n     * @param {string} event\n     * @param {Function} callback\n     */\n    on: function on(event, callback) {\n      event = event.toLowerCase();\n\n      if (!this.events.hasOwnProperty(event)) {\n        this.events[event] = [];\n      }\n\n      this.events[event].push(callback);\n    },\n\n    /**\n     * Remove event callback\n     * @function\n     * @param {string} [event] removes all events if not specified\n     * @param {Function} [fn] removes all callbacks of event if not specified\n     */\n    off: function off(event, fn) {\n      if (event !== undefined) {\n        event = event.toLowerCase();\n\n        if (fn !== undefined) {\n          if (this.events.hasOwnProperty(event)) {\n            arrayRemove(this.events[event], fn);\n          }\n        } else {\n          delete this.events[event];\n        }\n      } else {\n        this.events = {};\n      }\n    },\n\n    /**\n     * Fire an event\n     * @function\n     * @param {string} event event name\n     * @param {...} args arguments of a callback\n     * @return {bool} value is false if at least one of the event handlers which handled this event\n     * returned false. Otherwise it returns true.\n     */\n    fire: function fire(event, args) {\n      // `arguments` is an object, not array, in FF, so:\n      args = Array.prototype.slice.call(arguments);\n      event = event.toLowerCase();\n      var preventDefault = false;\n\n      if (this.events.hasOwnProperty(event)) {\n        each(this.events[event], function (callback) {\n          preventDefault = callback.apply(this, args.slice(1)) === false || preventDefault;\n        }, this);\n      }\n\n      if (event != 'catchall') {\n        args.unshift('catchAll');\n        preventDefault = this.fire.apply(this, args) === false || preventDefault;\n      }\n\n      return !preventDefault;\n    },\n\n    /**\n     * Read webkit dataTransfer object\n     * @param event\n     */\n    webkitReadDataTransfer: function webkitReadDataTransfer(event) {\n      var $ = this;\n      var queue = event.dataTransfer.items.length;\n      var files = [];\n      each(event.dataTransfer.items, function (item) {\n        var entry = item.webkitGetAsEntry();\n\n        if (!entry) {\n          decrement();\n          return;\n        }\n\n        if (entry.isFile) {\n          // due to a bug in Chrome's File System API impl - #149735\n          fileReadSuccess(item.getAsFile(), entry.fullPath);\n        } else {\n          readDirectory(entry.createReader());\n        }\n      });\n\n      function readDirectory(reader) {\n        reader.readEntries(function (entries) {\n          if (entries.length) {\n            queue += entries.length;\n            each(entries, function (entry) {\n              if (entry.isFile) {\n                var fullPath = entry.fullPath;\n                entry.file(function (file) {\n                  fileReadSuccess(file, fullPath);\n                }, readError);\n              } else if (entry.isDirectory) {\n                readDirectory(entry.createReader());\n              }\n            });\n            readDirectory(reader);\n          } else {\n            decrement();\n          }\n        }, readError);\n      }\n\n      function fileReadSuccess(file, fullPath) {\n        // relative path should not start with \"/\"\n        file.relativePath = fullPath.substring(1);\n        files.push(file);\n        decrement();\n      }\n\n      function readError(fileError) {\n        throw fileError;\n      }\n\n      function decrement() {\n        if (--queue == 0) {\n          $.addFiles(files, event);\n        }\n      }\n    },\n\n    /**\n     * Generate unique identifier for a file\n     * @function\n     * @param {FlowFile} file\n     * @returns {string}\n     */\n    generateUniqueIdentifier: function generateUniqueIdentifier(file) {\n      var custom = this.opts.generateUniqueIdentifier;\n\n      if (typeof custom === 'function') {\n        return custom(file);\n      } // Some confusion in different versions of Firefox\n\n\n      var relativePath = file.relativePath || file.webkitRelativePath || file.fileName || file.name;\n      return file.size + '-' + relativePath.replace(/[^0-9a-zA-Z_-]/img, '');\n    },\n\n    /**\n     * Upload next chunk from the queue\n     * @function\n     * @returns {boolean}\n     * @private\n     */\n    uploadNextChunk: function uploadNextChunk(preventEvents) {\n      // In some cases (such as videos) it's really handy to upload the first\n      // and last chunk of a file quickly; this let's the server check the file's\n      // metadata and determine if there's even a point in continuing.\n      var found = false;\n\n      if (this.opts.prioritizeFirstAndLastChunk) {\n        each(this.files, function (file) {\n          if (!file.paused && file.chunks.length && file.chunks[0].status() === 'pending') {\n            file.chunks[0].send();\n            found = true;\n            return false;\n          }\n\n          if (!file.paused && file.chunks.length > 1 && file.chunks[file.chunks.length - 1].status() === 'pending') {\n            file.chunks[file.chunks.length - 1].send();\n            found = true;\n            return false;\n          }\n        });\n\n        if (found) {\n          return found;\n        }\n      } // Now, simply look for the next, best thing to upload\n\n\n      each(this.files, function (file) {\n        if (!file.paused) {\n          each(file.chunks, function (chunk) {\n            if (chunk.status() === 'pending') {\n              chunk.send();\n              found = true;\n              return false;\n            }\n          });\n        }\n\n        if (found) {\n          return false;\n        }\n      });\n\n      if (found) {\n        return true;\n      } // The are no more outstanding chunks to upload, check is everything is done\n\n\n      var outstanding = false;\n      each(this.files, function (file) {\n        if (!file.isComplete()) {\n          outstanding = true;\n          return false;\n        }\n      });\n\n      if (!outstanding && !preventEvents) {\n        // All chunks have been uploaded, complete\n        async(function () {\n          this.fire('complete');\n        }, this);\n      }\n\n      return false;\n    },\n\n    /**\n     * Assign a browse action to one or more DOM nodes.\n     * @function\n     * @param {Element|Array.<Element>} domNodes\n     * @param {boolean} isDirectory Pass in true to allow directories to\n     * @param {boolean} singleFile prevent multi file upload\n     * @param {Object} attributes set custom attributes:\n     *  http://www.w3.org/TR/html-markup/input.file.html#input.file-attributes\n     *  eg: accept: 'image/*'\n     * be selected (Chrome only).\n     */\n    assignBrowse: function assignBrowse(domNodes, isDirectory, singleFile, attributes) {\n      if (domNodes instanceof Element) {\n        domNodes = [domNodes];\n      }\n\n      each(domNodes, function (domNode) {\n        var input;\n\n        if (domNode.tagName === 'INPUT' && domNode.type === 'file') {\n          input = domNode;\n        } else {\n          input = document.createElement('input');\n          input.setAttribute('type', 'file'); // display:none - not working in opera 12\n\n          extend(input.style, {\n            visibility: 'hidden',\n            position: 'absolute',\n            width: '1px',\n            height: '1px'\n          }); // for opera 12 browser, input must be assigned to a document\n\n          domNode.appendChild(input); // https://developer.mozilla.org/en/using_files_from_web_applications)\n          // event listener is executed two times\n          // first one - original mouse click event\n          // second - input.click(), input is inside domNode\n\n          domNode.addEventListener('click', function () {\n            input.click();\n          }, false);\n        }\n\n        if (!this.opts.singleFile && !singleFile) {\n          input.setAttribute('multiple', 'multiple');\n        }\n\n        if (isDirectory) {\n          input.setAttribute('webkitdirectory', 'webkitdirectory');\n        }\n\n        each(attributes, function (value, key) {\n          input.setAttribute(key, value);\n        }); // When new files are added, simply append them to the overall list\n\n        var $ = this;\n        input.addEventListener('change', function (e) {\n          if (e.target.value) {\n            $.addFiles(e.target.files, e);\n            e.target.value = '';\n          }\n        }, false);\n      }, this);\n    },\n\n    /**\n     * Assign one or more DOM nodes as a drop target.\n     * @function\n     * @param {Element|Array.<Element>} domNodes\n     */\n    assignDrop: function assignDrop(domNodes) {\n      if (typeof domNodes.length === 'undefined') {\n        domNodes = [domNodes];\n      }\n\n      each(domNodes, function (domNode) {\n        domNode.addEventListener('dragover', this.preventEvent, false);\n        domNode.addEventListener('dragenter', this.preventEvent, false);\n        domNode.addEventListener('drop', this.onDrop, false);\n      }, this);\n    },\n\n    /**\n     * Un-assign drop event from DOM nodes\n     * @function\n     * @param domNodes\n     */\n    unAssignDrop: function unAssignDrop(domNodes) {\n      if (typeof domNodes.length === 'undefined') {\n        domNodes = [domNodes];\n      }\n\n      each(domNodes, function (domNode) {\n        domNode.removeEventListener('dragover', this.preventEvent);\n        domNode.removeEventListener('dragenter', this.preventEvent);\n        domNode.removeEventListener('drop', this.onDrop);\n      }, this);\n    },\n\n    /**\n     * Returns a boolean indicating whether or not the instance is currently\n     * uploading anything.\n     * @function\n     * @returns {boolean}\n     */\n    isUploading: function isUploading() {\n      var uploading = false;\n      each(this.files, function (file) {\n        if (file.isUploading()) {\n          uploading = true;\n          return false;\n        }\n      });\n      return uploading;\n    },\n\n    /**\n     * should upload next chunk\n     * @function\n     * @returns {boolean|number}\n     */\n    _shouldUploadNext: function _shouldUploadNext() {\n      var num = 0;\n      var should = true;\n      var simultaneousUploads = this.opts.simultaneousUploads;\n      each(this.files, function (file) {\n        each(file.chunks, function (chunk) {\n          if (chunk.status() === 'uploading') {\n            num++;\n\n            if (num >= simultaneousUploads) {\n              should = false;\n              return false;\n            }\n          }\n        });\n      }); // if should is true then return uploading chunks's length\n\n      return should && num;\n    },\n\n    /**\n     * Start or resume uploading.\n     * @function\n     */\n    upload: function upload() {\n      // Make sure we don't start too many uploads at once\n      var ret = this._shouldUploadNext();\n\n      if (ret === false) {\n        return;\n      } // Kick off the queue\n\n\n      this.fire('uploadStart');\n      var started = false;\n\n      for (var num = 1; num <= this.opts.simultaneousUploads - ret; num++) {\n        started = this.uploadNextChunk(true) || started;\n      }\n\n      if (!started) {\n        async(function () {\n          this.fire('complete');\n        }, this);\n      }\n    },\n\n    /**\n     * Resume uploading.\n     * @function\n     */\n    resume: function resume() {\n      each(this.files, function (file) {\n        if (!file.isComplete()) {\n          file.resume();\n        }\n      });\n    },\n\n    /**\n     * Pause uploading.\n     * @function\n     */\n    pause: function pause() {\n      each(this.files, function (file) {\n        file.pause();\n      });\n    },\n\n    /**\n     * Cancel upload of all FlowFile objects and remove them from the list.\n     * @function\n     */\n    cancel: function cancel() {\n      for (var i = this.files.length - 1; i >= 0; i--) {\n        this.files[i].cancel();\n      }\n    },\n\n    /**\n     * Returns a number between 0 and 1 indicating the current upload progress\n     * of all files.\n     * @function\n     * @returns {number}\n     */\n    progress: function progress() {\n      var totalDone = 0;\n      var totalSize = 0; // Resume all chunks currently being uploaded\n\n      each(this.files, function (file) {\n        totalDone += file.progress() * file.size;\n        totalSize += file.size;\n      });\n      return totalSize > 0 ? totalDone / totalSize : 0;\n    },\n\n    /**\n     * Add a HTML5 File object to the list of files.\n     * @function\n     * @param {File} file\n     * @param {Event} [event] event is optional\n     */\n    addFile: function addFile(file, event) {\n      this.addFiles([file], event);\n    },\n\n    /**\n     * Add a HTML5 File object to the list of files.\n     * @function\n     * @param {FileList|Array} fileList\n     * @param {Event} [event] event is optional\n     */\n    addFiles: function addFiles(fileList, event) {\n      var files = [];\n      each(fileList, function (file) {\n        // https://github.com/flowjs/flow.js/issues/55\n        if ((!ie10plus || ie10plus && file.size > 0) && !(file.size % 4096 === 0 && (file.name === '.' || file.fileName === '.'))) {\n          var uniqueIdentifier = this.generateUniqueIdentifier(file);\n\n          if (this.opts.allowDuplicateUploads || !this.getFromUniqueIdentifier(uniqueIdentifier)) {\n            var f = new FlowFile(this, file, uniqueIdentifier);\n\n            if (this.fire('fileAdded', f, event)) {\n              files.push(f);\n            }\n          }\n        }\n      }, this);\n\n      if (this.fire('filesAdded', files, event)) {\n        each(files, function (file) {\n          if (this.opts.singleFile && this.files.length > 0) {\n            this.removeFile(this.files[0]);\n          }\n\n          this.files.push(file);\n        }, this);\n        this.fire('filesSubmitted', files, event);\n      }\n    },\n\n    /**\n     * Cancel upload of a specific FlowFile object from the list.\n     * @function\n     * @param {FlowFile} file\n     */\n    removeFile: function removeFile(file) {\n      for (var i = this.files.length - 1; i >= 0; i--) {\n        if (this.files[i] === file) {\n          this.files.splice(i, 1);\n          file.abort();\n          this.fire('fileRemoved', file);\n        }\n      }\n    },\n\n    /**\n     * Look up a FlowFile object by its unique identifier.\n     * @function\n     * @param {string} uniqueIdentifier\n     * @returns {boolean|FlowFile} false if file was not found\n     */\n    getFromUniqueIdentifier: function getFromUniqueIdentifier(uniqueIdentifier) {\n      var ret = false;\n      each(this.files, function (file) {\n        if (file.uniqueIdentifier === uniqueIdentifier) {\n          ret = file;\n        }\n      });\n      return ret;\n    },\n\n    /**\n     * Returns the total size of all files in bytes.\n     * @function\n     * @returns {number}\n     */\n    getSize: function getSize() {\n      var totalSize = 0;\n      each(this.files, function (file) {\n        totalSize += file.size;\n      });\n      return totalSize;\n    },\n\n    /**\n     * Returns the total size uploaded of all files in bytes.\n     * @function\n     * @returns {number}\n     */\n    sizeUploaded: function sizeUploaded() {\n      var size = 0;\n      each(this.files, function (file) {\n        size += file.sizeUploaded();\n      });\n      return size;\n    },\n\n    /**\n     * Returns remaining time to upload all files in seconds. Accuracy is based on average speed.\n     * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`\n     * @function\n     * @returns {number}\n     */\n    timeRemaining: function timeRemaining() {\n      var sizeDelta = 0;\n      var averageSpeed = 0;\n      each(this.files, function (file) {\n        if (!file.paused && !file.error) {\n          sizeDelta += file.size - file.sizeUploaded();\n          averageSpeed += file.averageSpeed;\n        }\n      });\n\n      if (sizeDelta && !averageSpeed) {\n        return Number.POSITIVE_INFINITY;\n      }\n\n      if (!sizeDelta && !averageSpeed) {\n        return 0;\n      }\n\n      return Math.floor(sizeDelta / averageSpeed);\n    }\n  };\n  /**\n   * FlowFile class\n   * @name FlowFile\n   * @param {Flow} flowObj\n   * @param {File} file\n   * @param {string} uniqueIdentifier\n   * @constructor\n   */\n\n  function FlowFile(flowObj, file, uniqueIdentifier) {\n    /**\n     * Reference to parent Flow instance\n     * @type {Flow}\n     */\n    this.flowObj = flowObj;\n    /**\n     * Used to store the bytes read\n     * @type {Blob|string}\n     */\n\n    this.bytes = null;\n    /**\n     * Reference to file\n     * @type {File}\n     */\n\n    this.file = file;\n    /**\n     * File name. Some confusion in different versions of Firefox\n     * @type {string}\n     */\n\n    this.name = file.fileName || file.name;\n    /**\n     * File size\n     * @type {number}\n     */\n\n    this.size = file.size;\n    /**\n     * Relative file path\n     * @type {string}\n     */\n\n    this.relativePath = file.relativePath || file.webkitRelativePath || this.name;\n    /**\n     * File unique identifier\n     * @type {string}\n     */\n\n    this.uniqueIdentifier = uniqueIdentifier === undefined ? flowObj.generateUniqueIdentifier(file) : uniqueIdentifier;\n    /**\n     * Size of Each Chunk\n     * @type {number}\n     */\n\n    this.chunkSize = 0;\n    /**\n     * List of chunks\n     * @type {Array.<FlowChunk>}\n     */\n\n    this.chunks = [];\n    /**\n     * Indicated if file is paused\n     * @type {boolean}\n     */\n\n    this.paused = false;\n    /**\n     * Indicated if file has encountered an error\n     * @type {boolean}\n     */\n\n    this.error = false;\n    /**\n     * Average upload speed\n     * @type {number}\n     */\n\n    this.averageSpeed = 0;\n    /**\n     * Current upload speed\n     * @type {number}\n     */\n\n    this.currentSpeed = 0;\n    /**\n     * Date then progress was called last time\n     * @type {number}\n     * @private\n     */\n\n    this._lastProgressCallback = Date.now();\n    /**\n     * Previously uploaded file size\n     * @type {number}\n     * @private\n     */\n\n    this._prevUploadedSize = 0;\n    /**\n     * Holds previous progress\n     * @type {number}\n     * @private\n     */\n\n    this._prevProgress = 0;\n    this.bootstrap();\n  }\n\n  FlowFile.prototype = {\n    /**\n     * Update speed parameters\n     * @link http://stackoverflow.com/questions/2779600/how-to-estimate-download-time-remaining-accurately\n     * @function\n     */\n    measureSpeed: function measureSpeed() {\n      var timeSpan = Date.now() - this._lastProgressCallback;\n\n      if (!timeSpan) {\n        return;\n      }\n\n      var smoothingFactor = this.flowObj.opts.speedSmoothingFactor;\n      var uploaded = this.sizeUploaded(); // Prevent negative upload speed after file upload resume\n\n      this.currentSpeed = Math.max((uploaded - this._prevUploadedSize) / timeSpan * 1000, 0);\n      this.averageSpeed = smoothingFactor * this.currentSpeed + (1 - smoothingFactor) * this.averageSpeed;\n      this._prevUploadedSize = uploaded;\n    },\n\n    /**\n     * For internal usage only.\n     * Callback when something happens within the chunk.\n     * @function\n     * @param {FlowChunk} chunk\n     * @param {string} event can be 'progress', 'success', 'error' or 'retry'\n     * @param {string} [message]\n     */\n    chunkEvent: function chunkEvent(chunk, event, message) {\n      switch (event) {\n        case 'progress':\n          if (Date.now() - this._lastProgressCallback < this.flowObj.opts.progressCallbacksInterval) {\n            break;\n          }\n\n          this.measureSpeed();\n          this.flowObj.fire('fileProgress', this, chunk);\n          this.flowObj.fire('progress');\n          this._lastProgressCallback = Date.now();\n          break;\n\n        case 'error':\n          this.error = true;\n          this.abort(true);\n          this.flowObj.fire('fileError', this, message, chunk);\n          this.flowObj.fire('error', message, this, chunk);\n          break;\n\n        case 'success':\n          if (this.error) {\n            return;\n          }\n\n          this.measureSpeed();\n          this.flowObj.fire('fileProgress', this, chunk);\n          this.flowObj.fire('progress');\n          this._lastProgressCallback = Date.now();\n\n          if (this.isComplete()) {\n            this.currentSpeed = 0;\n            this.averageSpeed = 0;\n            this.flowObj.fire('fileSuccess', this, message, chunk);\n          }\n\n          break;\n\n        case 'retry':\n          this.flowObj.fire('fileRetry', this, chunk);\n          break;\n      }\n    },\n\n    /**\n     * Pause file upload\n     * @function\n     */\n    pause: function pause() {\n      this.paused = true;\n      this.abort();\n    },\n\n    /**\n     * Resume file upload\n     * @function\n     */\n    resume: function resume() {\n      this.paused = false;\n      this.flowObj.upload();\n    },\n\n    /**\n     * Abort current upload\n     * @function\n     */\n    abort: function abort(reset) {\n      this.currentSpeed = 0;\n      this.averageSpeed = 0;\n      var chunks = this.chunks;\n\n      if (reset) {\n        this.chunks = [];\n      }\n\n      each(chunks, function (c) {\n        if (c.status() === 'uploading') {\n          c.abort();\n          this.flowObj.uploadNextChunk();\n        }\n      }, this);\n    },\n\n    /**\n     * Cancel current upload and remove from a list\n     * @function\n     */\n    cancel: function cancel() {\n      this.flowObj.removeFile(this);\n    },\n\n    /**\n     * Retry aborted file upload\n     * @function\n     */\n    retry: function retry() {\n      this.bootstrap();\n      this.flowObj.upload();\n    },\n\n    /**\n     * Clear current chunks and slice file again\n     * @function\n     */\n    bootstrap: function bootstrap() {\n      if (typeof this.flowObj.opts.initFileFn === \"function\") {\n        this.flowObj.opts.initFileFn(this);\n      }\n\n      this.abort(true);\n      this.error = false; // Rebuild stack of chunks from file\n\n      this._prevProgress = 0;\n      var round = this.flowObj.opts.forceChunkSize ? Math.ceil : Math.floor;\n      this.chunkSize = evalOpts(this.flowObj.opts.chunkSize, this);\n      var chunks = Math.max(round(this.size / this.chunkSize), 1);\n\n      for (var offset = 0; offset < chunks; offset++) {\n        this.chunks.push(new FlowChunk(this.flowObj, this, offset));\n      }\n    },\n\n    /**\n     * Get current upload progress status\n     * @function\n     * @returns {number} from 0 to 1\n     */\n    progress: function progress() {\n      if (this.error) {\n        return 1;\n      }\n\n      if (this.chunks.length === 1) {\n        this._prevProgress = Math.max(this._prevProgress, this.chunks[0].progress());\n        return this._prevProgress;\n      } // Sum up progress across everything\n\n\n      var bytesLoaded = 0;\n      each(this.chunks, function (c) {\n        // get chunk progress relative to entire file\n        bytesLoaded += c.progress() * (c.endByte - c.startByte);\n      });\n      var percent = bytesLoaded / this.size; // We don't want to lose percentages when an upload is paused\n\n      this._prevProgress = Math.max(this._prevProgress, percent > 0.9999 ? 1 : percent);\n      return this._prevProgress;\n    },\n\n    /**\n     * Indicates if file is being uploaded at the moment\n     * @function\n     * @returns {boolean}\n     */\n    isUploading: function isUploading() {\n      var uploading = false;\n      each(this.chunks, function (chunk) {\n        if (chunk.status() === 'uploading') {\n          uploading = true;\n          return false;\n        }\n      });\n      return uploading;\n    },\n\n    /**\n     * Indicates if file is has finished uploading and received a response\n     * @function\n     * @returns {boolean}\n     */\n    isComplete: function isComplete() {\n      var outstanding = false;\n      each(this.chunks, function (chunk) {\n        var status = chunk.status();\n\n        if (status === 'pending' || status === 'uploading' || status === 'reading' || chunk.preprocessState === 1 || chunk.readState === 1) {\n          outstanding = true;\n          return false;\n        }\n      });\n      return !outstanding;\n    },\n\n    /**\n     * Count total size uploaded\n     * @function\n     * @returns {number}\n     */\n    sizeUploaded: function sizeUploaded() {\n      var size = 0;\n      each(this.chunks, function (chunk) {\n        size += chunk.sizeUploaded();\n      });\n      return size;\n    },\n\n    /**\n     * Returns remaining time to finish upload file in seconds. Accuracy is based on average speed.\n     * If speed is zero, time remaining will be equal to positive infinity `Number.POSITIVE_INFINITY`\n     * @function\n     * @returns {number}\n     */\n    timeRemaining: function timeRemaining() {\n      if (this.paused || this.error) {\n        return 0;\n      }\n\n      var delta = this.size - this.sizeUploaded();\n\n      if (delta && !this.averageSpeed) {\n        return Number.POSITIVE_INFINITY;\n      }\n\n      if (!delta && !this.averageSpeed) {\n        return 0;\n      }\n\n      return Math.floor(delta / this.averageSpeed);\n    },\n\n    /**\n     * Get file type\n     * @function\n     * @returns {string}\n     */\n    getType: function getType() {\n      return this.file.type && this.file.type.split('/')[1];\n    },\n\n    /**\n     * Get file extension\n     * @function\n     * @returns {string}\n     */\n    getExtension: function getExtension() {\n      return this.name.substr((~-this.name.lastIndexOf(\".\") >>> 0) + 2).toLowerCase();\n    }\n  };\n  /**\n   * Default read function using the webAPI\n   *\n   * @function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk)\n   *\n   */\n\n  function webAPIFileRead(fileObj, startByte, endByte, fileType, chunk) {\n    var function_name = 'slice';\n    if (fileObj.file.slice) function_name = 'slice';else if (fileObj.file.mozSlice) function_name = 'mozSlice';else if (fileObj.file.webkitSlice) function_name = 'webkitSlice';\n    chunk.readFinished(fileObj.file[function_name](startByte, endByte, fileType));\n  }\n  /**\n   * Class for storing a single chunk\n   * @name FlowChunk\n   * @param {Flow} flowObj\n   * @param {FlowFile} fileObj\n   * @param {number} offset\n   * @constructor\n   */\n\n\n  function FlowChunk(flowObj, fileObj, offset) {\n    /**\n     * Reference to parent flow object\n     * @type {Flow}\n     */\n    this.flowObj = flowObj;\n    /**\n     * Reference to parent FlowFile object\n     * @type {FlowFile}\n     */\n\n    this.fileObj = fileObj;\n    /**\n     * File offset\n     * @type {number}\n     */\n\n    this.offset = offset;\n    /**\n     * Indicates if chunk existence was checked on the server\n     * @type {boolean}\n     */\n\n    this.tested = false;\n    /**\n     * Number of retries performed\n     * @type {number}\n     */\n\n    this.retries = 0;\n    /**\n     * Pending retry\n     * @type {boolean}\n     */\n\n    this.pendingRetry = false;\n    /**\n     * Preprocess state\n     * @type {number} 0 = unprocessed, 1 = processing, 2 = finished\n     */\n\n    this.preprocessState = 0;\n    /**\n     * Read state\n     * @type {number} 0 = not read, 1 = reading, 2 = finished\n     */\n\n    this.readState = 0;\n    /**\n     * Bytes transferred from total request size\n     * @type {number}\n     */\n\n    this.loaded = 0;\n    /**\n     * Total request size\n     * @type {number}\n     */\n\n    this.total = 0;\n    /**\n     * Size of a chunk\n     * @type {number}\n     */\n\n    this.chunkSize = this.fileObj.chunkSize;\n    /**\n     * Chunk start byte in a file\n     * @type {number}\n     */\n\n    this.startByte = this.offset * this.chunkSize;\n    /**\n      * Compute the endbyte in a file\n      *\n      */\n\n    this.computeEndByte = function () {\n      var endByte = Math.min(this.fileObj.size, (this.offset + 1) * this.chunkSize);\n\n      if (this.fileObj.size - endByte < this.chunkSize && !this.flowObj.opts.forceChunkSize) {\n        // The last chunk will be bigger than the chunk size,\n        // but less than 2 * this.chunkSize\n        endByte = this.fileObj.size;\n      }\n\n      return endByte;\n    };\n    /**\n     * Chunk end byte in a file\n     * @type {number}\n     */\n\n\n    this.endByte = this.computeEndByte();\n    /**\n     * XMLHttpRequest\n     * @type {XMLHttpRequest}\n     */\n\n    this.xhr = null;\n    var $ = this;\n    /**\n     * Send chunk event\n     * @param event\n     * @param {...} args arguments of a callback\n     */\n\n    this.event = function (event, args) {\n      args = Array.prototype.slice.call(arguments);\n      args.unshift($);\n      $.fileObj.chunkEvent.apply($.fileObj, args);\n    };\n    /**\n     * Catch progress event\n     * @param {ProgressEvent} event\n     */\n\n\n    this.progressHandler = function (event) {\n      if (event.lengthComputable) {\n        $.loaded = event.loaded;\n        $.total = event.total;\n      }\n\n      $.event('progress', event);\n    };\n    /**\n     * Catch test event\n     * @param {Event} event\n     */\n\n\n    this.testHandler = function (event) {\n      var status = $.status(true);\n\n      if (status === 'error') {\n        $.event(status, $.message());\n        $.flowObj.uploadNextChunk();\n      } else if (status === 'success') {\n        $.tested = true;\n        $.event(status, $.message());\n        $.flowObj.uploadNextChunk();\n      } else if (!$.fileObj.paused) {\n        // Error might be caused by file pause method\n        // Chunks does not exist on the server side\n        $.tested = true;\n        $.send();\n      }\n    };\n    /**\n     * Upload has stopped\n     * @param {Event} event\n     */\n\n\n    this.doneHandler = function (event) {\n      var status = $.status();\n\n      if (status === 'success' || status === 'error') {\n        delete this.data;\n        $.event(status, $.message());\n        $.flowObj.uploadNextChunk();\n      } else {\n        $.event('retry', $.message());\n        $.pendingRetry = true;\n        $.abort();\n        $.retries++;\n        var retryInterval = $.flowObj.opts.chunkRetryInterval;\n\n        if (retryInterval !== null) {\n          setTimeout(function () {\n            $.send();\n          }, retryInterval);\n        } else {\n          $.send();\n        }\n      }\n    };\n  }\n\n  FlowChunk.prototype = {\n    /**\n     * Get params for a request\n     * @function\n     */\n    getParams: function getParams() {\n      return {\n        flowChunkNumber: this.offset + 1,\n        flowChunkSize: this.chunkSize,\n        flowCurrentChunkSize: this.endByte - this.startByte,\n        flowTotalSize: this.fileObj.size,\n        flowIdentifier: this.fileObj.uniqueIdentifier,\n        flowFilename: this.fileObj.name,\n        flowRelativePath: this.fileObj.relativePath,\n        flowTotalChunks: this.fileObj.chunks.length\n      };\n    },\n\n    /**\n     * Get target option with query params\n     * @function\n     * @param params\n     * @returns {string}\n     */\n    getTarget: function getTarget(target, params) {\n      if (params.length == 0) {\n        return target;\n      }\n\n      if (target.indexOf('?') < 0) {\n        target += '?';\n      } else {\n        target += '&';\n      }\n\n      return target + params.join('&');\n    },\n\n    /**\n     * Makes a GET request without any data to see if the chunk has already\n     * been uploaded in a previous session\n     * @function\n     */\n    test: function test() {\n      // Set up request and listen for event\n      this.xhr = new XMLHttpRequest();\n      this.xhr.addEventListener(\"load\", this.testHandler, false);\n      this.xhr.addEventListener(\"error\", this.testHandler, false);\n      var testMethod = evalOpts(this.flowObj.opts.testMethod, this.fileObj, this);\n      var data = this.prepareXhrRequest(testMethod, true);\n      this.xhr.send(data);\n    },\n\n    /**\n     * Finish preprocess state\n     * @function\n     */\n    preprocessFinished: function preprocessFinished() {\n      // Re-compute the endByte after the preprocess function to allow an\n      // implementer of preprocess to set the fileObj size\n      this.endByte = this.computeEndByte();\n      this.preprocessState = 2;\n      this.send();\n    },\n\n    /**\n     * Finish read state\n     * @function\n     */\n    readFinished: function readFinished(bytes) {\n      this.readState = 2;\n      this.bytes = bytes;\n      this.send();\n    },\n\n    /**\n     * Uploads the actual data in a POST call\n     * @function\n     */\n    send: function send() {\n      var preprocess = this.flowObj.opts.preprocess;\n      var read = this.flowObj.opts.readFileFn;\n\n      if (typeof preprocess === 'function') {\n        switch (this.preprocessState) {\n          case 0:\n            this.preprocessState = 1;\n            preprocess(this);\n            return;\n\n          case 1:\n            return;\n        }\n      }\n\n      switch (this.readState) {\n        case 0:\n          this.readState = 1;\n          read(this.fileObj, this.startByte, this.endByte, this.fileObj.file.type, this);\n          return;\n\n        case 1:\n          return;\n      }\n\n      if (this.flowObj.opts.testChunks && !this.tested) {\n        this.test();\n        return;\n      }\n\n      this.loaded = 0;\n      this.total = 0;\n      this.pendingRetry = false; // Set up request and listen for event\n\n      this.xhr = new XMLHttpRequest();\n      this.xhr.upload.addEventListener('progress', this.progressHandler, false);\n      this.xhr.addEventListener(\"load\", this.doneHandler, false);\n      this.xhr.addEventListener(\"error\", this.doneHandler, false);\n      var uploadMethod = evalOpts(this.flowObj.opts.uploadMethod, this.fileObj, this);\n      var data = this.prepareXhrRequest(uploadMethod, false, this.flowObj.opts.method, this.bytes);\n      var changeRawDataBeforeSend = this.flowObj.opts.changeRawDataBeforeSend;\n\n      if (typeof changeRawDataBeforeSend === 'function') {\n        data = changeRawDataBeforeSend(this, data);\n      }\n\n      this.xhr.send(data);\n    },\n\n    /**\n     * Abort current xhr request\n     * @function\n     */\n    abort: function abort() {\n      // Abort and reset\n      var xhr = this.xhr;\n      this.xhr = null;\n\n      if (xhr) {\n        xhr.abort();\n      }\n    },\n\n    /**\n     * Retrieve current chunk upload status\n     * @function\n     * @returns {string} 'pending', 'uploading', 'success', 'error'\n     */\n    status: function status(isTest) {\n      if (this.readState === 1) {\n        return 'reading';\n      } else if (this.pendingRetry || this.preprocessState === 1) {\n        // if pending retry then that's effectively the same as actively uploading,\n        // there might just be a slight delay before the retry starts\n        return 'uploading';\n      } else if (!this.xhr) {\n        return 'pending';\n      } else if (this.xhr.readyState < 4) {\n        // Status is really 'OPENED', 'HEADERS_RECEIVED'\n        // or 'LOADING' - meaning that stuff is happening\n        return 'uploading';\n      } else {\n        if (this.flowObj.opts.successStatuses.indexOf(this.xhr.status) > -1) {\n          // HTTP 200, perfect\n          // HTTP 202 Accepted - The request has been accepted for processing, but the processing has not been completed.\n          return 'success';\n        } else if (this.flowObj.opts.permanentErrors.indexOf(this.xhr.status) > -1 || !isTest && this.retries >= this.flowObj.opts.maxChunkRetries) {\n          // HTTP 413/415/500/501, permanent error\n          return 'error';\n        } else {\n          // this should never happen, but we'll reset and queue a retry\n          // a likely case for this would be 503 service unavailable\n          this.abort();\n          return 'pending';\n        }\n      }\n    },\n\n    /**\n     * Get response from xhr request\n     * @function\n     * @returns {String}\n     */\n    message: function message() {\n      return this.xhr ? this.xhr.responseText : '';\n    },\n\n    /**\n     * Get upload progress\n     * @function\n     * @returns {number}\n     */\n    progress: function progress() {\n      if (this.pendingRetry) {\n        return 0;\n      }\n\n      var s = this.status();\n\n      if (s === 'success' || s === 'error') {\n        return 1;\n      } else if (s === 'pending') {\n        return 0;\n      } else {\n        return this.total > 0 ? this.loaded / this.total : 0;\n      }\n    },\n\n    /**\n     * Count total size uploaded\n     * @function\n     * @returns {number}\n     */\n    sizeUploaded: function sizeUploaded() {\n      var size = this.endByte - this.startByte; // can't return only chunk.loaded value, because it is bigger than chunk size\n\n      if (this.status() !== 'success') {\n        size = this.progress() * size;\n      }\n\n      return size;\n    },\n\n    /**\n     * Prepare Xhr request. Set query, headers and data\n     * @param {string} method GET or POST\n     * @param {bool} isTest is this a test request\n     * @param {string} [paramsMethod] octet or form\n     * @param {Blob} [blob] to send\n     * @returns {FormData|Blob|Null} data to send\n     */\n    prepareXhrRequest: function prepareXhrRequest(method, isTest, paramsMethod, blob) {\n      // Add data from the query options\n      var query = evalOpts(this.flowObj.opts.query, this.fileObj, this, isTest);\n      query = extend(query || {}, this.getParams());\n      var target = evalOpts(this.flowObj.opts.target, this.fileObj, this, isTest);\n      var data = null;\n\n      if (method === 'GET' || paramsMethod === 'octet') {\n        // Add data from the query options\n        var params = [];\n        each(query, function (v, k) {\n          params.push([encodeURIComponent(k), encodeURIComponent(v)].join('='));\n        });\n        target = this.getTarget(target, params);\n        data = blob || null;\n      } else {\n        // Add data from the query options\n        data = new FormData();\n        each(query, function (v, k) {\n          data.append(k, v);\n        });\n        if (typeof blob !== \"undefined\") data.append(this.flowObj.opts.fileParameterName, blob, this.fileObj.file.name);\n      }\n\n      this.xhr.open(method, target, true);\n      this.xhr.withCredentials = this.flowObj.opts.withCredentials; // Add data from header options\n\n      each(evalOpts(this.flowObj.opts.headers, this.fileObj, this, isTest), function (v, k) {\n        this.xhr.setRequestHeader(k, v);\n      }, this);\n      return data;\n    }\n  };\n  /**\n   * Remove value from array\n   * @param array\n   * @param value\n   */\n\n  function arrayRemove(array, value) {\n    var index = array.indexOf(value);\n\n    if (index > -1) {\n      array.splice(index, 1);\n    }\n  }\n  /**\n   * If option is a function, evaluate it with given params\n   * @param {*} data\n   * @param {...} args arguments of a callback\n   * @returns {*}\n   */\n\n\n  function evalOpts(data, args) {\n    if (typeof data === \"function\") {\n      // `arguments` is an object, not array, in FF, so:\n      args = Array.prototype.slice.call(arguments);\n      data = data.apply(null, args.slice(1));\n    }\n\n    return data;\n  }\n\n  Flow.evalOpts = evalOpts;\n  /**\n   * Execute function asynchronously\n   * @param fn\n   * @param context\n   */\n\n  function async(fn, context) {\n    setTimeout(fn.bind(context), 0);\n  }\n  /**\n   * Extends the destination object `dst` by copying all of the properties from\n   * the `src` object(s) to `dst`. You can specify multiple `src` objects.\n   * @function\n   * @param {Object} dst Destination object.\n   * @param {...Object} src Source object(s).\n   * @returns {Object} Reference to `dst`.\n   */\n\n\n  function extend(dst, src) {\n    each(arguments, function (obj) {\n      if (obj !== dst) {\n        each(obj, function (value, key) {\n          dst[key] = value;\n        });\n      }\n    });\n    return dst;\n  }\n\n  Flow.extend = extend;\n  /**\n   * Iterate each element of an object\n   * @function\n   * @param {Array|Object} obj object or an array to iterate\n   * @param {Function} callback first argument is a value and second is a key.\n   * @param {Object=} context Object to become context (`this`) for the iterator function.\n   */\n\n  function each(obj, callback, context) {\n    if (!obj) {\n      return;\n    }\n\n    var key; // Is Array?\n    // Array.isArray won't work, not only arrays can be iterated by index https://github.com/flowjs/ng-flow/issues/236#\n\n    if (typeof obj.length !== 'undefined') {\n      for (key = 0; key < obj.length; key++) {\n        if (callback.call(context, obj[key], key) === false) {\n          return;\n        }\n      }\n    } else {\n      for (key in obj) {\n        if (obj.hasOwnProperty(key) && callback.call(context, obj[key], key) === false) {\n          return;\n        }\n      }\n    }\n  }\n\n  Flow.each = each;\n  /**\n   * FlowFile constructor\n   * @type {FlowFile}\n   */\n\n  Flow.FlowFile = FlowFile;\n  /**\n   * FlowFile constructor\n   * @type {FlowChunk}\n   */\n\n  Flow.FlowChunk = FlowChunk;\n  /**\n   * Library version\n   * @type {string}\n   */\n\n  Flow.version = '<%= version %>';\n\n  if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) === \"object\" && module && _typeof(module.exports) === \"object\") {\n    // Expose Flow as module.exports in loaders that implement the Node\n    // module pattern (including browserify). Do not create the global, since\n    // the user will be storing it themselves locally, and globals are frowned\n    // upon in the Node module world.\n    module.exports = Flow;\n  } else {\n    // Otherwise expose Flow to the global object as usual\n    window.Flow = Flow; // Register as a named AMD module, since Flow can be concatenated with other\n    // files that may use define, but not via a proper concatenation script that\n    // understands anonymous AMD modules. A named AMD is safest and most robust\n    // way to register. Lowercase flow is used because AMD module names are\n    // derived from file names, and Flow is normally delivered in a lowercase\n    // file name. Do this after creating the global so that if an AMD module wants\n    // to call noConflict to hide this version of Flow, it will work.\n\n    if (typeof define === \"function\" && define.amd) {\n      define(\"flow\", [], function () {\n        return Flow;\n      });\n    }\n  }\n})(typeof window !== 'undefined' && window, typeof document !== 'undefined' && document);","import * as Flow from '@flowjs/flow.js/src/flow.js'\n\nexport { Flow }\n"],"sourceRoot":""}