@cling-se/widget 0.14.4 → 0.14.5

package/dist/BaseUpload-BDWnWTxr.js

@@ -0,0 +1,1977 @@
+import { a5 as Ue, k as De, n as $e, af as ye, O as ve } from "./main-B9t0ybqW.js";
+/*!
+ * Compressor.js v1.1.1
+ * https://fengyuanchen.github.io/compressorjs
+ *
+ * Copyright 2018-present Chen Fengyuan
+ * Released under the MIT license
+ *
+ * Date: 2021-10-05T02:32:40.212Z
+ */
+function be(s, n) {
+  var a = Object.keys(s);
+  if (Object.getOwnPropertySymbols) {
+    var l = Object.getOwnPropertySymbols(s);
+    n && (l = l.filter(function(d) {
+      return Object.getOwnPropertyDescriptor(s, d).enumerable;
+    })), a.push.apply(a, l);
+  }
+  return a;
+}
+function le(s) {
+  for (var n = 1; n < arguments.length; n++) {
+    var a = arguments[n] != null ? arguments[n] : {};
+    n % 2 ? be(Object(a), !0).forEach(function(l) {
+      Se(s, l, a[l]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(s, Object.getOwnPropertyDescriptors(a)) : be(Object(a)).forEach(function(l) {
+      Object.defineProperty(s, l, Object.getOwnPropertyDescriptor(a, l));
+    });
+  }
+  return s;
+}
+function Re(s, n) {
+  if (!(s instanceof n))
+    throw new TypeError("Cannot call a class as a function");
+}
+function _e(s, n) {
+  for (var a = 0; a < n.length; a++) {
+    var l = n[a];
+    l.enumerable = l.enumerable || !1, l.configurable = !0, "value" in l && (l.writable = !0), Object.defineProperty(s, l.key, l);
+  }
+}
+function Te(s, n, a) {
+  return n && _e(s.prototype, n), a && _e(s, a), s;
+}
+function Se(s, n, a) {
+  return n in s ? Object.defineProperty(s, n, {
+    value: a,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : s[n] = a, s;
+}
+function fe() {
+  return fe = Object.assign || function(s) {
+    for (var n = 1; n < arguments.length; n++) {
+      var a = arguments[n];
+      for (var l in a)
+        Object.prototype.hasOwnProperty.call(a, l) && (s[l] = a[l]);
+    }
+    return s;
+  }, fe.apply(this, arguments);
+}
+var Ee = { exports: {} };
+(function(s) {
+  typeof window > "u" || function(n) {
+    var a = n.HTMLCanvasElement && n.HTMLCanvasElement.prototype, l = n.Blob && function() {
+      try {
+        return !!new Blob();
+      } catch {
+        return !1;
+      }
+    }(), d = l && n.Uint8Array && function() {
+      try {
+        return new Blob([new Uint8Array(100)]).size === 100;
+      } catch {
+        return !1;
+      }
+    }(), p = n.BlobBuilder || n.WebKitBlobBuilder || n.MozBlobBuilder || n.MSBlobBuilder, m = /^data:((.*?)(;charset=.*?)?)(;base64)?,/, k = (l || p) && n.atob && n.ArrayBuffer && n.Uint8Array && function(g) {
+      var b, w, A, B, T, v, S, U, H;
+      if (b = g.match(m), !b)
+        throw new Error("invalid data URI");
+      for (w = b[2] ? b[1] : "text/plain" + (b[3] || ";charset=US-ASCII"), A = !!b[4], B = g.slice(b[0].length), A ? T = atob(B) : T = decodeURIComponent(B), v = new ArrayBuffer(T.length), S = new Uint8Array(v), U = 0; U < T.length; U += 1)
+        S[U] = T.charCodeAt(U);
+      return l ? new Blob([d ? S : v], {
+        type: w
+      }) : (H = new p(), H.append(v), H.getBlob(w));
+    };
+    n.HTMLCanvasElement && !a.toBlob && (a.mozGetAsFile ? a.toBlob = function(g, b, w) {
+      var A = this;
+      setTimeout(function() {
+        w && a.toDataURL && k ? g(k(A.toDataURL(b, w))) : g(A.mozGetAsFile("blob", b));
+      });
+    } : a.toDataURL && k && (a.msToBlob ? a.toBlob = function(g, b, w) {
+      var A = this;
+      setTimeout(function() {
+        (b && b !== "image/png" || w) && a.toDataURL && k ? g(k(A.toDataURL(b, w))) : g(A.msToBlob(b));
+      });
+    } : a.toBlob = function(g, b, w) {
+      var A = this;
+      setTimeout(function() {
+        g(k(A.toDataURL(b, w)));
+      });
+    })), s.exports ? s.exports = k : n.dataURLtoBlob = k;
+  }(window);
+})(Ee);
+var Be = Ee.exports, je = function(n) {
+  return typeof Blob > "u" ? !1 : n instanceof Blob || Object.prototype.toString.call(n) === "[object Blob]";
+}, ke = {
+  /**
+   * Indicates if output the original image instead of the compressed one
+   * when the size of the compressed image is greater than the original one's
+   * @type {boolean}
+   */
+  strict: !0,
+  /**
+   * Indicates if read the image's Exif Orientation information,
+   * and then rotate or flip the image automatically.
+   * @type {boolean}
+   */
+  checkOrientation: !0,
+  /**
+   * The max width of the output image.
+   * @type {number}
+   */
+  maxWidth: 1 / 0,
+  /**
+   * The max height of the output image.
+   * @type {number}
+   */
+  maxHeight: 1 / 0,
+  /**
+   * The min width of the output image.
+   * @type {number}
+   */
+  minWidth: 0,
+  /**
+   * The min height of the output image.
+   * @type {number}
+   */
+  minHeight: 0,
+  /**
+   * The width of the output image.
+   * If not specified, the natural width of the source image will be used.
+   * @type {number}
+   */
+  width: void 0,
+  /**
+   * The height of the output image.
+   * If not specified, the natural height of the source image will be used.
+   * @type {number}
+   */
+  height: void 0,
+  /**
+   * Sets how the size of the image should be resized to the container
+   * specified by the `width` and `height` options.
+   * @type {string}
+   */
+  resize: "none",
+  /**
+   * The quality of the output image.
+   * It must be a number between `0` and `1`,
+   * and only available for `image/jpeg` and `image/webp` images.
+   * Check out {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob canvas.toBlob}.
+   * @type {number}
+   */
+  quality: 0.8,
+  /**
+   * The mime type of the output image.
+   * By default, the original mime type of the source image file will be used.
+   * @type {string}
+   */
+  mimeType: "auto",
+  /**
+   * Files whose file type is included in this list,
+   * and whose file size exceeds the `convertSize` value will be converted to JPEGs.
+   * @type {string｜Array}
+   */
+  convertTypes: ["image/png"],
+  /**
+   * PNG files over this size (5 MB by default) will be converted to JPEGs.
+   * To disable this, just set the value to `Infinity`.
+   * @type {number}
+   */
+  convertSize: 5e6,
+  /**
+   * The hook function to execute before draw the image into the canvas for compression.
+   * @type {Function}
+   * @param {CanvasRenderingContext2D} context - The 2d rendering context of the canvas.
+   * @param {HTMLCanvasElement} canvas - The canvas for compression.
+   * @example
+   * function (context, canvas) {
+   *   context.fillStyle = '#fff';
+   * }
+   */
+  beforeDraw: null,
+  /**
+   * The hook function to execute after drew the image into the canvas for compression.
+   * @type {Function}
+   * @param {CanvasRenderingContext2D} context - The 2d rendering context of the canvas.
+   * @param {HTMLCanvasElement} canvas - The canvas for compression.
+   * @example
+   * function (context, canvas) {
+   *   context.filter = 'grayscale(100%)';
+   * }
+   */
+  drew: null,
+  /**
+   * The hook function to execute when success to compress the image.
+   * @type {Function}
+   * @param {File} file - The compressed image File object.
+   * @example
+   * function (file) {
+   *   console.log(file);
+   * }
+   */
+  success: null,
+  /**
+   * The hook function to execute when fail to compress the image.
+   * @type {Function}
+   * @param {Error} err - An Error object.
+   * @example
+   * function (err) {
+   *   console.log(err.message);
+   * }
+   */
+  error: null
+}, Pe = typeof window < "u" && typeof window.document < "u", q = Pe ? window : {}, de = function(n) {
+  return n > 0 && n < 1 / 0;
+}, Ie = Array.prototype.slice;
+function ze(s) {
+  return Array.from ? Array.from(s) : Ie.call(s);
+}
+var Ne = /^image\/.+$/;
+function ge(s) {
+  return Ne.test(s);
+}
+function Le(s) {
+  var n = ge(s) ? s.substr(6) : "";
+  return n === "jpeg" && (n = "jpg"), ".".concat(n);
+}
+var Ae = String.fromCharCode;
+function Me(s, n, a) {
+  var l = "", d;
+  for (a += n, d = n; d < a; d += 1)
+    l += Ae(s.getUint8(d));
+  return l;
+}
+var He = q.btoa;
+function We(s, n) {
+  for (var a = [], l = 8192, d = new Uint8Array(s); d.length > 0; )
+    a.push(Ae.apply(null, ze(d.subarray(0, l)))), d = d.subarray(l);
+  return "data:".concat(n, ";base64,").concat(He(a.join("")));
+}
+function qe(s) {
+  var n = new DataView(s), a;
+  try {
+    var l, d, p;
+    if (n.getUint8(0) === 255 && n.getUint8(1) === 216)
+      for (var m = n.byteLength, k = 2; k + 1 < m; ) {
+        if (n.getUint8(k) === 255 && n.getUint8(k + 1) === 225) {
+          d = k;
+          break;
+        }
+        k += 1;
+      }
+    if (d) {
+      var g = d + 4, b = d + 10;
+      if (Me(n, g, 4) === "Exif") {
+        var w = n.getUint16(b);
+        if (l = w === 18761, (l || w === 19789) && n.getUint16(b + 2, l) === 42) {
+          var A = n.getUint32(b + 4, l);
+          A >= 8 && (p = b + A);
+        }
+      }
+    }
+    if (p) {
+      var B = n.getUint16(p, l), T, v;
+      for (v = 0; v < B; v += 1)
+        if (T = p + v * 12 + 2, n.getUint16(T, l) === 274) {
+          T += 8, a = n.getUint16(T, l), n.setUint16(T, 1, l);
+          break;
+        }
+    }
+  } catch {
+    a = 1;
+  }
+  return a;
+}
+function Fe(s) {
+  var n = 0, a = 1, l = 1;
+  switch (s) {
+    case 2:
+      a = -1;
+      break;
+    case 3:
+      n = -180;
+      break;
+    case 4:
+      l = -1;
+      break;
+    case 5:
+      n = 90, l = -1;
+      break;
+    case 6:
+      n = 90;
+      break;
+    case 7:
+      n = 90, a = -1;
+      break;
+    case 8:
+      n = -90;
+      break;
+  }
+  return {
+    rotate: n,
+    scaleX: a,
+    scaleY: l
+  };
+}
+var Xe = /\.\d*(?:0|9){12}\d*$/;
+function xe(s) {
+  var n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1e11;
+  return Xe.test(s) ? Math.round(s * n) / n : s;
+}
+function V(s) {
+  var n = s.aspectRatio, a = s.height, l = s.width, d = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "none", p = de(l), m = de(a);
+  if (p && m) {
+    var k = a * n;
+    (d === "contain" || d === "none") && k > l || d === "cover" && k < l ? a = l / n : l = a * n;
+  } else
+    p ? a = l / n : m && (l = a * n);
+  return {
+    width: l,
+    height: a
+  };
+}
+var Ge = q.ArrayBuffer, Ce = q.FileReader, X = q.URL || q.webkitURL, Ke = /\.\w+$/, Je = q.Compressor, Oe = /* @__PURE__ */ function() {
+  function s(n, a) {
+    Re(this, s), this.file = n, this.image = new Image(), this.options = le(le({}, ke), a), this.aborted = !1, this.result = null, this.init();
+  }
+  return Te(s, [{
+    key: "init",
+    value: function() {
+      var a = this, l = this.file, d = this.options;
+      if (!je(l)) {
+        this.fail(new Error("The first argument must be a File or Blob object."));
+        return;
+      }
+      var p = l.type;
+      if (!ge(p)) {
+        this.fail(new Error("The first argument must be an image File or Blob object."));
+        return;
+      }
+      if (!X || !Ce) {
+        this.fail(new Error("The current browser does not support image compression."));
+        return;
+      }
+      if (Ge || (d.checkOrientation = !1), X && !d.checkOrientation)
+        this.load({
+          url: X.createObjectURL(l)
+        });
+      else {
+        var m = new Ce(), k = d.checkOrientation && p === "image/jpeg";
+        this.reader = m, m.onload = function(g) {
+          var b = g.target, w = b.result, A = {};
+          if (k) {
+            var B = qe(w);
+            B > 1 || !X ? (A.url = We(w, p), B > 1 && fe(A, Fe(B))) : A.url = X.createObjectURL(l);
+          } else
+            A.url = w;
+          a.load(A);
+        }, m.onabort = function() {
+          a.fail(new Error("Aborted to read the image with FileReader."));
+        }, m.onerror = function() {
+          a.fail(new Error("Failed to read the image with FileReader."));
+        }, m.onloadend = function() {
+          a.reader = null;
+        }, k ? m.readAsArrayBuffer(l) : m.readAsDataURL(l);
+      }
+    }
+  }, {
+    key: "load",
+    value: function(a) {
+      var l = this, d = this.file, p = this.image;
+      p.onload = function() {
+        l.draw(le(le({}, a), {}, {
+          naturalWidth: p.naturalWidth,
+          naturalHeight: p.naturalHeight
+        }));
+      }, p.onabort = function() {
+        l.fail(new Error("Aborted to load the image."));
+      }, p.onerror = function() {
+        l.fail(new Error("Failed to load the image."));
+      }, q.navigator && /(?:iPad|iPhone|iPod).*?AppleWebKit/i.test(q.navigator.userAgent) && (p.crossOrigin = "anonymous"), p.alt = d.name, p.src = a.url;
+    }
+  }, {
+    key: "draw",
+    value: function(a) {
+      var l = this, d = a.naturalWidth, p = a.naturalHeight, m = a.rotate, k = m === void 0 ? 0 : m, g = a.scaleX, b = g === void 0 ? 1 : g, w = a.scaleY, A = w === void 0 ? 1 : w, B = this.file, T = this.image, v = this.options, S = document.createElement("canvas"), U = S.getContext("2d"), H = Math.abs(k) % 180 === 90, G = (v.resize === "contain" || v.resize === "cover") && de(v.width) && de(v.height), F = Math.max(v.maxWidth, 0) || 1 / 0, I = Math.max(v.maxHeight, 0) || 1 / 0, z = Math.max(v.minWidth, 0) || 0, W = Math.max(v.minHeight, 0) || 0, L = d / p, D = v.width, $ = v.height;
+      if (H) {
+        var Q = [I, F];
+        F = Q[0], I = Q[1];
+        var Z = [W, z];
+        z = Z[0], W = Z[1];
+        var K = [$, D];
+        D = K[0], $ = K[1];
+      }
+      G && (L = D / $);
+      var ee = V({
+        aspectRatio: L,
+        width: F,
+        height: I
+      }, "contain");
+      F = ee.width, I = ee.height;
+      var te = V({
+        aspectRatio: L,
+        width: z,
+        height: W
+      }, "cover");
+      if (z = te.width, W = te.height, G) {
+        var re = V({
+          aspectRatio: L,
+          width: D,
+          height: $
+        }, v.resize);
+        D = re.width, $ = re.height;
+      } else {
+        var ie = V({
+          aspectRatio: L,
+          width: D,
+          height: $
+        }), ne = ie.width;
+        D = ne === void 0 ? d : ne;
+        var ae = ie.height;
+        $ = ae === void 0 ? p : ae;
+      }
+      D = Math.floor(xe(Math.min(Math.max(D, z), F))), $ = Math.floor(xe(Math.min(Math.max($, W), I)));
+      var ce = -D / 2, pe = -$ / 2, he = D, me = $, J = [];
+      if (G) {
+        var se = 0, oe = 0, Y = d, f = p, t = V({
+          aspectRatio: L,
+          width: d,
+          height: p
+        }, {
+          contain: "cover",
+          cover: "contain"
+        }[v.resize]);
+        Y = t.width, f = t.height, se = (d - Y) / 2, oe = (p - f) / 2, J.push(se, oe, Y, f);
+      }
+      if (J.push(ce, pe, he, me), H) {
+        var r = [$, D];
+        D = r[0], $ = r[1];
+      }
+      S.width = D, S.height = $, ge(v.mimeType) || (v.mimeType = B.type);
+      var i = "transparent";
+      if (B.size > v.convertSize && v.convertTypes.indexOf(v.mimeType) >= 0 && (v.mimeType = "image/jpeg"), v.mimeType === "image/jpeg" && (i = "#fff"), U.fillStyle = i, U.fillRect(0, 0, D, $), v.beforeDraw && v.beforeDraw.call(this, U, S), !this.aborted && (U.save(), U.translate(D / 2, $ / 2), U.rotate(k * Math.PI / 180), U.scale(b, A), U.drawImage.apply(U, [T].concat(J)), U.restore(), v.drew && v.drew.call(this, U, S), !this.aborted)) {
+        var u = function(h) {
+          l.aborted || l.done({
+            naturalWidth: d,
+            naturalHeight: p,
+            result: h
+          });
+        };
+        S.toBlob ? S.toBlob(u, v.mimeType, v.quality) : u(Be(S.toDataURL(v.mimeType, v.quality)));
+      }
+    }
+  }, {
+    key: "done",
+    value: function(a) {
+      var l = a.naturalWidth, d = a.naturalHeight, p = a.result, m = this.file, k = this.image, g = this.options;
+      if (X && !g.checkOrientation && X.revokeObjectURL(k.src), p)
+        if (g.strict && p.size > m.size && g.mimeType === m.type && !(g.width > l || g.height > d || g.minWidth > l || g.minHeight > d || g.maxWidth < l || g.maxHeight < d))
+          p = m;
+        else {
+          var b = /* @__PURE__ */ new Date();
+          p.lastModified = b.getTime(), p.lastModifiedDate = b, p.name = m.name, p.name && p.type !== m.type && (p.name = p.name.replace(Ke, Le(p.type)));
+        }
+      else
+        p = m;
+      this.result = p, g.success && g.success.call(this, p);
+    }
+  }, {
+    key: "fail",
+    value: function(a) {
+      var l = this.options;
+      if (l.error)
+        l.error.call(this, a);
+      else
+        throw a;
+    }
+  }, {
+    key: "abort",
+    value: function() {
+      this.aborted || (this.aborted = !0, this.reader ? this.reader.abort() : this.image.complete ? this.fail(new Error("The compression process has been aborted.")) : (this.image.onload = null, this.image.onabort()));
+    }
+    /**
+     * Get the no conflict compressor class.
+     * @returns {Compressor} The compressor class.
+     */
+  }], [{
+    key: "noConflict",
+    value: function() {
+      return window.Compressor = Je, s;
+    }
+    /**
+     * Change the default options.
+     * @param {Object} options - The new default options.
+     */
+  }, {
+    key: "setDefaults",
+    value: function(a) {
+      fe(ke, a);
+    }
+  }]), s;
+}(), we = { exports: {} };
+/*!
+ * Name: vue-upload-component
+ * Version: 2.8.21
+ * Author: Marco Lang
+ */
+(function(s, n) {
+  (function(a, l) {
+    s.exports = l();
+  })(Ue, function() {
+    var a = function(t) {
+      var r = new XMLHttpRequest();
+      return r.open(t.method || "GET", t.url), r.responseType = "json", t.headers && Object.keys(t.headers).forEach(function(i) {
+        r.setRequestHeader(i, t.headers[i]);
+      }), r;
+    }, l = function(t, r) {
+      return new Promise(function(i, u) {
+        t.onload = function() {
+          if (t.status >= 200 && t.status < 300) {
+            var o;
+            try {
+              o = JSON.parse(t.response);
+            } catch {
+              o = t.response;
+            }
+            i(o);
+          } else
+            u(t.response);
+        }, t.onerror = function() {
+          return u(t.response);
+        }, t.send(JSON.stringify(r));
+      });
+    }, d = function(t, r) {
+      var i = new FormData();
+      for (var u in r)
+        i.append(u, r[u]);
+      return new Promise(function(o, h) {
+        t.onload = function() {
+          if (t.status >= 200 && t.status < 300) {
+            var c;
+            try {
+              c = JSON.parse(t.response);
+            } catch {
+              c = t.response;
+            }
+            o(c);
+          } else
+            h(t.response);
+        }, t.onerror = function() {
+          return h(t.response);
+        }, t.send(i);
+      });
+    };
+    function p(f) {
+      var t = a(f);
+      return l(t, f.body);
+    }
+    var m = /* @__PURE__ */ function() {
+      function f(t, r) {
+        for (var i = 0; i < r.length; i++) {
+          var u = r[i];
+          u.enumerable = u.enumerable || !1, u.configurable = !0, "value" in u && (u.writable = !0), Object.defineProperty(t, u.key, u);
+        }
+      }
+      return function(t, r, i) {
+        return r && f(t.prototype, r), i && f(t, i), t;
+      };
+    }();
+    function k(f, t) {
+      if (!(f instanceof t))
+        throw new TypeError("Cannot call a class as a function");
+    }
+    var g = function() {
+      function f(t, r) {
+        k(this, f), this.file = t, this.options = r, this.chunks = [], this.sessionId = null, this.chunkSize = null, this.speedInterval = null;
+      }
+      return m(f, [{
+        key: "createChunks",
+        /**
+         * Creates all the chunks in the initial state
+         */
+        value: function() {
+          this.chunks = [];
+          for (var r = 0, i = this.chunkSize; r < this.fileSize; )
+            this.chunks.push({
+              blob: this.file.file.slice(r, i),
+              startOffset: r,
+              active: !1,
+              retries: this.maxRetries
+            }), r = i, i = r + this.chunkSize;
+        }
+        /**
+         * Updates the progress of the file with the handler's progress
+         */
+      }, {
+        key: "updateFileProgress",
+        value: function() {
+          this.file.progress = this.progress;
+        }
+        /**
+         * Paues the upload process
+         * - Stops all active requests
+         * - Sets the file not active
+         */
+      }, {
+        key: "pause",
+        value: function() {
+          this.file.active = !1, this.stopChunks();
+        }
+        /**
+         * Stops all the current chunks
+         */
+      }, {
+        key: "stopChunks",
+        value: function() {
+          this.chunksUploading.forEach(function(r) {
+            r.xhr.abort(), r.active = !1;
+          }), this.stopSpeedCalc();
+        }
+        /**
+         * Resumes the file upload
+         * - Sets the file active
+         * - Starts the following chunks
+         */
+      }, {
+        key: "resume",
+        value: function() {
+          this.file.active = !0, this.startChunking();
+        }
+        /**
+         * Starts the file upload
+         *
+         * @returns Promise
+         * - resolve  The file was uploaded
+         * - reject   The file upload failed
+         */
+      }, {
+        key: "upload",
+        value: function() {
+          var r = this;
+          return this.promise = new Promise(function(i, u) {
+            r.resolve = i, r.reject = u;
+          }), this.start(), this.promise;
+        }
+        /**
+         * Start phase
+         * Sends a request to the backend to initialise the chunks
+         */
+      }, {
+        key: "start",
+        value: function() {
+          var r = this;
+          p({
+            method: "POST",
+            headers: Object.assign({}, this.headers, {
+              "Content-Type": "application/json"
+            }),
+            url: this.action,
+            body: Object.assign(this.startBody, {
+              phase: "start",
+              mime_type: this.fileType,
+              size: this.fileSize,
+              name: this.fileName
+            })
+          }).then(function(i) {
+            if (i.status !== "success")
+              return r.file.response = i, r.reject("server");
+            r.sessionId = i.data.session_id, r.chunkSize = i.data.end_offset, r.createChunks(), r.startChunking();
+          }).catch(function(i) {
+            r.file.response = i, r.reject("server");
+          });
+        }
+        /**
+         * Starts to upload chunks
+         */
+      }, {
+        key: "startChunking",
+        value: function() {
+          for (var r = 0; r < this.maxActiveChunks; r++)
+            this.uploadNextChunk();
+          this.startSpeedCalc();
+        }
+        /**
+         * Uploads the next chunk
+         * - Won't do anything if the process is paused
+         * - Will start finish phase if there are no more chunks to upload
+         */
+      }, {
+        key: "uploadNextChunk",
+        value: function() {
+          if (this.file.active) {
+            if (this.hasChunksToUpload)
+              return this.uploadChunk(this.chunksToUpload[0]);
+            if (this.chunksUploading.length === 0)
+              return this.finish();
+          }
+        }
+        /**
+         * Uploads a chunk
+         * - Sends the chunk to the backend
+         * - Sets the chunk as uploaded if everything went well
+         * - Decreases the number of retries if anything went wrong
+         * - Fails if there are no more retries
+         *
+         * @param {Object} chunk
+         */
+      }, {
+        key: "uploadChunk",
+        value: function(r) {
+          var i = this;
+          r.progress = 0, r.active = !0, this.updateFileProgress(), r.xhr = a({
+            method: "POST",
+            headers: this.headers,
+            url: this.action
+          }), r.xhr.upload.addEventListener("progress", function(u) {
+            u.lengthComputable && (r.progress = Math.round(u.loaded / u.total * 100));
+          }, !1), d(r.xhr, Object.assign(this.uploadBody, {
+            phase: "upload",
+            session_id: this.sessionId,
+            start_offset: r.startOffset,
+            chunk: r.blob
+          })).then(function(u) {
+            if (r.active = !1, u.status === "success")
+              r.uploaded = !0;
+            else if (r.retries-- <= 0)
+              return i.stopChunks(), i.reject("upload");
+            i.uploadNextChunk();
+          }).catch(function() {
+            if (r.active = !1, r.retries-- <= 0)
+              return i.stopChunks(), i.reject("upload");
+            i.uploadNextChunk();
+          });
+        }
+        /**
+         * Finish phase
+         * Sends a request to the backend to finish the process
+         */
+      }, {
+        key: "finish",
+        value: function() {
+          var r = this;
+          this.updateFileProgress(), this.stopSpeedCalc(), p({
+            method: "POST",
+            headers: Object.assign({}, this.headers, {
+              "Content-Type": "application/json"
+            }),
+            url: this.action,
+            body: Object.assign(this.finishBody, {
+              phase: "finish",
+              session_id: this.sessionId
+            })
+          }).then(function(i) {
+            if (r.file.response = i, i.status !== "success")
+              return r.reject("server");
+            r.resolve(i);
+          }).catch(function(i) {
+            r.file.response = i, r.reject("server");
+          });
+        }
+        /**
+         * Sets an interval to calculate and
+         * set upload speed every 3 seconds
+         */
+      }, {
+        key: "startSpeedCalc",
+        value: function() {
+          var r = this;
+          this.file.speed = 0;
+          var i = 0;
+          this.speedInterval || (this.speedInterval = window.setInterval(function() {
+            var u = r.progress / 100 * r.fileSize;
+            r.file.speed = u - i, i = u;
+          }, 1e3));
+        }
+        /**
+         * Removes the upload speed interval
+         */
+      }, {
+        key: "stopSpeedCalc",
+        value: function() {
+          this.speedInterval && window.clearInterval(this.speedInterval), this.speedInterval = null, this.file.speed = 0;
+        }
+      }, {
+        key: "maxRetries",
+        get: function() {
+          return parseInt(this.options.maxRetries, 10);
+        }
+        /**
+         * Gets the max number of active chunks being uploaded at once from options
+         */
+      }, {
+        key: "maxActiveChunks",
+        get: function() {
+          return parseInt(this.options.maxActive, 10);
+        }
+        /**
+         * Gets the file type
+         */
+      }, {
+        key: "fileType",
+        get: function() {
+          return this.file.type;
+        }
+        /**
+         * Gets the file size
+         */
+      }, {
+        key: "fileSize",
+        get: function() {
+          return this.file.size;
+        }
+        /**
+         * Gets the file name
+         */
+      }, {
+        key: "fileName",
+        get: function() {
+          return this.file.name;
+        }
+        /**
+         * Gets action (url) to upload the file
+         */
+      }, {
+        key: "action",
+        get: function() {
+          return this.options.action || null;
+        }
+        /**
+         * Gets the body to be merged when sending the request in start phase
+         */
+      }, {
+        key: "startBody",
+        get: function() {
+          return this.options.startBody || {};
+        }
+        /**
+         * Gets the body to be merged when sending the request in upload phase
+         */
+      }, {
+        key: "uploadBody",
+        get: function() {
+          return this.options.uploadBody || {};
+        }
+        /**
+         * Gets the body to be merged when sending the request in finish phase
+         */
+      }, {
+        key: "finishBody",
+        get: function() {
+          return this.options.finishBody || {};
+        }
+        /**
+         * Gets the headers of the requests from options
+         */
+      }, {
+        key: "headers",
+        get: function() {
+          return this.options.headers || {};
+        }
+        /**
+         * Whether it's ready to upload files or not
+         */
+      }, {
+        key: "readyToUpload",
+        get: function() {
+          return !!this.chunks;
+        }
+        /**
+         * Gets the progress of the chunk upload
+         * - Gets all the completed chunks
+         * - Gets the progress of all the chunks that are being uploaded
+         */
+      }, {
+        key: "progress",
+        get: function() {
+          var r = this, i = this.chunksUploaded.length / this.chunks.length * 100, u = this.chunksUploading.reduce(function(o, h) {
+            return o + (h.progress | 0) / r.chunks.length;
+          }, 0);
+          return Math.min(i + u, 100);
+        }
+        /**
+         * Gets all the chunks that are pending to be uploaded
+         */
+      }, {
+        key: "chunksToUpload",
+        get: function() {
+          return this.chunks.filter(function(r) {
+            return !r.active && !r.uploaded;
+          });
+        }
+        /**
+         * Whether there are chunks to upload or not
+         */
+      }, {
+        key: "hasChunksToUpload",
+        get: function() {
+          return this.chunksToUpload.length > 0;
+        }
+        /**
+         * Gets all the chunks that are uploading
+         */
+      }, {
+        key: "chunksUploading",
+        get: function() {
+          return this.chunks.filter(function(r) {
+            return !!r.xhr && !!r.active;
+          });
+        }
+        /**
+         * Gets all the chunks that have finished uploading
+         */
+      }, {
+        key: "chunksUploaded",
+        get: function() {
+          return this.chunks.filter(function(r) {
+            return !!r.uploaded;
+          });
+        }
+      }]), f;
+    }(), b = {
+      methods: {
+        change: function(t) {
+          this.$parent.addInputFile(t.target), t.target.files ? (t.target.value = "", t.target.files.length && !/safari/i.test(navigator.userAgent) && (t.target.type = "", t.target.type = "file")) : (this.$destroy(), new this.constructor({
+            parent: this.$parent,
+            el: this.$el
+          }));
+        }
+      }
+    };
+    function w(f, t, r, i, u, o, h, c, x, C) {
+      typeof h != "boolean" && (x = c, c = h, h = !1);
+      var _ = typeof r == "function" ? r.options : r;
+      f && f.render && (_.render = f.render, _.staticRenderFns = f.staticRenderFns, _._compiled = !0, u && (_.functional = !0)), i && (_._scopeId = i);
+      var O;
+      if (o ? (O = function(R) {
+        R = R || // cached call
+        this.$vnode && this.$vnode.ssrContext || // stateful
+        this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext, !R && typeof __VUE_SSR_CONTEXT__ < "u" && (R = __VUE_SSR_CONTEXT__), t && t.call(this, x(R)), R && R._registeredComponents && R._registeredComponents.add(o);
+      }, _._ssrRegister = O) : t && (O = h ? function() {
+        t.call(this, C(this.$root.$options.shadowRoot));
+      } : function(P) {
+        t.call(this, c(P));
+      }), O)
+        if (_.functional) {
+          var y = _.render;
+          _.render = function(R, j) {
+            return O.call(j), y(R, j);
+          };
+        } else {
+          var E = _.beforeCreate;
+          _.beforeCreate = E ? [].concat(E, O) : [O];
+        }
+      return r;
+    }
+    var A = w, B = b, T = function() {
+      var t = this, r = t.$createElement, i = t._self._c || r;
+      return i("input", { attrs: { type: "file", name: t.$parent.name, id: t.$parent.inputId || t.$parent.name, accept: t.$parent.accept, capture: t.$parent.capture, disabled: t.$parent.disabled, webkitdirectory: t.$parent.directory && t.$parent.features.directory, directory: t.$parent.directory && t.$parent.features.directory, multiple: t.$parent.multiple && t.$parent.features.html5 }, on: { change: t.change } });
+    }, v = [], S = void 0, U = void 0, H = void 0, G = !1, F = A({ render: T, staticRenderFns: v }, S, B, U, G, H, void 0, void 0), I = Object.assign || function(f) {
+      for (var t = 1; t < arguments.length; t++) {
+        var r = arguments[t];
+        for (var i in r)
+          Object.prototype.hasOwnProperty.call(r, i) && (f[i] = r[i]);
+      }
+      return f;
+    }, z = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(f) {
+      return typeof f;
+    } : function(f) {
+      return f && typeof Symbol == "function" && f.constructor === Symbol && f !== Symbol.prototype ? "symbol" : typeof f;
+    };
+    function W(f) {
+      if (Array.isArray(f)) {
+        for (var t = 0, r = Array(f.length); t < f.length; t++)
+          r[t] = f[t];
+        return r;
+      } else
+        return Array.from(f);
+    }
+    var L = {
+      headers: {},
+      action: "",
+      minSize: 1048576,
+      maxActive: 3,
+      maxRetries: 5,
+      handler: g
+    }, D = {
+      components: {
+        InputFile: F
+      },
+      props: {
+        inputId: {
+          type: String
+        },
+        name: {
+          type: String,
+          default: "file"
+        },
+        accept: {
+          type: String
+        },
+        capture: {},
+        disabled: {},
+        multiple: {
+          type: Boolean
+        },
+        maximum: {
+          type: Number,
+          default: function() {
+            return this.multiple ? 0 : 1;
+          }
+        },
+        addIndex: {
+          type: [Boolean, Number]
+        },
+        directory: {
+          type: Boolean
+        },
+        postAction: {
+          type: String
+        },
+        putAction: {
+          type: String
+        },
+        customAction: {
+          type: Function
+        },
+        headers: {
+          type: Object,
+          default: Object
+        },
+        data: {
+          type: Object,
+          default: Object
+        },
+        timeout: {
+          type: Number,
+          default: 0
+        },
+        drop: {
+          default: !1
+        },
+        dropDirectory: {
+          type: Boolean,
+          default: !0
+        },
+        size: {
+          type: Number,
+          default: 0
+        },
+        extensions: {
+          default: Array
+        },
+        value: {
+          type: Array,
+          default: Array
+        },
+        thread: {
+          type: Number,
+          default: 1
+        },
+        // Chunk upload enabled
+        chunkEnabled: {
+          type: Boolean,
+          default: !1
+        },
+        // Chunk upload properties
+        chunk: {
+          type: Object,
+          default: function() {
+            return L;
+          }
+        }
+      },
+      data: function() {
+        return {
+          files: this.value,
+          features: {
+            html5: !0,
+            directory: !1,
+            drop: !1
+          },
+          active: !1,
+          dropActive: !1,
+          uploading: 0,
+          destroy: !1
+        };
+      },
+      /**
+       * mounted
+       * @return {[type]} [description]
+       */
+      mounted: function() {
+        var t = document.createElement("input");
+        if (t.type = "file", t.multiple = !0, window.FormData && t.files ? ((typeof t.webkitdirectory == "boolean" || typeof t.directory == "boolean") && (this.features.directory = !0), this.features.html5 && typeof t.ondrop < "u" && (this.features.drop = !0)) : this.features.html5 = !1, this.maps = {}, this.files)
+          for (var r = 0; r < this.files.length; r++) {
+            var i = this.files[r];
+            this.maps[i.id] = i;
+          }
+        this.$nextTick(function() {
+          var u = this;
+          this.$parent ? (this.$parent.$forceUpdate(), this.$parent.$nextTick(function() {
+            u.watchDrop(u.drop);
+          })) : this.watchDrop(this.drop);
+        });
+      },
+      /**
+       * beforeDestroy
+       * @return {[type]} [description]
+       */
+      beforeDestroy: function() {
+        this.destroy = !0, this.active = !1, this.watchDrop(!1);
+      },
+      computed: {
+        /**
+         * uploading 正在上传的线程
+         * @return {[type]} [description]
+         */
+        /**
+         * uploaded 文件列表是否全部已上传
+         * @return {[type]} [description]
+         */
+        uploaded: function() {
+          for (var t = void 0, r = 0; r < this.files.length; r++)
+            if (t = this.files[r], t.fileObject && !t.error && !t.success)
+              return !1;
+          return !0;
+        },
+        chunkOptions: function() {
+          return Object.assign(L, this.chunk);
+        },
+        className: function() {
+          return ["file-uploads", this.features.html5 ? "file-uploads-html5" : "file-uploads-html4", this.features.directory && this.directory ? "file-uploads-directory" : void 0, this.features.drop && this.drop ? "file-uploads-drop" : void 0, this.disabled ? "file-uploads-disabled" : void 0];
+        }
+      },
+      watch: {
+        active: function(t) {
+          this.watchActive(t);
+        },
+        dropActive: function() {
+          this.$parent && this.$parent.$forceUpdate();
+        },
+        drop: function(t) {
+          this.watchDrop(t);
+        },
+        value: function(t) {
+          if (this.files !== t) {
+            this.files = t;
+            var r = this.maps;
+            this.maps = {};
+            for (var i = 0; i < this.files.length; i++) {
+              var u = this.files[i];
+              this.maps[u.id] = u;
+            }
+            for (var o in this.maps) {
+              var h = this.maps[o], c = r[o];
+              h !== c && this.emitFile(h, c);
+            }
+            for (var x in r)
+              this.maps[x] || this.emitFile(void 0, r[x]);
+          }
+        }
+      },
+      methods: {
+        // 清空
+        clear: function() {
+          if (this.files.length) {
+            var t = this.files;
+            this.files = [], this.maps = {}, this.emitInput();
+            for (var r = 0; r < t.length; r++)
+              this.emitFile(void 0, t[r]);
+          }
+          return !0;
+        },
+        // 选择
+        get: function(t) {
+          return t ? (typeof t > "u" ? "undefined" : z(t)) === "object" ? this.maps[t.id] || !1 : this.maps[t] || !1 : !1;
+        },
+        // 添加
+        add: function(t) {
+          var r = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.addIndex, i = t, u = i instanceof Array;
+          u || (i = [i]);
+          for (var o = [], h = 0; h < i.length; h++) {
+            var c = i[h];
+            this.features.html5 && c instanceof Blob && (c = {
+              file: c,
+              size: c.size,
+              name: c.webkitRelativePath || c.relativePath || c.name || "unknown",
+              type: c.type
+            });
+            var x = !1;
+            if (c.fileObject === !1 || (c.fileObject || typeof Element < "u" && c.el instanceof Element || typeof Blob < "u" && c.file instanceof Blob) && (x = !0), x && (c = I({
+              fileObject: !0,
+              size: -1,
+              name: "Filename",
+              type: "",
+              active: !1,
+              error: "",
+              success: !1,
+              putAction: this.putAction,
+              postAction: this.postAction,
+              timeout: this.timeout
+            }, c, {
+              response: {},
+              progress: "0.00",
+              // 只读
+              speed: 0
+              // 只读
+              // xhr: false,                // 只读
+              // iframe: false,             // 只读
+            }), c.data = I({}, this.data, c.data ? c.data : {}), c.headers = I({}, this.headers, c.headers ? c.headers : {})), c.id || (c.id = Math.random().toString(36).substr(2)), !this.emitFilter(c, void 0) && (this.maximum > 1 && o.length + this.files.length >= this.maximum || (o.push(c), this.maximum === 1)))
+              break;
+          }
+          if (!o.length)
+            return !1;
+          this.maximum === 1 && this.clear();
+          var C = void 0;
+          if (r === !0 || r === 0)
+            C = o.concat(this.files);
+          else if (r) {
+            var _;
+            C = this.files.concat([]), (_ = C).splice.apply(_, [r, 0].concat(o));
+          } else
+            C = this.files.concat(o);
+          this.files = C;
+          for (var O = 0; O < o.length; O++) {
+            var y = o[O];
+            this.maps[y.id] = y;
+          }
+          this.emitInput();
+          for (var E = 0; E < o.length; E++)
+            this.emitFile(o[E], void 0);
+          return u ? o : o[0];
+        },
+        // 添加表单文件
+        addInputFile: function(t) {
+          var r = [];
+          if (t.files)
+            for (var i = 0; i < t.files.length; i++) {
+              var u = t.files[i];
+              r.push({
+                size: u.size,
+                name: u.webkitRelativePath || u.relativePath || u.name,
+                type: u.type,
+                file: u
+              });
+            }
+          else {
+            var o = t.value.replace(/\\/g, "/").split("/");
+            delete t.__vuex__, r.push({
+              name: o[o.length - 1],
+              el: t
+            });
+          }
+          return this.add(r);
+        },
+        // 添加 DataTransfer
+        addDataTransfer: function(t) {
+          var r = this, i = [];
+          if (t.items && t.items.length) {
+            for (var u = [], o = 0; o < t.items.length; o++) {
+              var h = t.items[o];
+              h.getAsEntry ? h = h.getAsEntry() || h.getAsFile() : h.webkitGetAsEntry ? h = h.webkitGetAsEntry() || h.getAsFile() : h = h.getAsFile(), h && u.push(h);
+            }
+            return new Promise(function(x, C) {
+              var _ = function O(y) {
+                var E = u[y];
+                if (!E || r.maximum > 0 && i.length >= r.maximum)
+                  return x(r.add(i));
+                r.getEntry(E).then(function(P) {
+                  i.push.apply(i, W(P)), O(y + 1);
+                });
+              };
+              _(0);
+            });
+          }
+          if (t.files.length) {
+            for (var c = 0; c < t.files.length && (i.push(t.files[c]), !(this.maximum > 0 && i.length >= this.maximum)); c++)
+              ;
+            return Promise.resolve(this.add(i));
+          }
+          return Promise.resolve([]);
+        },
+        // 获得 entry
+        getEntry: function(t) {
+          var r = this, i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+          return new Promise(function(u, o) {
+            if (t.isFile)
+              t.file(function(C) {
+                u([{
+                  size: C.size,
+                  name: i + C.name,
+                  type: C.type,
+                  file: C
+                }]);
+              });
+            else if (t.isDirectory && r.dropDirectory) {
+              var h = [], c = t.createReader(), x = function C() {
+                c.readEntries(function(_) {
+                  var O = function y(E) {
+                    if (!_[E] && E === 0 || r.maximum > 0 && h.length >= r.maximum)
+                      return u(h);
+                    if (!_[E])
+                      return C();
+                    r.getEntry(_[E], i + t.name + "/").then(function(P) {
+                      h.push.apply(h, W(P)), y(E + 1);
+                    });
+                  };
+                  O(0);
+                });
+              };
+              x();
+            } else
+              u([]);
+          });
+        },
+        replace: function(t, r) {
+          var i = this.get(t), u = this.get(r);
+          if (!i || !u || i === u)
+            return !1;
+          var o = this.files.concat([]), h = o.indexOf(i), c = o.indexOf(u);
+          return h === -1 || c === -1 ? !1 : (o[h] = u, o[c] = i, this.files = o, this.emitInput(), !0);
+        },
+        // 移除
+        remove: function(t) {
+          var r = this.get(t);
+          if (r) {
+            if (this.emitFilter(void 0, r))
+              return !1;
+            var i = this.files.concat([]), u = i.indexOf(r);
+            if (u === -1)
+              return console.error("remove", r), !1;
+            i.splice(u, 1), this.files = i, delete this.maps[r.id], this.emitInput(), this.emitFile(void 0, r);
+          }
+          return r;
+        },
+        // 更新
+        update: function(t, r) {
+          var i = this.get(t);
+          if (i) {
+            var u = I({}, i, r);
+            if (i.fileObject && i.active && !u.active && !u.error && !u.success && (u.error = "abort"), this.emitFilter(u, i))
+              return !1;
+            var o = this.files.concat([]), h = o.indexOf(i);
+            return h === -1 ? (console.error("update", i), !1) : (o.splice(h, 1, u), this.files = o, delete this.maps[i.id], this.maps[u.id] = u, this.emitInput(), this.emitFile(u, i), u);
+          }
+          return !1;
+        },
+        // 预处理 事件 过滤器
+        emitFilter: function(t, r) {
+          var i = !1;
+          return this.$emit("input-filter", t, r, function() {
+            return i = !0, i;
+          }), i;
+        },
+        // 处理后 事件 分发
+        emitFile: function(t, r) {
+          this.$emit("input-file", t, r), t && t.fileObject && t.active && (!r || !r.active) ? (this.uploading++, this.$nextTick(function() {
+            var i = this;
+            setTimeout(function() {
+              i.upload(t).then(function() {
+                t = i.get(t), t && t.fileObject && i.update(t, {
+                  active: !1,
+                  success: !t.error
+                });
+              }).catch(function(u) {
+                i.update(t, {
+                  active: !1,
+                  success: !1,
+                  error: u.code || u.error || u.message || u
+                });
+              });
+            }, parseInt(Math.random() * 50 + 50, 10));
+          })) : (!t || !t.fileObject || !t.active) && r && r.fileObject && r.active && this.uploading--, this.active && (!!t != !!r || t.active !== r.active) && this.watchActive(!0);
+        },
+        emitInput: function() {
+          this.$emit("input", this.files);
+        },
+        // 上传
+        upload: function(t) {
+          var r = this.get(t);
+          if (!r)
+            return Promise.reject("not_exists");
+          if (!r.fileObject)
+            return Promise.reject("file_object");
+          if (r.error)
+            return Promise.reject(r.error);
+          if (r.success)
+            return Promise.resolve(r);
+          var i = this.extensions;
+          if (i && (i.length || typeof i.length > "u") && (((typeof i > "u" ? "undefined" : z(i)) !== "object" || !(i instanceof RegExp)) && (typeof i == "string" && (i = i.split(",").map(function(u) {
+            return u.trim();
+          }).filter(function(u) {
+            return u;
+          })), i = new RegExp("\\.(" + i.join("|").replace(/\./g, "\\.") + ")$", "i")), r.name.search(i) === -1))
+            return Promise.reject("extension");
+          if (this.size > 0 && r.size >= 0 && r.size > this.size)
+            return Promise.reject("size");
+          if (this.customAction)
+            return this.customAction(r, this);
+          if (this.features.html5) {
+            if (this.shouldUseChunkUpload(r))
+              return this.uploadChunk(r);
+            if (r.putAction)
+              return this.uploadPut(r);
+            if (r.postAction)
+              return this.uploadHtml5(r);
+          }
+          return r.postAction ? this.uploadHtml4(r) : Promise.reject("No action configured");
+        },
+        /**
+         * Whether this file should be uploaded using chunk upload or not
+         *
+         * @param Object file
+         */
+        shouldUseChunkUpload: function(t) {
+          return this.chunkEnabled && !!this.chunkOptions.handler && t.size > this.chunkOptions.minSize;
+        },
+        /**
+         * Upload a file using Chunk method
+         *
+         * @param File file
+         */
+        uploadChunk: function(t) {
+          var r = this.chunkOptions.handler;
+          return t.chunk = new r(t, this.chunkOptions), t.chunk.upload();
+        },
+        uploadPut: function(t) {
+          var r = [], i = void 0;
+          for (var u in t.data)
+            i = t.data[u], i != null && r.push(encodeURIComponent(u) + "=" + encodeURIComponent(i));
+          var o = r.length ? (t.putAction.indexOf("?") === -1 ? "?" : "&") + r.join("&") : "", h = new XMLHttpRequest();
+          return h.open("PUT", t.putAction + o), this.uploadXhr(h, t, t.file);
+        },
+        uploadHtml5: function(t) {
+          var r = new window.FormData(), i = void 0;
+          for (var u in t.data)
+            i = t.data[u], i && (typeof i > "u" ? "undefined" : z(i)) === "object" && typeof i.toString != "function" ? i instanceof File ? r.append(u, i, i.name) : r.append(u, JSON.stringify(i)) : i != null && r.append(u, i);
+          r.append(this.name, t.file, t.file.filename || t.name);
+          var o = new XMLHttpRequest();
+          return o.open("POST", t.postAction), this.uploadXhr(o, t, r);
+        },
+        uploadXhr: function(t, r, i) {
+          var u = this, o = r, h = 0, c = 0;
+          t.upload.onprogress = function(C) {
+            if (o = u.get(o), !(!C.lengthComputable || !o || !o.fileObject || !o.active)) {
+              var _ = Math.round(Date.now() / 1e3);
+              _ !== h && (h = _, o = u.update(o, {
+                progress: (C.loaded / C.total * 100).toFixed(2),
+                speed: C.loaded - c
+              }), c = C.loaded);
+            }
+          };
+          var x = setInterval(function() {
+            if (o = u.get(o), !(o && o.fileObject && !o.success && !o.error && o.active)) {
+              x && (clearInterval(x), x = !1);
+              try {
+                t.abort(), t.timeout = 1;
+              } catch {
+              }
+            }
+          }, 100);
+          return new Promise(function(C, _) {
+            var O = void 0, y = function(R) {
+              if (!O) {
+                if (O = !0, x && (clearInterval(x), x = !1), o = u.get(o), !o)
+                  return _("not_exists");
+                if (!o.fileObject)
+                  return _("file_object");
+                if (o.error)
+                  return _(o.error);
+                if (!o.active)
+                  return _("abort");
+                if (o.success)
+                  return C(o);
+                var j = {};
+                switch (R.type) {
+                  case "timeout":
+                  case "abort":
+                    j.error = R.type;
+                    break;
+                  case "error":
+                    t.status ? t.status >= 500 ? j.error = "server" : t.status >= 400 && (j.error = "denied") : j.error = "network";
+                    break;
+                  default:
+                    t.status >= 500 ? j.error = "server" : t.status >= 400 ? j.error = "denied" : j.progress = "100.00";
+                }
+                if (t.responseText) {
+                  var ue = t.getResponseHeader("Content-Type");
+                  ue && ue.indexOf("/json") !== -1 ? j.response = JSON.parse(t.responseText) : j.response = t.responseText;
+                }
+                return o = u.update(o, j), o.error ? _(o.error) : C(o);
+              }
+            };
+            t.onload = y, t.onerror = y, t.onabort = y, t.ontimeout = y, o.timeout && (t.timeout = o.timeout);
+            for (var E in o.headers)
+              t.setRequestHeader(E, o.headers[E]);
+            o = u.update(o, { xhr: t }), t.send(i);
+          });
+        },
+        uploadHtml4: function(t) {
+          var r = this, i = t, u = function(y) {
+            y.keyCode === 27 && y.preventDefault();
+          }, o = document.createElement("iframe");
+          o.id = "upload-iframe-" + i.id, o.name = "upload-iframe-" + i.id, o.src = "about:blank", o.setAttribute("style", "width:1px;height:1px;top:-999em;position:absolute; margin-top:-999em;");
+          var h = document.createElement("form");
+          h.action = i.postAction, h.name = "upload-form-" + i.id, h.setAttribute("method", "POST"), h.setAttribute("target", "upload-iframe-" + i.id), h.setAttribute("enctype", "multipart/form-data");
+          var c = void 0, x = void 0;
+          for (var C in i.data)
+            c = i.data[C], c && (typeof c > "u" ? "undefined" : z(c)) === "object" && typeof c.toString != "function" && (c = JSON.stringify(c)), c != null && (x = document.createElement("input"), x.type = "hidden", x.name = C, x.value = c, h.appendChild(x));
+          h.appendChild(i.el), document.body.appendChild(o).appendChild(h);
+          var _ = function() {
+            var y = void 0;
+            try {
+              o.contentWindow && (y = o.contentWindow.document);
+            } catch {
+            }
+            if (!y)
+              try {
+                y = o.contentDocument ? o.contentDocument : o.document;
+              } catch {
+                y = o.document;
+              }
+            return y && y.body ? y.body.innerHTML : null;
+          };
+          return new Promise(function(O, y) {
+            setTimeout(function() {
+              if (i = r.update(i, { iframe: o }), !i)
+                return y("not_exists");
+              var E = setInterval(function() {
+                i = r.get(i), !(i && i.fileObject && !i.success && !i.error && i.active) && (E && (clearInterval(E), E = !1), o.onabort({ type: i ? "abort" : "not_exists" }));
+              }, 100), P = void 0, R = function(ue) {
+                if (!P) {
+                  if (P = !0, E && (clearInterval(E), E = !1), document.body.removeEventListener("keydown", u), i = r.get(i), !i)
+                    return y("not_exists");
+                  if (!i.fileObject)
+                    return y("file_object");
+                  if (i.error)
+                    return y(i.error);
+                  if (!i.active)
+                    return y("abort");
+                  if (i.success)
+                    return O(i);
+                  var M = _(), N = {};
+                  switch (ue.type) {
+                    case "abort":
+                      N.error = "abort";
+                      break;
+                    case "error":
+                      i.error ? N.error = i.error : M === null ? N.error = "network" : N.error = "denied";
+                      break;
+                    default:
+                      i.error ? N.error = i.error : N === null ? N.error = "network" : N.progress = "100.00";
+                  }
+                  if (M !== null) {
+                    if (M && M.substr(0, 1) === "{" && M.substr(M.length - 1, 1) === "}")
+                      try {
+                        M = JSON.parse(M);
+                      } catch {
+                      }
+                    N.response = M;
+                  }
+                  return i = r.update(i, N), i.error ? y(i.error) : O(i);
+                }
+              };
+              o.onload = R, o.onerror = R, o.onabort = R, document.body.addEventListener("keydown", u), h.submit();
+            }, 50);
+          }).then(function(O) {
+            return o.parentNode && o.parentNode.removeChild(o), O;
+          }).catch(function(O) {
+            return o.parentNode && o.parentNode.removeChild(o), O;
+          });
+        },
+        watchActive: function(t) {
+          for (var r = void 0, i = 0; r = this.files[i]; )
+            if (i++, r.fileObject)
+              if (t && !this.destroy) {
+                if (this.uploading >= this.thread || this.uploading && !this.features.html5)
+                  break;
+                !r.active && !r.error && !r.success && this.update(r, { active: !0 });
+              } else
+                r.active && this.update(r, { active: !1 });
+          this.uploading === 0 && (this.active = !1);
+        },
+        watchDrop: function(t) {
+          var r = t;
+          if (this.features.drop) {
+            if (this.dropElement)
+              try {
+                document.removeEventListener("dragenter", this.onDragenter, !1), document.removeEventListener("dragleave", this.onDragleave, !1), document.removeEventListener("drop", this.onDocumentDrop, !1), this.dropElement.removeEventListener("dragover", this.onDragover, !1), this.dropElement.removeEventListener("drop", this.onDrop, !1);
+              } catch {
+              }
+            r ? typeof r == "string" ? r = document.querySelector(r) || this.$root.$el.querySelector(r) : r === !0 && (r = this.$parent.$el) : r = !1, this.dropElement = r, this.dropElement && (document.addEventListener("dragenter", this.onDragenter, !1), document.addEventListener("dragleave", this.onDragleave, !1), document.addEventListener("drop", this.onDocumentDrop, !1), this.dropElement.addEventListener("dragover", this.onDragover, !1), this.dropElement.addEventListener("drop", this.onDrop, !1));
+          }
+        },
+        onDragenter: function(t) {
+          if (t.preventDefault(), !this.dropActive && t.dataTransfer) {
+            var r = t.dataTransfer;
+            r.files && r.files.length ? this.dropActive = !0 : r.types ? r.types.indexOf && r.types.indexOf("Files") !== -1 ? this.dropActive = !0 : r.types.contains && r.types.contains("Files") && (this.dropActive = !0) : this.dropActive = !0;
+          }
+        },
+        onDragleave: function(t) {
+          t.preventDefault(), this.dropActive && (t.target.nodeName === "HTML" || t.target === t.explicitOriginalTarget || !t.fromElement && (t.clientX <= 0 || t.clientY <= 0 || t.clientX >= window.innerWidth || t.clientY >= window.innerHeight)) && (this.dropActive = !1);
+        },
+        onDragover: function(t) {
+          t.preventDefault();
+        },
+        onDocumentDrop: function() {
+          this.dropActive = !1;
+        },
+        onDrop: function(t) {
+          t.preventDefault(), this.addDataTransfer(t.dataTransfer);
+        }
+      }
+    }, $ = typeof navigator < "u" && /msie [6-9]\\b/.test(navigator.userAgent.toLowerCase());
+    function Q(f) {
+      return function(t, r) {
+        return ee(t, r);
+      };
+    }
+    var Z = document.head || document.getElementsByTagName("head")[0], K = {};
+    function ee(f, t) {
+      var r = $ ? t.media || "default" : f, i = K[r] || (K[r] = {
+        ids: /* @__PURE__ */ new Set(),
+        styles: []
+      });
+      if (!i.ids.has(f)) {
+        i.ids.add(f);
+        var u = t.source;
+        if (t.map && (u += `
+/*# sourceURL=` + t.map.sources[0] + " */", u += `
+/*# sourceMappingURL=data:application/json;base64,` + btoa(unescape(encodeURIComponent(JSON.stringify(t.map)))) + " */"), i.element || (i.element = document.createElement("style"), i.element.type = "text/css", t.media && i.element.setAttribute("media", t.media), Z.appendChild(i.element)), "styleSheet" in i.element)
+          i.styles.push(u), i.element.styleSheet.cssText = i.styles.filter(Boolean).join(`
+`);
+        else {
+          var o = i.ids.size - 1, h = document.createTextNode(u), c = i.element.childNodes;
+          c[o] && i.element.removeChild(c[o]), c.length ? i.element.insertBefore(h, c[o]) : i.element.appendChild(h);
+        }
+      }
+    }
+    var te = Q, re = D, ie = function() {
+      var t = this, r = t.$createElement, i = t._self._c || r;
+      return i("span", { class: t.className }, [t._t("default"), t._v(" "), i("label", { attrs: { for: t.inputId || t.name } }), t._v(" "), i("input-file")], 2);
+    }, ne = [], ae = function(t) {
+      t && t("data-v-76d380b6_0", { source: ".file-uploads{overflow:hidden;position:relative;text-align:center;display:inline-block}.file-uploads.file-uploads-html4 input,.file-uploads.file-uploads-html5 label{background:#fff;opacity:0;font-size:20em;z-index:1;top:0;left:0;right:0;bottom:0;position:absolute;width:100%;height:100%}.file-uploads.file-uploads-html4 label,.file-uploads.file-uploads-html5 input{background:rgba(255,255,255,0);overflow:hidden;position:fixed;width:1px;height:1px;z-index:-1;opacity:0}", map: void 0, media: void 0 });
+    }, ce = void 0, pe = void 0, he = !1, me = A({ render: ie, staticRenderFns: ne }, ae, re, ce, he, pe, te, void 0), J = /* @__PURE__ */ Object.freeze({
+      default: me
+    });
+    function se(f) {
+      return f && f.default || f;
+    }
+    var oe = se(J), Y = oe;
+    return Y;
+  });
+})(we);
+var Ye = we.exports;
+const Ve = /* @__PURE__ */ De(Ye), Qe = {
+  i18nOptions: {
+    namespaces: "baseUpload",
+    messages: {
+      en: {
+        dropActive: "Drag & drop files to upload",
+        errors: {
+          thumbnail: "Could not create thumbnail",
+          compress: "Could not upload photo",
+          general: "File could not be uploaded",
+          extension: "Unsupported file format. Supported types are: {{extensions}}",
+          size: "File is too large. Max file size is {{maxFileSize}}",
+          ECONNREFUSED: "File could not be uploaded, no internet connection"
+        }
+      },
+      sv: {
+        dropActive: "Släpp filer för att ladda upp",
+        errors: {
+          thumbnail: "Kunde inte skapa tumnagel",
+          compress: "Kunde inte ladda upp bild",
+          general: "Kunde inte ladda upp fil",
+          extension: "Ogiltigt format. Tillåtna format: {{extensions}}",
+          size: "För stor fil. Max filstorlek är {{maxFileSize}}",
+          ECONNREFUSED: "Kunde inte ladda upp fil, ingen internetanslutning"
+        }
+      }
+    }
+  },
+  name: "BaseUpload",
+  components: {
+    FileUpload: Ve,
+    UploadModal: () => import("./UploadModal-9O4HTVZm.js")
+  },
+  props: {
+    // Optional function to handle any errors
+    // If not supplied a default errorHandler is used
+    onError: {
+      type: Function,
+      default: void 0
+    },
+    autostartUpload: {
+      type: Boolean,
+      default: !1
+    },
+    multiple: {
+      type: Boolean,
+      default: !0
+    },
+    // max file size in bytes
+    maxSize: {
+      type: Number,
+      default: 1e3 * 1e3 * 10
+      // 10 MB
+    },
+    // Compression (0 - 1)
+    // Only for image/jpeg and image/webp
+    quality: {
+      type: Number,
+      default: 0.8
+      // Be careful to use 1 as it may make the size of the output image become larger
+    },
+    // Resize
+    maxHeight: {
+      type: Number,
+      default: 1 / 0
+    },
+    maxWidth: {
+      type: Number,
+      default: 1 / 0
+    },
+    // Thumbnail props
+    createThumbnails: {
+      type: Boolean,
+      default: !1
+    },
+    thumbnailMaxWidth: {
+      type: Number,
+      default: 120
+    },
+    thumbnailMaxHeight: {
+      type: Number,
+      default: 120
+    },
+    drop: {
+      type: Boolean,
+      default: !1
+    },
+    maximum: {
+      type: Number,
+      default: null
+    },
+    extensions: {
+      type: String,
+      default: "gif,jpg,jpeg,png,webp,heic,heif"
+    },
+    accept: {
+      type: String,
+      default: "image/png,image/gif,image/jpeg,image/webp,image/heic,image/heif,image/tiff"
+    },
+    recentModal: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  data() {
+    return {
+      files: [],
+      modalOpen: !1
+    };
+  },
+  mounted() {
+    this.$emit("has-mounted", !0);
+  },
+  methods: {
+    open() {
+      this.recentModal ? this.modalOpen = !0 : this.openFilePicker();
+    },
+    openFilePicker() {
+      this.$refs.upload && this.$refs.upload.$el.querySelector("input[type='file']").click();
+    },
+    closeRecentModal() {
+      this.$modal.hide("recent-modal");
+    },
+    async postAction(s) {
+      const n = new FormData();
+      n.append("file", s.file, s.file.name);
+      const { data: a } = await ye.post("/file", n, {
+        onUploadProgress: (d) => {
+          const p = this.files.filter(
+            (m) => m.id === s.id
+          );
+          if (p.length) {
+            const m = p[0], k = m, g = Math.round(
+              d.loaded * 100 / d.total
+            );
+            k.progress = g, this.$refs.upload.update(m, k);
+          }
+        },
+        timeout: 6e4
+      }), l = s;
+      return l.response = a, this.$refs.upload.update(s, l), a;
+    },
+    // Pre-treatment when files are added
+    inputFilter(s, n) {
+      if (s && (!n || s.file !== n.file)) {
+        s.url = "";
+        const a = window.URL || window.webkitURL;
+        a && a.createObjectURL && (s.url = a.createObjectURL(s.file));
+      }
+    },
+    // Method to start uploading
+    startUpload() {
+      this.$refs.upload.active = !0;
+    },
+    // Clear any uploads
+    undoFileUpload() {
+      this.$refs.upload.clear();
+    },
+    remove(s) {
+      this.$refs.upload.remove(s);
+    },
+    // When a file is changed
+    inputFile(s, n) {
+      if (this.modalOpen && (this.modalOpen = !1), this.createThumbnails && s && !s.thumbnailId && s.file && s.type.substr(0, 6) === "image/" && !["image/heic", "image/heif"].includes(s.type) && !n)
+        return s.error = "thumbnail", new Promise(async (a, l) => {
+          try {
+            const { id: d } = await this.generateThumbnail(
+              s.file
+            ), p = s;
+            return p.thumbnailId = d, p.error = "", this.$refs.upload.update(s, p), a();
+          } catch (d) {
+            return l(d);
+          }
+        }).catch((a) => {
+          this.$refs.upload.update(s, {
+            error: a.code || a.error || a.message || a
+          });
+        });
+      if (s && s.file && s.type.substr(0, 6) === "image/" && !["image/heic", "image/heif"].includes(s.type) && !s.hasCompressed)
+        return s.error = "compressor", new Promise(async (a, l) => {
+          try {
+            const d = await this.compressFile(s.file);
+            return this.$refs.upload.update(s, { ...d, error: "" }), a();
+          } catch (d) {
+            return l(d);
+          }
+        }).catch((a) => {
+          this.$refs.upload.update(s, {
+            error: a.code || a.error || a.message || a
+          });
+        });
+      if (s && !s.active && !s.success && !s.error && this.autostartUpload && (s.active = !0), s && s.success && !n.success && this.$emit("upload-success", s), s && s.error && s.error !== "thumbnail" && s.error !== "compressor" && (!n || !n.error)) {
+        if (this.onError)
+          this.onError(s);
+        else {
+          let a = null;
+          switch (s.error) {
+            case "extension": {
+              const l = this.extensions.replace(/,/g, ", ");
+              a = this.$t("errors.extension", {
+                extensions: l
+              });
+              break;
+            }
+            case "size": {
+              a = this.$t("errors.size", {
+                maxFileSize: `${this.maxSize / 1e6} MB`
+              });
+              break;
+            }
+            case "ECONNREFUSED": {
+              a = this.$t("errors.ECONNREFUSED");
+              break;
+            }
+            default:
+              a = `${this.$t("errors.general")}: ${s.error}`;
+          }
+          ve("error", a);
+        }
+        this.remove(s);
+      }
+      return !0;
+    },
+    async generateThumbnail(s) {
+      try {
+        return new Promise((n, a) => {
+          new Oe(s, {
+            quality: this.quality,
+            maxWidth: this.thumbnailMaxWidth,
+            maxHeight: this.thumbnailMaxHeight,
+            success: (l) => {
+              const d = new FormData(), p = this.appendToFilename(
+                l.name,
+                "_thumbnail"
+              );
+              return d.append("file", l, p), ye.post("/file", d).then((m) => n(m.data)).catch((m) => a(m));
+            },
+            error: (l) => a(l)
+          });
+        });
+      } catch (n) {
+        return ve("error", this.$t("errors.thumbnail")), Promise.reject(n);
+      }
+    },
+    /**
+     * Helper to compress file
+     *
+     * @param {Object} originalFile
+     *
+     * @returns {Promise} Resolves with a new fileObj when done
+     */
+    async compressFile(s) {
+      let n;
+      try {
+        return new Promise((a, l) => {
+          n = new Oe(s, {
+            quality: this.quality,
+            maxWidth: this.maxWidth,
+            maxHeight: this.maxHeight,
+            success: (d) => {
+              const p = {
+                file: d,
+                size: d.size,
+                type: d.type,
+                hasCompressed: !0
+              };
+              return a(p);
+            },
+            error: (d) => l(d)
+          });
+        });
+      } catch (a) {
+        return ve("error", this.$t("errors.compress")), this.$refs.upload.update(s, { error: e.message }), Promise.reject(a);
+      } finally {
+        n = null;
+      }
+    },
+    appendToFilename(s, n) {
+      const a = s.lastIndexOf(".");
+      return a === -1 ? s + n : s.substring(0, a) + n + s.substring(a);
+    }
+  }
+};
+var Ze = function() {
+  var l, d, p;
+  var n = this, a = n._self._c;
+  return a("FileUpload", { ref: "upload", staticClass: "btn btn-primary white-list", attrs: { maximum: n.maximum, "custom-action": n.postAction, extensions: n.extensions, multiple: n.multiple, drop: n.drop || n.modalOpen, size: n.maxSize, thread: 1, accept: n.accept }, on: { input: function(m) {
+    return n.$emit("input", n.files);
+  }, "input-filter": n.inputFilter, "input-file": n.inputFile }, model: { value: n.files, callback: function(m) {
+    n.files = m;
+  }, expression: "files" } }, [n._t("default", null, { openFilePicker: n.open }), n.drop || n.modalOpen ? a("div", { directives: [{ name: "show", rawName: "v-show", value: (d = (l = n.$refs) == null ? void 0 : l.upload) == null ? void 0 : d.dropActive, expression: "$refs?.upload?.dropActive" }], staticClass: "drop-active font-inter white-list", class: { transparent: n.modalOpen } }, [a("CIcon", { attrs: { type: "upload-cloud", size: "60" } }), n._v(" " + n._s(n.$t("dropActive")) + " ")], 1) : n._e(), n.modalOpen ? a("portal", { attrs: { to: "modal" } }, [a("div", { staticClass: "modal-overlay", on: { click: function(m) {
+    if (m.target !== m.currentTarget)
+      return null;
+    n.modalOpen = !1;
+  } } }, [a("div", { staticClass: "modal-container" }, [a("UploadModal", { on: { "open-picker": n.openFilePicker, select: function(m) {
+    n.$emit("upload-success", { response: m }), n.modalOpen = !1;
+  } } })], 1)]), (p = n.$refs.upload) != null && p.dropActive ? a("div", { staticClass: "drop-active font-inter", staticStyle: { "pointer-events": "none" } }, [a("style", { tag: "component", attrs: { type: "text/css" } }, [n._v(" * { pointer-events: none !important; } .white-list { pointer-events: initial !important; } ")]), a("CIcon", { attrs: { type: "upload-cloud", size: "60" } }), n._v(" " + n._s(n.$t("dropActive")) + " ")], 1) : n._e()]) : n._e()], 2);
+}, et = [], tt = /* @__PURE__ */ $e(
+  Qe,
+  Ze,
+  et,
+  !1,
+  null,
+  "7d0db589"
+);
+const nt = tt.exports;
+export {
+  nt as default
+};