wcz-test 6.24.4 → 6.24.6

package/dist/chunks/FileHooks-DdKh9cZa.js

@@ -0,0 +1,3478 @@
+import { c } from "react/compiler-runtime";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import saveAs from "file-saver";
+import { useState } from "react";
+import { uuidv7 } from "uuidv7";
+import z__default from "zod";
+import { F as FileMetaSchema } from "./FileMeta-G1oT3mYK.js";
+import { t as toKebabCase, h as httpClient } from "./utils-MD9YwOtu.js";
+import { c as clientEnv } from "./env-gsqZ6zZD.js";
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function _typeof$8(o) {
+  "@babel/helpers - typeof";
+  return _typeof$8 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof$8(o);
+}
+function _createClass$8(Constructor, protoProps, staticProps) {
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _classCallCheck$8(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _callSuper$1(t, o, e) {
+  return o = _getPrototypeOf$1(o), _possibleConstructorReturn$1(t, _isNativeReflectConstruct$1() ? Reflect.construct(o, e || [], _getPrototypeOf$1(t).constructor) : o.apply(t, e));
+}
+function _possibleConstructorReturn$1(self2, call) {
+  if (call && (_typeof$8(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized$1(self2);
+}
+function _assertThisInitialized$1(self2) {
+  if (self2 === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self2;
+}
+function _inherits$1(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 } });
+  Object.defineProperty(subClass, "prototype", { writable: false });
+  if (superClass) _setPrototypeOf$1(subClass, superClass);
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+  _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+    if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
+    if (typeof Class2 !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class2)) return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _getPrototypeOf$1(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
+    return _setPrototypeOf$1(Wrapper, Class2);
+  };
+  return _wrapNativeSuper(Class);
+}
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct$1()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf$1(p, r.prototype), p;
+}
+function _isNativeReflectConstruct$1() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch (t2) {
+  }
+  return (_isNativeReflectConstruct$1 = function _isNativeReflectConstruct2() {
+    return !!t;
+  })();
+}
+function _isNativeFunction(fn) {
+  try {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+  } catch (e) {
+    return typeof fn === "function";
+  }
+}
+function _setPrototypeOf$1(o, p) {
+  _setPrototypeOf$1 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf$1(o, p);
+}
+function _getPrototypeOf$1(o) {
+  _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf$1(o);
+}
+var DetailedError = /* @__PURE__ */ (function(_Error) {
+  function DetailedError2(message) {
+    var _this;
+    var causingErr = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+    var req = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
+    var res = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : null;
+    _classCallCheck$8(this, DetailedError2);
+    _this = _callSuper$1(this, DetailedError2, [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;
+  }
+  _inherits$1(DetailedError2, _Error);
+  return _createClass$8(DetailedError2);
+})(/* @__PURE__ */ _wrapNativeSuper(Error));
+function log(msg) {
+  return;
+}
+function _typeof$7(o) {
+  "@babel/helpers - typeof";
+  return _typeof$7 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof$7(o);
+}
+function _classCallCheck$7(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$7(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey$7(descriptor.key), descriptor);
+  }
+}
+function _createClass$7(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties$7(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _toPropertyKey$7(t) {
+  var i = _toPrimitive$7(t, "string");
+  return "symbol" == _typeof$7(i) ? i : i + "";
+}
+function _toPrimitive$7(t, r) {
+  if ("object" != _typeof$7(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof$7(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var NoopUrlStorage = /* @__PURE__ */ (function() {
+  function NoopUrlStorage2() {
+    _classCallCheck$7(this, NoopUrlStorage2);
+  }
+  return _createClass$7(NoopUrlStorage2, [{
+    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);
+    }
+  }]);
+})();
+const version = "3.7.8";
+const VERSION = version;
+const _hasBuffer = typeof Buffer === "function";
+const _TD = typeof TextDecoder === "function" ? new TextDecoder() : void 0;
+const _TE = typeof TextEncoder === "function" ? new TextEncoder() : void 0;
+const b64ch = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+const b64chs = Array.prototype.slice.call(b64ch);
+const b64tab = ((a) => {
+  let tab = {};
+  a.forEach((c2, i) => tab[c2] = i);
+  return tab;
+})(b64chs);
+const b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+const _fromCC = String.fromCharCode.bind(String);
+const _U8Afrom = typeof Uint8Array.from === "function" ? Uint8Array.from.bind(Uint8Array) : (it) => new Uint8Array(Array.prototype.slice.call(it, 0));
+const _mkUriSafe = (src) => src.replace(/=/g, "").replace(/[+\/]/g, (m0) => m0 == "+" ? "-" : "_");
+const _tidyB64 = (s) => s.replace(/[^A-Za-z0-9\+\/]/g, "");
+const btoaPolyfill = (bin) => {
+  let u32, c0, c1, c2, asc = "";
+  const pad = bin.length % 3;
+  for (let i = 0; i < bin.length; ) {
+    if ((c0 = bin.charCodeAt(i++)) > 255 || (c1 = bin.charCodeAt(i++)) > 255 || (c2 = bin.charCodeAt(i++)) > 255)
+      throw new TypeError("invalid character found");
+    u32 = c0 << 16 | c1 << 8 | c2;
+    asc += b64chs[u32 >> 18 & 63] + b64chs[u32 >> 12 & 63] + b64chs[u32 >> 6 & 63] + b64chs[u32 & 63];
+  }
+  return pad ? asc.slice(0, pad - 3) + "===".substring(pad) : asc;
+};
+const _btoa = typeof btoa === "function" ? (bin) => btoa(bin) : _hasBuffer ? (bin) => Buffer.from(bin, "binary").toString("base64") : btoaPolyfill;
+const _fromUint8Array = _hasBuffer ? (u8a) => Buffer.from(u8a).toString("base64") : (u8a) => {
+  const maxargs = 4096;
+  let strs = [];
+  for (let i = 0, l = u8a.length; i < l; i += maxargs) {
+    strs.push(_fromCC.apply(null, u8a.subarray(i, i + maxargs)));
+  }
+  return _btoa(strs.join(""));
+};
+const fromUint8Array = (u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a);
+const cb_utob = (c2) => {
+  if (c2.length < 2) {
+    var cc = c2.charCodeAt(0);
+    return cc < 128 ? c2 : cc < 2048 ? _fromCC(192 | cc >>> 6) + _fromCC(128 | cc & 63) : _fromCC(224 | cc >>> 12 & 15) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
+  } else {
+    var cc = 65536 + (c2.charCodeAt(0) - 55296) * 1024 + (c2.charCodeAt(1) - 56320);
+    return _fromCC(240 | cc >>> 18 & 7) + _fromCC(128 | cc >>> 12 & 63) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
+  }
+};
+const re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
+const utob = (u) => u.replace(re_utob, cb_utob);
+const _encode = _hasBuffer ? (s) => Buffer.from(s, "utf8").toString("base64") : _TE ? (s) => _fromUint8Array(_TE.encode(s)) : (s) => _btoa(utob(s));
+const encode = (src, urlsafe = false) => urlsafe ? _mkUriSafe(_encode(src)) : _encode(src);
+const encodeURI = (src) => encode(src, true);
+const re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
+const cb_btou = (cccc) => {
+  switch (cccc.length) {
+    case 4:
+      var cp = (7 & cccc.charCodeAt(0)) << 18 | (63 & cccc.charCodeAt(1)) << 12 | (63 & cccc.charCodeAt(2)) << 6 | 63 & cccc.charCodeAt(3), offset = cp - 65536;
+      return _fromCC((offset >>> 10) + 55296) + _fromCC((offset & 1023) + 56320);
+    case 3:
+      return _fromCC((15 & cccc.charCodeAt(0)) << 12 | (63 & cccc.charCodeAt(1)) << 6 | 63 & cccc.charCodeAt(2));
+    default:
+      return _fromCC((31 & cccc.charCodeAt(0)) << 6 | 63 & cccc.charCodeAt(1));
+  }
+};
+const btou = (b) => b.replace(re_btou, cb_btou);
+const atobPolyfill = (asc) => {
+  asc = asc.replace(/\s+/g, "");
+  if (!b64re.test(asc))
+    throw new TypeError("malformed base64.");
+  asc += "==".slice(2 - (asc.length & 3));
+  let u24, r1, r2;
+  let binArray = [];
+  for (let i = 0; i < asc.length; ) {
+    u24 = b64tab[asc.charAt(i++)] << 18 | b64tab[asc.charAt(i++)] << 12 | (r1 = b64tab[asc.charAt(i++)]) << 6 | (r2 = b64tab[asc.charAt(i++)]);
+    if (r1 === 64) {
+      binArray.push(_fromCC(u24 >> 16 & 255));
+    } else if (r2 === 64) {
+      binArray.push(_fromCC(u24 >> 16 & 255, u24 >> 8 & 255));
+    } else {
+      binArray.push(_fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255));
+    }
+  }
+  return binArray.join("");
+};
+const _atob = typeof atob === "function" ? (asc) => atob(_tidyB64(asc)) : _hasBuffer ? (asc) => Buffer.from(asc, "base64").toString("binary") : atobPolyfill;
+const _toUint8Array = _hasBuffer ? (a) => _U8Afrom(Buffer.from(a, "base64")) : (a) => _U8Afrom(_atob(a).split("").map((c2) => c2.charCodeAt(0)));
+const toUint8Array = (a) => _toUint8Array(_unURI(a));
+const _decode = _hasBuffer ? (a) => Buffer.from(a, "base64").toString("utf8") : _TD ? (a) => _TD.decode(_toUint8Array(a)) : (a) => btou(_atob(a));
+const _unURI = (a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == "-" ? "+" : "/"));
+const decode = (src) => _decode(_unURI(src));
+const isValid = (src) => {
+  if (typeof src !== "string")
+    return false;
+  const s = src.replace(/\s+/g, "").replace(/={0,2}$/, "");
+  return !/[^\s0-9a-zA-Z\+/]/.test(s) || !/[^\s0-9a-zA-Z\-_]/.test(s);
+};
+const _noEnum = (v) => {
+  return {
+    value: v,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  };
+};
+const extendString = function() {
+  const _add = (name, body) => Object.defineProperty(String.prototype, name, _noEnum(body));
+  _add("fromBase64", function() {
+    return decode(this);
+  });
+  _add("toBase64", function(urlsafe) {
+    return encode(this, urlsafe);
+  });
+  _add("toBase64URI", function() {
+    return encode(this, true);
+  });
+  _add("toBase64URL", function() {
+    return encode(this, true);
+  });
+  _add("toUint8Array", function() {
+    return toUint8Array(this);
+  });
+};
+const extendUint8Array = function() {
+  const _add = (name, body) => Object.defineProperty(Uint8Array.prototype, name, _noEnum(body));
+  _add("toBase64", function(urlsafe) {
+    return fromUint8Array(this, urlsafe);
+  });
+  _add("toBase64URI", function() {
+    return fromUint8Array(this, true);
+  });
+  _add("toBase64URL", function() {
+    return fromUint8Array(this, true);
+  });
+};
+const extendBuiltins = () => {
+  extendString();
+  extendUint8Array();
+};
+const gBase64 = {
+  version,
+  VERSION,
+  atob: _atob,
+  atobPolyfill,
+  btoa: _btoa,
+  btoaPolyfill,
+  fromBase64: decode,
+  toBase64: encode,
+  encode,
+  encodeURI,
+  encodeURL: encodeURI,
+  utob,
+  btou,
+  decode,
+  isValid,
+  fromUint8Array,
+  toUint8Array,
+  extendString,
+  extendUint8Array,
+  extendBuiltins
+};
+var requiresPort;
+var hasRequiredRequiresPort;
+function requireRequiresPort() {
+  if (hasRequiredRequiresPort) return requiresPort;
+  hasRequiredRequiresPort = 1;
+  requiresPort = 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;
+  };
+  return requiresPort;
+}
+var querystringify = {};
+var hasRequiredQuerystringify;
+function requireQuerystringify() {
+  if (hasRequiredQuerystringify) return querystringify;
+  hasRequiredQuerystringify = 1;
+  var has = Object.prototype.hasOwnProperty, undef;
+  function decode2(input) {
+    try {
+      return decodeURIComponent(input.replace(/\+/g, " "));
+    } catch (e) {
+      return null;
+    }
+  }
+  function encode2(input) {
+    try {
+      return encodeURIComponent(input);
+    } catch (e) {
+      return null;
+    }
+  }
+  function querystring(query) {
+    var parser = /([^=?#&]+)=?([^&]*)/g, result = {}, part;
+    while (part = parser.exec(query)) {
+      var key = decode2(part[1]), value = decode2(part[2]);
+      if (key === null || value === null || key in result) continue;
+      result[key] = value;
+    }
+    return result;
+  }
+  function querystringify$1(obj, prefix) {
+    prefix = prefix || "";
+    var pairs = [], value, key;
+    if ("string" !== typeof prefix) prefix = "?";
+    for (key in obj) {
+      if (has.call(obj, key)) {
+        value = obj[key];
+        if (!value && (value === null || value === undef || isNaN(value))) {
+          value = "";
+        }
+        key = encode2(key);
+        value = encode2(value);
+        if (key === null || value === null) continue;
+        pairs.push(key + "=" + value);
+      }
+    }
+    return pairs.length ? prefix + pairs.join("&") : "";
+  }
+  querystringify.stringify = querystringify$1;
+  querystringify.parse = querystring;
+  return querystringify;
+}
+var urlParse;
+var hasRequiredUrlParse;
+function requireUrlParse() {
+  if (hasRequiredUrlParse) return urlParse;
+  hasRequiredUrlParse = 1;
+  var required = requireRequiresPort(), qs = requireQuerystringify(), controlOrWhitespace = /^[\x00-\x20\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/, CRHTLF = /[\n\r\t]/g, slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//, port = /:\d+$/, protocolre = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\\/]+)?([\S\s]*)/i, windowsDriveLetter = /^[a-zA-Z]:/;
+  function trimLeft(str) {
+    return (str ? str : "").toString().replace(controlOrWhitespace, "");
+  }
+  var rules = [
+    ["#", "hash"],
+    // Extract from the back.
+    ["?", "query"],
+    // Extract from the back.
+    function sanitize(address, url) {
+      return isSpecial(url.protocol) ? address.replace(/\\/g, "/") : address;
+    },
+    ["/", "pathname"],
+    // Extract from the back.
+    ["@", "auth", 1],
+    // Extract from the front.
+    [NaN, "host", void 0, 1, 1],
+    // Set left over value.
+    [/:(\d*)$/, "port", void 0, 1],
+    // RegExp the back.
+    [NaN, "hostname", void 0, 1, 1]
+    // Set left over.
+  ];
+  var ignore = { hash: 1, query: 1 };
+  function lolcation(loc) {
+    var globalVar;
+    if (typeof window !== "undefined") globalVar = window;
+    else if (typeof commonjsGlobal !== "undefined") globalVar = commonjsGlobal;
+    else if (typeof self !== "undefined") globalVar = self;
+    else globalVar = {};
+    var location = globalVar.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 === void 0) {
+        finaldestination.slashes = slashes.test(loc.href);
+      }
+    }
+    return finaldestination;
+  }
+  function isSpecial(scheme) {
+    return scheme === "file:" || scheme === "ftp:" || scheme === "http:" || scheme === "https:" || scheme === "ws:" || scheme === "wss:";
+  }
+  function extractProtocol(address, location) {
+    address = trimLeft(address);
+    address = address.replace(CRHTLF, "");
+    location = location || {};
+    var match = protocolre.exec(address);
+    var protocol = match[1] ? match[1].toLowerCase() : "";
+    var forwardSlashes = !!match[2];
+    var otherSlashes = !!match[3];
+    var slashesCount = 0;
+    var rest;
+    if (forwardSlashes) {
+      if (otherSlashes) {
+        rest = match[2] + match[3] + match[4];
+        slashesCount = match[2].length + match[3].length;
+      } else {
+        rest = match[2] + match[4];
+        slashesCount = match[2].length;
+      }
+    } else {
+      if (otherSlashes) {
+        rest = match[3] + match[4];
+        slashesCount = match[3].length;
+      } else {
+        rest = match[4];
+      }
+    }
+    if (protocol === "file:") {
+      if (slashesCount >= 2) {
+        rest = rest.slice(2);
+      }
+    } else if (isSpecial(protocol)) {
+      rest = match[4];
+    } else if (protocol) {
+      if (forwardSlashes) {
+        rest = rest.slice(2);
+      }
+    } else if (slashesCount >= 2 && isSpecial(location.protocol)) {
+      rest = match[4];
+    }
+    return {
+      protocol,
+      slashes: forwardSlashes || isSpecial(protocol),
+      slashesCount,
+      rest
+    };
+  }
+  function resolve(relative, base) {
+    if (relative === "") return 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("/");
+  }
+  function Url(address, location, parser) {
+    address = trimLeft(address);
+    address = address.replace(CRHTLF, "");
+    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;
+    if ("object" !== type && "string" !== type) {
+      parser = location;
+      location = null;
+    }
+    if (parser && "function" !== typeof parser) parser = qs.parse;
+    location = lolcation(location);
+    extracted = extractProtocol(address || "", location);
+    relative = !extracted.protocol && !extracted.slashes;
+    url.slashes = extracted.slashes || relative && location.slashes;
+    url.protocol = extracted.protocol || location.protocol || "";
+    address = extracted.rest;
+    if (extracted.protocol === "file:" && (extracted.slashesCount !== 2 || windowsDriveLetter.test(address)) || !extracted.slashes && (extracted.protocol || extracted.slashesCount < 2 || !isSpecial(url.protocol))) {
+      instructions[3] = [/(.*)/, "pathname"];
+    }
+    for (; i < instructions.length; i++) {
+      instruction = instructions[i];
+      if (typeof instruction === "function") {
+        address = instruction(address, url);
+        continue;
+      }
+      parse = instruction[0];
+      key = instruction[1];
+      if (parse !== parse) {
+        url[key] = address;
+      } else if ("string" === typeof parse) {
+        index = parse === "@" ? address.lastIndexOf(parse) : address.indexOf(parse);
+        if (~index) {
+          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] || "" : "");
+      if (instruction[4]) url[key] = url[key].toLowerCase();
+    }
+    if (parser) url.query = parser(url.query);
+    if (relative && location.slashes && url.pathname.charAt(0) !== "/" && (url.pathname !== "" || location.pathname !== "")) {
+      url.pathname = resolve(url.pathname, location.pathname);
+    }
+    if (url.pathname.charAt(0) !== "/" && isSpecial(url.protocol)) {
+      url.pathname = "/" + url.pathname;
+    }
+    if (!required(url.port, url.protocol)) {
+      url.host = url.hostname;
+      url.port = "";
+    }
+    url.username = url.password = "";
+    if (url.auth) {
+      index = url.auth.indexOf(":");
+      if (~index) {
+        url.username = url.auth.slice(0, index);
+        url.username = encodeURIComponent(decodeURIComponent(url.username));
+        url.password = url.auth.slice(index + 1);
+        url.password = encodeURIComponent(decodeURIComponent(url.password));
+      } else {
+        url.username = encodeURIComponent(decodeURIComponent(url.auth));
+      }
+      url.auth = url.password ? url.username + ":" + url.password : url.username;
+    }
+    url.origin = url.protocol !== "file:" && isSpecial(url.protocol) && url.host ? url.protocol + "//" + url.host : "null";
+    url.href = url.toString();
+  }
+  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 (port.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;
+      case "username":
+      case "password":
+        url[part] = encodeURIComponent(value);
+        break;
+      case "auth":
+        var index = value.indexOf(":");
+        if (~index) {
+          url.username = value.slice(0, index);
+          url.username = encodeURIComponent(decodeURIComponent(url.username));
+          url.password = value.slice(index + 1);
+          url.password = encodeURIComponent(decodeURIComponent(url.password));
+        } else {
+          url.username = encodeURIComponent(decodeURIComponent(value));
+        }
+    }
+    for (var i = 0; i < rules.length; i++) {
+      var ins = rules[i];
+      if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();
+    }
+    url.auth = url.password ? url.username + ":" + url.password : url.username;
+    url.origin = url.protocol !== "file:" && isSpecial(url.protocol) && url.host ? url.protocol + "//" + url.host : "null";
+    url.href = url.toString();
+    return url;
+  }
+  function toString(stringify) {
+    if (!stringify || "function" !== typeof stringify) stringify = qs.stringify;
+    var query, url = this, host = url.host, protocol = url.protocol;
+    if (protocol && protocol.charAt(protocol.length - 1) !== ":") protocol += ":";
+    var result = protocol + (url.protocol && url.slashes || isSpecial(url.protocol) ? "//" : "");
+    if (url.username) {
+      result += url.username;
+      if (url.password) result += ":" + url.password;
+      result += "@";
+    } else if (url.password) {
+      result += ":" + url.password;
+      result += "@";
+    } else if (url.protocol !== "file:" && isSpecial(url.protocol) && !host && url.pathname !== "/") {
+      result += "@";
+    }
+    if (host[host.length - 1] === ":" || port.test(url.hostname) && !url.port) {
+      host += ":";
+    }
+    result += 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, toString };
+  Url.extractProtocol = extractProtocol;
+  Url.location = lolcation;
+  Url.trimLeft = trimLeft;
+  Url.qs = qs;
+  urlParse = Url;
+  return urlParse;
+}
+var urlParseExports = requireUrlParse();
+function uuid() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c2) {
+    var r = Math.random() * 16 | 0;
+    var v = c2 === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function _regeneratorRuntime$1() {
+  _regeneratorRuntime$1 = function _regeneratorRuntime2() {
+    return e;
+  };
+  var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function(t2, e2, r2) {
+    t2[e2] = r2.value;
+  }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c2 = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag";
+  function define(t2, e2, r2) {
+    return Object.defineProperty(t2, e2, { value: r2, enumerable: true, configurable: true, writable: true }), t2[e2];
+  }
+  try {
+    define({}, "");
+  } catch (t2) {
+    define = function define2(t3, e2, r2) {
+      return t3[e2] = r2;
+    };
+  }
+  function wrap(t2, e2, r2, n2) {
+    var i2 = e2 && e2.prototype instanceof Generator ? e2 : Generator, a2 = Object.create(i2.prototype), c3 = new Context(n2 || []);
+    return o(a2, "_invoke", { value: makeInvokeMethod(t2, r2, c3) }), a2;
+  }
+  function tryCatch(t2, e2, r2) {
+    try {
+      return { type: "normal", arg: t2.call(e2, r2) };
+    } catch (t3) {
+      return { type: "throw", arg: t3 };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {};
+  function Generator() {
+  }
+  function GeneratorFunction() {
+  }
+  function GeneratorFunctionPrototype() {
+  }
+  var p = {};
+  define(p, a, function() {
+    return this;
+  });
+  var d = Object.getPrototypeOf, v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t2) {
+    ["next", "throw", "return"].forEach(function(e2) {
+      define(t2, e2, function(t3) {
+        return this._invoke(e2, t3);
+      });
+    });
+  }
+  function AsyncIterator(t2, e2) {
+    function invoke(r3, o2, i2, a2) {
+      var c3 = tryCatch(t2[r3], t2, o2);
+      if ("throw" !== c3.type) {
+        var u2 = c3.arg, h2 = u2.value;
+        return h2 && "object" == _typeof$6(h2) && n.call(h2, "__await") ? e2.resolve(h2.__await).then(function(t3) {
+          invoke("next", t3, i2, a2);
+        }, function(t3) {
+          invoke("throw", t3, i2, a2);
+        }) : e2.resolve(h2).then(function(t3) {
+          u2.value = t3, i2(u2);
+        }, function(t3) {
+          return invoke("throw", t3, i2, a2);
+        });
+      }
+      a2(c3.arg);
+    }
+    var r2;
+    o(this, "_invoke", { value: function value(t3, n2) {
+      function callInvokeWithMethodAndArg() {
+        return new e2(function(e3, r3) {
+          invoke(t3, n2, e3, r3);
+        });
+      }
+      return r2 = r2 ? r2.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    } });
+  }
+  function makeInvokeMethod(e2, r2, n2) {
+    var o2 = h;
+    return function(i2, a2) {
+      if (o2 === f) throw Error("Generator is already running");
+      if (o2 === s) {
+        if ("throw" === i2) throw a2;
+        return { value: t, done: true };
+      }
+      for (n2.method = i2, n2.arg = a2; ; ) {
+        var c3 = n2.delegate;
+        if (c3) {
+          var u2 = maybeInvokeDelegate(c3, n2);
+          if (u2) {
+            if (u2 === y) continue;
+            return u2;
+          }
+        }
+        if ("next" === n2.method) n2.sent = n2._sent = n2.arg;
+        else if ("throw" === n2.method) {
+          if (o2 === h) throw o2 = s, n2.arg;
+          n2.dispatchException(n2.arg);
+        } else "return" === n2.method && n2.abrupt("return", n2.arg);
+        o2 = f;
+        var p2 = tryCatch(e2, r2, n2);
+        if ("normal" === p2.type) {
+          if (o2 = n2.done ? s : l, p2.arg === y) continue;
+          return { value: p2.arg, done: n2.done };
+        }
+        "throw" === p2.type && (o2 = s, n2.method = "throw", n2.arg = p2.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e2, r2) {
+    var n2 = r2.method, o2 = e2.iterator[n2];
+    if (o2 === t) return r2.delegate = null, "throw" === n2 && e2.iterator["return"] && (r2.method = "return", r2.arg = t, maybeInvokeDelegate(e2, r2), "throw" === r2.method) || "return" !== n2 && (r2.method = "throw", r2.arg = new TypeError("The iterator does not provide a '" + n2 + "' method")), y;
+    var i2 = tryCatch(o2, e2.iterator, r2.arg);
+    if ("throw" === i2.type) return r2.method = "throw", r2.arg = i2.arg, r2.delegate = null, y;
+    var a2 = i2.arg;
+    return a2 ? a2.done ? (r2[e2.resultName] = a2.value, r2.next = e2.nextLoc, "return" !== r2.method && (r2.method = "next", r2.arg = t), r2.delegate = null, y) : a2 : (r2.method = "throw", r2.arg = new TypeError("iterator result is not an object"), r2.delegate = null, y);
+  }
+  function pushTryEntry(t2) {
+    var e2 = { tryLoc: t2[0] };
+    1 in t2 && (e2.catchLoc = t2[1]), 2 in t2 && (e2.finallyLoc = t2[2], e2.afterLoc = t2[3]), this.tryEntries.push(e2);
+  }
+  function resetTryEntry(t2) {
+    var e2 = t2.completion || {};
+    e2.type = "normal", delete e2.arg, t2.completion = e2;
+  }
+  function Context(t2) {
+    this.tryEntries = [{ tryLoc: "root" }], t2.forEach(pushTryEntry, this), this.reset(true);
+  }
+  function values(e2) {
+    if (e2 || "" === e2) {
+      var r2 = e2[a];
+      if (r2) return r2.call(e2);
+      if ("function" == typeof e2.next) return e2;
+      if (!isNaN(e2.length)) {
+        var o2 = -1, i2 = function next() {
+          for (; ++o2 < e2.length; ) if (n.call(e2, o2)) return next.value = e2[o2], next.done = false, next;
+          return next.value = t, next.done = true, next;
+        };
+        return i2.next = i2;
+      }
+    }
+    throw new TypeError(_typeof$6(e2) + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { value: GeneratorFunctionPrototype, configurable: true }), o(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: true }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function(t2) {
+    var e2 = "function" == typeof t2 && t2.constructor;
+    return !!e2 && (e2 === GeneratorFunction || "GeneratorFunction" === (e2.displayName || e2.name));
+  }, e.mark = function(t2) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t2, GeneratorFunctionPrototype) : (t2.__proto__ = GeneratorFunctionPrototype, define(t2, u, "GeneratorFunction")), t2.prototype = Object.create(g), t2;
+  }, e.awrap = function(t2) {
+    return { __await: t2 };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c2, function() {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function(t2, r2, n2, o2, i2) {
+    void 0 === i2 && (i2 = Promise);
+    var a2 = new AsyncIterator(wrap(t2, r2, n2, o2), i2);
+    return e.isGeneratorFunction(r2) ? a2 : a2.next().then(function(t3) {
+      return t3.done ? t3.value : a2.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function() {
+    return this;
+  }), define(g, "toString", function() {
+    return "[object Generator]";
+  }), e.keys = function(t2) {
+    var e2 = Object(t2), r2 = [];
+    for (var n2 in e2) r2.push(n2);
+    return r2.reverse(), function next() {
+      for (; r2.length; ) {
+        var t3 = r2.pop();
+        if (t3 in e2) return next.value = t3, next.done = false, next;
+      }
+      return next.done = true, next;
+    };
+  }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e2) {
+    if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e2) for (var r2 in this) "t" === r2.charAt(0) && n.call(this, r2) && !isNaN(+r2.slice(1)) && (this[r2] = t);
+  }, stop: function stop() {
+    this.done = true;
+    var t2 = this.tryEntries[0].completion;
+    if ("throw" === t2.type) throw t2.arg;
+    return this.rval;
+  }, dispatchException: function dispatchException(e2) {
+    if (this.done) throw e2;
+    var r2 = this;
+    function handle(n2, o3) {
+      return a2.type = "throw", a2.arg = e2, r2.next = n2, o3 && (r2.method = "next", r2.arg = t), !!o3;
+    }
+    for (var o2 = this.tryEntries.length - 1; o2 >= 0; --o2) {
+      var i2 = this.tryEntries[o2], a2 = i2.completion;
+      if ("root" === i2.tryLoc) return handle("end");
+      if (i2.tryLoc <= this.prev) {
+        var c3 = n.call(i2, "catchLoc"), u2 = n.call(i2, "finallyLoc");
+        if (c3 && u2) {
+          if (this.prev < i2.catchLoc) return handle(i2.catchLoc, true);
+          if (this.prev < i2.finallyLoc) return handle(i2.finallyLoc);
+        } else if (c3) {
+          if (this.prev < i2.catchLoc) return handle(i2.catchLoc, true);
+        } else {
+          if (!u2) throw Error("try statement without catch or finally");
+          if (this.prev < i2.finallyLoc) return handle(i2.finallyLoc);
+        }
+      }
+    }
+  }, abrupt: function abrupt(t2, e2) {
+    for (var r2 = this.tryEntries.length - 1; r2 >= 0; --r2) {
+      var o2 = this.tryEntries[r2];
+      if (o2.tryLoc <= this.prev && n.call(o2, "finallyLoc") && this.prev < o2.finallyLoc) {
+        var i2 = o2;
+        break;
+      }
+    }
+    i2 && ("break" === t2 || "continue" === t2) && i2.tryLoc <= e2 && e2 <= i2.finallyLoc && (i2 = null);
+    var a2 = i2 ? i2.completion : {};
+    return a2.type = t2, a2.arg = e2, i2 ? (this.method = "next", this.next = i2.finallyLoc, y) : this.complete(a2);
+  }, complete: function complete(t2, e2) {
+    if ("throw" === t2.type) throw t2.arg;
+    return "break" === t2.type || "continue" === t2.type ? this.next = t2.arg : "return" === t2.type ? (this.rval = this.arg = t2.arg, this.method = "return", this.next = "end") : "normal" === t2.type && e2 && (this.next = e2), y;
+  }, finish: function finish(t2) {
+    for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+      var r2 = this.tryEntries[e2];
+      if (r2.finallyLoc === t2) return this.complete(r2.completion, r2.afterLoc), resetTryEntry(r2), y;
+    }
+  }, "catch": function _catch(t2) {
+    for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+      var r2 = this.tryEntries[e2];
+      if (r2.tryLoc === t2) {
+        var n2 = r2.completion;
+        if ("throw" === n2.type) {
+          var o2 = n2.arg;
+          resetTryEntry(r2);
+        }
+        return o2;
+      }
+    }
+    throw Error("illegal catch attempt");
+  }, delegateYield: function delegateYield(e2, r2, n2) {
+    return this.delegate = { iterator: values(e2), resultName: r2, nextLoc: n2 }, "next" === this.method && (this.arg = t), y;
+  } }, e;
+}
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+function _asyncToGenerator$1(fn) {
+  return function() {
+    var self2 = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self2, args);
+      function _next(value) {
+        asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e, n, i, u, a = [], f = true, o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ;
+      else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
+    } catch (r2) {
+      o = true, n = r2;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _typeof$6(o) {
+  "@babel/helpers - typeof";
+  return _typeof$6 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof$6(o);
+}
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) {
+      if (it) o = it;
+      var i = 0;
+      var F = function F2() {
+      };
+      return { s: F, n: function n() {
+        if (i >= o.length) return { done: true };
+        return { done: false, value: o[i++] };
+      }, e: function e(_e) {
+        throw _e;
+      }, f: F };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true, didErr = false, err;
+  return { s: function s() {
+    it = it.call(o);
+  }, n: function n() {
+    var step = it.next();
+    normalCompletion = step.done;
+    return step;
+  }, e: function e(_e2) {
+    didErr = true;
+    err = _e2;
+  }, f: function f() {
+    try {
+      if (!normalCompletion && it["return"] != null) it["return"]();
+    } finally {
+      if (didErr) throw err;
+    }
+  } };
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len2) {
+  if (len2 == null || len2 > arr.length) len2 = arr.length;
+  for (var i = 0, arr2 = new Array(len2); i < len2; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function ownKeys$1(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread$1(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys$1(Object(t), true).forEach(function(r2) {
+      _defineProperty$1(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _defineProperty$1(obj, key, value) {
+  key = _toPropertyKey$6(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _classCallCheck$6(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$6(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey$6(descriptor.key), descriptor);
+  }
+}
+function _createClass$6(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties$6(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties$6(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _toPropertyKey$6(t) {
+  var i = _toPrimitive$6(t, "string");
+  return "symbol" == _typeof$6(i) ? i : i + "";
+}
+function _toPrimitive$6(t, r) {
+  if ("object" != _typeof$6(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof$6(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var PROTOCOL_TUS_V1 = "tus-v1";
+var PROTOCOL_IETF_DRAFT_03 = "ietf-draft-03";
+var PROTOCOL_IETF_DRAFT_05 = "ietf-draft-05";
+var defaultOptions$1 = {
+  endpoint: null,
+  uploadUrl: null,
+  metadata: {},
+  metadataForPartialUploads: {},
+  fingerprint: null,
+  uploadSize: null,
+  onProgress: null,
+  onChunkComplete: null,
+  onSuccess: null,
+  onError: null,
+  onUploadUrlAvailable: null,
+  overridePatchMethod: false,
+  headers: {},
+  addRequestId: false,
+  onBeforeRequest: null,
+  onAfterResponse: null,
+  onShouldRetry: defaultOnShouldRetry,
+  chunkSize: Number.POSITIVE_INFINITY,
+  retryDelays: [0, 1e3, 3e3, 5e3],
+  parallelUploads: 1,
+  parallelUploadBoundaries: null,
+  storeFingerprintForResuming: true,
+  removeFingerprintOnSuccess: false,
+  uploadLengthDeferred: false,
+  uploadDataDuringCreation: false,
+  urlStorage: null,
+  fileReader: null,
+  httpStack: null,
+  protocol: PROTOCOL_TUS_V1
+};
+var BaseUpload = /* @__PURE__ */ (function() {
+  function BaseUpload2(file, options) {
+    _classCallCheck$6(this, BaseUpload2);
+    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.");
+    }
+    this.options = options;
+    this.options.chunkSize = Number(this.options.chunkSize);
+    this._urlStorage = this.options.urlStorage;
+    this.file = file;
+    this.url = null;
+    this._req = null;
+    this._fingerprint = null;
+    this._urlStorageKey = null;
+    this._offset = null;
+    this._aborted = false;
+    this._size = null;
+    this._source = null;
+    this._retryAttempt = 0;
+    this._retryTimeout = null;
+    this._offsetBeforeRetry = 0;
+    this._parallelUploads = null;
+    this._parallelUploadUrls = null;
+  }
+  return _createClass$6(BaseUpload2, [{
+    key: "findPreviousUploads",
+    value: function findPreviousUploads() {
+      var _this = this;
+      return this.options.fingerprint(this.file, this.options).then(function(fingerprint2) {
+        return _this._urlStorage.findUploadsByFingerprint(fingerprint2);
+      });
+    }
+  }, {
+    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 (![PROTOCOL_TUS_V1, PROTOCOL_IETF_DRAFT_03, PROTOCOL_IETF_DRAFT_05].includes(this.options.protocol)) {
+        this._emitError(new Error("tus: unsupported protocol ".concat(this.options.protocol)));
+        return;
+      }
+      if (!this.options.endpoint && !this.options.uploadUrl && !this.url) {
+        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) {
+        for (var _i = 0, _arr = ["uploadUrl", "uploadSize", "uploadLengthDeferred"]; _i < _arr.length; _i++) {
+          var optionName = _arr[_i];
+          if (this.options[optionName]) {
+            this._emitError(new Error("tus: cannot use the ".concat(optionName, " option when parallelUploads is enabled")));
+            return;
+          }
+        }
+      }
+      if (this.options.parallelUploadBoundaries) {
+        if (this.options.parallelUploads <= 1) {
+          this._emitError(new Error("tus: cannot use the `parallelUploadBoundaries` option when `parallelUploads` is disabled"));
+          return;
+        }
+        if (this.options.parallelUploads !== this.options.parallelUploadBoundaries.length) {
+          this._emitError(new Error("tus: the `parallelUploadBoundaries` must have the same length as the value of `parallelUploads`"));
+          return;
+        }
+      }
+      this.options.fingerprint(file, this.options).then(function(fingerprint2) {
+        _this2._fingerprint = fingerprint2;
+        if (_this2._source) {
+          return _this2._source;
+        }
+        return _this2.options.fileReader.openFile(file, _this2.options.chunkSize);
+      }).then(function(source) {
+        _this2._source = source;
+        if (_this2.options.uploadLengthDeferred) {
+          _this2._size = null;
+        } else if (_this2.options.uploadSize != null) {
+          _this2._size = Number(_this2.options.uploadSize);
+          if (Number.isNaN(_this2._size)) {
+            _this2._emitError(new Error("tus: cannot convert `uploadSize` option into a number"));
+            return;
+          }
+        } else {
+          _this2._size = _this2._source.size;
+          if (_this2._size == null) {
+            _this2._emitError(new Error("tus: cannot automatically derive upload's size from input. Specify it manually using the `uploadSize` option or use the `uploadLengthDeferred` option"));
+            return;
+          }
+        }
+        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 _this$options$paralle, _this3 = this;
+      var totalSize = this._size;
+      var totalProgress = 0;
+      this._parallelUploads = [];
+      var partCount = this._parallelUploadUrls != null ? this._parallelUploadUrls.length : this.options.parallelUploads;
+      var parts = (_this$options$paralle = this.options.parallelUploadBoundaries) !== null && _this$options$paralle !== void 0 ? _this$options$paralle : splitSizeIntoParts(this._source.size, partCount);
+      if (this._parallelUploadUrls) {
+        parts.forEach(function(part, index) {
+          part.uploadUrl = _this3._parallelUploadUrls[index] || null;
+        });
+      }
+      this._parallelUploadUrls = new Array(parts.length);
+      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) {
+            var options = _objectSpread$1(_objectSpread$1({}, _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,
+              // Reset this option as we are not doing a parallel upload.
+              parallelUploadBoundaries: null,
+              metadata: _this3.options.metadataForPartialUploads,
+              // Add the header to indicate the this is a partial upload.
+              headers: _objectSpread$1(_objectSpread$1({}, _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;
+                if (_this3._parallelUploadUrls.filter(function(u) {
+                  return Boolean(u);
+                }).length === parts.length) {
+                  _this3._saveUploadInUrlStorage();
+                }
+              }
+            });
+            var upload = new BaseUpload2(value, options);
+            upload.start();
+            _this3._parallelUploads.push(upload);
+          });
+        });
+      });
+      var req;
+      Promise.all(uploads).then(function() {
+        req = _this3._openRequest("POST", _this3.options.endpoint);
+        req.setHeader("Upload-Concat", "final;".concat(_this3._parallelUploadUrls.join(" ")));
+        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);
+        log("Created upload at ".concat(_this3.url));
+        _this3._emitSuccess(res);
+      })["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() {
+      this._aborted = false;
+      if (this.url != null) {
+        log("Resuming upload from previous URL: ".concat(this.url));
+        this._resumeUpload();
+        return;
+      }
+      if (this.options.uploadUrl != null) {
+        log("Resuming upload from provided URL: ".concat(this.options.uploadUrl));
+        this.url = this.options.uploadUrl;
+        this._resumeUpload();
+        return;
+      }
+      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) {
+      var _this4 = this;
+      if (this._parallelUploads != null) {
+        var _iterator = _createForOfIteratorHelper(this._parallelUploads), _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+            var upload = _step.value;
+            upload.abort(shouldTerminate);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+      if (this._req !== null) {
+        this._req.abort();
+      }
+      this._aborted = true;
+      if (this._retryTimeout != null) {
+        clearTimeout(this._retryTimeout);
+        this._retryTimeout = null;
+      }
+      if (!shouldTerminate || this.url == null) {
+        return Promise.resolve();
+      }
+      return BaseUpload2.terminate(this.url, this.options).then(function() {
+        return _this4._removeFromUrlStorage();
+      });
+    }
+  }, {
+    key: "_emitHttpError",
+    value: function _emitHttpError(req, res, message, causingErr) {
+      this._emitError(new DetailedError(message, causingErr, req, res));
+    }
+  }, {
+    key: "_emitError",
+    value: function _emitError(err) {
+      var _this5 = this;
+      if (this._aborted) return;
+      if (this.options.retryDelays != null) {
+        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.
+     *
+     * @param {object} lastResponse Last HTTP response.
+     * @api private
+     */
+  }, {
+    key: "_emitSuccess",
+    value: function _emitSuccess(lastResponse) {
+      if (this.options.removeFingerprintOnSuccess) {
+        this._removeFromUrlStorage();
+      }
+      if (typeof this.options.onSuccess === "function") {
+        this.options.onSuccess({
+          lastResponse
+        });
+      }
+    }
+    /**
+     * 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", "".concat(this._size));
+      }
+      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 {
+        if (this.options.protocol === PROTOCOL_IETF_DRAFT_03 || this.options.protocol === PROTOCOL_IETF_DRAFT_05) {
+          req.setHeader("Upload-Complete", "?0");
+        }
+        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);
+        log("Created upload at ".concat(_this6.url));
+        if (typeof _this6.options.onUploadUrlAvailable === "function") {
+          _this6.options.onUploadUrlAvailable();
+        }
+        if (_this6._size === 0) {
+          _this6._emitSuccess(res);
+          _this6._source.close();
+          return;
+        }
+        _this6._saveUploadInUrlStorage().then(function() {
+          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 (status === 423) {
+            _this7._emitHttpError(req, res, "tus: upload is currently locked; retry later");
+            return;
+          }
+          if (inStatusCategory(status, 400)) {
+            _this7._removeFromUrlStorage();
+          }
+          if (!_this7.options.endpoint) {
+            _this7._emitHttpError(req, res, "tus: unable to resume upload (new upload cannot be created without an endpoint)");
+            return;
+          }
+          _this7.url = null;
+          _this7._createUpload();
+          return;
+        }
+        var offset = Number.parseInt(res.getHeader("Upload-Offset"), 10);
+        if (Number.isNaN(offset)) {
+          _this7._emitHttpError(req, res, "tus: invalid or missing offset value");
+          return;
+        }
+        var length = Number.parseInt(res.getHeader("Upload-Length"), 10);
+        if (Number.isNaN(length) && !_this7.options.uploadLengthDeferred && _this7.options.protocol === PROTOCOL_TUS_V1) {
+          _this7._emitHttpError(req, res, "tus: invalid or missing length value");
+          return;
+        }
+        if (typeof _this7.options.onUploadUrlAvailable === "function") {
+          _this7.options.onUploadUrlAvailable();
+        }
+        _this7._saveUploadInUrlStorage().then(function() {
+          if (offset === length) {
+            _this7._emitProgress(length, length);
+            _this7._emitSuccess(res);
+            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 (this._aborted) {
+        return;
+      }
+      var req;
+      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", "".concat(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) {
+        if (_this8._aborted) {
+          return;
+        }
+        _this8._emitHttpError(req, null, "tus: failed to upload chunk at offset ".concat(_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);
+      });
+      if (this.options.protocol === PROTOCOL_TUS_V1) {
+        req.setHeader("Content-Type", "application/offset+octet-stream");
+      } else if (this.options.protocol === PROTOCOL_IETF_DRAFT_05) {
+        req.setHeader("Content-Type", "application/partial-upload");
+      }
+      if ((end === Number.POSITIVE_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;
+        var valueSize = value !== null && value !== void 0 && value.size ? value.size : 0;
+        if (_this9.options.uploadLengthDeferred && done) {
+          _this9._size = _this9._offset + valueSize;
+          req.setHeader("Upload-Length", "".concat(_this9._size));
+        }
+        var newSize = _this9._offset + valueSize;
+        if (!_this9.options.uploadLengthDeferred && done && newSize !== _this9._size) {
+          return Promise.reject(new Error("upload was configured with a size of ".concat(_this9._size, " bytes, but the source is done after ").concat(newSize, " bytes")));
+        }
+        if (value === null) {
+          return _this9._sendRequest(req);
+        }
+        if (_this9.options.protocol === PROTOCOL_IETF_DRAFT_03 || _this9.options.protocol === PROTOCOL_IETF_DRAFT_05) {
+          req.setHeader("Upload-Complete", done ? "?1" : "?0");
+        }
+        _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 = Number.parseInt(res.getHeader("Upload-Offset"), 10);
+      if (Number.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) {
+        this._emitSuccess(res);
+        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;
+      if (!this.options.storeFingerprintForResuming || !this._fingerprint || this._urlStorageKey !== null) {
+        return Promise.resolve();
+      }
+      var storedUpload = {
+        size: this._size,
+        metadata: this.options.metadata,
+        creationTime: (/* @__PURE__ */ new Date()).toString()
+      };
+      if (this._parallelUploads) {
+        storedUpload.parallelUploadUrls = this._parallelUploadUrls;
+      } else {
+        storedUpload.uploadUrl = this.url;
+      }
+      return this._urlStorage.addUpload(this._fingerprint, storedUpload).then(function(urlStorageKey) {
+        _this11._urlStorageKey = urlStorageKey;
+      });
+    }
+    /**
+     * Send a request with the provided body.
+     *
+     * @api private
+     */
+  }, {
+    key: "_sendRequest",
+    value: function _sendRequest(req) {
+      var body = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+      return sendRequest(req, body, this.options);
+    }
+  }], [{
+    key: "terminate",
+    value: function terminate(url) {
+      var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      var req = openRequest("DELETE", url, options);
+      return sendRequest(req, null, options).then(function(res) {
+        if (res.getStatus() === 204) {
+          return;
+        }
+        throw new DetailedError("tus: unexpected response while terminating upload", null, req, res);
+      })["catch"](function(err) {
+        if (!(err instanceof DetailedError)) {
+          err = new DetailedError("tus: failed to terminate upload", err, req, null);
+        }
+        if (!shouldRetry(err, 0, options)) {
+          throw err;
+        }
+        var delay = options.retryDelays[0];
+        var remainingDelays = options.retryDelays.slice(1);
+        var newOptions = _objectSpread$1(_objectSpread$1({}, options), {}, {
+          retryDelays: remainingDelays
+        });
+        return new Promise(function(resolve) {
+          return setTimeout(resolve, delay);
+        }).then(function() {
+          return BaseUpload2.terminate(url, newOptions);
+        });
+      });
+    }
+  }]);
+})();
+function encodeMetadata(metadata) {
+  return Object.entries(metadata).map(function(_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2), key = _ref4[0], value = _ref4[1];
+    return "".concat(key, " ").concat(gBase64.encode(String(value)));
+  }).join(",");
+}
+function inStatusCategory(status, category) {
+  return status >= category && status < category + 100;
+}
+function openRequest(method, url, options) {
+  var req = options.httpStack.createRequest(method, url);
+  if (options.protocol === PROTOCOL_IETF_DRAFT_03) {
+    req.setHeader("Upload-Draft-Interop-Version", "5");
+  } else if (options.protocol === PROTOCOL_IETF_DRAFT_05) {
+    req.setHeader("Upload-Draft-Interop-Version", "6");
+  } else {
+    req.setHeader("Tus-Resumable", "1.0.0");
+  }
+  var headers = options.headers || {};
+  for (var _i2 = 0, _Object$entries = Object.entries(headers); _i2 < _Object$entries.length; _i2++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i2], 2), name = _Object$entries$_i[0], value = _Object$entries$_i[1];
+    req.setHeader(name, value);
+  }
+  if (options.addRequestId) {
+    var requestId = uuid();
+    req.setHeader("X-Request-ID", requestId);
+  }
+  return req;
+}
+function sendRequest(_x, _x2, _x3) {
+  return _sendRequest2.apply(this, arguments);
+}
+function _sendRequest2() {
+  _sendRequest2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee(req, body, options) {
+    var res;
+    return _regeneratorRuntime$1().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (!(typeof options.onBeforeRequest === "function")) {
+            _context.next = 3;
+            break;
+          }
+          _context.next = 3;
+          return options.onBeforeRequest(req);
+        case 3:
+          _context.next = 5;
+          return req.send(body);
+        case 5:
+          res = _context.sent;
+          if (!(typeof options.onAfterResponse === "function")) {
+            _context.next = 9;
+            break;
+          }
+          _context.next = 9;
+          return options.onAfterResponse(req, res);
+        case 9:
+          return _context.abrupt("return", res);
+        case 10:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _sendRequest2.apply(this, arguments);
+}
+function isOnline() {
+  var online = true;
+  if (typeof navigator !== "undefined" && navigator.onLine === false) {
+    online = false;
+  }
+  return online;
+}
+function shouldRetry(err, retryAttempt, options) {
+  if (options.retryDelays == null || retryAttempt >= options.retryDelays.length || err.originalRequest == null) {
+    return false;
+  }
+  if (options && typeof options.onShouldRetry === "function") {
+    return options.onShouldRetry(err, retryAttempt, options);
+  }
+  return defaultOnShouldRetry(err);
+}
+function defaultOnShouldRetry(err) {
+  var status = err.originalResponse ? err.originalResponse.getStatus() : 0;
+  return (!inStatusCategory(status, 400) || status === 409 || status === 423) && isOnline();
+}
+function resolveUrl(origin, link) {
+  return new urlParseExports(link, origin).toString();
+}
+function splitSizeIntoParts(totalSize, partCount) {
+  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;
+  return parts;
+}
+BaseUpload.defaultOptions = defaultOptions$1;
+var isReactNative = function isReactNative2() {
+  return typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative";
+};
+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();
+  });
+}
+var isCordova = function isCordova2() {
+  return typeof window !== "undefined" && (typeof window.PhoneGap !== "undefined" || typeof window.Cordova !== "undefined" || typeof window.cordova !== "undefined");
+};
+function readAsByteArray(chunk) {
+  return new Promise(function(resolve, reject) {
+    var reader = new FileReader();
+    reader.onload = function() {
+      var value = new Uint8Array(reader.result);
+      resolve({
+        value
+      });
+    };
+    reader.onerror = function(err) {
+      reject(err);
+    };
+    reader.readAsArrayBuffer(chunk);
+  });
+}
+function _typeof$5(o) {
+  "@babel/helpers - typeof";
+  return _typeof$5 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof$5(o);
+}
+function _classCallCheck$5(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$5(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey$5(descriptor.key), descriptor);
+  }
+}
+function _createClass$5(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties$5(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _toPropertyKey$5(t) {
+  var i = _toPrimitive$5(t, "string");
+  return "symbol" == _typeof$5(i) ? i : i + "";
+}
+function _toPrimitive$5(t, r) {
+  if ("object" != _typeof$5(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof$5(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var FileSource = /* @__PURE__ */ (function() {
+  function FileSource2(file) {
+    _classCallCheck$5(this, FileSource2);
+    this._file = file;
+    this.size = file.size;
+  }
+  return _createClass$5(FileSource2, [{
+    key: "slice",
+    value: function slice(start, end) {
+      if (isCordova()) {
+        return readAsByteArray(this._file.slice(start, end));
+      }
+      var value = this._file.slice(start, end);
+      var done = end >= this.size;
+      return Promise.resolve({
+        value,
+        done
+      });
+    }
+  }, {
+    key: "close",
+    value: function close() {
+    }
+  }]);
+})();
+function _typeof$4(o) {
+  "@babel/helpers - typeof";
+  return _typeof$4 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof$4(o);
+}
+function _classCallCheck$4(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$4(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey$4(descriptor.key), descriptor);
+  }
+}
+function _createClass$4(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties$4(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _toPropertyKey$4(t) {
+  var i = _toPrimitive$4(t, "string");
+  return "symbol" == _typeof$4(i) ? i : i + "";
+}
+function _toPrimitive$4(t, r) {
+  if ("object" != _typeof$4(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof$4(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+function len(blobOrArray) {
+  if (blobOrArray === void 0) return 0;
+  if (blobOrArray.size !== void 0) return blobOrArray.size;
+  return blobOrArray.length;
+}
+function concat(a, b) {
+  if (a.concat) {
+    return a.concat(b);
+  }
+  if (a instanceof Blob) {
+    return new Blob([a, b], {
+      type: a.type
+    });
+  }
+  if (a.set) {
+    var c2 = new a.constructor(a.length + b.length);
+    c2.set(a);
+    c2.set(b, a.length);
+    return c2;
+  }
+  throw new Error("Unknown data type");
+}
+var StreamSource = /* @__PURE__ */ (function() {
+  function StreamSource2(reader) {
+    _classCallCheck$4(this, StreamSource2);
+    this._buffer = void 0;
+    this._bufferOffset = 0;
+    this._reader = reader;
+    this._done = false;
+  }
+  return _createClass$4(StreamSource2, [{
+    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,
+          done
+        });
+      }
+      return this._reader.read().then(function(_ref) {
+        var value2 = _ref.value, done2 = _ref.done;
+        if (done2) {
+          _this._done = true;
+        } else if (_this._buffer === void 0) {
+          _this._buffer = value2;
+        } else {
+          _this._buffer = concat(_this._buffer, value2);
+        }
+        return _this._readUntilEnoughDataOrDone(start, end);
+      });
+    }
+  }, {
+    key: "_getDataFromBuffer",
+    value: function _getDataFromBuffer(start, end) {
+      if (start > this._bufferOffset) {
+        this._buffer = this._buffer.slice(start - this._bufferOffset);
+        this._bufferOffset = start;
+      }
+      var hasAllDataBeenRead = len(this._buffer) === 0;
+      if (this._done && hasAllDataBeenRead) {
+        return null;
+      }
+      return this._buffer.slice(0, end - start);
+    }
+  }, {
+    key: "close",
+    value: function close() {
+      if (this._reader.cancel) {
+        this._reader.cancel();
+      }
+    }
+  }]);
+})();
+function _typeof$3(o) {
+  "@babel/helpers - typeof";
+  return _typeof$3 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof$3(o);
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function _regeneratorRuntime2() {
+    return e;
+  };
+  var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function(t2, e2, r2) {
+    t2[e2] = r2.value;
+  }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c2 = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag";
+  function define(t2, e2, r2) {
+    return Object.defineProperty(t2, e2, { value: r2, enumerable: true, configurable: true, writable: true }), t2[e2];
+  }
+  try {
+    define({}, "");
+  } catch (t2) {
+    define = function define2(t3, e2, r2) {
+      return t3[e2] = r2;
+    };
+  }
+  function wrap(t2, e2, r2, n2) {
+    var i2 = e2 && e2.prototype instanceof Generator ? e2 : Generator, a2 = Object.create(i2.prototype), c3 = new Context(n2 || []);
+    return o(a2, "_invoke", { value: makeInvokeMethod(t2, r2, c3) }), a2;
+  }
+  function tryCatch(t2, e2, r2) {
+    try {
+      return { type: "normal", arg: t2.call(e2, r2) };
+    } catch (t3) {
+      return { type: "throw", arg: t3 };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {};
+  function Generator() {
+  }
+  function GeneratorFunction() {
+  }
+  function GeneratorFunctionPrototype() {
+  }
+  var p = {};
+  define(p, a, function() {
+    return this;
+  });
+  var d = Object.getPrototypeOf, v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t2) {
+    ["next", "throw", "return"].forEach(function(e2) {
+      define(t2, e2, function(t3) {
+        return this._invoke(e2, t3);
+      });
+    });
+  }
+  function AsyncIterator(t2, e2) {
+    function invoke(r3, o2, i2, a2) {
+      var c3 = tryCatch(t2[r3], t2, o2);
+      if ("throw" !== c3.type) {
+        var u2 = c3.arg, h2 = u2.value;
+        return h2 && "object" == _typeof$3(h2) && n.call(h2, "__await") ? e2.resolve(h2.__await).then(function(t3) {
+          invoke("next", t3, i2, a2);
+        }, function(t3) {
+          invoke("throw", t3, i2, a2);
+        }) : e2.resolve(h2).then(function(t3) {
+          u2.value = t3, i2(u2);
+        }, function(t3) {
+          return invoke("throw", t3, i2, a2);
+        });
+      }
+      a2(c3.arg);
+    }
+    var r2;
+    o(this, "_invoke", { value: function value(t3, n2) {
+      function callInvokeWithMethodAndArg() {
+        return new e2(function(e3, r3) {
+          invoke(t3, n2, e3, r3);
+        });
+      }
+      return r2 = r2 ? r2.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    } });
+  }
+  function makeInvokeMethod(e2, r2, n2) {
+    var o2 = h;
+    return function(i2, a2) {
+      if (o2 === f) throw Error("Generator is already running");
+      if (o2 === s) {
+        if ("throw" === i2) throw a2;
+        return { value: t, done: true };
+      }
+      for (n2.method = i2, n2.arg = a2; ; ) {
+        var c3 = n2.delegate;
+        if (c3) {
+          var u2 = maybeInvokeDelegate(c3, n2);
+          if (u2) {
+            if (u2 === y) continue;
+            return u2;
+          }
+        }
+        if ("next" === n2.method) n2.sent = n2._sent = n2.arg;
+        else if ("throw" === n2.method) {
+          if (o2 === h) throw o2 = s, n2.arg;
+          n2.dispatchException(n2.arg);
+        } else "return" === n2.method && n2.abrupt("return", n2.arg);
+        o2 = f;
+        var p2 = tryCatch(e2, r2, n2);
+        if ("normal" === p2.type) {
+          if (o2 = n2.done ? s : l, p2.arg === y) continue;
+          return { value: p2.arg, done: n2.done };
+        }
+        "throw" === p2.type && (o2 = s, n2.method = "throw", n2.arg = p2.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e2, r2) {
+    var n2 = r2.method, o2 = e2.iterator[n2];
+    if (o2 === t) return r2.delegate = null, "throw" === n2 && e2.iterator["return"] && (r2.method = "return", r2.arg = t, maybeInvokeDelegate(e2, r2), "throw" === r2.method) || "return" !== n2 && (r2.method = "throw", r2.arg = new TypeError("The iterator does not provide a '" + n2 + "' method")), y;
+    var i2 = tryCatch(o2, e2.iterator, r2.arg);
+    if ("throw" === i2.type) return r2.method = "throw", r2.arg = i2.arg, r2.delegate = null, y;
+    var a2 = i2.arg;
+    return a2 ? a2.done ? (r2[e2.resultName] = a2.value, r2.next = e2.nextLoc, "return" !== r2.method && (r2.method = "next", r2.arg = t), r2.delegate = null, y) : a2 : (r2.method = "throw", r2.arg = new TypeError("iterator result is not an object"), r2.delegate = null, y);
+  }
+  function pushTryEntry(t2) {
+    var e2 = { tryLoc: t2[0] };
+    1 in t2 && (e2.catchLoc = t2[1]), 2 in t2 && (e2.finallyLoc = t2[2], e2.afterLoc = t2[3]), this.tryEntries.push(e2);
+  }
+  function resetTryEntry(t2) {
+    var e2 = t2.completion || {};
+    e2.type = "normal", delete e2.arg, t2.completion = e2;
+  }
+  function Context(t2) {
+    this.tryEntries = [{ tryLoc: "root" }], t2.forEach(pushTryEntry, this), this.reset(true);
+  }
+  function values(e2) {
+    if (e2 || "" === e2) {
+      var r2 = e2[a];
+      if (r2) return r2.call(e2);
+      if ("function" == typeof e2.next) return e2;
+      if (!isNaN(e2.length)) {
+        var o2 = -1, i2 = function next() {
+          for (; ++o2 < e2.length; ) if (n.call(e2, o2)) return next.value = e2[o2], next.done = false, next;
+          return next.value = t, next.done = true, next;
+        };
+        return i2.next = i2;
+      }
+    }
+    throw new TypeError(_typeof$3(e2) + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { value: GeneratorFunctionPrototype, configurable: true }), o(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: true }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function(t2) {
+    var e2 = "function" == typeof t2 && t2.constructor;
+    return !!e2 && (e2 === GeneratorFunction || "GeneratorFunction" === (e2.displayName || e2.name));
+  }, e.mark = function(t2) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t2, GeneratorFunctionPrototype) : (t2.__proto__ = GeneratorFunctionPrototype, define(t2, u, "GeneratorFunction")), t2.prototype = Object.create(g), t2;
+  }, e.awrap = function(t2) {
+    return { __await: t2 };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c2, function() {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function(t2, r2, n2, o2, i2) {
+    void 0 === i2 && (i2 = Promise);
+    var a2 = new AsyncIterator(wrap(t2, r2, n2, o2), i2);
+    return e.isGeneratorFunction(r2) ? a2 : a2.next().then(function(t3) {
+      return t3.done ? t3.value : a2.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function() {
+    return this;
+  }), define(g, "toString", function() {
+    return "[object Generator]";
+  }), e.keys = function(t2) {
+    var e2 = Object(t2), r2 = [];
+    for (var n2 in e2) r2.push(n2);
+    return r2.reverse(), function next() {
+      for (; r2.length; ) {
+        var t3 = r2.pop();
+        if (t3 in e2) return next.value = t3, next.done = false, next;
+      }
+      return next.done = true, next;
+    };
+  }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e2) {
+    if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e2) for (var r2 in this) "t" === r2.charAt(0) && n.call(this, r2) && !isNaN(+r2.slice(1)) && (this[r2] = t);
+  }, stop: function stop() {
+    this.done = true;
+    var t2 = this.tryEntries[0].completion;
+    if ("throw" === t2.type) throw t2.arg;
+    return this.rval;
+  }, dispatchException: function dispatchException(e2) {
+    if (this.done) throw e2;
+    var r2 = this;
+    function handle(n2, o3) {
+      return a2.type = "throw", a2.arg = e2, r2.next = n2, o3 && (r2.method = "next", r2.arg = t), !!o3;
+    }
+    for (var o2 = this.tryEntries.length - 1; o2 >= 0; --o2) {
+      var i2 = this.tryEntries[o2], a2 = i2.completion;
+      if ("root" === i2.tryLoc) return handle("end");
+      if (i2.tryLoc <= this.prev) {
+        var c3 = n.call(i2, "catchLoc"), u2 = n.call(i2, "finallyLoc");
+        if (c3 && u2) {
+          if (this.prev < i2.catchLoc) return handle(i2.catchLoc, true);
+          if (this.prev < i2.finallyLoc) return handle(i2.finallyLoc);
+        } else if (c3) {
+          if (this.prev < i2.catchLoc) return handle(i2.catchLoc, true);
+        } else {
+          if (!u2) throw Error("try statement without catch or finally");
+          if (this.prev < i2.finallyLoc) return handle(i2.finallyLoc);
+        }
+      }
+    }
+  }, abrupt: function abrupt(t2, e2) {
+    for (var r2 = this.tryEntries.length - 1; r2 >= 0; --r2) {
+      var o2 = this.tryEntries[r2];
+      if (o2.tryLoc <= this.prev && n.call(o2, "finallyLoc") && this.prev < o2.finallyLoc) {
+        var i2 = o2;
+        break;
+      }
+    }
+    i2 && ("break" === t2 || "continue" === t2) && i2.tryLoc <= e2 && e2 <= i2.finallyLoc && (i2 = null);
+    var a2 = i2 ? i2.completion : {};
+    return a2.type = t2, a2.arg = e2, i2 ? (this.method = "next", this.next = i2.finallyLoc, y) : this.complete(a2);
+  }, complete: function complete(t2, e2) {
+    if ("throw" === t2.type) throw t2.arg;
+    return "break" === t2.type || "continue" === t2.type ? this.next = t2.arg : "return" === t2.type ? (this.rval = this.arg = t2.arg, this.method = "return", this.next = "end") : "normal" === t2.type && e2 && (this.next = e2), y;
+  }, finish: function finish(t2) {
+    for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+      var r2 = this.tryEntries[e2];
+      if (r2.finallyLoc === t2) return this.complete(r2.completion, r2.afterLoc), resetTryEntry(r2), y;
+    }
+  }, "catch": function _catch(t2) {
+    for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+      var r2 = this.tryEntries[e2];
+      if (r2.tryLoc === t2) {
+        var n2 = r2.completion;
+        if ("throw" === n2.type) {
+          var o2 = n2.arg;
+          resetTryEntry(r2);
+        }
+        return o2;
+      }
+    }
+    throw Error("illegal catch attempt");
+  }, delegateYield: function delegateYield(e2, r2, n2) {
+    return this.delegate = { iterator: values(e2), resultName: r2, nextLoc: n2 }, "next" === this.method && (this.arg = t), y;
+  } }, e;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+function _asyncToGenerator(fn) {
+  return function() {
+    var self2 = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self2, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _classCallCheck$3(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$3(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey$3(descriptor.key), descriptor);
+  }
+}
+function _createClass$3(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties$3(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _toPropertyKey$3(t) {
+  var i = _toPrimitive$3(t, "string");
+  return "symbol" == _typeof$3(i) ? i : i + "";
+}
+function _toPrimitive$3(t, r) {
+  if ("object" != _typeof$3(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof$3(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var FileReader$1 = /* @__PURE__ */ (function() {
+  function FileReader2() {
+    _classCallCheck$3(this, FileReader2);
+  }
+  return _createClass$3(FileReader2, [{
+    key: "openFile",
+    value: (function() {
+      var _openFile = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee(input, chunkSize) {
+        var blob;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!(isReactNative() && input && typeof input.uri !== "undefined")) {
+                _context.next = 11;
+                break;
+              }
+              _context.prev = 1;
+              _context.next = 4;
+              return uriToBlob(input.uri);
+            case 4:
+              blob = _context.sent;
+              return _context.abrupt("return", new FileSource(blob));
+            case 8:
+              _context.prev = 8;
+              _context.t0 = _context["catch"](1);
+              throw new Error("tus: cannot fetch `file.uri` as Blob, make sure the uri is correct and accessible. ".concat(_context.t0));
+            case 11:
+              if (!(typeof input.slice === "function" && typeof input.size !== "undefined")) {
+                _context.next = 13;
+                break;
+              }
+              return _context.abrupt("return", Promise.resolve(new FileSource(input)));
+            case 13:
+              if (!(typeof input.read === "function")) {
+                _context.next = 18;
+                break;
+              }
+              chunkSize = Number(chunkSize);
+              if (Number.isFinite(chunkSize)) {
+                _context.next = 17;
+                break;
+              }
+              return _context.abrupt("return", Promise.reject(new Error("cannot create source for stream without a finite value for the `chunkSize` option")));
+            case 17:
+              return _context.abrupt("return", Promise.resolve(new StreamSource(input, chunkSize)));
+            case 18:
+              return _context.abrupt("return", Promise.reject(new Error("source object may only be an instance of File, Blob, or Reader in this environment")));
+            case 19:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 8]]);
+      }));
+      function openFile(_x, _x2) {
+        return _openFile.apply(this, arguments);
+      }
+      return openFile;
+    })()
+  }]);
+})();
+function fingerprint(file, options) {
+  if (isReactNative()) {
+    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) {
+  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;
+  }
+  return hash;
+}
+function _typeof$2(o) {
+  "@babel/helpers - typeof";
+  return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof$2(o);
+}
+function _classCallCheck$2(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$2(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey$2(descriptor.key), descriptor);
+  }
+}
+function _createClass$2(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _toPropertyKey$2(t) {
+  var i = _toPrimitive$2(t, "string");
+  return "symbol" == _typeof$2(i) ? i : i + "";
+}
+function _toPrimitive$2(t, r) {
+  if ("object" != _typeof$2(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof$2(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var XHRHttpStack = /* @__PURE__ */ (function() {
+  function XHRHttpStack2() {
+    _classCallCheck$2(this, XHRHttpStack2);
+  }
+  return _createClass$2(XHRHttpStack2, [{
+    key: "createRequest",
+    value: function createRequest(method, url) {
+      return new Request(method, url);
+    }
+  }, {
+    key: "getName",
+    value: function getName() {
+      return "XHRHttpStack";
+    }
+  }]);
+})();
+var Request = /* @__PURE__ */ (function() {
+  function Request2(method, url) {
+    _classCallCheck$2(this, Request2);
+    this._xhr = new XMLHttpRequest();
+    this._xhr.open(method, url, true);
+    this._method = method;
+    this._url = url;
+    this._headers = {};
+  }
+  return _createClass$2(Request2, [{
+    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) {
+      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] !== void 0 ? 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;
+    }
+  }]);
+})();
+var Response = /* @__PURE__ */ (function() {
+  function Response2(xhr) {
+    _classCallCheck$2(this, Response2);
+    this._xhr = xhr;
+  }
+  return _createClass$2(Response2, [{
+    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;
+    }
+  }]);
+})();
+function _typeof$1(o) {
+  "@babel/helpers - typeof";
+  return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof$1(o);
+}
+function _classCallCheck$1(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$1(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey$1(descriptor.key), descriptor);
+  }
+}
+function _createClass$1(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _toPropertyKey$1(t) {
+  var i = _toPrimitive$1(t, "string");
+  return "symbol" == _typeof$1(i) ? i : i + "";
+}
+function _toPrimitive$1(t, r) {
+  if ("object" != _typeof$1(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof$1(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var hasStorage = false;
+try {
+  hasStorage = "localStorage" in window;
+  var key = "tusSupport";
+  var originalValue = localStorage.getItem(key);
+  localStorage.setItem(key, originalValue);
+  if (originalValue === null) localStorage.removeItem(key);
+} catch (e) {
+  if (e.code === e.SECURITY_ERR || e.code === e.QUOTA_EXCEEDED_ERR) {
+    hasStorage = false;
+  } else {
+    throw e;
+  }
+}
+var canStoreURLs = hasStorage;
+var WebStorageUrlStorage = /* @__PURE__ */ (function() {
+  function WebStorageUrlStorage2() {
+    _classCallCheck$1(this, WebStorageUrlStorage2);
+  }
+  return _createClass$1(WebStorageUrlStorage2, [{
+    key: "findAllUploads",
+    value: function findAllUploads() {
+      var results = this._findEntries("tus::");
+      return Promise.resolve(results);
+    }
+  }, {
+    key: "findUploadsByFingerprint",
+    value: function findUploadsByFingerprint(fingerprint2) {
+      var results = this._findEntries("tus::".concat(fingerprint2, "::"));
+      return Promise.resolve(results);
+    }
+  }, {
+    key: "removeUpload",
+    value: function removeUpload(urlStorageKey) {
+      localStorage.removeItem(urlStorageKey);
+      return Promise.resolve();
+    }
+  }, {
+    key: "addUpload",
+    value: function addUpload(fingerprint2, upload) {
+      var id = Math.round(Math.random() * 1e12);
+      var key = "tus::".concat(fingerprint2, "::").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) {
+        }
+      }
+      return results;
+    }
+  }]);
+})();
+function _typeof(o) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
+}
+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, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function _possibleConstructorReturn(self2, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self2);
+}
+function _assertThisInitialized(self2) {
+  if (self2 === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self2;
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch (t2) {
+  }
+  return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
+    return !!t;
+  })();
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf(o);
+}
+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 } });
+  Object.defineProperty(subClass, "prototype", { writable: false });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf(o, p);
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+function _toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+var defaultOptions = _objectSpread(_objectSpread({}, BaseUpload.defaultOptions), {}, {
+  httpStack: new XHRHttpStack(),
+  fileReader: new FileReader$1(),
+  urlStorage: canStoreURLs ? new WebStorageUrlStorage() : new NoopUrlStorage(),
+  fingerprint
+});
+var Upload = /* @__PURE__ */ (function(_BaseUpload) {
+  function Upload2() {
+    var file = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    _classCallCheck(this, Upload2);
+    options = _objectSpread(_objectSpread({}, defaultOptions), options);
+    return _callSuper(this, Upload2, [file, options]);
+  }
+  _inherits(Upload2, _BaseUpload);
+  return _createClass(Upload2, null, [{
+    key: "terminate",
+    value: function terminate(url) {
+      var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      options = _objectSpread(_objectSpread({}, defaultOptions), options);
+      return BaseUpload.terminate(url, options);
+    }
+  }]);
+})(BaseUpload);
+const QUERY_KEY = "file";
+const HOUR = 1e3 * 60 * 60;
+const APP_NAME = toKebabCase(clientEnv.VITE_APP_TITLE);
+z__default.object({
+  appName: z__default.string().min(1).max(255).default(APP_NAME).optional(),
+  subId: z__default.uuid()
+});
+const useGetFileMetas = (params, options) => {
+  const $ = c(12);
+  let queryParams;
+  if ($[0] !== params.appName || $[1] !== params.subId) {
+    queryParams = new URLSearchParams();
+    queryParams.append("appName", params.appName ?? APP_NAME);
+    queryParams.append("subId", params.subId);
+    $[0] = params.appName;
+    $[1] = params.subId;
+    $[2] = queryParams;
+  } else {
+    queryParams = $[2];
+  }
+  const t0 = params.appName ?? APP_NAME;
+  let t1;
+  if ($[3] !== params.subId || $[4] !== t0) {
+    t1 = [QUERY_KEY, "meta", t0, params.subId];
+    $[3] = params.subId;
+    $[4] = t0;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  let t2;
+  if ($[6] !== queryParams) {
+    t2 = (t32) => {
+      const {
+        signal
+      } = t32;
+      return httpClient.request({
+        url: `/${QUERY_KEY}/v1/meta?${queryParams.toString()}`,
+        method: "GET",
+        signal
+      }).then(_temp);
+    };
+    $[6] = queryParams;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  let t3;
+  if ($[8] !== options || $[9] !== t1 || $[10] !== t2) {
+    t3 = {
+      ...options,
+      queryKey: t1,
+      queryFn: t2,
+      staleTime: HOUR,
+      gcTime: HOUR,
+      refetchOnWindowFocus: false
+    };
+    $[8] = options;
+    $[9] = t1;
+    $[10] = t2;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
+  }
+  return useQuery(t3);
+};
+z__default.object({
+  appName: z__default.string().min(1).max(255).default(APP_NAME).optional(),
+  meta: FileMetaSchema.nullish()
+});
+const useGetFileThumbnail = (params, options) => {
+  const $ = c(13);
+  let queryParams;
+  if ($[0] !== params.appName || $[1] !== params.meta?.id) {
+    queryParams = new URLSearchParams();
+    queryParams.append("appName", params.appName ?? APP_NAME);
+    queryParams.append("id", params.meta?.id ?? "");
+    $[0] = params.appName;
+    $[1] = params.meta?.id;
+    $[2] = queryParams;
+  } else {
+    queryParams = $[2];
+  }
+  const t0 = params.appName ?? APP_NAME;
+  const t1 = params.meta?.id;
+  let t2;
+  if ($[3] !== t0 || $[4] !== t1) {
+    t2 = [QUERY_KEY, "thumbnail", t0, t1];
+    $[3] = t0;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] !== queryParams) {
+    t3 = (t42) => {
+      const {
+        signal
+      } = t42;
+      return httpClient.request({
+        url: `/${QUERY_KEY}/v1/thumbnail?${queryParams.toString()}`,
+        method: "GET",
+        signal,
+        responseType: "blob"
+      }).then(_temp2);
+    };
+    $[6] = queryParams;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  const t4 = !!params.meta && options?.enabled !== false;
+  let t5;
+  if ($[8] !== options || $[9] !== t2 || $[10] !== t3 || $[11] !== t4) {
+    t5 = {
+      ...options,
+      queryKey: t2,
+      queryFn: t3,
+      select: _temp3,
+      staleTime: HOUR,
+      gcTime: HOUR,
+      refetchOnWindowFocus: false,
+      enabled: t4
+    };
+    $[8] = options;
+    $[9] = t2;
+    $[10] = t3;
+    $[11] = t4;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  return useQuery(t5);
+};
+z__default.object({
+  appName: z__default.string().min(1).max(255).default(APP_NAME).optional(),
+  meta: FileMetaSchema.nullish()
+});
+const useGetFile = (params, options) => {
+  const $ = c(13);
+  let queryParams;
+  if ($[0] !== params.appName || $[1] !== params.meta?.id) {
+    queryParams = new URLSearchParams();
+    queryParams.append("appName", params.appName ?? APP_NAME);
+    queryParams.append("id", params.meta?.id ?? "");
+    $[0] = params.appName;
+    $[1] = params.meta?.id;
+    $[2] = queryParams;
+  } else {
+    queryParams = $[2];
+  }
+  const t0 = params.appName ?? APP_NAME;
+  const t1 = params.meta?.id;
+  let t2;
+  if ($[3] !== t0 || $[4] !== t1) {
+    t2 = [QUERY_KEY, t0, t1];
+    $[3] = t0;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] !== queryParams) {
+    t3 = (t42) => {
+      const {
+        signal
+      } = t42;
+      return httpClient.request({
+        url: `/${QUERY_KEY}/v1?${queryParams.toString()}`,
+        method: "GET",
+        signal,
+        responseType: "blob"
+      }).then(_temp4);
+    };
+    $[6] = queryParams;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  const t4 = !!params.meta && options?.enabled !== false;
+  let t5;
+  if ($[8] !== options || $[9] !== t2 || $[10] !== t3 || $[11] !== t4) {
+    t5 = {
+      ...options,
+      queryKey: t2,
+      queryFn: t3,
+      select: _temp5,
+      staleTime: HOUR,
+      gcTime: HOUR,
+      refetchOnWindowFocus: false,
+      enabled: t4
+    };
+    $[8] = options;
+    $[9] = t2;
+    $[10] = t3;
+    $[11] = t4;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  return useQuery(t5);
+};
+const useDownloadFile = (options) => {
+  const $ = c(2);
+  let t0;
+  if ($[0] !== options) {
+    t0 = {
+      ...options,
+      mutationFn: _temp7,
+      onSuccess: _temp8
+    };
+    $[0] = options;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return useMutation(t0);
+};
+const useOpenFile = (options) => {
+  const $ = c(2);
+  let t0;
+  if ($[0] !== options) {
+    t0 = {
+      ...options,
+      mutationFn: _temp0,
+      onSuccess: _temp1
+    };
+    $[0] = options;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return useMutation(t0);
+};
+const useUpdateFileMeta = (options) => {
+  const $ = c(5);
+  const queryClient = useQueryClient();
+  let t0;
+  if ($[0] !== queryClient) {
+    t0 = () => queryClient.invalidateQueries({
+      queryKey: [QUERY_KEY, "meta"],
+      exact: false
+    });
+    $[0] = queryClient;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== options || $[3] !== t0) {
+    t1 = {
+      ...options,
+      mutationFn: _temp11,
+      onSettled: t0
+    };
+    $[2] = options;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  return useMutation(t1);
+};
+const useDeleteFile = (options) => {
+  const $ = c(5);
+  const queryClient = useQueryClient();
+  let t0;
+  if ($[0] !== queryClient) {
+    t0 = () => queryClient.invalidateQueries({
+      queryKey: [QUERY_KEY, "meta"],
+      exact: false
+    });
+    $[0] = queryClient;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== options || $[3] !== t0) {
+    t1 = {
+      ...options,
+      mutationFn: _temp13,
+      onSettled: t0
+    };
+    $[2] = options;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  return useMutation(t1);
+};
+const useDeleteFiles = (options) => {
+  const $ = c(5);
+  const queryClient = useQueryClient();
+  let t0;
+  if ($[0] !== queryClient) {
+    t0 = () => queryClient.invalidateQueries({
+      queryKey: [QUERY_KEY, "meta"],
+      exact: false
+    });
+    $[0] = queryClient;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== options || $[3] !== t0) {
+    t1 = {
+      ...options,
+      mutationFn: _temp15,
+      onSettled: t0
+    };
+    $[2] = options;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  return useMutation(t1);
+};
+const useUploadFile = (t0) => {
+  const $ = c(8);
+  const {
+    subId,
+    onSuccess,
+    onError
+  } = t0;
+  const [progress, setProgress] = useState(0);
+  const queryClient = useQueryClient();
+  let t1;
+  if ($[0] !== onError || $[1] !== onSuccess || $[2] !== queryClient || $[3] !== subId) {
+    t1 = async (file) => {
+      if (!subId) {
+        throw new Error("subId is required for file upload");
+      }
+      const metadata = {
+        id: uuidv7(),
+        appName: APP_NAME,
+        subId,
+        fileName: file.name
+      };
+      const upload = new Upload(file, {
+        endpoint: `${clientEnv.VITE_API_URL}/${QUERY_KEY}/v1/upload`,
+        chunkSize: 1048576,
+        metadata: {
+          id: metadata.id,
+          appName: metadata.appName,
+          subId: metadata.subId,
+          fileName: metadata.fileName,
+          fileExtension: file.type
+        },
+        headers: {
+          "Authorization": "Bearer YOUR_ACCESS_TOKEN_HERE"
+        },
+        onError: (error) => {
+          setProgress(0);
+          onError?.(error);
+        },
+        onProgress: (bytesUploaded, bytesTotal) => {
+          setProgress(bytesUploaded / bytesTotal * 100);
+        },
+        onSuccess: () => {
+          setProgress(0);
+          queryClient.invalidateQueries({
+            queryKey: [QUERY_KEY, "meta", subId],
+            exact: false
+          });
+          onSuccess?.(metadata);
+        }
+      });
+      const previousUploads = await upload.findPreviousUploads();
+      if (previousUploads.length > 0) {
+        upload.resumeFromPreviousUpload(previousUploads[0]);
+      }
+      upload.start();
+    };
+    $[0] = onError;
+    $[1] = onSuccess;
+    $[2] = queryClient;
+    $[3] = subId;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const mutate = t1;
+  let t2;
+  if ($[5] !== mutate || $[6] !== progress) {
+    t2 = {
+      mutate,
+      progress
+    };
+    $[5] = mutate;
+    $[6] = progress;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  return t2;
+};
+function _temp(request) {
+  return request.data;
+}
+function _temp2(request) {
+  return request.data;
+}
+function _temp3(data) {
+  return URL.createObjectURL(data);
+}
+function _temp4(request) {
+  return request.data;
+}
+function _temp5(data) {
+  return URL.createObjectURL(data);
+}
+function _temp6(request) {
+  return request.data;
+}
+function _temp7(meta) {
+  return httpClient.request({
+    url: `/${QUERY_KEY}/v1/download?appName=${APP_NAME}&id=${meta.id}`,
+    method: "GET",
+    responseType: "blob"
+  }).then(_temp6);
+}
+function _temp8(data, variables) {
+  return saveAs(data, `${variables.fileName}.${variables.fileExtension}`);
+}
+function _temp9(request) {
+  return request.data;
+}
+function _temp0(meta) {
+  return httpClient.request({
+    url: `/${QUERY_KEY}/v1?appName=${APP_NAME}&id=${meta.id}`,
+    method: "GET",
+    responseType: "blob"
+  }).then(_temp9);
+}
+function _temp1(data) {
+  window.open(URL.createObjectURL(data));
+}
+function _temp10(request) {
+  return request.data;
+}
+function _temp11(meta) {
+  return httpClient.request({
+    url: `/${QUERY_KEY}/v1/meta?appName=${APP_NAME}&id=${meta.id}`,
+    method: "PUT",
+    data: meta
+  }).then(_temp10);
+}
+function _temp12(request) {
+  return request.data;
+}
+function _temp13(meta) {
+  return httpClient.request({
+    url: `/${QUERY_KEY}/v1?appName=${APP_NAME}&id=${meta.id}`,
+    method: "DELETE"
+  }).then(_temp12);
+}
+function _temp14(request) {
+  return request.data;
+}
+function _temp15(subId) {
+  return httpClient.request({
+    url: `/${QUERY_KEY}/v1?appName=${APP_NAME}&subId=${subId}`,
+    method: "DELETE"
+  }).then(_temp14);
+}
+export {
+  useGetFileThumbnail as a,
+  useGetFile as b,
+  useDownloadFile as c,
+  useOpenFile as d,
+  useUpdateFileMeta as e,
+  useDeleteFile as f,
+  useDeleteFiles as g,
+  useUploadFile as h,
+  useGetFileMetas as u
+};
+//# sourceMappingURL=FileHooks-DdKh9cZa.js.map