@utogether/udp-core 1.0.0

package/dist/pda-app-CRhVGijN.js

@@ -0,0 +1,2209 @@
+import { defineComponent as vt, ref as ee, computed as Ve, watch as Dt, createVNode as M, Fragment as De, withDirectives as qt, unref as K, resolveDirective as kt, nextTick as Ut, resolveComponent as x, createElementBlock as jt, openBlock as ze, createBlock as Ft, createCommentVNode as Vt, isVNode as zt } from "vue";
+import { useI18n as $t } from "vue-i18n";
+import { t as Ht } from "./await-to-js.es5-BtRbN2QH.js";
+import { A as Kt, I as Jt, B as Yt, w as Qt } from "./index-BKIw8tSn.js";
+import { withInstall as Gt, useRender as Wt } from "@utogether/utils";
+import { clone as Et, isString as $e } from "xe-utils";
+const qe = {
+  silent: !1,
+  logLevel: "warn"
+};
+function V(e) {
+  if (typeof e != "object" || e === null)
+    return !1;
+  const r = Object.getPrototypeOf(e);
+  return (r === null || r === Object.prototype || Object.getPrototypeOf(r) === null) && !(Symbol.toStringTag in e) && !(Symbol.iterator in e);
+}
+const xt = () => ({
+  func: () => {
+  },
+  bool: !0,
+  string: "",
+  number: 0,
+  array: () => [],
+  object: () => ({}),
+  integer: 0
+}), Tt = Object.prototype, Bt = Tt.toString, Xt = Tt.hasOwnProperty, At = /^\s*function (\w+)/;
+function He(e) {
+  const r = (e == null ? void 0 : e.type) ?? e;
+  if (r) {
+    const i = r.toString().match(At);
+    return i ? i[1] : "";
+  }
+  return "";
+}
+function Zt(e) {
+  if (e == null)
+    return "";
+  const r = e.constructor.toString().match(At);
+  return r ? r[1].replace(/^Async/, "") : "";
+}
+function Ke(e) {
+  return "structuredClone" in globalThis ? structuredClone(e) : Array.isArray(e) ? [...e] : V(e) ? Object.assign({}, e) : e;
+}
+function Rt() {
+}
+let _ = Rt;
+process.env.NODE_ENV !== "production" && (_ = typeof console < "u" ? function(i, n = qe.logLevel) {
+  qe.silent === !1 && console[n](`[VueTypes warn]: ${i}`);
+} : Rt);
+const te = (e, r) => Xt.call(e, r), en = Number.isInteger || function(r) {
+  return typeof r == "number" && isFinite(r) && Math.floor(r) === r;
+}, ne = Array.isArray || function(r) {
+  return Bt.call(r) === "[object Array]";
+}, re = (e) => Bt.call(e) === "[object Function]", ke = (e, r) => V(e) && te(e, "_vueTypes_name") && (!r || e._vueTypes_name === r), St = (e) => V(e) && (te(e, "type") || ["_vueTypes_name", "validator", "default", "required"].some(
+  (r) => te(e, r)
+));
+function Pt(e, r) {
+  return Object.defineProperty(e.bind(r), "__original", {
+    value: e
+  });
+}
+function J(e, r, i = !1) {
+  let n, t = !0, o = "";
+  V(e) ? n = e : n = { type: e };
+  const s = ke(n) ? n._vueTypes_name + " - " : "";
+  if (St(n) && n.type !== null) {
+    if (n.type === void 0 || n.type === !0 || !n.required && r == null)
+      return t;
+    ne(n.type) ? (t = n.type.some(
+      (a) => J(a, r, !0) === !0
+    ), o = n.type.map((a) => He(a)).join(" or ")) : (o = He(n), o === "Array" ? t = ne(r) : o === "Object" ? t = V(r) : o === "String" || o === "Number" || o === "Boolean" || o === "Function" ? t = Zt(r) === o : t = r instanceof n.type);
+  }
+  if (!t) {
+    const a = `${s}value "${r}" should be of type "${o}"`;
+    return i === !1 ? (_(a), !1) : a;
+  }
+  if (te(n, "validator") && re(n.validator)) {
+    const a = _, u = [];
+    if (_ = (c) => {
+      u.push(c);
+    }, t = n.validator(r), _ = a, !t) {
+      const c = (u.length > 1 ? "* " : "") + u.join(`
+* `);
+      return u.length = 0, i === !1 ? (_(c), t) : c;
+    }
+  }
+  return t;
+}
+function O(e, r) {
+  const i = Object.defineProperties(r, {
+    _vueTypes_name: {
+      value: e,
+      writable: !0
+    },
+    isRequired: {
+      get() {
+        return this.required = !0, this;
+      }
+    },
+    def: {
+      value(t) {
+        if (t === void 0) {
+          if (this.type === Boolean || Array.isArray(this.type) && this.type.includes(Boolean)) {
+            this.default = void 0;
+            return;
+          }
+          return te(this, "default") && delete this.default, this;
+        }
+        return !re(t) && J(this, t, !0) !== !0 ? (_(`${this._vueTypes_name} - invalid default value: "${t}"`), this) : (ne(t) ? this.default = () => Ke(t) : V(t) ? this.default = () => Ke(t) : this.default = t, this);
+      }
+    }
+  }), { validator: n } = i;
+  return re(n) && (i.validator = Pt(n, i)), i;
+}
+function k(e, r) {
+  const i = O(e, r);
+  return Object.defineProperty(i, "validate", {
+    value(n) {
+      return re(this.validator) && _(
+        `${this._vueTypes_name} - calling .validate() will overwrite the current custom validator function. Validator info:
+${JSON.stringify(
+          this
+        )}`
+      ), this.validator = Pt(n, this), this;
+    }
+  });
+}
+function ue(e) {
+  return e.replace(/^(?!\s*$)/gm, "  ");
+}
+const tn = () => k("any", {}), nn = () => k("function", {
+  type: Function
+}), Je = () => k("boolean", {
+  type: Boolean
+}), rn = () => k("string", {
+  type: String
+}), on = () => k("number", {
+  type: Number
+}), sn = () => k("array", {
+  type: Array
+}), an = () => k("object", {
+  type: Object
+}), un = () => O("integer", {
+  type: Number,
+  validator(e) {
+    const r = en(e);
+    return r === !1 && _(`integer - "${e}" is not an integer`), r;
+  }
+}), ln = () => O("symbol", {
+  validator(e) {
+    const r = typeof e == "symbol";
+    return r === !1 && _(`symbol - invalid value "${e}"`), r;
+  }
+}), cn = () => Object.defineProperty(
+  {
+    type: null,
+    validator(e) {
+      const r = e === null;
+      return r === !1 && _("nullable - value should be null"), r;
+    }
+  },
+  "_vueTypes_name",
+  { value: "nullable" }
+);
+function fn(e, r = "custom validation failed") {
+  if (typeof e != "function")
+    throw new TypeError(
+      "[VueTypes error]: You must provide a function as argument"
+    );
+  return O(e.name || "<<anonymous function>>", {
+    type: null,
+    validator(i) {
+      const n = e(i);
+      return n || _(`${this._vueTypes_name} - ${r}`), n;
+    }
+  });
+}
+function dn(e) {
+  if (!ne(e))
+    throw new TypeError(
+      "[VueTypes error]: You must provide an array as argument."
+    );
+  const r = `oneOf - value should be one of "${e.map((n) => typeof n == "symbol" ? n.toString() : n).join('", "')}".`, i = {
+    validator(n) {
+      const t = e.indexOf(n) !== -1;
+      return t || _(r), t;
+    }
+  };
+  if (e.indexOf(null) === -1) {
+    const n = e.reduce(
+      (t, o) => {
+        if (o != null) {
+          const s = o.constructor;
+          t.indexOf(s) === -1 && t.push(s);
+        }
+        return t;
+      },
+      []
+    );
+    n.length > 0 && (i.type = n);
+  }
+  return O("oneOf", i);
+}
+function gn(e) {
+  if (!ne(e))
+    throw new TypeError(
+      "[VueTypes error]: You must provide an array as argument"
+    );
+  let r = !1, i = !1, n = [];
+  for (let o = 0; o < e.length; o += 1) {
+    const s = e[o];
+    if (St(s)) {
+      if (re(s.validator) && (r = !0), ke(s, "oneOf") && s.type) {
+        n = n.concat(s.type);
+        continue;
+      }
+      if (ke(s, "nullable")) {
+        i = !0;
+        continue;
+      }
+      if (s.type === !0 || !s.type) {
+        _('oneOfType - invalid usage of "true" and "null" as types.');
+        continue;
+      }
+      n = n.concat(s.type);
+    } else
+      n.push(s);
+  }
+  n = n.filter((o, s) => n.indexOf(o) === s);
+  const t = i === !1 && n.length > 0 ? n : null;
+  return r ? O("oneOfType", {
+    type: t,
+    validator(o) {
+      const s = [], a = e.some((u) => {
+        const c = J(u, o, !0);
+        return typeof c == "string" && s.push(c), c === !0;
+      });
+      return a || _(
+        `oneOfType - provided value does not match any of the ${s.length} passed-in validators:
+${ue(s.join(`
+`))}`
+      ), a;
+    }
+  }) : O("oneOfType", {
+    type: t
+  });
+}
+function hn(e) {
+  return O("arrayOf", {
+    type: Array,
+    validator(r) {
+      let i = "";
+      const n = r.every((t) => (i = J(e, t, !0), i === !0));
+      return n || _(`arrayOf - value validation error:
+${ue(i)}`), n;
+    }
+  });
+}
+function mn(e) {
+  return O("instanceOf", {
+    type: e
+  });
+}
+function yn(e) {
+  return O("objectOf", {
+    type: Object,
+    validator(r) {
+      let i = "";
+      if (!V(r))
+        return !1;
+      const n = Object.keys(r).every((t) => (i = J(e, r[t], !0), i === !0));
+      return n || _(`objectOf - value validation error:
+${ue(i)}`), n;
+    }
+  });
+}
+function pn(e) {
+  const r = Object.keys(e), i = r.filter((t) => {
+    var o;
+    return !!((o = e[t]) != null && o.required);
+  }), n = O("shape", {
+    type: Object,
+    validator(t) {
+      if (!V(t))
+        return !1;
+      const o = Object.keys(t);
+      if (i.length > 0 && i.some((s) => o.indexOf(s) === -1)) {
+        const s = i.filter(
+          (a) => o.indexOf(a) === -1
+        );
+        return s.length === 1 ? _(`shape - required property "${s[0]}" is not defined.`) : _(
+          `shape - required properties "${s.join(
+            '", "'
+          )}" are not defined.`
+        ), !1;
+      }
+      return o.every((s) => {
+        if (r.indexOf(s) === -1)
+          return this._vueTypes_isLoose === !0 ? !0 : (_(
+            `shape - shape definition does not include a "${s}" property. Allowed keys: "${r.join(
+              '", "'
+            )}".`
+          ), !1);
+        const a = e[s], u = J(a, t[s], !0);
+        return typeof u == "string" && _(`shape - "${s}" property validation error:
+ ${ue(u)}`), u === !0;
+      });
+    }
+  });
+  return Object.defineProperty(n, "_vueTypes_isLoose", {
+    writable: !0,
+    value: !1
+  }), Object.defineProperty(n, "loose", {
+    get() {
+      return this._vueTypes_isLoose = !0, this;
+    }
+  }), n;
+}
+var wn = Object.defineProperty, bn = (e, r, i) => r in e ? wn(e, r, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[r] = i, L = (e, r, i) => (bn(e, typeof r != "symbol" ? r + "" : r, i), i);
+const Cn = /* @__PURE__ */ (() => {
+  var e;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+    e = class {
+      static get any() {
+        return tn();
+      }
+      static get func() {
+        return nn().def(this.defaults.func);
+      }
+      static get bool() {
+        return this.defaults.bool === void 0 ? Je() : Je().def(this.defaults.bool);
+      }
+      static get string() {
+        return rn().def(this.defaults.string);
+      }
+      static get number() {
+        return on().def(this.defaults.number);
+      }
+      static get array() {
+        return sn().def(this.defaults.array);
+      }
+      static get object() {
+        return an().def(this.defaults.object);
+      }
+      static get integer() {
+        return un().def(this.defaults.integer);
+      }
+      static get symbol() {
+        return ln();
+      }
+      static get nullable() {
+        return cn();
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      static extend(...r) {
+        _(
+          "VueTypes.extend has been removed. Use the ES6+ method instead. See https://dwightjack.github.io/vue-types/advanced/extending-vue-types.html#extending-namespaced-validators-in-es6 for details."
+        );
+      }
+    }, L(e, "defaults", {}), L(e, "sensibleDefaults"), L(e, "config", qe), L(e, "custom", fn), L(e, "oneOf", dn), L(e, "instanceOf", mn), L(e, "oneOfType", gn), L(e, "arrayOf", hn), L(e, "objectOf", yn), L(e, "shape", pn), L(e, "utils", {
+      validate(r, i) {
+        return J(i, r, !0) === !0;
+      },
+      toType(r, i, n = !1) {
+        return n ? k(r, i) : O(r, i);
+      }
+    }), e
+  );
+})();
+function Nt(e = xt()) {
+  var r;
+  return r = class extends Cn {
+    static get sensibleDefaults() {
+      return { ...this.defaults };
+    }
+    static set sensibleDefaults(i) {
+      if (i === !1) {
+        this.defaults = {};
+        return;
+      }
+      if (i === !0) {
+        this.defaults = { ...e };
+        return;
+      }
+      this.defaults = { ...i };
+    }
+  }, L(r, "defaults", { ...e }), r;
+}
+class nr extends Nt() {
+}
+const vn = Nt({
+  func: void 0,
+  bool: void 0,
+  string: void 0,
+  number: void 0,
+  object: void 0,
+  integer: void 0
+});
+class se extends vn {
+  // a native-like validator that supports the `.validable` method
+  static get style() {
+    return k("style", {
+      type: [String, Object]
+    });
+  }
+  static get VNodeChild() {
+    return k("VNodeChild", {
+      type: void 0
+    });
+  }
+}
+var X = {}, de, Ye;
+function En() {
+  return Ye || (Ye = 1, de = function() {
+    return typeof Promise == "function" && Promise.prototype && Promise.prototype.then;
+  }), de;
+}
+var ge = {}, F = {}, Qe;
+function Y() {
+  if (Qe) return F;
+  Qe = 1;
+  let e;
+  const r = [
+    0,
+    // Not used
+    26,
+    44,
+    70,
+    100,
+    134,
+    172,
+    196,
+    242,
+    292,
+    346,
+    404,
+    466,
+    532,
+    581,
+    655,
+    733,
+    815,
+    901,
+    991,
+    1085,
+    1156,
+    1258,
+    1364,
+    1474,
+    1588,
+    1706,
+    1828,
+    1921,
+    2051,
+    2185,
+    2323,
+    2465,
+    2611,
+    2761,
+    2876,
+    3034,
+    3196,
+    3362,
+    3532,
+    3706
+  ];
+  return F.getSymbolSize = function(n) {
+    if (!n) throw new Error('"version" cannot be null or undefined');
+    if (n < 1 || n > 40) throw new Error('"version" should be in range from 1 to 40');
+    return n * 4 + 17;
+  }, F.getSymbolTotalCodewords = function(n) {
+    return r[n];
+  }, F.getBCHDigit = function(i) {
+    let n = 0;
+    for (; i !== 0; )
+      n++, i >>>= 1;
+    return n;
+  }, F.setToSJISFunction = function(n) {
+    if (typeof n != "function")
+      throw new Error('"toSJISFunc" is not a valid function.');
+    e = n;
+  }, F.isKanjiModeEnabled = function() {
+    return typeof e < "u";
+  }, F.toSJIS = function(n) {
+    return e(n);
+  }, F;
+}
+var he = {}, Ge;
+function Ue() {
+  return Ge || (Ge = 1, function(e) {
+    e.L = { bit: 1 }, e.M = { bit: 0 }, e.Q = { bit: 3 }, e.H = { bit: 2 };
+    function r(i) {
+      if (typeof i != "string")
+        throw new Error("Param is not a string");
+      switch (i.toLowerCase()) {
+        case "l":
+        case "low":
+          return e.L;
+        case "m":
+        case "medium":
+          return e.M;
+        case "q":
+        case "quartile":
+          return e.Q;
+        case "h":
+        case "high":
+          return e.H;
+        default:
+          throw new Error("Unknown EC Level: " + i);
+      }
+    }
+    e.isValid = function(n) {
+      return n && typeof n.bit < "u" && n.bit >= 0 && n.bit < 4;
+    }, e.from = function(n, t) {
+      if (e.isValid(n))
+        return n;
+      try {
+        return r(n);
+      } catch {
+        return t;
+      }
+    };
+  }(he)), he;
+}
+var me, We;
+function Tn() {
+  if (We) return me;
+  We = 1;
+  function e() {
+    this.buffer = [], this.length = 0;
+  }
+  return e.prototype = {
+    get: function(r) {
+      const i = Math.floor(r / 8);
+      return (this.buffer[i] >>> 7 - r % 8 & 1) === 1;
+    },
+    put: function(r, i) {
+      for (let n = 0; n < i; n++)
+        this.putBit((r >>> i - n - 1 & 1) === 1);
+    },
+    getLengthInBits: function() {
+      return this.length;
+    },
+    putBit: function(r) {
+      const i = Math.floor(this.length / 8);
+      this.buffer.length <= i && this.buffer.push(0), r && (this.buffer[i] |= 128 >>> this.length % 8), this.length++;
+    }
+  }, me = e, me;
+}
+var ye, xe;
+function Bn() {
+  if (xe) return ye;
+  xe = 1;
+  function e(r) {
+    if (!r || r < 1)
+      throw new Error("BitMatrix size must be defined and greater than 0");
+    this.size = r, this.data = new Uint8Array(r * r), this.reservedBit = new Uint8Array(r * r);
+  }
+  return e.prototype.set = function(r, i, n, t) {
+    const o = r * this.size + i;
+    this.data[o] = n, t && (this.reservedBit[o] = !0);
+  }, e.prototype.get = function(r, i) {
+    return this.data[r * this.size + i];
+  }, e.prototype.xor = function(r, i, n) {
+    this.data[r * this.size + i] ^= n;
+  }, e.prototype.isReserved = function(r, i) {
+    return this.reservedBit[r * this.size + i];
+  }, ye = e, ye;
+}
+var pe = {}, Xe;
+function An() {
+  return Xe || (Xe = 1, function(e) {
+    const r = Y().getSymbolSize;
+    e.getRowColCoords = function(n) {
+      if (n === 1) return [];
+      const t = Math.floor(n / 7) + 2, o = r(n), s = o === 145 ? 26 : Math.ceil((o - 13) / (2 * t - 2)) * 2, a = [o - 7];
+      for (let u = 1; u < t - 1; u++)
+        a[u] = a[u - 1] - s;
+      return a.push(6), a.reverse();
+    }, e.getPositions = function(n) {
+      const t = [], o = e.getRowColCoords(n), s = o.length;
+      for (let a = 0; a < s; a++)
+        for (let u = 0; u < s; u++)
+          a === 0 && u === 0 || // top-left
+          a === 0 && u === s - 1 || // bottom-left
+          a === s - 1 && u === 0 || t.push([o[a], o[u]]);
+      return t;
+    };
+  }(pe)), pe;
+}
+var we = {}, Ze;
+function Rn() {
+  if (Ze) return we;
+  Ze = 1;
+  const e = Y().getSymbolSize, r = 7;
+  return we.getPositions = function(n) {
+    const t = e(n);
+    return [
+      // top-left
+      [0, 0],
+      // top-right
+      [t - r, 0],
+      // bottom-left
+      [0, t - r]
+    ];
+  }, we;
+}
+var be = {}, et;
+function Sn() {
+  return et || (et = 1, function(e) {
+    e.Patterns = {
+      PATTERN000: 0,
+      PATTERN001: 1,
+      PATTERN010: 2,
+      PATTERN011: 3,
+      PATTERN100: 4,
+      PATTERN101: 5,
+      PATTERN110: 6,
+      PATTERN111: 7
+    };
+    const r = {
+      N1: 3,
+      N2: 3,
+      N3: 40,
+      N4: 10
+    };
+    e.isValid = function(t) {
+      return t != null && t !== "" && !isNaN(t) && t >= 0 && t <= 7;
+    }, e.from = function(t) {
+      return e.isValid(t) ? parseInt(t, 10) : void 0;
+    }, e.getPenaltyN1 = function(t) {
+      const o = t.size;
+      let s = 0, a = 0, u = 0, c = null, m = null;
+      for (let B = 0; B < o; B++) {
+        a = u = 0, c = m = null;
+        for (let b = 0; b < o; b++) {
+          let g = t.get(B, b);
+          g === c ? a++ : (a >= 5 && (s += r.N1 + (a - 5)), c = g, a = 1), g = t.get(b, B), g === m ? u++ : (u >= 5 && (s += r.N1 + (u - 5)), m = g, u = 1);
+        }
+        a >= 5 && (s += r.N1 + (a - 5)), u >= 5 && (s += r.N1 + (u - 5));
+      }
+      return s;
+    }, e.getPenaltyN2 = function(t) {
+      const o = t.size;
+      let s = 0;
+      for (let a = 0; a < o - 1; a++)
+        for (let u = 0; u < o - 1; u++) {
+          const c = t.get(a, u) + t.get(a, u + 1) + t.get(a + 1, u) + t.get(a + 1, u + 1);
+          (c === 4 || c === 0) && s++;
+        }
+      return s * r.N2;
+    }, e.getPenaltyN3 = function(t) {
+      const o = t.size;
+      let s = 0, a = 0, u = 0;
+      for (let c = 0; c < o; c++) {
+        a = u = 0;
+        for (let m = 0; m < o; m++)
+          a = a << 1 & 2047 | t.get(c, m), m >= 10 && (a === 1488 || a === 93) && s++, u = u << 1 & 2047 | t.get(m, c), m >= 10 && (u === 1488 || u === 93) && s++;
+      }
+      return s * r.N3;
+    }, e.getPenaltyN4 = function(t) {
+      let o = 0;
+      const s = t.data.length;
+      for (let u = 0; u < s; u++) o += t.data[u];
+      return Math.abs(Math.ceil(o * 100 / s / 5) - 10) * r.N4;
+    };
+    function i(n, t, o) {
+      switch (n) {
+        case e.Patterns.PATTERN000:
+          return (t + o) % 2 === 0;
+        case e.Patterns.PATTERN001:
+          return t % 2 === 0;
+        case e.Patterns.PATTERN010:
+          return o % 3 === 0;
+        case e.Patterns.PATTERN011:
+          return (t + o) % 3 === 0;
+        case e.Patterns.PATTERN100:
+          return (Math.floor(t / 2) + Math.floor(o / 3)) % 2 === 0;
+        case e.Patterns.PATTERN101:
+          return t * o % 2 + t * o % 3 === 0;
+        case e.Patterns.PATTERN110:
+          return (t * o % 2 + t * o % 3) % 2 === 0;
+        case e.Patterns.PATTERN111:
+          return (t * o % 3 + (t + o) % 2) % 2 === 0;
+        default:
+          throw new Error("bad maskPattern:" + n);
+      }
+    }
+    e.applyMask = function(t, o) {
+      const s = o.size;
+      for (let a = 0; a < s; a++)
+        for (let u = 0; u < s; u++)
+          o.isReserved(u, a) || o.xor(u, a, i(t, u, a));
+    }, e.getBestMask = function(t, o) {
+      const s = Object.keys(e.Patterns).length;
+      let a = 0, u = 1 / 0;
+      for (let c = 0; c < s; c++) {
+        o(c), e.applyMask(c, t);
+        const m = e.getPenaltyN1(t) + e.getPenaltyN2(t) + e.getPenaltyN3(t) + e.getPenaltyN4(t);
+        e.applyMask(c, t), m < u && (u = m, a = c);
+      }
+      return a;
+    };
+  }(be)), be;
+}
+var ae = {}, tt;
+function It() {
+  if (tt) return ae;
+  tt = 1;
+  const e = Ue(), r = [
+    // L  M  Q  H
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    1,
+    2,
+    2,
+    4,
+    1,
+    2,
+    4,
+    4,
+    2,
+    4,
+    4,
+    4,
+    2,
+    4,
+    6,
+    5,
+    2,
+    4,
+    6,
+    6,
+    2,
+    5,
+    8,
+    8,
+    4,
+    5,
+    8,
+    8,
+    4,
+    5,
+    8,
+    11,
+    4,
+    8,
+    10,
+    11,
+    4,
+    9,
+    12,
+    16,
+    4,
+    9,
+    16,
+    16,
+    6,
+    10,
+    12,
+    18,
+    6,
+    10,
+    17,
+    16,
+    6,
+    11,
+    16,
+    19,
+    6,
+    13,
+    18,
+    21,
+    7,
+    14,
+    21,
+    25,
+    8,
+    16,
+    20,
+    25,
+    8,
+    17,
+    23,
+    25,
+    9,
+    17,
+    23,
+    34,
+    9,
+    18,
+    25,
+    30,
+    10,
+    20,
+    27,
+    32,
+    12,
+    21,
+    29,
+    35,
+    12,
+    23,
+    34,
+    37,
+    12,
+    25,
+    34,
+    40,
+    13,
+    26,
+    35,
+    42,
+    14,
+    28,
+    38,
+    45,
+    15,
+    29,
+    40,
+    48,
+    16,
+    31,
+    43,
+    51,
+    17,
+    33,
+    45,
+    54,
+    18,
+    35,
+    48,
+    57,
+    19,
+    37,
+    51,
+    60,
+    19,
+    38,
+    53,
+    63,
+    20,
+    40,
+    56,
+    66,
+    21,
+    43,
+    59,
+    70,
+    22,
+    45,
+    62,
+    74,
+    24,
+    47,
+    65,
+    77,
+    25,
+    49,
+    68,
+    81
+  ], i = [
+    // L  M  Q  H
+    7,
+    10,
+    13,
+    17,
+    10,
+    16,
+    22,
+    28,
+    15,
+    26,
+    36,
+    44,
+    20,
+    36,
+    52,
+    64,
+    26,
+    48,
+    72,
+    88,
+    36,
+    64,
+    96,
+    112,
+    40,
+    72,
+    108,
+    130,
+    48,
+    88,
+    132,
+    156,
+    60,
+    110,
+    160,
+    192,
+    72,
+    130,
+    192,
+    224,
+    80,
+    150,
+    224,
+    264,
+    96,
+    176,
+    260,
+    308,
+    104,
+    198,
+    288,
+    352,
+    120,
+    216,
+    320,
+    384,
+    132,
+    240,
+    360,
+    432,
+    144,
+    280,
+    408,
+    480,
+    168,
+    308,
+    448,
+    532,
+    180,
+    338,
+    504,
+    588,
+    196,
+    364,
+    546,
+    650,
+    224,
+    416,
+    600,
+    700,
+    224,
+    442,
+    644,
+    750,
+    252,
+    476,
+    690,
+    816,
+    270,
+    504,
+    750,
+    900,
+    300,
+    560,
+    810,
+    960,
+    312,
+    588,
+    870,
+    1050,
+    336,
+    644,
+    952,
+    1110,
+    360,
+    700,
+    1020,
+    1200,
+    390,
+    728,
+    1050,
+    1260,
+    420,
+    784,
+    1140,
+    1350,
+    450,
+    812,
+    1200,
+    1440,
+    480,
+    868,
+    1290,
+    1530,
+    510,
+    924,
+    1350,
+    1620,
+    540,
+    980,
+    1440,
+    1710,
+    570,
+    1036,
+    1530,
+    1800,
+    570,
+    1064,
+    1590,
+    1890,
+    600,
+    1120,
+    1680,
+    1980,
+    630,
+    1204,
+    1770,
+    2100,
+    660,
+    1260,
+    1860,
+    2220,
+    720,
+    1316,
+    1950,
+    2310,
+    750,
+    1372,
+    2040,
+    2430
+  ];
+  return ae.getBlocksCount = function(t, o) {
+    switch (o) {
+      case e.L:
+        return r[(t - 1) * 4 + 0];
+      case e.M:
+        return r[(t - 1) * 4 + 1];
+      case e.Q:
+        return r[(t - 1) * 4 + 2];
+      case e.H:
+        return r[(t - 1) * 4 + 3];
+      default:
+        return;
+    }
+  }, ae.getTotalCodewordsCount = function(t, o) {
+    switch (o) {
+      case e.L:
+        return i[(t - 1) * 4 + 0];
+      case e.M:
+        return i[(t - 1) * 4 + 1];
+      case e.Q:
+        return i[(t - 1) * 4 + 2];
+      case e.H:
+        return i[(t - 1) * 4 + 3];
+      default:
+        return;
+    }
+  }, ae;
+}
+var Ce = {}, Z = {}, nt;
+function Pn() {
+  if (nt) return Z;
+  nt = 1;
+  const e = new Uint8Array(512), r = new Uint8Array(256);
+  return function() {
+    let n = 1;
+    for (let t = 0; t < 255; t++)
+      e[t] = n, r[n] = t, n <<= 1, n & 256 && (n ^= 285);
+    for (let t = 255; t < 512; t++)
+      e[t] = e[t - 255];
+  }(), Z.log = function(n) {
+    if (n < 1) throw new Error("log(" + n + ")");
+    return r[n];
+  }, Z.exp = function(n) {
+    return e[n];
+  }, Z.mul = function(n, t) {
+    return n === 0 || t === 0 ? 0 : e[r[n] + r[t]];
+  }, Z;
+}
+var rt;
+function Nn() {
+  return rt || (rt = 1, function(e) {
+    const r = Pn();
+    e.mul = function(n, t) {
+      const o = new Uint8Array(n.length + t.length - 1);
+      for (let s = 0; s < n.length; s++)
+        for (let a = 0; a < t.length; a++)
+          o[s + a] ^= r.mul(n[s], t[a]);
+      return o;
+    }, e.mod = function(n, t) {
+      let o = new Uint8Array(n);
+      for (; o.length - t.length >= 0; ) {
+        const s = o[0];
+        for (let u = 0; u < t.length; u++)
+          o[u] ^= r.mul(t[u], s);
+        let a = 0;
+        for (; a < o.length && o[a] === 0; ) a++;
+        o = o.slice(a);
+      }
+      return o;
+    }, e.generateECPolynomial = function(n) {
+      let t = new Uint8Array([1]);
+      for (let o = 0; o < n; o++)
+        t = e.mul(t, new Uint8Array([1, r.exp(o)]));
+      return t;
+    };
+  }(Ce)), Ce;
+}
+var ve, ot;
+function In() {
+  if (ot) return ve;
+  ot = 1;
+  const e = Nn();
+  function r(i) {
+    this.genPoly = void 0, this.degree = i, this.degree && this.initialize(this.degree);
+  }
+  return r.prototype.initialize = function(n) {
+    this.degree = n, this.genPoly = e.generateECPolynomial(this.degree);
+  }, r.prototype.encode = function(n) {
+    if (!this.genPoly)
+      throw new Error("Encoder not initialized");
+    const t = new Uint8Array(n.length + this.degree);
+    t.set(n);
+    const o = e.mod(t, this.genPoly), s = this.degree - o.length;
+    if (s > 0) {
+      const a = new Uint8Array(this.degree);
+      return a.set(o, s), a;
+    }
+    return o;
+  }, ve = r, ve;
+}
+var Ee = {}, Te = {}, Be = {}, it;
+function _t() {
+  return it || (it = 1, Be.isValid = function(r) {
+    return !isNaN(r) && r >= 1 && r <= 40;
+  }), Be;
+}
+var q = {}, st;
+function Mt() {
+  if (st) return q;
+  st = 1;
+  const e = "[0-9]+", r = "[A-Z $%*+\\-./:]+";
+  let i = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
+  i = i.replace(/u/g, "\\u");
+  const n = "(?:(?![A-Z0-9 $%*+\\-./:]|" + i + `)(?:.|[\r
+]))+`;
+  q.KANJI = new RegExp(i, "g"), q.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g"), q.BYTE = new RegExp(n, "g"), q.NUMERIC = new RegExp(e, "g"), q.ALPHANUMERIC = new RegExp(r, "g");
+  const t = new RegExp("^" + i + "$"), o = new RegExp("^" + e + "$"), s = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+  return q.testKanji = function(u) {
+    return t.test(u);
+  }, q.testNumeric = function(u) {
+    return o.test(u);
+  }, q.testAlphanumeric = function(u) {
+    return s.test(u);
+  }, q;
+}
+var at;
+function Q() {
+  return at || (at = 1, function(e) {
+    const r = _t(), i = Mt();
+    e.NUMERIC = {
+      id: "Numeric",
+      bit: 1,
+      ccBits: [10, 12, 14]
+    }, e.ALPHANUMERIC = {
+      id: "Alphanumeric",
+      bit: 2,
+      ccBits: [9, 11, 13]
+    }, e.BYTE = {
+      id: "Byte",
+      bit: 4,
+      ccBits: [8, 16, 16]
+    }, e.KANJI = {
+      id: "Kanji",
+      bit: 8,
+      ccBits: [8, 10, 12]
+    }, e.MIXED = {
+      bit: -1
+    }, e.getCharCountIndicator = function(o, s) {
+      if (!o.ccBits) throw new Error("Invalid mode: " + o);
+      if (!r.isValid(s))
+        throw new Error("Invalid version: " + s);
+      return s >= 1 && s < 10 ? o.ccBits[0] : s < 27 ? o.ccBits[1] : o.ccBits[2];
+    }, e.getBestModeForData = function(o) {
+      return i.testNumeric(o) ? e.NUMERIC : i.testAlphanumeric(o) ? e.ALPHANUMERIC : i.testKanji(o) ? e.KANJI : e.BYTE;
+    }, e.toString = function(o) {
+      if (o && o.id) return o.id;
+      throw new Error("Invalid mode");
+    }, e.isValid = function(o) {
+      return o && o.bit && o.ccBits;
+    };
+    function n(t) {
+      if (typeof t != "string")
+        throw new Error("Param is not a string");
+      switch (t.toLowerCase()) {
+        case "numeric":
+          return e.NUMERIC;
+        case "alphanumeric":
+          return e.ALPHANUMERIC;
+        case "kanji":
+          return e.KANJI;
+        case "byte":
+          return e.BYTE;
+        default:
+          throw new Error("Unknown mode: " + t);
+      }
+    }
+    e.from = function(o, s) {
+      if (e.isValid(o))
+        return o;
+      try {
+        return n(o);
+      } catch {
+        return s;
+      }
+    };
+  }(Te)), Te;
+}
+var ut;
+function _n() {
+  return ut || (ut = 1, function(e) {
+    const r = Y(), i = It(), n = Ue(), t = Q(), o = _t(), s = 7973, a = r.getBCHDigit(s);
+    function u(b, g, N) {
+      for (let l = 1; l <= 40; l++)
+        if (g <= e.getCapacity(l, N, b))
+          return l;
+    }
+    function c(b, g) {
+      return t.getCharCountIndicator(b, g) + 4;
+    }
+    function m(b, g) {
+      let N = 0;
+      return b.forEach(function(l) {
+        const A = c(l.mode, g);
+        N += A + l.getBitsLength();
+      }), N;
+    }
+    function B(b, g) {
+      for (let N = 1; N <= 40; N++)
+        if (m(b, N) <= e.getCapacity(N, g, t.MIXED))
+          return N;
+    }
+    e.from = function(g, N) {
+      return o.isValid(g) ? parseInt(g, 10) : N;
+    }, e.getCapacity = function(g, N, l) {
+      if (!o.isValid(g))
+        throw new Error("Invalid QR Code version");
+      typeof l > "u" && (l = t.BYTE);
+      const A = r.getSymbolTotalCodewords(g), f = i.getTotalCodewordsCount(g, N), C = (A - f) * 8;
+      if (l === t.MIXED) return C;
+      const p = C - c(l, g);
+      switch (l) {
+        case t.NUMERIC:
+          return Math.floor(p / 10 * 3);
+        case t.ALPHANUMERIC:
+          return Math.floor(p / 11 * 2);
+        case t.KANJI:
+          return Math.floor(p / 13);
+        case t.BYTE:
+        default:
+          return Math.floor(p / 8);
+      }
+    }, e.getBestVersionForData = function(g, N) {
+      let l;
+      const A = n.from(N, n.M);
+      if (Array.isArray(g)) {
+        if (g.length > 1)
+          return B(g, A);
+        if (g.length === 0)
+          return 1;
+        l = g[0];
+      } else
+        l = g;
+      return u(l.mode, l.getLength(), A);
+    }, e.getEncodedBits = function(g) {
+      if (!o.isValid(g) || g < 7)
+        throw new Error("Invalid QR Code version");
+      let N = g << 12;
+      for (; r.getBCHDigit(N) - a >= 0; )
+        N ^= s << r.getBCHDigit(N) - a;
+      return g << 12 | N;
+    };
+  }(Ee)), Ee;
+}
+var Ae = {}, lt;
+function Mn() {
+  if (lt) return Ae;
+  lt = 1;
+  const e = Y(), r = 1335, i = 21522, n = e.getBCHDigit(r);
+  return Ae.getEncodedBits = function(o, s) {
+    const a = o.bit << 3 | s;
+    let u = a << 10;
+    for (; e.getBCHDigit(u) - n >= 0; )
+      u ^= r << e.getBCHDigit(u) - n;
+    return (a << 10 | u) ^ i;
+  }, Ae;
+}
+var Re = {}, Se, ct;
+function Ln() {
+  if (ct) return Se;
+  ct = 1;
+  const e = Q();
+  function r(i) {
+    this.mode = e.NUMERIC, this.data = i.toString();
+  }
+  return r.getBitsLength = function(n) {
+    return 10 * Math.floor(n / 3) + (n % 3 ? n % 3 * 3 + 1 : 0);
+  }, r.prototype.getLength = function() {
+    return this.data.length;
+  }, r.prototype.getBitsLength = function() {
+    return r.getBitsLength(this.data.length);
+  }, r.prototype.write = function(n) {
+    let t, o, s;
+    for (t = 0; t + 3 <= this.data.length; t += 3)
+      o = this.data.substr(t, 3), s = parseInt(o, 10), n.put(s, 10);
+    const a = this.data.length - t;
+    a > 0 && (o = this.data.substr(t), s = parseInt(o, 10), n.put(s, a * 3 + 1));
+  }, Se = r, Se;
+}
+var Pe, ft;
+function On() {
+  if (ft) return Pe;
+  ft = 1;
+  const e = Q(), r = [
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    " ",
+    "$",
+    "%",
+    "*",
+    "+",
+    "-",
+    ".",
+    "/",
+    ":"
+  ];
+  function i(n) {
+    this.mode = e.ALPHANUMERIC, this.data = n;
+  }
+  return i.getBitsLength = function(t) {
+    return 11 * Math.floor(t / 2) + 6 * (t % 2);
+  }, i.prototype.getLength = function() {
+    return this.data.length;
+  }, i.prototype.getBitsLength = function() {
+    return i.getBitsLength(this.data.length);
+  }, i.prototype.write = function(t) {
+    let o;
+    for (o = 0; o + 2 <= this.data.length; o += 2) {
+      let s = r.indexOf(this.data[o]) * 45;
+      s += r.indexOf(this.data[o + 1]), t.put(s, 11);
+    }
+    this.data.length % 2 && t.put(r.indexOf(this.data[o]), 6);
+  }, Pe = i, Pe;
+}
+var Ne, dt;
+function Dn() {
+  if (dt) return Ne;
+  dt = 1;
+  const e = Q();
+  function r(i) {
+    this.mode = e.BYTE, typeof i == "string" ? this.data = new TextEncoder().encode(i) : this.data = new Uint8Array(i);
+  }
+  return r.getBitsLength = function(n) {
+    return n * 8;
+  }, r.prototype.getLength = function() {
+    return this.data.length;
+  }, r.prototype.getBitsLength = function() {
+    return r.getBitsLength(this.data.length);
+  }, r.prototype.write = function(i) {
+    for (let n = 0, t = this.data.length; n < t; n++)
+      i.put(this.data[n], 8);
+  }, Ne = r, Ne;
+}
+var Ie, gt;
+function qn() {
+  if (gt) return Ie;
+  gt = 1;
+  const e = Q(), r = Y();
+  function i(n) {
+    this.mode = e.KANJI, this.data = n;
+  }
+  return i.getBitsLength = function(t) {
+    return t * 13;
+  }, i.prototype.getLength = function() {
+    return this.data.length;
+  }, i.prototype.getBitsLength = function() {
+    return i.getBitsLength(this.data.length);
+  }, i.prototype.write = function(n) {
+    let t;
+    for (t = 0; t < this.data.length; t++) {
+      let o = r.toSJIS(this.data[t]);
+      if (o >= 33088 && o <= 40956)
+        o -= 33088;
+      else if (o >= 57408 && o <= 60351)
+        o -= 49472;
+      else
+        throw new Error(
+          "Invalid SJIS character: " + this.data[t] + `
+Make sure your charset is UTF-8`
+        );
+      o = (o >>> 8 & 255) * 192 + (o & 255), n.put(o, 13);
+    }
+  }, Ie = i, Ie;
+}
+var _e = { exports: {} }, ht;
+function kn() {
+  return ht || (ht = 1, function(e) {
+    var r = {
+      single_source_shortest_paths: function(i, n, t) {
+        var o = {}, s = {};
+        s[n] = 0;
+        var a = r.PriorityQueue.make();
+        a.push(n, 0);
+        for (var u, c, m, B, b, g, N, l, A; !a.empty(); ) {
+          u = a.pop(), c = u.value, B = u.cost, b = i[c] || {};
+          for (m in b)
+            b.hasOwnProperty(m) && (g = b[m], N = B + g, l = s[m], A = typeof s[m] > "u", (A || l > N) && (s[m] = N, a.push(m, N), o[m] = c));
+        }
+        if (typeof t < "u" && typeof s[t] > "u") {
+          var f = ["Could not find a path from ", n, " to ", t, "."].join("");
+          throw new Error(f);
+        }
+        return o;
+      },
+      extract_shortest_path_from_predecessor_list: function(i, n) {
+        for (var t = [], o = n; o; )
+          t.push(o), i[o], o = i[o];
+        return t.reverse(), t;
+      },
+      find_path: function(i, n, t) {
+        var o = r.single_source_shortest_paths(i, n, t);
+        return r.extract_shortest_path_from_predecessor_list(
+          o,
+          t
+        );
+      },
+      /**
+       * A very naive priority queue implementation.
+       */
+      PriorityQueue: {
+        make: function(i) {
+          var n = r.PriorityQueue, t = {}, o;
+          i = i || {};
+          for (o in n)
+            n.hasOwnProperty(o) && (t[o] = n[o]);
+          return t.queue = [], t.sorter = i.sorter || n.default_sorter, t;
+        },
+        default_sorter: function(i, n) {
+          return i.cost - n.cost;
+        },
+        /**
+         * Add a new item to the queue and ensure the highest priority element
+         * is at the front of the queue.
+         */
+        push: function(i, n) {
+          var t = { value: i, cost: n };
+          this.queue.push(t), this.queue.sort(this.sorter);
+        },
+        /**
+         * Return the highest priority element in the queue.
+         */
+        pop: function() {
+          return this.queue.shift();
+        },
+        empty: function() {
+          return this.queue.length === 0;
+        }
+      }
+    };
+    e.exports = r;
+  }(_e)), _e.exports;
+}
+var mt;
+function Un() {
+  return mt || (mt = 1, function(e) {
+    const r = Q(), i = Ln(), n = On(), t = Dn(), o = qn(), s = Mt(), a = Y(), u = kn();
+    function c(f) {
+      return unescape(encodeURIComponent(f)).length;
+    }
+    function m(f, C, p) {
+      const w = [];
+      let I;
+      for (; (I = f.exec(p)) !== null; )
+        w.push({
+          data: I[0],
+          index: I.index,
+          mode: C,
+          length: I[0].length
+        });
+      return w;
+    }
+    function B(f) {
+      const C = m(s.NUMERIC, r.NUMERIC, f), p = m(s.ALPHANUMERIC, r.ALPHANUMERIC, f);
+      let w, I;
+      return a.isKanjiModeEnabled() ? (w = m(s.BYTE, r.BYTE, f), I = m(s.KANJI, r.KANJI, f)) : (w = m(s.BYTE_KANJI, r.BYTE, f), I = []), C.concat(p, w, I).sort(function(T, R) {
+        return T.index - R.index;
+      }).map(function(T) {
+        return {
+          data: T.data,
+          mode: T.mode,
+          length: T.length
+        };
+      });
+    }
+    function b(f, C) {
+      switch (C) {
+        case r.NUMERIC:
+          return i.getBitsLength(f);
+        case r.ALPHANUMERIC:
+          return n.getBitsLength(f);
+        case r.KANJI:
+          return o.getBitsLength(f);
+        case r.BYTE:
+          return t.getBitsLength(f);
+      }
+    }
+    function g(f) {
+      return f.reduce(function(C, p) {
+        const w = C.length - 1 >= 0 ? C[C.length - 1] : null;
+        return w && w.mode === p.mode ? (C[C.length - 1].data += p.data, C) : (C.push(p), C);
+      }, []);
+    }
+    function N(f) {
+      const C = [];
+      for (let p = 0; p < f.length; p++) {
+        const w = f[p];
+        switch (w.mode) {
+          case r.NUMERIC:
+            C.push([
+              w,
+              { data: w.data, mode: r.ALPHANUMERIC, length: w.length },
+              { data: w.data, mode: r.BYTE, length: w.length }
+            ]);
+            break;
+          case r.ALPHANUMERIC:
+            C.push([
+              w,
+              { data: w.data, mode: r.BYTE, length: w.length }
+            ]);
+            break;
+          case r.KANJI:
+            C.push([
+              w,
+              { data: w.data, mode: r.BYTE, length: c(w.data) }
+            ]);
+            break;
+          case r.BYTE:
+            C.push([
+              { data: w.data, mode: r.BYTE, length: c(w.data) }
+            ]);
+        }
+      }
+      return C;
+    }
+    function l(f, C) {
+      const p = {}, w = { start: {} };
+      let I = ["start"];
+      for (let y = 0; y < f.length; y++) {
+        const T = f[y], R = [];
+        for (let d = 0; d < T.length; d++) {
+          const v = T[d], E = "" + y + d;
+          R.push(E), p[E] = { node: v, lastCount: 0 }, w[E] = {};
+          for (let S = 0; S < I.length; S++) {
+            const h = I[S];
+            p[h] && p[h].node.mode === v.mode ? (w[h][E] = b(p[h].lastCount + v.length, v.mode) - b(p[h].lastCount, v.mode), p[h].lastCount += v.length) : (p[h] && (p[h].lastCount = v.length), w[h][E] = b(v.length, v.mode) + 4 + r.getCharCountIndicator(v.mode, C));
+          }
+        }
+        I = R;
+      }
+      for (let y = 0; y < I.length; y++)
+        w[I[y]].end = 0;
+      return { map: w, table: p };
+    }
+    function A(f, C) {
+      let p;
+      const w = r.getBestModeForData(f);
+      if (p = r.from(C, w), p !== r.BYTE && p.bit < w.bit)
+        throw new Error('"' + f + '" cannot be encoded with mode ' + r.toString(p) + `.
+ Suggested mode is: ` + r.toString(w));
+      switch (p === r.KANJI && !a.isKanjiModeEnabled() && (p = r.BYTE), p) {
+        case r.NUMERIC:
+          return new i(f);
+        case r.ALPHANUMERIC:
+          return new n(f);
+        case r.KANJI:
+          return new o(f);
+        case r.BYTE:
+          return new t(f);
+      }
+    }
+    e.fromArray = function(C) {
+      return C.reduce(function(p, w) {
+        return typeof w == "string" ? p.push(A(w, null)) : w.data && p.push(A(w.data, w.mode)), p;
+      }, []);
+    }, e.fromString = function(C, p) {
+      const w = B(C, a.isKanjiModeEnabled()), I = N(w), y = l(I, p), T = u.find_path(y.map, "start", "end"), R = [];
+      for (let d = 1; d < T.length - 1; d++)
+        R.push(y.table[T[d]].node);
+      return e.fromArray(g(R));
+    }, e.rawSplit = function(C) {
+      return e.fromArray(
+        B(C, a.isKanjiModeEnabled())
+      );
+    };
+  }(Re)), Re;
+}
+var yt;
+function jn() {
+  if (yt) return ge;
+  yt = 1;
+  const e = Y(), r = Ue(), i = Tn(), n = Bn(), t = An(), o = Rn(), s = Sn(), a = It(), u = In(), c = _n(), m = Mn(), B = Q(), b = Un();
+  function g(y, T) {
+    const R = y.size, d = o.getPositions(T);
+    for (let v = 0; v < d.length; v++) {
+      const E = d[v][0], S = d[v][1];
+      for (let h = -1; h <= 7; h++)
+        if (!(E + h <= -1 || R <= E + h))
+          for (let P = -1; P <= 7; P++)
+            S + P <= -1 || R <= S + P || (h >= 0 && h <= 6 && (P === 0 || P === 6) || P >= 0 && P <= 6 && (h === 0 || h === 6) || h >= 2 && h <= 4 && P >= 2 && P <= 4 ? y.set(E + h, S + P, !0, !0) : y.set(E + h, S + P, !1, !0));
+    }
+  }
+  function N(y) {
+    const T = y.size;
+    for (let R = 8; R < T - 8; R++) {
+      const d = R % 2 === 0;
+      y.set(R, 6, d, !0), y.set(6, R, d, !0);
+    }
+  }
+  function l(y, T) {
+    const R = t.getPositions(T);
+    for (let d = 0; d < R.length; d++) {
+      const v = R[d][0], E = R[d][1];
+      for (let S = -2; S <= 2; S++)
+        for (let h = -2; h <= 2; h++)
+          S === -2 || S === 2 || h === -2 || h === 2 || S === 0 && h === 0 ? y.set(v + S, E + h, !0, !0) : y.set(v + S, E + h, !1, !0);
+    }
+  }
+  function A(y, T) {
+    const R = y.size, d = c.getEncodedBits(T);
+    let v, E, S;
+    for (let h = 0; h < 18; h++)
+      v = Math.floor(h / 3), E = h % 3 + R - 8 - 3, S = (d >> h & 1) === 1, y.set(v, E, S, !0), y.set(E, v, S, !0);
+  }
+  function f(y, T, R) {
+    const d = y.size, v = m.getEncodedBits(T, R);
+    let E, S;
+    for (E = 0; E < 15; E++)
+      S = (v >> E & 1) === 1, E < 6 ? y.set(E, 8, S, !0) : E < 8 ? y.set(E + 1, 8, S, !0) : y.set(d - 15 + E, 8, S, !0), E < 8 ? y.set(8, d - E - 1, S, !0) : E < 9 ? y.set(8, 15 - E - 1 + 1, S, !0) : y.set(8, 15 - E - 1, S, !0);
+    y.set(d - 8, 8, 1, !0);
+  }
+  function C(y, T) {
+    const R = y.size;
+    let d = -1, v = R - 1, E = 7, S = 0;
+    for (let h = R - 1; h > 0; h -= 2)
+      for (h === 6 && h--; ; ) {
+        for (let P = 0; P < 2; P++)
+          if (!y.isReserved(v, h - P)) {
+            let D = !1;
+            S < T.length && (D = (T[S] >>> E & 1) === 1), y.set(v, h - P, D), E--, E === -1 && (S++, E = 7);
+          }
+        if (v += d, v < 0 || R <= v) {
+          v -= d, d = -d;
+          break;
+        }
+      }
+  }
+  function p(y, T, R) {
+    const d = new i();
+    R.forEach(function(P) {
+      d.put(P.mode.bit, 4), d.put(P.getLength(), B.getCharCountIndicator(P.mode, y)), P.write(d);
+    });
+    const v = e.getSymbolTotalCodewords(y), E = a.getTotalCodewordsCount(y, T), S = (v - E) * 8;
+    for (d.getLengthInBits() + 4 <= S && d.put(0, 4); d.getLengthInBits() % 8 !== 0; )
+      d.putBit(0);
+    const h = (S - d.getLengthInBits()) / 8;
+    for (let P = 0; P < h; P++)
+      d.put(P % 2 ? 17 : 236, 8);
+    return w(d, y, T);
+  }
+  function w(y, T, R) {
+    const d = e.getSymbolTotalCodewords(T), v = a.getTotalCodewordsCount(T, R), E = d - v, S = a.getBlocksCount(T, R), h = d % S, P = S - h, D = Math.floor(d / S), z = Math.floor(E / S), $ = z + 1, H = D - z, oe = new u(H);
+    let G = 0;
+    const ie = new Array(S), je = new Array(S);
+    let le = 0;
+    const Ot = new Uint8Array(y.buffer);
+    for (let W = 0; W < S; W++) {
+      const fe = W < P ? z : $;
+      ie[W] = Ot.slice(G, G + fe), je[W] = oe.encode(ie[W]), G += fe, le = Math.max(le, fe);
+    }
+    const ce = new Uint8Array(d);
+    let Fe = 0, U, j;
+    for (U = 0; U < le; U++)
+      for (j = 0; j < S; j++)
+        U < ie[j].length && (ce[Fe++] = ie[j][U]);
+    for (U = 0; U < H; U++)
+      for (j = 0; j < S; j++)
+        ce[Fe++] = je[j][U];
+    return ce;
+  }
+  function I(y, T, R, d) {
+    let v;
+    if (Array.isArray(y))
+      v = b.fromArray(y);
+    else if (typeof y == "string") {
+      let D = T;
+      if (!D) {
+        const z = b.rawSplit(y);
+        D = c.getBestVersionForData(z, R);
+      }
+      v = b.fromString(y, D || 40);
+    } else
+      throw new Error("Invalid data");
+    const E = c.getBestVersionForData(v, R);
+    if (!E)
+      throw new Error("The amount of data is too big to be stored in a QR Code");
+    if (!T)
+      T = E;
+    else if (T < E)
+      throw new Error(
+        `
+The chosen QR Code version cannot contain this amount of data.
+Minimum version required to store current data is: ` + E + `.
+`
+      );
+    const S = p(T, R, v), h = e.getSymbolSize(T), P = new n(h);
+    return g(P, T), N(P), l(P, T), f(P, R, 0), T >= 7 && A(P, T), C(P, S), isNaN(d) && (d = s.getBestMask(
+      P,
+      f.bind(null, P, R)
+    )), s.applyMask(d, P), f(P, R, d), {
+      modules: P,
+      version: T,
+      errorCorrectionLevel: R,
+      maskPattern: d,
+      segments: v
+    };
+  }
+  return ge.create = function(T, R) {
+    if (typeof T > "u" || T === "")
+      throw new Error("No input text");
+    let d = r.M, v, E;
+    return typeof R < "u" && (d = r.from(R.errorCorrectionLevel, r.M), v = c.from(R.version), E = s.from(R.maskPattern), R.toSJISFunc && e.setToSJISFunction(R.toSJISFunc)), I(T, v, d, E);
+  }, ge;
+}
+var Me = {}, Le = {}, pt;
+function Lt() {
+  return pt || (pt = 1, function(e) {
+    function r(i) {
+      if (typeof i == "number" && (i = i.toString()), typeof i != "string")
+        throw new Error("Color should be defined as hex string");
+      let n = i.slice().replace("#", "").split("");
+      if (n.length < 3 || n.length === 5 || n.length > 8)
+        throw new Error("Invalid hex color: " + i);
+      (n.length === 3 || n.length === 4) && (n = Array.prototype.concat.apply([], n.map(function(o) {
+        return [o, o];
+      }))), n.length === 6 && n.push("F", "F");
+      const t = parseInt(n.join(""), 16);
+      return {
+        r: t >> 24 & 255,
+        g: t >> 16 & 255,
+        b: t >> 8 & 255,
+        a: t & 255,
+        hex: "#" + n.slice(0, 6).join("")
+      };
+    }
+    e.getOptions = function(n) {
+      n || (n = {}), n.color || (n.color = {});
+      const t = typeof n.margin > "u" || n.margin === null || n.margin < 0 ? 4 : n.margin, o = n.width && n.width >= 21 ? n.width : void 0, s = n.scale || 4;
+      return {
+        width: o,
+        scale: o ? 4 : s,
+        margin: t,
+        color: {
+          dark: r(n.color.dark || "#000000ff"),
+          light: r(n.color.light || "#ffffffff")
+        },
+        type: n.type,
+        rendererOpts: n.rendererOpts || {}
+      };
+    }, e.getScale = function(n, t) {
+      return t.width && t.width >= n + t.margin * 2 ? t.width / (n + t.margin * 2) : t.scale;
+    }, e.getImageWidth = function(n, t) {
+      const o = e.getScale(n, t);
+      return Math.floor((n + t.margin * 2) * o);
+    }, e.qrToImageData = function(n, t, o) {
+      const s = t.modules.size, a = t.modules.data, u = e.getScale(s, o), c = Math.floor((s + o.margin * 2) * u), m = o.margin * u, B = [o.color.light, o.color.dark];
+      for (let b = 0; b < c; b++)
+        for (let g = 0; g < c; g++) {
+          let N = (b * c + g) * 4, l = o.color.light;
+          if (b >= m && g >= m && b < c - m && g < c - m) {
+            const A = Math.floor((b - m) / u), f = Math.floor((g - m) / u);
+            l = B[a[A * s + f] ? 1 : 0];
+          }
+          n[N++] = l.r, n[N++] = l.g, n[N++] = l.b, n[N] = l.a;
+        }
+    };
+  }(Le)), Le;
+}
+var wt;
+function Fn() {
+  return wt || (wt = 1, function(e) {
+    const r = Lt();
+    function i(t, o, s) {
+      t.clearRect(0, 0, o.width, o.height), o.style || (o.style = {}), o.height = s, o.width = s, o.style.height = s + "px", o.style.width = s + "px";
+    }
+    function n() {
+      try {
+        return document.createElement("canvas");
+      } catch {
+        throw new Error("You need to specify a canvas element");
+      }
+    }
+    e.render = function(o, s, a) {
+      let u = a, c = s;
+      typeof u > "u" && (!s || !s.getContext) && (u = s, s = void 0), s || (c = n()), u = r.getOptions(u);
+      const m = r.getImageWidth(o.modules.size, u), B = c.getContext("2d"), b = B.createImageData(m, m);
+      return r.qrToImageData(b.data, o, u), i(B, c, m), B.putImageData(b, 0, 0), c;
+    }, e.renderToDataURL = function(o, s, a) {
+      let u = a;
+      typeof u > "u" && (!s || !s.getContext) && (u = s, s = void 0), u || (u = {});
+      const c = e.render(o, s, u), m = u.type || "image/png", B = u.rendererOpts || {};
+      return c.toDataURL(m, B.quality);
+    };
+  }(Me)), Me;
+}
+var Oe = {}, bt;
+function Vn() {
+  if (bt) return Oe;
+  bt = 1;
+  const e = Lt();
+  function r(t, o) {
+    const s = t.a / 255, a = o + '="' + t.hex + '"';
+    return s < 1 ? a + " " + o + '-opacity="' + s.toFixed(2).slice(1) + '"' : a;
+  }
+  function i(t, o, s) {
+    let a = t + o;
+    return typeof s < "u" && (a += " " + s), a;
+  }
+  function n(t, o, s) {
+    let a = "", u = 0, c = !1, m = 0;
+    for (let B = 0; B < t.length; B++) {
+      const b = Math.floor(B % o), g = Math.floor(B / o);
+      !b && !c && (c = !0), t[B] ? (m++, B > 0 && b > 0 && t[B - 1] || (a += c ? i("M", b + s, 0.5 + g + s) : i("m", u, 0), u = 0, c = !1), b + 1 < o && t[B + 1] || (a += i("h", m), m = 0)) : u++;
+    }
+    return a;
+  }
+  return Oe.render = function(o, s, a) {
+    const u = e.getOptions(s), c = o.modules.size, m = o.modules.data, B = c + u.margin * 2, b = u.color.light.a ? "<path " + r(u.color.light, "fill") + ' d="M0 0h' + B + "v" + B + 'H0z"/>' : "", g = "<path " + r(u.color.dark, "stroke") + ' d="' + n(m, c, u.margin) + '"/>', N = 'viewBox="0 0 ' + B + " " + B + '"', A = '<svg xmlns="http://www.w3.org/2000/svg" ' + (u.width ? 'width="' + u.width + '" height="' + u.width + '" ' : "") + N + ' shape-rendering="crispEdges">' + b + g + `</svg>
+`;
+    return typeof a == "function" && a(null, A), A;
+  }, Oe;
+}
+var Ct;
+function zn() {
+  if (Ct) return X;
+  Ct = 1;
+  const e = En(), r = jn(), i = Fn(), n = Vn();
+  function t(o, s, a, u, c) {
+    const m = [].slice.call(arguments, 1), B = m.length, b = typeof m[B - 1] == "function";
+    if (!b && !e())
+      throw new Error("Callback required as last argument");
+    if (b) {
+      if (B < 2)
+        throw new Error("Too few arguments provided");
+      B === 2 ? (c = a, a = s, s = u = void 0) : B === 3 && (s.getContext && typeof c > "u" ? (c = u, u = void 0) : (c = u, u = a, a = s, s = void 0));
+    } else {
+      if (B < 1)
+        throw new Error("Too few arguments provided");
+      return B === 1 ? (a = s, s = u = void 0) : B === 2 && !s.getContext && (u = a, a = s, s = void 0), new Promise(function(g, N) {
+        try {
+          const l = r.create(a, u);
+          g(o(l, s, u));
+        } catch (l) {
+          N(l);
+        }
+      });
+    }
+    try {
+      const g = r.create(a, u);
+      c(null, o(g, s, u));
+    } catch (g) {
+      c(g);
+    }
+  }
+  return X.create = r.create, X.toCanvas = t.bind(null, i.render), X.toDataURL = t.bind(null, i.renderToDataURL), X.toString = t.bind(null, function(o, s, a) {
+    return n.render(o, a);
+  }), X;
+}
+var $n = zn();
+const Hn = /* @__PURE__ */ Kt($n), Kn = {
+  // img 或者 canvas,img不支持logo嵌套
+  tag: se.string.validate((e) => ["canvas", "img"].includes(e)).def("canvas"),
+  // 二维码内容
+  text: {
+    type: [String, Array],
+    default: null
+  },
+  // qrcode.js配置项
+  options: {
+    type: Object,
+    default: () => ({})
+  },
+  // 宽度
+  width: se.number.def(200),
+  // logo
+  logo: {
+    type: [String, Object],
+    default: () => ""
+  },
+  // 是否过期
+  disabled: se.bool.def(!1),
+  // 过期提示内容
+  disabledText: se.string.def("")
+}, Jn = /* @__PURE__ */ vt({
+  name: "SuQrcode",
+  props: Kn,
+  emits: ["done", "click", "disabled-click"],
+  setup(e, {
+    emit: r
+  }) {
+    const {
+      toCanvas: i,
+      toDataURL: n
+    } = Hn, t = ee(!0), o = ee(null), s = Ve(() => String(e.text)), a = Ve(() => ({
+      width: e.width + "px",
+      height: e.width + "px"
+    })), u = async () => {
+      await Ut();
+      const l = Et(e.options || {}, !0);
+      if (e.tag === "canvas") {
+        l.errorCorrectionLevel = l.errorCorrectionLevel || B(K(s));
+        const A = await m(K(s), l);
+        l.scale = e.width === 0 ? void 0 : e.width / A * 4;
+        const f = await i(K(o), K(s), l);
+        if (e.logo) {
+          const C = await c(f);
+          r("done", C), t.value = !1;
+        } else
+          r("done", f.toDataURL()), t.value = !1;
+      } else {
+        const A = await n(s.value, {
+          errorCorrectionLevel: "H",
+          width: e.width,
+          ...l
+        });
+        K(o).src = A, r("done", A), t.value = !1;
+      }
+    };
+    Dt(() => s.value, (l) => {
+      l && u();
+    }, {
+      deep: !0,
+      immediate: !0
+    });
+    const c = (l) => {
+      const A = l.width, f = Object.assign({
+        logoSize: 0.15,
+        bgColor: "#ffffff",
+        borderSize: 0.05,
+        crossOrigin: "anonymous",
+        borderRadius: 8,
+        logoRadius: 0
+      }, $e(e.logo) ? {} : e.logo), {
+        logoSize: C = 0.15,
+        bgColor: p = "#ffffff",
+        borderSize: w = 0.05,
+        crossOrigin: I = "anonymous",
+        borderRadius: y = 8,
+        logoRadius: T = 0
+      } = f, R = $e(e.logo) ? e.logo : e.logo.src, d = A * C, v = A * (1 - C) / 2, E = A * (C + w), S = A * (1 - C - w) / 2, h = l.getContext("2d");
+      if (!h) return;
+      b(h)(S, S, E, E, y), h.fillStyle = p, h.fill();
+      const P = new Image();
+      (I || T) && P.setAttribute("crossOrigin", I), P.src = R;
+      const D = ($) => {
+        h.drawImage($, v, v, d, d);
+      }, z = ($) => {
+        const H = document.createElement("canvas");
+        H.width = v + d, H.height = v + d;
+        const oe = H.getContext("2d");
+        if (!oe || !h || (oe.drawImage($, v, v, d, d), b(h)(v, v, d, d, T), !h)) return;
+        const G = h.createPattern(H, "no-repeat");
+        G && (h.fillStyle = G, h.fill());
+      };
+      return new Promise(($) => {
+        P.onload = () => {
+          T ? z(P) : D(P), $(l.toDataURL());
+        };
+      });
+    }, m = async (l, A) => {
+      const f = document.createElement("canvas");
+      return await i(f, l, A), f.width;
+    }, B = (l) => l.length > 36 ? "M" : l.length > 16 ? "Q" : "H", b = (l) => (A, f, C, p, w) => {
+      const I = Math.min(C, p);
+      return w > I / 2 && (w = I / 2), l.beginPath(), l.moveTo(A + w, f), l.arcTo(A + C, f, A + C, f + p, w), l.arcTo(A + C, f + p, A, f + p, w), l.arcTo(A, f + p, A, f, w), l.arcTo(A, f, A + C, f, w), l.closePath(), l;
+    }, g = () => {
+      r("click");
+    }, N = () => {
+      r("disabled-click");
+    };
+    return () => M(De, null, [qt(M("div", {
+      class: "qrcode relative inline-block",
+      style: K(a)
+    }, [e.tag === "canvas" ? M("canvas", {
+      ref: o,
+      onClick: g
+    }, null) : M("img", {
+      ref: o,
+      onClick: g
+    }, null), e.disabled && M("div", {
+      class: "qrcode--disabled absolute top-0 left-0 flex w-full h-full items-center justify-center",
+      onClick: N
+    }, [M("div", {
+      class: "absolute top-[50%] left-[50%] font-bold"
+    }, [M(Jt, {
+      class: "cursor-pointer",
+      icon: "refresh-right",
+      width: "30",
+      color: "var(--el-color-primary)"
+    }, null), M("div", null, [e.disabledText])])])]), [[kt("loading"), K(t)]])]);
+  }
+}), Yn = Gt(Jn);
+function Qn(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !zt(e);
+}
+const Gn = {
+  name: "PdaApp"
+}, rr = /* @__PURE__ */ vt({
+  ...Gn,
+  setup(e) {
+    const r = Yt(), i = Wt(), {
+      t: n
+    } = $t(), t = "/upms/v1/app-manage", o = ee(null), s = ee({}), a = [
+      {
+        type: "checkbox",
+        width: 45,
+        align: "center"
+      },
+      // { field: 'trayTypeCode', width: 110, formatter: ['formatDict', 'SU.TRAY.TYPE'] },
+      {
+        field: "appVersion",
+        width: 110
+      },
+      {
+        field: "buildNo",
+        width: 130
+      },
+      {
+        field: "versionInfo",
+        miWidth: 200
+      },
+      {
+        field: "enabled",
+        title: "message.status",
+        width: 90,
+        formatter: ({
+          row: l
+        }) => l.enabled === "1" ? n("message.appupper") : n("message.applower")
+      },
+      {
+        field: "creationDate",
+        width: 140
+      },
+      {
+        field: "operate",
+        width: 260,
+        fixed: "right",
+        slots: {
+          default: ({
+            row: l
+          }) => {
+            const A = l.enabled === "1" ? "applower" : "appupper", f = l.enabled === "1" ? "warning" : "primary", C = l.enabled === "1" ? "ri-inbox-archive-line" : "ri-inbox-unarchive-line";
+            return l.enabled !== "1" ? [M(x("ut-button"), {
+              content: A,
+              icon: C,
+              status: f,
+              onTap: () => u(l)
+            }, null)] : [
+              M(De, null, [M("div", {
+                style: "display: flex; justify-content: space-between;"
+              }, [M(x("ut-button"), {
+                content: A,
+                icon: C,
+                status: f,
+                onTap: () => u(l)
+              }, null), M(x("el-popover"), {
+                placement: "left"
+              }, {
+                default: () => [M(De, null, [M(Yn, {
+                  text: r + "/ufil/" + l.downloadUrl
+                }, null)])],
+                reference: () => {
+                  let p;
+                  return M(x("el-button"), {
+                    type: "success"
+                  }, Qn(p = n("message.btn.scan")) ? p : {
+                    default: () => [p]
+                  });
+                }
+              })])])
+              // <el-popover
+              //   placement="left"
+              //   v-slots={{
+              //     reference: () => <el-button type="primary">外网下载</el-button>
+              //   }}
+              // >
+              //   <>
+              //     <SuQrcode text={'http://jemes.uzuo.cn/gateway/ufil/' + row.downloadUrl} />
+              //   </>
+              // </el-popover>
+            ];
+          }
+        }
+      }
+    ], u = async (l) => {
+      const A = Et(l, !0);
+      A.enabled = l.enabled === "1" ? "0" : "1", await Ht(Qt().put(t, A)), o.value.refreshData();
+    }, c = (l) => {
+      l === "add" && b(), l === "del" && g();
+    }, m = [{
+      field: "appVersion",
+      required: !0
+    }, {
+      field: "buildNo",
+      required: !0
+    }, {
+      field: "versionInfo",
+      required: !0,
+      itemRender: i.renderTextarea()
+    }, {
+      field: "downloadUrl",
+      required: !1,
+      itemRender: {
+        name: "#upload",
+        props: {
+          baseUrl: r
+        }
+      }
+    }], B = ee(!1), b = () => {
+      s.value = {}, B.value = !0;
+    }, g = () => {
+      o.value.getInstance().commitProxy("delete");
+    }, N = () => {
+      o.value.refreshData();
+    };
+    return (l, A) => {
+      const f = x("ut-grid"), C = x("ut-modal-form");
+      return ze(), jt("div", null, [M(f, {
+        ref_key: "xgrid",
+        ref: o,
+        columns: a,
+        url: t,
+        mode: "form",
+        onButtonClick: c
+      }, null, 512), B.value ? (ze(), Ft(C, {
+        key: 0,
+        record: s.value,
+        items: m,
+        width: 360,
+        height: 340,
+        title: l.$t("message.title.appAdd"),
+        url: t,
+        "data-status": "add",
+        onClose: A[0] || (A[0] = (p) => B.value = !1),
+        onConfirm: N
+      }, null, 8, ["record", "title"])) : Vt("", !0)]);
+    };
+  }
+});
+export {
+  rr as default
+};