{"version":3,"file":"67308b1af82682956f356e04.js?3.6.14.7428b935c.1723600572441","mappings":"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","sources":["webpack://mono-repo/./node_modules/tus-js-client/lib.esm/upload.js"],"sourcesContent":["function _regeneratorRuntime() { \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; }, $Symbol = \"function\" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || \"@@iterator\", asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\", toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, \"\"); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return defineProperty(generator, \"_invoke\", { value: makeInvokeMethod(innerFn, self, context) }), generator; } function tryCatch(fn, obj, arg) { try { return { type: \"normal\", arg: fn.call(obj, arg) }; } catch (err) { return { type: \"throw\", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { [\"next\", \"throw\", \"return\"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if (\"throw\" !== record.type) { var result = record.arg, value = result.value; return value && \"object\" == _typeof(value) && hasOwn.call(value, \"__await\") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke(\"next\", value, resolve, reject); }, function (err) { invoke(\"throw\", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke(\"throw\", error, resolve, reject); }); } reject(record.arg); } var previousPromise; defineProperty(this, \"_invoke\", { value: function value(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(innerFn, self, context) { var state = \"suspendedStart\"; return function (method, arg) { if (\"executing\" === state) throw new Error(\"Generator is already running\"); if (\"completed\" === state) { if (\"throw\" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if (\"next\" === context.method) context.sent = context._sent = context.arg;else if (\"throw\" === context.method) { if (\"suspendedStart\" === state) throw state = \"completed\", context.arg; context.dispatchException(context.arg); } else \"return\" === context.method && context.abrupt(\"return\", context.arg); state = \"executing\"; var record = tryCatch(innerFn, self, context); if (\"normal\" === record.type) { if (state = context.done ? \"completed\" : \"suspendedYield\", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } \"throw\" === record.type && (state = \"completed\", context.method = \"throw\", context.arg = record.arg); } }; } function maybeInvokeDelegate(delegate, context) { var methodName = context.method, method = delegate.iterator[methodName]; if (undefined === method) return context.delegate = null, \"throw\" === methodName && delegate.iterator[\"return\"] && (context.method = \"return\", context.arg = undefined, maybeInvokeDelegate(delegate, context), \"throw\" === context.method) || \"return\" !== methodName && (context.method = \"throw\", context.arg = new TypeError(\"The iterator does not provide a '\" + methodName + \"' method\")), ContinueSentinel; var record = tryCatch(method, delegate.iterator, context.arg); if (\"throw\" === record.type) return context.method = \"throw\", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, \"return\" !== context.method && (context.method = \"next\", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = \"throw\", context.arg = new TypeError(\"iterator result is not an object\"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = \"normal\", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: \"root\" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if (\"function\" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, \"constructor\", { value: GeneratorFunctionPrototype, configurable: !0 }), defineProperty(GeneratorFunctionPrototype, \"constructor\", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, \"GeneratorFunction\"), exports.isGeneratorFunction = function (genFun) { var ctor = \"function\" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || \"GeneratorFunction\" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, \"GeneratorFunction\")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, \"Generator\"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, \"toString\", function () { return \"[object Generator]\"; }), exports.keys = function (val) { var object = Object(val), keys = []; for (var key in object) keys.push(key); return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) \"t\" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if (\"throw\" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = \"throw\", record.arg = exception, context.next = loc, caught && (context.method = \"next\", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if (\"root\" === entry.tryLoc) return handle(\"end\"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, \"catchLoc\"), hasFinally = hasOwn.call(entry, \"finallyLoc\"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error(\"try statement without catch or finally\"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, \"finallyLoc\") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && (\"break\" === type || \"continue\" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = \"next\", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if (\"throw\" === record.type) throw record.arg; return \"break\" === record.type || \"continue\" === record.type ? this.next = record.arg : \"return\" === record.type ? (this.rval = this.arg = record.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, \"catch\": function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if (\"throw\" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error(\"illegal catch attempt\"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, \"next\" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }\nfunction _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err); } _next(undefined); }); }; }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i[\"return\"] && (_r = _i[\"return\"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _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, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport { Base64 } from 'js-base64';\nimport URL from 'url-parse';\nimport DetailedError from './error.js';\nimport { log } from './logger.js';\nimport uuid from './uuid.js';\nvar defaultOptions = {\n  endpoint: null,\n  uploadUrl: null,\n  metadata: {},\n  fingerprint: null,\n  uploadSize: null,\n  onProgress: null,\n  onChunkComplete: null,\n  onSuccess: null,\n  onError: null,\n  onUploadUrlAvailable: null,\n  overridePatchMethod: false,\n  headers: {},\n  addRequestId: false,\n  onBeforeRequest: null,\n  onAfterResponse: null,\n  onShouldRetry: null,\n  chunkSize: Infinity,\n  retryDelays: [0, 1000, 3000, 5000],\n  parallelUploads: 1,\n  parallelUploadBoundaries: null,\n  storeFingerprintForResuming: true,\n  removeFingerprintOnSuccess: false,\n  uploadLengthDeferred: false,\n  uploadDataDuringCreation: false,\n  urlStorage: null,\n  fileReader: null,\n  httpStack: null\n};\nvar BaseUpload = /*#__PURE__*/function () {\n  function BaseUpload(file, options) {\n    _classCallCheck(this, BaseUpload);\n    // Warn about removed options from previous versions\n    if ('resume' in options) {\n      console.log('tus: The `resume` option has been removed in tus-js-client v2. Please use the URL storage API instead.'); // eslint-disable-line no-console\n    }\n\n    // The default options will already be added from the wrapper classes.\n    this.options = options;\n\n    // Cast chunkSize to integer\n    this.options.chunkSize = Number(this.options.chunkSize);\n\n    // The storage module used to store URLs\n    this._urlStorage = 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 request object for the current PATCH request\n    this._req = null;\n\n    // The fingerpinrt for the current file (set after start())\n    this._fingerprint = null;\n\n    // The key that the URL storage returned when saving an URL with a fingerprint,\n    this._urlStorageKey = 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. Zero 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    // An array of BaseUpload instances which are used for uploading the different\n    // parts, if the parallelUploads option is used.\n    this._parallelUploads = null;\n\n    // An array of upload URLs which are used for uploading the different\n    // parts, if the parallelUploads option is used.\n    this._parallelUploadUrls = null;\n  }\n\n  /**\n   * Use the Termination extension to delete an upload from the server by sending a DELETE\n   * request to the specified upload URL. This is only possible if the server supports the\n   * Termination extension. If the `options.retryDelays` property is set, the method will\n   * also retry if an error ocurrs.\n   *\n   * @param {String} url The upload's URL which will be terminated.\n   * @param {object} options Optional options for influencing HTTP requests.\n   * @return {Promise} The Promise will be resolved/rejected when the requests finish.\n   */\n  _createClass(BaseUpload, [{\n    key: \"findPreviousUploads\",\n    value: function findPreviousUploads() {\n      var _this = this;\n      return this.options.fingerprint(this.file, this.options).then(function (fingerprint) {\n        return _this._urlStorage.findUploadsByFingerprint(fingerprint);\n      });\n    }\n  }, {\n    key: \"resumeFromPreviousUpload\",\n    value: function resumeFromPreviousUpload(previousUpload) {\n      this.url = previousUpload.uploadUrl || null;\n      this._parallelUploadUrls = previousUpload.parallelUploadUrls || null;\n      this._urlStorageKey = previousUpload.urlStorageKey;\n    }\n  }, {\n    key: \"start\",\n    value: function start() {\n      var _this2 = this;\n      var file = this.file;\n      if (!file) {\n        this._emitError(new Error('tus: no file or stream to upload provided'));\n        return;\n      }\n      if (!this.options.endpoint && !this.options.uploadUrl && !this.url) {\n        this._emitError(new Error('tus: neither an endpoint or an upload URL is provided'));\n        return;\n      }\n      var retryDelays = this.options.retryDelays;\n      if (retryDelays != null && 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      }\n      if (this.options.parallelUploads > 1) {\n        // Test which options are incompatible with parallel uploads.\n        for (var _i = 0, _arr = ['uploadUrl', 'uploadSize', 'uploadLengthDeferred']; _i < _arr.length; _i++) {\n          var optionName = _arr[_i];\n          if (this.options[optionName]) {\n            this._emitError(new Error(\"tus: cannot use the \".concat(optionName, \" option when parallelUploads is enabled\")));\n            return;\n          }\n        }\n      }\n      if (this.options.parallelUploadBoundaries) {\n        if (this.options.parallelUploads <= 1) {\n          this._emitError(new Error('tus: cannot use the `parallelUploadBoundaries` option when `parallelUploads` is disabled'));\n          return;\n        }\n        if (this.options.parallelUploads !== this.options.parallelUploadBoundaries.length) {\n          this._emitError(new Error('tus: the `parallelUploadBoundaries` must have the same length as the value of `parallelUploads`'));\n          return;\n        }\n      }\n      this.options.fingerprint(file, this.options).then(function (fingerprint) {\n        if (fingerprint == null) {\n          log('No fingerprint was calculated meaning that the upload cannot be stored in the URL storage.');\n        } else {\n          log(\"Calculated fingerprint: \".concat(fingerprint));\n        }\n        _this2._fingerprint = fingerprint;\n        if (_this2._source) {\n          return _this2._source;\n        }\n        return _this2.options.fileReader.openFile(file, _this2.options.chunkSize);\n      }).then(function (source) {\n        _this2._source = source;\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 (_this2.options.uploadLengthDeferred) {\n          _this2._size = null;\n        } else if (_this2.options.uploadSize != null) {\n          _this2._size = Number(_this2.options.uploadSize);\n          if (Number.isNaN(_this2._size)) {\n            _this2._emitError(new Error('tus: cannot convert `uploadSize` option into a number'));\n            return;\n          }\n        } else {\n          _this2._size = _this2._source.size;\n          if (_this2._size == null) {\n            _this2._emitError(new Error(\"tus: cannot automatically derive upload's size from input. Specify it manually using the `uploadSize` option or use the `uploadLengthDeferred` option\"));\n            return;\n          }\n        }\n\n        // If the upload was configured to use multiple requests or if we resume from\n        // an upload which used multiple requests, we start a parallel upload.\n        if (_this2.options.parallelUploads > 1 || _this2._parallelUploadUrls != null) {\n          _this2._startParallelUpload();\n        } else {\n          _this2._startSingleUpload();\n        }\n      })[\"catch\"](function (err) {\n        _this2._emitError(err);\n      });\n    }\n\n    /**\n     * Initiate the uploading procedure for a parallelized upload, where one file is split into\n     * multiple request which are run in parallel.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_startParallelUpload\",\n    value: function _startParallelUpload() {\n      var _this$options$paralle,\n        _this3 = this;\n      var totalSize = this._size;\n      var totalProgress = 0;\n      this._parallelUploads = [];\n      var partCount = this._parallelUploadUrls != null ? this._parallelUploadUrls.length : this.options.parallelUploads;\n\n      // The input file will be split into multiple slices which are uploaded in separate\n      // requests. Here we get the start and end position for the slices.\n      var parts = (_this$options$paralle = this.options.parallelUploadBoundaries) !== null && _this$options$paralle !== void 0 ? _this$options$paralle : splitSizeIntoParts(this._source.size, partCount);\n\n      // Attach URLs from previous uploads, if available.\n      if (this._parallelUploadUrls) {\n        parts.forEach(function (part, index) {\n          part.uploadUrl = _this3._parallelUploadUrls[index] || null;\n        });\n      }\n\n      // Create an empty list for storing the upload URLs\n      this._parallelUploadUrls = new Array(parts.length);\n\n      // Generate a promise for each slice that will be resolve if the respective\n      // upload is completed.\n      var uploads = parts.map(function (part, index) {\n        var lastPartProgress = 0;\n        return _this3._source.slice(part.start, part.end).then(function (_ref) {\n          var value = _ref.value;\n          return new Promise(function (resolve, reject) {\n            // Merge with the user supplied options but overwrite some values.\n            var options = _objectSpread(_objectSpread({}, _this3.options), {}, {\n              // If available, the partial upload should be resumed from a previous URL.\n              uploadUrl: part.uploadUrl || null,\n              // We take manually care of resuming for partial uploads, so they should\n              // not be stored in the URL storage.\n              storeFingerprintForResuming: false,\n              removeFingerprintOnSuccess: false,\n              // Reset the parallelUploads option to not cause recursion.\n              parallelUploads: 1,\n              // Reset this option as we are not doing a parallel upload.\n              parallelUploadBoundaries: null,\n              metadata: {},\n              // Add the header to indicate the this is a partial upload.\n              headers: _objectSpread(_objectSpread({}, _this3.options.headers), {}, {\n                'Upload-Concat': 'partial'\n              }),\n              // Reject or resolve the promise if the upload errors or completes.\n              onSuccess: resolve,\n              onError: reject,\n              // Based in the progress for this partial upload, calculate the progress\n              // for the entire final upload.\n              onProgress: function onProgress(newPartProgress) {\n                totalProgress = totalProgress - lastPartProgress + newPartProgress;\n                lastPartProgress = newPartProgress;\n                _this3._emitProgress(totalProgress, totalSize);\n              },\n              // Wait until every partial upload has an upload URL, so we can add\n              // them to the URL storage.\n              onUploadUrlAvailable: function onUploadUrlAvailable() {\n                _this3._parallelUploadUrls[index] = upload.url;\n                // Test if all uploads have received an URL\n                if (_this3._parallelUploadUrls.filter(function (u) {\n                  return Boolean(u);\n                }).length === parts.length) {\n                  _this3._saveUploadInUrlStorage();\n                }\n              }\n            });\n            var upload = new BaseUpload(value, options);\n            upload.start();\n\n            // Store the upload in an array, so we can later abort them if necessary.\n            _this3._parallelUploads.push(upload);\n          });\n        });\n      });\n      var req;\n      // Wait until all partial uploads are finished and we can send the POST request for\n      // creating the final upload.\n      Promise.all(uploads).then(function () {\n        req = _this3._openRequest('POST', _this3.options.endpoint);\n        req.setHeader('Upload-Concat', \"final;\".concat(_this3._parallelUploadUrls.join(' ')));\n\n        // Add metadata if values have been added\n        var metadata = encodeMetadata(_this3.options.metadata);\n        if (metadata !== '') {\n          req.setHeader('Upload-Metadata', metadata);\n        }\n        return _this3._sendRequest(req, null);\n      }).then(function (res) {\n        if (!inStatusCategory(res.getStatus(), 200)) {\n          _this3._emitHttpError(req, res, 'tus: unexpected response while creating upload');\n          return;\n        }\n        var location = res.getHeader('Location');\n        if (location == null) {\n          _this3._emitHttpError(req, res, 'tus: invalid or missing Location header');\n          return;\n        }\n        _this3.url = resolveUrl(_this3.options.endpoint, location);\n        log(\"Created upload at \".concat(_this3.url));\n        _this3._emitSuccess();\n      })[\"catch\"](function (err) {\n        _this3._emitError(err);\n      });\n    }\n\n    /**\n     * Initiate the uploading procedure for a non-parallel upload. Here the entire file is\n     * uploaded in a sequential matter.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_startSingleUpload\",\n    value: function _startSingleUpload() {\n      // Reset the aborted flag when the upload is started or else the\n      // _performUpload 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        log(\"Resuming upload from previous URL: \".concat(this.url));\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        log(\"Resuming upload from provided URL: \".concat(this.options.uploadUrl));\n        this.url = this.options.uploadUrl;\n        this._resumeUpload();\n        return;\n      }\n\n      // An upload has not started for the file yet, so we start a new one\n      log('Creating a new upload');\n      this._createUpload();\n    }\n\n    /**\n     * Abort any running request and stop the current upload. After abort is called, no event\n     * handler will be invoked anymore. You can use the `start` method to resume the upload\n     * again.\n     * If `shouldTerminate` is true, the `terminate` function will be called to remove the\n     * current upload from the server.\n     *\n     * @param {boolean} shouldTerminate True if the upload should be deleted from the server.\n     * @return {Promise} The Promise will be resolved/rejected when the requests finish.\n     */\n  }, {\n    key: \"abort\",\n    value: function abort(shouldTerminate) {\n      var _this4 = this;\n      // Stop any parallel partial uploads, that have been started in _startParallelUploads.\n      if (this._parallelUploads != null) {\n        this._parallelUploads.forEach(function (upload) {\n          upload.abort(shouldTerminate);\n        });\n      }\n\n      // Stop any current running request.\n      if (this._req !== null) {\n        this._req.abort();\n        // Note: We do not close the file source here, so the user can resume in the future.\n      }\n\n      this._aborted = true;\n\n      // Stop any timeout used for initiating a retry.\n      if (this._retryTimeout != null) {\n        clearTimeout(this._retryTimeout);\n        this._retryTimeout = null;\n      }\n      if (!shouldTerminate || this.url == null) {\n        return Promise.resolve();\n      }\n      return BaseUpload.terminate(this.url, this.options)\n      // Remove entry from the URL storage since the upload URL is no longer valid.\n      .then(function () {\n        return _this4._removeFromUrlStorage();\n      });\n    }\n  }, {\n    key: \"_emitHttpError\",\n    value: function _emitHttpError(req, res, message, causingErr) {\n      this._emitError(new DetailedError(message, causingErr, req, res));\n    }\n  }, {\n    key: \"_emitError\",\n    value: function _emitError(err) {\n      var _this5 = this;\n      // Do not emit errors, e.g. from aborted HTTP requests, if the upload has been stopped.\n      if (this._aborted) return;\n\n      // Check if we should retry, when enabled, before sending the error to the user.\n      if (this.options.retryDelays != null) {\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 = this._offset != null && this._offset > this._offsetBeforeRetry;\n        if (shouldResetDelays) {\n          this._retryAttempt = 0;\n        }\n        if (shouldRetry(err, this._retryAttempt, this.options)) {\n          var delay = this.options.retryDelays[this._retryAttempt++];\n          this._offsetBeforeRetry = this._offset;\n          this._retryTimeout = setTimeout(function () {\n            _this5.start();\n          }, delay);\n          return;\n        }\n      }\n      if (typeof this.options.onError === 'function') {\n        this.options.onError(err);\n      } else {\n        throw err;\n      }\n    }\n\n    /**\n     * Publishes notification if the upload has been successfully completed.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_emitSuccess\",\n    value: function _emitSuccess() {\n      if (this.options.removeFingerprintOnSuccess) {\n        // Remove stored fingerprint and corresponding endpoint. This causes\n        // new uploads of the same file to be treated as a different file.\n        this._removeFromUrlStorage();\n      }\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     *\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     * @api private\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 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     * @api private\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     * 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    key: \"_createUpload\",\n    value: function _createUpload() {\n      var _this6 = this;\n      if (!this.options.endpoint) {\n        this._emitError(new Error('tus: unable to create upload because no endpoint is provided'));\n        return;\n      }\n      var req = this._openRequest('POST', this.options.endpoint);\n      if (this.options.uploadLengthDeferred) {\n        req.setHeader('Upload-Defer-Length', 1);\n      } else {\n        req.setHeader('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        req.setHeader('Upload-Metadata', metadata);\n      }\n      var promise;\n      if (this.options.uploadDataDuringCreation && !this.options.uploadLengthDeferred) {\n        this._offset = 0;\n        promise = this._addChunkToRequest(req);\n      } else {\n        promise = this._sendRequest(req, null);\n      }\n      promise.then(function (res) {\n        if (!inStatusCategory(res.getStatus(), 200)) {\n          _this6._emitHttpError(req, res, 'tus: unexpected response while creating upload');\n          return;\n        }\n        var location = res.getHeader('Location');\n        if (location == null) {\n          _this6._emitHttpError(req, res, 'tus: invalid or missing Location header');\n          return;\n        }\n        _this6.url = resolveUrl(_this6.options.endpoint, location);\n        log(\"Created upload at \".concat(_this6.url));\n        if (typeof _this6.options.onUploadUrlAvailable === 'function') {\n          _this6.options.onUploadUrlAvailable();\n        }\n        if (_this6._size === 0) {\n          // Nothing to upload and file was successfully created\n          _this6._emitSuccess();\n          _this6._source.close();\n          return;\n        }\n        _this6._saveUploadInUrlStorage().then(function () {\n          if (_this6.options.uploadDataDuringCreation) {\n            _this6._handleUploadResponse(req, res);\n          } else {\n            _this6._offset = 0;\n            _this6._performUpload();\n          }\n        });\n      })[\"catch\"](function (err) {\n        _this6._emitHttpError(req, null, 'tus: failed to create upload', err);\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    key: \"_resumeUpload\",\n    value: function _resumeUpload() {\n      var _this7 = this;\n      var req = this._openRequest('HEAD', this.url);\n      var promise = this._sendRequest(req, null);\n      promise.then(function (res) {\n        var status = res.getStatus();\n        if (!inStatusCategory(status, 200)) {\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 (status === 423) {\n            _this7._emitHttpError(req, res, 'tus: upload is currently locked; retry later');\n            return;\n          }\n          if (inStatusCategory(status, 400)) {\n            // Remove stored fingerprint and corresponding endpoint,\n            // on client errors since the file can not be found\n            _this7._removeFromUrlStorage();\n          }\n          if (!_this7.options.endpoint) {\n            // Don't attempt to create a new upload if no endpoint is provided.\n            _this7._emitHttpError(req, res, '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          _this7.url = null;\n          _this7._createUpload();\n          return;\n        }\n        var offset = parseInt(res.getHeader('Upload-Offset'), 10);\n        if (Number.isNaN(offset)) {\n          _this7._emitHttpError(req, res, 'tus: invalid or missing offset value');\n          return;\n        }\n        var length = parseInt(res.getHeader('Upload-Length'), 10);\n        if (Number.isNaN(length) && !_this7.options.uploadLengthDeferred) {\n          _this7._emitHttpError(req, res, 'tus: invalid or missing length value');\n          return;\n        }\n        if (typeof _this7.options.onUploadUrlAvailable === 'function') {\n          _this7.options.onUploadUrlAvailable();\n        }\n        _this7._saveUploadInUrlStorage().then(function () {\n          // Upload has already been completed and we do not need to send additional\n          // data to the server\n          if (offset === length) {\n            _this7._emitProgress(length, length);\n            _this7._emitSuccess();\n            return;\n          }\n          _this7._offset = offset;\n          _this7._performUpload();\n        });\n      })[\"catch\"](function (err) {\n        _this7._emitHttpError(req, null, 'tus: failed to resume upload', err);\n      });\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    key: \"_performUpload\",\n    value: function _performUpload() {\n      var _this8 = this;\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      var req;\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        req = this._openRequest('POST', this.url);\n        req.setHeader('X-HTTP-Method-Override', 'PATCH');\n      } else {\n        req = this._openRequest('PATCH', this.url);\n      }\n      req.setHeader('Upload-Offset', this._offset);\n      var promise = this._addChunkToRequest(req);\n      promise.then(function (res) {\n        if (!inStatusCategory(res.getStatus(), 200)) {\n          _this8._emitHttpError(req, res, 'tus: unexpected response while uploading chunk');\n          return;\n        }\n        _this8._handleUploadResponse(req, res);\n      })[\"catch\"](function (err) {\n        // Don't emit an error if the upload was aborted manually\n        if (_this8._aborted) {\n          return;\n        }\n        _this8._emitHttpError(req, null, \"tus: failed to upload chunk at offset \".concat(_this8._offset), err);\n      });\n    }\n\n    /**\n     * _addChunktoRequest reads a chunk from the source and sends it using the\n     * supplied request object. It will not handle the response.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_addChunkToRequest\",\n    value: function _addChunkToRequest(req) {\n      var _this9 = this;\n      var start = this._offset;\n      var end = this._offset + this.options.chunkSize;\n      req.setProgressHandler(function (bytesSent) {\n        _this9._emitProgress(start + bytesSent, _this9._size);\n      });\n      req.setHeader('Content-Type', 'application/offset+octet-stream');\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      return this._source.slice(start, end).then(function (_ref2) {\n        var value = _ref2.value,\n          done = _ref2.done;\n        var valueSize = value && value.size ? value.size : 0;\n\n        // If the upload length is deferred, the upload size was not specified during\n        // upload creation. So, if the file reader is done reading, we know the total\n        // upload size and can tell the tus server.\n        if (_this9.options.uploadLengthDeferred && done) {\n          _this9._size = _this9._offset + valueSize;\n          req.setHeader('Upload-Length', _this9._size);\n        }\n\n        // The specified uploadSize might not match the actual amount of data that a source\n        // provides. In these cases, we cannot successfully complete the upload, so we\n        // rather error out and let the user know. If not, tus-js-client will be stuck\n        // in a loop of repeating empty PATCH requests.\n        // See https://community.transloadit.com/t/how-to-abort-hanging-companion-uploads/16488/13\n        var newSize = _this9._offset + valueSize;\n        if (!_this9.options.uploadLengthDeferred && done && newSize !== _this9._size) {\n          return Promise.reject(new Error(\"upload was configured with a size of \".concat(_this9._size, \" bytes, but the source is done after \").concat(newSize, \" bytes\")));\n        }\n        if (value === null) {\n          return _this9._sendRequest(req);\n        }\n        _this9._emitProgress(_this9._offset, _this9._size);\n        return _this9._sendRequest(req, value);\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     * @api private\n     */\n  }, {\n    key: \"_handleUploadResponse\",\n    value: function _handleUploadResponse(req, res) {\n      var offset = parseInt(res.getHeader('Upload-Offset'), 10);\n      if (Number.isNaN(offset)) {\n        this._emitHttpError(req, res, 'tus: invalid or missing offset value');\n        return;\n      }\n      this._emitProgress(offset, this._size);\n      this._emitChunkComplete(offset - this._offset, offset, this._size);\n      this._offset = offset;\n      if (offset === this._size) {\n        // Yay, finally done :)\n        this._emitSuccess();\n        this._source.close();\n        return;\n      }\n      this._performUpload();\n    }\n\n    /**\n     * Create a new HTTP request object with the given method and URL.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_openRequest\",\n    value: function _openRequest(method, url) {\n      var req = openRequest(method, url, this.options);\n      this._req = req;\n      return req;\n    }\n\n    /**\n     * Remove the entry in the URL storage, if it has been saved before.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_removeFromUrlStorage\",\n    value: function _removeFromUrlStorage() {\n      var _this10 = this;\n      if (!this._urlStorageKey) return;\n      this._urlStorage.removeUpload(this._urlStorageKey)[\"catch\"](function (err) {\n        _this10._emitError(err);\n      });\n      this._urlStorageKey = null;\n    }\n\n    /**\n     * Add the upload URL to the URL storage, if possible.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_saveUploadInUrlStorage\",\n    value: function _saveUploadInUrlStorage() {\n      var _this11 = this;\n      // We do not store the upload URL\n      // - if it was disabled in the option, or\n      // - if no fingerprint was calculated for the input (i.e. a stream), or\n      // - if the URL is already stored (i.e. key is set alread).\n      if (!this.options.storeFingerprintForResuming || !this._fingerprint || this._urlStorageKey !== null) {\n        return Promise.resolve();\n      }\n      var storedUpload = {\n        size: this._size,\n        metadata: this.options.metadata,\n        creationTime: new Date().toString()\n      };\n      if (this._parallelUploads) {\n        // Save multiple URLs if the parallelUploads option is used ...\n        storedUpload.parallelUploadUrls = this._parallelUploadUrls;\n      } else {\n        // ... otherwise we just save the one available URL.\n        storedUpload.uploadUrl = this.url;\n      }\n      return this._urlStorage.addUpload(this._fingerprint, storedUpload).then(function (urlStorageKey) {\n        _this11._urlStorageKey = urlStorageKey;\n      });\n    }\n\n    /**\n     * Send a request with the provided body.\n     *\n     * @api private\n     */\n  }, {\n    key: \"_sendRequest\",\n    value: function _sendRequest(req) {\n      var body = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n      return sendRequest(req, body, this.options);\n    }\n  }], [{\n    key: \"terminate\",\n    value: function terminate(url) {\n      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      var req = openRequest('DELETE', url, options);\n      return sendRequest(req, null, options).then(function (res) {\n        // A 204 response indicates a successfull request\n        if (res.getStatus() === 204) {\n          return;\n        }\n        throw new DetailedError('tus: unexpected response while terminating upload', null, req, res);\n      })[\"catch\"](function (err) {\n        if (!(err instanceof DetailedError)) {\n          err = new DetailedError('tus: failed to terminate upload', err, req, null);\n        }\n        if (!shouldRetry(err, 0, options)) {\n          throw err;\n        }\n\n        // Instead of keeping track of the retry attempts, we remove the first element from the delays\n        // array. If the array is empty, all retry attempts are used up and we will bubble up the error.\n        // We recursively call the terminate function will removing elements from the retryDelays array.\n        var delay = options.retryDelays[0];\n        var remainingDelays = options.retryDelays.slice(1);\n        var newOptions = _objectSpread(_objectSpread({}, options), {}, {\n          retryDelays: remainingDelays\n        });\n        return new Promise(function (resolve) {\n          return setTimeout(resolve, delay);\n        }).then(function () {\n          return BaseUpload.terminate(url, newOptions);\n        });\n      });\n    }\n  }]);\n  return BaseUpload;\n}();\nfunction encodeMetadata(metadata) {\n  return Object.entries(metadata).map(function (_ref3) {\n    var _ref4 = _slicedToArray(_ref3, 2),\n      key = _ref4[0],\n      value = _ref4[1];\n    return \"\".concat(key, \" \").concat(Base64.encode(String(value)));\n  }).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\n/**\n * Create a new HTTP request with the specified method and URL.\n * The necessary headers that are included in every request\n * will be added, including the request ID.\n *\n * @api private\n */\nfunction openRequest(method, url, options) {\n  var req = options.httpStack.createRequest(method, url);\n  req.setHeader('Tus-Resumable', '1.0.0');\n  var headers = options.headers || {};\n  Object.entries(headers).forEach(function (_ref5) {\n    var _ref6 = _slicedToArray(_ref5, 2),\n      name = _ref6[0],\n      value = _ref6[1];\n    req.setHeader(name, value);\n  });\n  if (options.addRequestId) {\n    var requestId = uuid();\n    req.setHeader('X-Request-ID', requestId);\n  }\n  return req;\n}\n\n/**\n * Send a request with the provided body while invoking the onBeforeRequest\n * and onAfterResponse callbacks.\n *\n * @api private\n */\nfunction sendRequest(_x2, _x3, _x4) {\n  return _sendRequest2.apply(this, arguments);\n}\n/**\n * Checks whether the browser running this code has internet access.\n * This function will always return true in the node.js environment\n *\n * @api private\n */\nfunction _sendRequest2() {\n  _sendRequest2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(req, body, options) {\n    var res;\n    return _regeneratorRuntime().wrap(function _callee$(_context) {\n      while (1) switch (_context.prev = _context.next) {\n        case 0:\n          if (!(typeof options.onBeforeRequest === 'function')) {\n            _context.next = 3;\n            break;\n          }\n          _context.next = 3;\n          return options.onBeforeRequest(req);\n        case 3:\n          _context.next = 5;\n          return req.send(body);\n        case 5:\n          res = _context.sent;\n          if (!(typeof options.onAfterResponse === 'function')) {\n            _context.next = 9;\n            break;\n          }\n          _context.next = 9;\n          return options.onAfterResponse(req, res);\n        case 9:\n          return _context.abrupt(\"return\", res);\n        case 10:\n        case \"end\":\n          return _context.stop();\n      }\n    }, _callee);\n  }));\n  return _sendRequest2.apply(this, arguments);\n}\nfunction isOnline() {\n  var online = true;\n  if (typeof window !== 'undefined' &&\n  // eslint-disable-next-line no-undef\n  'navigator' in window &&\n  // eslint-disable-next-line no-undef\n  window.navigator.onLine === false) {\n    // eslint-disable-line no-undef\n    online = false;\n  }\n  return online;\n}\n\n/**\n * Checks whether or not it is ok to retry a request.\n * @param {Error} err the error returned from the last request\n * @param {number} retryAttempt the number of times the request has already been retried\n * @param {object} options tus Upload options\n *\n * @api private\n */\nfunction shouldRetry(err, retryAttempt, options) {\n  // We only attempt a retry if\n  // - retryDelays option is set\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. not a status 4xx except a 409 or 423) or\n  // a onShouldRetry is specified and returns true\n  // - the browser does not indicate that we are offline\n  if (options.retryDelays == null || retryAttempt >= options.retryDelays.length || err.originalRequest == null) {\n    return false;\n  }\n  if (options && typeof options.onShouldRetry === 'function') {\n    return options.onShouldRetry(err, retryAttempt, options);\n  }\n  var status = err.originalResponse ? err.originalResponse.getStatus() : 0;\n  return (!inStatusCategory(status, 400) || status === 409 || status === 423) && isOnline();\n}\n\n/**\n * Resolve a relative link given the origin as source. For example,\n * if a HTTP request to http://example.com/files/ returns a Location\n * header with the value /upload/abc, the resolved URL will be:\n * http://example.com/upload/abc\n */\nfunction resolveUrl(origin, link) {\n  return new URL(link, origin).toString();\n}\n\n/**\n * Calculate the start and end positions for the parts if an upload\n * is split into multiple parallel requests.\n *\n * @param {number} totalSize The byte size of the upload, which will be split.\n * @param {number} partCount The number in how many parts the upload will be split.\n * @return {object[]}\n * @api private\n */\nfunction splitSizeIntoParts(totalSize, partCount) {\n  var partSize = Math.floor(totalSize / partCount);\n  var parts = [];\n  for (var i = 0; i < partCount; i++) {\n    parts.push({\n      start: partSize * i,\n      end: partSize * (i + 1)\n    });\n  }\n  parts[partCount - 1].end = totalSize;\n  return parts;\n}\nBaseUpload.defaultOptions = defaultOptions;\nexport default BaseUpload;"],"names":["_regeneratorRuntime","exports","Op","Object","prototype","hasOwn","hasOwnProperty","defineProperty","obj","key","desc","value","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","enumerable","configurable","writable","err","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","generator","create","context","Context","makeInvokeMethod","tryCatch","fn","arg","type","call","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","this","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","forEach","method","_invoke","AsyncIterator","PromiseImpl","invoke","resolve","reject","record","result","_typeof","__await","then","unwrapped","error","previousPromise","callInvokeWithMethodAndArg","state","Error","undefined","done","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","methodName","TypeError","info","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","push","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","length","i","doneResult","displayName","isGeneratorFunction","genFun","ctor","constructor","name","mark","setPrototypeOf","__proto__","awrap","async","Promise","iter","keys","val","object","reverse","pop","skipTempReset","prev","charAt","slice","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","asyncGeneratorStep","gen","_next","_throw","_slicedToArray","arr","Array","isArray","_arrayWithHoles","_i","_s","_e","_x","_r","_arr","_n","_d","_iterableToArrayLimit","o","minLen","_arrayLikeToArray","n","toString","from","test","_unsupportedIterableToArray","_nonIterableRest","len","arr2","ownKeys","enumerableOnly","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","apply","_objectSpread","target","arguments","source","_defineProperty","getOwnPropertyDescriptors","defineProperties","_toPropertyKey","_defineProperties","props","descriptor","input","hint","prim","toPrimitive","res","String","_toPrimitive","BaseUpload","file","options","instance","Constructor","_classCallCheck","console","log","chunkSize","Number","_urlStorage","urlStorage","url","_req","_fingerprint","_urlStorageKey","_offset","_aborted","_size","_source","_retryAttempt","_retryTimeout","_offsetBeforeRetry","_parallelUploads","_parallelUploadUrls","protoProps","staticProps","_this","fingerprint","findUploadsByFingerprint","previousUpload","uploadUrl","parallelUploadUrls","urlStorageKey","_this2","endpoint","retryDelays","parallelUploads","optionName","_emitError","concat","parallelUploadBoundaries","fileReader","openFile","uploadLengthDeferred","uploadSize","size","_startParallelUpload","_startSingleUpload","_this$options$paralle","_this3","totalSize","totalProgress","partCount","parts","partSize","Math","floor","start","end","splitSizeIntoParts","part","index","req","uploads","map","lastPartProgress","_ref","storeFingerprintForResuming","removeFingerprintOnSuccess","metadata","headers","onSuccess","onError","onProgress","newPartProgress","_emitProgress","onUploadUrlAvailable","upload","u","Boolean","_saveUploadInUrlStorage","all","_openRequest","setHeader","join","encodeMetadata","_sendRequest","inStatusCategory","getStatus","location","getHeader","resolveUrl","_emitSuccess","_emitHttpError","_resumeUpload","_createUpload","shouldTerminate","_this4","abort","clearTimeout","terminate","_removeFromUrlStorage","message","causingErr","_this5","shouldRetry","delay","setTimeout","bytesSent","bytesTotal","bytesAccepted","onChunkComplete","_this6","promise","uploadDataDuringCreation","_addChunkToRequest","close","_handleUploadResponse","_performUpload","_this7","status","offset","parseInt","_this8","overridePatchMethod","_this9","setProgressHandler","Infinity","_ref2","valueSize","newSize","_emitChunkComplete","openRequest","_this10","removeUpload","_this11","storedUpload","creationTime","Date","addUpload","sendRequest","remainingDelays","newOptions","entries","_ref3","_ref4","category","httpStack","createRequest","_ref5","_ref6","addRequestId","requestId","_x2","_x3","_x4","_sendRequest2","_callee","body","_context","onBeforeRequest","send","onAfterResponse","args","retryAttempt","originalRequest","onShouldRetry","online","originalResponse","window","navigator","onLine","origin","link","defaultOptions"],"sourceRoot":""}