{"version":3,"sources":["webpack:///./src/services/loadingMixin.js","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/browser/storage.js","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/upload.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_cloneArrayBuffer.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_cloneBuffer.js","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/browser/request.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/merge.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/isPlainObject.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_safeGet.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_copyObject.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_baseMerge.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/isArrayLikeObject.js","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/browser/uriToBlob.js","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/browser/isReactNative.js","webpack:///./src/services/tus/UploadFacade.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_copyArray.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_baseRest.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_isIterateeCall.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_overRest.js","webpack:///C:/agent/_work/77/s/node_modules/querystringify/index.js","webpack:///C:/agent/_work/77/s/node_modules/extend/index.js","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/browser/fingerprint.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_assignMergeValue.js","webpack:///./src/components/Dropzone.vue?00ce","webpack:///C:/agent/_work/77/s/node_modules/lodash/_baseMergeDeep.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_assignValue.js","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/browser/isCordova.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/constant.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_shortOut.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_baseKeysIn.js","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/browser/source.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_initCloneObject.js","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/error.js","webpack:///C:/agent/_work/77/s/node_modules/js-base64/base64.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_baseCreate.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_createAssigner.js","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/browser/readAsByteArray.js","webpack:///./src/services/globalEventBus.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/keysIn.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_apply.js","webpack:///C:/agent/_work/77/s/node_modules/url-parse/index.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/toPlainObject.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_cloneTypedArray.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_setToString.js","webpack:///./src/components/Dropzone.vue?4354","webpack:///src/components/Dropzone.vue","webpack:///./src/components/Dropzone.vue?f0c3","webpack:///./src/components/Dropzone.vue","webpack:///C:/agent/_work/77/s/node_modules/tus-js-client/lib.es5/index.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_baseSetToString.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_nativeKeysIn.js","webpack:///C:/agent/_work/77/s/node_modules/requires-port/index.js","webpack:///C:/agent/_work/77/s/node_modules/lodash/_getPrototype.js"],"names":["createStartFunction","loadingCountDataName","this","createEndFunction","clearLoadingMethodName","createClearFunction","createWaitFunction","startLoadingMethodName","endLoadingMethodName","promise","waitLoading","createLoadingComputedFunction","createPrototype","params","loadingComputedName","waitLoadingMethodName","data","methods","computed","build","name","capitalizedName","firstCapitalized","defaultLoadingManager","Object","defineProperty","exports","value","_createClass","defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","key","Constructor","protoProps","staticProps","prototype","_classCallCheck","instance","TypeError","getStorage","hasStorage","window","localStorage","setItem","getItem","e","code","SECURITY_ERR","QUOTA_EXCEEDED_ERR","canStoreURLs","LocalStorage","cb","removeItem","_error","_error2","_interopRequireDefault","_extend","_extend2","_jsBase","_request","_source","_storage","_fingerprint","_fingerprint2","obj","__esModule","default","defaultOptions","endpoint","fingerprint","resume","onProgress","onChunkComplete","onSuccess","onError","headers","chunkSize","Infinity","withCredentials","uploadUrl","uploadSize","overridePatchMethod","retryDelays","removeFingerprintOnSuccess","uploadLengthDeferred","urlStorage","fileReader","uploadDataDuringCreation","Upload","file","options","url","_xhr","_offset","_aborted","_size","_retryAttempt","_retryTimeout","_offsetBeforeRetry","_this","_start","getSource","err","source","_emitError","Error","_this2","isNaN","size","toString","call","errorCallback","shouldResetDelays","isOnline","navigator","onLine","status","originalRequest","isServerError","inStatusCategory","shouldRetry","delay","setTimeout","start","_resumeUpload","_hasStorage","fingerprintValue","resumedUrl","_createUpload","shouldTerminate","_this3","abort","close","clearTimeout","terminate","xhr","causingErr","bytesSent","bytesTotal","bytesAccepted","setupXHR","_this4","newRequest","open","onload","location","getResponseHeader","resolveUrl","_emitSuccess","_handleUploadResponse","_startUpload","_emitXhrError","onerror","_setupXHR","setRequestHeader","metadata","encodeMetadata","_addChunkToRequest","send","_this5","offset","parseInt","_emitProgress","_this6","_this7","upload","onprogress","lengthComputable","loaded","end","slice","complete","_this8","_emitChunkComplete","encoded","push","Base64","encode","join","category","Uint8Array","cloneArrayBuffer","arrayBuffer","result","constructor","byteLength","set","module","freeExports","nodeType","freeModule","moduleExports","Buffer","root","undefined","allocUnsafe","cloneBuffer","buffer","isDeep","copy","_urlParse","_urlParse2","XMLHttpRequest","origin","link","baseMerge","createAssigner","merge","object","srcIndex","baseGetTag","getPrototype","isObjectLike","objectTag","funcProto","Function","objectProto","funcToString","hasOwnProperty","objectCtorString","isPlainObject","proto","Ctor","safeGet","assignValue","baseAssignValue","copyObject","customizer","isNew","index","newValue","Stack","assignMergeValue","baseFor","baseMergeDeep","isObject","keysIn","stack","srcValue","isArrayLike","isArrayLikeObject","uriToBlob","uri","done","responseType","blob","response","isReactNative","product","toLowerCase","getFileId","parts","split","toUpperCase","TUS_TERMINATION_NOT_SUPPORTED_ERROR","ABSOLUTE_URL_MATCHER","getFinalUrl","test","baseUrl","uploadBuilder","uploadOptions","decorateBasicHeaders","nomeDoArquivo","tus","startFileData","fileData","getPercent","current","total","UploadFacade","listeners","listenersScope","files","autoStart","errorHandling","assign","EventBus","createObservableProxy","onEach","fileUploads","appendFile","forEach","percentageSent","acceptedBytes","percentageAccepted","totalBytes","args","handleOnProgress","emit","handleOnError","getFileData","stopFileData","Promise","all","map","splice","indexOf","resolve","reject","error","message","includes","handleTusResponseError","find","managedFile","event","fileId","id","eventArgs","errorEvent","copyArray","array","Array","identity","overRest","setToString","baseRest","func","eq","isIndex","isIterateeCall","type","apply","nativeMax","Math","max","transform","arguments","otherArgs","undef","has","decode","input","decodeURIComponent","replace","querystring","query","part","parser","exec","querystringify","prefix","pairs","encodeURIComponent","stringify","parse","hasOwn","toStr","gOPD","getOwnPropertyDescriptor","isArray","arr","hasOwnConstructor","hasIsPrototypeOf","setProperty","getProperty","extend","src","copyIsArray","clone","deep","_isReactNative","_isReactNative2","callback","reactNativeFingerprint","lastModified","exifHash","exif","hashCode","JSON","str","hash","char","charCodeAt","cloneTypedArray","initCloneObject","isArguments","isBuffer","isFunction","isTypedArray","toPlainObject","mergeFunc","objValue","stacked","get","isCommon","isArr","isBuff","isTyped","isCordova","PhoneGap","Cordova","cordova","constant","HOT_COUNT","HOT_SPAN","nativeNow","Date","now","shortOut","count","lastCalled","stamp","remaining","isPrototype","nativeKeysIn","baseKeysIn","isProto","_uriToBlob","_uriToBlob2","_isCordova","_isCordova2","_readAsByteArray","_readAsByteArray2","FileSource","_file","chunk","StreamSource","reader","_chunkSize","_buffer","_bufferOffset","_reader","_done","_readUntilEnoughDataOrDone","hasEnoughData","len","_getDataFromBuffer","read","then","_ref","concat","catch","hasAllDataBeenRead","cancel","blobOrArray","a","b","Blob","c","isFinite","baseCreate","_possibleConstructorReturn","self","ReferenceError","_inherits","subClass","superClass","create","setPrototypeOf","__proto__","DetailedError","_Error","getPrototypeOf","causingError","responseText","global","factory","_Base64","version","eval","b64chars","b64tab","bin","t","l","charAt","fromCharCode","String","cb_utob","cc","re_utob","utob","u","cb_encode","ccc","padlen","ord","chars","btoa","_encode","isUint8Array","urisafe","m0","encodeURI","re_btou","cb_btou","cccc","cp","btou","cb_decode","n","_atob","atob","_decode","from","noConflict","VERSION","fromBase64","toBase64","__buffer__","noEnum","v","extendString","objectCreate","assigner","sources","guard","readAsByteArray","FileReader","readAsArrayBuffer","validateNamespaceOneDepthLevel","term","emptyEventNameValidator","eventNameValidator","listenersCollection","eventName","fn","scope","getListeners","events","keys","on","findIndex","listener","clearListeners","hasListenersConfig","off","arrayLikeKeys","thisArg","required","qs","slashes","protocolre","whitespace","left","RegExp","trimLeft","rules","address","NaN","ignore","lolcation","loc","globalVar","finaldestination","protocol","Url","unescape","pathname","href","extractProtocol","match","rest","relative","base","path","last","unshift","up","extracted","instruction","instructions","port","host","hostname","username","password","auth","pop","ins","typedArray","byteOffset","baseSetToString","render","_vm","_h","$createElement","_c","_self","attrs","staticClass","_v","_s","title","$event","preventDefault","dragHandler","fileSelect","dataTransfer","$t","openFileSelector","ref","isMultipleUpload","inputAccept","staticRenderFns","Boolean","drag","$refs","fileInput","click","fileList","$emit","fileListArray","component","_upload","_upload2","storage","_interopRequireWildcard","newObj","moduleExport","_window","isSupported","FileStorage","string","overArg"],"mappings":"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","file":"js/assetInformationFiles~baseGeneralData~generalPanelAnalysisProcessing.c566888a.js","sourcesContent":["import { firstCapitalized } from './stringHelper';\r\n\r\n/**\r\n * Cria a função de iniciar carregamento.\r\n * A função gerada tem o comportamento de incrementar em 1 o contador de carregamentos.\r\n */\r\nfunction createStartFunction({\r\n  loadingCountDataName,\r\n}) {\r\n  return function startLoading() {\r\n    this[loadingCountDataName] += 1;\r\n  };\r\n}\r\n\r\n/**\r\n * Cria a função de finalizar carregamento.\r\n * A função gerada tem o comportamento de decrementar em 1 o contador de carregamentos.\r\n * Também faz a checagem para garantir que o contador não fique negativo após o decremento.\r\n */\r\nfunction createEndFunction({\r\n  loadingCountDataName,\r\n  clearLoadingMethodName,\r\n}) {\r\n  return function endLoading() {\r\n    this[loadingCountDataName] -= 1;\r\n    if (this[loadingCountDataName] < 0) {\r\n      this[clearLoadingMethodName]();\r\n    }\r\n  };\r\n}\r\n\r\n/**\r\n * Cria a função para limpar o carregamento.\r\n * A função gerada tem o comportamento de zerar o contador de carregamentos.\r\n */\r\nfunction createClearFunction({\r\n  loadingCountDataName,\r\n}) {\r\n  return function clearLoading() {\r\n    this[loadingCountDataName] = 0;\r\n  };\r\n}\r\n\r\n/**\r\n * Cria a função para aguardar um carregamento assincrono.\r\n * A função gerada tem o comportamento de esperar uma promessa recebida por parametro. Enquanto\r\n * a promessa não acaba, ela define um carregamento, removendo ele ao fim da execução.\r\n */\r\nfunction createWaitFunction({\r\n  startLoadingMethodName,\r\n  endLoadingMethodName,\r\n}) {\r\n  return async function waitLoading(promise) {\r\n    this[startLoadingMethodName]();\r\n    try {\r\n      await promise;\r\n    } finally {\r\n      this[endLoadingMethodName]();\r\n    }\r\n  };\r\n}\r\n\r\n/**\r\n * Cria a função para gerar a computed que fala se está havendo carregamento.\r\n * A função gerada tem a intenção de retornar verdadeira se o contador for maior do que zero.\r\n */\r\nfunction createLoadingComputedFunction({\r\n  loadingCountDataName,\r\n}) {\r\n  return function loading() {\r\n    return !!this[loadingCountDataName];\r\n  };\r\n}\r\n\r\n/**\r\n * Cria o protótipo do mixin com base nos nomes passados por parametro.\r\n */\r\nfunction createPrototype(params) {\r\n  const {\r\n    loadingComputedName,\r\n    loadingCountDataName,\r\n    startLoadingMethodName,\r\n    endLoadingMethodName,\r\n    clearLoadingMethodName,\r\n    waitLoadingMethodName,\r\n  } = params;\r\n\r\n  return {\r\n    data: () => ({\r\n      [loadingCountDataName]: 0,\r\n    }),\r\n    methods: {\r\n      [startLoadingMethodName]: createStartFunction(params),\r\n      [endLoadingMethodName]: createEndFunction(params),\r\n      [clearLoadingMethodName]: createClearFunction(params),\r\n      [waitLoadingMethodName]: createWaitFunction(params),\r\n    },\r\n    computed: {\r\n      [loadingComputedName]: createLoadingComputedFunction(params),\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * Constrói um mixin de carregamento.\r\n *\r\n * @param {String} [name] Nome do carregamento para concatenar aos elementos gerados.\r\n *\r\n * Interface gerada:\r\n *  {\r\n *    data: () => ({\r\n *      loading{name}Count: Number,\r\n *    }),\r\n *    methods: {\r\n *      startLoading{name}(): void,\r\n *      endLoading{name}(): void,\r\n *      clearLoading{name}(): void,\r\n *      waitLoading{name}(Promise): Promise,\r\n *    },\r\n *    computed: {\r\n *      loading{name}: Boolean\r\n *    }\r\n *  }\r\n *\r\n * Exemplo:\r\n *\r\n * const mixin = build('Person');\r\n *\r\n * expect(mixin).toMatchObject({\r\n *    data: () => ({\r\n *      loadingPersonCount,\r\n *    }),\r\n *    methods: {\r\n *      startLoadingPerson,\r\n *      endLoadingPerson,\r\n *      clearLoadingPerson,\r\n *      waitLoadingPerson,\r\n *    },\r\n *    computed: {\r\n *      loadingPerson,\r\n *    }\r\n * });\r\n *\r\n * Para detalhes do funcionamento da interface gerada, veja a documentação\r\n * do mixin básico mais a abaixo.\r\n */\r\nexport function build(name = '') {\r\n  const capitalizedName = firstCapitalized(name);\r\n  const loadingComputedName = `loading${capitalizedName}`;\r\n  const loadingCountDataName = `loading${capitalizedName}Count`;\r\n  const startLoadingMethodName = `startLoading${capitalizedName}`;\r\n  const endLoadingMethodName = `endLoading${capitalizedName}`;\r\n  const clearLoadingMethodName = `clearLoading${capitalizedName}`;\r\n  const waitLoadingMethodName = `waitLoading${capitalizedName}`;\r\n\r\n  return createPrototype({\r\n    loadingComputedName,\r\n    loadingCountDataName,\r\n    startLoadingMethodName,\r\n    endLoadingMethodName,\r\n    clearLoadingMethodName,\r\n    waitLoadingMethodName,\r\n  });\r\n}\r\n\r\n/**\r\n * Mixin básico de carregamento.\r\n *\r\n * Interface do mixin:\r\n *\r\n *  {\r\n *    data: () => ({\r\n *      // Contagem de carregamentos definidos.\r\n *      loadingCount: Number,\r\n *    }),\r\n *    methods: {\r\n *      // Seta um carregamento.\r\n *      startLoading(): void,\r\n *\r\n *      // Remove um carregamento.\r\n *      endLoading(): void,\r\n *\r\n *      // Limpa os carregamentos, zerando tudo.\r\n *      clearLoading(): void,\r\n *\r\n *      // Espera uma promessa, definindo um carregamento enquanto estiver em execução.\r\n *      waitLoading(Promise): Promise,\r\n *    },\r\n *    computed: {\r\n *      // True se a contagem for diferente de zero.\r\n *      loading: Boolean\r\n *    }\r\n *  }\r\n *\r\n * Exemplos de uso do mixin nos components Vue:\r\n *\r\n *  import loadingMixin from '@/services/loadingMixin';\r\n *\r\n *  export default {\r\n *    mixins: [\r\n *      loadingMixin,\r\n *    ],\r\n *    methods: {\r\n *      refreshDataA() {\r\n *        this.startLoading();\r\n *        Service.getData().then(() => {\r\n *          this.endLoading();\r\n *        }).catch(() => {\r\n *          this.endLoading();\r\n *        });\r\n *      },\r\n *      async refreshDataB() {\r\n *        this.startLoading();\r\n *        try {\r\n *          await Service.getData();\r\n *        } finally {\r\n *          this.endLoading();\r\n *        }\r\n *      },\r\n *      refreshDataC() {\r\n *        this.waitLoading(Service.getData());\r\n *      },\r\n *    }\r\n *  }\r\n *\r\n *  <span v-if=\"loading\">Carregando...</span>\r\n */\r\nconst defaultLoadingManager = build();\r\nexport default defaultLoadingManager;\r\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nexports.getStorage = getStorage;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/* global window, localStorage */\n\nvar hasStorage = false;\ntry {\n  hasStorage = \"localStorage\" in window;\n\n  // Attempt to store and read entries from the local storage to detect Private\n  // Mode on Safari on iOS (see #49)\n  var key = \"tusSupport\";\n  localStorage.setItem(key, localStorage.getItem(key));\n} catch (e) {\n  // If we try to access localStorage inside a sandboxed iframe, a SecurityError\n  // is thrown. When in private mode on iOS Safari, a QuotaExceededError is\n  // thrown (see #49)\n  if (e.code === e.SECURITY_ERR || e.code === e.QUOTA_EXCEEDED_ERR) {\n    hasStorage = false;\n  } else {\n    throw e;\n  }\n}\n\nvar canStoreURLs = exports.canStoreURLs = hasStorage;\n\nvar LocalStorage = function () {\n  function LocalStorage() {\n    _classCallCheck(this, LocalStorage);\n  }\n\n  _createClass(LocalStorage, [{\n    key: \"setItem\",\n    value: function setItem(key, value, cb) {\n      cb(null, localStorage.setItem(key, value));\n    }\n  }, {\n    key: \"getItem\",\n    value: function getItem(key, cb) {\n      cb(null, localStorage.getItem(key));\n    }\n  }, {\n    key: \"removeItem\",\n    value: function removeItem(key, cb) {\n      cb(null, localStorage.removeItem(key));\n    }\n  }]);\n\n  return LocalStorage;\n}();\n\nfunction getStorage() {\n  return hasStorage ? new LocalStorage() : null;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /* global window */\n\n\n// We import the files used inside the Node environment which are rewritten\n// for browsers using the rules defined in the package.json\n\n\nvar _error = require(\"./error\");\n\nvar _error2 = _interopRequireDefault(_error);\n\nvar _extend = require(\"extend\");\n\nvar _extend2 = _interopRequireDefault(_extend);\n\nvar _jsBase = require(\"js-base64\");\n\nvar _request = require(\"./node/request\");\n\nvar _source = require(\"./node/source\");\n\nvar _storage = require(\"./node/storage\");\n\nvar _fingerprint = require(\"./node/fingerprint\");\n\nvar _fingerprint2 = _interopRequireDefault(_fingerprint);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar defaultOptions = {\n  endpoint: null,\n  fingerprint: _fingerprint2.default,\n  resume: true,\n  onProgress: null,\n  onChunkComplete: null,\n  onSuccess: null,\n  onError: null,\n  headers: {},\n  chunkSize: Infinity,\n  withCredentials: false,\n  uploadUrl: null,\n  uploadSize: null,\n  overridePatchMethod: false,\n  retryDelays: null,\n  removeFingerprintOnSuccess: false,\n  uploadLengthDeferred: false,\n  urlStorage: null,\n  fileReader: null,\n  uploadDataDuringCreation: false\n};\n\nvar Upload = function () {\n  function Upload(file, options) {\n    _classCallCheck(this, Upload);\n\n    this.options = (0, _extend2.default)(true, {}, defaultOptions, options);\n\n    // The storage module used to store URLs\n    this._storage = this.options.urlStorage;\n\n    // The underlying File/Blob object\n    this.file = file;\n\n    // The URL against which the file will be uploaded\n    this.url = null;\n\n    // The underlying XHR object for the current PATCH request\n    this._xhr = null;\n\n    // The fingerpinrt for the current file (set after start())\n    this._fingerprint = null;\n\n    // The offset used in the current PATCH request\n    this._offset = null;\n\n    // True if the current PATCH request has been aborted\n    this._aborted = false;\n\n    // The file's size in bytes\n    this._size = null;\n\n    // The Source object which will wrap around the given file and provides us\n    // with a unified interface for getting its size and slice chunks from its\n    // content allowing us to easily handle Files, Blobs, Buffers and Streams.\n    this._source = null;\n\n    // The current count of attempts which have been made. Null indicates none.\n    this._retryAttempt = 0;\n\n    // The timeout's ID which is used to delay the next retry\n    this._retryTimeout = null;\n\n    // The offset of the remote upload before the latest attempt was started.\n    this._offsetBeforeRetry = 0;\n  }\n\n  _createClass(Upload, [{\n    key: \"start\",\n    value: function start() {\n      var _this = this;\n\n      var file = this.file;\n\n      if (!file) {\n        this._emitError(new Error(\"tus: no file or stream to upload provided\"));\n        return;\n      }\n\n      if (!this.options.endpoint && !this.options.uploadUrl) {\n        this._emitError(new Error(\"tus: neither an endpoint or an upload URL is provided\"));\n        return;\n      }\n\n      if (this.options.resume && this._storage == null) {\n        this._storage = (0, _storage.getStorage)();\n      }\n\n      if (this._source) {\n        this._start(this._source);\n      } else {\n        var fileReader = this.options.fileReader || _source.getSource;\n        fileReader(file, this.options.chunkSize, function (err, source) {\n          if (err) {\n            _this._emitError(err);\n            return;\n          }\n\n          _this._source = source;\n          _this._start(source);\n        });\n      }\n    }\n  }, {\n    key: \"_start\",\n    value: function _start(source) {\n      var _this2 = this;\n\n      var file = this.file;\n\n      // First, we look at the uploadLengthDeferred option.\n      // Next, we check if the caller has supplied a manual upload size.\n      // Finally, we try to use the calculated size from the source object.\n      if (this.options.uploadLengthDeferred) {\n        this._size = null;\n      } else if (this.options.uploadSize != null) {\n        this._size = +this.options.uploadSize;\n        if (isNaN(this._size)) {\n          this._emitError(new Error(\"tus: cannot convert `uploadSize` option into a number\"));\n          return;\n        }\n      } else {\n        this._size = source.size;\n        if (this._size == null) {\n          this._emitError(new Error(\"tus: cannot automatically derive upload's size from input and must be specified manually using the `uploadSize` option\"));\n          return;\n        }\n      }\n\n      var retryDelays = this.options.retryDelays;\n      if (retryDelays != null) {\n        if (Object.prototype.toString.call(retryDelays) !== \"[object Array]\") {\n          this._emitError(new Error(\"tus: the `retryDelays` option must either be an array or null\"));\n          return;\n        } else {\n          var errorCallback = this.options.onError;\n          this.options.onError = function (err) {\n            // Restore the original error callback which may have been set.\n            _this2.options.onError = errorCallback;\n\n            // We will reset the attempt counter if\n            // - we were already able to connect to the server (offset != null) and\n            // - we were able to upload a small chunk of data to the server\n            var shouldResetDelays = _this2._offset != null && _this2._offset > _this2._offsetBeforeRetry;\n            if (shouldResetDelays) {\n              _this2._retryAttempt = 0;\n            }\n\n            var isOnline = true;\n            if (typeof window !== \"undefined\" && \"navigator\" in window && window.navigator.onLine === false) {\n              isOnline = false;\n            }\n\n            // We only attempt a retry if\n            // - we didn't exceed the maxium number of retries, yet, and\n            // - this error was caused by a request or it's response and\n            // - the error is server error (i.e. no a status 4xx or a 409 or 423) and\n            // - the browser does not indicate that we are offline\n            var status = err.originalRequest ? err.originalRequest.status : 0;\n            var isServerError = !inStatusCategory(status, 400) || status === 409 || status === 423;\n            var shouldRetry = _this2._retryAttempt < retryDelays.length && err.originalRequest != null && isServerError && isOnline;\n\n            if (!shouldRetry) {\n              _this2._emitError(err);\n              return;\n            }\n\n            var delay = retryDelays[_this2._retryAttempt++];\n\n            _this2._offsetBeforeRetry = _this2._offset;\n            _this2.options.uploadUrl = _this2.url;\n\n            _this2._retryTimeout = setTimeout(function () {\n              _this2.start();\n            }, delay);\n          };\n        }\n      }\n\n      // Reset the aborted flag when the upload is started or else the\n      // _startUpload will stop before sending a request if the upload has been\n      // aborted previously.\n      this._aborted = false;\n\n      // The upload had been started previously and we should reuse this URL.\n      if (this.url != null) {\n        this._resumeUpload();\n        return;\n      }\n\n      // A URL has manually been specified, so we try to resume\n      if (this.options.uploadUrl != null) {\n        this.url = this.options.uploadUrl;\n        this._resumeUpload();\n        return;\n      }\n\n      // Try to find the endpoint for the file in the storage\n      if (this._hasStorage()) {\n        this.options.fingerprint(file, this.options, function (err, fingerprintValue) {\n          if (err) {\n            _this2._emitError(err);\n            return;\n          }\n\n          _this2._fingerprint = fingerprintValue;\n          _this2._storage.getItem(_this2._fingerprint, function (err, resumedUrl) {\n            if (err) {\n              _this2._emitError(err);\n              return;\n            }\n\n            if (resumedUrl != null) {\n              _this2.url = resumedUrl;\n              _this2._resumeUpload();\n            } else {\n              _this2._createUpload();\n            }\n          });\n        });\n      } else {\n        // An upload has not started for the file yet, so we start a new one\n        this._createUpload();\n      }\n    }\n  }, {\n    key: \"abort\",\n    value: function abort(shouldTerminate, cb) {\n      var _this3 = this;\n\n      if (this._xhr !== null) {\n        this._xhr.abort();\n        this._source.close();\n      }\n      this._aborted = true;\n\n      if (this._retryTimeout != null) {\n        clearTimeout(this._retryTimeout);\n        this._retryTimeout = null;\n      }\n\n      cb = cb || function () {};\n      if (shouldTerminate) {\n        Upload.terminate(this.url, this.options, function (err, xhr) {\n          if (err) {\n            return cb(err, xhr);\n          }\n\n          _this3._hasStorage() ? _this3._storage.removeItem(_this3._fingerprint, cb) : cb();\n        });\n      } else {\n        cb();\n      }\n    }\n  }, {\n    key: \"_hasStorage\",\n    value: function _hasStorage() {\n      return this.options.resume && this._storage;\n    }\n  }, {\n    key: \"_emitXhrError\",\n    value: function _emitXhrError(xhr, err, causingErr) {\n      this._emitError(new _error2.default(err, causingErr, xhr));\n    }\n  }, {\n    key: \"_emitError\",\n    value: function _emitError(err) {\n      if (typeof this.options.onError === \"function\") {\n        this.options.onError(err);\n      } else {\n        throw err;\n      }\n    }\n  }, {\n    key: \"_emitSuccess\",\n    value: function _emitSuccess() {\n      if (typeof this.options.onSuccess === \"function\") {\n        this.options.onSuccess();\n      }\n    }\n\n    /**\n     * Publishes notification when data has been sent to the server. This\n     * data may not have been accepted by the server yet.\n     * @param  {number} bytesSent  Number of bytes sent to the server.\n     * @param  {number} bytesTotal Total number of bytes to be sent to the server.\n     */\n\n  }, {\n    key: \"_emitProgress\",\n    value: function _emitProgress(bytesSent, bytesTotal) {\n      if (typeof this.options.onProgress === \"function\") {\n        this.options.onProgress(bytesSent, bytesTotal);\n      }\n    }\n\n    /**\n     * Publishes notification when a chunk of data has been sent to the server\n     * and accepted by the server.\n     * @param  {number} chunkSize  Size of the chunk that was accepted by the\n     *                             server.\n     * @param  {number} bytesAccepted Total number of bytes that have been\n     *                                accepted by the server.\n     * @param  {number} bytesTotal Total number of bytes to be sent to the server.\n     */\n\n  }, {\n    key: \"_emitChunkComplete\",\n    value: function _emitChunkComplete(chunkSize, bytesAccepted, bytesTotal) {\n      if (typeof this.options.onChunkComplete === \"function\") {\n        this.options.onChunkComplete(chunkSize, bytesAccepted, bytesTotal);\n      }\n    }\n\n    /**\n     * Set the headers used in the request and the withCredentials property\n     * as defined in the options\n     *\n     * @param {XMLHttpRequest} xhr\n     */\n\n  }, {\n    key: \"_setupXHR\",\n    value: function _setupXHR(xhr) {\n      this._xhr = xhr;\n      setupXHR(xhr, this.options);\n    }\n\n    /**\n     * Create a new upload using the creation extension by sending a POST\n     * request to the endpoint. After successful creation the file will be\n     * uploaded\n     *\n     * @api private\n     */\n\n  }, {\n    key: \"_createUpload\",\n    value: function _createUpload() {\n      var _this4 = this;\n\n      if (!this.options.endpoint) {\n        this._emitError(new Error(\"tus: unable to create upload because no endpoint is provided\"));\n        return;\n      }\n\n      var xhr = (0, _request.newRequest)();\n      xhr.open(\"POST\", this.options.endpoint, true);\n\n      xhr.onload = function () {\n        if (!inStatusCategory(xhr.status, 200)) {\n          _this4._emitXhrError(xhr, new Error(\"tus: unexpected response while creating upload\"));\n          return;\n        }\n\n        var location = xhr.getResponseHeader(\"Location\");\n        if (location == null) {\n          _this4._emitXhrError(xhr, new Error(\"tus: invalid or missing Location header\"));\n          return;\n        }\n\n        _this4.url = (0, _request.resolveUrl)(_this4.options.endpoint, location);\n\n        if (_this4._size === 0) {\n          // Nothing to upload and file was successfully created\n          _this4._emitSuccess();\n          _this4._source.close();\n          return;\n        }\n\n        if (_this4._hasStorage()) {\n          _this4._storage.setItem(_this4._fingerprint, _this4.url, function (err) {\n            if (err) {\n              _this4._emitError(err);\n            }\n          });\n        }\n\n        if (_this4.options.uploadDataDuringCreation) {\n          _this4._handleUploadResponse(xhr);\n        } else {\n          _this4._offset = 0;\n          _this4._startUpload();\n        }\n      };\n\n      xhr.onerror = function (err) {\n        _this4._emitXhrError(xhr, new Error(\"tus: failed to create upload\"), err);\n      };\n\n      this._setupXHR(xhr);\n      if (this.options.uploadLengthDeferred) {\n        xhr.setRequestHeader(\"Upload-Defer-Length\", 1);\n      } else {\n        xhr.setRequestHeader(\"Upload-Length\", this._size);\n      }\n\n      // Add metadata if values have been added\n      var metadata = encodeMetadata(this.options.metadata);\n      if (metadata !== \"\") {\n        xhr.setRequestHeader(\"Upload-Metadata\", metadata);\n      }\n\n      if (this.options.uploadDataDuringCreation && !this.options.uploadLengthDeferred) {\n        this._offset = 0;\n        this._addChunkToRequest(xhr);\n      } else {\n        xhr.send(null);\n      }\n    }\n\n    /*\n     * Try to resume an existing upload. First a HEAD request will be sent\n     * to retrieve the offset. If the request fails a new upload will be\n     * created. In the case of a successful response the file will be uploaded.\n     *\n     * @api private\n     */\n\n  }, {\n    key: \"_resumeUpload\",\n    value: function _resumeUpload() {\n      var _this5 = this;\n\n      var xhr = (0, _request.newRequest)();\n      xhr.open(\"HEAD\", this.url, true);\n\n      xhr.onload = function () {\n        if (!inStatusCategory(xhr.status, 200)) {\n          if (_this5._hasStorage() && inStatusCategory(xhr.status, 400)) {\n            // Remove stored fingerprint and corresponding endpoint,\n            // on client errors since the file can not be found\n            _this5._storage.removeItem(_this5._fingerprint, function (err) {\n              if (err) {\n                _this5._emitError(err);\n              }\n            });\n          }\n\n          // If the upload is locked (indicated by the 423 Locked status code), we\n          // emit an error instead of directly starting a new upload. This way the\n          // retry logic can catch the error and will retry the upload. An upload\n          // is usually locked for a short period of time and will be available\n          // afterwards.\n          if (xhr.status === 423) {\n            _this5._emitXhrError(xhr, new Error(\"tus: upload is currently locked; retry later\"));\n            return;\n          }\n\n          if (!_this5.options.endpoint) {\n            // Don't attempt to create a new upload if no endpoint is provided.\n            _this5._emitXhrError(xhr, new Error(\"tus: unable to resume upload (new upload cannot be created without an endpoint)\"));\n            return;\n          }\n\n          // Try to create a new upload\n          _this5.url = null;\n          _this5._createUpload();\n          return;\n        }\n\n        var offset = parseInt(xhr.getResponseHeader(\"Upload-Offset\"), 10);\n        if (isNaN(offset)) {\n          _this5._emitXhrError(xhr, new Error(\"tus: invalid or missing offset value\"));\n          return;\n        }\n\n        var length = parseInt(xhr.getResponseHeader(\"Upload-Length\"), 10);\n        if (isNaN(length) && !_this5.options.uploadLengthDeferred) {\n          _this5._emitXhrError(xhr, new Error(\"tus: invalid or missing length value\"));\n          return;\n        }\n\n        // Upload has already been completed and we do not need to send additional\n        // data to the server\n        if (offset === length) {\n          _this5._emitProgress(length, length);\n          _this5._emitSuccess();\n          return;\n        }\n\n        _this5._offset = offset;\n        _this5._startUpload();\n      };\n\n      xhr.onerror = function (err) {\n        _this5._emitXhrError(xhr, new Error(\"tus: failed to resume upload\"), err);\n      };\n\n      this._setupXHR(xhr);\n      xhr.send(null);\n    }\n\n    /**\n     * Start uploading the file using PATCH requests. The file will be divided\n     * into chunks as specified in the chunkSize option. During the upload\n     * the onProgress event handler may be invoked multiple times.\n     *\n     * @api private\n     */\n\n  }, {\n    key: \"_startUpload\",\n    value: function _startUpload() {\n      var _this6 = this;\n\n      // If the upload has been aborted, we will not send the next PATCH request.\n      // This is important if the abort method was called during a callback, such\n      // as onChunkComplete or onProgress.\n      if (this._aborted) {\n        return;\n      }\n\n      var xhr = (0, _request.newRequest)();\n\n      // Some browser and servers may not support the PATCH method. For those\n      // cases, you can tell tus-js-client to use a POST request with the\n      // X-HTTP-Method-Override header for simulating a PATCH request.\n      if (this.options.overridePatchMethod) {\n        xhr.open(\"POST\", this.url, true);\n        xhr.setRequestHeader(\"X-HTTP-Method-Override\", \"PATCH\");\n      } else {\n        xhr.open(\"PATCH\", this.url, true);\n      }\n\n      xhr.onload = function () {\n        if (!inStatusCategory(xhr.status, 200)) {\n          _this6._emitXhrError(xhr, new Error(\"tus: unexpected response while uploading chunk\"));\n          return;\n        }\n\n        _this6._handleUploadResponse(xhr);\n      };\n\n      xhr.onerror = function (err) {\n        // Don't emit an error if the upload was aborted manually\n        if (_this6._aborted) {\n          return;\n        }\n\n        _this6._emitXhrError(xhr, new Error(\"tus: failed to upload chunk at offset \" + _this6._offset), err);\n      };\n\n      this._setupXHR(xhr);\n\n      xhr.setRequestHeader(\"Upload-Offset\", this._offset);\n      this._addChunkToRequest(xhr);\n    }\n\n    /**\n     * _addChunktoRequest reads a chunk from the source and sends it using the\n     * supplied XHR object. It will not handle the response.\n     */\n\n  }, {\n    key: \"_addChunkToRequest\",\n    value: function _addChunkToRequest(xhr) {\n      var _this7 = this;\n\n      // Test support for progress events before attaching an event listener\n      if (\"upload\" in xhr) {\n        xhr.upload.onprogress = function (e) {\n          if (!e.lengthComputable) {\n            return;\n          }\n\n          _this7._emitProgress(start + e.loaded, _this7._size);\n        };\n      }\n\n      xhr.setRequestHeader(\"Content-Type\", \"application/offset+octet-stream\");\n\n      var start = this._offset;\n      var end = this._offset + this.options.chunkSize;\n\n      // The specified chunkSize may be Infinity or the calcluated end position\n      // may exceed the file's size. In both cases, we limit the end position to\n      // the input's total size for simpler calculations and correctness.\n      if ((end === Infinity || end > this._size) && !this.options.uploadLengthDeferred) {\n        end = this._size;\n      }\n\n      this._source.slice(start, end, function (err, value, complete) {\n        if (err) {\n          _this7._emitError(err);\n          return;\n        }\n\n        if (_this7.options.uploadLengthDeferred) {\n          if (complete) {\n            _this7._size = _this7._offset + (value && value.size ? value.size : 0);\n            xhr.setRequestHeader(\"Upload-Length\", _this7._size);\n          }\n        }\n\n        if (value === null) {\n          xhr.send();\n        } else {\n          xhr.send(value);\n          _this7._emitProgress(_this7._offset, _this7._size);\n        }\n      });\n    }\n\n    /**\n     * _handleUploadResponse is used by requests that haven been sent using _addChunkToRequest\n     * and already have received a response.\n     */\n\n  }, {\n    key: \"_handleUploadResponse\",\n    value: function _handleUploadResponse(xhr) {\n      var _this8 = this;\n\n      var offset = parseInt(xhr.getResponseHeader(\"Upload-Offset\"), 10);\n      if (isNaN(offset)) {\n        this._emitXhrError(xhr, new Error(\"tus: invalid or missing offset value\"));\n        return;\n      }\n\n      this._emitProgress(offset, this._size);\n      this._emitChunkComplete(offset - this._offset, offset, this._size);\n\n      this._offset = offset;\n\n      if (offset == this._size) {\n        if (this.options.removeFingerprintOnSuccess && this.options.resume) {\n          // Remove stored fingerprint and corresponding endpoint. This causes\n          // new upload of the same file must be treated as a different file.\n          this._storage.removeItem(this._fingerprint, function (err) {\n            if (err) {\n              _this8._emitError(err);\n            }\n          });\n        }\n\n        // Yay, finally done :)\n        this._emitSuccess();\n        this._source.close();\n        return;\n      }\n\n      this._startUpload();\n    }\n  }], [{\n    key: \"terminate\",\n    value: function terminate(url, options, cb) {\n      if (typeof options !== \"function\" && typeof cb !== \"function\") {\n        throw new Error(\"tus: a callback function must be specified\");\n      }\n\n      if (typeof options === \"function\") {\n        cb = options;\n        options = {};\n      }\n\n      var xhr = (0, _request.newRequest)();\n      xhr.open(\"DELETE\", url, true);\n\n      xhr.onload = function () {\n        if (xhr.status !== 204) {\n          cb(new _error2.default(new Error(\"tus: unexpected response while terminating upload\"), null, xhr));\n          return;\n        }\n\n        cb();\n      };\n\n      xhr.onerror = function (err) {\n        cb(new _error2.default(err, new Error(\"tus: failed to terminate upload\"), xhr));\n      };\n\n      setupXHR(xhr, options);\n      xhr.send(null);\n    }\n  }]);\n\n  return Upload;\n}();\n\nfunction encodeMetadata(metadata) {\n  var encoded = [];\n\n  for (var key in metadata) {\n    encoded.push(key + \" \" + _jsBase.Base64.encode(metadata[key]));\n  }\n\n  return encoded.join(\",\");\n}\n\n/**\n * Checks whether a given status is in the range of the expected category.\n * For example, only a status between 200 and 299 will satisfy the category 200.\n *\n * @api private\n */\nfunction inStatusCategory(status, category) {\n  return status >= category && status < category + 100;\n}\n\nfunction setupXHR(xhr, options) {\n  xhr.setRequestHeader(\"Tus-Resumable\", \"1.0.0\");\n  var headers = options.headers || {};\n\n  for (var name in headers) {\n    xhr.setRequestHeader(name, headers[name]);\n  }\n\n  xhr.withCredentials = options.withCredentials;\n}\n\nUpload.defaultOptions = defaultOptions;\n\nexports.default = Upload;","var Uint8Array = require('./_Uint8Array');\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\nmodule.exports = cloneArrayBuffer;\n","var root = require('./_root');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nmodule.exports = cloneBuffer;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.newRequest = newRequest;\nexports.resolveUrl = resolveUrl;\n\nvar _urlParse = require(\"url-parse\");\n\nvar _urlParse2 = _interopRequireDefault(_urlParse);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction newRequest() {\n  return new window.XMLHttpRequest();\n} /* global window */\nfunction resolveUrl(origin, link) {\n  return new _urlParse2.default(link, origin).toString();\n}","var baseMerge = require('./_baseMerge'),\n    createAssigner = require('./_createAssigner');\n\n/**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n *   'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n *   'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\nvar merge = createAssigner(function(object, source, srcIndex) {\n  baseMerge(object, source, srcIndex);\n});\n\nmodule.exports = merge;\n","var baseGetTag = require('./_baseGetTag'),\n    getPrototype = require('./_getPrototype'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\nmodule.exports = isPlainObject;\n","/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n  if (key === 'constructor' && typeof object[key] === 'function') {\n    return;\n  }\n\n  if (key == '__proto__') {\n    return;\n  }\n\n  return object[key];\n}\n\nmodule.exports = safeGet;\n","var assignValue = require('./_assignValue'),\n    baseAssignValue = require('./_baseAssignValue');\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\nmodule.exports = copyObject;\n","var Stack = require('./_Stack'),\n    assignMergeValue = require('./_assignMergeValue'),\n    baseFor = require('./_baseFor'),\n    baseMergeDeep = require('./_baseMergeDeep'),\n    isObject = require('./isObject'),\n    keysIn = require('./keysIn'),\n    safeGet = require('./_safeGet');\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  baseFor(source, function(srcValue, key) {\n    stack || (stack = new Stack);\n    if (isObject(srcValue)) {\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n\nmodule.exports = baseMerge;\n","var isArrayLike = require('./isArrayLike'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\nmodule.exports = isArrayLikeObject;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n/**\n * uriToBlob resolves a URI to a Blob object. This is used for\n * React Native to retrieve a file (identified by a file://\n * URI) as a blob.\n */\nfunction uriToBlob(uri, done) {\n  var xhr = new XMLHttpRequest();\n  xhr.responseType = \"blob\";\n  xhr.onload = function () {\n    var blob = xhr.response;\n    done(null, blob);\n  };\n  xhr.onerror = function (err) {\n    done(err);\n  };\n  xhr.open(\"GET\", uri);\n  xhr.send();\n}\n\nexports.default = uriToBlob;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nvar isReactNative = function isReactNative() {\n  return typeof navigator !== \"undefined\" && typeof navigator.product === \"string\" && navigator.product.toLowerCase() === \"reactnative\";\n};\n\nexports.default = isReactNative;","import tus from 'tus-js-client';\r\nimport merge from 'lodash/merge';\r\nimport { EventBus } from '@/services/globalEventBus';\r\nimport { decorateBasicHeaders, baseUrl } from '../http/common';\r\nimport { handleTusResponseError } from '../globalErrorHandlers';\r\n\r\nfunction getFileId({ url: uploadUrl }) {\r\n  const parts = uploadUrl.split('/');\r\n  return parts[parts.length - 1].toUpperCase();\r\n}\r\n\r\nconst TUS_TERMINATION_NOT_SUPPORTED_ERROR = 'tus: failed to terminate upload, originated from'\r\n + ' request';\r\n\r\nconst ABSOLUTE_URL_MATCHER = /^https?:\\/\\//i;\r\n\r\nfunction getFinalUrl(url) {\r\n  if (ABSOLUTE_URL_MATCHER.test(url)) {\r\n    return url;\r\n  }\r\n  return `${baseUrl}${url}`;\r\n}\r\n\r\n/**\r\n * Constrói um upload do TUS adicionando alguns padrões da aplicação, como, por exemplo,\r\n * autenticação.\r\n * @param {File} file Arquivo\r\n * @param {Object} options Opções do TUS.\r\n * @returns {tus.Upload}\r\n */\r\nfunction uploadBuilder(file, options) {\r\n  const uploadOptions = merge({\r\n    resume: false,\r\n    removeFingerprintOnSuccess: true,\r\n    headers: decorateBasicHeaders(),\r\n    metadata: {\r\n      nomeDoArquivo: file.name,\r\n    },\r\n  }, options);\r\n\r\n  return new tus.Upload(file, uploadOptions);\r\n}\r\n\r\n/**\r\n * @private\r\n * Inicia o upload a partir de dados do arquivo.\r\n * @param {Object} fileData Dados do arquivo\r\n */\r\nfunction startFileData(fileData) {\r\n  fileData.upload.start();\r\n}\r\n\r\nfunction getPercent(current, total) {\r\n  return current * 100 / total;\r\n}\r\n\r\n/**\r\n * Fachada de Upload para o TUS.\r\n *\r\n * Possui alguns facilidades:\r\n * - Unifica e consolida os eventos de onProgress e onChunkComplete do TUS em um único evento.\r\n * - Suporta multiplos uploads.\r\n * - Controle genérico de erros.\r\n */\r\nexport default class UploadFacade {\r\n  /**\r\n   * Evento de erro.\r\n   * @event on-error\r\n   * @type {Error}\r\n   */\r\n  /**\r\n   * Evento de progresso.\r\n   * @event on-progress\r\n   * @type {Object}\r\n   * @property {File} file Arquivo.\r\n   * @property {Number} bytesSent Bytes enviados.\r\n   * @property {Number} percentageSent Porcentagem de envio.\r\n   * @property {Number} acceptedBytes Bytes aceitos pelo servidor (envio bem sucedido).\r\n   * @property {Number} percentageAccepted Porcentagem recebida/aceita no servidor.\r\n   * @property {Number} totalBytes Total de bytes.\r\n   */\r\n  /**\r\n   * Evento de upload concluído com sucesso.\r\n   * @event on-success\r\n   */\r\n  /**\r\n   * Id de arquivo recuperado.\r\n   * @event retrieved-file-id\r\n   * @type {Object}\r\n   * @property {File} file Arquivo.\r\n   * @property {String} id Id do arquivo.\r\n   */\r\n\r\n  /**\r\n   * Url\r\n   * @type {String}\r\n   * @readonly\r\n   */\r\n  url\r\n\r\n  /**\r\n   * Iniciar uploads automaticamente.\r\n   * @type {Boolean}\r\n   */\r\n  autoStart\r\n\r\n  /**\r\n   * Configurações do controle geral de erros.\r\n   * @type {Object}\r\n   */\r\n  errorHandling\r\n\r\n  /**\r\n   * Constrói uma fachada de Upload para o TUS.\r\n   * @param {Object} param Parâmetros de construção do Uploader.\r\n   * @param {String} param.url Url. Ver doc. da propriedade.\r\n   * @param {Object} [param.listeners] Definição de ouvintes.\r\n   * @param {any} [param.listenersScope] Escopo dos ouvintes.\r\n   * @param {Boolean} [param.autoStart] Auto iniciar. Ver doc. da propriedade.\r\n   * @param {File[]} [param.files] Arquivos para upload. Opcional, arquivos podem ser adicionados\r\n   * posteriomente.\r\n   */\r\n  constructor({\r\n    url,\r\n    listeners,\r\n    listenersScope,\r\n    files,\r\n    autoStart = true,\r\n    errorHandling = {},\r\n  }) {\r\n    Object.assign(this, new EventBus().createObservableProxy());\r\n\r\n    if (listeners) {\r\n      this.onEach(listeners, listenersScope);\r\n    }\r\n\r\n    this.fileUploads = [];\r\n    this.url = getFinalUrl(url);\r\n    this.autoStart = autoStart;\r\n    this.errorHandling = errorHandling || {};\r\n\r\n    if (files) {\r\n      this.appendFile(...files);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Adiciona um arquivo a listagem de uploads.\r\n   * Inicia automaticamente o upload caso esteja configurado o autoStart=true.\r\n   * @param {...File} files Arquivos\r\n   */\r\n  appendFile(...files) {\r\n    files.forEach((file) => {\r\n      const fileData = {\r\n        file,\r\n        bytesSent: 0,\r\n        percentageSent: 0,\r\n        acceptedBytes: 0,\r\n        percentageAccepted: 0,\r\n        totalBytes: null,\r\n        upload: uploadBuilder(file, {\r\n          endpoint: this.url,\r\n          onProgress: (...args) => this.handleOnProgress(fileData, 'progress', ...args),\r\n          onChunkComplete: (...args) => this.handleOnProgress(fileData, 'chunkComplete', ...args),\r\n          onSuccess: (...args) => this.emit('on-success', file, ...args),\r\n          onError: (...args) => this.handleOnError(fileData, ...args),\r\n        }),\r\n      };\r\n      this.fileUploads.push(fileData);\r\n\r\n      if (this.autoStart) {\r\n        fileData.upload.start();\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Inicia ou continua o upload de um arquivo em específico.\r\n   * @param {File} file Arquivo.\r\n   */\r\n  start(file) {\r\n    const fileData = this.getFileData(file);\r\n    startFileData(fileData);\r\n  }\r\n\r\n  /**\r\n   * Inicia ou continua todos os uploads.\r\n   */\r\n  startAll() {\r\n    this.fileUploads.forEach(startFileData);\r\n  }\r\n\r\n  /**\r\n   * Para o upload de um arquivo.\r\n   * @param {File} file Arquivo.\r\n   * @param {Boolean} [terminate=true] Terminar o upload e remover arquivo. Se false, apenas pausa.\r\n   * @returns {Promise}\r\n   */\r\n  stop(file, terminate = true) {\r\n    const fileData = this.getFileData(file);\r\n    return this.stopFileData(fileData, terminate);\r\n  }\r\n\r\n  /**\r\n   * Para todos os uploads.\r\n   * @param {Boolean} [terminate=true] Terminar o upload e remover arquivos. Se false, apenas pausa.\r\n   * @returns {Promise}\r\n   */\r\n  stopAll(terminate = true) {\r\n    return Promise.all(this.fileUploads.map(fileData => this.stopFileData(fileData, terminate)));\r\n  }\r\n\r\n  // ==== Membros privados daqui em diante ====\r\n\r\n  /**\r\n   * @private\r\n   * Para um upload a partir dos dados do arquivo.\r\n   * Remove da lista caso seja para finalizar (terminate).\r\n   * @param {Object} fileData Dados do arquivo.\r\n   * @param {Boolean} terminate Terminar o upload.\r\n   */\r\n  stopFileData(fileData, terminate) {\r\n    if (terminate) {\r\n      this.fileUploads.splice(this.fileUploads.indexOf(fileData), 1);\r\n    }\r\n\r\n    return new Promise((resolve, reject) => {\r\n      fileData.upload.abort(terminate, (error) => {\r\n        if (error && !error.message.includes(TUS_TERMINATION_NOT_SUPPORTED_ERROR)) {\r\n          handleTusResponseError(this.errorHandling, error);\r\n          reject(error);\r\n          return;\r\n        }\r\n\r\n        resolve();\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * @private\r\n   * Dados dos arquivos de upload.\r\n   * @type {Object[]}\r\n   * @property {File} fileUploads[].file Arquivo.\r\n   * @property {Number} fileUploads[].bytesSent Bytes enviados.\r\n   * @property {Number} fileUploads[].percentageSent Porcentagem de envio.\r\n   * @property {Number} fileUploads[].acceptedBytes Bytes recebidos pelo servidor.\r\n   * @property {Number} fileUploads[].percentageAccepted Porcentagem de recebimento.\r\n   * @property {Number} fileUploads[].totalBytes Total de bytes do envio.\r\n   * @property {tus.Upload} fileUploads[].upload Upload do TUS.\r\n   */\r\n  fileUploads\r\n\r\n  /**\r\n   * @private\r\n   * Retorna os dados de arquivo a partir de um File.\r\n   * @param {File} file Arquivo;\r\n   */\r\n  getFileData(file) {\r\n    return this.fileUploads.find(({ file: managedFile }) => managedFile === file);\r\n  }\r\n\r\n  /**\r\n   * @private\r\n   * Controla o progresso de upload.\r\n   * @param {Object} fileData Dados do arquivo.\r\n   * @param {String} event Evento que disparou.\r\n   * @param  {...any} eventArgs Argumentos do evento.\r\n   */\r\n  handleOnProgress(fileData, event, ...eventArgs) {\r\n    /* eslint-disable no-param-reassign */\r\n    if (fileData.fileId == null) {\r\n      fileData.fileId = getFileId(fileData.upload);\r\n      this.emit('retrieved-file-id', { file: fileData.file, id: fileData.fileId });\r\n    }\r\n\r\n    switch (event) {\r\n      case 'progress':\r\n        // eventArgs = [bytesSent, bytesTotal]\r\n        [fileData.bytesSent, fileData.totalBytes] = eventArgs;\r\n        fileData.percentageSent = getPercent(fileData.bytesSent, fileData.totalBytes);\r\n        break;\r\n      case 'chunkComplete':\r\n        // eventArgs = [chunkSize, bytesAccepted, bytesTotal]\r\n        [, fileData.acceptedBytes, fileData.totalBytes] = eventArgs;\r\n        fileData.percentageAccepted = getPercent(fileData.acceptedBytes, fileData.totalBytes);\r\n        break;\r\n      default:\r\n        throw new Error(`Not supported event: ${event}`);\r\n    }\r\n    /* eslint-enable no-param-reassign */\r\n\r\n    this.emit('on-progress', {\r\n      file: fileData.file,\r\n      bytesSent: fileData.bytesSent,\r\n      percentageSent: fileData.percentageSent,\r\n      acceptedBytes: fileData.acceptedBytes,\r\n      percentageAccepted: fileData.percentageAccepted,\r\n      totalBytes: fileData.totalBytes,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * @private\r\n   * Controla erros de upload.\r\n   * @param {Object} fileData Dados do arquivo.\r\n   * @param  {any} errorEvent Argumentos do evento de erro.\r\n   */\r\n  handleOnError({ file }, errorEvent) {\r\n    handleTusResponseError(this.errorHandling, errorEvent);\r\n\r\n    this.emit('on-error', file, errorEvent);\r\n  }\r\n}\r\n","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\nmodule.exports = copyArray;\n","var identity = require('./identity'),\n    overRest = require('./_overRest'),\n    setToString = require('./_setToString');\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\nmodule.exports = baseRest;\n","var eq = require('./eq'),\n    isArrayLike = require('./isArrayLike'),\n    isIndex = require('./_isIndex'),\n    isObject = require('./isObject');\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\n}\n\nmodule.exports = isIterateeCall;\n","var apply = require('./_apply');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\nmodule.exports = overRest;\n","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , undef;\n\n/**\n * Decode a URI encoded string.\n *\n * @param {String} input The URI encoded string.\n * @returns {String|Null} The decoded string.\n * @api private\n */\nfunction decode(input) {\n  try {\n    return decodeURIComponent(input.replace(/\\+/g, ' '));\n  } catch (e) {\n    return null;\n  }\n}\n\n/**\n * Attempts to encode a given input.\n *\n * @param {String} input The string that needs to be encoded.\n * @returns {String|Null} The encoded string.\n * @api private\n */\nfunction encode(input) {\n  try {\n    return encodeURIComponent(input);\n  } catch (e) {\n    return null;\n  }\n}\n\n/**\n * Simple query string parser.\n *\n * @param {String} query The query string that needs to be parsed.\n * @returns {Object}\n * @api public\n */\nfunction querystring(query) {\n  var parser = /([^=?&]+)=?([^&]*)/g\n    , result = {}\n    , part;\n\n  while (part = parser.exec(query)) {\n    var key = decode(part[1])\n      , value = decode(part[2]);\n\n    //\n    // Prevent overriding of existing properties. This ensures that build-in\n    // methods like `toString` or __proto__ are not overriden by malicious\n    // querystrings.\n    //\n    // In the case if failed decoding, we want to omit the key/value pairs\n    // from the result.\n    //\n    if (key === null || value === null || key in result) continue;\n    result[key] = value;\n  }\n\n  return result;\n}\n\n/**\n * Transform a query string to an object.\n *\n * @param {Object} obj Object that should be transformed.\n * @param {String} prefix Optional prefix.\n * @returns {String}\n * @api public\n */\nfunction querystringify(obj, prefix) {\n  prefix = prefix || '';\n\n  var pairs = []\n    , value\n    , key;\n\n  //\n  // Optionally prefix with a '?' if needed\n  //\n  if ('string' !== typeof prefix) prefix = '?';\n\n  for (key in obj) {\n    if (has.call(obj, key)) {\n      value = obj[key];\n\n      //\n      // Edge cases where we actually want to encode the value to an empty\n      // string instead of the stringified value.\n      //\n      if (!value && (value === null || value === undef || isNaN(value))) {\n        value = '';\n      }\n\n      key = encodeURIComponent(key);\n      value = encodeURIComponent(value);\n\n      //\n      // If we failed to encode the strings, we should bail out as we don't\n      // want to add invalid strings to the query.\n      //\n      if (key === null || value === null) continue;\n      pairs.push(key +'='+ value);\n    }\n  }\n\n  return pairs.length ? prefix + pairs.join('&') : '';\n}\n\n//\n// Expose the module.\n//\nexports.stringify = querystringify;\nexports.parse = querystring;\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = fingerprint;\n\nvar _isReactNative = require(\"./isReactNative\");\n\nvar _isReactNative2 = _interopRequireDefault(_isReactNative);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Generate a fingerprint for a file which will be used the store the endpoint\n *\n * @param {File} file\n * @param {Object} options\n * @param {Function} callback\n */\nfunction fingerprint(file, options, callback) {\n  if ((0, _isReactNative2.default)()) {\n    return callback(null, reactNativeFingerprint(file, options));\n  }\n\n  return callback(null, [\"tus-br\", file.name, file.type, file.size, file.lastModified, options.endpoint].join(\"-\"));\n}\n\nfunction reactNativeFingerprint(file, options) {\n  var exifHash = file.exif ? hashCode(JSON.stringify(file.exif)) : \"noexif\";\n  return [\"tus-rn\", file.name || \"noname\", file.size || \"nosize\", exifHash, options.endpoint].join(\"/\");\n}\n\nfunction hashCode(str) {\n  // from https://stackoverflow.com/a/8831937/151666\n  var hash = 0;\n  if (str.length === 0) {\n    return hash;\n  }\n  for (var i = 0; i < str.length; i++) {\n    var char = str.charCodeAt(i);\n    hash = (hash << 5) - hash + char;\n    hash = hash & hash; // Convert to 32bit integer\n  }\n  return hash;\n}","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignMergeValue;\n","import mod from \"-!../../../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Dropzone.vue?vue&type=style&index=0&id=9a7d86dc&lang=sass&scoped=true&\"; export default mod; export * from \"-!../../../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--9-oneOf-1-0!../../../../node_modules/css-loader/dist/cjs.js??ref--9-oneOf-1-1!../../../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../../../node_modules/postcss-loader/src/index.js??ref--9-oneOf-1-2!../../../../node_modules/sass-loader/dist/cjs.js??ref--9-oneOf-1-3!../../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Dropzone.vue?vue&type=style&index=0&id=9a7d86dc&lang=sass&scoped=true&\"","var assignMergeValue = require('./_assignMergeValue'),\n    cloneBuffer = require('./_cloneBuffer'),\n    cloneTypedArray = require('./_cloneTypedArray'),\n    copyArray = require('./_copyArray'),\n    initCloneObject = require('./_initCloneObject'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isArrayLikeObject = require('./isArrayLikeObject'),\n    isBuffer = require('./isBuffer'),\n    isFunction = require('./isFunction'),\n    isObject = require('./isObject'),\n    isPlainObject = require('./isPlainObject'),\n    isTypedArray = require('./isTypedArray'),\n    safeGet = require('./_safeGet'),\n    toPlainObject = require('./toPlainObject');\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = safeGet(object, key),\n      srcValue = safeGet(source, key),\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n        isBuff = !isArr && isBuffer(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      }\n      else if (!isObject(objValue) || isFunction(objValue)) {\n        newValue = initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  assignMergeValue(object, key, newValue);\n}\n\nmodule.exports = baseMergeDeep;\n","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignValue;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nvar isCordova = function isCordova() {\n  return typeof window != \"undefined\" && (typeof window.PhoneGap != \"undefined\" || typeof window.Cordova != \"undefined\" || typeof window.cordova != \"undefined\");\n};\n\nexports.default = isCordova;","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\nmodule.exports = constant;\n","/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\nmodule.exports = shortOut;\n","var isObject = require('./isObject'),\n    isPrototype = require('./_isPrototype'),\n    nativeKeysIn = require('./_nativeKeysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeysIn;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nexports.getSource = getSource;\n\nvar _isReactNative = require(\"./isReactNative\");\n\nvar _isReactNative2 = _interopRequireDefault(_isReactNative);\n\nvar _uriToBlob = require(\"./uriToBlob\");\n\nvar _uriToBlob2 = _interopRequireDefault(_uriToBlob);\n\nvar _isCordova = require(\"./isCordova\");\n\nvar _isCordova2 = _interopRequireDefault(_isCordova);\n\nvar _readAsByteArray = require(\"./readAsByteArray\");\n\nvar _readAsByteArray2 = _interopRequireDefault(_readAsByteArray);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar FileSource = function () {\n  function FileSource(file) {\n    _classCallCheck(this, FileSource);\n\n    this._file = file;\n    this.size = file.size;\n  }\n\n  _createClass(FileSource, [{\n    key: \"slice\",\n    value: function slice(start, end, callback) {\n      // In Apache Cordova applications, a File must be resolved using\n      // FileReader instances, see\n      // https://cordova.apache.org/docs/en/8.x/reference/cordova-plugin-file/index.html#read-a-file\n      if ((0, _isCordova2.default)()) {\n        (0, _readAsByteArray2.default)(this._file.slice(start, end), function (err, chunk) {\n          if (err) return callback(err);\n\n          callback(null, chunk);\n        });\n        return;\n      }\n\n      callback(null, this._file.slice(start, end));\n    }\n  }, {\n    key: \"close\",\n    value: function close() {}\n  }]);\n\n  return FileSource;\n}();\n\nvar StreamSource = function () {\n  function StreamSource(reader, chunkSize) {\n    _classCallCheck(this, StreamSource);\n\n    this._chunkSize = chunkSize;\n    this._buffer = undefined;\n    this._bufferOffset = 0;\n    this._reader = reader;\n    this._done = false;\n  }\n\n  _createClass(StreamSource, [{\n    key: \"slice\",\n    value: function slice(start, end, callback) {\n      if (start < this._bufferOffset) {\n        callback(new Error(\"Requested data is before the reader's current offset\"));\n        return;\n      }\n\n      return this._readUntilEnoughDataOrDone(start, end, callback);\n    }\n  }, {\n    key: \"_readUntilEnoughDataOrDone\",\n    value: function _readUntilEnoughDataOrDone(start, end, callback) {\n      var _this = this;\n\n      var hasEnoughData = end <= this._bufferOffset + len(this._buffer);\n      if (this._done || hasEnoughData) {\n        var value = this._getDataFromBuffer(start, end);\n        callback(null, value, value == null ? this._done : false);\n        return;\n      }\n      this._reader.read().then(function (_ref) {\n        var value = _ref.value,\n            done = _ref.done;\n\n        if (done) {\n          _this._done = true;\n        } else if (_this._buffer === undefined) {\n          _this._buffer = value;\n        } else {\n          _this._buffer = concat(_this._buffer, value);\n        }\n\n        _this._readUntilEnoughDataOrDone(start, end, callback);\n      }).catch(function (err) {\n        callback(new Error(\"Error during read: \" + err));\n      });\n    }\n  }, {\n    key: \"_getDataFromBuffer\",\n    value: function _getDataFromBuffer(start, end) {\n      // Remove data from buffer before `start`.\n      // Data might be reread from the buffer if an upload fails, so we can only\n      // safely delete data when it comes *before* what is currently being read.\n      if (start > this._bufferOffset) {\n        this._buffer = this._buffer.slice(start - this._bufferOffset);\n        this._bufferOffset = start;\n      }\n      // If the buffer is empty after removing old data, all data has been read.\n      var hasAllDataBeenRead = len(this._buffer) === 0;\n      if (this._done && hasAllDataBeenRead) {\n        return null;\n      }\n      // We already removed data before `start`, so we just return the first\n      // chunk from the buffer.\n      return this._buffer.slice(0, end - start);\n    }\n  }, {\n    key: \"close\",\n    value: function close() {\n      if (this._reader.cancel) {\n        this._reader.cancel();\n      }\n    }\n  }]);\n\n  return StreamSource;\n}();\n\nfunction len(blobOrArray) {\n  if (blobOrArray === undefined) return 0;\n  if (blobOrArray.size !== undefined) return blobOrArray.size;\n  return blobOrArray.length;\n}\n\n/*\n  Typed arrays and blobs don't have a concat method.\n  This function helps StreamSource accumulate data to reach chunkSize.\n*/\nfunction concat(a, b) {\n  if (a.concat) {\n    // Is `a` an Array?\n    return a.concat(b);\n  }\n  if (a instanceof Blob) {\n    return new Blob([a, b], { type: a.type });\n  }\n  if (a.set) {\n    // Is `a` a typed array?\n    var c = new a.constructor(a.length + b.length);\n    c.set(a);\n    c.set(b, a.length);\n    return c;\n  }\n  throw new Error(\"Unknown data type\");\n}\n\nfunction getSource(input, chunkSize, callback) {\n  // In React Native, when user selects a file, instead of a File or Blob,\n  // you usually get a file object {} with a uri property that contains\n  // a local path to the file. We use XMLHttpRequest to fetch\n  // the file blob, before uploading with tus.\n  if ((0, _isReactNative2.default)() && input && typeof input.uri !== \"undefined\") {\n    (0, _uriToBlob2.default)(input.uri, function (err, blob) {\n      if (err) {\n        return callback(new Error(\"tus: cannot fetch `file.uri` as Blob, make sure the uri is correct and accessible. \" + err));\n      }\n      callback(null, new FileSource(blob));\n    });\n    return;\n  }\n\n  // Since we emulate the Blob type in our tests (not all target browsers\n  // support it), we cannot use `instanceof` for testing whether the input value\n  // can be handled. Instead, we simply check is the slice() function and the\n  // size property are available.\n  if (typeof input.slice === \"function\" && typeof input.size !== \"undefined\") {\n    callback(null, new FileSource(input));\n    return;\n  }\n\n  if (typeof input.read === \"function\") {\n    chunkSize = +chunkSize;\n    if (!isFinite(chunkSize)) {\n      callback(new Error(\"cannot create source for stream without a finite value for the `chunkSize` option\"));\n      return;\n    }\n    callback(null, new StreamSource(input, chunkSize));\n    return;\n  }\n\n  callback(new Error(\"source object may only be an instance of File, Blob, or Reader in this environment\"));\n}","var baseCreate = require('./_baseCreate'),\n    getPrototype = require('./_getPrototype'),\n    isPrototype = require('./_isPrototype');\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\nmodule.exports = initCloneObject;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar DetailedError = function (_Error) {\n  _inherits(DetailedError, _Error);\n\n  function DetailedError(error) {\n    var causingErr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n    var xhr = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n\n    _classCallCheck(this, DetailedError);\n\n    var _this = _possibleConstructorReturn(this, (DetailedError.__proto__ || Object.getPrototypeOf(DetailedError)).call(this, error.message));\n\n    _this.originalRequest = xhr;\n    _this.causingError = causingErr;\n\n    var message = error.message;\n    if (causingErr != null) {\n      message += \", caused by \" + causingErr.toString();\n    }\n    if (xhr != null) {\n      message += \", originated from request (response code: \" + xhr.status + \", response text: \" + xhr.responseText + \")\";\n    }\n    _this.message = message;\n    return _this;\n  }\n\n  return DetailedError;\n}(Error);\n\nexports.default = DetailedError;","/*\n *  base64.js\n *\n *  Licensed under the BSD 3-Clause License.\n *    http://opensource.org/licenses/BSD-3-Clause\n *\n *  References:\n *    http://en.wikipedia.org/wiki/Base64\n */\n;(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined'\n        ? module.exports = factory(global)\n        : typeof define === 'function' && define.amd\n        ? define(factory) : factory(global)\n}((\n    typeof self !== 'undefined' ? self\n        : typeof window !== 'undefined' ? window\n        : typeof global !== 'undefined' ? global\n: this\n), function(global) {\n    'use strict';\n    // existing version for noConflict()\n    global = global || {};\n    var _Base64 = global.Base64;\n    var version = \"2.5.2\";\n    // if node.js and NOT React Native, we use Buffer\n    var buffer;\n    if (typeof module !== 'undefined' && module.exports) {\n        try {\n            buffer = eval(\"require('buffer').Buffer\");\n        } catch (err) {\n            buffer = undefined;\n        }\n    }\n    // constants\n    var b64chars\n        = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n    var b64tab = function(bin) {\n        var t = {};\n        for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;\n        return t;\n    }(b64chars);\n    var fromCharCode = String.fromCharCode;\n    // encoder stuff\n    var cb_utob = function(c) {\n        if (c.length < 2) {\n            var cc = c.charCodeAt(0);\n            return cc < 0x80 ? c\n                : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))\n                                + fromCharCode(0x80 | (cc & 0x3f)))\n                : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))\n                    + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))\n                    + fromCharCode(0x80 | ( cc         & 0x3f)));\n        } else {\n            var cc = 0x10000\n                + (c.charCodeAt(0) - 0xD800) * 0x400\n                + (c.charCodeAt(1) - 0xDC00);\n            return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))\n                    + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))\n                    + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))\n                    + fromCharCode(0x80 | ( cc         & 0x3f)));\n        }\n    };\n    var re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n    var utob = function(u) {\n        return u.replace(re_utob, cb_utob);\n    };\n    var cb_encode = function(ccc) {\n        var padlen = [0, 2, 1][ccc.length % 3],\n        ord = ccc.charCodeAt(0) << 16\n            | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)\n            | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),\n        chars = [\n            b64chars.charAt( ord >>> 18),\n            b64chars.charAt((ord >>> 12) & 63),\n            padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),\n            padlen >= 1 ? '=' : b64chars.charAt(ord & 63)\n        ];\n        return chars.join('');\n    };\n    var btoa = global.btoa ? function(b) {\n        return global.btoa(b);\n    } : function(b) {\n        return b.replace(/[\\s\\S]{1,3}/g, cb_encode);\n    };\n    var _encode = function(u) {\n        var isUint8Array = Object.prototype.toString.call(u) === '[object Uint8Array]';\n        return isUint8Array ? u.toString('base64')\n            : btoa(utob(String(u)));\n    }\n    var encode = function(u, urisafe) {\n        return !urisafe\n            ? _encode(u)\n            : _encode(String(u)).replace(/[+\\/]/g, function(m0) {\n                return m0 == '+' ? '-' : '_';\n            }).replace(/=/g, '');\n    };\n    var encodeURI = function(u) { return encode(u, true) };\n    // decoder stuff\n    var re_btou = /[\\xC0-\\xDF][\\x80-\\xBF]|[\\xE0-\\xEF][\\x80-\\xBF]{2}|[\\xF0-\\xF7][\\x80-\\xBF]{3}/g;\n    var cb_btou = function(cccc) {\n        switch(cccc.length) {\n        case 4:\n            var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n                |    ((0x3f & cccc.charCodeAt(1)) << 12)\n                |    ((0x3f & cccc.charCodeAt(2)) <<  6)\n                |     (0x3f & cccc.charCodeAt(3)),\n            offset = cp - 0x10000;\n            return (fromCharCode((offset  >>> 10) + 0xD800)\n                    + fromCharCode((offset & 0x3FF) + 0xDC00));\n        case 3:\n            return fromCharCode(\n                ((0x0f & cccc.charCodeAt(0)) << 12)\n                    | ((0x3f & cccc.charCodeAt(1)) << 6)\n                    |  (0x3f & cccc.charCodeAt(2))\n            );\n        default:\n            return  fromCharCode(\n                ((0x1f & cccc.charCodeAt(0)) << 6)\n                    |  (0x3f & cccc.charCodeAt(1))\n            );\n        }\n    };\n    var btou = function(b) {\n        return b.replace(re_btou, cb_btou);\n    };\n    var cb_decode = function(cccc) {\n        var len = cccc.length,\n        padlen = len % 4,\n        n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)\n            | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)\n            | (len > 2 ? b64tab[cccc.charAt(2)] <<  6 : 0)\n            | (len > 3 ? b64tab[cccc.charAt(3)]       : 0),\n        chars = [\n            fromCharCode( n >>> 16),\n            fromCharCode((n >>>  8) & 0xff),\n            fromCharCode( n         & 0xff)\n        ];\n        chars.length -= [0, 0, 2, 1][padlen];\n        return chars.join('');\n    };\n    var _atob = global.atob ? function(a) {\n        return global.atob(a);\n    } : function(a){\n        return a.replace(/\\S{1,4}/g, cb_decode);\n    };\n    var atob = function(a) {\n        return _atob(String(a).replace(/[^A-Za-z0-9\\+\\/]/g, ''));\n    };\n    var _decode = buffer ?\n        buffer.from && Uint8Array && buffer.from !== Uint8Array.from\n        ? function(a) {\n            return (a.constructor === buffer.constructor\n                    ? a : buffer.from(a, 'base64')).toString();\n        }\n        : function(a) {\n            return (a.constructor === buffer.constructor\n                    ? a : new buffer(a, 'base64')).toString();\n        }\n        : function(a) { return btou(_atob(a)) };\n    var decode = function(a){\n        return _decode(\n            String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })\n                .replace(/[^A-Za-z0-9\\+\\/]/g, '')\n        );\n    };\n    var noConflict = function() {\n        var Base64 = global.Base64;\n        global.Base64 = _Base64;\n        return Base64;\n    };\n    // export Base64\n    global.Base64 = {\n        VERSION: version,\n        atob: atob,\n        btoa: btoa,\n        fromBase64: decode,\n        toBase64: encode,\n        utob: utob,\n        encode: encode,\n        encodeURI: encodeURI,\n        btou: btou,\n        decode: decode,\n        noConflict: noConflict,\n        __buffer__: buffer\n    };\n    // if ES5 is available, make Base64.extendString() available\n    if (typeof Object.defineProperty === 'function') {\n        var noEnum = function(v){\n            return {value:v,enumerable:false,writable:true,configurable:true};\n        };\n        global.Base64.extendString = function () {\n            Object.defineProperty(\n                String.prototype, 'fromBase64', noEnum(function () {\n                    return decode(this)\n                }));\n            Object.defineProperty(\n                String.prototype, 'toBase64', noEnum(function (urisafe) {\n                    return encode(this, urisafe)\n                }));\n            Object.defineProperty(\n                String.prototype, 'toBase64URI', noEnum(function () {\n                    return encode(this, true)\n                }));\n        };\n    }\n    //\n    // export Base64 to the namespace\n    //\n    if (global['Meteor']) { // Meteor.js\n        Base64 = global.Base64;\n    }\n    // module.exports and AMD are mutually exclusive.\n    // module.exports has precedence.\n    if (typeof module !== 'undefined' && module.exports) {\n        module.exports.Base64 = global.Base64;\n    }\n    else if (typeof define === 'function' && define.amd) {\n        // AMD. Register as an anonymous module.\n        define([], function(){ return global.Base64 });\n    }\n    // that's it!\n    return {Base64: global.Base64}\n}));\n\n","var isObject = require('./isObject');\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\nmodule.exports = baseCreate;\n","var baseRest = require('./_baseRest'),\n    isIterateeCall = require('./_isIterateeCall');\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\nmodule.exports = createAssigner;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n/**\n * readAsByteArray converts a File object to a Uint8Array.\n * This function is only used on the Apache Cordova platform.\n * See https://cordova.apache.org/docs/en/latest/reference/cordova-plugin-file/index.html#read-a-file\n */\nfunction readAsByteArray(chunk, callback) {\n  var reader = new FileReader();\n  reader.onload = function () {\n    callback(null, new Uint8Array(reader.result));\n  };\n  reader.onerror = function (err) {\n    callback(err);\n  };\n  reader.readAsArrayBuffer(chunk);\n}\n\nexports.default = readAsByteArray;","export function validateNamespaceOneDepthLevel(term) {\r\n  if (typeof term === 'string' && term.split('.').length >= 2) {\r\n    return;\r\n  }\r\n\r\n  throw new Error('Nome de evento inválido.\\nO nome do evento deve ser uma string com namespace'\r\n  + 'com pelo 1 nível de profundidade, exemplo: \"alarms.autorefresh\", \"mySigma.nonConfiguredArea\".');\r\n}\r\n\r\nconst emptyEventNameValidator = () => null;\r\n\r\n/**\r\n * Event Bus / Barramento de eventos\r\n *\r\n * Event bus simples para ouvintes e publicadores.\r\n *\r\n * Os nome de eventos usados aqui devem ser no formato \"namespace.evento\".\r\n * O namespace deve ter pelo menos 1 nível de profundidade a fim de evitar colisão de eventos,\r\n * exemplo: \"myData.save\", \"myData.load\", \"profile.save\".\r\n *\r\n * Os ouvintes devem ser funções formato \"function(...args: any[]): void\",\r\n * podendo ter 0 ou muitos argumentos passados no evento.\r\n */\r\nexport class EventBus {\r\n  /**\r\n   * @private\r\n   * Coleção de ouvintes de todos os eventos pendurados.\r\n   */\r\n  listenersCollection = null;\r\n\r\n  /**\r\n   * Validador de nomes de eventos;\r\n   * @readonly\r\n   */\r\n  eventNameValidator\r\n\r\n  /**\r\n   * Construtor base.\r\n   * @param {Function} [eventNameValidator] Função validadora de nomes de eventos.\r\n   */\r\n  constructor({ eventNameValidator } = {}) {\r\n    this.listenersCollection = {};\r\n    this.eventNameValidator = eventNameValidator || emptyEventNameValidator;\r\n  }\r\n\r\n  /**\r\n   * Adiciona um ouvinte a um evento.\r\n   * @param {String} eventName Nome do evento.\r\n   * @param {Function} fn Função ouvinte do evento.\r\n   * @param {Any} [scope] Escopo de execução (this) para a função ouvinte.\r\n   */\r\n  on(eventName, fn, scope = null) {\r\n    this.eventNameValidator(eventName);\r\n    this.getListeners(eventName).push({\r\n      fn,\r\n      scope,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Adiciona ouvintes a eventos em um objeto de definições.\r\n   * @param {Object} events Object de definições no formato { eventName: fn, ... }.\r\n   * @param {Any} [scope] Escopo de execução (this) para a função ouvinte.\r\n   */\r\n  onEach(events, scope = null) {\r\n    Object.keys(events).forEach(eventName => this.on(eventName, events[eventName], scope));\r\n  }\r\n\r\n  /**\r\n   * Remove um ouvinte de um evento. As referências passadas aqui devem ser as mesmas\r\n   * usadas para adicionar o ouvinte.\r\n   * @param {String} eventName Nome do evento.\r\n   * @param {Function} fn Função ouvinte do evento.\r\n   * @param {Any} [scope] Escopo de execução (this) para a função ouvinte.\r\n   */\r\n  off(eventName, fn, scope = null) {\r\n    const listeners = this.getListeners(eventName);\r\n    const index = listeners.findIndex(listener => listener.fn === fn\r\n      && listener.scope === scope);\r\n\r\n    if (index === -1) {\r\n      throw new Error(`Não é possível remover o ouvinte. Ouvinte não encontrado para o evento \"${\r\n        eventName\r\n      }\". Verifique a referência da função e do escopo.`);\r\n    }\r\n\r\n    listeners.splice(index, 1);\r\n    if (!listeners.length) {\r\n      this.clearListeners(eventName);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Emitir um evento através do barramento para todos os ouvintes.\r\n   * @param {String} eventName Nome do evento.\r\n   * @param  {...any} [args] Argumentos do evento. Podem ser omitidos para um evento sem\r\n   * parametros.\r\n   */\r\n  emit(eventName, ...args) {\r\n    if (this.hasListenersConfig(eventName)) {\r\n      this.getListeners(eventName)\r\n        .forEach(listener => listener.fn.call(listener.scope, ...args));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Método privado para uso interno.\r\n   * Retorna os ouvintes de um evento de maneira segura, evitando retornos nulos.\r\n   * @private\r\n   * @param {String} eventName Nome do evento.\r\n   * @returns {Object[]} Array de listeners do Evento.\r\n   */\r\n  getListeners(eventName) {\r\n    if (!this.hasListenersConfig(eventName)) {\r\n      this.listenersCollection[eventName] = [];\r\n    }\r\n    return this.listenersCollection[eventName];\r\n  }\r\n\r\n  /**\r\n   * Método privado para uso interno.\r\n   * Informa se há configuração de listeners para um evento.\r\n   * @private\r\n   * @param {String} eventName Nome do evento.\r\n   */\r\n  hasListenersConfig(eventName) {\r\n    return !!this.listenersCollection[eventName];\r\n  }\r\n\r\n  /**\r\n   * Método privado para uso interno.\r\n   * Limpa todos os ouvintes de um evento.\r\n   * @private\r\n   * @param {String} eventName Nome do evento.\r\n   */\r\n  clearListeners(eventName) {\r\n    delete this.listenersCollection[eventName];\r\n  }\r\n\r\n  /**\r\n   * Cria uma interface de procurador para um eventBus, expondo apenas os métodos relacionados\r\n   * a observação, como On, Off, Emit, e etc.\r\n   * @returns {Object}\r\n   */\r\n  createObservableProxy() {\r\n    return {\r\n      on: (...args) => this.on(...args),\r\n      onEach: (...args) => this.onEach(...args),\r\n      off: (...args) => this.off(...args),\r\n      emit: (...args) => this.emit(...args),\r\n    };\r\n  }\r\n}\r\n\r\n/**\r\n * Barramento global de eventos.\r\n */\r\nexport default new EventBus({ eventNameValidator: validateNamespaceOneDepthLevel });\r\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeysIn = require('./_baseKeysIn'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nmodule.exports = keysIn;\n","/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\nmodule.exports = apply;\n","'use strict';\n\nvar required = require('requires-port')\n  , qs = require('querystringify')\n  , slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\\/\\//\n  , protocolre = /^([a-z][a-z0-9.+-]*:)?(\\/\\/)?([\\S\\s]*)/i\n  , whitespace = '[\\\\x09\\\\x0A\\\\x0B\\\\x0C\\\\x0D\\\\x20\\\\xA0\\\\u1680\\\\u180E\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200A\\\\u202F\\\\u205F\\\\u3000\\\\u2028\\\\u2029\\\\uFEFF]'\n  , left = new RegExp('^'+ whitespace +'+');\n\n/**\n * Trim a given string.\n *\n * @param {String} str String to trim.\n * @public\n */\nfunction trimLeft(str) {\n  return (str ? str : '').toString().replace(left, '');\n}\n\n/**\n * These are the parse rules for the URL parser, it informs the parser\n * about:\n *\n * 0. The char it Needs to parse, if it's a string it should be done using\n *    indexOf, RegExp using exec and NaN means set as current value.\n * 1. The property we should set when parsing this value.\n * 2. Indication if it's backwards or forward parsing, when set as number it's\n *    the value of extra chars that should be split off.\n * 3. Inherit from location if non existing in the parser.\n * 4. `toLowerCase` the resulting value.\n */\nvar rules = [\n  ['#', 'hash'],                        // Extract from the back.\n  ['?', 'query'],                       // Extract from the back.\n  function sanitize(address) {          // Sanitize what is left of the address\n    return address.replace('\\\\', '/');\n  },\n  ['/', 'pathname'],                    // Extract from the back.\n  ['@', 'auth', 1],                     // Extract from the front.\n  [NaN, 'host', undefined, 1, 1],       // Set left over value.\n  [/:(\\d+)$/, 'port', undefined, 1],    // RegExp the back.\n  [NaN, 'hostname', undefined, 1, 1]    // Set left over.\n];\n\n/**\n * These properties should not be copied or inherited from. This is only needed\n * for all non blob URL's as a blob URL does not include a hash, only the\n * origin.\n *\n * @type {Object}\n * @private\n */\nvar ignore = { hash: 1, query: 1 };\n\n/**\n * The location object differs when your code is loaded through a normal page,\n * Worker or through a worker using a blob. And with the blobble begins the\n * trouble as the location object will contain the URL of the blob, not the\n * location of the page where our code is loaded in. The actual origin is\n * encoded in the `pathname` so we can thankfully generate a good \"default\"\n * location from it so we can generate proper relative URL's again.\n *\n * @param {Object|String} loc Optional default location object.\n * @returns {Object} lolcation object.\n * @public\n */\nfunction lolcation(loc) {\n  var globalVar;\n\n  if (typeof window !== 'undefined') globalVar = window;\n  else if (typeof global !== 'undefined') globalVar = global;\n  else if (typeof self !== 'undefined') globalVar = self;\n  else globalVar = {};\n\n  var location = globalVar.location || {};\n  loc = loc || location;\n\n  var finaldestination = {}\n    , type = typeof loc\n    , key;\n\n  if ('blob:' === loc.protocol) {\n    finaldestination = new Url(unescape(loc.pathname), {});\n  } else if ('string' === type) {\n    finaldestination = new Url(loc, {});\n    for (key in ignore) delete finaldestination[key];\n  } else if ('object' === type) {\n    for (key in loc) {\n      if (key in ignore) continue;\n      finaldestination[key] = loc[key];\n    }\n\n    if (finaldestination.slashes === undefined) {\n      finaldestination.slashes = slashes.test(loc.href);\n    }\n  }\n\n  return finaldestination;\n}\n\n/**\n * @typedef ProtocolExtract\n * @type Object\n * @property {String} protocol Protocol matched in the URL, in lowercase.\n * @property {Boolean} slashes `true` if protocol is followed by \"//\", else `false`.\n * @property {String} rest Rest of the URL that is not part of the protocol.\n */\n\n/**\n * Extract protocol information from a URL with/without double slash (\"//\").\n *\n * @param {String} address URL we want to extract from.\n * @return {ProtocolExtract} Extracted information.\n * @private\n */\nfunction extractProtocol(address) {\n  address = trimLeft(address);\n  var match = protocolre.exec(address);\n\n  return {\n    protocol: match[1] ? match[1].toLowerCase() : '',\n    slashes: !!match[2],\n    rest: match[3]\n  };\n}\n\n/**\n * Resolve a relative URL pathname against a base URL pathname.\n *\n * @param {String} relative Pathname of the relative URL.\n * @param {String} base Pathname of the base URL.\n * @return {String} Resolved pathname.\n * @private\n */\nfunction resolve(relative, base) {\n  if (relative === '') return base;\n\n  var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/'))\n    , i = path.length\n    , last = path[i - 1]\n    , unshift = false\n    , up = 0;\n\n  while (i--) {\n    if (path[i] === '.') {\n      path.splice(i, 1);\n    } else if (path[i] === '..') {\n      path.splice(i, 1);\n      up++;\n    } else if (up) {\n      if (i === 0) unshift = true;\n      path.splice(i, 1);\n      up--;\n    }\n  }\n\n  if (unshift) path.unshift('');\n  if (last === '.' || last === '..') path.push('');\n\n  return path.join('/');\n}\n\n/**\n * The actual URL instance. Instead of returning an object we've opted-in to\n * create an actual constructor as it's much more memory efficient and\n * faster and it pleases my OCD.\n *\n * It is worth noting that we should not use `URL` as class name to prevent\n * clashes with the global URL instance that got introduced in browsers.\n *\n * @constructor\n * @param {String} address URL we want to parse.\n * @param {Object|String} [location] Location defaults for relative paths.\n * @param {Boolean|Function} [parser] Parser for the query string.\n * @private\n */\nfunction Url(address, location, parser) {\n  address = trimLeft(address);\n\n  if (!(this instanceof Url)) {\n    return new Url(address, location, parser);\n  }\n\n  var relative, extracted, parse, instruction, index, key\n    , instructions = rules.slice()\n    , type = typeof location\n    , url = this\n    , i = 0;\n\n  //\n  // The following if statements allows this module two have compatibility with\n  // 2 different API:\n  //\n  // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments\n  //    where the boolean indicates that the query string should also be parsed.\n  //\n  // 2. The `URL` interface of the browser which accepts a URL, object as\n  //    arguments. The supplied object will be used as default values / fall-back\n  //    for relative paths.\n  //\n  if ('object' !== type && 'string' !== type) {\n    parser = location;\n    location = null;\n  }\n\n  if (parser && 'function' !== typeof parser) parser = qs.parse;\n\n  location = lolcation(location);\n\n  //\n  // Extract protocol information before running the instructions.\n  //\n  extracted = extractProtocol(address || '');\n  relative = !extracted.protocol && !extracted.slashes;\n  url.slashes = extracted.slashes || relative && location.slashes;\n  url.protocol = extracted.protocol || location.protocol || '';\n  address = extracted.rest;\n\n  //\n  // When the authority component is absent the URL starts with a path\n  // component.\n  //\n  if (!extracted.slashes) instructions[3] = [/(.*)/, 'pathname'];\n\n  for (; i < instructions.length; i++) {\n    instruction = instructions[i];\n\n    if (typeof instruction === 'function') {\n      address = instruction(address);\n      continue;\n    }\n\n    parse = instruction[0];\n    key = instruction[1];\n\n    if (parse !== parse) {\n      url[key] = address;\n    } else if ('string' === typeof parse) {\n      if (~(index = address.indexOf(parse))) {\n        if ('number' === typeof instruction[2]) {\n          url[key] = address.slice(0, index);\n          address = address.slice(index + instruction[2]);\n        } else {\n          url[key] = address.slice(index);\n          address = address.slice(0, index);\n        }\n      }\n    } else if ((index = parse.exec(address))) {\n      url[key] = index[1];\n      address = address.slice(0, index.index);\n    }\n\n    url[key] = url[key] || (\n      relative && instruction[3] ? location[key] || '' : ''\n    );\n\n    //\n    // Hostname, host and protocol should be lowercased so they can be used to\n    // create a proper `origin`.\n    //\n    if (instruction[4]) url[key] = url[key].toLowerCase();\n  }\n\n  //\n  // Also parse the supplied query string in to an object. If we're supplied\n  // with a custom parser as function use that instead of the default build-in\n  // parser.\n  //\n  if (parser) url.query = parser(url.query);\n\n  //\n  // If the URL is relative, resolve the pathname against the base URL.\n  //\n  if (\n      relative\n    && location.slashes\n    && url.pathname.charAt(0) !== '/'\n    && (url.pathname !== '' || location.pathname !== '')\n  ) {\n    url.pathname = resolve(url.pathname, location.pathname);\n  }\n\n  //\n  // We should not add port numbers if they are already the default port number\n  // for a given protocol. As the host also contains the port number we're going\n  // override it with the hostname which contains no port number.\n  //\n  if (!required(url.port, url.protocol)) {\n    url.host = url.hostname;\n    url.port = '';\n  }\n\n  //\n  // Parse down the `auth` for the username and password.\n  //\n  url.username = url.password = '';\n  if (url.auth) {\n    instruction = url.auth.split(':');\n    url.username = instruction[0] || '';\n    url.password = instruction[1] || '';\n  }\n\n  url.origin = url.protocol && url.host && url.protocol !== 'file:'\n    ? url.protocol +'//'+ url.host\n    : 'null';\n\n  //\n  // The href is just the compiled result.\n  //\n  url.href = url.toString();\n}\n\n/**\n * This is convenience method for changing properties in the URL instance to\n * insure that they all propagate correctly.\n *\n * @param {String} part          Property we need to adjust.\n * @param {Mixed} value          The newly assigned value.\n * @param {Boolean|Function} fn  When setting the query, it will be the function\n *                               used to parse the query.\n *                               When setting the protocol, double slash will be\n *                               removed from the final url if it is true.\n * @returns {URL} URL instance for chaining.\n * @public\n */\nfunction set(part, value, fn) {\n  var url = this;\n\n  switch (part) {\n    case 'query':\n      if ('string' === typeof value && value.length) {\n        value = (fn || qs.parse)(value);\n      }\n\n      url[part] = value;\n      break;\n\n    case 'port':\n      url[part] = value;\n\n      if (!required(value, url.protocol)) {\n        url.host = url.hostname;\n        url[part] = '';\n      } else if (value) {\n        url.host = url.hostname +':'+ value;\n      }\n\n      break;\n\n    case 'hostname':\n      url[part] = value;\n\n      if (url.port) value += ':'+ url.port;\n      url.host = value;\n      break;\n\n    case 'host':\n      url[part] = value;\n\n      if (/:\\d+$/.test(value)) {\n        value = value.split(':');\n        url.port = value.pop();\n        url.hostname = value.join(':');\n      } else {\n        url.hostname = value;\n        url.port = '';\n      }\n\n      break;\n\n    case 'protocol':\n      url.protocol = value.toLowerCase();\n      url.slashes = !fn;\n      break;\n\n    case 'pathname':\n    case 'hash':\n      if (value) {\n        var char = part === 'pathname' ? '/' : '#';\n        url[part] = value.charAt(0) !== char ? char + value : value;\n      } else {\n        url[part] = value;\n      }\n      break;\n\n    default:\n      url[part] = value;\n  }\n\n  for (var i = 0; i < rules.length; i++) {\n    var ins = rules[i];\n\n    if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();\n  }\n\n  url.origin = url.protocol && url.host && url.protocol !== 'file:'\n    ? url.protocol +'//'+ url.host\n    : 'null';\n\n  url.href = url.toString();\n\n  return url;\n}\n\n/**\n * Transform the properties back in to a valid and full URL string.\n *\n * @param {Function} stringify Optional query stringify function.\n * @returns {String} Compiled version of the URL.\n * @public\n */\nfunction toString(stringify) {\n  if (!stringify || 'function' !== typeof stringify) stringify = qs.stringify;\n\n  var query\n    , url = this\n    , protocol = url.protocol;\n\n  if (protocol && protocol.charAt(protocol.length - 1) !== ':') protocol += ':';\n\n  var result = protocol + (url.slashes ? '//' : '');\n\n  if (url.username) {\n    result += url.username;\n    if (url.password) result += ':'+ url.password;\n    result += '@';\n  }\n\n  result += url.host + url.pathname;\n\n  query = 'object' === typeof url.query ? stringify(url.query) : url.query;\n  if (query) result += '?' !== query.charAt(0) ? '?'+ query : query;\n\n  if (url.hash) result += url.hash;\n\n  return result;\n}\n\nUrl.prototype = { set: set, toString: toString };\n\n//\n// Expose the URL parser and some additional properties that might be useful for\n// others or testing.\n//\nUrl.extractProtocol = extractProtocol;\nUrl.location = lolcation;\nUrl.trimLeft = trimLeft;\nUrl.qs = qs;\n\nmodule.exports = Url;\n","var copyObject = require('./_copyObject'),\n    keysIn = require('./keysIn');\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n\nmodule.exports = toPlainObject;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nmodule.exports = cloneTypedArray;\n","var baseSetToString = require('./_baseSetToString'),\n    shortOut = require('./_shortOut');\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nmodule.exports = setToString;\n","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('b-container',{attrs:{\"fluid\":\"\"}},[_c('b-row',{staticClass:\"dropzone__title mb-3 mt-3 mt-sm-0\"},[_c('label',{staticClass:\"text-center text-sm-left w-100 mb-0\"},[_vm._v(\"\\n      \"+_vm._s(_vm.title)+\"\\n    \")])]),_vm._v(\" \"),_c('b-row',{staticClass:\"dropzone__view\",on:{\"dragover\":function($event){$event.preventDefault();return _vm.dragHandler(true)},\"dragenter\":function($event){$event.preventDefault();return _vm.dragHandler(true)},\"dragleave\":function($event){$event.preventDefault();return _vm.dragHandler(false)},\"drop\":function($event){$event.preventDefault();return _vm.fileSelect($event.dataTransfer.files)}}},[_c('b-col',{staticClass:\"text-center\",attrs:{\"cols\":\"12\",\"align-self\":\"end\"}},[_c('label',[_vm._v(\"\\n        \"+_vm._s(_vm.$t('actions.drag-file'))+\"\\n      \")])]),_vm._v(\" \"),_c('b-col',{staticClass:\"text-center mt-3\",attrs:{\"cols\":\"12\"}},[_c('b-btn',{staticClass:\"dropzone__button\",attrs:{\"size\":\"sm\",\"variant\":\"outline-primary\"},on:{\"click\":_vm.openFileSelector}},[_vm._v(\"\\n        \"+_vm._s(_vm.$t('actions.select-file'))+\"\\n        \"),_c('input',{ref:\"fileInput\",staticClass:\"dropzone__hidden-input\",attrs:{\"multiple\":_vm.isMultipleUpload,\"accept\":_vm.inputAccept.join(','),\"type\":\"file\"},on:{\"change\":function($event){return _vm.fileSelect($event.target.files)}}})])],1)],1)],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","<template>\r\n  <b-container fluid>\r\n    <b-row class=\"dropzone__title mb-3 mt-3 mt-sm-0\">\r\n      <label class=\"text-center text-sm-left w-100 mb-0\">\r\n        {{ title }}\r\n      </label>\r\n    </b-row>\r\n    <b-row\r\n      class=\"dropzone__view\"\r\n      @dragover.prevent=\"dragHandler(true)\"\r\n      @dragenter.prevent=\"dragHandler(true)\"\r\n      @dragleave.prevent=\"dragHandler(false)\"\r\n      @drop.prevent=\"fileSelect($event.dataTransfer.files)\"\r\n    >\r\n      <b-col\r\n        cols=\"12\"\r\n        align-self=\"end\"\r\n        class=\"text-center\"\r\n      >\r\n        <label>\r\n          {{ $t('actions.drag-file') }}\r\n        </label>\r\n      </b-col>\r\n      <b-col\r\n        cols=\"12\"\r\n        class=\"text-center mt-3\"\r\n      >\r\n        <b-btn\r\n          size=\"sm\"\r\n          class=\"dropzone__button\"\r\n          variant=\"outline-primary\"\r\n          @click=\"openFileSelector\"\r\n        >\r\n          {{ $t('actions.select-file') }}\r\n          <input\r\n            :multiple=\"isMultipleUpload\"\r\n            @change=\"fileSelect($event.target.files)\"\r\n            :accept=\"inputAccept.join(',')\"\r\n            class=\"dropzone__hidden-input\"\r\n            type=\"file\"\r\n            ref=\"fileInput\"\r\n          />\r\n        </b-btn>\r\n      </b-col>\r\n    </b-row>\r\n  </b-container>\r\n</template>\r\n\r\n<script>\r\nexport default {\r\n  name: 'Dropzone',\r\n  props: {\r\n    inputAccept: {\r\n      type: Array,\r\n      required: true,\r\n    },\r\n    title: {\r\n      type: String,\r\n    },\r\n    isMultipleUpload: {\r\n      type: Boolean,\r\n      required: false,\r\n      default: true,\r\n    },\r\n  },\r\n  data: () => ({\r\n    drag: false,\r\n  }),\r\n  methods: {\r\n    dragHandler(value) {\r\n      this.drag = value;\r\n    },\r\n    openFileSelector() {\r\n      this.$refs.fileInput.click();\r\n    },\r\n    fileSelect(fileList) {\r\n      const fileListArray = [...fileList];\r\n\r\n      if (!fileList || !fileList.length > 0) {\r\n        return;\r\n      }\r\n\r\n      this.$refs.fileInput.value = '';\r\n\r\n      this.$emit('input', fileListArray);\r\n    },\r\n  },\r\n};\r\n</script>\r\n\r\n<style lang=\"sass\" scoped>\r\n  @import src/styles/defaults/variables\r\n\r\n  .dropzone\r\n    &__hidden-input\r\n      display: none\r\n    &__title\r\n      font-size: 1.2em\r\n    &__button\r\n      font-size: .9em\r\n      font-weight: bold\r\n    &__view\r\n      border-radius: 5px\r\n      padding: 15px\r\n      min-height: 200px\r\n      border: 2px dashed $color-gray-intermediary\r\n      font-size: 1.2em\r\n      color: $color-gray-intermediary\r\n</style>\r\n","import mod from \"-!../../../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../../../node_modules/thread-loader/dist/cjs.js!../../../../node_modules/babel-loader/lib/index.js!../../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Dropzone.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../../../node_modules/thread-loader/dist/cjs.js!../../../../node_modules/babel-loader/lib/index.js!../../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Dropzone.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./Dropzone.vue?vue&type=template&id=9a7d86dc&scoped=true&\"\nimport script from \"./Dropzone.vue?vue&type=script&lang=js&\"\nexport * from \"./Dropzone.vue?vue&type=script&lang=js&\"\nimport style0 from \"./Dropzone.vue?vue&type=style&index=0&id=9a7d86dc&lang=sass&scoped=true&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"9a7d86dc\",\n  null\n  \n)\n\nexport default component.exports","\"use strict\";\n\nvar _upload = require(\"./upload\");\n\nvar _upload2 = _interopRequireDefault(_upload);\n\nvar _storage = require(\"./node/storage\");\n\nvar storage = _interopRequireWildcard(_storage);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/* global window */\nvar defaultOptions = _upload2.default.defaultOptions;\n\n\nvar moduleExport = {\n  Upload: _upload2.default,\n  canStoreURLs: storage.canStoreURLs,\n  defaultOptions: defaultOptions\n};\n\nif (typeof window !== \"undefined\") {\n  // Browser environment using XMLHttpRequest\n  var _window = window,\n      XMLHttpRequest = _window.XMLHttpRequest,\n      Blob = _window.Blob;\n\n\n  moduleExport.isSupported = XMLHttpRequest && Blob && typeof Blob.prototype.slice === \"function\";\n} else {\n  // Node.js environment using http module\n  moduleExport.isSupported = true;\n  // make FileStorage module available as it will not be set by default.\n  moduleExport.FileStorage = storage.FileStorage;\n}\n\n// The usage of the commonjs exporting syntax instead of the new ECMAScript\n// one is actually inteded and prevents weird behaviour if we are trying to\n// import this module in another module using Babel.\nmodule.exports = moduleExport;","var constant = require('./constant'),\n    defineProperty = require('./_defineProperty'),\n    identity = require('./identity');\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\nmodule.exports = baseSetToString;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = nativeKeysIn;\n","'use strict';\n\n/**\n * Check if we're required to add a port number.\n *\n * @see https://url.spec.whatwg.org/#default-port\n * @param {Number|String} port Port number we need to check\n * @param {String} protocol Protocol we need to check against.\n * @returns {Boolean} Is it a default port for the given protocol\n * @api private\n */\nmodule.exports = function required(port, protocol) {\n  protocol = protocol.split(':')[0];\n  port = +port;\n\n  if (!port) return false;\n\n  switch (protocol) {\n    case 'http':\n    case 'ws':\n    return port !== 80;\n\n    case 'https':\n    case 'wss':\n    return port !== 443;\n\n    case 'ftp':\n    return port !== 21;\n\n    case 'gopher':\n    return port !== 70;\n\n    case 'file':\n    return false;\n  }\n\n  return port !== 0;\n};\n","var overArg = require('./_overArg');\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nmodule.exports = getPrototype;\n"],"sourceRoot":""}