@cling-se/widget 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/BaseUpload-BiJBcWRu.js

@@ -0,0 +1,2472 @@
+import { be as Ie, bf as je, aC as Me, bg as ze, bh as Ne, bi as Le, bj as $e, F as He, bk as _e, bl as We, aE as Ve, bm as qe, bn as Fe, aD as Xe, bo as Ke, aj as Ge, bp as Je, bq as Ye, br as Qe, bs as Ze, bt as et, bu as tt, bv as rt, bw as nt, bx as it, by as at, i as st, bz as ot, c as ae, f as se, d as pe, s as he, bA as ut, bB as lt, bC as ct, bD as ft, bE as dt, bF as pt, B as oe, e as ue, bG as ht, z as De, h as mt, bH as vt, bI as gt, bJ as yt, bK as bt, bL as Et, bM as wt, bN as kt, bO as Ot, bP as Dt, bQ as St, bR as Ct, H as xt, bS as At, bT as Tt, bU as Pt, bV as Rt, ai as Ut, bW as Bt, bX as It, bY as jt, bZ as Mt, b_ as zt, b$ as Nt, c0 as Lt, c1 as $t, c2 as Ht, P as _t, c3 as Wt, c4 as Vt, N as qt, O as Ft, L as Xt, c5 as Kt, c6 as Gt, at as Jt, c7 as Yt, c8 as Qt, c9 as Zt, Z as er, Q as tr, n as Se, ca as rr, l as nr, cb as ir, J as ar, M as sr, cc as or, cd as ur, ce as lr, a0 as cr, cf as fr, cg as dr, ch as pr, ci as hr, cj as mr, ck as vr, cl as gr, o as G, cm as yr, x as br, cn as Er, co as wr, cp as kr, r as Or, cq as Dr, I as Sr, cr as Cr, cs as xr, k as Ar, S as Ce, b as Q, a3 as Tr, aq as xe, ct as Pr, cu as Rr, cv as Ur, cw as Br, cx as Ir, cy as jr, cz as Mr, bd as zr, cA as Nr, cB as Lr, cC as $r, v as me, cD as Hr, cE as _r, cF as Wr, cG as Vr, t as qr, cH as Fr, cI as Xr, cJ as Kr, j as Gr, u as Jr, cK as Yr, cL as Qr, cM as Zr, cN as en, cO as tn, cP as rn, cQ as nn, cR as an, $ as sn, cS as on, bc as un, cT as ln, b6 as cn, am as fn, cU as dn, G as Ae, cV as pn, cW as hn, K as mn, cX as vn, cY as gn, cZ as yn, c_ as bn, w as le, c$ as En, E as Te, af as wn, d0 as kn, ao as Pe, d1 as On, d2 as Dn, d3 as Sn, a1 as Cn, _ as xn, d4 as ge, aA as de } from "./main-Cb-nyil1.js";
+/**
+* vue v3.5.12
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+const An = () => {
+}, Tn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BaseTransition: Ie,
+  BaseTransitionPropsValidators: je,
+  Comment: Me,
+  DeprecationTypes: ze,
+  EffectScope: Ne,
+  ErrorCodes: Le,
+  ErrorTypeStrings: $e,
+  Fragment: He,
+  KeepAlive: _e,
+  ReactiveEffect: We,
+  Static: Ve,
+  Suspense: qe,
+  Teleport: Fe,
+  Text: Xe,
+  TrackOpTypes: Ke,
+  Transition: Ge,
+  TransitionGroup: Je,
+  TriggerOpTypes: Ye,
+  VueElement: Qe,
+  assertNumber: Ze,
+  callWithAsyncErrorHandling: et,
+  callWithErrorHandling: tt,
+  camelize: rt,
+  capitalize: nt,
+  cloneVNode: it,
+  compatUtils: at,
+  compile: An,
+  computed: st,
+  createApp: ot,
+  createBlock: ae,
+  createCommentVNode: se,
+  createElementBlock: pe,
+  createElementVNode: he,
+  createHydrationRenderer: ut,
+  createPropsRestProxy: lt,
+  createRenderer: ct,
+  createSSRApp: ft,
+  createSlots: dt,
+  createStaticVNode: pt,
+  createTextVNode: oe,
+  createVNode: ue,
+  customRef: ht,
+  defineAsyncComponent: De,
+  defineComponent: mt,
+  defineCustomElement: vt,
+  defineEmits: gt,
+  defineExpose: yt,
+  defineModel: bt,
+  defineOptions: Et,
+  defineProps: wt,
+  defineSSRCustomElement: kt,
+  defineSlots: Ot,
+  devtools: Dt,
+  effect: St,
+  effectScope: Ct,
+  getCurrentInstance: xt,
+  getCurrentScope: At,
+  getCurrentWatcher: Tt,
+  getTransitionRawChildren: Pt,
+  guardReactiveProps: Rt,
+  h: Ut,
+  handleError: Bt,
+  hasInjectionContext: It,
+  hydrate: jt,
+  hydrateOnIdle: Mt,
+  hydrateOnInteraction: zt,
+  hydrateOnMediaQuery: Nt,
+  hydrateOnVisible: Lt,
+  initCustomFormatter: $t,
+  initDirectivesForSSR: Ht,
+  inject: _t,
+  isMemoSame: Wt,
+  isProxy: Vt,
+  isReactive: qt,
+  isReadonly: Ft,
+  isRef: Xt,
+  isRuntimeOnly: Kt,
+  isShallow: Gt,
+  isVNode: Jt,
+  markRaw: Yt,
+  mergeDefaults: Qt,
+  mergeModels: Zt,
+  mergeProps: er,
+  nextTick: tr,
+  normalizeClass: Se,
+  normalizeProps: rr,
+  normalizeStyle: nr,
+  onActivated: ir,
+  onBeforeMount: ar,
+  onBeforeUnmount: sr,
+  onBeforeUpdate: or,
+  onDeactivated: ur,
+  onErrorCaptured: lr,
+  onMounted: cr,
+  onRenderTracked: fr,
+  onRenderTriggered: dr,
+  onScopeDispose: pr,
+  onServerPrefetch: hr,
+  onUnmounted: mr,
+  onUpdated: vr,
+  onWatcherCleanup: gr,
+  openBlock: G,
+  popScopeId: yr,
+  provide: br,
+  proxyRefs: Er,
+  pushScopeId: wr,
+  queuePostFlushCb: kr,
+  reactive: Or,
+  readonly: Dr,
+  ref: Sr,
+  registerRuntimeCompiler: Cr,
+  render: xr,
+  renderList: Ar,
+  renderSlot: Ce,
+  resolveComponent: Q,
+  resolveDirective: Tr,
+  resolveDynamicComponent: xe,
+  resolveFilter: Pr,
+  resolveTransitionHooks: Rr,
+  setBlockTracking: Ur,
+  setDevtoolsHook: Br,
+  setTransitionHooks: Ir,
+  shallowReactive: jr,
+  shallowReadonly: Mr,
+  shallowRef: zr,
+  ssrContextKey: Nr,
+  ssrUtils: Lr,
+  stop: $r,
+  toDisplayString: me,
+  toHandlerKey: Hr,
+  toHandlers: _r,
+  toRaw: Wr,
+  toRef: Vr,
+  toRefs: qr,
+  toValue: Fr,
+  transformVNodeArgs: Xr,
+  triggerRef: Kr,
+  unref: Gr,
+  useAttrs: Jr,
+  useCssModule: Yr,
+  useCssVars: Qr,
+  useHost: Zr,
+  useId: en,
+  useModel: tn,
+  useSSRContext: rn,
+  useShadowRoot: nn,
+  useSlots: an,
+  useTemplateRef: sn,
+  useTransitionState: on,
+  vModelCheckbox: un,
+  vModelDynamic: ln,
+  vModelRadio: cn,
+  vModelSelect: fn,
+  vModelText: dn,
+  vShow: Ae,
+  version: pn,
+  warn: hn,
+  watch: mn,
+  watchEffect: vn,
+  watchPostEffect: gn,
+  watchSyncEffect: yn,
+  withAsyncContext: bn,
+  withCtx: le,
+  withDefaults: En,
+  withDirectives: Te,
+  withKeys: wn,
+  withMemo: kn,
+  withModifiers: Pe,
+  withScopeId: On
+}, Symbol.toStringTag, { value: "Module" }));
+/*!
+ * 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 ye(u, l) {
+  var s = Object.keys(u);
+  if (Object.getOwnPropertySymbols) {
+    var c = Object.getOwnPropertySymbols(u);
+    l && (c = c.filter(function(d) {
+      return Object.getOwnPropertyDescriptor(u, d).enumerable;
+    })), s.push.apply(s, c);
+  }
+  return s;
+}
+function ie(u) {
+  for (var l = 1; l < arguments.length; l++) {
+    var s = arguments[l] != null ? arguments[l] : {};
+    l % 2 ? ye(Object(s), !0).forEach(function(c) {
+      Un(u, c, s[c]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(u, Object.getOwnPropertyDescriptors(s)) : ye(Object(s)).forEach(function(c) {
+      Object.defineProperty(u, c, Object.getOwnPropertyDescriptor(s, c));
+    });
+  }
+  return u;
+}
+function Pn(u, l) {
+  if (!(u instanceof l))
+    throw new TypeError("Cannot call a class as a function");
+}
+function be(u, l) {
+  for (var s = 0; s < l.length; s++) {
+    var c = l[s];
+    c.enumerable = c.enumerable || !1, c.configurable = !0, "value" in c && (c.writable = !0), Object.defineProperty(u, c.key, c);
+  }
+}
+function Rn(u, l, s) {
+  return l && be(u.prototype, l), s && be(u, s), u;
+}
+function Un(u, l, s) {
+  return l in u ? Object.defineProperty(u, l, {
+    value: s,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : u[l] = s, u;
+}
+function ce() {
+  return ce = Object.assign || function(u) {
+    for (var l = 1; l < arguments.length; l++) {
+      var s = arguments[l];
+      for (var c in s)
+        Object.prototype.hasOwnProperty.call(s, c) && (u[c] = s[c]);
+    }
+    return u;
+  }, ce.apply(this, arguments);
+}
+var Re = { exports: {} };
+(function(u) {
+  typeof window > "u" || function(l) {
+    var s = l.HTMLCanvasElement && l.HTMLCanvasElement.prototype, c = l.Blob && function() {
+      try {
+        return !!new Blob();
+      } catch {
+        return !1;
+      }
+    }(), d = c && l.Uint8Array && function() {
+      try {
+        return new Blob([new Uint8Array(100)]).size === 100;
+      } catch {
+        return !1;
+      }
+    }(), p = l.BlobBuilder || l.WebKitBlobBuilder || l.MozBlobBuilder || l.MSBlobBuilder, b = /^data:((.*?)(;charset=.*?)?)(;base64)?,/, O = (c || p) && l.atob && l.ArrayBuffer && l.Uint8Array && function(v) {
+      var k, E, C, A, B, h, I, T, $;
+      if (k = v.match(b), !k)
+        throw new Error("invalid data URI");
+      for (E = k[2] ? k[1] : "text/plain" + (k[3] || ";charset=US-ASCII"), C = !!k[4], A = v.slice(k[0].length), C ? B = atob(A) : B = decodeURIComponent(A), h = new ArrayBuffer(B.length), I = new Uint8Array(h), T = 0; T < B.length; T += 1)
+        I[T] = B.charCodeAt(T);
+      return c ? new Blob([d ? I : h], {
+        type: E
+      }) : ($ = new p(), $.append(h), $.getBlob(E));
+    };
+    l.HTMLCanvasElement && !s.toBlob && (s.mozGetAsFile ? s.toBlob = function(v, k, E) {
+      var C = this;
+      setTimeout(function() {
+        E && s.toDataURL && O ? v(O(C.toDataURL(k, E))) : v(C.mozGetAsFile("blob", k));
+      });
+    } : s.toDataURL && O && (s.msToBlob ? s.toBlob = function(v, k, E) {
+      var C = this;
+      setTimeout(function() {
+        (k && k !== "image/png" || E) && s.toDataURL && O ? v(O(C.toDataURL(k, E))) : v(C.msToBlob(k));
+      });
+    } : s.toBlob = function(v, k, E) {
+      var C = this;
+      setTimeout(function() {
+        v(O(C.toDataURL(k, E)));
+      });
+    })), u.exports ? u.exports = O : l.dataURLtoBlob = O;
+  }(window);
+})(Re);
+var Bn = Re.exports, In = function(l) {
+  return typeof Blob > "u" ? !1 : l instanceof Blob || Object.prototype.toString.call(l) === "[object Blob]";
+}, Ee = {
+  /**
+   * 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
+}, jn = typeof window < "u" && typeof window.document < "u", V = jn ? window : {}, fe = function(l) {
+  return l > 0 && l < 1 / 0;
+}, Mn = Array.prototype.slice;
+function zn(u) {
+  return Array.from ? Array.from(u) : Mn.call(u);
+}
+var Nn = /^image\/.+$/;
+function ve(u) {
+  return Nn.test(u);
+}
+function Ln(u) {
+  var l = ve(u) ? u.substr(6) : "";
+  return l === "jpeg" && (l = "jpg"), ".".concat(l);
+}
+var Ue = String.fromCharCode;
+function $n(u, l, s) {
+  var c = "", d;
+  for (s += l, d = l; d < s; d += 1)
+    c += Ue(u.getUint8(d));
+  return c;
+}
+var Hn = V.btoa;
+function _n(u, l) {
+  for (var s = [], c = 8192, d = new Uint8Array(u); d.length > 0; )
+    s.push(Ue.apply(null, zn(d.subarray(0, c)))), d = d.subarray(c);
+  return "data:".concat(l, ";base64,").concat(Hn(s.join("")));
+}
+function Wn(u) {
+  var l = new DataView(u), s;
+  try {
+    var c, d, p;
+    if (l.getUint8(0) === 255 && l.getUint8(1) === 216)
+      for (var b = l.byteLength, O = 2; O + 1 < b; ) {
+        if (l.getUint8(O) === 255 && l.getUint8(O + 1) === 225) {
+          d = O;
+          break;
+        }
+        O += 1;
+      }
+    if (d) {
+      var v = d + 4, k = d + 10;
+      if ($n(l, v, 4) === "Exif") {
+        var E = l.getUint16(k);
+        if (c = E === 18761, (c || E === 19789) && l.getUint16(k + 2, c) === 42) {
+          var C = l.getUint32(k + 4, c);
+          C >= 8 && (p = k + C);
+        }
+      }
+    }
+    if (p) {
+      var A = l.getUint16(p, c), B, h;
+      for (h = 0; h < A; h += 1)
+        if (B = p + h * 12 + 2, l.getUint16(B, c) === 274) {
+          B += 8, s = l.getUint16(B, c), l.setUint16(B, 1, c);
+          break;
+        }
+    }
+  } catch {
+    s = 1;
+  }
+  return s;
+}
+function Vn(u) {
+  var l = 0, s = 1, c = 1;
+  switch (u) {
+    case 2:
+      s = -1;
+      break;
+    case 3:
+      l = -180;
+      break;
+    case 4:
+      c = -1;
+      break;
+    case 5:
+      l = 90, c = -1;
+      break;
+    case 6:
+      l = 90;
+      break;
+    case 7:
+      l = 90, s = -1;
+      break;
+    case 8:
+      l = -90;
+      break;
+  }
+  return {
+    rotate: l,
+    scaleX: s,
+    scaleY: c
+  };
+}
+var qn = /\.\d*(?:0|9){12}\d*$/;
+function we(u) {
+  var l = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1e11;
+  return qn.test(u) ? Math.round(u * l) / l : u;
+}
+function Y(u) {
+  var l = u.aspectRatio, s = u.height, c = u.width, d = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "none", p = fe(c), b = fe(s);
+  if (p && b) {
+    var O = s * l;
+    (d === "contain" || d === "none") && O > c || d === "cover" && O < c ? s = c / l : c = s * l;
+  } else p ? s = c / l : b && (c = s * l);
+  return {
+    width: c,
+    height: s
+  };
+}
+var Fn = V.ArrayBuffer, ke = V.FileReader, K = V.URL || V.webkitURL, Xn = /\.\w+$/, Kn = V.Compressor, Oe = /* @__PURE__ */ function() {
+  function u(l, s) {
+    Pn(this, u), this.file = l, this.image = new Image(), this.options = ie(ie({}, Ee), s), this.aborted = !1, this.result = null, this.init();
+  }
+  return Rn(u, [{
+    key: "init",
+    value: function() {
+      var s = this, c = this.file, d = this.options;
+      if (!In(c)) {
+        this.fail(new Error("The first argument must be a File or Blob object."));
+        return;
+      }
+      var p = c.type;
+      if (!ve(p)) {
+        this.fail(new Error("The first argument must be an image File or Blob object."));
+        return;
+      }
+      if (!K || !ke) {
+        this.fail(new Error("The current browser does not support image compression."));
+        return;
+      }
+      if (Fn || (d.checkOrientation = !1), K && !d.checkOrientation)
+        this.load({
+          url: K.createObjectURL(c)
+        });
+      else {
+        var b = new ke(), O = d.checkOrientation && p === "image/jpeg";
+        this.reader = b, b.onload = function(v) {
+          var k = v.target, E = k.result, C = {};
+          if (O) {
+            var A = Wn(E);
+            A > 1 || !K ? (C.url = _n(E, p), A > 1 && ce(C, Vn(A))) : C.url = K.createObjectURL(c);
+          } else
+            C.url = E;
+          s.load(C);
+        }, b.onabort = function() {
+          s.fail(new Error("Aborted to read the image with FileReader."));
+        }, b.onerror = function() {
+          s.fail(new Error("Failed to read the image with FileReader."));
+        }, b.onloadend = function() {
+          s.reader = null;
+        }, O ? b.readAsArrayBuffer(c) : b.readAsDataURL(c);
+      }
+    }
+  }, {
+    key: "load",
+    value: function(s) {
+      var c = this, d = this.file, p = this.image;
+      p.onload = function() {
+        c.draw(ie(ie({}, s), {}, {
+          naturalWidth: p.naturalWidth,
+          naturalHeight: p.naturalHeight
+        }));
+      }, p.onabort = function() {
+        c.fail(new Error("Aborted to load the image."));
+      }, p.onerror = function() {
+        c.fail(new Error("Failed to load the image."));
+      }, V.navigator && /(?:iPad|iPhone|iPod).*?AppleWebKit/i.test(V.navigator.userAgent) && (p.crossOrigin = "anonymous"), p.alt = d.name, p.src = s.url;
+    }
+  }, {
+    key: "draw",
+    value: function(s) {
+      var c = this, d = s.naturalWidth, p = s.naturalHeight, b = s.rotate, O = b === void 0 ? 0 : b, v = s.scaleX, k = v === void 0 ? 1 : v, E = s.scaleY, C = E === void 0 ? 1 : E, A = this.file, B = this.image, h = this.options, I = document.createElement("canvas"), T = I.getContext("2d"), $ = Math.abs(O) % 180 === 90, J = (h.resize === "contain" || h.resize === "cover") && fe(h.width) && fe(h.height), H = Math.max(h.maxWidth, 0) || 1 / 0, q = Math.max(h.maxHeight, 0) || 1 / 0, F = Math.max(h.minWidth, 0) || 0, _ = Math.max(h.minHeight, 0) || 0, W = d / p, P = h.width, R = h.height;
+      if ($) {
+        var Z = [q, H];
+        H = Z[0], q = Z[1];
+        var ee = [_, F];
+        F = ee[0], _ = ee[1];
+        var te = [R, P];
+        P = te[0], R = te[1];
+      }
+      J && (W = P / R);
+      var re = Y({
+        aspectRatio: W,
+        width: H,
+        height: q
+      }, "contain");
+      H = re.width, q = re.height;
+      var ne = Y({
+        aspectRatio: W,
+        width: F,
+        height: _
+      }, "cover");
+      if (F = ne.width, _ = ne.height, J) {
+        var i = Y({
+          aspectRatio: W,
+          width: P,
+          height: R
+        }, h.resize);
+        P = i.width, R = i.height;
+      } else {
+        var t = Y({
+          aspectRatio: W,
+          width: P,
+          height: R
+        }), r = t.width;
+        P = r === void 0 ? d : r;
+        var n = t.height;
+        R = n === void 0 ? p : n;
+      }
+      P = Math.floor(we(Math.min(Math.max(P, F), H))), R = Math.floor(we(Math.min(Math.max(R, _), q)));
+      var a = -P / 2, o = -R / 2, f = P, g = R, w = [];
+      if (J) {
+        var D = 0, y = 0, x = d, m = p, S = Y({
+          aspectRatio: W,
+          width: d,
+          height: p
+        }, {
+          contain: "cover",
+          cover: "contain"
+        }[h.resize]);
+        x = S.width, m = S.height, D = (d - x) / 2, y = (p - m) / 2, w.push(D, y, x, m);
+      }
+      if (w.push(a, o, f, g), $) {
+        var j = [R, P];
+        P = j[0], R = j[1];
+      }
+      I.width = P, I.height = R, ve(h.mimeType) || (h.mimeType = A.type);
+      var M = "transparent";
+      if (A.size > h.convertSize && h.convertTypes.indexOf(h.mimeType) >= 0 && (h.mimeType = "image/jpeg"), h.mimeType === "image/jpeg" && (M = "#fff"), T.fillStyle = M, T.fillRect(0, 0, P, R), h.beforeDraw && h.beforeDraw.call(this, T, I), !this.aborted && (T.save(), T.translate(P / 2, R / 2), T.rotate(O * Math.PI / 180), T.scale(k, C), T.drawImage.apply(T, [B].concat(w)), T.restore(), h.drew && h.drew.call(this, T, I), !this.aborted)) {
+        var U = function(X) {
+          c.aborted || c.done({
+            naturalWidth: d,
+            naturalHeight: p,
+            result: X
+          });
+        };
+        I.toBlob ? I.toBlob(U, h.mimeType, h.quality) : U(Bn(I.toDataURL(h.mimeType, h.quality)));
+      }
+    }
+  }, {
+    key: "done",
+    value: function(s) {
+      var c = s.naturalWidth, d = s.naturalHeight, p = s.result, b = this.file, O = this.image, v = this.options;
+      if (K && !v.checkOrientation && K.revokeObjectURL(O.src), p)
+        if (v.strict && p.size > b.size && v.mimeType === b.type && !(v.width > c || v.height > d || v.minWidth > c || v.minHeight > d || v.maxWidth < c || v.maxHeight < d))
+          p = b;
+        else {
+          var k = /* @__PURE__ */ new Date();
+          p.lastModified = k.getTime(), p.lastModifiedDate = k, p.name = b.name, p.name && p.type !== b.type && (p.name = p.name.replace(Xn, Ln(p.type)));
+        }
+      else
+        p = b;
+      this.result = p, v.success && v.success.call(this, p);
+    }
+  }, {
+    key: "fail",
+    value: function(s) {
+      var c = this.options;
+      if (c.error)
+        c.error.call(this, s);
+      else
+        throw s;
+    }
+  }, {
+    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 = Kn, u;
+    }
+    /**
+     * Change the default options.
+     * @param {Object} options - The new default options.
+     */
+  }, {
+    key: "setDefaults",
+    value: function(s) {
+      ce(Ee, s);
+    }
+  }]), u;
+}(), Be = { exports: {} };
+const Gn = /* @__PURE__ */ Dn(Tn);
+/*!
+ Name: vue-upload-component 
+Component URI: https://github.com/lian-yue/vue-upload-component#readme 
+Version: 3.1.16 
+Author: LianYue 
+License: Apache-2.0 
+Description: Vue.js file upload component, Multi-file upload, Upload directory, Drag upload, Drag the directory, Upload multiple files at the same time, html4 (IE 9), `PUT` method, Customize the filter 
+ */
+(function(u, l) {
+  (function(s, c) {
+    u.exports = c(Gn);
+  })(Sn, function(s) {
+    function c(i) {
+      return O(i) || b(i) || p(i) || d();
+    }
+    function d() {
+      throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+    }
+    function p(i, t) {
+      if (i) {
+        if (typeof i == "string") return v(i, t);
+        var r = Object.prototype.toString.call(i).slice(8, -1);
+        if (r === "Object" && i.constructor && (r = i.constructor.name), r === "Map" || r === "Set") return Array.from(i);
+        if (r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)) return v(i, t);
+      }
+    }
+    function b(i) {
+      if (typeof Symbol < "u" && i[Symbol.iterator] != null || i["@@iterator"] != null) return Array.from(i);
+    }
+    function O(i) {
+      if (Array.isArray(i)) return v(i);
+    }
+    function v(i, t) {
+      (t == null || t > i.length) && (t = i.length);
+      for (var r = 0, n = new Array(t); r < t; r++)
+        n[r] = i[r];
+      return n;
+    }
+    function k(i, t) {
+      var r = Object.keys(i);
+      if (Object.getOwnPropertySymbols) {
+        var n = Object.getOwnPropertySymbols(i);
+        t && (n = n.filter(function(a) {
+          return Object.getOwnPropertyDescriptor(i, a).enumerable;
+        })), r.push.apply(r, n);
+      }
+      return r;
+    }
+    function E(i) {
+      for (var t = 1; t < arguments.length; t++) {
+        var r = arguments[t] != null ? arguments[t] : {};
+        t % 2 ? k(Object(r), !0).forEach(function(n) {
+          C(i, n, r[n]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(i, Object.getOwnPropertyDescriptors(r)) : k(Object(r)).forEach(function(n) {
+          Object.defineProperty(i, n, Object.getOwnPropertyDescriptor(r, n));
+        });
+      }
+      return i;
+    }
+    function C(i, t, r) {
+      return t in i ? Object.defineProperty(i, t, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : i[t] = r, i;
+    }
+    function A(i) {
+      "@babel/helpers - typeof";
+      return A = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+        return typeof t;
+      } : function(t) {
+        return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+      }, A(i);
+    }
+    function B(i, t) {
+      var r = Object.keys(i);
+      if (Object.getOwnPropertySymbols) {
+        var n = Object.getOwnPropertySymbols(i);
+        t && (n = n.filter(function(a) {
+          return Object.getOwnPropertyDescriptor(i, a).enumerable;
+        })), r.push.apply(r, n);
+      }
+      return r;
+    }
+    function h(i) {
+      for (var t = 1; t < arguments.length; t++) {
+        var r = arguments[t] != null ? arguments[t] : {};
+        t % 2 ? B(Object(r), !0).forEach(function(n) {
+          J(i, n, r[n]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(i, Object.getOwnPropertyDescriptors(r)) : B(Object(r)).forEach(function(n) {
+          Object.defineProperty(i, n, Object.getOwnPropertyDescriptor(r, n));
+        });
+      }
+      return i;
+    }
+    function I(i, t) {
+      if (!(i instanceof t))
+        throw new TypeError("Cannot call a class as a function");
+    }
+    function T(i, t) {
+      for (var r = 0; r < t.length; r++) {
+        var n = t[r];
+        n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(i, n.key, n);
+      }
+    }
+    function $(i, t, r) {
+      return t && T(i.prototype, t), Object.defineProperty(i, "prototype", {
+        writable: !1
+      }), i;
+    }
+    function J(i, t, r) {
+      return t in i ? Object.defineProperty(i, t, {
+        value: r,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      }) : i[t] = r, i;
+    }
+    var H = 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(n) {
+        r.setRequestHeader(n, t.headers[n]);
+      }), r;
+    }, q = function(t, r) {
+      return new Promise(function(n, a) {
+        t.onload = function() {
+          if (t.status >= 200 && t.status < 300) {
+            var o;
+            try {
+              o = JSON.parse(t.response);
+            } catch {
+              o = t.response;
+            }
+            n(o);
+          } else
+            a(t.response);
+        }, t.onerror = function() {
+          return a(t.response);
+        }, t.send(JSON.stringify(r));
+      });
+    }, F = function(t, r) {
+      var n = new FormData();
+      for (var a in r)
+        n.append(a, r[a]);
+      return new Promise(function(o, f) {
+        t.onload = function() {
+          if (t.status >= 200 && t.status < 300) {
+            var g;
+            try {
+              g = JSON.parse(t.response);
+            } catch {
+              g = t.response;
+            }
+            o(g);
+          } else
+            f(t.response);
+        }, t.onerror = function() {
+          return f(t.response);
+        }, t.send(n);
+      });
+    };
+    function _(i) {
+      var t = H(i);
+      return q(t, i.body);
+    }
+    var W = /* @__PURE__ */ function() {
+      function i(t, r) {
+        I(this, i), this.file = t, this.options = r, this.chunks = [], this.sessionId = null, this.chunkSize = null, this.speedInterval = null;
+      }
+      return $(i, [{
+        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, n = this.chunksUploaded.length / this.chunks.length * 100, a = this.chunksUploading.reduce(function(o, f) {
+            return o + (f.progress | 0) / r.chunks.length;
+          }, 0);
+          return Math.min(n + a, 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;
+          });
+        }
+        /**
+         * Creates all the chunks in the initial state
+         */
+      }, {
+        key: "createChunks",
+        value: function() {
+          this.chunks = [];
+          for (var r = 0, n = this.chunkSize; r < this.fileSize; )
+            this.chunks.push({
+              blob: this.file.file.slice(r, n),
+              startOffset: r,
+              active: !1,
+              retries: this.maxRetries
+            }), r = n, n = 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(n, a) {
+            r.resolve = n, r.reject = a;
+          }), this.start(), this.promise;
+        }
+        /**
+         * Start phase
+         * Sends a request to the backend to initialise the chunks
+         */
+      }, {
+        key: "start",
+        value: function() {
+          var r = this;
+          _({
+            method: "POST",
+            headers: h(h({}, 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(n) {
+            if (n.status !== "success")
+              return r.file.response = n, r.reject("server");
+            r.sessionId = n.data.session_id, r.chunkSize = n.data.end_offset, r.createChunks(), r.startChunking();
+          }).catch(function(n) {
+            r.file.response = n, 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 n = this;
+          r.progress = 0, r.active = !0, this.updateFileProgress(), r.xhr = H({
+            method: "POST",
+            headers: this.headers,
+            url: this.action
+          }), r.xhr.upload.addEventListener("progress", function(a) {
+            a.lengthComputable && (r.progress = Math.round(a.loaded / a.total * 100));
+          }, !1), F(r.xhr, Object.assign(this.uploadBody, {
+            phase: "upload",
+            session_id: this.sessionId,
+            start_offset: r.startOffset,
+            chunk: r.blob
+          })).then(function(a) {
+            if (r.active = !1, a.status === "success")
+              r.uploaded = !0;
+            else if (r.retries-- <= 0)
+              return n.stopChunks(), n.reject("upload");
+            n.uploadNextChunk();
+          }).catch(function() {
+            if (r.active = !1, r.retries-- <= 0)
+              return n.stopChunks(), n.reject("upload");
+            n.uploadNextChunk();
+          });
+        }
+        /**
+         * Finish phase
+         * Sends a request to the backend to finish the process
+         */
+      }, {
+        key: "finish",
+        value: function() {
+          var r = this;
+          this.updateFileProgress(), this.stopSpeedCalc(), _({
+            method: "POST",
+            headers: h(h({}, this.headers), {}, {
+              "Content-Type": "application/json"
+            }),
+            url: this.action,
+            body: Object.assign(this.finishBody, {
+              phase: "finish",
+              session_id: this.sessionId
+            })
+          }).then(function(n) {
+            if (r.file.response = n, n.status !== "success")
+              return r.reject("server");
+            r.resolve(n);
+          }).catch(function(n) {
+            r.file.response = n, 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 n = 0;
+          this.speedInterval || (this.speedInterval = window.setInterval(function() {
+            var a = r.progress / 100 * r.fileSize;
+            r.file.speed = a - n, n = a;
+          }, 1e3));
+        }
+        /**
+         * Removes the upload speed interval
+         */
+      }, {
+        key: "stopSpeedCalc",
+        value: function() {
+          this.speedInterval && window.clearInterval(this.speedInterval), this.speedInterval = null, this.file.speed = 0;
+        }
+      }]), i;
+    }(), P = {
+      headers: {},
+      action: "",
+      minSize: 1048576,
+      maxActive: 3,
+      maxRetries: 5,
+      handler: W
+    }, R = s.defineComponent({
+      compatConfig: {
+        MODE: 3
+      },
+      props: {
+        inputId: {
+          type: String
+        },
+        name: {
+          type: String,
+          default: "file"
+        },
+        accept: {
+          type: String
+        },
+        capture: {},
+        disabled: {
+          default: !1
+        },
+        multiple: {
+          type: Boolean,
+          default: !1
+        },
+        maximum: {
+          type: Number
+        },
+        addIndex: {
+          type: [Boolean, Number]
+        },
+        directory: {
+          type: Boolean
+        },
+        createDirectory: {
+          type: Boolean,
+          default: !1
+        },
+        postAction: {
+          type: String
+        },
+        putAction: {
+          type: String
+        },
+        customAction: {
+          type: Function
+        },
+        headers: {
+          type: Object,
+          default: function() {
+            return {};
+          }
+        },
+        data: {
+          type: Object,
+          default: function() {
+            return {};
+          }
+        },
+        timeout: {
+          type: Number,
+          default: 0
+        },
+        drop: {
+          type: [Boolean, String, HTMLElement],
+          default: function() {
+            return !1;
+          }
+        },
+        dropDirectory: {
+          type: Boolean,
+          default: !0
+        },
+        size: {
+          type: Number,
+          default: 0
+        },
+        extensions: {
+          type: [RegExp, String, Array],
+          default: function() {
+            return [];
+          }
+        },
+        modelValue: {
+          type: Array,
+          default: function() {
+            return [];
+          }
+        },
+        thread: {
+          type: Number,
+          default: 1
+        },
+        // Chunk upload enabled
+        chunkEnabled: {
+          type: Boolean,
+          default: !1
+        },
+        // Chunk upload properties
+        chunk: {
+          type: Object,
+          default: function() {
+            return P;
+          }
+        }
+      },
+      emits: ["update:modelValue", "input-filter", "input-file"],
+      data: function() {
+        return {
+          files: this.modelValue,
+          features: {
+            html5: !0,
+            directory: !1,
+            drop: !1
+          },
+          active: !1,
+          dropActive: !1,
+          dropElementActive: !1,
+          uploading: 0,
+          destroy: !1,
+          maps: {},
+          dropElement: null,
+          dropTimeout: null,
+          reload: !1
+        };
+      },
+      /**
+       * mounted
+       * @return {[type]} [description]
+       */
+      mounted: function() {
+        var t = this, r = document.createElement("input");
+        if (r.type = "file", r.multiple = !0, window.FormData && r.files ? ((typeof r.webkitdirectory == "boolean" || typeof r.directory == "boolean") && (this.features.directory = !0), this.features.html5 && typeof r.ondrop < "u" && this.isRelatedTargetSupported() && (this.features.drop = !0)) : this.features.html5 = !1, this.maps = {}, this.files)
+          for (var n = 0; n < this.files.length; n++) {
+            var a = this.files[n];
+            this.maps[a.id] = a;
+          }
+        this.$nextTick(function() {
+          t.$parent ? (t.$parent.$forceUpdate(), t.$parent.$nextTick(function() {
+            t.watchDrop(t.drop);
+          })) : t.watchDrop(t.drop);
+        });
+      },
+      /**
+       * beforeUnmount
+       * @return {[type]} [description]
+       */
+      beforeUnmount: function() {
+        this.destroy = !0, this.active = !1, this.watchDrop(!1), this.watchActive(!1);
+      },
+      computed: {
+        /**
+         * uploading 正在上传的线程
+         * @return {[type]} [description]
+         */
+        /**
+         * uploaded 文件列表是否全部已上传
+         * @return {[type]} [description]
+         */
+        uploaded: function() {
+          for (var t, 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(P, 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];
+        },
+        forId: function() {
+          return this.inputId || this.name;
+        },
+        iMaximum: function() {
+          return this.maximum === void 0 ? this.multiple ? 0 : 1 : this.maximum;
+        },
+        iExtensions: function() {
+          if (this.extensions) {
+            if (this.extensions instanceof RegExp)
+              return this.extensions;
+            if (this.extensions.length) {
+              var t = [];
+              return typeof this.extensions == "string" ? t = this.extensions.split(",") : t = this.extensions, t = t.map(function(r) {
+                return r.trim();
+              }).filter(function(r) {
+                return r;
+              }), new RegExp("\\.(" + t.join("|").replace(/\./g, "\\.") + ")$", "i");
+            }
+          }
+        },
+        iDirectory: function() {
+          if (this.directory && this.features.directory)
+            return !0;
+        }
+      },
+      watch: {
+        active: function(t) {
+          this.watchActive(t);
+        },
+        dropActive: function(t) {
+          this.watchDropActive(t), this.$parent && this.$parent.$forceUpdate();
+        },
+        drop: function(t) {
+          this.watchDrop(t);
+        },
+        modelValue: function(t) {
+          if (this.files !== t) {
+            this.files = t;
+            var r = this.maps;
+            this.maps = {};
+            for (var n = 0; n < this.files.length; n++) {
+              var a = this.files[n];
+              this.maps[a.id] = a;
+            }
+            for (var o in this.maps) {
+              var f = this.maps[o], g = r[o];
+              f !== g && this.emitFile(f, g);
+            }
+            for (var w in r)
+              this.maps[w] || this.emitFile(void 0, r[w]);
+          }
+        }
+      },
+      methods: {
+        newId: function() {
+          return Math.random().toString(36).substr(2);
+        },
+        // 清空
+        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 ? A(t) === "object" ? this.maps[t.id || ""] || !1 : this.maps[t] || !1 : !1;
+        },
+        // 添加
+        add: function(t, r) {
+          var n;
+          t instanceof Array ? n = t : n = [t], r === void 0 && (r = this.addIndex);
+          for (var a = [], o = 0; o < n.length; o++) {
+            var f = n[o];
+            this.features.html5 && f instanceof Blob && (f = {
+              id: "",
+              file: f,
+              size: f.size,
+              // @ts-ignore
+              name: f.webkitRelativePath || f.relativePath || f.name || "unknown",
+              type: f.type
+            }), f = f;
+            var g = !1;
+            if (f.fileObject === !1 || (f.fileObject || typeof Element < "u" && f.el instanceof HTMLInputElement || typeof Blob < "u" && f.file instanceof Blob) && (g = !0), g && (f = E(E({
+              fileObject: !0,
+              size: -1,
+              name: "Filename",
+              type: "",
+              active: !1,
+              error: "",
+              success: !1,
+              putAction: this.putAction,
+              postAction: this.postAction,
+              timeout: this.timeout
+            }, f), {}, {
+              response: {},
+              progress: "0.00",
+              speed: 0
+              // 只读
+              // file: undefined,
+              // xhr: undefined,
+              // el: undefined,
+              // iframe: undefined,
+            }), f.data = E(E({}, this.data), f.data ? f.data : {}), f.headers = E(E({}, this.headers), f.headers ? f.headers : {})), f.id || (f.id = this.newId()), !this.emitFilter(f, void 0) && (this.iMaximum > 1 && a.length + this.files.length >= this.iMaximum || (a.push(f), this.iMaximum === 1)))
+              break;
+          }
+          if (a.length) {
+            this.iMaximum === 1 && this.clear();
+            var w;
+            if (r === !0 || r === 0)
+              w = a.concat(this.files);
+            else if (r) {
+              var D;
+              w = this.files.concat([]), (D = w).splice.apply(D, [r, 0].concat(c(a)));
+            } else
+              w = this.files.concat(a);
+            this.files = w;
+            var y = 0;
+            r === !0 || r === 0 ? y = 0 : r ? r >= 0 ? r + a.length > this.files.length ? y = this.files.length - a.length : y = r : (y = this.files.length - a.length + r, y < 0 && (y = 0)) : y = this.files.length - a.length, a = this.files.slice(y, y + a.length);
+            for (var x = 0; x < a.length; x++) {
+              var m = a[x];
+              this.maps[m.id] = m;
+            }
+            this.emitInput();
+            for (var S = 0; S < a.length; S++)
+              this.emitFile(a[S], void 0);
+            return t instanceof Array ? a : a[0];
+          }
+        },
+        // 添加表单文件
+        addInputFile: function(t) {
+          var r = this, n = [];
+          this.iMaximum;
+          var a = t.webkitEntries || t.entries || void 0;
+          if (a != null && a.length)
+            return this.getFileSystemEntry(a).then(function(w) {
+              return r.add(w);
+            });
+          if (t.files)
+            for (var o = 0; o < t.files.length; o++) {
+              var f = t.files[o];
+              n.push({
+                id: "",
+                size: f.size,
+                // @ts-ignore
+                name: f.webkitRelativePath || f.relativePath || f.name,
+                type: f.type,
+                file: f
+              });
+            }
+          else {
+            var g = t.value.replace(/\\/g, "/").split("/");
+            (!g || !g.length) && (g = [t.value]), delete t.__vuex__, n.push({
+              id: "",
+              name: g[g.length - 1],
+              el: t
+            });
+          }
+          return Promise.resolve(this.add(n));
+        },
+        // 添加 DataTransfer
+        addDataTransfer: function(t) {
+          var r, n = this;
+          if (t != null && (r = t.items) !== null && r !== void 0 && r.length) {
+            for (var a = [], o = 0; o < t.items.length; o++) {
+              var f = t.items[o], g = void 0;
+              f.getAsEntry ? g = f.getAsEntry() || f.getAsFile() : f.webkitGetAsEntry ? g = f.webkitGetAsEntry() || f.getAsFile() : g = f.getAsFile(), g && a.push(g);
+            }
+            return this.getFileSystemEntry(a).then(function(x) {
+              return n.add(x);
+            });
+          }
+          var w = this.iMaximum, D = [];
+          if (t.files.length) {
+            for (var y = 0; y < t.files.length && (D.push(t.files[y]), !(w > 0 && D.length >= w)); y++)
+              ;
+            return Promise.resolve(this.add(D));
+          }
+          return Promise.resolve([]);
+        },
+        // 获得 entrys    
+        getFileSystemEntry: function(t) {
+          var r = this, n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+          return new Promise(function(a) {
+            var o = r.iMaximum;
+            if (!t) {
+              a([]);
+              return;
+            }
+            if (t instanceof Array) {
+              var f = [], g = function S(j) {
+                var M = t[j];
+                if (!M || o > 0 && f.length >= o)
+                  return a(f);
+                r.getFileSystemEntry(M, n).then(function(U) {
+                  f.push.apply(f, c(U)), S(j + 1);
+                });
+              };
+              g(0);
+              return;
+            }
+            if (t instanceof Blob) {
+              a([{
+                id: "",
+                size: t.size,
+                // @ts-ignore
+                name: n + t.name,
+                type: t.type,
+                file: t
+              }]);
+              return;
+            }
+            if (t.isFile) {
+              var w = t;
+              w.file(function(S) {
+                a([{
+                  id: "",
+                  size: S.size,
+                  name: n + S.name,
+                  type: S.type,
+                  file: S
+                }]);
+              });
+              return;
+            }
+            if (t.isDirectory && r.dropDirectory) {
+              var D = t, y = [];
+              r.createDirectory && y.push({
+                id: "",
+                name: n + D.name,
+                size: 0,
+                type: "text/directory",
+                file: new File([], n + D.name, {
+                  type: "text/directory"
+                })
+              });
+              var x = D.createReader(), m = function S() {
+                x.readEntries(function(j) {
+                  var M = function U(z) {
+                    if (!j[z] && z === 0 || o > 0 && y.length >= o)
+                      return a(y);
+                    if (!j[z])
+                      return S();
+                    r.getFileSystemEntry(j[z], n + D.name + "/").then(function(X) {
+                      y.push.apply(y, c(X)), U(z + 1);
+                    });
+                  };
+                  M(0);
+                });
+              };
+              m();
+              return;
+            }
+            a([]);
+          });
+        },
+        // 替换
+        replace: function(t, r) {
+          var n = this.get(t), a = this.get(r);
+          if (!n || !a || n === a)
+            return !1;
+          var o = this.files.concat([]), f = o.indexOf(n), g = o.indexOf(a);
+          return f === -1 || g === -1 ? !1 : (o[f] = a, o[g] = n, 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 n = this.files.concat([]), a = n.indexOf(r);
+            if (a === -1)
+              return console.error("remove", r), !1;
+            n.splice(a, 1), this.files = n, delete this.maps[r.id], this.emitInput(), this.emitFile(void 0, r);
+          }
+          return r;
+        },
+        // 更新
+        update: function(t, r) {
+          var n = this.get(t);
+          if (n) {
+            var a = E(E({}, n), r);
+            if (n.fileObject && n.active && !a.active && !a.error && !a.success && (a.error = "abort"), this.emitFilter(a, n))
+              return !1;
+            var o = this.files.concat([]), f = o.indexOf(n);
+            return f === -1 ? (console.error("update", n), !1) : (o.splice(f, 1, a), this.files = o, a = this.files[f], delete this.maps[n.id], this.maps[a.id] = a, this.emitInput(), this.emitFile(a, n), a);
+          }
+          return !1;
+        },
+        // 预处理 事件 过滤器
+        emitFilter: function(t, r) {
+          var n = !1;
+          return this.$emit("input-filter", t, r, function() {
+            var a = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !0;
+            return n = a, n;
+          }), n;
+        },
+        // 处理后 事件 分发
+        emitFile: function(t, r) {
+          var n, a = this;
+          this.$emit("input-file", t, r), (n = t) !== null && n !== void 0 && n.fileObject && t.active && (!r || !r.active) ? (this.uploading++, this.$nextTick(function() {
+            setTimeout(function() {
+              t && a.upload(t).then(function() {
+                var o;
+                t && (t = a.get(t) || void 0), (o = t) !== null && o !== void 0 && o.fileObject && a.update(t, {
+                  active: !1,
+                  success: !t.error
+                });
+              }).catch(function(o) {
+                t && a.update(t, {
+                  active: !1,
+                  success: !1,
+                  error: o.code || o.error || o.message || o
+                });
+              });
+            }, Math.ceil(Math.random() * 50 + 50));
+          })) : (!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("update:modelValue", this.files);
+        },
+        // 上传
+        upload: function(t) {
+          var r = this.get(t);
+          if (!r)
+            return Promise.reject(new Error("not_exists"));
+          if (!r.fileObject)
+            return Promise.reject(new Error("file_object"));
+          if (r.error)
+            return r.error instanceof Error ? Promise.reject(r.error) : Promise.reject(new Error(r.error));
+          if (r.success)
+            return Promise.resolve(r);
+          if (r.name && this.iExtensions && r.type !== "text/directory" && r.name.search(this.iExtensions) === -1)
+            return Promise.reject(new Error("extension"));
+          if (this.size > 0 && r.size !== void 0 && r.size >= 0 && r.size > this.size && r.type !== "text/directory")
+            return Promise.reject(new Error("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(new Error("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 && 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().then(function(n) {
+            return t;
+          });
+        },
+        uploadPut: function(t) {
+          var r = [], n;
+          for (var a in t.data)
+            n = t.data[a], n != null && r.push(encodeURIComponent(a) + "=" + encodeURIComponent(n));
+          var o = t.putAction || "", f = r.length ? (o.indexOf("?") === -1 ? "?" : "&") + r.join("&") : "", g = new XMLHttpRequest();
+          return g.open("PUT", o + f), this.uploadXhr(g, t, t.file);
+        },
+        uploadHtml5: function(t) {
+          var r = new window.FormData(), n;
+          for (var a in t.data)
+            n = t.data[a], n && A(n) === "object" && typeof n.toString != "function" ? n instanceof File ? r.append(a, n, n.name) : r.append(a, JSON.stringify(n)) : n != null && r.append(a, n);
+          r.append(this.name, t.file, t.name || t.file.name || t.file.filename);
+          var o = new XMLHttpRequest();
+          return o.open("POST", t.postAction || ""), this.uploadXhr(o, t, r);
+        },
+        uploadXhr: function(t, r, n) {
+          var a = this, o = r, f = 0, g = 0;
+          t.upload.onprogress = function(D) {
+            if (o && (o = a.get(o), !(!D.lengthComputable || !o || !o.fileObject || !o.active))) {
+              var y = Math.round(Date.now() / 1e3);
+              y !== f && (f = y, o = a.update(o, {
+                progress: (D.loaded / D.total * 100).toFixed(2),
+                speed: D.loaded - g
+              }), g = D.loaded);
+            }
+          };
+          var w = window.setInterval(function() {
+            if (o && (o = a.get(o))) {
+              var D;
+              if ((D = o) !== null && D !== void 0 && D.fileObject && !o.success && !o.error && o.active)
+                return;
+            }
+            w && (clearInterval(w), w = void 0);
+            try {
+              t.abort(), t.timeout = 1;
+            } catch {
+            }
+          }, 100);
+          return new Promise(function(D, y) {
+            if (!o) {
+              y(new Error("not_exists"));
+              return;
+            }
+            var x, m = function(M) {
+              if (!x) {
+                if (x = !0, w && (clearInterval(w), w = void 0), !o)
+                  return y(new Error("not_exists"));
+                if (o = a.get(o), !o)
+                  return y(new Error("not_exists"));
+                if (!o.fileObject)
+                  return y(new Error("file_object"));
+                if (o.error)
+                  return o.error instanceof Error ? y(o.error) : y(new Error(o.error));
+                if (!o.active)
+                  return y(new Error("abort"));
+                if (o.success)
+                  return D(o);
+                var U = {};
+                switch (M.type) {
+                  case "timeout":
+                  case "abort":
+                    U.error = M.type;
+                    break;
+                  case "error":
+                    t.status ? t.status >= 500 ? U.error = "server" : t.status >= 400 && (U.error = "denied") : U.error = "network";
+                    break;
+                  default:
+                    t.status >= 500 ? U.error = "server" : t.status >= 400 ? U.error = "denied" : U.progress = "100.00";
+                }
+                if (t.responseText) {
+                  var z = t.getResponseHeader("Content-Type");
+                  z && z.indexOf("/json") !== -1 ? U.response = JSON.parse(t.responseText) : U.response = t.responseText;
+                }
+                return o = a.update(o, U), o ? o.error ? o.error instanceof Error ? y(o.error) : y(new Error(o.error)) : D(o) : y(new Error("abort"));
+              }
+            };
+            t.onload = m, t.onerror = m, t.onabort = m, t.ontimeout = m, o.timeout && (t.timeout = o.timeout);
+            for (var S in o.headers)
+              t.setRequestHeader(S, o.headers[S]);
+            o = a.update(o, {
+              xhr: t
+            }), o && t.send(n);
+          });
+        },
+        uploadHtml4: function(t) {
+          var r = this, n = t;
+          if (!n)
+            return Promise.reject(new Error("not_exists"));
+          var a = function(m) {
+            m.keyCode === 27 && m.preventDefault();
+          }, o = document.createElement("iframe");
+          o.id = "upload-iframe-" + n.id, o.name = "upload-iframe-" + n.id, o.src = "about:blank", o.setAttribute("style", "width:1px;height:1px;top:-999em;position:absolute; margin-top:-999em;");
+          var f = document.createElement("form");
+          f.setAttribute("action", n.postAction || ""), f.name = "upload-form-" + n.id, f.setAttribute("method", "POST"), f.setAttribute("target", "upload-iframe-" + n.id), f.setAttribute("enctype", "multipart/form-data");
+          for (var g in n.data) {
+            var w = n.data[g];
+            if (w && A(w) === "object" && typeof w.toString != "function" && (w = JSON.stringify(w)), w != null) {
+              var D = document.createElement("input");
+              D.type = "hidden", D.name = g, D.value = w, f.appendChild(D);
+            }
+          }
+          f.appendChild(n.el), document.body.appendChild(o).appendChild(f);
+          var y = function() {
+            var m, S;
+            try {
+              o.contentWindow && (S = o.contentWindow.document);
+            } catch {
+            }
+            if (!S)
+              try {
+                S = o.contentDocument ? o.contentDocument : o.document;
+              } catch {
+                S = o.document;
+              }
+            return (m = S) !== null && m !== void 0 && m.body ? S.body.innerHTML : null;
+          };
+          return new Promise(function(x, m) {
+            setTimeout(function() {
+              if (!n) {
+                m(new Error("not_exists"));
+                return;
+              }
+              if (n = r.update(n, {
+                iframe: o
+              }), !n)
+                return m(new Error("not_exists"));
+              var S = window.setInterval(function() {
+                n && (n = r.get(n)) && n.fileObject && !n.success && !n.error && n.active || (S && (clearInterval(S), S = void 0), o.onabort({
+                  type: n ? "abort" : "not_exists"
+                }));
+              }, 100), j, M = function(z) {
+                var X;
+                if (!j) {
+                  if (j = !0, S && (clearInterval(S), S = void 0), document.body.removeEventListener("keydown", a), !n)
+                    return m(new Error("not_exists"));
+                  if (n = r.get(n), !n)
+                    return m(new Error("not_exists"));
+                  if (!n.fileObject)
+                    return m(new Error("file_object"));
+                  if (n.error)
+                    return n.error instanceof Error ? m(n.error) : m(new Error(n.error));
+                  if (!n.active)
+                    return m(new Error("abort"));
+                  if (n.success)
+                    return x(n);
+                  var N = y(), L = {};
+                  if (typeof z == "string")
+                    return m(new Error(z));
+                  switch (z.type) {
+                    case "abort":
+                      L.error = "abort";
+                      break;
+                    case "error":
+                      n.error ? L.error = n.error : N === null ? L.error = "network" : L.error = "denied";
+                      break;
+                    default:
+                      n.error ? L.error = n.error : N === null ? L.error = "network" : L.progress = "100.00";
+                  }
+                  if (N !== null) {
+                    if (N && N.substr(0, 1) === "{" && N.substr(N.length - 1, 1) === "}")
+                      try {
+                        N = JSON.parse(N);
+                      } catch {
+                      }
+                    L.response = N;
+                  }
+                  return n = r.update(n, L), n ? (X = n) !== null && X !== void 0 && X.error ? n.error instanceof Error ? m(n.error) : m(new Error(n.error)) : x(n) : m(new Error("not_exists"));
+                }
+              };
+              o.onload = M, o.onerror = M, o.onabort = M, document.body.addEventListener("keydown", a), f.submit();
+            }, 50);
+          }).then(function(x) {
+            var m;
+            return o == null || (m = o.parentNode) === null || m === void 0 || m.removeChild(o), x;
+          }).catch(function(x) {
+            var m;
+            return o == null || (m = o.parentNode) === null || m === void 0 || m.removeChild(o), x;
+          });
+        },
+        watchActive: function(t) {
+          for (var r, n = 0; r = this.files[n]; )
+            if (n++, 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 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0;
+          if (this.features.drop && t !== r) {
+            if (this.dropElement)
+              try {
+                document.removeEventListener("dragenter", this.onDocumentDragenter, !1), document.removeEventListener("dragleave", this.onDocumentDragleave, !1), document.removeEventListener("dragover", this.onDocumentDragover, !1), document.removeEventListener("drop", this.onDocumentDrop, !1), this.dropElement.removeEventListener("dragenter", this.onDragenter, !1), this.dropElement.removeEventListener("dragleave", this.onDragleave, !1), this.dropElement.removeEventListener("dragover", this.onDragover, !1), this.dropElement.removeEventListener("drop", this.onDrop, !1);
+              } catch {
+              }
+            var n = null;
+            if (t) if (typeof t == "string")
+              n = document.querySelector(t) || this.$root.$el.querySelector(t);
+            else if (t === !0) {
+              var a;
+              if (n = this.$parent.$el, !n || ((a = n) === null || a === void 0 ? void 0 : a.nodeType) === 8) {
+                var o;
+                n = this.$root.$el, (!n || ((o = n) === null || o === void 0 ? void 0 : o.nodeType) === 8) && (n = document.body);
+              }
+            } else
+              n = t;
+            this.dropElement = n, this.dropElement && (document.addEventListener("dragenter", this.onDocumentDragenter, !1), document.addEventListener("dragleave", this.onDocumentDragleave, !1), document.addEventListener("dragover", this.onDocumentDragover, !1), document.addEventListener("drop", this.onDocumentDrop, !1), this.dropElement.addEventListener("dragenter", this.onDragenter, !1), this.dropElement.addEventListener("dragleave", this.onDragleave, !1), this.dropElement.addEventListener("dragover", this.onDragover, !1), this.dropElement.addEventListener("drop", this.onDrop, !1));
+          }
+        },
+        watchDropActive: function(t, r) {
+          t !== r && (!t && this.dropElementActive && (this.dropElementActive = !1), this.dropTimeout && (clearTimeout(this.dropTimeout), this.dropTimeout = null), t && (this.dropTimeout = setTimeout(this.onDocumentDrop, 1e3)));
+        },
+        onDocumentDragenter: function(t) {
+          var r, n;
+          if (!this.dropActive && t.dataTransfer) {
+            var a = t.dataTransfer;
+            a != null && (r = a.files) !== null && r !== void 0 && r.length ? this.dropActive = !0 : a.types ? a.types.indexOf && a.types.indexOf("Files") !== -1 ? this.dropActive = !0 : (n = a.types) !== null && n !== void 0 && n.contains && a.types.contains("Files") && (this.dropActive = !0) : this.dropActive = !0, this.dropActive && this.watchDropActive(!0);
+          }
+        },
+        onDocumentDragleave: function(t) {
+          this.dropActive && (t.target === t.explicitOriginalTarget || !t.fromElement && (t.clientX <= 0 || t.clientY <= 0 || t.clientX >= window.innerWidth || t.clientY >= window.innerHeight)) && (this.dropActive = !1, this.watchDropActive(!1));
+        },
+        onDocumentDragover: function() {
+          this.watchDropActive(!0);
+        },
+        onDocumentDrop: function() {
+          this.dropActive = !1, this.watchDropActive(!1);
+        },
+        onDragenter: function(t) {
+          !this.dropActive || this.dropElementActive || (this.dropElementActive = !0);
+        },
+        onDragleave: function(t) {
+          var r;
+          if (this.dropElementActive) {
+            var n = t.relatedTarget;
+            if (!n)
+              this.dropElementActive = !1;
+            else if ((r = this.dropElement) !== null && r !== void 0 && r.contains)
+              this.dropElement.contains(n) || (this.dropElementActive = !1);
+            else {
+              for (var a = n; a && a !== this.dropElement; )
+                a = a.parentNode;
+              a !== this.dropElement && (this.dropElementActive = !1);
+            }
+          }
+        },
+        onDragover: function(t) {
+          t.preventDefault();
+        },
+        onDrop: function(t) {
+          t.preventDefault(), t.dataTransfer && this.addDataTransfer(t.dataTransfer);
+        },
+        inputOnChange: async function(t) {
+          var r = this;
+          if (!(t.target instanceof HTMLInputElement))
+            return Promise.reject(new Error("not HTMLInputElement"));
+          t.target;
+          var n = function(o) {
+            return r.reload = !0, r.$nextTick(function() {
+              r.reload = !1;
+            }), o;
+          };
+          return this.addInputFile(t.target).then(n).catch(n);
+        },
+        isRelatedTargetSupported: function() {
+          try {
+            var t = new MouseEvent("mouseout", {
+              relatedTarget: document.body
+            });
+            return "relatedTarget" in t;
+          } catch {
+            return !1;
+          }
+        }
+      }
+    }), Z = ["for"], ee = ["name", "id", "accept", "capture", "disabled", "webkitdirectory", "allowdirs", "directory", "multiple"];
+    function te(i, t, r, n, a, o) {
+      return s.openBlock(), s.createElementBlock("span", {
+        class: s.normalizeClass(i.className)
+      }, [s.renderSlot(i.$slots, "default"), s.createElementVNode("label", {
+        for: i.forId
+      }, null, 8, Z), i.reload ? s.createCommentVNode("", !0) : (s.openBlock(), s.createElementBlock("input", {
+        key: 0,
+        ref: "input",
+        type: "file",
+        name: i.name,
+        id: i.forId,
+        accept: i.accept,
+        capture: i.capture,
+        disabled: i.disabled,
+        webkitdirectory: i.iDirectory,
+        allowdirs: i.iDirectory,
+        directory: i.iDirectory,
+        multiple: i.multiple && i.features.html5,
+        onChange: t[0] || (t[0] = function() {
+          return i.inputOnChange && i.inputOnChange.apply(i, arguments);
+        })
+      }, null, 40, ee))], 2);
+    }
+    function re(i, t) {
+      t === void 0 && (t = {});
+      var r = t.insertAt;
+      if (!(typeof document > "u")) {
+        var n = document.head || document.getElementsByTagName("head")[0], a = document.createElement("style");
+        a.type = "text/css", r === "top" && n.firstChild ? n.insertBefore(a, n.firstChild) : n.appendChild(a), a.styleSheet ? a.styleSheet.cssText = i : a.appendChild(document.createTextNode(i));
+      }
+    }
+    var ne = `
+.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 fix ie  click */
+  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-html5 input,
+.file-uploads.file-uploads-html4 label {
+  /* background fix ie  click */
+  position: absolute;
+  background: rgba(255, 255, 255, 0);
+  overflow: hidden;
+  position: fixed;
+  width: 1px;
+  height: 1px;
+  z-index: -1;
+  opacity: 0;
+}
+`;
+    return re(ne), R.render = te, R;
+  });
+})(Be);
+var Jn = Be.exports;
+const Yn = /* @__PURE__ */ Cn(Jn), Qn = {
+  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: Yn,
+    UploadModal: De(
+      () => import("./UploadModal-C_X2NjVY.js")
+    )
+  },
+  emits: ["input", "upload-success", "has-mounted"],
+  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(u) {
+      const l = new FormData();
+      l.append("file", u.file, u.file.name);
+      const { data: s } = await ge.post("/file", l, {
+        onUploadProgress: (d) => {
+          const p = this.files.filter(
+            (b) => b.id === u.id
+          );
+          if (p.length) {
+            const b = p[0], O = b, v = Math.round(
+              d.loaded * 100 / d.total
+            );
+            O.progress = v, this.$refs.upload.update(b, O);
+          }
+        },
+        timeout: 6e4
+      }), c = u;
+      return c.response = s, this.$refs.upload.update(u, c), s;
+    },
+    // Pre-treatment when files are added
+    inputFilter(u, l) {
+      if (u && (!l || u.file !== l.file)) {
+        u.url = "";
+        const s = window.URL || window.webkitURL;
+        s && s.createObjectURL && (u.url = s.createObjectURL(u.file));
+      }
+    },
+    // Method to start uploading
+    startUpload() {
+      this.$refs.upload.active = !0;
+    },
+    // Clear any uploads
+    undoFileUpload() {
+      this.$refs.upload.clear();
+    },
+    remove(u) {
+      this.$refs.upload.remove(u);
+    },
+    // When a file is changed
+    inputFile(u, l) {
+      if (this.modalOpen && (this.modalOpen = !1), this.createThumbnails && u && !u.thumbnailId && u.file && u.type.substr(0, 6) === "image/" && !["image/heic", "image/heif"].includes(u.type) && !l)
+        return u.error = "thumbnail", new Promise(async (s, c) => {
+          try {
+            const { id: d } = await this.generateThumbnail(
+              u.file
+            ), p = u;
+            return p.thumbnailId = d, p.error = "", this.$refs.upload.update(u, p), s();
+          } catch (d) {
+            return c(d);
+          }
+        }).catch((s) => {
+          this.$refs.upload.update(u, {
+            error: s.code || s.error || s.message || s
+          });
+        });
+      if (u && u.file && u.type.substr(0, 6) === "image/" && !["image/heic", "image/heif"].includes(u.type) && !u.hasCompressed)
+        return u.error = "compressor", new Promise(async (s, c) => {
+          try {
+            const d = await this.compressFile(u.file);
+            return this.$refs.upload.update(u, { ...d, error: "" }), s();
+          } catch (d) {
+            return c(d);
+          }
+        }).catch((s) => {
+          this.$refs.upload.update(u, {
+            error: s.code || s.error || s.message || s
+          });
+        });
+      if (u && !u.active && !u.success && !u.error && this.autostartUpload && (u.active = !0), u && u.success && !l.success && this.$emit("upload-success", u), u && u.error && u.error !== "thumbnail" && u.error !== "compressor" && (!l || !l.error)) {
+        if (this.onError)
+          this.onError(u);
+        else {
+          let s = null;
+          switch (u.error) {
+            case "extension": {
+              const c = this.extensions.replace(/,/g, ", ");
+              s = this.$t("errors.extension", {
+                extensions: c
+              });
+              break;
+            }
+            case "size": {
+              s = this.$t("errors.size", {
+                maxFileSize: `${this.maxSize / 1e6} MB`
+              });
+              break;
+            }
+            case "ECONNREFUSED": {
+              s = this.$t("errors.ECONNREFUSED");
+              break;
+            }
+            default:
+              s = `${this.$t("errors.general")}: ${u.error}`;
+          }
+          de("error", s);
+        }
+        this.remove(u);
+      }
+      return !0;
+    },
+    async generateThumbnail(u) {
+      try {
+        return new Promise((l, s) => {
+          new Oe(u, {
+            quality: this.quality,
+            maxWidth: this.thumbnailMaxWidth,
+            maxHeight: this.thumbnailMaxHeight,
+            success: (c) => {
+              const d = new FormData(), p = this.appendToFilename(
+                c.name,
+                "_thumbnail"
+              );
+              return d.append("file", c, p), ge.post("/file", d).then((b) => l(b.data)).catch((b) => s(b));
+            },
+            error: (c) => s(c)
+          });
+        });
+      } catch (l) {
+        return de("error", this.$t("errors.thumbnail")), Promise.reject(l);
+      }
+    },
+    /**
+     * Helper to compress file
+     *
+     * @param {Object} originalFile
+     *
+     * @returns {Promise} Resolves with a new fileObj when done
+     */
+    async compressFile(u) {
+      let l;
+      try {
+        return new Promise((s, c) => {
+          l = new Oe(u, {
+            quality: this.quality,
+            maxWidth: this.maxWidth,
+            maxHeight: this.maxHeight,
+            success: (d) => {
+              const p = {
+                file: d,
+                size: d.size,
+                type: d.type,
+                hasCompressed: !0
+              };
+              return s(p);
+            },
+            error: (d) => c(d)
+          });
+        });
+      } catch (s) {
+        return de("error", this.$t("errors.compress")), this.$refs.upload.update(u, { error: e.message }), Promise.reject(s);
+      } finally {
+        l = null;
+      }
+    },
+    appendToFilename(u, l) {
+      const s = u.lastIndexOf(".");
+      return s === -1 ? u + l : u.substring(0, s) + l + u.substring(s);
+    },
+    handleSelect(u) {
+      this.$emit("upload-success", { response: u }), this.modalOpen = !1;
+    }
+  }
+}, Zn = { class: "modal-container" }, ei = {
+  key: 0,
+  class: "drop-active font-inter",
+  style: { "pointer-events": "none" }
+};
+function ti(u, l, s, c, d, p) {
+  const b = Q("CIcon"), O = Q("UploadModal"), v = Q("portal"), k = Q("FileUpload");
+  return G(), ae(k, {
+    ref: "upload",
+    modelValue: d.files,
+    "onUpdate:modelValue": l[1] || (l[1] = (E) => d.files = E),
+    maximum: s.maximum,
+    "custom-action": p.postAction,
+    extensions: s.extensions,
+    multiple: s.multiple,
+    drop: s.drop || d.modalOpen,
+    size: s.maxSize,
+    thread: 1,
+    accept: s.accept,
+    class: "btn btn-primary white-list",
+    onInput: l[2] || (l[2] = (E) => u.$emit("input", d.files)),
+    onInputFilter: p.inputFilter,
+    onInputFile: p.inputFile
+  }, {
+    default: le(() => {
+      var E, C;
+      return [
+        Ce(u.$slots, "default", { openFilePicker: p.open }, void 0, !0),
+        s.drop || d.modalOpen ? Te((G(), pe("div", {
+          key: 0,
+          class: Se([{ transparent: d.modalOpen }, "drop-active font-inter white-list"])
+        }, [
+          ue(b, {
+            type: "upload-cloud",
+            size: "60"
+          }),
+          oe(" " + me(u.$t("dropActive")), 1)
+        ], 2)), [
+          [Ae, (C = (E = u.$refs) == null ? void 0 : E.upload) == null ? void 0 : C.dropActive]
+        ]) : se("", !0),
+        d.modalOpen ? (G(), ae(v, {
+          key: 1,
+          to: "modal"
+        }, {
+          default: le(() => {
+            var A;
+            return [
+              he("div", {
+                class: "modal-overlay",
+                onClick: l[0] || (l[0] = Pe((B) => d.modalOpen = !1, ["self"]))
+              }, [
+                he("div", Zn, [
+                  ue(O, {
+                    onOpenPicker: p.openFilePicker,
+                    onSelect: p.handleSelect
+                  }, null, 8, ["onOpenPicker", "onSelect"])
+                ])
+              ]),
+              (A = u.$refs.upload) != null && A.dropActive ? (G(), pe("div", ei, [
+                (G(), ae(xe("style"), { type: "text/css" }, {
+                  default: le(() => l[3] || (l[3] = [
+                    oe(" * { pointer-events: none !important; } .white-list { pointer-events: initial !important; } ")
+                  ])),
+                  _: 1
+                })),
+                ue(b, {
+                  type: "upload-cloud",
+                  size: "60"
+                }),
+                oe(" " + me(u.$t("dropActive")), 1)
+              ])) : se("", !0)
+            ];
+          }),
+          _: 1
+        })) : se("", !0)
+      ];
+    }),
+    _: 3
+  }, 8, ["modelValue", "maximum", "custom-action", "extensions", "multiple", "drop", "size", "accept", "onInputFilter", "onInputFile"]);
+}
+const ii = /* @__PURE__ */ xn(Qn, [["render", ti], ["__scopeId", "data-v-8fe2d4c5"]]);
+export {
+  ii as default
+};