tus.min.js

(function(f) { if (typeof exports === "object" && typeof module !== "undefined") { module.exports = f() } else if (typeof define === "function" && define.amd) { define([], f) } else { var g; if (typeof window !== "undefined") { g = window } else if (typeof global !== "undefined") { g = global } else if (typeof self !== "undefined") { g = self } else { g = this }
        g.tus = f() } })(function() {
    var define, module, exports;
    return (function e(t, n, r) {
        function s(o, u) { if (!n[o]) { if (!t[o]) { var a = typeof require == "function" && require; if (!u && a) return a(o, !0); if (i) return i(o, !0); var f = new Error("Cannot find module '" + o + "'"); throw f.code = "MODULE_NOT_FOUND", f } var l = n[o] = { exports: {} };
                t[o][0].call(l.exports, function(e) { var n = t[o][1][e]; return s(n ? n : e) }, l, l.exports, e, t, n, r) } return n[o].exports } var i = typeof require == "function" && require; for (var o = 0; o < r.length; o++) s(r[o]); return s })({
        1: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = void 0;

            var _isReactNative = _interopRequireDefault(require("./isReactNative"));

            var _uriToBlob = _interopRequireDefault(require("./uriToBlob"));

            var _isCordova = _interopRequireDefault(require("./isCordova"));

            var _readAsByteArray = _interopRequireDefault(require("./readAsByteArray"));

            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

            function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

            function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor); } }

            function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

            var FileSource = /*#__PURE__*/ function() {
                // Make this.size a method
                function FileSource(file) {
                    _classCallCheck(this, FileSource);

                    this._file = file;
                    this.size = file.size;
                }

                _createClass(FileSource, [{
                    key: "slice",
                    value: function slice(start, end) {
                        // In Apache Cordova applications, a File must be resolved using
                        // FileReader instances, see
                        // https://cordova.apache.org/docs/en/8.x/reference/cordova-plugin-file/index.html#read-a-file
                        if ((0, _isCordova["default"])()) {
                            return (0, _readAsByteArray["default"])(this._file.slice(start, end));
                        }

                        var value = this._file.slice(start, end);

                        return Promise.resolve({
                            value: value
                        });
                    }
                }, {
                    key: "close",
                    value: function close() { // Nothing to do here since we don't need to release any resources.
                    }
                }]);

                return FileSource;
            }();

            var StreamSource = /*#__PURE__*/ function() {
                function StreamSource(reader, chunkSize) {
                    _classCallCheck(this, StreamSource);

                    this._chunkSize = chunkSize;
                    this._buffer = undefined;
                    this._bufferOffset = 0;
                    this._reader = reader;
                    this._done = false;
                }

                _createClass(StreamSource, [{
                    key: "slice",
                    value: function slice(start, end) {
                        if (start < this._bufferOffset) {
                            return Promise.reject(new Error("Requested data is before the reader's current offset"));
                        }

                        return this._readUntilEnoughDataOrDone(start, end);
                    }
                }, {
                    key: "_readUntilEnoughDataOrDone",
                    value: function _readUntilEnoughDataOrDone(start, end) {
                        var _this = this;

                        var hasEnoughData = end <= this._bufferOffset + len(this._buffer);

                        if (this._done || hasEnoughData) {
                            var value = this._getDataFromBuffer(start, end);

                            var done = value == null ? this._done : false;
                            return Promise.resolve({
                                value: value,
                                done: done
                            });
                        }

                        return this._reader.read().then(function(_ref) {
                            var value = _ref.value,
                                done = _ref.done;

                            if (done) {
                                _this._done = true;
                            } else if (_this._buffer === undefined) {
                                _this._buffer = value;
                            } else {
                                _this._buffer = concat(_this._buffer, value);
                            }

                            return _this._readUntilEnoughDataOrDone(start, end);
                        });
                    }
                }, {
                    key: "_getDataFromBuffer",
                    value: function _getDataFromBuffer(start, end) {
                        // Remove data from buffer before `start`.
                        // Data might be reread from the buffer if an upload fails, so we can only
                        // safely delete data when it comes *before* what is currently being read.
                        if (start > this._bufferOffset) {
                            this._buffer = this._buffer.slice(start - this._bufferOffset);
                            this._bufferOffset = start;
                        } // If the buffer is empty after removing old data, all data has been read.


                        var hasAllDataBeenRead = len(this._buffer) === 0;

                        if (this._done && hasAllDataBeenRead) {
                            return null;
                        } // We already removed data before `start`, so we just return the first
                        // chunk from the buffer.


                        return this._buffer.slice(0, end - start);
                    }
                }, {
                    key: "close",
                    value: function close() {
                        if (this._reader.cancel) {
                            this._reader.cancel();
                        }
                    }
                }]);

                return StreamSource;
            }();

            function len(blobOrArray) {
                if (blobOrArray === undefined) return 0;
                if (blobOrArray.size !== undefined) return blobOrArray.size;
                return blobOrArray.length;
            }
            /*
              Typed arrays and blobs don't have a concat method.
              This function helps StreamSource accumulate data to reach chunkSize.
            */


            function concat(a, b) {
                if (a.concat) {
                    // Is `a` an Array?
                    return a.concat(b);
                }

                if (a instanceof Blob) {
                    return new Blob([a, b], {
                        type: a.type
                    });
                }

                if (a.set) {
                    // Is `a` a typed array?
                    var c = new a.constructor(a.length + b.length);
                    c.set(a);
                    c.set(b, a.length);
                    return c;
                }

                throw new Error("Unknown data type");
            }

            var FileReader = /*#__PURE__*/ function() {
                function FileReader() {
                    _classCallCheck(this, FileReader);
                }

                _createClass(FileReader, [{
                    key: "openFile",
                    value: function openFile(input, chunkSize) {
                        // In React Native, when user selects a file, instead of a File or Blob,
                        // you usually get a file object {} with a uri property that contains
                        // a local path to the file. We use XMLHttpRequest to fetch
                        // the file blob, before uploading with tus.
                        if ((0, _isReactNative["default"])() && input && typeof input.uri !== "undefined") {
                            return (0, _uriToBlob["default"])(input.uri).then(function(blob) {
                                return new FileSource(blob);
                            })["catch"](function(err) {
                                throw new Error("tus: cannot fetch `file.uri` as Blob, make sure the uri is correct and accessible. " + err);
                            });
                        } // Since we emulate the Blob type in our tests (not all target browsers
                        // support it), we cannot use `instanceof` for testing whether the input value
                        // can be handled. Instead, we simply check is the slice() function and the
                        // size property are available.


                        if (typeof input.slice === "function" && typeof input.size !== "undefined") {
                            return Promise.resolve(new FileSource(input));
                        }

                        if (typeof input.read === "function") {
                            chunkSize = +chunkSize;

                            if (!isFinite(chunkSize)) {
                                return Promise.reject(new Error("cannot create source for stream without a finite value for the `chunkSize` option"));
                            }

                            return Promise.resolve(new StreamSource(input, chunkSize));
                        }

                        return Promise.reject(new Error("source object may only be an instance of File, Blob, or Reader in this environment"));
                    }
                }]);

                return FileReader;
            }();

            exports["default"] = FileReader;

        }, { "./isCordova": 5, "./isReactNative": 6, "./readAsByteArray": 7, "./uriToBlob": 8 }],
        2: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = fingerprint;

            var _isReactNative = _interopRequireDefault(require("./isReactNative"));

            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

            // TODO: Differenciate between input types

            /**
             * Generate a fingerprint for a file which will be used the store the endpoint
             *
             * @param {File} file
             * @param {Object} options
             * @param {Function} callback
             */
            function fingerprint(file, options) {
                if ((0, _isReactNative["default"])()) {
                    return Promise.resolve(reactNativeFingerprint(file, options));
                }

                return Promise.resolve(["tus-br", file.name, file.type, file.size, file.lastModified, options.endpoint].join("-"));
            }

            function reactNativeFingerprint(file, options) {
                var exifHash = file.exif ? hashCode(JSON.stringify(file.exif)) : "noexif";
                return ["tus-rn", file.name || "noname", file.size || "nosize", exifHash, options.endpoint].join("/");
            }

            function hashCode(str) {
                // from https://stackoverflow.com/a/8831937/151666
                var hash = 0;

                if (str.length === 0) {
                    return hash;
                }

                for (var i = 0; i < str.length; i++) {
                    var _char = str.charCodeAt(i);

                    hash = (hash << 5) - hash + _char;
                    hash = hash & hash; // Convert to 32bit integer
                }

                return hash;
            }

        }, { "./isReactNative": 6 }],
        3: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = void 0;

            function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

            function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor); } }

            function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

            /* global window */
            var XHRHttpStack = /*#__PURE__*/ function() {
                function XHRHttpStack() {
                    _classCallCheck(this, XHRHttpStack);
                }

                _createClass(XHRHttpStack, [{
                    key: "createRequest",
                    value: function createRequest(method, url) {
                        return new Request(method, url);
                    }
                }, {
                    key: "getName",
                    value: function getName() {
                        return "XHRHttpStack";
                    }
                }]);

                return XHRHttpStack;
            }();

            exports["default"] = XHRHttpStack;

            var Request = /*#__PURE__*/ function() {
                function Request(method, url) {
                    _classCallCheck(this, Request);

                    this._xhr = new XMLHttpRequest();

                    this._xhr.open(method, url, true);

                    this._method = method;
                    this._url = url;
                    this._headers = {};
                }

                _createClass(Request, [{
                    key: "getMethod",
                    value: function getMethod() {
                        return this._method;
                    }
                }, {
                    key: "getURL",
                    value: function getURL() {
                        return this._url;
                    }
                }, {
                    key: "setHeader",
                    value: function setHeader(header, value) {
                        this._xhr.setRequestHeader(header, value);

                        this._headers[header] = value;
                    }
                }, {
                    key: "getHeader",
                    value: function getHeader(header) {
                        return this._headers[header];
                    }
                }, {
                    key: "setProgressHandler",
                    value: function setProgressHandler(progressHandler) {
                        // Test support for progress events before attaching an event listener
                        if (!("upload" in this._xhr)) {
                            return;
                        }

                        this._xhr.upload.onprogress = function(e) {
                            if (!e.lengthComputable) {
                                return;
                            }

                            progressHandler(e.loaded);
                        };
                    }
                }, {
                    key: "send",
                    value: function send() {
                        var _this = this;

                        var body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
                        return new Promise(function(resolve, reject) {
                            _this._xhr.onload = function() {
                                resolve(new Response(_this._xhr));
                            };

                            _this._xhr.onerror = function(err) {
                                reject(err);
                            };

                            _this._xhr.send(body);
                        });
                    }
                }, {
                    key: "abort",
                    value: function abort() {
                        this._xhr.abort();

                        return Promise.resolve();
                    }
                }, {
                    key: "getUnderlyingObject",
                    value: function getUnderlyingObject() {
                        return this._xhr;
                    }
                }]);

                return Request;
            }();

            var Response = /*#__PURE__*/ function() {
                function Response(xhr) {
                    _classCallCheck(this, Response);

                    this._xhr = xhr;
                }

                _createClass(Response, [{
                    key: "getStatus",
                    value: function getStatus() {
                        return this._xhr.status;
                    }
                }, {
                    key: "getHeader",
                    value: function getHeader(header) {
                        return this._xhr.getResponseHeader(header);
                    }
                }, {
                    key: "getBody",
                    value: function getBody() {
                        return this._xhr.responseText;
                    }
                }, {
                    key: "getUnderlyingObject",
                    value: function getUnderlyingObject() {
                        return this._xhr;
                    }
                }]);

                return Response;
            }();

        }, {}],
        4: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            Object.defineProperty(exports, "enableDebugLog", {
                enumerable: true,
                get: function get() {
                    return _logger.enableDebugLog;
                }
            });
            Object.defineProperty(exports, "canStoreURLs", {
                enumerable: true,
                get: function get() {
                    return _urlStorage.canStoreURLs;
                }
            });
            exports.isSupported = exports.defaultOptions = exports.Upload = void 0;

            var _upload = _interopRequireDefault(require("../upload"));

            var _noopUrlStorage = _interopRequireDefault(require("../noopUrlStorage"));

            var _logger = require("../logger");

            var _urlStorage = require("./urlStorage");

            var _httpStack = _interopRequireDefault(require("./httpStack"));

            var _fileReader = _interopRequireDefault(require("./fileReader"));

            var _fingerprint = _interopRequireDefault(require("./fingerprint"));

            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

            function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

            function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

            function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor); } }

            function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

            function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); }
                subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

            function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

            function _createSuper(Derived) { return function() { var Super = _getPrototypeOf(Derived),
                        result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor;
                        result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

            function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

            function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

            function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function() {})); return true; } catch (e) { return false; } }

            function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

            function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function(sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; });
                    keys.push.apply(keys, symbols); } return keys; }

            function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function(key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function(key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

            function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

            var defaultOptions = _objectSpread({}, _upload["default"].defaultOptions, {
                httpStack: new _httpStack["default"](),
                fileReader: new _fileReader["default"](),
                urlStorage: _urlStorage.canStoreURLs ? new _urlStorage.WebStorageUrlStorage() : new _noopUrlStorage["default"](),
                fingerprint: _fingerprint["default"]
            });

            exports.defaultOptions = defaultOptions;

            var Upload = /*#__PURE__*/ function(_BaseUpload) {
                _inherits(Upload, _BaseUpload);

                var _super = _createSuper(Upload);

                function Upload() {
                    var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
                    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

                    _classCallCheck(this, Upload);

                    options = _objectSpread({}, defaultOptions, {}, options);
                    return _super.call(this, file, options);
                }

                _createClass(Upload, null, [{
                    key: "terminate",
                    value: function terminate(url, options, cb) {
                        options = _objectSpread({}, defaultOptions, {}, options);
                        return _upload["default"].terminate(url, options, cb);
                    }
                }]);

                return Upload;
            }(_upload["default"]);

            exports.Upload = Upload;
            var _window = window,
                XMLHttpRequest = _window.XMLHttpRequest,
                Blob = _window.Blob;
            var isSupported = XMLHttpRequest && Blob && typeof Blob.prototype.slice === "function";
            exports.isSupported = isSupported;

        }, { "../logger": 11, "../noopUrlStorage": 12, "../upload": 13, "./fileReader": 1, "./fingerprint": 2, "./httpStack": 3, "./urlStorage": 9 }],
        5: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = void 0;

            var isCordova = function isCordova() {
                return typeof window != "undefined" && (typeof window.PhoneGap != "undefined" || typeof window.Cordova != "undefined" || typeof window.cordova != "undefined");
            };

            var _default = isCordova;
            exports["default"] = _default;

        }, {}],
        6: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = void 0;

            var isReactNative = function isReactNative() {
                return typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative";
            };

            var _default = isReactNative;
            exports["default"] = _default;

        }, {}],
        7: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = readAsByteArray;

            /**
             * readAsByteArray converts a File object to a Uint8Array.
             * This function is only used on the Apache Cordova platform.
             * See https://cordova.apache.org/docs/en/latest/reference/cordova-plugin-file/index.html#read-a-file
             */
            function readAsByteArray(chunk) {
                return new Promise(function(resolve, reject) {
                    var reader = new FileReader();

                    reader.onload = function() {
                        var value = new Uint8Array(reader.result);
                        resolve({
                            value: value
                        });
                    };

                    reader.onerror = function(err) {
                        reject(err);
                    };

                    reader.readAsArrayBuffer(chunk);
                });
            }

        }, {}],
        8: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = uriToBlob;

            /**
             * uriToBlob resolves a URI to a Blob object. This is used for
             * React Native to retrieve a file (identified by a file://
             * URI) as a blob.
             */
            function uriToBlob(uri) {
                return new Promise(function(resolve, reject) {
                    var xhr = new XMLHttpRequest();
                    xhr.responseType = "blob";

                    xhr.onload = function() {
                        var blob = xhr.response;
                        resolve(blob);
                    };

                    xhr.onerror = function(err) {
                        reject(err);
                    };

                    xhr.open("GET", uri);
                    xhr.send();
                });
            }

        }, {}],
        9: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports.WebStorageUrlStorage = exports.canStoreURLs = void 0;

            function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

            function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor); } }

            function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

            /* global window, localStorage */
            var hasStorage = false;

            try {
                hasStorage = "localStorage" in window; // Attempt to store and read entries from the local storage to detect Private
                // Mode on Safari on iOS (see #49)

                var key = "tusSupport";
                localStorage.setItem(key, localStorage.getItem(key));
            } catch (e) {
                // If we try to access localStorage inside a sandboxed iframe, a SecurityError
                // is thrown. When in private mode on iOS Safari, a QuotaExceededError is
                // thrown (see #49)
                if (e.code === e.SECURITY_ERR || e.code === e.QUOTA_EXCEEDED_ERR) {
                    hasStorage = false;
                } else {
                    throw e;
                }
            }

            var canStoreURLs = hasStorage;
            exports.canStoreURLs = canStoreURLs;

            var WebStorageUrlStorage = /*#__PURE__*/ function() {
                function WebStorageUrlStorage() {
                    _classCallCheck(this, WebStorageUrlStorage);
                }

                _createClass(WebStorageUrlStorage, [{
                    key: "findAllUploads",
                    value: function findAllUploads() {
                        var results = this._findEntries("tus::");

                        return Promise.resolve(results);
                    }
                }, {
                    key: "findUploadsByFingerprint",
                    value: function findUploadsByFingerprint(fingerprint) {
                        var results = this._findEntries("tus::".concat(fingerprint, "::"));

                        return Promise.resolve(results);
                    }
                }, {
                    key: "removeUpload",
                    value: function removeUpload(urlStorageKey) {
                        localStorage.removeItem(urlStorageKey);
                        return Promise.resolve();
                    }
                }, {
                    key: "addUpload",
                    value: function addUpload(fingerprint, upload) {
                        var id = Math.round(Math.random() * 1e12);
                        var key = "tus::".concat(fingerprint, "::").concat(id);
                        localStorage.setItem(key, JSON.stringify(upload));
                        return Promise.resolve(key);
                    }
                }, {
                    key: "_findEntries",
                    value: function _findEntries(prefix) {
                        var results = [];

                        for (var i = 0; i < localStorage.length; i++) {
                            var _key = localStorage.key(i);

                            if (_key.indexOf(prefix) !== 0) continue;

                            try {
                                var upload = JSON.parse(localStorage.getItem(_key));
                                upload.urlStorageKey = _key;
                                results.push(upload);
                            } catch (e) { // The JSON parse error is intentionally ignored here, so a malformed
                                // entry in the storage cannot prevent an upload.
                            }
                        }

                        return results;
                    }
                }]);

                return WebStorageUrlStorage;
            }();

            exports.WebStorageUrlStorage = WebStorageUrlStorage;

        }, {}],
        10: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = void 0;

            function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

            function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

            function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); }
                subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

            function _createSuper(Derived) { return function() { var Super = _getPrototypeOf(Derived),
                        result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor;
                        result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

            function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

            function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

            function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined;
                _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class);
                        _cache.set(Class, Wrapper); }

                    function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); }
                    Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }

            function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null];
                        a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }

            function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function() {})); return true; } catch (e) { return false; } }

            function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }

            function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

            function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

            var DetailedError = /*#__PURE__*/ function(_Error) {
                _inherits(DetailedError, _Error);

                var _super = _createSuper(DetailedError);

                function DetailedError(message) {
                    var _this;

                    var causingErr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
                    var req = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
                    var res = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;

                    _classCallCheck(this, DetailedError);

                    _this = _super.call(this, message);
                    _this.originalRequest = req;
                    _this.originalResponse = res;
                    _this.causingError = causingErr;

                    if (causingErr != null) {
                        message += ", caused by ".concat(causingErr.toString());
                    }

                    if (req != null) {
                        var requestId = req.getHeader("X-Request-ID") || "n/a";
                        var method = req.getMethod();
                        var url = req.getURL();
                        var status = res ? res.getStatus() : "n/a";
                        var body = res ? res.getBody() || "" : "n/a";
                        message += ", originated from request (method: ".concat(method, ", url: ").concat(url, ", response code: ").concat(status, ", response text: ").concat(body, ", request id: ").concat(requestId, ")");
                    }

                    _this.message = message;
                    return _this;
                }

                return DetailedError;
            }( /*#__PURE__*/ _wrapNativeSuper(Error));

            var _default = DetailedError;
            exports["default"] = _default;

        }, {}],
        11: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports.enableDebugLog = enableDebugLog;
            exports.log = log;

            /* eslint no-console: "off" */
            var isEnabled = false;

            function enableDebugLog() {
                isEnabled = true;
            }

            function log(msg) {
                if (!isEnabled) return;
                console.log(msg);
            }

        }, {}],
        12: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = void 0;

            function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

            function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor); } }

            function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

            /* eslint no-unused-vars: "off" */
            var NoopUrlStorage = /*#__PURE__*/ function() {
                function NoopUrlStorage() {
                    _classCallCheck(this, NoopUrlStorage);
                }

                _createClass(NoopUrlStorage, [{
                    key: "listAllUploads",
                    value: function listAllUploads() {
                        return Promise.resolve([]);
                    }
                }, {
                    key: "findUploadsByFingerprint",
                    value: function findUploadsByFingerprint(fingerprint) {
                        return Promise.resolve([]);
                    }
                }, {
                    key: "removeUpload",
                    value: function removeUpload(urlStorageKey) {
                        return Promise.resolve();
                    }
                }, {
                    key: "addUpload",
                    value: function addUpload(fingerprint, upload) {
                        return Promise.resolve(null);
                    }
                }]);

                return NoopUrlStorage;
            }();

            exports["default"] = NoopUrlStorage;

        }, {}],
        13: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = void 0;

            var _error = _interopRequireDefault(require("./error"));

            var _uuid = _interopRequireDefault(require("./uuid"));

            var _jsBase = require("js-base64");

            var _urlParse = _interopRequireDefault(require("url-parse"));

            var _logger = require("./logger");

            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

            function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function(sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; });
                    keys.push.apply(keys, symbols); } return keys; }

            function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function(key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function(key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

            function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

            function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

            function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor); } }

            function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

            var defaultOptions = {
                endpoint: null,
                uploadUrl: null,
                metadata: {},
                fingerprint: null,
                uploadSize: null,
                onProgress: null,
                onChunkComplete: null,
                onSuccess: null,
                onError: null,
                _onUploadUrlAvailable: null,
                overridePatchMethod: false,
                headers: {},
                addRequestId: false,
                onBeforeRequest: null,
                onAfterResponse: null,
                chunkSize: Infinity,
                retryDelays: [0, 1000, 3000, 5000],
                parallelUploads: 1,
                storeFingerprintForResuming: true,
                removeFingerprintOnSuccess: false,
                uploadLengthDeferred: false,
                uploadDataDuringCreation: false,
                urlStorage: null,
                fileReader: null,
                httpStack: null
            };

            var BaseUpload = /*#__PURE__*/ function() {
                function BaseUpload(file, options) {
                    _classCallCheck(this, BaseUpload);

                    // Warn about removed options from previous versions
                    if ("resume" in options) {
                        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
                    } // The default options will already be added from the wrapper classes.


                    this.options = options; // The storage module used to store URLs

                    this._urlStorage = this.options.urlStorage; // The underlying File/Blob object

                    this.file = file; // The URL against which the file will be uploaded

                    this.url = null; // The underlying request object for the current PATCH request

                    this._req = null; // The fingerpinrt for the current file (set after start())

                    this._fingerprint = null; // The key that the URL storage returned when saving an URL with a fingerprint,

                    this._urlStorageKey = null; // The offset used in the current PATCH request

                    this._offset = null; // True if the current PATCH request has been aborted

                    this._aborted = false; // The file's size in bytes

                    this._size = null; // The Source object which will wrap around the given file and provides us
                    // with a unified interface for getting its size and slice chunks from its
                    // content allowing us to easily handle Files, Blobs, Buffers and Streams.

                    this._source = null; // The current count of attempts which have been made. Zero indicates none.

                    this._retryAttempt = 0; // The timeout's ID which is used to delay the next retry

                    this._retryTimeout = null; // The offset of the remote upload before the latest attempt was started.

                    this._offsetBeforeRetry = 0; // An array of BaseUpload instances which are used for uploading the different
                    // parts, if the parallelUploads option is used.

                    this._parallelUploads = null; // An array of upload URLs which are used for uploading the different
                    // parts, if the parallelUploads option is used.

                    this._parallelUploadUrls = null;
                }
                /**
                 * Use the Termination extension to delete an upload from the server by sending a DELETE
                 * request to the specified upload URL. This is only possible if the server supports the
                 * Termination extension. If the `options.retryDelays` property is set, the method will
                 * also retry if an error ocurrs.
                 *
                 * @param {String} url The upload's URL which will be terminated.
                 * @param {object} options Optional options for influencing HTTP requests.
                 * @return {Promise} The Promise will be resolved/rejected when the requests finish.
                 */


                _createClass(BaseUpload, [{
                    key: "findPreviousUploads",
                    value: function findPreviousUploads() {
                        var _this = this;

                        return this.options.fingerprint(this.file, this.options).then(function(fingerprint) {
                            return _this._urlStorage.findUploadsByFingerprint(fingerprint);
                        });
                    }
                }, {
                    key: "resumeFromPreviousUpload",
                    value: function resumeFromPreviousUpload(previousUpload) {
                        this.url = previousUpload.uploadUrl || null;
                        this._parallelUploadUrls = previousUpload.parallelUploadUrls || null;
                        this._urlStorageKey = previousUpload.urlStorageKey;
                    }
                }, {
                    key: "start",
                    value: function start() {
                            var _this2 = this;

                            var file = this.file;

                            if (!file) {
                                this._emitError(new Error("tus: no file or stream to upload provided"));

                                return;
                            }

                            if (!this.options.endpoint && !this.options.uploadUrl) {
                                this._emitError(new Error("tus: neither an endpoint or an upload URL is provided"));

                                return;
                            }

                            var retryDelays = this.options.retryDelays;

                            if (retryDelays != null && Object.prototype.toString.call(retryDelays) !== "[object Array]") {
                                this._emitError(new Error("tus: the `retryDelays` option must either be an array or null"));

                                return;
                            }

                            if (this.options.parallelUploads > 1) {
                                // Test which options are incompatible with parallel uploads.
                                ["uploadUrl", "uploadSize", "uploadLengthDeferred"].forEach(function(optionName) {
                                    if (_this2.options[optionName]) {
                                        _this2._emitError(new Error("tus: cannot use the ".concat(optionName, " option when parallelUploads is enabled")));
                                    }
                                });
                            }

                            this.options.fingerprint(file, this.options).then(function(fingerprint) {
                                if (fingerprint == null) {
                                    (0, _logger.log)("No fingerprint was calculated meaning that the upload cannot be stored in the URL storage.");
                                } else {
                                    (0, _logger.log)("Calculated fingerprint: ".concat(fingerprint));
                                }

                                _this2._fingerprint = fingerprint;

                                if (_this2._source) {
                                    return _this2._source;
                                } else {
                                    return _this2.options.fileReader.openFile(file, _this2.options.chunkSize);
                                }
                            }).then(function(source) {
                                _this2._source = source; // If the upload was configured to use multiple requests or if we resume from
                                // an upload which used multiple requests, we start a parallel upload.

                                if (_this2.options.parallelUploads > 1 || _this2._parallelUploadUrls != null) {
                                    _this2._startParallelUpload();
                                } else {
                                    _this2._startSingleUpload();
                                }
                            })["catch"](function(err) {
                                _this2._emitError(err);
                            });
                        }
                        /**
                         * Initiate the uploading procedure for a parallelized upload, where one file is split into
                         * multiple request which are run in parallel.
                         *
                         * @api private
                         */

                }, {
                    key: "_startParallelUpload",
                    value: function _startParallelUpload() {
                            var _this3 = this;

                            var totalSize = this._size = this._source.size;
                            var totalProgress = 0;
                            this._parallelUploads = [];
                            var partCount = this._parallelUploadUrls != null ? this._parallelUploadUrls.length : this.options.parallelUploads; // The input file will be split into multiple slices which are uploaded in separate
                            // requests. Here we generate the start and end position for the slices.

                            var parts = splitSizeIntoParts(this._source.size, partCount, this._parallelUploadUrls); // Create an empty list for storing the upload URLs

                            this._parallelUploadUrls = new Array(parts.length); // Generate a promise for each slice that will be resolve if the respective
                            // upload is completed.

                            var uploads = parts.map(function(part, index) {
                                var lastPartProgress = 0;
                                return _this3._source.slice(part.start, part.end).then(function(_ref) {
                                    var value = _ref.value;
                                    return new Promise(function(resolve, reject) {
                                        // Merge with the user supplied options but overwrite some values.
                                        var options = _objectSpread({}, _this3.options, {
                                            // If available, the partial upload should be resumed from a previous URL.
                                            uploadUrl: part.uploadUrl || null,
                                            // We take manually care of resuming for partial uploads, so they should
                                            // not be stored in the URL storage.
                                            storeFingerprintForResuming: false,
                                            removeFingerprintOnSuccess: false,
                                            // Reset the parallelUploads option to not cause recursion.
                                            parallelUploads: 1,
                                            metadata: {},
                                            // Add the header to indicate the this is a partial upload.
                                            headers: _objectSpread({}, _this3.options.headers, {
                                                "Upload-Concat": "partial"
                                            }),
                                            // Reject or resolve the promise if the upload errors or completes.
                                            onSuccess: resolve,
                                            onError: reject,
                                            // Based in the progress for this partial upload, calculate the progress
                                            // for the entire final upload.
                                            onProgress: function onProgress(newPartProgress) {
                                                totalProgress = totalProgress - lastPartProgress + newPartProgress;
                                                lastPartProgress = newPartProgress;

                                                _this3._emitProgress(totalProgress, totalSize);
                                            },
                                            // Wait until every partial upload has an upload URL, so we can add
                                            // them to the URL storage.
                                            _onUploadUrlAvailable: function _onUploadUrlAvailable() {
                                                _this3._parallelUploadUrls[index] = upload.url; // Test if all uploads have received an URL

                                                if (_this3._parallelUploadUrls.filter(function(u) {
                                                        return !!u;
                                                    }).length === parts.length) {
                                                    _this3._saveUploadInUrlStorage();
                                                }
                                            }
                                        });

                                        var upload = new BaseUpload(value, options);
                                        upload.start(); // Store the upload in an array, so we can later abort them if necessary.

                                        _this3._parallelUploads.push(upload);
                                    });
                                });
                            });
                            var req; // Wait until all partial uploads are finished and we can send the POST request for
                            // creating the final upload.

                            Promise.all(uploads).then(function() {
                                req = _this3._openRequest("POST", _this3.options.endpoint);
                                req.setHeader("Upload-Concat", "final;".concat(_this3._parallelUploadUrls.join(" "))); // Add metadata if values have been added

                                var metadata = encodeMetadata(_this3.options.metadata);

                                if (metadata !== "") {
                                    req.setHeader("Upload-Metadata", metadata);
                                }

                                return _this3._sendRequest(req, null);
                            }).then(function(res) {
                                if (!inStatusCategory(res.getStatus(), 200)) {
                                    _this3._emitHttpError(req, res, "tus: unexpected response while creating upload");

                                    return;
                                }

                                var location = res.getHeader("Location");

                                if (location == null) {
                                    _this3._emitHttpError(req, res, "tus: invalid or missing Location header");

                                    return;
                                }

                                _this3.url = resolveUrl(_this3.options.endpoint, location);
                                (0, _logger.log)("Created upload at ".concat(_this3.url));

                                _this3._emitSuccess();
                            })["catch"](function(err) {
                                _this3._emitError(err);
                            });
                        }
                        /**
                         * Initiate the uploading procedure for a non-parallel upload. Here the entire file is
                         * uploaded in a sequential matter.
                         *
                         * @api private
                         */

                }, {
                    key: "_startSingleUpload",
                    value: function _startSingleUpload() {
                            // First, we look at the uploadLengthDeferred option.
                            // Next, we check if the caller has supplied a manual upload size.
                            // Finally, we try to use the calculated size from the source object.
                            if (this.options.uploadLengthDeferred) {
                                this._size = null;
                            } else if (this.options.uploadSize != null) {
                                this._size = +this.options.uploadSize;

                                if (isNaN(this._size)) {
                                    this._emitError(new Error("tus: cannot convert `uploadSize` option into a number"));

                                    return;
                                }
                            } else {
                                this._size = this._source.size;

                                if (this._size == null) {
                                    this._emitError(new Error("tus: cannot automatically derive upload's size from input and must be specified manually using the `uploadSize` option"));

                                    return;
                                }
                            } // Reset the aborted flag when the upload is started or else the
                            // _performUpload will stop before sending a request if the upload has been
                            // aborted previously.


                            this._aborted = false; // The upload had been started previously and we should reuse this URL.

                            if (this.url != null) {
                                (0, _logger.log)("Resuming upload from previous URL: ".concat(this.url));

                                this._resumeUpload();

                                return;
                            } // A URL has manually been specified, so we try to resume


                            if (this.options.uploadUrl != null) {
                                (0, _logger.log)("Resuming upload from provided URL: ".concat(this.options.url));
                                this.url = this.options.uploadUrl;

                                this._resumeUpload();

                                return;
                            } // An upload has not started for the file yet, so we start a new one


                            (0, _logger.log)("Creating a new upload");

                            this._createUpload();
                        }
                        /**
                         * Abort any running request and stop the current upload. After abort is called, no event
                         * handler will be invoked anymore. You can use the `start` method to resume the upload
                         * again.
                         * If `shouldTerminate` is true, the `terminate` function will be called to remove the
                         * current upload from the server.
                         *
                         * @param {boolean} shouldTerminate True if the upload should be deleted from the server.
                         * @return {Promise} The Promise will be resolved/rejected when the requests finish.
                         */

                }, {
                    key: "abort",
                    value: function abort(shouldTerminate, cb) {
                        var _this4 = this;

                        if (typeof cb === "function") {
                            throw new Error("tus: the abort function does not accept a callback since v2 anymore; please use the returned Promise instead");
                        } // Stop any parallel partial uploads, that have been started in _startParallelUploads.


                        if (this._parallelUploads != null) {
                            this._parallelUploads.forEach(function(upload) {
                                upload.abort(shouldTerminate);
                            });
                        } // Stop any current running request.


                        if (this._req !== null) {
                            this._req.abort();

                            this._source.close();
                        }

                        this._aborted = true; // Stop any timeout used for initiating a retry.

                        if (this._retryTimeout != null) {
                            clearTimeout(this._retryTimeout);
                            this._retryTimeout = null;
                        }

                        if (!shouldTerminate || this.url == null) {
                            return Promise.resolve();
                        }

                        return BaseUpload.terminate(this.url, this.options) // Remove entry from the URL storage since the upload URL is no longer valid.
                            .then(function() {
                                return _this4._removeFromUrlStorage();
                            });
                    }
                }, {
                    key: "_emitHttpError",
                    value: function _emitHttpError(req, res, message, causingErr) {
                        this._emitError(new _error["default"](message, causingErr, req, res));
                    }
                }, {
                    key: "_emitError",
                    value: function _emitError(err) {
                            var _this5 = this;

                            // Do not emit errors, e.g. from aborted HTTP requests, if the upload has been stopped.
                            if (this._aborted) return; // Check if we should retry, when enabled, before sending the error to the user.

                            if (this.options.retryDelays != null) {
                                // We will reset the attempt counter if
                                // - we were already able to connect to the server (offset != null) and
                                // - we were able to upload a small chunk of data to the server
                                var shouldResetDelays = this._offset != null && this._offset > this._offsetBeforeRetry;

                                if (shouldResetDelays) {
                                    this._retryAttempt = 0;
                                }

                                if (shouldRetry(err, this._retryAttempt, this.options)) {
                                    var delay = this.options.retryDelays[this._retryAttempt++];
                                    this._offsetBeforeRetry = this._offset;
                                    this._retryTimeout = setTimeout(function() {
                                        _this5.start();
                                    }, delay);
                                    return;
                                }
                            }

                            if (typeof this.options.onError === "function") {
                                this.options.onError(err);
                            } else {
                                throw err;
                            }
                        }
                        /**
                         * Publishes notification if the upload has been successfully completed.
                         *
                         * @api private
                         */

                }, {
                    key: "_emitSuccess",
                    value: function _emitSuccess() {
                            if (this.options.removeFingerprintOnSuccess) {
                                // Remove stored fingerprint and corresponding endpoint. This causes
                                // new uploads of the same file to be treated as a different file.
                                this._removeFromUrlStorage();
                            }

                            if (typeof this.options.onSuccess === "function") {
                                this.options.onSuccess();
                            }
                        }
                        /**
                         * Publishes notification when data has been sent to the server. This
                         * data may not have been accepted by the server yet.
                         *
                         * @param {number} bytesSent  Number of bytes sent to the server.
                         * @param {number} bytesTotal Total number of bytes to be sent to the server.
                         * @api private
                         */

                }, {
                    key: "_emitProgress",
                    value: function _emitProgress(bytesSent, bytesTotal) {
                            if (typeof this.options.onProgress === "function") {
                                this.options.onProgress(bytesSent, bytesTotal);
                            }
                        }
                        /**
                         * Publishes notification when a chunk of data has been sent to the server
                         * and accepted by the server.
                         * @param {number} chunkSize  Size of the chunk that was accepted by the server.
                         * @param {number} bytesAccepted Total number of bytes that have been
                         *                                accepted by the server.
                         * @param {number} bytesTotal Total number of bytes to be sent to the server.
                         * @api private
                         */

                }, {
                    key: "_emitChunkComplete",
                    value: function _emitChunkComplete(chunkSize, bytesAccepted, bytesTotal) {
                            if (typeof this.options.onChunkComplete === "function") {
                                this.options.onChunkComplete(chunkSize, bytesAccepted, bytesTotal);
                            }
                        }
                        /**
                         * Create a new upload using the creation extension by sending a POST
                         * request to the endpoint. After successful creation the file will be
                         * uploaded
                         *
                         * @api private
                         */

                }, {
                    key: "_createUpload",
                    value: function _createUpload() {
                            var _this6 = this;

                            if (!this.options.endpoint) {
                                this._emitError(new Error("tus: unable to create upload because no endpoint is provided"));

                                return;
                            }

                            var req = this._openRequest("POST", this.options.endpoint);

                            if (this.options.uploadLengthDeferred) {
                                req.setHeader("Upload-Defer-Length", 1);
                            } else {
                                req.setHeader("Upload-Length", this._size);
                            } // Add metadata if values have been added


                            var metadata = encodeMetadata(this.options.metadata);

                            if (metadata !== "") {
                                req.setHeader("Upload-Metadata", metadata);
                            }

                            var promise;

                            if (this.options.uploadDataDuringCreation && !this.options.uploadLengthDeferred) {
                                this._offset = 0;
                                promise = this._addChunkToRequest(req);
                            } else {
                                promise = this._sendRequest(req, null);
                            }

                            promise.then(function(res) {
                                if (!inStatusCategory(res.getStatus(), 200)) {
                                    _this6._emitHttpError(req, res, "tus: unexpected response while creating upload");

                                    return;
                                }

                                var location = res.getHeader("Location");

                                if (location == null) {
                                    _this6._emitHttpError(req, res, "tus: invalid or missing Location header");

                                    return;
                                }

                                _this6.url = resolveUrl(_this6.options.endpoint, location);
                                (0, _logger.log)("Created upload at ".concat(_this6.url));

                                if (typeof _this6.options._onUploadUrlAvailable === "function") {
                                    _this6.options._onUploadUrlAvailable();
                                }

                                if (_this6._size === 0) {
                                    // Nothing to upload and file was successfully created
                                    _this6._emitSuccess();

                                    _this6._source.close();

                                    return;
                                }

                                _this6._saveUploadInUrlStorage();

                                if (_this6.options.uploadDataDuringCreation) {
                                    _this6._handleUploadResponse(req, res);
                                } else {
                                    _this6._offset = 0;

                                    _this6._performUpload();
                                }
                            })["catch"](function(err) {
                                _this6._emitHttpError(req, null, "tus: failed to create upload", err);
                            });
                        }
                        /*
                         * Try to resume an existing upload. First a HEAD request will be sent
                         * to retrieve the offset. If the request fails a new upload will be
                         * created. In the case of a successful response the file will be uploaded.
                         *
                         * @api private
                         */

                }, {
                    key: "_resumeUpload",
                    value: function _resumeUpload() {
                            var _this7 = this;

                            var req = this._openRequest("HEAD", this.url);

                            var promise = this._sendRequest(req, null);

                            promise.then(function(res) {
                                var status = res.getStatus();

                                if (!inStatusCategory(status, 200)) {
                                    if (inStatusCategory(status, 400)) {
                                        // Remove stored fingerprint and corresponding endpoint,
                                        // on client errors since the file can not be found
                                        _this7._removeFromUrlStorage();
                                    } // If the upload is locked (indicated by the 423 Locked status code), we
                                    // emit an error instead of directly starting a new upload. This way the
                                    // retry logic can catch the error and will retry the upload. An upload
                                    // is usually locked for a short period of time and will be available
                                    // afterwards.


                                    if (status === 423) {
                                        _this7._emitHttpError(req, res, "tus: upload is currently locked; retry later");

                                        return;
                                    }

                                    if (!_this7.options.endpoint) {
                                        // Don't attempt to create a new upload if no endpoint is provided.
                                        _this7._emitHttpError(req, res, "tus: unable to resume upload (new upload cannot be created without an endpoint)");

                                        return;
                                    } // Try to create a new upload


                                    _this7.url = null;

                                    _this7._createUpload();

                                    return;
                                }

                                var offset = parseInt(res.getHeader("Upload-Offset"), 10);

                                if (isNaN(offset)) {
                                    _this7._emitHttpError(req, res, "tus: invalid or missing offset value");

                                    return;
                                }

                                var length = parseInt(res.getHeader("Upload-Length"), 10);

                                if (isNaN(length) && !_this7.options.uploadLengthDeferred) {
                                    _this7._emitHttpError(req, res, "tus: invalid or missing length value");

                                    return;
                                }

                                if (typeof _this7.options._onUploadUrlAvailable === "function") {
                                    _this7.options._onUploadUrlAvailable();
                                } // Upload has already been completed and we do not need to send additional
                                // data to the server


                                if (offset === length) {
                                    _this7._emitProgress(length, length);

                                    _this7._emitSuccess();

                                    return;
                                }

                                _this7._offset = offset;

                                _this7._performUpload();
                            })["catch"](function(err) {
                                _this7._emitHttpError(req, null, "tus: failed to resume upload", err);
                            });
                        }
                        /**
                         * Start uploading the file using PATCH requests. The file will be divided
                         * into chunks as specified in the chunkSize option. During the upload
                         * the onProgress event handler may be invoked multiple times.
                         *
                         * @api private
                         */

                }, {
                    key: "_performUpload",
                    value: function _performUpload() {
                            var _this8 = this;

                            // If the upload has been aborted, we will not send the next PATCH request.
                            // This is important if the abort method was called during a callback, such
                            // as onChunkComplete or onProgress.
                            if (this._aborted) {
                                return;
                            }

                            var req; // Some browser and servers may not support the PATCH method. For those
                            // cases, you can tell tus-js-client to use a POST request with the
                            // X-HTTP-Method-Override header for simulating a PATCH request.

                            if (this.options.overridePatchMethod) {
                                req = this._openRequest("POST", this.url);
                                req.setHeader("X-HTTP-Method-Override", "PATCH");
                            } else {
                                req = this._openRequest("PATCH", this.url);
                            }

                            req.setHeader("Upload-Offset", this._offset);

                            var promise = this._addChunkToRequest(req);

                            promise.then(function(res) {
                                if (!inStatusCategory(res.getStatus(), 200)) {
                                    _this8._emitHttpError(req, res, "tus: unexpected response while uploading chunk");

                                    return;
                                }

                                _this8._handleUploadResponse(req, res);
                            })["catch"](function(err) {
                                // Don't emit an error if the upload was aborted manually
                                if (_this8._aborted) {
                                    return;
                                }

                                _this8._emitHttpError(req, null, "tus: failed to upload chunk at offset " + _this8._offset, err);
                            });
                        }
                        /**
                         * _addChunktoRequest reads a chunk from the source and sends it using the
                         * supplied request object. It will not handle the response.
                         *
                         * @api private
                         */

                }, {
                    key: "_addChunkToRequest",
                    value: function _addChunkToRequest(req) {
                            var _this9 = this;

                            var start = this._offset;
                            var end = this._offset + this.options.chunkSize;
                            req.setProgressHandler(function(bytesSent) {
                                _this9._emitProgress(start + bytesSent, _this9._size);
                            });
                            req.setHeader("Content-Type", "application/offset+octet-stream"); // The specified chunkSize may be Infinity or the calcluated end position
                            // may exceed the file's size. In both cases, we limit the end position to
                            // the input's total size for simpler calculations and correctness.

                            if ((end === Infinity || end > this._size) && !this.options.uploadLengthDeferred) {
                                end = this._size;
                            }

                            return this._source.slice(start, end).then(function(_ref2) {
                                var value = _ref2.value,
                                    done = _ref2.done;

                                // If the upload length is deferred, the upload size was not specified during
                                // upload creation. So, if the file reader is done reading, we know the total
                                // upload size and can tell the tus server.
                                if (_this9.options.uploadLengthDeferred && done) {
                                    _this9._size = _this9._offset + (value && value.size ? value.size : 0);
                                    req.setHeader("Upload-Length", _this9._size);
                                }

                                if (value === null) {
                                    return _this9._sendRequest(req);
                                } else {
                                    _this9._emitProgress(_this9._offset, _this9._size);

                                    return _this9._sendRequest(req, value);
                                }
                            });
                        }
                        /**
                         * _handleUploadResponse is used by requests that haven been sent using _addChunkToRequest
                         * and already have received a response.
                         *
                         * @api private
                         */

                }, {
                    key: "_handleUploadResponse",
                    value: function _handleUploadResponse(req, res) {
                            var offset = parseInt(res.getHeader("Upload-Offset"), 10);

                            if (isNaN(offset)) {
                                this._emitHttpError(req, res, "tus: invalid or missing offset value");

                                return;
                            }

                            this._emitProgress(offset, this._size);

                            this._emitChunkComplete(offset - this._offset, offset, this._size);

                            this._offset = offset;

                            if (offset == this._size) {
                                // Yay, finally done :)
                                this._emitSuccess();

                                this._source.close();

                                return;
                            }

                            this._performUpload();
                        }
                        /**
                         * Create a new HTTP request object with the given method and URL.
                         *
                         * @api private
                         */

                }, {
                    key: "_openRequest",
                    value: function _openRequest(method, url) {
                            var req = openRequest(method, url, this.options);
                            this._req = req;
                            return req;
                        }
                        /**
                         * Remove the entry in the URL storage, if it has been saved before.
                         *
                         * @api private
                         */

                }, {
                    key: "_removeFromUrlStorage",
                    value: function _removeFromUrlStorage() {
                            var _this10 = this;

                            if (!this._urlStorageKey) return;

                            this._urlStorage.removeUpload(this._urlStorageKey)["catch"](function(err) {
                                _this10._emitError(err);
                            });

                            this._urlStorageKey = null;
                        }
                        /**
                         * Add the upload URL to the URL storage, if possible.
                         *
                         * @api private
                         */

                }, {
                    key: "_saveUploadInUrlStorage",
                    value: function _saveUploadInUrlStorage() {
                            var _this11 = this;

                            // Only if a fingerprint was calculated for the input (i.e. not a stream), we can store the upload URL.
                            if (!this.options.storeFingerprintForResuming || !this._fingerprint) {
                                return;
                            }

                            var storedUpload = {
                                size: this._size,
                                metadata: this.options.metadata,
                                creationTime: new Date().toString()
                            };

                            if (this._parallelUploads) {
                                // Save multiple URLs if the parallelUploads option is used ...
                                storedUpload.parallelUploadUrls = this._parallelUploadUrls;
                            } else {
                                // ... otherwise we just save the one available URL.
                                storedUpload.uploadUrl = this.url;
                            }

                            this._urlStorage.addUpload(this._fingerprint, storedUpload).then(function(urlStorageKey) {
                                return _this11._urlStorageKey = urlStorageKey;
                            })["catch"](function(err) {
                                _this11._emitError(err);
                            });
                        }
                        /**
                         * Send a request with the provided body while invoking the onBeforeRequest
                         * and onAfterResponse callbacks.
                         *
                         * @api private
                         */

                }, {
                    key: "_sendRequest",
                    value: function _sendRequest(req) {
                        var _this12 = this;

                        var body = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

                        if (typeof this.options.onBeforeRequest === "function") {
                            this.options.onBeforeRequest(req);
                        }

                        return req.send(body).then(function(res) {
                            if (typeof _this12.options.onAfterResponse === "function") {
                                _this12.options.onAfterResponse(req, res);
                            }

                            return res;
                        });
                    }
                }], [{
                    key: "terminate",
                    value: function terminate(url) {
                        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
                        var cb = arguments.length > 2 ? arguments[2] : undefined;

                        if (typeof options === "function" || typeof cb === "function") {
                            throw new Error("tus: the terminate function does not accept a callback since v2 anymore; please use the returned Promise instead");
                        }

                        var req = openRequest("DELETE", url, options);
                        var promise = req.send();
                        return promise.then(function(res) {
                            // A 204 response indicates a successfull request
                            if (res.getStatus() === 204) {
                                return;
                            }

                            throw new _error["default"]("tus: unexpected response while terminating upload", null, req, res);
                        })["catch"](function(err) {
                            if (!(err instanceof _error["default"])) {
                                err = new _error["default"]("tus: failed to terminate upload", err, req, null);
                            }

                            if (!shouldRetry(err, 0, options)) {
                                throw err;
                            } // Instead of keeping track of the retry attempts, we remove the first element from the delays
                            // array. If the array is empty, all retry attempts are used up and we will bubble up the error.
                            // We recursively call the terminate function will removing elements from the retryDelays array.


                            var delay = options.retryDelays[0];
                            var remainingDelays = options.retryDelays.slice(1);

                            var newOptions = _objectSpread({}, options, {
                                retryDelays: remainingDelays
                            });

                            return new Promise(function(resolve) {
                                return setTimeout(resolve, delay);
                            }).then(function() {
                                return BaseUpload.terminate(url, newOptions);
                            });
                        });
                    }
                }]);

                return BaseUpload;
            }();

            function encodeMetadata(metadata) {
                var encoded = [];

                for (var key in metadata) {
                    encoded.push(key + " " + _jsBase.Base64.encode(metadata[key]));
                }

                return encoded.join(",");
            }
            /**
             * Checks whether a given status is in the range of the expected category.
             * For example, only a status between 200 and 299 will satisfy the category 200.
             *
             * @api private
             */


            function inStatusCategory(status, category) {
                return status >= category && status < category + 100;
            }
            /**
             * Create a new HTTP request with the specified method and URL.
             * The necessary headers that are included in every request
             * will be added, including the request ID.
             *
             * @api private
             */


            function openRequest(method, url, options) {
                var req = options.httpStack.createRequest(method, url);
                req.setHeader("Tus-Resumable", "1.0.0");
                var headers = options.headers || {};

                for (var name in headers) {
                    req.setHeader(name, headers[name]);
                }

                if (options.addRequestId) {
                    var requestId = (0, _uuid["default"])();
                    req.setHeader("X-Request-ID", requestId);
                }

                return req;
            }
            /**
             * Checks whether the browser running this code has internet access.
             * This function will always return true in the node.js environment
             *
             * @api private
             */


            function isOnline() {
                var online = true;

                if (typeof window !== "undefined" && "navigator" in window && window.navigator.onLine === false) {
                    online = false;
                }

                return online;
            }
            /**
             * Checks whether or not it is ok to retry a request.
             * @param {Error} err the error returned from the last request
             * @param {number} retryAttempt the number of times the request has already been retried
             * @param {object} options tus Upload options
             *
             * @api private
             */


            function shouldRetry(err, retryAttempt, options) {
                // We only attempt a retry if
                // - retryDelays option is set
                // - we didn't exceed the maxium number of retries, yet, and
                // - this error was caused by a request or it's response and
                // - the error is server error (i.e. no a status 4xx or a 409 or 423) and
                // - the browser does not indicate that we are offline
                var status = err.originalResponse ? err.originalResponse.getStatus() : 0;
                var isServerError = !inStatusCategory(status, 400) || status === 409 || status === 423;
                return options.retryDelays != null && retryAttempt < options.retryDelays.length && err.originalRequest != null && isServerError && isOnline();
            }
            /**
             * Resolve a relative link given the origin as source. For example,
             * if a HTTP request to http://example.com/files/ returns a Location
             * header with the value /upload/abc, the resolved URL will be:
             * http://example.com/upload/abc
             */


            function resolveUrl(origin, link) {
                return new _urlParse["default"](link, origin).toString();
            }
            /**
             * Calculate the start and end positions for the parts if an upload
             * is split into multiple parallel requests.
             *
             * @param {number} totalSize The byte size of the upload, which will be split.
             * @param {number} partCount The number in how many parts the upload will be split.
             * @param {string[]} previousUrls The upload URLs for previous parts.
             * @return {object[]}
             * @api private
             */


            function splitSizeIntoParts(totalSize, partCount, previousUrls) {
                var partSize = Math.floor(totalSize / partCount);
                var parts = [];

                for (var i = 0; i < partCount; i++) {
                    parts.push({
                        start: partSize * i,
                        end: partSize * (i + 1)
                    });
                }

                parts[partCount - 1].end = totalSize; // Attach URLs from previous uploads, if available.

                if (previousUrls) {
                    parts.forEach(function(part, index) {
                        part.uploadUrl = previousUrls[index] || null;
                    });
                }

                return parts;
            }

            BaseUpload.defaultOptions = defaultOptions;
            var _default = BaseUpload;
            exports["default"] = _default;

        }, { "./error": 10, "./logger": 11, "./uuid": 14, "js-base64": 15, "url-parse": 18 }],
        14: [function(require, module, exports) {
            "use strict";

            Object.defineProperty(exports, "__esModule", {
                value: true
            });
            exports["default"] = uuid;

            /**
             * Generate a UUID v4 based on random numbers. We intentioanlly use the less
             * secure Math.random function here since the more secure crypto.getRandomNumbers
             * is not available on all platforms.
             * This is not a problem for us since we use the UUID only for generating a
             * request ID, so we can correlate server logs to client errors.
             *
             * This function is taken from following site:
             * https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript
             *
             * @return {string} The generate UUID
             */
            function uuid() {
                return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
                    var r = Math.random() * 16 | 0,
                        v = c == "x" ? r : r & 0x3 | 0x8;
                    return v.toString(16);
                });
            }

        }, {}],
        15: [function(require, module, exports) {
            (function(global) {
                /*
                 *  base64.js
                 *
                 *  Licensed under the BSD 3-Clause License.
                 *    http://opensource.org/licenses/BSD-3-Clause
                 *
                 *  References:
                 *    http://en.wikipedia.org/wiki/Base64
                 */
                ;
                (function(global, factory) {
                    typeof exports === 'object' && typeof module !== 'undefined' ?
                        module.exports = factory(global) :
                        typeof define === 'function' && define.amd ?
                        define(factory) : factory(global)
                }((
                    typeof self !== 'undefined' ? self :
                    typeof window !== 'undefined' ? window :
                    typeof global !== 'undefined' ? global :
                    this
                ), function(global) {
                    'use strict';
                    // existing version for noConflict()
                    var _Base64 = global.Base64;
                    var version = "2.4.9";
                    // if node.js and NOT React Native, we use Buffer
                    var buffer;
                    if (typeof module !== 'undefined' && module.exports) {
                        try {
                            buffer = eval("require('buffer').Buffer");
                        } catch (err) {
                            buffer = undefined;
                        }
                    }
                    // constants
                    var b64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
                    var b64tab = function(bin) {
                        var t = {};
                        for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;
                        return t;
                    }(b64chars);
                    var fromCharCode = String.fromCharCode;
                    // encoder stuff
                    var cb_utob = function(c) {
                        if (c.length < 2) {
                            var cc = c.charCodeAt(0);
                            return cc < 0x80 ? c :
                                cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6)) +
                                    fromCharCode(0x80 | (cc & 0x3f))) :
                                (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f)) +
                                    fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) +
                                    fromCharCode(0x80 | (cc & 0x3f)));
                        } else {
                            var cc = 0x10000 +
                                (c.charCodeAt(0) - 0xD800) * 0x400 +
                                (c.charCodeAt(1) - 0xDC00);
                            return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07)) +
                                fromCharCode(0x80 | ((cc >>> 12) & 0x3f)) +
                                fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) +
                                fromCharCode(0x80 | (cc & 0x3f)));
                        }
                    };
                    var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
                    var utob = function(u) {
                        return u.replace(re_utob, cb_utob);
                    };
                    var cb_encode = function(ccc) {
                        var padlen = [0, 2, 1][ccc.length % 3],
                            ord = ccc.charCodeAt(0) << 16 |
                            ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8) |
                            ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),
                            chars = [
                                b64chars.charAt(ord >>> 18),
                                b64chars.charAt((ord >>> 12) & 63),
                                padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),
                                padlen >= 1 ? '=' : b64chars.charAt(ord & 63)
                            ];
                        return chars.join('');
                    };
                    var btoa = global.btoa ? function(b) {
                        return global.btoa(b);
                    } : function(b) {
                        return b.replace(/[\s\S]{1,3}/g, cb_encode);
                    };
                    var _encode = buffer ?
                        buffer.from && Uint8Array && buffer.from !== Uint8Array.from ?

                        function(u) {
                            return (u.constructor === buffer.constructor ? u : buffer.from(u))
                                .toString('base64')
                        } :
                        function(u) {
                            return (u.constructor === buffer.constructor ? u : new buffer(u))
                                .toString('base64')
                        } :
                        function(u) { return btoa(utob(u)) };
                    var encode = function(u, urisafe) {
                        return !urisafe ?
                            _encode(String(u)) :
                            _encode(String(u)).replace(/[+\/]/g, function(m0) {
                                return m0 == '+' ? '-' : '_';
                            }).replace(/=/g, '');
                    };
                    var encodeURI = function(u) { return encode(u, true) };
                    // decoder stuff
                    var re_btou = new RegExp([
                        '[\xC0-\xDF][\x80-\xBF]',
                        '[\xE0-\xEF][\x80-\xBF]{2}',
                        '[\xF0-\xF7][\x80-\xBF]{3}'
                    ].join('|'), 'g');
                    var cb_btou = function(cccc) {
                        switch (cccc.length) {
                            case 4:
                                var cp = ((0x07 & cccc.charCodeAt(0)) << 18) |
                                    ((0x3f & cccc.charCodeAt(1)) << 12) |
                                    ((0x3f & cccc.charCodeAt(2)) << 6) |
                                    (0x3f & cccc.charCodeAt(3)),
                                    offset = cp - 0x10000;
                                return (fromCharCode((offset >>> 10) + 0xD800) +
                                    fromCharCode((offset & 0x3FF) + 0xDC00));
                            case 3:
                                return fromCharCode(
                                    ((0x0f & cccc.charCodeAt(0)) << 12) |
                                    ((0x3f & cccc.charCodeAt(1)) << 6) |
                                    (0x3f & cccc.charCodeAt(2))
                                );
                            default:
                                return fromCharCode(
                                    ((0x1f & cccc.charCodeAt(0)) << 6) |
                                    (0x3f & cccc.charCodeAt(1))
                                );
                        }
                    };
                    var btou = function(b) {
                        return b.replace(re_btou, cb_btou);
                    };
                    var cb_decode = function(cccc) {
                        var len = cccc.length,
                            padlen = len % 4,
                            n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0) |
                            (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0) |
                            (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0) |
                            (len > 3 ? b64tab[cccc.charAt(3)] : 0),
                            chars = [
                                fromCharCode(n >>> 16),
                                fromCharCode((n >>> 8) & 0xff),
                                fromCharCode(n & 0xff)
                            ];
                        chars.length -= [0, 0, 2, 1][padlen];
                        return chars.join('');
                    };
                    var atob = global.atob ? function(a) {
                        return global.atob(a);
                    } : function(a) {
                        return a.replace(/[\s\S]{1,4}/g, cb_decode);
                    };
                    var _decode = buffer ?
                        buffer.from && Uint8Array && buffer.from !== Uint8Array.from ?

                        function(a) {
                            return (a.constructor === buffer.constructor ?
                                a : buffer.from(a, 'base64')).toString();
                        } :
                        function(a) {
                            return (a.constructor === buffer.constructor ?
                                a : new buffer(a, 'base64')).toString();
                        } :
                        function(a) { return btou(atob(a)) };
                    var decode = function(a) {
                        return _decode(
                            String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })
                            .replace(/[^A-Za-z0-9\+\/]/g, '')
                        );
                    };
                    var noConflict = function() {
                        var Base64 = global.Base64;
                        global.Base64 = _Base64;
                        return Base64;
                    };
                    // export Base64
                    global.Base64 = {
                        VERSION: version,
                        atob: atob,
                        btoa: btoa,
                        fromBase64: decode,
                        toBase64: encode,
                        utob: utob,
                        encode: encode,
                        encodeURI: encodeURI,
                        btou: btou,
                        decode: decode,
                        noConflict: noConflict,
                        __buffer__: buffer
                    };
                    // if ES5 is available, make Base64.extendString() available
                    if (typeof Object.defineProperty === 'function') {
                        var noEnum = function(v) {
                            return { value: v, enumerable: false, writable: true, configurable: true };
                        };
                        global.Base64.extendString = function() {
                            Object.defineProperty(
                                String.prototype, 'fromBase64', noEnum(function() {
                                    return decode(this)
                                }));
                            Object.defineProperty(
                                String.prototype, 'toBase64', noEnum(function(urisafe) {
                                    return encode(this, urisafe)
                                }));
                            Object.defineProperty(
                                String.prototype, 'toBase64URI', noEnum(function() {
                                    return encode(this, true)
                                }));
                        };
                    }
                    //
                    // export Base64 to the namespace
                    //
                    if (global['Meteor']) { // Meteor.js
                        Base64 = global.Base64;
                    }
                    // module.exports and AMD are mutually exclusive.
                    // module.exports has precedence.
                    if (typeof module !== 'undefined' && module.exports) {
                        module.exports.Base64 = global.Base64;
                    } else if (typeof define === 'function' && define.amd) {
                        // AMD. Register as an anonymous module.
                        define([], function() { return global.Base64 });
                    }
                    // that's it!
                    return { Base64: global.Base64 }
                }));

            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

        }, {}],
        16: [function(require, module, exports) {
            'use strict';

            var has = Object.prototype.hasOwnProperty;

            /**
             * Decode a URI encoded string.
             *
             * @param {String} input The URI encoded string.
             * @returns {String} The decoded string.
             * @api private
             */
            function decode(input) {
                return decodeURIComponent(input.replace(/\+/g, ' '));
            }

            /**
             * Simple query string parser.
             *
             * @param {String} query The query string that needs to be parsed.
             * @returns {Object}
             * @api public
             */
            function querystring(query) {
                var parser = /([^=?&]+)=?([^&]*)/g,
                    result = {},
                    part;

                while (part = parser.exec(query)) {
                    var key = decode(part[1]),
                        value = decode(part[2]);

                    //
                    // Prevent overriding of existing properties. This ensures that build-in
                    // methods like `toString` or __proto__ are not overriden by malicious
                    // querystrings.
                    //
                    if (key in result) continue;
                    result[key] = value;
                }

                return result;
            }

            /**
             * Transform a query string to an object.
             *
             * @param {Object} obj Object that should be transformed.
             * @param {String} prefix Optional prefix.
             * @returns {String}
             * @api public
             */
            function querystringify(obj, prefix) {
                prefix = prefix || '';

                var pairs = [];

                //
                // Optionally prefix with a '?' if needed
                //
                if ('string' !== typeof prefix) prefix = '?';

                for (var key in obj) {
                    if (has.call(obj, key)) {
                        pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(obj[key]));
                    }
                }

                return pairs.length ? prefix + pairs.join('&') : '';
            }

            //
            // Expose the module.
            //
            exports.stringify = querystringify;
            exports.parse = querystring;

        }, {}],
        17: [function(require, module, exports) {
            'use strict';

            /**
             * Check if we're required to add a port number.
             *
             * @see https://url.spec.whatwg.org/#default-port
             * @param {Number|String} port Port number we need to check
             * @param {String} protocol Protocol we need to check against.
             * @returns {Boolean} Is it a default port for the given protocol
             * @api private
             */
            module.exports = function required(port, protocol) {
                protocol = protocol.split(':')[0];
                port = +port;

                if (!port) return false;

                switch (protocol) {
                    case 'http':
                    case 'ws':
                        return port !== 80;

                    case 'https':
                    case 'wss':
                        return port !== 443;

                    case 'ftp':
                        return port !== 21;

                    case 'gopher':
                        return port !== 70;

                    case 'file':
                        return false;
                }

                return port !== 0;
            };

        }, {}],
        18: [function(require, module, exports) {
            (function(global) {
                'use strict';

                var required = require('requires-port'),
                    qs = require('querystringify'),
                    protocolre = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\S\s]*)/i,
                    slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//;

                /**
                 * These are the parse rules for the URL parser, it informs the parser
                 * about:
                 *
                 * 0. The char it Needs to parse, if it's a string it should be done using
                 *    indexOf, RegExp using exec and NaN means set as current value.
                 * 1. The property we should set when parsing this value.
                 * 2. Indication if it's backwards or forward parsing, when set as number it's
                 *    the value of extra chars that should be split off.
                 * 3. Inherit from location if non existing in the parser.
                 * 4. `toLowerCase` the resulting value.
                 */
                var rules = [
                    ['#', 'hash'], // Extract from the back.
                    ['?', 'query'], // Extract from the back.
                    function sanitize(address) { // Sanitize what is left of the address
                        return address.replace('\\', '/');
                    },
                    ['/', 'pathname'], // Extract from the back.
                    ['@', 'auth', 1], // Extract from the front.
                    [NaN, 'host', undefined, 1, 1], // Set left over value.
                    [/:(\d+)$/, 'port', undefined, 1], // RegExp the back.
                    [NaN, 'hostname', undefined, 1, 1] // Set left over.
                ];

                /**
                 * These properties should not be copied or inherited from. This is only needed
                 * for all non blob URL's as a blob URL does not include a hash, only the
                 * origin.
                 *
                 * @type {Object}
                 * @private
                 */
                var ignore = { hash: 1, query: 1 };

                /**
                 * The location object differs when your code is loaded through a normal page,
                 * Worker or through a worker using a blob. And with the blobble begins the
                 * trouble as the location object will contain the URL of the blob, not the
                 * location of the page where our code is loaded in. The actual origin is
                 * encoded in the `pathname` so we can thankfully generate a good "default"
                 * location from it so we can generate proper relative URL's again.
                 *
                 * @param {Object|String} loc Optional default location object.
                 * @returns {Object} lolcation object.
                 * @public
                 */
                function lolcation(loc) {
                    var location = global && global.location || {};
                    loc = loc || location;

                    var finaldestination = {},
                        type = typeof loc,
                        key;

                    if ('blob:' === loc.protocol) {
                        finaldestination = new Url(unescape(loc.pathname), {});
                    } else if ('string' === type) {
                        finaldestination = new Url(loc, {});
                        for (key in ignore) delete finaldestination[key];
                    } else if ('object' === type) {
                        for (key in loc) {
                            if (key in ignore) continue;
                            finaldestination[key] = loc[key];
                        }

                        if (finaldestination.slashes === undefined) {
                            finaldestination.slashes = slashes.test(loc.href);
                        }
                    }

                    return finaldestination;
                }

                /**
                 * @typedef ProtocolExtract
                 * @type Object
                 * @property {String} protocol Protocol matched in the URL, in lowercase.
                 * @property {Boolean} slashes `true` if protocol is followed by "//", else `false`.
                 * @property {String} rest Rest of the URL that is not part of the protocol.
                 */

                /**
                 * Extract protocol information from a URL with/without double slash ("//").
                 *
                 * @param {String} address URL we want to extract from.
                 * @return {ProtocolExtract} Extracted information.
                 * @private
                 */
                function extractProtocol(address) {
                    var match = protocolre.exec(address);

                    return {
                        protocol: match[1] ? match[1].toLowerCase() : '',
                        slashes: !!match[2],
                        rest: match[3]
                    };
                }

                /**
                 * Resolve a relative URL pathname against a base URL pathname.
                 *
                 * @param {String} relative Pathname of the relative URL.
                 * @param {String} base Pathname of the base URL.
                 * @return {String} Resolved pathname.
                 * @private
                 */
                function resolve(relative, base) {
                    var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/')),
                        i = path.length,
                        last = path[i - 1],
                        unshift = false,
                        up = 0;

                    while (i--) {
                        if (path[i] === '.') {
                            path.splice(i, 1);
                        } else if (path[i] === '..') {
                            path.splice(i, 1);
                            up++;
                        } else if (up) {
                            if (i === 0) unshift = true;
                            path.splice(i, 1);
                            up--;
                        }
                    }

                    if (unshift) path.unshift('');
                    if (last === '.' || last === '..') path.push('');

                    return path.join('/');
                }

                /**
                 * The actual URL instance. Instead of returning an object we've opted-in to
                 * create an actual constructor as it's much more memory efficient and
                 * faster and it pleases my OCD.
                 *
                 * It is worth noting that we should not use `URL` as class name to prevent
                 * clashes with the global URL instance that got introduced in browsers.
                 *
                 * @constructor
                 * @param {String} address URL we want to parse.
                 * @param {Object|String} location Location defaults for relative paths.
                 * @param {Boolean|Function} parser Parser for the query string.
                 * @private
                 */
                function Url(address, location, parser) {
                    if (!(this instanceof Url)) {
                        return new Url(address, location, parser);
                    }

                    var relative, extracted, parse, instruction, index, key, instructions = rules.slice(),
                        type = typeof location,
                        url = this,
                        i = 0;

                    //
                    // The following if statements allows this module two have compatibility with
                    // 2 different API:
                    //
                    // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments
                    //    where the boolean indicates that the query string should also be parsed.
                    //
                    // 2. The `URL` interface of the browser which accepts a URL, object as
                    //    arguments. The supplied object will be used as default values / fall-back
                    //    for relative paths.
                    //
                    if ('object' !== type && 'string' !== type) {
                        parser = location;
                        location = null;
                    }

                    if (parser && 'function' !== typeof parser) parser = qs.parse;

                    location = lolcation(location);

                    //
                    // Extract protocol information before running the instructions.
                    //
                    extracted = extractProtocol(address || '');
                    relative = !extracted.protocol && !extracted.slashes;
                    url.slashes = extracted.slashes || relative && location.slashes;
                    url.protocol = extracted.protocol || location.protocol || '';
                    address = extracted.rest;

                    //
                    // When the authority component is absent the URL starts with a path
                    // component.
                    //
                    if (!extracted.slashes) instructions[3] = [/(.*)/, 'pathname'];

                    for (; i < instructions.length; i++) {
                        instruction = instructions[i];

                        if (typeof instruction === 'function') {
                            address = instruction(address);
                            continue;
                        }

                        parse = instruction[0];
                        key = instruction[1];

                        if (parse !== parse) {
                            url[key] = address;
                        } else if ('string' === typeof parse) {
                            if (~(index = address.indexOf(parse))) {
                                if ('number' === typeof instruction[2]) {
                                    url[key] = address.slice(0, index);
                                    address = address.slice(index + instruction[2]);
                                } else {
                                    url[key] = address.slice(index);
                                    address = address.slice(0, index);
                                }
                            }
                        } else if ((index = parse.exec(address))) {
                            url[key] = index[1];
                            address = address.slice(0, index.index);
                        }

                        url[key] = url[key] || (
                            relative && instruction[3] ? location[key] || '' : ''
                        );

                        //
                        // Hostname, host and protocol should be lowercased so they can be used to
                        // create a proper `origin`.
                        //
                        if (instruction[4]) url[key] = url[key].toLowerCase();
                    }

                    //
                    // Also parse the supplied query string in to an object. If we're supplied
                    // with a custom parser as function use that instead of the default build-in
                    // parser.
                    //
                    if (parser) url.query = parser(url.query);

                    //
                    // If the URL is relative, resolve the pathname against the base URL.
                    //
                    if (
                        relative &&
                        location.slashes &&
                        url.pathname.charAt(0) !== '/' &&
                        (url.pathname !== '' || location.pathname !== '')
                    ) {
                        url.pathname = resolve(url.pathname, location.pathname);
                    }

                    //
                    // We should not add port numbers if they are already the default port number
                    // for a given protocol. As the host also contains the port number we're going
                    // override it with the hostname which contains no port number.
                    //
                    if (!required(url.port, url.protocol)) {
                        url.host = url.hostname;
                        url.port = '';
                    }

                    //
                    // Parse down the `auth` for the username and password.
                    //
                    url.username = url.password = '';
                    if (url.auth) {
                        instruction = url.auth.split(':');
                        url.username = instruction[0] || '';
                        url.password = instruction[1] || '';
                    }

                    url.origin = url.protocol && url.host && url.protocol !== 'file:' ?
                        url.protocol + '//' + url.host :
                        'null';

                    //
                    // The href is just the compiled result.
                    //
                    url.href = url.toString();
                }

                /**
                 * This is convenience method for changing properties in the URL instance to
                 * insure that they all propagate correctly.
                 *
                 * @param {String} part          Property we need to adjust.
                 * @param {Mixed} value          The newly assigned value.
                 * @param {Boolean|Function} fn  When setting the query, it will be the function
                 *                               used to parse the query.
                 *                               When setting the protocol, double slash will be
                 *                               removed from the final url if it is true.
                 * @returns {URL} URL instance for chaining.
                 * @public
                 */
                function set(part, value, fn) {
                    var url = this;

                    switch (part) {
                        case 'query':
                            if ('string' === typeof value && value.length) {
                                value = (fn || qs.parse)(value);
                            }

                            url[part] = value;
                            break;

                        case 'port':
                            url[part] = value;

                            if (!required(value, url.protocol)) {
                                url.host = url.hostname;
                                url[part] = '';
                            } else if (value) {
                                url.host = url.hostname + ':' + value;
                            }

                            break;

                        case 'hostname':
                            url[part] = value;

                            if (url.port) value += ':' + url.port;
                            url.host = value;
                            break;

                        case 'host':
                            url[part] = value;

                            if (/:\d+$/.test(value)) {
                                value = value.split(':');
                                url.port = value.pop();
                                url.hostname = value.join(':');
                            } else {
                                url.hostname = value;
                                url.port = '';
                            }

                            break;

                        case 'protocol':
                            url.protocol = value.toLowerCase();
                            url.slashes = !fn;
                            break;

                        case 'pathname':
                        case 'hash':
                            if (value) {
                                var char = part === 'pathname' ? '/' : '#';
                                url[part] = value.charAt(0) !== char ? char + value : value;
                            } else {
                                url[part] = value;
                            }
                            break;

                        default:
                            url[part] = value;
                    }

                    for (var i = 0; i < rules.length; i++) {
                        var ins = rules[i];

                        if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();
                    }

                    url.origin = url.protocol && url.host && url.protocol !== 'file:' ?
                        url.protocol + '//' + url.host :
                        'null';

                    url.href = url.toString();

                    return url;
                }

                /**
                 * Transform the properties back in to a valid and full URL string.
                 *
                 * @param {Function} stringify Optional query stringify function.
                 * @returns {String} Compiled version of the URL.
                 * @public
                 */
                function toString(stringify) {
                    if (!stringify || 'function' !== typeof stringify) stringify = qs.stringify;

                    var query, url = this,
                        protocol = url.protocol;

                    if (protocol && protocol.charAt(protocol.length - 1) !== ':') protocol += ':';

                    var result = protocol + (url.slashes ? '//' : '');

                    if (url.username) {
                        result += url.username;
                        if (url.password) result += ':' + url.password;
                        result += '@';
                    }

                    result += url.host + url.pathname;

                    query = 'object' === typeof url.query ? stringify(url.query) : url.query;
                    if (query) result += '?' !== query.charAt(0) ? '?' + query : query;

                    if (url.hash) result += url.hash;

                    return result;
                }

                Url.prototype = { set: set, toString: toString };

                //
                // Expose the URL parser and some additional properties that might be useful for
                // others or testing.
                //
                Url.extractProtocol = extractProtocol;
                Url.location = lolcation;
                Url.qs = qs;

                module.exports = Url;

            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

        }, { "querystringify": 16, "requires-port": 17 }]
    }, {}, [4])(4)
});
//# sourceMappingURL=tus.js.map