@cling-se/widget 0.14.4 → 0.14.6

package/dist/AnswerModal-CsA2pl2P.js

@@ -0,0 +1,3874 @@
+import { m as ft } from "./mapFormMixin-DlFcgwhm.js";
+import { at as It, O as Tt, h as Et, au as Mt, av as Rt, aw as $t, n as ot, ax as Dt, g as yt, e as At, M as Bt } from "./main-CQBEuZk9.js";
+import { a as nt } from "./anime.es-BrPTThYb.js";
+import { a as Ut } from "./vuex.esm-DKGl8mcw.js";
+import { C as Lt } from "./CFormField--m3PvQuT.js";
+/*!
+ * vue-qrcode v1.0.2
+ * https://fengyuanchen.github.io/vue-qrcode
+ *
+ * Copyright 2018-present Chen Fengyuan
+ * Released under the MIT license
+ *
+ * Date: 2020-01-18T06:04:33.222Z
+ */
+function gt() {
+  throw new Error("Dynamic requires are not currently supported by rollup-plugin-commonjs");
+}
+function Nt(v, r) {
+  return r = { exports: {} }, v(r, r.exports), r.exports;
+}
+var xt = Nt(function(v, r) {
+  (function(n) {
+    v.exports = n();
+  })(function() {
+    return (/* @__PURE__ */ function() {
+      function n(g, u, h) {
+        function d(s, f) {
+          if (!u[s]) {
+            if (!g[s]) {
+              var a = typeof gt == "function" && gt;
+              if (!f && a)
+                return a(s, !0);
+              if (l)
+                return l(s, !0);
+              var y = new Error("Cannot find module '" + s + "'");
+              throw y.code = "MODULE_NOT_FOUND", y;
+            }
+            var x = u[s] = { exports: {} };
+            g[s][0].call(x.exports, function(b) {
+              var A = g[s][1][b];
+              return d(A || b);
+            }, x, x.exports, n, g, u, h);
+          }
+          return u[s].exports;
+        }
+        for (var l = typeof gt == "function" && gt, i = 0; i < h.length; i++)
+          d(h[i]);
+        return d;
+      }
+      return n;
+    }())({ 1: [function(n, g, u) {
+      g.exports = function() {
+        return typeof Promise == "function" && Promise.prototype && Promise.prototype.then;
+      };
+    }, {}], 2: [function(n, g, u) {
+      var h = n("./utils").getSymbolSize;
+      u.getRowColCoords = function(l) {
+        if (l === 1)
+          return [];
+        for (var i = Math.floor(l / 7) + 2, s = h(l), f = s === 145 ? 26 : Math.ceil((s - 13) / (2 * i - 2)) * 2, a = [s - 7], y = 1; y < i - 1; y++)
+          a[y] = a[y - 1] - f;
+        return a.push(6), a.reverse();
+      }, u.getPositions = function(l) {
+        for (var i = [], s = u.getRowColCoords(l), f = s.length, a = 0; a < f; a++)
+          for (var y = 0; y < f; y++)
+            a === 0 && y === 0 || // top-left
+            a === 0 && y === f - 1 || // bottom-left
+            a === f - 1 && y === 0 || i.push([s[a], s[y]]);
+        return i;
+      };
+    }, { "./utils": 21 }], 3: [function(n, g, u) {
+      var h = n("./mode"), d = [
+        "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 l(i) {
+        this.mode = h.ALPHANUMERIC, this.data = i;
+      }
+      l.getBitsLength = function(s) {
+        return 11 * Math.floor(s / 2) + 6 * (s % 2);
+      }, l.prototype.getLength = function() {
+        return this.data.length;
+      }, l.prototype.getBitsLength = function() {
+        return l.getBitsLength(this.data.length);
+      }, l.prototype.write = function(s) {
+        var f;
+        for (f = 0; f + 2 <= this.data.length; f += 2) {
+          var a = d.indexOf(this.data[f]) * 45;
+          a += d.indexOf(this.data[f + 1]), s.put(a, 11);
+        }
+        this.data.length % 2 && s.put(d.indexOf(this.data[f]), 6);
+      }, g.exports = l;
+    }, { "./mode": 14 }], 4: [function(n, g, u) {
+      function h() {
+        this.buffer = [], this.length = 0;
+      }
+      h.prototype = {
+        get: function(d) {
+          var l = Math.floor(d / 8);
+          return (this.buffer[l] >>> 7 - d % 8 & 1) === 1;
+        },
+        put: function(d, l) {
+          for (var i = 0; i < l; i++)
+            this.putBit((d >>> l - i - 1 & 1) === 1);
+        },
+        getLengthInBits: function() {
+          return this.length;
+        },
+        putBit: function(d) {
+          var l = Math.floor(this.length / 8);
+          this.buffer.length <= l && this.buffer.push(0), d && (this.buffer[l] |= 128 >>> this.length % 8), this.length++;
+        }
+      }, g.exports = h;
+    }, {}], 5: [function(n, g, u) {
+      var h = n("../utils/buffer");
+      function d(l) {
+        if (!l || l < 1)
+          throw new Error("BitMatrix size must be defined and greater than 0");
+        this.size = l, this.data = h.alloc(l * l), this.reservedBit = h.alloc(l * l);
+      }
+      d.prototype.set = function(l, i, s, f) {
+        var a = l * this.size + i;
+        this.data[a] = s, f && (this.reservedBit[a] = !0);
+      }, d.prototype.get = function(l, i) {
+        return this.data[l * this.size + i];
+      }, d.prototype.xor = function(l, i, s) {
+        this.data[l * this.size + i] ^= s;
+      }, d.prototype.isReserved = function(l, i) {
+        return this.reservedBit[l * this.size + i];
+      }, g.exports = d;
+    }, { "../utils/buffer": 28 }], 6: [function(n, g, u) {
+      var h = n("../utils/buffer"), d = n("./mode");
+      function l(i) {
+        this.mode = d.BYTE, this.data = h.from(i);
+      }
+      l.getBitsLength = function(s) {
+        return s * 8;
+      }, l.prototype.getLength = function() {
+        return this.data.length;
+      }, l.prototype.getBitsLength = function() {
+        return l.getBitsLength(this.data.length);
+      }, l.prototype.write = function(i) {
+        for (var s = 0, f = this.data.length; s < f; s++)
+          i.put(this.data[s], 8);
+      }, g.exports = l;
+    }, { "../utils/buffer": 28, "./mode": 14 }], 7: [function(n, g, u) {
+      var h = n("./error-correction-level"), d = [
+        // 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
+      ], l = [
+        // 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
+      ];
+      u.getBlocksCount = function(s, f) {
+        switch (f) {
+          case h.L:
+            return d[(s - 1) * 4 + 0];
+          case h.M:
+            return d[(s - 1) * 4 + 1];
+          case h.Q:
+            return d[(s - 1) * 4 + 2];
+          case h.H:
+            return d[(s - 1) * 4 + 3];
+          default:
+            return;
+        }
+      }, u.getTotalCodewordsCount = function(s, f) {
+        switch (f) {
+          case h.L:
+            return l[(s - 1) * 4 + 0];
+          case h.M:
+            return l[(s - 1) * 4 + 1];
+          case h.Q:
+            return l[(s - 1) * 4 + 2];
+          case h.H:
+            return l[(s - 1) * 4 + 3];
+          default:
+            return;
+        }
+      };
+    }, { "./error-correction-level": 8 }], 8: [function(n, g, u) {
+      u.L = { bit: 1 }, u.M = { bit: 0 }, u.Q = { bit: 3 }, u.H = { bit: 2 };
+      function h(d) {
+        if (typeof d != "string")
+          throw new Error("Param is not a string");
+        var l = d.toLowerCase();
+        switch (l) {
+          case "l":
+          case "low":
+            return u.L;
+          case "m":
+          case "medium":
+            return u.M;
+          case "q":
+          case "quartile":
+            return u.Q;
+          case "h":
+          case "high":
+            return u.H;
+          default:
+            throw new Error("Unknown EC Level: " + d);
+        }
+      }
+      u.isValid = function(l) {
+        return l && typeof l.bit < "u" && l.bit >= 0 && l.bit < 4;
+      }, u.from = function(l, i) {
+        if (u.isValid(l))
+          return l;
+        try {
+          return h(l);
+        } catch {
+          return i;
+        }
+      };
+    }, {}], 9: [function(n, g, u) {
+      var h = n("./utils").getSymbolSize, d = 7;
+      u.getPositions = function(i) {
+        var s = h(i);
+        return [
+          // top-left
+          [0, 0],
+          // top-right
+          [s - d, 0],
+          // bottom-left
+          [0, s - d]
+        ];
+      };
+    }, { "./utils": 21 }], 10: [function(n, g, u) {
+      var h = n("./utils"), d = 1335, l = 21522, i = h.getBCHDigit(d);
+      u.getEncodedBits = function(f, a) {
+        for (var y = f.bit << 3 | a, x = y << 10; h.getBCHDigit(x) - i >= 0; )
+          x ^= d << h.getBCHDigit(x) - i;
+        return (y << 10 | x) ^ l;
+      };
+    }, { "./utils": 21 }], 11: [function(n, g, u) {
+      var h = n("../utils/buffer"), d = h.alloc(512), l = h.alloc(256);
+      (function() {
+        for (var s = 1, f = 0; f < 255; f++)
+          d[f] = s, l[s] = f, s <<= 1, s & 256 && (s ^= 285);
+        for (f = 255; f < 512; f++)
+          d[f] = d[f - 255];
+      })(), u.log = function(s) {
+        if (s < 1)
+          throw new Error("log(" + s + ")");
+        return l[s];
+      }, u.exp = function(s) {
+        return d[s];
+      }, u.mul = function(s, f) {
+        return s === 0 || f === 0 ? 0 : d[l[s] + l[f]];
+      };
+    }, { "../utils/buffer": 28 }], 12: [function(n, g, u) {
+      var h = n("./mode"), d = n("./utils");
+      function l(i) {
+        this.mode = h.KANJI, this.data = i;
+      }
+      l.getBitsLength = function(s) {
+        return s * 13;
+      }, l.prototype.getLength = function() {
+        return this.data.length;
+      }, l.prototype.getBitsLength = function() {
+        return l.getBitsLength(this.data.length);
+      }, l.prototype.write = function(i) {
+        var s;
+        for (s = 0; s < this.data.length; s++) {
+          var f = d.toSJIS(this.data[s]);
+          if (f >= 33088 && f <= 40956)
+            f -= 33088;
+          else if (f >= 57408 && f <= 60351)
+            f -= 49472;
+          else
+            throw new Error(
+              "Invalid SJIS character: " + this.data[s] + `
+Make sure your charset is UTF-8`
+            );
+          f = (f >>> 8 & 255) * 192 + (f & 255), i.put(f, 13);
+        }
+      }, g.exports = l;
+    }, { "./mode": 14, "./utils": 21 }], 13: [function(n, g, u) {
+      u.Patterns = {
+        PATTERN000: 0,
+        PATTERN001: 1,
+        PATTERN010: 2,
+        PATTERN011: 3,
+        PATTERN100: 4,
+        PATTERN101: 5,
+        PATTERN110: 6,
+        PATTERN111: 7
+      };
+      var h = {
+        N1: 3,
+        N2: 3,
+        N3: 40,
+        N4: 10
+      };
+      u.isValid = function(i) {
+        return i != null && i !== "" && !isNaN(i) && i >= 0 && i <= 7;
+      }, u.from = function(i) {
+        return u.isValid(i) ? parseInt(i, 10) : void 0;
+      }, u.getPenaltyN1 = function(i) {
+        for (var s = i.size, f = 0, a = 0, y = 0, x = null, b = null, A = 0; A < s; A++) {
+          a = y = 0, x = b = null;
+          for (var F = 0; F < s; F++) {
+            var M = i.get(A, F);
+            M === x ? a++ : (a >= 5 && (f += h.N1 + (a - 5)), x = M, a = 1), M = i.get(F, A), M === b ? y++ : (y >= 5 && (f += h.N1 + (y - 5)), b = M, y = 1);
+          }
+          a >= 5 && (f += h.N1 + (a - 5)), y >= 5 && (f += h.N1 + (y - 5));
+        }
+        return f;
+      }, u.getPenaltyN2 = function(i) {
+        for (var s = i.size, f = 0, a = 0; a < s - 1; a++)
+          for (var y = 0; y < s - 1; y++) {
+            var x = i.get(a, y) + i.get(a, y + 1) + i.get(a + 1, y) + i.get(a + 1, y + 1);
+            (x === 4 || x === 0) && f++;
+          }
+        return f * h.N2;
+      }, u.getPenaltyN3 = function(i) {
+        for (var s = i.size, f = 0, a = 0, y = 0, x = 0; x < s; x++) {
+          a = y = 0;
+          for (var b = 0; b < s; b++)
+            a = a << 1 & 2047 | i.get(x, b), b >= 10 && (a === 1488 || a === 93) && f++, y = y << 1 & 2047 | i.get(b, x), b >= 10 && (y === 1488 || y === 93) && f++;
+        }
+        return f * h.N3;
+      }, u.getPenaltyN4 = function(i) {
+        for (var s = 0, f = i.data.length, a = 0; a < f; a++)
+          s += i.data[a];
+        var y = Math.abs(Math.ceil(s * 100 / f / 5) - 10);
+        return y * h.N4;
+      };
+      function d(l, i, s) {
+        switch (l) {
+          case u.Patterns.PATTERN000:
+            return (i + s) % 2 === 0;
+          case u.Patterns.PATTERN001:
+            return i % 2 === 0;
+          case u.Patterns.PATTERN010:
+            return s % 3 === 0;
+          case u.Patterns.PATTERN011:
+            return (i + s) % 3 === 0;
+          case u.Patterns.PATTERN100:
+            return (Math.floor(i / 2) + Math.floor(s / 3)) % 2 === 0;
+          case u.Patterns.PATTERN101:
+            return i * s % 2 + i * s % 3 === 0;
+          case u.Patterns.PATTERN110:
+            return (i * s % 2 + i * s % 3) % 2 === 0;
+          case u.Patterns.PATTERN111:
+            return (i * s % 3 + (i + s) % 2) % 2 === 0;
+          default:
+            throw new Error("bad maskPattern:" + l);
+        }
+      }
+      u.applyMask = function(i, s) {
+        for (var f = s.size, a = 0; a < f; a++)
+          for (var y = 0; y < f; y++)
+            s.isReserved(y, a) || s.xor(y, a, d(i, y, a));
+      }, u.getBestMask = function(i, s) {
+        for (var f = Object.keys(u.Patterns).length, a = 0, y = 1 / 0, x = 0; x < f; x++) {
+          s(x), u.applyMask(x, i);
+          var b = u.getPenaltyN1(i) + u.getPenaltyN2(i) + u.getPenaltyN3(i) + u.getPenaltyN4(i);
+          u.applyMask(x, i), b < y && (y = b, a = x);
+        }
+        return a;
+      };
+    }, {}], 14: [function(n, g, u) {
+      var h = n("./version-check"), d = n("./regex");
+      u.NUMERIC = {
+        id: "Numeric",
+        bit: 1,
+        ccBits: [10, 12, 14]
+      }, u.ALPHANUMERIC = {
+        id: "Alphanumeric",
+        bit: 2,
+        ccBits: [9, 11, 13]
+      }, u.BYTE = {
+        id: "Byte",
+        bit: 4,
+        ccBits: [8, 16, 16]
+      }, u.KANJI = {
+        id: "Kanji",
+        bit: 8,
+        ccBits: [8, 10, 12]
+      }, u.MIXED = {
+        bit: -1
+      }, u.getCharCountIndicator = function(s, f) {
+        if (!s.ccBits)
+          throw new Error("Invalid mode: " + s);
+        if (!h.isValid(f))
+          throw new Error("Invalid version: " + f);
+        return f >= 1 && f < 10 ? s.ccBits[0] : f < 27 ? s.ccBits[1] : s.ccBits[2];
+      }, u.getBestModeForData = function(s) {
+        return d.testNumeric(s) ? u.NUMERIC : d.testAlphanumeric(s) ? u.ALPHANUMERIC : d.testKanji(s) ? u.KANJI : u.BYTE;
+      }, u.toString = function(s) {
+        if (s && s.id)
+          return s.id;
+        throw new Error("Invalid mode");
+      }, u.isValid = function(s) {
+        return s && s.bit && s.ccBits;
+      };
+      function l(i) {
+        if (typeof i != "string")
+          throw new Error("Param is not a string");
+        var s = i.toLowerCase();
+        switch (s) {
+          case "numeric":
+            return u.NUMERIC;
+          case "alphanumeric":
+            return u.ALPHANUMERIC;
+          case "kanji":
+            return u.KANJI;
+          case "byte":
+            return u.BYTE;
+          default:
+            throw new Error("Unknown mode: " + i);
+        }
+      }
+      u.from = function(s, f) {
+        if (u.isValid(s))
+          return s;
+        try {
+          return l(s);
+        } catch {
+          return f;
+        }
+      };
+    }, { "./regex": 19, "./version-check": 22 }], 15: [function(n, g, u) {
+      var h = n("./mode");
+      function d(l) {
+        this.mode = h.NUMERIC, this.data = l.toString();
+      }
+      d.getBitsLength = function(i) {
+        return 10 * Math.floor(i / 3) + (i % 3 ? i % 3 * 3 + 1 : 0);
+      }, d.prototype.getLength = function() {
+        return this.data.length;
+      }, d.prototype.getBitsLength = function() {
+        return d.getBitsLength(this.data.length);
+      }, d.prototype.write = function(i) {
+        var s, f, a;
+        for (s = 0; s + 3 <= this.data.length; s += 3)
+          f = this.data.substr(s, 3), a = parseInt(f, 10), i.put(a, 10);
+        var y = this.data.length - s;
+        y > 0 && (f = this.data.substr(s), a = parseInt(f, 10), i.put(a, y * 3 + 1));
+      }, g.exports = d;
+    }, { "./mode": 14 }], 16: [function(n, g, u) {
+      var h = n("../utils/buffer"), d = n("./galois-field");
+      u.mul = function(i, s) {
+        for (var f = h.alloc(i.length + s.length - 1), a = 0; a < i.length; a++)
+          for (var y = 0; y < s.length; y++)
+            f[a + y] ^= d.mul(i[a], s[y]);
+        return f;
+      }, u.mod = function(i, s) {
+        for (var f = h.from(i); f.length - s.length >= 0; ) {
+          for (var a = f[0], y = 0; y < s.length; y++)
+            f[y] ^= d.mul(s[y], a);
+          for (var x = 0; x < f.length && f[x] === 0; )
+            x++;
+          f = f.slice(x);
+        }
+        return f;
+      }, u.generateECPolynomial = function(i) {
+        for (var s = h.from([1]), f = 0; f < i; f++)
+          s = u.mul(s, [1, d.exp(f)]);
+        return s;
+      };
+    }, { "../utils/buffer": 28, "./galois-field": 11 }], 17: [function(n, g, u) {
+      var h = n("../utils/buffer"), d = n("./utils"), l = n("./error-correction-level"), i = n("./bit-buffer"), s = n("./bit-matrix"), f = n("./alignment-pattern"), a = n("./finder-pattern"), y = n("./mask-pattern"), x = n("./error-correction-code"), b = n("./reed-solomon-encoder"), A = n("./version"), F = n("./format-info"), M = n("./mode"), E = n("./segments"), B = n("isarray");
+      function I($, D) {
+        for (var U = $.size, R = a.getPositions(D), O = 0; O < R.length; O++)
+          for (var z = R[O][0], N = R[O][1], Y = -1; Y <= 7; Y++)
+            if (!(z + Y <= -1 || U <= z + Y))
+              for (var j = -1; j <= 7; j++)
+                N + j <= -1 || U <= N + j || (Y >= 0 && Y <= 6 && (j === 0 || j === 6) || j >= 0 && j <= 6 && (Y === 0 || Y === 6) || Y >= 2 && Y <= 4 && j >= 2 && j <= 4 ? $.set(z + Y, N + j, !0, !0) : $.set(z + Y, N + j, !1, !0));
+      }
+      function k($) {
+        for (var D = $.size, U = 8; U < D - 8; U++) {
+          var R = U % 2 === 0;
+          $.set(U, 6, R, !0), $.set(6, U, R, !0);
+        }
+      }
+      function _($, D) {
+        for (var U = f.getPositions(D), R = 0; R < U.length; R++)
+          for (var O = U[R][0], z = U[R][1], N = -2; N <= 2; N++)
+            for (var Y = -2; Y <= 2; Y++)
+              N === -2 || N === 2 || Y === -2 || Y === 2 || N === 0 && Y === 0 ? $.set(O + N, z + Y, !0, !0) : $.set(O + N, z + Y, !1, !0);
+      }
+      function m($, D) {
+        for (var U = $.size, R = A.getEncodedBits(D), O, z, N, Y = 0; Y < 18; Y++)
+          O = Math.floor(Y / 3), z = Y % 3 + U - 8 - 3, N = (R >> Y & 1) === 1, $.set(O, z, N, !0), $.set(z, O, N, !0);
+      }
+      function p($, D, U) {
+        var R = $.size, O = F.getEncodedBits(D, U), z, N;
+        for (z = 0; z < 15; z++)
+          N = (O >> z & 1) === 1, z < 6 ? $.set(z, 8, N, !0) : z < 8 ? $.set(z + 1, 8, N, !0) : $.set(R - 15 + z, 8, N, !0), z < 8 ? $.set(8, R - z - 1, N, !0) : z < 9 ? $.set(8, 15 - z - 1 + 1, N, !0) : $.set(8, 15 - z - 1, N, !0);
+        $.set(R - 8, 8, 1, !0);
+      }
+      function C($, D) {
+        for (var U = $.size, R = -1, O = U - 1, z = 7, N = 0, Y = U - 1; Y > 0; Y -= 2)
+          for (Y === 6 && Y--; ; ) {
+            for (var j = 0; j < 2; j++)
+              if (!$.isReserved(O, Y - j)) {
+                var et = !1;
+                N < D.length && (et = (D[N] >>> z & 1) === 1), $.set(O, Y - j, et), z--, z === -1 && (N++, z = 7);
+              }
+            if (O += R, O < 0 || U <= O) {
+              O -= R, R = -R;
+              break;
+            }
+          }
+      }
+      function T($, D, U) {
+        var R = new i();
+        U.forEach(function(et) {
+          R.put(et.mode.bit, 4), R.put(et.getLength(), M.getCharCountIndicator(et.mode, $)), et.write(R);
+        });
+        var O = d.getSymbolTotalCodewords($), z = x.getTotalCodewordsCount($, D), N = (O - z) * 8;
+        for (R.getLengthInBits() + 4 <= N && R.put(0, 4); R.getLengthInBits() % 8 !== 0; )
+          R.putBit(0);
+        for (var Y = (N - R.getLengthInBits()) / 8, j = 0; j < Y; j++)
+          R.put(j % 2 ? 17 : 236, 8);
+        return L(R, $, D);
+      }
+      function L($, D, U) {
+        for (var R = d.getSymbolTotalCodewords(D), O = x.getTotalCodewordsCount(D, U), z = R - O, N = x.getBlocksCount(D, U), Y = R % N, j = N - Y, et = Math.floor(R / N), X = Math.floor(z / N), mt = X + 1, J = et - X, q = new b(J), at = 0, it = new Array(N), st = new Array(N), ut = 0, vt = h.from($.buffer), rt = 0; rt < N; rt++) {
+          var ct = rt < j ? X : mt;
+          it[rt] = vt.slice(at, at + ct), st[rt] = q.encode(it[rt]), at += ct, ut = Math.max(ut, ct);
+        }
+        var lt = h.alloc(R), ht = 0, tt, Q;
+        for (tt = 0; tt < ut; tt++)
+          for (Q = 0; Q < N; Q++)
+            tt < it[Q].length && (lt[ht++] = it[Q][tt]);
+        for (tt = 0; tt < J; tt++)
+          for (Q = 0; Q < N; Q++)
+            lt[ht++] = st[Q][tt];
+        return lt;
+      }
+      function W($, D, U, R) {
+        var O;
+        if (B($))
+          O = E.fromArray($);
+        else if (typeof $ == "string") {
+          var z = D;
+          if (!z) {
+            var N = E.rawSplit($);
+            z = A.getBestVersionForData(
+              N,
+              U
+            );
+          }
+          O = E.fromString($, z || 40);
+        } else
+          throw new Error("Invalid data");
+        var Y = A.getBestVersionForData(
+          O,
+          U
+        );
+        if (!Y)
+          throw new Error("The amount of data is too big to be stored in a QR Code");
+        if (!D)
+          D = Y;
+        else if (D < Y)
+          throw new Error(
+            `
+The chosen QR Code version cannot contain this amount of data.
+Minimum version required to store current data is: ` + Y + `.
+`
+          );
+        var j = T(D, U, O), et = d.getSymbolSize(D), X = new s(et);
+        return I(X, D), k(X), _(X, D), p(X, U, 0), D >= 7 && m(X, D), C(X, j), isNaN(R) && (R = y.getBestMask(
+          X,
+          p.bind(null, X, U)
+        )), y.applyMask(R, X), p(X, U, R), {
+          modules: X,
+          version: D,
+          errorCorrectionLevel: U,
+          maskPattern: R,
+          segments: O
+        };
+      }
+      u.create = function(D, U) {
+        if (typeof D > "u" || D === "")
+          throw new Error("No input text");
+        var R = l.M, O, z;
+        return typeof U < "u" && (R = l.from(U.errorCorrectionLevel, l.M), O = A.from(U.version), z = y.from(U.maskPattern), U.toSJISFunc && d.setToSJISFunction(U.toSJISFunc)), W(D, O, R, z);
+      };
+    }, { "../utils/buffer": 28, "./alignment-pattern": 2, "./bit-buffer": 4, "./bit-matrix": 5, "./error-correction-code": 7, "./error-correction-level": 8, "./finder-pattern": 9, "./format-info": 10, "./mask-pattern": 13, "./mode": 14, "./reed-solomon-encoder": 18, "./segments": 20, "./utils": 21, "./version": 23, isarray: 33 }], 18: [function(n, g, u) {
+      var h = n("../utils/buffer"), d = n("./polynomial"), l = n("buffer").Buffer;
+      function i(s) {
+        this.genPoly = void 0, this.degree = s, this.degree && this.initialize(this.degree);
+      }
+      i.prototype.initialize = function(f) {
+        this.degree = f, this.genPoly = d.generateECPolynomial(this.degree);
+      }, i.prototype.encode = function(f) {
+        if (!this.genPoly)
+          throw new Error("Encoder not initialized");
+        var a = h.alloc(this.degree), y = l.concat([f, a], f.length + this.degree), x = d.mod(y, this.genPoly), b = this.degree - x.length;
+        if (b > 0) {
+          var A = h.alloc(this.degree);
+          return x.copy(A, b), A;
+        }
+        return x;
+      }, g.exports = i;
+    }, { "../utils/buffer": 28, "./polynomial": 16, buffer: 30 }], 19: [function(n, g, u) {
+      var h = "[0-9]+", d = "[A-Z $%*+\\-./:]+", l = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
+      l = l.replace(/u/g, "\\u");
+      var i = "(?:(?![A-Z0-9 $%*+\\-./:]|" + l + `)(?:.|[\r
+]))+`;
+      u.KANJI = new RegExp(l, "g"), u.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g"), u.BYTE = new RegExp(i, "g"), u.NUMERIC = new RegExp(h, "g"), u.ALPHANUMERIC = new RegExp(d, "g");
+      var s = new RegExp("^" + l + "$"), f = new RegExp("^" + h + "$"), a = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+      u.testKanji = function(x) {
+        return s.test(x);
+      }, u.testNumeric = function(x) {
+        return f.test(x);
+      }, u.testAlphanumeric = function(x) {
+        return a.test(x);
+      };
+    }, {}], 20: [function(n, g, u) {
+      var h = n("./mode"), d = n("./numeric-data"), l = n("./alphanumeric-data"), i = n("./byte-data"), s = n("./kanji-data"), f = n("./regex"), a = n("./utils"), y = n("dijkstrajs");
+      function x(k) {
+        return unescape(encodeURIComponent(k)).length;
+      }
+      function b(k, _, m) {
+        for (var p = [], C; (C = k.exec(m)) !== null; )
+          p.push({
+            data: C[0],
+            index: C.index,
+            mode: _,
+            length: C[0].length
+          });
+        return p;
+      }
+      function A(k) {
+        var _ = b(f.NUMERIC, h.NUMERIC, k), m = b(f.ALPHANUMERIC, h.ALPHANUMERIC, k), p, C;
+        a.isKanjiModeEnabled() ? (p = b(f.BYTE, h.BYTE, k), C = b(f.KANJI, h.KANJI, k)) : (p = b(f.BYTE_KANJI, h.BYTE, k), C = []);
+        var T = _.concat(m, p, C);
+        return T.sort(function(L, W) {
+          return L.index - W.index;
+        }).map(function(L) {
+          return {
+            data: L.data,
+            mode: L.mode,
+            length: L.length
+          };
+        });
+      }
+      function F(k, _) {
+        switch (_) {
+          case h.NUMERIC:
+            return d.getBitsLength(k);
+          case h.ALPHANUMERIC:
+            return l.getBitsLength(k);
+          case h.KANJI:
+            return s.getBitsLength(k);
+          case h.BYTE:
+            return i.getBitsLength(k);
+        }
+      }
+      function M(k) {
+        return k.reduce(function(_, m) {
+          var p = _.length - 1 >= 0 ? _[_.length - 1] : null;
+          return p && p.mode === m.mode ? (_[_.length - 1].data += m.data, _) : (_.push(m), _);
+        }, []);
+      }
+      function E(k) {
+        for (var _ = [], m = 0; m < k.length; m++) {
+          var p = k[m];
+          switch (p.mode) {
+            case h.NUMERIC:
+              _.push([
+                p,
+                { data: p.data, mode: h.ALPHANUMERIC, length: p.length },
+                { data: p.data, mode: h.BYTE, length: p.length }
+              ]);
+              break;
+            case h.ALPHANUMERIC:
+              _.push([
+                p,
+                { data: p.data, mode: h.BYTE, length: p.length }
+              ]);
+              break;
+            case h.KANJI:
+              _.push([
+                p,
+                { data: p.data, mode: h.BYTE, length: x(p.data) }
+              ]);
+              break;
+            case h.BYTE:
+              _.push([
+                { data: p.data, mode: h.BYTE, length: x(p.data) }
+              ]);
+          }
+        }
+        return _;
+      }
+      function B(k, _) {
+        for (var m = {}, p = { start: {} }, C = ["start"], T = 0; T < k.length; T++) {
+          for (var L = k[T], W = [], $ = 0; $ < L.length; $++) {
+            var D = L[$], U = "" + T + $;
+            W.push(U), m[U] = { node: D, lastCount: 0 }, p[U] = {};
+            for (var R = 0; R < C.length; R++) {
+              var O = C[R];
+              m[O] && m[O].node.mode === D.mode ? (p[O][U] = F(m[O].lastCount + D.length, D.mode) - F(m[O].lastCount, D.mode), m[O].lastCount += D.length) : (m[O] && (m[O].lastCount = D.length), p[O][U] = F(D.length, D.mode) + 4 + h.getCharCountIndicator(D.mode, _));
+            }
+          }
+          C = W;
+        }
+        for (R = 0; R < C.length; R++)
+          p[C[R]].end = 0;
+        return { map: p, table: m };
+      }
+      function I(k, _) {
+        var m, p = h.getBestModeForData(k);
+        if (m = h.from(_, p), m !== h.BYTE && m.bit < p.bit)
+          throw new Error('"' + k + '" cannot be encoded with mode ' + h.toString(m) + `.
+ Suggested mode is: ` + h.toString(p));
+        switch (m === h.KANJI && !a.isKanjiModeEnabled() && (m = h.BYTE), m) {
+          case h.NUMERIC:
+            return new d(k);
+          case h.ALPHANUMERIC:
+            return new l(k);
+          case h.KANJI:
+            return new s(k);
+          case h.BYTE:
+            return new i(k);
+        }
+      }
+      u.fromArray = function(_) {
+        return _.reduce(function(m, p) {
+          return typeof p == "string" ? m.push(I(p, null)) : p.data && m.push(I(p.data, p.mode)), m;
+        }, []);
+      }, u.fromString = function(_, m) {
+        for (var p = A(_, a.isKanjiModeEnabled()), C = E(p), T = B(C, m), L = y.find_path(T.map, "start", "end"), W = [], $ = 1; $ < L.length - 1; $++)
+          W.push(T.table[L[$]].node);
+        return u.fromArray(M(W));
+      }, u.rawSplit = function(_) {
+        return u.fromArray(
+          A(_, a.isKanjiModeEnabled())
+        );
+      };
+    }, { "./alphanumeric-data": 3, "./byte-data": 6, "./kanji-data": 12, "./mode": 14, "./numeric-data": 15, "./regex": 19, "./utils": 21, dijkstrajs: 31 }], 21: [function(n, g, u) {
+      var h, d = [
+        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
+      ];
+      u.getSymbolSize = function(i) {
+        if (!i)
+          throw new Error('"version" cannot be null or undefined');
+        if (i < 1 || i > 40)
+          throw new Error('"version" should be in range from 1 to 40');
+        return i * 4 + 17;
+      }, u.getSymbolTotalCodewords = function(i) {
+        return d[i];
+      }, u.getBCHDigit = function(l) {
+        for (var i = 0; l !== 0; )
+          i++, l >>>= 1;
+        return i;
+      }, u.setToSJISFunction = function(i) {
+        if (typeof i != "function")
+          throw new Error('"toSJISFunc" is not a valid function.');
+        h = i;
+      }, u.isKanjiModeEnabled = function() {
+        return typeof h < "u";
+      }, u.toSJIS = function(i) {
+        return h(i);
+      };
+    }, {}], 22: [function(n, g, u) {
+      u.isValid = function(d) {
+        return !isNaN(d) && d >= 1 && d <= 40;
+      };
+    }, {}], 23: [function(n, g, u) {
+      var h = n("./utils"), d = n("./error-correction-code"), l = n("./error-correction-level"), i = n("./mode"), s = n("./version-check"), f = n("isarray"), a = 7973, y = h.getBCHDigit(a);
+      function x(M, E, B) {
+        for (var I = 1; I <= 40; I++)
+          if (E <= u.getCapacity(I, B, M))
+            return I;
+      }
+      function b(M, E) {
+        return i.getCharCountIndicator(M, E) + 4;
+      }
+      function A(M, E) {
+        var B = 0;
+        return M.forEach(function(I) {
+          var k = b(I.mode, E);
+          B += k + I.getBitsLength();
+        }), B;
+      }
+      function F(M, E) {
+        for (var B = 1; B <= 40; B++) {
+          var I = A(M, B);
+          if (I <= u.getCapacity(B, E, i.MIXED))
+            return B;
+        }
+      }
+      u.from = function(E, B) {
+        return s.isValid(E) ? parseInt(E, 10) : B;
+      }, u.getCapacity = function(E, B, I) {
+        if (!s.isValid(E))
+          throw new Error("Invalid QR Code version");
+        typeof I > "u" && (I = i.BYTE);
+        var k = h.getSymbolTotalCodewords(E), _ = d.getTotalCodewordsCount(E, B), m = (k - _) * 8;
+        if (I === i.MIXED)
+          return m;
+        var p = m - b(I, E);
+        switch (I) {
+          case i.NUMERIC:
+            return Math.floor(p / 10 * 3);
+          case i.ALPHANUMERIC:
+            return Math.floor(p / 11 * 2);
+          case i.KANJI:
+            return Math.floor(p / 13);
+          case i.BYTE:
+          default:
+            return Math.floor(p / 8);
+        }
+      }, u.getBestVersionForData = function(E, B) {
+        var I, k = l.from(B, l.M);
+        if (f(E)) {
+          if (E.length > 1)
+            return F(E, k);
+          if (E.length === 0)
+            return 1;
+          I = E[0];
+        } else
+          I = E;
+        return x(I.mode, I.getLength(), k);
+      }, u.getEncodedBits = function(E) {
+        if (!s.isValid(E) || E < 7)
+          throw new Error("Invalid QR Code version");
+        for (var B = E << 12; h.getBCHDigit(B) - y >= 0; )
+          B ^= a << h.getBCHDigit(B) - y;
+        return E << 12 | B;
+      };
+    }, { "./error-correction-code": 7, "./error-correction-level": 8, "./mode": 14, "./utils": 21, "./version-check": 22, isarray: 33 }], 24: [function(n, g, u) {
+      var h = n("./can-promise"), d = n("./core/qrcode"), l = n("./renderer/canvas"), i = n("./renderer/svg-tag.js");
+      function s(f, a, y, x, b) {
+        var A = [].slice.call(arguments, 1), F = A.length, M = typeof A[F - 1] == "function";
+        if (!M && !h())
+          throw new Error("Callback required as last argument");
+        if (M) {
+          if (F < 2)
+            throw new Error("Too few arguments provided");
+          F === 2 ? (b = y, y = a, a = x = void 0) : F === 3 && (a.getContext && typeof b > "u" ? (b = x, x = void 0) : (b = x, x = y, y = a, a = void 0));
+        } else {
+          if (F < 1)
+            throw new Error("Too few arguments provided");
+          return F === 1 ? (y = a, a = x = void 0) : F === 2 && !a.getContext && (x = y, y = a, a = void 0), new Promise(function(B, I) {
+            try {
+              var k = d.create(y, x);
+              B(f(k, a, x));
+            } catch (_) {
+              I(_);
+            }
+          });
+        }
+        try {
+          var E = d.create(y, x);
+          b(null, f(E, a, x));
+        } catch (B) {
+          b(B);
+        }
+      }
+      u.create = d.create, u.toCanvas = s.bind(null, l.render), u.toDataURL = s.bind(null, l.renderToDataURL), u.toString = s.bind(null, function(f, a, y) {
+        return i.render(f, y);
+      });
+    }, { "./can-promise": 1, "./core/qrcode": 17, "./renderer/canvas": 25, "./renderer/svg-tag.js": 26 }], 25: [function(n, g, u) {
+      var h = n("./utils");
+      function d(i, s, f) {
+        i.clearRect(0, 0, s.width, s.height), s.style || (s.style = {}), s.height = f, s.width = f, s.style.height = f + "px", s.style.width = f + "px";
+      }
+      function l() {
+        try {
+          return document.createElement("canvas");
+        } catch {
+          throw new Error("You need to specify a canvas element");
+        }
+      }
+      u.render = function(s, f, a) {
+        var y = a, x = f;
+        typeof y > "u" && (!f || !f.getContext) && (y = f, f = void 0), f || (x = l()), y = h.getOptions(y);
+        var b = h.getImageWidth(s.modules.size, y), A = x.getContext("2d"), F = A.createImageData(b, b);
+        return h.qrToImageData(F.data, s, y), d(A, x, b), A.putImageData(F, 0, 0), x;
+      }, u.renderToDataURL = function(s, f, a) {
+        var y = a;
+        typeof y > "u" && (!f || !f.getContext) && (y = f, f = void 0), y || (y = {});
+        var x = u.render(s, f, y), b = y.type || "image/png", A = y.rendererOpts || {};
+        return x.toDataURL(b, A.quality);
+      };
+    }, { "./utils": 27 }], 26: [function(n, g, u) {
+      var h = n("./utils");
+      function d(s, f) {
+        var a = s.a / 255, y = f + '="' + s.hex + '"';
+        return a < 1 ? y + " " + f + '-opacity="' + a.toFixed(2).slice(1) + '"' : y;
+      }
+      function l(s, f, a) {
+        var y = s + f;
+        return typeof a < "u" && (y += " " + a), y;
+      }
+      function i(s, f, a) {
+        for (var y = "", x = 0, b = !1, A = 0, F = 0; F < s.length; F++) {
+          var M = Math.floor(F % f), E = Math.floor(F / f);
+          !M && !b && (b = !0), s[F] ? (A++, F > 0 && M > 0 && s[F - 1] || (y += b ? l("M", M + a, 0.5 + E + a) : l("m", x, 0), x = 0, b = !1), M + 1 < f && s[F + 1] || (y += l("h", A), A = 0)) : x++;
+        }
+        return y;
+      }
+      u.render = function(f, a, y) {
+        var x = h.getOptions(a), b = f.modules.size, A = f.modules.data, F = b + x.margin * 2, M = x.color.light.a ? "<path " + d(x.color.light, "fill") + ' d="M0 0h' + F + "v" + F + 'H0z"/>' : "", E = "<path " + d(x.color.dark, "stroke") + ' d="' + i(A, b, x.margin) + '"/>', B = 'viewBox="0 0 ' + F + " " + F + '"', I = x.width ? 'width="' + x.width + '" height="' + x.width + '" ' : "", k = '<svg xmlns="http://www.w3.org/2000/svg" ' + I + B + ' shape-rendering="crispEdges">' + M + E + `</svg>
+`;
+        return typeof y == "function" && y(null, k), k;
+      };
+    }, { "./utils": 27 }], 27: [function(n, g, u) {
+      function h(d) {
+        if (typeof d == "number" && (d = d.toString()), typeof d != "string")
+          throw new Error("Color should be defined as hex string");
+        var l = d.slice().replace("#", "").split("");
+        if (l.length < 3 || l.length === 5 || l.length > 8)
+          throw new Error("Invalid hex color: " + d);
+        (l.length === 3 || l.length === 4) && (l = Array.prototype.concat.apply([], l.map(function(s) {
+          return [s, s];
+        }))), l.length === 6 && l.push("F", "F");
+        var i = parseInt(l.join(""), 16);
+        return {
+          r: i >> 24 & 255,
+          g: i >> 16 & 255,
+          b: i >> 8 & 255,
+          a: i & 255,
+          hex: "#" + l.slice(0, 6).join("")
+        };
+      }
+      u.getOptions = function(l) {
+        l || (l = {}), l.color || (l.color = {});
+        var i = typeof l.margin > "u" || l.margin === null || l.margin < 0 ? 4 : l.margin, s = l.width && l.width >= 21 ? l.width : void 0, f = l.scale || 4;
+        return {
+          width: s,
+          scale: s ? 4 : f,
+          margin: i,
+          color: {
+            dark: h(l.color.dark || "#000000ff"),
+            light: h(l.color.light || "#ffffffff")
+          },
+          type: l.type,
+          rendererOpts: l.rendererOpts || {}
+        };
+      }, u.getScale = function(l, i) {
+        return i.width && i.width >= l + i.margin * 2 ? i.width / (l + i.margin * 2) : i.scale;
+      }, u.getImageWidth = function(l, i) {
+        var s = u.getScale(l, i);
+        return Math.floor((l + i.margin * 2) * s);
+      }, u.qrToImageData = function(l, i, s) {
+        for (var f = i.modules.size, a = i.modules.data, y = u.getScale(f, s), x = Math.floor((f + s.margin * 2) * y), b = s.margin * y, A = [s.color.light, s.color.dark], F = 0; F < x; F++)
+          for (var M = 0; M < x; M++) {
+            var E = (F * x + M) * 4, B = s.color.light;
+            if (F >= b && M >= b && F < x - b && M < x - b) {
+              var I = Math.floor((F - b) / y), k = Math.floor((M - b) / y);
+              B = A[a[I * f + k] ? 1 : 0];
+            }
+            l[E++] = B.r, l[E++] = B.g, l[E++] = B.b, l[E] = B.a;
+          }
+      };
+    }, {}], 28: [function(n, g, u) {
+      var h = n("isarray");
+      function d() {
+        try {
+          var _ = new Uint8Array(1);
+          return _.__proto__ = { __proto__: Uint8Array.prototype, foo: function() {
+            return 42;
+          } }, _.foo() === 42;
+        } catch {
+          return !1;
+        }
+      }
+      i.TYPED_ARRAY_SUPPORT = d();
+      var l = i.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823;
+      function i(_, m, p) {
+        return !i.TYPED_ARRAY_SUPPORT && !(this instanceof i) ? new i(_, m, p) : typeof _ == "number" ? y(this, _) : k(this, _, m, p);
+      }
+      i.TYPED_ARRAY_SUPPORT && (i.prototype.__proto__ = Uint8Array.prototype, i.__proto__ = Uint8Array, typeof Symbol < "u" && Symbol.species && i[Symbol.species] === i && Object.defineProperty(i, Symbol.species, {
+        value: null,
+        configurable: !0,
+        enumerable: !1,
+        writable: !1
+      }));
+      function s(_) {
+        if (_ >= l)
+          throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + l.toString(16) + " bytes");
+        return _ | 0;
+      }
+      function f(_) {
+        return _ !== _;
+      }
+      function a(_, m) {
+        var p;
+        return i.TYPED_ARRAY_SUPPORT ? (p = new Uint8Array(m), p.__proto__ = i.prototype) : (p = _, p === null && (p = new i(m)), p.length = m), p;
+      }
+      function y(_, m) {
+        var p = a(_, m < 0 ? 0 : s(m) | 0);
+        if (!i.TYPED_ARRAY_SUPPORT)
+          for (var C = 0; C < m; ++C)
+            p[C] = 0;
+        return p;
+      }
+      function x(_, m) {
+        var p = E(m) | 0, C = a(_, p), T = C.write(m);
+        return T !== p && (C = C.slice(0, T)), C;
+      }
+      function b(_, m) {
+        for (var p = m.length < 0 ? 0 : s(m.length) | 0, C = a(_, p), T = 0; T < p; T += 1)
+          C[T] = m[T] & 255;
+        return C;
+      }
+      function A(_, m, p, C) {
+        if (p < 0 || m.byteLength < p)
+          throw new RangeError("'offset' is out of bounds");
+        if (m.byteLength < p + (C || 0))
+          throw new RangeError("'length' is out of bounds");
+        var T;
+        return p === void 0 && C === void 0 ? T = new Uint8Array(m) : C === void 0 ? T = new Uint8Array(m, p) : T = new Uint8Array(m, p, C), i.TYPED_ARRAY_SUPPORT ? T.__proto__ = i.prototype : T = b(_, T), T;
+      }
+      function F(_, m) {
+        if (i.isBuffer(m)) {
+          var p = s(m.length) | 0, C = a(_, p);
+          return C.length === 0 || m.copy(C, 0, 0, p), C;
+        }
+        if (m) {
+          if (typeof ArrayBuffer < "u" && m.buffer instanceof ArrayBuffer || "length" in m)
+            return typeof m.length != "number" || f(m.length) ? a(_, 0) : b(_, m);
+          if (m.type === "Buffer" && Array.isArray(m.data))
+            return b(_, m.data);
+        }
+        throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.");
+      }
+      function M(_, m) {
+        m = m || 1 / 0;
+        for (var p, C = _.length, T = null, L = [], W = 0; W < C; ++W) {
+          if (p = _.charCodeAt(W), p > 55295 && p < 57344) {
+            if (!T) {
+              if (p > 56319) {
+                (m -= 3) > -1 && L.push(239, 191, 189);
+                continue;
+              } else if (W + 1 === C) {
+                (m -= 3) > -1 && L.push(239, 191, 189);
+                continue;
+              }
+              T = p;
+              continue;
+            }
+            if (p < 56320) {
+              (m -= 3) > -1 && L.push(239, 191, 189), T = p;
+              continue;
+            }
+            p = (T - 55296 << 10 | p - 56320) + 65536;
+          } else
+            T && (m -= 3) > -1 && L.push(239, 191, 189);
+          if (T = null, p < 128) {
+            if ((m -= 1) < 0)
+              break;
+            L.push(p);
+          } else if (p < 2048) {
+            if ((m -= 2) < 0)
+              break;
+            L.push(
+              p >> 6 | 192,
+              p & 63 | 128
+            );
+          } else if (p < 65536) {
+            if ((m -= 3) < 0)
+              break;
+            L.push(
+              p >> 12 | 224,
+              p >> 6 & 63 | 128,
+              p & 63 | 128
+            );
+          } else if (p < 1114112) {
+            if ((m -= 4) < 0)
+              break;
+            L.push(
+              p >> 18 | 240,
+              p >> 12 & 63 | 128,
+              p >> 6 & 63 | 128,
+              p & 63 | 128
+            );
+          } else
+            throw new Error("Invalid code point");
+        }
+        return L;
+      }
+      function E(_) {
+        if (i.isBuffer(_))
+          return _.length;
+        if (typeof ArrayBuffer < "u" && typeof ArrayBuffer.isView == "function" && (ArrayBuffer.isView(_) || _ instanceof ArrayBuffer))
+          return _.byteLength;
+        typeof _ != "string" && (_ = "" + _);
+        var m = _.length;
+        return m === 0 ? 0 : M(_).length;
+      }
+      function B(_, m, p, C) {
+        for (var T = 0; T < C && !(T + p >= m.length || T >= _.length); ++T)
+          m[T + p] = _[T];
+        return T;
+      }
+      function I(_, m, p, C) {
+        return B(M(m, _.length - p), _, p, C);
+      }
+      function k(_, m, p, C) {
+        if (typeof m == "number")
+          throw new TypeError('"value" argument must not be a number');
+        return typeof ArrayBuffer < "u" && m instanceof ArrayBuffer ? A(_, m, p, C) : typeof m == "string" ? x(_, m) : F(_, m);
+      }
+      i.prototype.write = function(m, p, C) {
+        p === void 0 ? (C = this.length, p = 0) : C === void 0 && typeof p == "string" ? (C = this.length, p = 0) : isFinite(p) && (p = p | 0, isFinite(C) ? C = C | 0 : C = void 0);
+        var T = this.length - p;
+        if ((C === void 0 || C > T) && (C = T), m.length > 0 && (C < 0 || p < 0) || p > this.length)
+          throw new RangeError("Attempt to write outside buffer bounds");
+        return I(this, m, p, C);
+      }, i.prototype.slice = function(m, p) {
+        var C = this.length;
+        m = ~~m, p = p === void 0 ? C : ~~p, m < 0 ? (m += C, m < 0 && (m = 0)) : m > C && (m = C), p < 0 ? (p += C, p < 0 && (p = 0)) : p > C && (p = C), p < m && (p = m);
+        var T;
+        if (i.TYPED_ARRAY_SUPPORT)
+          T = this.subarray(m, p), T.__proto__ = i.prototype;
+        else {
+          var L = p - m;
+          T = new i(L, void 0);
+          for (var W = 0; W < L; ++W)
+            T[W] = this[W + m];
+        }
+        return T;
+      }, i.prototype.copy = function(m, p, C, T) {
+        if (C || (C = 0), !T && T !== 0 && (T = this.length), p >= m.length && (p = m.length), p || (p = 0), T > 0 && T < C && (T = C), T === C || m.length === 0 || this.length === 0)
+          return 0;
+        if (p < 0)
+          throw new RangeError("targetStart out of bounds");
+        if (C < 0 || C >= this.length)
+          throw new RangeError("sourceStart out of bounds");
+        if (T < 0)
+          throw new RangeError("sourceEnd out of bounds");
+        T > this.length && (T = this.length), m.length - p < T - C && (T = m.length - p + C);
+        var L = T - C, W;
+        if (this === m && C < p && p < T)
+          for (W = L - 1; W >= 0; --W)
+            m[W + p] = this[W + C];
+        else if (L < 1e3 || !i.TYPED_ARRAY_SUPPORT)
+          for (W = 0; W < L; ++W)
+            m[W + p] = this[W + C];
+        else
+          Uint8Array.prototype.set.call(
+            m,
+            this.subarray(C, C + L),
+            p
+          );
+        return L;
+      }, i.prototype.fill = function(m, p, C) {
+        if (typeof m == "string") {
+          if (typeof p == "string" ? (p = 0, C = this.length) : typeof C == "string" && (C = this.length), m.length === 1) {
+            var T = m.charCodeAt(0);
+            T < 256 && (m = T);
+          }
+        } else
+          typeof m == "number" && (m = m & 255);
+        if (p < 0 || this.length < p || this.length < C)
+          throw new RangeError("Out of range index");
+        if (C <= p)
+          return this;
+        p = p >>> 0, C = C === void 0 ? this.length : C >>> 0, m || (m = 0);
+        var L;
+        if (typeof m == "number")
+          for (L = p; L < C; ++L)
+            this[L] = m;
+        else {
+          var W = i.isBuffer(m) ? m : new i(m), $ = W.length;
+          for (L = 0; L < C - p; ++L)
+            this[L + p] = W[L % $];
+        }
+        return this;
+      }, i.concat = function(m, p) {
+        if (!h(m))
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        if (m.length === 0)
+          return a(null, 0);
+        var C;
+        if (p === void 0)
+          for (p = 0, C = 0; C < m.length; ++C)
+            p += m[C].length;
+        var T = y(null, p), L = 0;
+        for (C = 0; C < m.length; ++C) {
+          var W = m[C];
+          if (!i.isBuffer(W))
+            throw new TypeError('"list" argument must be an Array of Buffers');
+          W.copy(T, L), L += W.length;
+        }
+        return T;
+      }, i.byteLength = E, i.prototype._isBuffer = !0, i.isBuffer = function(m) {
+        return !!(m != null && m._isBuffer);
+      }, g.exports.alloc = function(_) {
+        var m = new i(_);
+        return m.fill(0), m;
+      }, g.exports.from = function(_) {
+        return new i(_);
+      };
+    }, { isarray: 33 }], 29: [function(n, g, u) {
+      u.byteLength = y, u.toByteArray = b, u.fromByteArray = M;
+      for (var h = [], d = [], l = typeof Uint8Array < "u" ? Uint8Array : Array, i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", s = 0, f = i.length; s < f; ++s)
+        h[s] = i[s], d[i.charCodeAt(s)] = s;
+      d[45] = 62, d[95] = 63;
+      function a(E) {
+        var B = E.length;
+        if (B % 4 > 0)
+          throw new Error("Invalid string. Length must be a multiple of 4");
+        var I = E.indexOf("=");
+        I === -1 && (I = B);
+        var k = I === B ? 0 : 4 - I % 4;
+        return [I, k];
+      }
+      function y(E) {
+        var B = a(E), I = B[0], k = B[1];
+        return (I + k) * 3 / 4 - k;
+      }
+      function x(E, B, I) {
+        return (B + I) * 3 / 4 - I;
+      }
+      function b(E) {
+        var B, I = a(E), k = I[0], _ = I[1], m = new l(x(E, k, _)), p = 0, C = _ > 0 ? k - 4 : k, T;
+        for (T = 0; T < C; T += 4)
+          B = d[E.charCodeAt(T)] << 18 | d[E.charCodeAt(T + 1)] << 12 | d[E.charCodeAt(T + 2)] << 6 | d[E.charCodeAt(T + 3)], m[p++] = B >> 16 & 255, m[p++] = B >> 8 & 255, m[p++] = B & 255;
+        return _ === 2 && (B = d[E.charCodeAt(T)] << 2 | d[E.charCodeAt(T + 1)] >> 4, m[p++] = B & 255), _ === 1 && (B = d[E.charCodeAt(T)] << 10 | d[E.charCodeAt(T + 1)] << 4 | d[E.charCodeAt(T + 2)] >> 2, m[p++] = B >> 8 & 255, m[p++] = B & 255), m;
+      }
+      function A(E) {
+        return h[E >> 18 & 63] + h[E >> 12 & 63] + h[E >> 6 & 63] + h[E & 63];
+      }
+      function F(E, B, I) {
+        for (var k, _ = [], m = B; m < I; m += 3)
+          k = (E[m] << 16 & 16711680) + (E[m + 1] << 8 & 65280) + (E[m + 2] & 255), _.push(A(k));
+        return _.join("");
+      }
+      function M(E) {
+        for (var B, I = E.length, k = I % 3, _ = [], m = 16383, p = 0, C = I - k; p < C; p += m)
+          _.push(F(
+            E,
+            p,
+            p + m > C ? C : p + m
+          ));
+        return k === 1 ? (B = E[I - 1], _.push(
+          h[B >> 2] + h[B << 4 & 63] + "=="
+        )) : k === 2 && (B = (E[I - 2] << 8) + E[I - 1], _.push(
+          h[B >> 10] + h[B >> 4 & 63] + h[B << 2 & 63] + "="
+        )), _.join("");
+      }
+    }, {}], 30: [function(n, g, u) {
+      var h = n("base64-js"), d = n("ieee754"), l = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
+      u.Buffer = a, u.SlowBuffer = k, u.INSPECT_MAX_BYTES = 50;
+      var i = 2147483647;
+      u.kMaxLength = i, a.TYPED_ARRAY_SUPPORT = s(), !a.TYPED_ARRAY_SUPPORT && typeof console < "u" && typeof console.error == "function" && console.error(
+        "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+      );
+      function s() {
+        try {
+          var o = new Uint8Array(1), t = { foo: function() {
+            return 42;
+          } };
+          return Object.setPrototypeOf(t, Uint8Array.prototype), Object.setPrototypeOf(o, t), o.foo() === 42;
+        } catch {
+          return !1;
+        }
+      }
+      Object.defineProperty(a.prototype, "parent", {
+        enumerable: !0,
+        get: function() {
+          if (a.isBuffer(this))
+            return this.buffer;
+        }
+      }), Object.defineProperty(a.prototype, "offset", {
+        enumerable: !0,
+        get: function() {
+          if (a.isBuffer(this))
+            return this.byteOffset;
+        }
+      });
+      function f(o) {
+        if (o > i)
+          throw new RangeError('The value "' + o + '" is invalid for option "size"');
+        var t = new Uint8Array(o);
+        return Object.setPrototypeOf(t, a.prototype), t;
+      }
+      function a(o, t, e) {
+        if (typeof o == "number") {
+          if (typeof t == "string")
+            throw new TypeError(
+              'The "string" argument must be of type string. Received type number'
+            );
+          return A(o);
+        }
+        return y(o, t, e);
+      }
+      typeof Symbol < "u" && Symbol.species != null && a[Symbol.species] === a && Object.defineProperty(a, Symbol.species, {
+        value: null,
+        configurable: !0,
+        enumerable: !1,
+        writable: !1
+      }), a.poolSize = 8192;
+      function y(o, t, e) {
+        if (typeof o == "string")
+          return F(o, t);
+        if (ArrayBuffer.isView(o))
+          return M(o);
+        if (o == null)
+          throw new TypeError(
+            "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof o
+          );
+        if (Q(o, ArrayBuffer) || o && Q(o.buffer, ArrayBuffer))
+          return E(o, t, e);
+        if (typeof o == "number")
+          throw new TypeError(
+            'The "value" argument must not be of type number. Received type number'
+          );
+        var c = o.valueOf && o.valueOf();
+        if (c != null && c !== o)
+          return a.from(c, t, e);
+        var w = B(o);
+        if (w)
+          return w;
+        if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof o[Symbol.toPrimitive] == "function")
+          return a.from(
+            o[Symbol.toPrimitive]("string"),
+            t,
+            e
+          );
+        throw new TypeError(
+          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof o
+        );
+      }
+      a.from = function(o, t, e) {
+        return y(o, t, e);
+      }, Object.setPrototypeOf(a.prototype, Uint8Array.prototype), Object.setPrototypeOf(a, Uint8Array);
+      function x(o) {
+        if (typeof o != "number")
+          throw new TypeError('"size" argument must be of type number');
+        if (o < 0)
+          throw new RangeError('The value "' + o + '" is invalid for option "size"');
+      }
+      function b(o, t, e) {
+        return x(o), o <= 0 ? f(o) : t !== void 0 ? typeof e == "string" ? f(o).fill(t, e) : f(o).fill(t) : f(o);
+      }
+      a.alloc = function(o, t, e) {
+        return b(o, t, e);
+      };
+      function A(o) {
+        return x(o), f(o < 0 ? 0 : I(o) | 0);
+      }
+      a.allocUnsafe = function(o) {
+        return A(o);
+      }, a.allocUnsafeSlow = function(o) {
+        return A(o);
+      };
+      function F(o, t) {
+        if ((typeof t != "string" || t === "") && (t = "utf8"), !a.isEncoding(t))
+          throw new TypeError("Unknown encoding: " + t);
+        var e = _(o, t) | 0, c = f(e), w = c.write(o, t);
+        return w !== e && (c = c.slice(0, w)), c;
+      }
+      function M(o) {
+        for (var t = o.length < 0 ? 0 : I(o.length) | 0, e = f(t), c = 0; c < t; c += 1)
+          e[c] = o[c] & 255;
+        return e;
+      }
+      function E(o, t, e) {
+        if (t < 0 || o.byteLength < t)
+          throw new RangeError('"offset" is outside of buffer bounds');
+        if (o.byteLength < t + (e || 0))
+          throw new RangeError('"length" is outside of buffer bounds');
+        var c;
+        return t === void 0 && e === void 0 ? c = new Uint8Array(o) : e === void 0 ? c = new Uint8Array(o, t) : c = new Uint8Array(o, t, e), Object.setPrototypeOf(c, a.prototype), c;
+      }
+      function B(o) {
+        if (a.isBuffer(o)) {
+          var t = I(o.length) | 0, e = f(t);
+          return e.length === 0 || o.copy(e, 0, 0, t), e;
+        }
+        if (o.length !== void 0)
+          return typeof o.length != "number" || wt(o.length) ? f(0) : M(o);
+        if (o.type === "Buffer" && Array.isArray(o.data))
+          return M(o.data);
+      }
+      function I(o) {
+        if (o >= i)
+          throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + i.toString(16) + " bytes");
+        return o | 0;
+      }
+      function k(o) {
+        return +o != o && (o = 0), a.alloc(+o);
+      }
+      a.isBuffer = function(t) {
+        return t != null && t._isBuffer === !0 && t !== a.prototype;
+      }, a.compare = function(t, e) {
+        if (Q(t, Uint8Array) && (t = a.from(t, t.offset, t.byteLength)), Q(e, Uint8Array) && (e = a.from(e, e.offset, e.byteLength)), !a.isBuffer(t) || !a.isBuffer(e))
+          throw new TypeError(
+            'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+          );
+        if (t === e)
+          return 0;
+        for (var c = t.length, w = e.length, P = 0, S = Math.min(c, w); P < S; ++P)
+          if (t[P] !== e[P]) {
+            c = t[P], w = e[P];
+            break;
+          }
+        return c < w ? -1 : w < c ? 1 : 0;
+      }, a.isEncoding = function(t) {
+        switch (String(t).toLowerCase()) {
+          case "hex":
+          case "utf8":
+          case "utf-8":
+          case "ascii":
+          case "latin1":
+          case "binary":
+          case "base64":
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return !0;
+          default:
+            return !1;
+        }
+      }, a.concat = function(t, e) {
+        if (!Array.isArray(t))
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        if (t.length === 0)
+          return a.alloc(0);
+        var c;
+        if (e === void 0)
+          for (e = 0, c = 0; c < t.length; ++c)
+            e += t[c].length;
+        var w = a.allocUnsafe(e), P = 0;
+        for (c = 0; c < t.length; ++c) {
+          var S = t[c];
+          if (Q(S, Uint8Array) && (S = a.from(S)), !a.isBuffer(S))
+            throw new TypeError('"list" argument must be an Array of Buffers');
+          S.copy(w, P), P += S.length;
+        }
+        return w;
+      };
+      function _(o, t) {
+        if (a.isBuffer(o))
+          return o.length;
+        if (ArrayBuffer.isView(o) || Q(o, ArrayBuffer))
+          return o.byteLength;
+        if (typeof o != "string")
+          throw new TypeError(
+            'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof o
+          );
+        var e = o.length, c = arguments.length > 2 && arguments[2] === !0;
+        if (!c && e === 0)
+          return 0;
+        for (var w = !1; ; )
+          switch (t) {
+            case "ascii":
+            case "latin1":
+            case "binary":
+              return e;
+            case "utf8":
+            case "utf-8":
+              return rt(o).length;
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return e * 2;
+            case "hex":
+              return e >>> 1;
+            case "base64":
+              return ht(o).length;
+            default:
+              if (w)
+                return c ? -1 : rt(o).length;
+              t = ("" + t).toLowerCase(), w = !0;
+          }
+      }
+      a.byteLength = _;
+      function m(o, t, e) {
+        var c = !1;
+        if ((t === void 0 || t < 0) && (t = 0), t > this.length || ((e === void 0 || e > this.length) && (e = this.length), e <= 0) || (e >>>= 0, t >>>= 0, e <= t))
+          return "";
+        for (o || (o = "utf8"); ; )
+          switch (o) {
+            case "hex":
+              return X(this, t, e);
+            case "utf8":
+            case "utf-8":
+              return z(this, t, e);
+            case "ascii":
+              return j(this, t, e);
+            case "latin1":
+            case "binary":
+              return et(this, t, e);
+            case "base64":
+              return O(this, t, e);
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return mt(this, t, e);
+            default:
+              if (c)
+                throw new TypeError("Unknown encoding: " + o);
+              o = (o + "").toLowerCase(), c = !0;
+          }
+      }
+      a.prototype._isBuffer = !0;
+      function p(o, t, e) {
+        var c = o[t];
+        o[t] = o[e], o[e] = c;
+      }
+      a.prototype.swap16 = function() {
+        var t = this.length;
+        if (t % 2 !== 0)
+          throw new RangeError("Buffer size must be a multiple of 16-bits");
+        for (var e = 0; e < t; e += 2)
+          p(this, e, e + 1);
+        return this;
+      }, a.prototype.swap32 = function() {
+        var t = this.length;
+        if (t % 4 !== 0)
+          throw new RangeError("Buffer size must be a multiple of 32-bits");
+        for (var e = 0; e < t; e += 4)
+          p(this, e, e + 3), p(this, e + 1, e + 2);
+        return this;
+      }, a.prototype.swap64 = function() {
+        var t = this.length;
+        if (t % 8 !== 0)
+          throw new RangeError("Buffer size must be a multiple of 64-bits");
+        for (var e = 0; e < t; e += 8)
+          p(this, e, e + 7), p(this, e + 1, e + 6), p(this, e + 2, e + 5), p(this, e + 3, e + 4);
+        return this;
+      }, a.prototype.toString = function() {
+        var t = this.length;
+        return t === 0 ? "" : arguments.length === 0 ? z(this, 0, t) : m.apply(this, arguments);
+      }, a.prototype.toLocaleString = a.prototype.toString, a.prototype.equals = function(t) {
+        if (!a.isBuffer(t))
+          throw new TypeError("Argument must be a Buffer");
+        return this === t ? !0 : a.compare(this, t) === 0;
+      }, a.prototype.inspect = function() {
+        var t = "", e = u.INSPECT_MAX_BYTES;
+        return t = this.toString("hex", 0, e).replace(/(.{2})/g, "$1 ").trim(), this.length > e && (t += " ... "), "<Buffer " + t + ">";
+      }, l && (a.prototype[l] = a.prototype.inspect), a.prototype.compare = function(t, e, c, w, P) {
+        if (Q(t, Uint8Array) && (t = a.from(t, t.offset, t.byteLength)), !a.isBuffer(t))
+          throw new TypeError(
+            'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof t
+          );
+        if (e === void 0 && (e = 0), c === void 0 && (c = t ? t.length : 0), w === void 0 && (w = 0), P === void 0 && (P = this.length), e < 0 || c > t.length || w < 0 || P > this.length)
+          throw new RangeError("out of range index");
+        if (w >= P && e >= c)
+          return 0;
+        if (w >= P)
+          return -1;
+        if (e >= c)
+          return 1;
+        if (e >>>= 0, c >>>= 0, w >>>= 0, P >>>= 0, this === t)
+          return 0;
+        for (var S = P - w, H = c - e, G = Math.min(S, H), K = this.slice(w, P), Z = t.slice(e, c), V = 0; V < G; ++V)
+          if (K[V] !== Z[V]) {
+            S = K[V], H = Z[V];
+            break;
+          }
+        return S < H ? -1 : H < S ? 1 : 0;
+      };
+      function C(o, t, e, c, w) {
+        if (o.length === 0)
+          return -1;
+        if (typeof e == "string" ? (c = e, e = 0) : e > 2147483647 ? e = 2147483647 : e < -2147483648 && (e = -2147483648), e = +e, wt(e) && (e = w ? 0 : o.length - 1), e < 0 && (e = o.length + e), e >= o.length) {
+          if (w)
+            return -1;
+          e = o.length - 1;
+        } else if (e < 0)
+          if (w)
+            e = 0;
+          else
+            return -1;
+        if (typeof t == "string" && (t = a.from(t, c)), a.isBuffer(t))
+          return t.length === 0 ? -1 : T(o, t, e, c, w);
+        if (typeof t == "number")
+          return t = t & 255, typeof Uint8Array.prototype.indexOf == "function" ? w ? Uint8Array.prototype.indexOf.call(o, t, e) : Uint8Array.prototype.lastIndexOf.call(o, t, e) : T(o, [t], e, c, w);
+        throw new TypeError("val must be string, number or Buffer");
+      }
+      function T(o, t, e, c, w) {
+        var P = 1, S = o.length, H = t.length;
+        if (c !== void 0 && (c = String(c).toLowerCase(), c === "ucs2" || c === "ucs-2" || c === "utf16le" || c === "utf-16le")) {
+          if (o.length < 2 || t.length < 2)
+            return -1;
+          P = 2, S /= 2, H /= 2, e /= 2;
+        }
+        function G(Pt, St) {
+          return P === 1 ? Pt[St] : Pt.readUInt16BE(St * P);
+        }
+        var K;
+        if (w) {
+          var Z = -1;
+          for (K = e; K < S; K++)
+            if (G(o, K) === G(t, Z === -1 ? 0 : K - Z)) {
+              if (Z === -1 && (Z = K), K - Z + 1 === H)
+                return Z * P;
+            } else
+              Z !== -1 && (K -= K - Z), Z = -1;
+        } else
+          for (e + H > S && (e = S - H), K = e; K >= 0; K--) {
+            for (var V = !0, dt = 0; dt < H; dt++)
+              if (G(o, K + dt) !== G(t, dt)) {
+                V = !1;
+                break;
+              }
+            if (V)
+              return K;
+          }
+        return -1;
+      }
+      a.prototype.includes = function(t, e, c) {
+        return this.indexOf(t, e, c) !== -1;
+      }, a.prototype.indexOf = function(t, e, c) {
+        return C(this, t, e, c, !0);
+      }, a.prototype.lastIndexOf = function(t, e, c) {
+        return C(this, t, e, c, !1);
+      };
+      function L(o, t, e, c) {
+        e = Number(e) || 0;
+        var w = o.length - e;
+        c ? (c = Number(c), c > w && (c = w)) : c = w;
+        var P = t.length;
+        c > P / 2 && (c = P / 2);
+        for (var S = 0; S < c; ++S) {
+          var H = parseInt(t.substr(S * 2, 2), 16);
+          if (wt(H))
+            return S;
+          o[e + S] = H;
+        }
+        return S;
+      }
+      function W(o, t, e, c) {
+        return tt(rt(t, o.length - e), o, e, c);
+      }
+      function $(o, t, e, c) {
+        return tt(ct(t), o, e, c);
+      }
+      function D(o, t, e, c) {
+        return $(o, t, e, c);
+      }
+      function U(o, t, e, c) {
+        return tt(ht(t), o, e, c);
+      }
+      function R(o, t, e, c) {
+        return tt(lt(t, o.length - e), o, e, c);
+      }
+      a.prototype.write = function(t, e, c, w) {
+        if (e === void 0)
+          w = "utf8", c = this.length, e = 0;
+        else if (c === void 0 && typeof e == "string")
+          w = e, c = this.length, e = 0;
+        else if (isFinite(e))
+          e = e >>> 0, isFinite(c) ? (c = c >>> 0, w === void 0 && (w = "utf8")) : (w = c, c = void 0);
+        else
+          throw new Error(
+            "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+          );
+        var P = this.length - e;
+        if ((c === void 0 || c > P) && (c = P), t.length > 0 && (c < 0 || e < 0) || e > this.length)
+          throw new RangeError("Attempt to write outside buffer bounds");
+        w || (w = "utf8");
+        for (var S = !1; ; )
+          switch (w) {
+            case "hex":
+              return L(this, t, e, c);
+            case "utf8":
+            case "utf-8":
+              return W(this, t, e, c);
+            case "ascii":
+              return $(this, t, e, c);
+            case "latin1":
+            case "binary":
+              return D(this, t, e, c);
+            case "base64":
+              return U(this, t, e, c);
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return R(this, t, e, c);
+            default:
+              if (S)
+                throw new TypeError("Unknown encoding: " + w);
+              w = ("" + w).toLowerCase(), S = !0;
+          }
+      }, a.prototype.toJSON = function() {
+        return {
+          type: "Buffer",
+          data: Array.prototype.slice.call(this._arr || this, 0)
+        };
+      };
+      function O(o, t, e) {
+        return t === 0 && e === o.length ? h.fromByteArray(o) : h.fromByteArray(o.slice(t, e));
+      }
+      function z(o, t, e) {
+        e = Math.min(o.length, e);
+        for (var c = [], w = t; w < e; ) {
+          var P = o[w], S = null, H = P > 239 ? 4 : P > 223 ? 3 : P > 191 ? 2 : 1;
+          if (w + H <= e) {
+            var G, K, Z, V;
+            switch (H) {
+              case 1:
+                P < 128 && (S = P);
+                break;
+              case 2:
+                G = o[w + 1], (G & 192) === 128 && (V = (P & 31) << 6 | G & 63, V > 127 && (S = V));
+                break;
+              case 3:
+                G = o[w + 1], K = o[w + 2], (G & 192) === 128 && (K & 192) === 128 && (V = (P & 15) << 12 | (G & 63) << 6 | K & 63, V > 2047 && (V < 55296 || V > 57343) && (S = V));
+                break;
+              case 4:
+                G = o[w + 1], K = o[w + 2], Z = o[w + 3], (G & 192) === 128 && (K & 192) === 128 && (Z & 192) === 128 && (V = (P & 15) << 18 | (G & 63) << 12 | (K & 63) << 6 | Z & 63, V > 65535 && V < 1114112 && (S = V));
+            }
+          }
+          S === null ? (S = 65533, H = 1) : S > 65535 && (S -= 65536, c.push(S >>> 10 & 1023 | 55296), S = 56320 | S & 1023), c.push(S), w += H;
+        }
+        return Y(c);
+      }
+      var N = 4096;
+      function Y(o) {
+        var t = o.length;
+        if (t <= N)
+          return String.fromCharCode.apply(String, o);
+        for (var e = "", c = 0; c < t; )
+          e += String.fromCharCode.apply(
+            String,
+            o.slice(c, c += N)
+          );
+        return e;
+      }
+      function j(o, t, e) {
+        var c = "";
+        e = Math.min(o.length, e);
+        for (var w = t; w < e; ++w)
+          c += String.fromCharCode(o[w] & 127);
+        return c;
+      }
+      function et(o, t, e) {
+        var c = "";
+        e = Math.min(o.length, e);
+        for (var w = t; w < e; ++w)
+          c += String.fromCharCode(o[w]);
+        return c;
+      }
+      function X(o, t, e) {
+        var c = o.length;
+        (!t || t < 0) && (t = 0), (!e || e < 0 || e > c) && (e = c);
+        for (var w = "", P = t; P < e; ++P)
+          w += kt[o[P]];
+        return w;
+      }
+      function mt(o, t, e) {
+        for (var c = o.slice(t, e), w = "", P = 0; P < c.length; P += 2)
+          w += String.fromCharCode(c[P] + c[P + 1] * 256);
+        return w;
+      }
+      a.prototype.slice = function(t, e) {
+        var c = this.length;
+        t = ~~t, e = e === void 0 ? c : ~~e, t < 0 ? (t += c, t < 0 && (t = 0)) : t > c && (t = c), e < 0 ? (e += c, e < 0 && (e = 0)) : e > c && (e = c), e < t && (e = t);
+        var w = this.subarray(t, e);
+        return Object.setPrototypeOf(w, a.prototype), w;
+      };
+      function J(o, t, e) {
+        if (o % 1 !== 0 || o < 0)
+          throw new RangeError("offset is not uint");
+        if (o + t > e)
+          throw new RangeError("Trying to access beyond buffer length");
+      }
+      a.prototype.readUIntLE = function(t, e, c) {
+        t = t >>> 0, e = e >>> 0, c || J(t, e, this.length);
+        for (var w = this[t], P = 1, S = 0; ++S < e && (P *= 256); )
+          w += this[t + S] * P;
+        return w;
+      }, a.prototype.readUIntBE = function(t, e, c) {
+        t = t >>> 0, e = e >>> 0, c || J(t, e, this.length);
+        for (var w = this[t + --e], P = 1; e > 0 && (P *= 256); )
+          w += this[t + --e] * P;
+        return w;
+      }, a.prototype.readUInt8 = function(t, e) {
+        return t = t >>> 0, e || J(t, 1, this.length), this[t];
+      }, a.prototype.readUInt16LE = function(t, e) {
+        return t = t >>> 0, e || J(t, 2, this.length), this[t] | this[t + 1] << 8;
+      }, a.prototype.readUInt16BE = function(t, e) {
+        return t = t >>> 0, e || J(t, 2, this.length), this[t] << 8 | this[t + 1];
+      }, a.prototype.readUInt32LE = function(t, e) {
+        return t = t >>> 0, e || J(t, 4, this.length), (this[t] | this[t + 1] << 8 | this[t + 2] << 16) + this[t + 3] * 16777216;
+      }, a.prototype.readUInt32BE = function(t, e) {
+        return t = t >>> 0, e || J(t, 4, this.length), this[t] * 16777216 + (this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3]);
+      }, a.prototype.readIntLE = function(t, e, c) {
+        t = t >>> 0, e = e >>> 0, c || J(t, e, this.length);
+        for (var w = this[t], P = 1, S = 0; ++S < e && (P *= 256); )
+          w += this[t + S] * P;
+        return P *= 128, w >= P && (w -= Math.pow(2, 8 * e)), w;
+      }, a.prototype.readIntBE = function(t, e, c) {
+        t = t >>> 0, e = e >>> 0, c || J(t, e, this.length);
+        for (var w = e, P = 1, S = this[t + --w]; w > 0 && (P *= 256); )
+          S += this[t + --w] * P;
+        return P *= 128, S >= P && (S -= Math.pow(2, 8 * e)), S;
+      }, a.prototype.readInt8 = function(t, e) {
+        return t = t >>> 0, e || J(t, 1, this.length), this[t] & 128 ? (255 - this[t] + 1) * -1 : this[t];
+      }, a.prototype.readInt16LE = function(t, e) {
+        t = t >>> 0, e || J(t, 2, this.length);
+        var c = this[t] | this[t + 1] << 8;
+        return c & 32768 ? c | 4294901760 : c;
+      }, a.prototype.readInt16BE = function(t, e) {
+        t = t >>> 0, e || J(t, 2, this.length);
+        var c = this[t + 1] | this[t] << 8;
+        return c & 32768 ? c | 4294901760 : c;
+      }, a.prototype.readInt32LE = function(t, e) {
+        return t = t >>> 0, e || J(t, 4, this.length), this[t] | this[t + 1] << 8 | this[t + 2] << 16 | this[t + 3] << 24;
+      }, a.prototype.readInt32BE = function(t, e) {
+        return t = t >>> 0, e || J(t, 4, this.length), this[t] << 24 | this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3];
+      }, a.prototype.readFloatLE = function(t, e) {
+        return t = t >>> 0, e || J(t, 4, this.length), d.read(this, t, !0, 23, 4);
+      }, a.prototype.readFloatBE = function(t, e) {
+        return t = t >>> 0, e || J(t, 4, this.length), d.read(this, t, !1, 23, 4);
+      }, a.prototype.readDoubleLE = function(t, e) {
+        return t = t >>> 0, e || J(t, 8, this.length), d.read(this, t, !0, 52, 8);
+      }, a.prototype.readDoubleBE = function(t, e) {
+        return t = t >>> 0, e || J(t, 8, this.length), d.read(this, t, !1, 52, 8);
+      };
+      function q(o, t, e, c, w, P) {
+        if (!a.isBuffer(o))
+          throw new TypeError('"buffer" argument must be a Buffer instance');
+        if (t > w || t < P)
+          throw new RangeError('"value" argument is out of bounds');
+        if (e + c > o.length)
+          throw new RangeError("Index out of range");
+      }
+      a.prototype.writeUIntLE = function(t, e, c, w) {
+        if (t = +t, e = e >>> 0, c = c >>> 0, !w) {
+          var P = Math.pow(2, 8 * c) - 1;
+          q(this, t, e, c, P, 0);
+        }
+        var S = 1, H = 0;
+        for (this[e] = t & 255; ++H < c && (S *= 256); )
+          this[e + H] = t / S & 255;
+        return e + c;
+      }, a.prototype.writeUIntBE = function(t, e, c, w) {
+        if (t = +t, e = e >>> 0, c = c >>> 0, !w) {
+          var P = Math.pow(2, 8 * c) - 1;
+          q(this, t, e, c, P, 0);
+        }
+        var S = c - 1, H = 1;
+        for (this[e + S] = t & 255; --S >= 0 && (H *= 256); )
+          this[e + S] = t / H & 255;
+        return e + c;
+      }, a.prototype.writeUInt8 = function(t, e, c) {
+        return t = +t, e = e >>> 0, c || q(this, t, e, 1, 255, 0), this[e] = t & 255, e + 1;
+      }, a.prototype.writeUInt16LE = function(t, e, c) {
+        return t = +t, e = e >>> 0, c || q(this, t, e, 2, 65535, 0), this[e] = t & 255, this[e + 1] = t >>> 8, e + 2;
+      }, a.prototype.writeUInt16BE = function(t, e, c) {
+        return t = +t, e = e >>> 0, c || q(this, t, e, 2, 65535, 0), this[e] = t >>> 8, this[e + 1] = t & 255, e + 2;
+      }, a.prototype.writeUInt32LE = function(t, e, c) {
+        return t = +t, e = e >>> 0, c || q(this, t, e, 4, 4294967295, 0), this[e + 3] = t >>> 24, this[e + 2] = t >>> 16, this[e + 1] = t >>> 8, this[e] = t & 255, e + 4;
+      }, a.prototype.writeUInt32BE = function(t, e, c) {
+        return t = +t, e = e >>> 0, c || q(this, t, e, 4, 4294967295, 0), this[e] = t >>> 24, this[e + 1] = t >>> 16, this[e + 2] = t >>> 8, this[e + 3] = t & 255, e + 4;
+      }, a.prototype.writeIntLE = function(t, e, c, w) {
+        if (t = +t, e = e >>> 0, !w) {
+          var P = Math.pow(2, 8 * c - 1);
+          q(this, t, e, c, P - 1, -P);
+        }
+        var S = 0, H = 1, G = 0;
+        for (this[e] = t & 255; ++S < c && (H *= 256); )
+          t < 0 && G === 0 && this[e + S - 1] !== 0 && (G = 1), this[e + S] = (t / H >> 0) - G & 255;
+        return e + c;
+      }, a.prototype.writeIntBE = function(t, e, c, w) {
+        if (t = +t, e = e >>> 0, !w) {
+          var P = Math.pow(2, 8 * c - 1);
+          q(this, t, e, c, P - 1, -P);
+        }
+        var S = c - 1, H = 1, G = 0;
+        for (this[e + S] = t & 255; --S >= 0 && (H *= 256); )
+          t < 0 && G === 0 && this[e + S + 1] !== 0 && (G = 1), this[e + S] = (t / H >> 0) - G & 255;
+        return e + c;
+      }, a.prototype.writeInt8 = function(t, e, c) {
+        return t = +t, e = e >>> 0, c || q(this, t, e, 1, 127, -128), t < 0 && (t = 255 + t + 1), this[e] = t & 255, e + 1;
+      }, a.prototype.writeInt16LE = function(t, e, c) {
+        return t = +t, e = e >>> 0, c || q(this, t, e, 2, 32767, -32768), this[e] = t & 255, this[e + 1] = t >>> 8, e + 2;
+      }, a.prototype.writeInt16BE = function(t, e, c) {
+        return t = +t, e = e >>> 0, c || q(this, t, e, 2, 32767, -32768), this[e] = t >>> 8, this[e + 1] = t & 255, e + 2;
+      }, a.prototype.writeInt32LE = function(t, e, c) {
+        return t = +t, e = e >>> 0, c || q(this, t, e, 4, 2147483647, -2147483648), this[e] = t & 255, this[e + 1] = t >>> 8, this[e + 2] = t >>> 16, this[e + 3] = t >>> 24, e + 4;
+      }, a.prototype.writeInt32BE = function(t, e, c) {
+        return t = +t, e = e >>> 0, c || q(this, t, e, 4, 2147483647, -2147483648), t < 0 && (t = 4294967295 + t + 1), this[e] = t >>> 24, this[e + 1] = t >>> 16, this[e + 2] = t >>> 8, this[e + 3] = t & 255, e + 4;
+      };
+      function at(o, t, e, c, w, P) {
+        if (e + c > o.length)
+          throw new RangeError("Index out of range");
+        if (e < 0)
+          throw new RangeError("Index out of range");
+      }
+      function it(o, t, e, c, w) {
+        return t = +t, e = e >>> 0, w || at(o, t, e, 4), d.write(o, t, e, c, 23, 4), e + 4;
+      }
+      a.prototype.writeFloatLE = function(t, e, c) {
+        return it(this, t, e, !0, c);
+      }, a.prototype.writeFloatBE = function(t, e, c) {
+        return it(this, t, e, !1, c);
+      };
+      function st(o, t, e, c, w) {
+        return t = +t, e = e >>> 0, w || at(o, t, e, 8), d.write(o, t, e, c, 52, 8), e + 8;
+      }
+      a.prototype.writeDoubleLE = function(t, e, c) {
+        return st(this, t, e, !0, c);
+      }, a.prototype.writeDoubleBE = function(t, e, c) {
+        return st(this, t, e, !1, c);
+      }, a.prototype.copy = function(t, e, c, w) {
+        if (!a.isBuffer(t))
+          throw new TypeError("argument should be a Buffer");
+        if (c || (c = 0), !w && w !== 0 && (w = this.length), e >= t.length && (e = t.length), e || (e = 0), w > 0 && w < c && (w = c), w === c || t.length === 0 || this.length === 0)
+          return 0;
+        if (e < 0)
+          throw new RangeError("targetStart out of bounds");
+        if (c < 0 || c >= this.length)
+          throw new RangeError("Index out of range");
+        if (w < 0)
+          throw new RangeError("sourceEnd out of bounds");
+        w > this.length && (w = this.length), t.length - e < w - c && (w = t.length - e + c);
+        var P = w - c;
+        if (this === t && typeof Uint8Array.prototype.copyWithin == "function")
+          this.copyWithin(e, c, w);
+        else if (this === t && c < e && e < w)
+          for (var S = P - 1; S >= 0; --S)
+            t[S + e] = this[S + c];
+        else
+          Uint8Array.prototype.set.call(
+            t,
+            this.subarray(c, w),
+            e
+          );
+        return P;
+      }, a.prototype.fill = function(t, e, c, w) {
+        if (typeof t == "string") {
+          if (typeof e == "string" ? (w = e, e = 0, c = this.length) : typeof c == "string" && (w = c, c = this.length), w !== void 0 && typeof w != "string")
+            throw new TypeError("encoding must be a string");
+          if (typeof w == "string" && !a.isEncoding(w))
+            throw new TypeError("Unknown encoding: " + w);
+          if (t.length === 1) {
+            var P = t.charCodeAt(0);
+            (w === "utf8" && P < 128 || w === "latin1") && (t = P);
+          }
+        } else
+          typeof t == "number" ? t = t & 255 : typeof t == "boolean" && (t = Number(t));
+        if (e < 0 || this.length < e || this.length < c)
+          throw new RangeError("Out of range index");
+        if (c <= e)
+          return this;
+        e = e >>> 0, c = c === void 0 ? this.length : c >>> 0, t || (t = 0);
+        var S;
+        if (typeof t == "number")
+          for (S = e; S < c; ++S)
+            this[S] = t;
+        else {
+          var H = a.isBuffer(t) ? t : a.from(t, w), G = H.length;
+          if (G === 0)
+            throw new TypeError('The value "' + t + '" is invalid for argument "value"');
+          for (S = 0; S < c - e; ++S)
+            this[S + e] = H[S % G];
+        }
+        return this;
+      };
+      var ut = /[^+/0-9A-Za-z-_]/g;
+      function vt(o) {
+        if (o = o.split("=")[0], o = o.trim().replace(ut, ""), o.length < 2)
+          return "";
+        for (; o.length % 4 !== 0; )
+          o = o + "=";
+        return o;
+      }
+      function rt(o, t) {
+        t = t || 1 / 0;
+        for (var e, c = o.length, w = null, P = [], S = 0; S < c; ++S) {
+          if (e = o.charCodeAt(S), e > 55295 && e < 57344) {
+            if (!w) {
+              if (e > 56319) {
+                (t -= 3) > -1 && P.push(239, 191, 189);
+                continue;
+              } else if (S + 1 === c) {
+                (t -= 3) > -1 && P.push(239, 191, 189);
+                continue;
+              }
+              w = e;
+              continue;
+            }
+            if (e < 56320) {
+              (t -= 3) > -1 && P.push(239, 191, 189), w = e;
+              continue;
+            }
+            e = (w - 55296 << 10 | e - 56320) + 65536;
+          } else
+            w && (t -= 3) > -1 && P.push(239, 191, 189);
+          if (w = null, e < 128) {
+            if ((t -= 1) < 0)
+              break;
+            P.push(e);
+          } else if (e < 2048) {
+            if ((t -= 2) < 0)
+              break;
+            P.push(
+              e >> 6 | 192,
+              e & 63 | 128
+            );
+          } else if (e < 65536) {
+            if ((t -= 3) < 0)
+              break;
+            P.push(
+              e >> 12 | 224,
+              e >> 6 & 63 | 128,
+              e & 63 | 128
+            );
+          } else if (e < 1114112) {
+            if ((t -= 4) < 0)
+              break;
+            P.push(
+              e >> 18 | 240,
+              e >> 12 & 63 | 128,
+              e >> 6 & 63 | 128,
+              e & 63 | 128
+            );
+          } else
+            throw new Error("Invalid code point");
+        }
+        return P;
+      }
+      function ct(o) {
+        for (var t = [], e = 0; e < o.length; ++e)
+          t.push(o.charCodeAt(e) & 255);
+        return t;
+      }
+      function lt(o, t) {
+        for (var e, c, w, P = [], S = 0; S < o.length && !((t -= 2) < 0); ++S)
+          e = o.charCodeAt(S), c = e >> 8, w = e % 256, P.push(w), P.push(c);
+        return P;
+      }
+      function ht(o) {
+        return h.toByteArray(vt(o));
+      }
+      function tt(o, t, e, c) {
+        for (var w = 0; w < c && !(w + e >= t.length || w >= o.length); ++w)
+          t[w + e] = o[w];
+        return w;
+      }
+      function Q(o, t) {
+        return o instanceof t || o != null && o.constructor != null && o.constructor.name != null && o.constructor.name === t.name;
+      }
+      function wt(o) {
+        return o !== o;
+      }
+      var kt = function() {
+        for (var o = "0123456789abcdef", t = new Array(256), e = 0; e < 16; ++e)
+          for (var c = e * 16, w = 0; w < 16; ++w)
+            t[c + w] = o[e] + o[w];
+        return t;
+      }();
+    }, { "base64-js": 29, ieee754: 32 }], 31: [function(n, g, u) {
+      var h = {
+        single_source_shortest_paths: function(d, l, i) {
+          var s = {}, f = {};
+          f[l] = 0;
+          var a = h.PriorityQueue.make();
+          a.push(l, 0);
+          for (var y, x, b, A, F, M, E, B, I; !a.empty(); ) {
+            y = a.pop(), x = y.value, A = y.cost, F = d[x] || {};
+            for (b in F)
+              F.hasOwnProperty(b) && (M = F[b], E = A + M, B = f[b], I = typeof f[b] > "u", (I || B > E) && (f[b] = E, a.push(b, E), s[b] = x));
+          }
+          if (typeof i < "u" && typeof f[i] > "u") {
+            var k = ["Could not find a path from ", l, " to ", i, "."].join("");
+            throw new Error(k);
+          }
+          return s;
+        },
+        extract_shortest_path_from_predecessor_list: function(d, l) {
+          for (var i = [], s = l; s; )
+            i.push(s), d[s], s = d[s];
+          return i.reverse(), i;
+        },
+        find_path: function(d, l, i) {
+          var s = h.single_source_shortest_paths(d, l, i);
+          return h.extract_shortest_path_from_predecessor_list(
+            s,
+            i
+          );
+        },
+        /**
+         * A very naive priority queue implementation.
+         */
+        PriorityQueue: {
+          make: function(d) {
+            var l = h.PriorityQueue, i = {}, s;
+            d = d || {};
+            for (s in l)
+              l.hasOwnProperty(s) && (i[s] = l[s]);
+            return i.queue = [], i.sorter = d.sorter || l.default_sorter, i;
+          },
+          default_sorter: function(d, l) {
+            return d.cost - l.cost;
+          },
+          /**
+           * Add a new item to the queue and ensure the highest priority element
+           * is at the front of the queue.
+           */
+          push: function(d, l) {
+            var i = { value: d, cost: l };
+            this.queue.push(i), 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;
+          }
+        }
+      };
+      typeof g < "u" && (g.exports = h);
+    }, {}], 32: [function(n, g, u) {
+      u.read = function(h, d, l, i, s) {
+        var f, a, y = s * 8 - i - 1, x = (1 << y) - 1, b = x >> 1, A = -7, F = l ? s - 1 : 0, M = l ? -1 : 1, E = h[d + F];
+        for (F += M, f = E & (1 << -A) - 1, E >>= -A, A += y; A > 0; f = f * 256 + h[d + F], F += M, A -= 8)
+          ;
+        for (a = f & (1 << -A) - 1, f >>= -A, A += i; A > 0; a = a * 256 + h[d + F], F += M, A -= 8)
+          ;
+        if (f === 0)
+          f = 1 - b;
+        else {
+          if (f === x)
+            return a ? NaN : (E ? -1 : 1) * (1 / 0);
+          a = a + Math.pow(2, i), f = f - b;
+        }
+        return (E ? -1 : 1) * a * Math.pow(2, f - i);
+      }, u.write = function(h, d, l, i, s, f) {
+        var a, y, x, b = f * 8 - s - 1, A = (1 << b) - 1, F = A >> 1, M = s === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, E = i ? 0 : f - 1, B = i ? 1 : -1, I = d < 0 || d === 0 && 1 / d < 0 ? 1 : 0;
+        for (d = Math.abs(d), isNaN(d) || d === 1 / 0 ? (y = isNaN(d) ? 1 : 0, a = A) : (a = Math.floor(Math.log(d) / Math.LN2), d * (x = Math.pow(2, -a)) < 1 && (a--, x *= 2), a + F >= 1 ? d += M / x : d += M * Math.pow(2, 1 - F), d * x >= 2 && (a++, x /= 2), a + F >= A ? (y = 0, a = A) : a + F >= 1 ? (y = (d * x - 1) * Math.pow(2, s), a = a + F) : (y = d * Math.pow(2, F - 1) * Math.pow(2, s), a = 0)); s >= 8; h[l + E] = y & 255, E += B, y /= 256, s -= 8)
+          ;
+        for (a = a << s | y, b += s; b > 0; h[l + E] = a & 255, E += B, a /= 256, b -= 8)
+          ;
+        h[l + E - B] |= I * 128;
+      };
+    }, {}], 33: [function(n, g, u) {
+      var h = {}.toString;
+      g.exports = Array.isArray || function(d) {
+        return h.call(d) == "[object Array]";
+      };
+    }, {}] }, {}, [24])(24);
+  });
+}), Ot = {
+  name: "qrcode",
+  props: {
+    /**
+     * The value of the QR code.
+     */
+    value: null,
+    /**
+     * The options for the QR code generator.
+     * {@link https://github.com/soldair/node-qrcode#qr-code-options}
+     */
+    options: Object,
+    /**
+     * The tag name of the component's root element.
+     */
+    tag: {
+      type: String,
+      default: "canvas"
+    }
+  },
+  render: function(r) {
+    return r(this.tag, this.$slots.default);
+  },
+  watch: {
+    $props: {
+      deep: !0,
+      immediate: !0,
+      /**
+       * Update the QR code when props changed.
+       */
+      handler: function() {
+        this.$el && this.generate();
+      }
+    }
+  },
+  methods: {
+    /**
+     * Generate QR code.
+     */
+    generate: function() {
+      var r = this, n = this.options, g = this.tag, u = String(this.value);
+      g === "canvas" ? xt.toCanvas(this.$el, u, n, function(h) {
+        if (h)
+          throw h;
+      }) : g === "img" ? xt.toDataURL(u, n, function(h, d) {
+        if (h)
+          throw h;
+        r.$el.src = d;
+      }) : xt.toString(u, n, function(h, d) {
+        if (h)
+          throw h;
+        r.$el.innerHTML = d;
+      });
+    }
+  },
+  mounted: function() {
+    this.generate();
+  }
+};
+class zt {
+  constructor() {
+    this._activePolls = {}, this._pollingInterval = 1e3;
+  }
+  _startPolling(r) {
+    const { handler: n, interval: g } = this._activePolls[r], u = async () => {
+      var h;
+      await n(), (h = this._activePolls[r]) != null && h.pollActive && setTimeout(u, g || this._pollingInterval);
+    };
+    u();
+  }
+  /**
+   * Add a new poll to the active polls list.
+   * @param {string} options.id - Unique identifier for the poll.
+   * @param {function} options.handler - Function to be executed when the poll is activated.
+   * @param {number} options.interval - Time interval in milliseconds at which the poll should run.
+   * @param {number} [options.removeAfterMs=0] - Optional. Time in milliseconds after which the poll should be automatically removed.
+   * @param {boolean} [options.startImmediately=true] - Optional. If true, the poll will start immediately after being added.
+   * @param {*} [options.data] - Optional. Additional data associated with the poll.
+   * @returns {function} - A function that can be used to manually remove the poll from the active polls list.
+   */
+  addPoll({
+    id: r,
+    handler: n,
+    interval: g,
+    removeAfterMs: u = 0,
+    startImmediately: h = !0,
+    data: d
+  }) {
+    if (!r || typeof n != "function")
+      throw new Error("Invalid poll definition");
+    if (this._activePolls[r])
+      throw new Error("Poll with the same ID already exists");
+    return this._activePolls[r] = { handler: n, interval: g, pollActive: !1, data: d }, h && setTimeout(() => {
+      this.activatePoll(r);
+    }, 0), u && setTimeout(() => {
+      this._activePolls[r] && this.removePoll(r);
+    }, u), () => this.removePoll(r);
+  }
+  activatePoll(r) {
+    if (!this._activePolls[r])
+      throw new Error("Poll not found");
+    this._activePolls[r].pollActive || (this._activePolls[r].pollActive = !0, this._startPolling(r));
+  }
+  deactivatePoll(r) {
+    if (!this._activePolls[r]) {
+      console.warn("[deactivatePoll] Poll not found");
+      return;
+    }
+    this._activePolls[r].pollActive = !1;
+  }
+  removePoll(r) {
+    if (!this._activePolls[r]) {
+      console.warn("[removePoll] Poll not found");
+      return;
+    }
+    delete this._activePolls[r];
+  }
+}
+let _t = null;
+function Ft() {
+  return _t || (_t = new zt()), _t;
+}
+function Yt(v) {
+  window.history.replaceState({}, "", window.location.href);
+  let r = "";
+  const n = (navigator == null ? void 0 : navigator.userAgent) || "";
+  return n.match("CriOS") ? r = "googlechromes://" : n.match("FxiOS") ? r = "firefox://" : n.match("GSA") && (r = "googleapp://open-url?url="), r + encodeURIComponent(`${window.location.href}#${v}`);
+}
+const Wt = {
+  name: "BankIdAnswer",
+  components: {
+    QrCode: Ot
+  },
+  mixins: [ft([])],
+  props: {
+    onCompleteFunc: {
+      type: Function,
+      default: null
+    }
+  },
+  data() {
+    return {
+      signAnswerId: null,
+      view: "form",
+      errorMessage: "",
+      isLoading: !1,
+      qrCode: null,
+      autoStartToken: null,
+      isMobile: !1
+    };
+  },
+  computed: {
+    viewText() {
+      const v = (r) => this._document.$t(`answerModal.bankId.component.viewText.${r}`);
+      return {
+        new: {
+          title: v("new.title"),
+          text: v("new.text"),
+          spinnerText: v("new.spinnerText")
+        },
+        waiting: {
+          title: v("waiting.title"),
+          text: v("waiting.text"),
+          spinnerText: v("waiting.spinnerText")
+        },
+        started: {
+          title: v("waiting.title"),
+          text: v("waiting.text"),
+          spinnerText: v("waiting.spinnerText")
+        },
+        signing: {
+          title: v("signing.title"),
+          text: v("signing.text"),
+          spinnerText: v("signing.spinnerText")
+        },
+        error: {
+          title: v("error.title"),
+          text: v("error.text")
+        },
+        canceled: {
+          title: v("canceled.title"),
+          text: v("canceled.text")
+        }
+      };
+    }
+  },
+  watch: {
+    isLoading(v) {
+      this.$emit("loading", v);
+    }
+  },
+  created() {
+    this.isMobile = It(), this.tryResumeSigningSession();
+  },
+  methods: {
+    tryResumeSigningSession() {
+      var n, g;
+      const v = Ft(), r = Object.keys(v._activePolls).find(
+        (u) => u.includes("bankId-")
+      );
+      try {
+        if (r) {
+          const { signAnswerId: u, autoStartToken: h, qrCode: d } = ((n = v._activePolls[r]) == null ? void 0 : n.data) || {};
+          this.signAnswerId = u, this.autoStartToken = h, this.qrCode = d, v.removePoll(r), (g = window.location) != null && g.hash && window.history.replaceState(
+            {},
+            "",
+            window.location.pathname
+            // clears search + hash
+          ), this.isLoading = !0, this.startPolling();
+        }
+      } catch {
+        const h = this._document.$t(
+          "answerModal.bankId.component.viewText.error.text"
+        );
+        Tt("error", h);
+      }
+    },
+    async submit({ answer: v }) {
+      try {
+        this.isLoading = !0;
+        const { id: r, autoStartToken: n, qrCodeData: g } = await v({
+          body: { isAccepted: !0 }
+        });
+        n && (this.autoStartToken = n), g && (this.qrCode = g), this.signAnswerId = r, this.startPolling(), this.isMobile && this.triggerAutoStart();
+        return;
+      } catch (r) {
+        this.onError(r);
+      }
+    },
+    async startPolling() {
+      if (!this.signAnswerId)
+        throw Error("Missing signAnswerId");
+      const v = Ft(), r = `bankId-${this.signAnswerId}`, n = async () => {
+        if (!this.signAnswerId)
+          throw Error("Missing signAnswerId");
+        const g = () => {
+          this.clearSignState(), v.removePoll(r);
+        };
+        try {
+          const { data: u } = await Rt.get(this.signAnswerId);
+          u.qrCodeData && (this.qrCode = u.qrCodeData), ["completed", "canceled"].includes(u.status) && g(), u.status === "completed" ? this.onComplete() : u.status === "canceled" ? this.onCanceled() : this.view = u.status;
+        } catch (u) {
+          this.onError(u), g();
+        }
+      };
+      try {
+        v.addPoll({
+          id: r,
+          handler: n,
+          interval: 1e3,
+          data: {
+            signAnswerId: this.signAnswerId,
+            autoStartToken: this.autoStartToken,
+            qrCode: this.qrCode
+          }
+        });
+      } catch {
+        this.clearSignState();
+        const u = this._document.$t(
+          "answerModal.bankId.component.viewText.error.text"
+        );
+        Tt("error", u);
+      }
+    },
+    clearSignState() {
+      this.autoStartToken = null, this.qrCode = null, this.isLoading = !1;
+    },
+    onComplete() {
+      typeof this.onCompleteFunc == "function" && this.onCompleteFunc();
+    },
+    onCanceled() {
+      this.view = "canceled", this.errorMessage = this._document.$t(
+        "answerModal.bankId.component.signingInterrupted"
+      );
+    },
+    onError(v) {
+      var n, g;
+      if (v.httpStatusCode === 409)
+        throw v;
+      this.$emit("error"), this.view = "error";
+      const r = (g = (n = v.response) == null ? void 0 : n.data) == null ? void 0 : g.errorCode;
+      switch (r) {
+        case 9001:
+        case 9002:
+        case 9003:
+        case 9004:
+        case 9005:
+        case 9006:
+        case 9007:
+          Mt.warn(v);
+          break;
+        case 9009:
+          this.$emit("complete");
+          break;
+        default:
+          Et(v, { showMessage: !1 });
+      }
+      this.errorMessage = this.$i18n.te(`errors:${r}`) && this._document.$t(`answerModal.bankId.component.errors.${r}`) || this._document.$t("answerModal.bankId.component.defaultError");
+    },
+    triggerAutoStart() {
+      if (!this.autoStartToken)
+        return;
+      let v = "bankid://", r = "null";
+      if (this.isMobile) {
+        const g = $t(), u = (navigator == null ? void 0 : navigator.userAgent) || (navigator == null ? void 0 : navigator.vendor) || (window == null ? void 0 : window.opera), h = g === "iOS" && (/Version\/[\d.]+.*Safari/.test(u) || /GSA/.test(u)), d = g === "Android" && /Version\/[\d.]+.*Chrome/.test(u);
+        (h || d) && (v = "https://app.bankid.com"), g === "iOS" && this.$view !== "widget" && (r = Yt(this.signAnswerId));
+      }
+      const n = `${v}/?autostarttoken=${this.autoStartToken}&redirect=${r}`;
+      this.isMobile ? document.location = n : this.$refs.autoStartFrame.src = n;
+    }
+  }
+};
+var Ht = function() {
+  var g;
+  var r = this, n = r._self._c;
+  return n("div", { staticClass: "-my-4 flex flex-col items-center" }, [n("iframe", { ref: "autoStartFrame", staticClass: "hidden", attrs: { height: "0", width: "0" } }), ["form", "signing", "error", "canceled"].includes(r.view) ? n("div", { staticClass: "flex h-[250px] w-[250px] items-center justify-center rounded-xl bg-gray-100" }, [n("CIcon", { staticClass: "text-gray-500", attrs: { type: "bankId", size: "50" } })], 1) : r._e(), ["new", "waiting", "started"].includes(r.view) ? [r.qrCode ? n("QrCode", { attrs: { value: r.qrCode, options: {
+    width: 250,
+    errorCorrectionLevel: "L",
+    color: { dark: "#000000" }
+  } } }) : r._e()] : r._e(), n("Animation", { staticClass: "w-full" }, [n("div", { key: "a", staticClass: "min-h-[20px] pt-4 text-sm text-gray-500", domProps: { textContent: r._s((g = r.viewText[r.view]) == null ? void 0 : g.spinnerText) } }), !r.isMobile && ["new", "waiting", "started"].includes(r.view) ? n("CButton", { key: "b", staticClass: "mt-4", attrs: { type: "none", pattern: "secondary", size: "small" }, on: { click: r.triggerAutoStart } }, [r._v(" " + r._s(r._document.$t("answerModal.bankId.component.startOnThisDevice")) + " ")]) : r._e()], 1), ["form", "new", "waiting", "started"].includes(r.view) ? r._e() : n("div", [n("transition", { attrs: { name: "pop-in" } }, [n("div", { staticClass: "bankid-popup", on: { click: () => {
+    r.view = "form", r.isLoading = !1;
+  } } }, [n("div", { staticClass: "flex flex-col items-center justify-center", staticStyle: { "background-color": "#183e4f", padding: "calc(2.5 * var(--rem)) calc(3 * var(--rem))" } }, [n("CIcon", { staticClass: "text-white", attrs: { type: "bankId", size: "34" } }), n("div", { staticClass: "pt-4 text-sm font-medium text-white opacity-75", domProps: { textContent: r._s(r.viewText[r.view].text) } })], 1), n("div", { staticClass: "flex w-full flex-col items-center justify-center text-center", staticStyle: { padding: "calc(3 * var(--rem)) calc(2 * var(--rem))" } }, [r.view === "signing" ? [n("div", { staticClass: "spinner" }), n("div", { staticClass: "pt-8 text-gray-500", domProps: { textContent: r._s(r.viewText[r.view].spinnerText) } })] : ["error", "canceled"].includes(r.view) ? [n("CIcon", { staticClass: "mb-2.5 text-gray-400", attrs: { type: "error", size: "22" } }), n("div", { staticStyle: { "font-size": "14px" }, domProps: { textContent: r._s(r.errorMessage) } }), n("CButton", { staticStyle: { "margin-top": "calc(2.5 * var(--rem))", padding: "1em", height: "initial" }, attrs: { loading: r.isLoading, type: "none", pattern: "secondary", size: "small" }, on: { click: function(u) {
+    r.view = "form";
+  } } }, [r._v(" " + r._s(r._document.$t("tryAgain")) + " ")])] : r._e()], 2)])])], 1)], 2);
+}, jt = [], Gt = /* @__PURE__ */ ot(
+  Wt,
+  Ht,
+  jt,
+  !1,
+  null,
+  "091e7765"
+);
+const Kt = Gt.exports, Vt = {
+  name: "DenyAnswer",
+  mixins: [ft([])],
+  props: {
+    onCompleteFunc: {
+      type: Function,
+      default: null
+    }
+  },
+  data() {
+    return {
+      rejectReason: ""
+    };
+  },
+  methods: {
+    async submit({ update: v, answer: r }) {
+      const n = [];
+      this.rejectReason && n.push({
+        key: "unclear-other",
+        category: "misc",
+        description: this.rejectReason,
+        sentAt: this._document.lastSentAt
+      }), await v({ body: { "data.rejectReasons": n } }), await r({ body: { isAccepted: !1 } }), typeof this.onCompleteFunc == "function" && this.onCompleteFunc();
+    }
+  }
+};
+var Jt = function() {
+  var r = this, n = r._self._c;
+  return n("div", { staticClass: "text-left" }, [n("label", [r._v(r._s(r._document.$t("answerModal.decline.component.label")))]), n("CInput", { staticStyle: { "margin-bottom": "calc(1.5 * var(--rem))" }, attrs: { type: "textarea", filled: "", "custom-class": "decline-input" }, model: { value: r.rejectReason, callback: function(g) {
+    r.rejectReason = g;
+  }, expression: "rejectReason" } })], 1);
+}, Xt = [], Qt = /* @__PURE__ */ ot(
+  Vt,
+  Jt,
+  Xt,
+  !1,
+  null,
+  null
+);
+const qt = Qt.exports;
+/*!
+ * Signature Pad v4.0.10 | https://github.com/szimek/signature_pad
+ * (c) 2022 Szymon Nowak | Released under the MIT license
+ */
+class pt {
+  constructor(r, n, g, u) {
+    if (isNaN(r) || isNaN(n))
+      throw new Error(`Point is invalid: (${r}, ${n})`);
+    this.x = +r, this.y = +n, this.pressure = g || 0, this.time = u || Date.now();
+  }
+  distanceTo(r) {
+    return Math.sqrt(Math.pow(this.x - r.x, 2) + Math.pow(this.y - r.y, 2));
+  }
+  equals(r) {
+    return this.x === r.x && this.y === r.y && this.pressure === r.pressure && this.time === r.time;
+  }
+  velocityFrom(r) {
+    return this.time !== r.time ? this.distanceTo(r) / (this.time - r.time) : 0;
+  }
+}
+class bt {
+  constructor(r, n, g, u, h, d) {
+    this.startPoint = r, this.control2 = n, this.control1 = g, this.endPoint = u, this.startWidth = h, this.endWidth = d;
+  }
+  static fromPoints(r, n) {
+    const g = this.calculateControlPoints(r[0], r[1], r[2]).c2, u = this.calculateControlPoints(r[1], r[2], r[3]).c1;
+    return new bt(r[1], g, u, r[2], n.start, n.end);
+  }
+  static calculateControlPoints(r, n, g) {
+    const u = r.x - n.x, h = r.y - n.y, d = n.x - g.x, l = n.y - g.y, i = { x: (r.x + n.x) / 2, y: (r.y + n.y) / 2 }, s = { x: (n.x + g.x) / 2, y: (n.y + g.y) / 2 }, f = Math.sqrt(u * u + h * h), a = Math.sqrt(d * d + l * l), y = i.x - s.x, x = i.y - s.y, b = a / (f + a), A = { x: s.x + y * b, y: s.y + x * b }, F = n.x - A.x, M = n.y - A.y;
+    return {
+      c1: new pt(i.x + F, i.y + M),
+      c2: new pt(s.x + F, s.y + M)
+    };
+  }
+  length() {
+    let n = 0, g, u;
+    for (let h = 0; h <= 10; h += 1) {
+      const d = h / 10, l = this.point(d, this.startPoint.x, this.control1.x, this.control2.x, this.endPoint.x), i = this.point(d, this.startPoint.y, this.control1.y, this.control2.y, this.endPoint.y);
+      if (h > 0) {
+        const s = l - g, f = i - u;
+        n += Math.sqrt(s * s + f * f);
+      }
+      g = l, u = i;
+    }
+    return n;
+  }
+  point(r, n, g, u, h) {
+    return n * (1 - r) * (1 - r) * (1 - r) + 3 * g * (1 - r) * (1 - r) * r + 3 * u * (1 - r) * r * r + h * r * r * r;
+  }
+}
+class Zt {
+  constructor() {
+    try {
+      this._et = new EventTarget();
+    } catch {
+      this._et = document;
+    }
+  }
+  addEventListener(r, n, g) {
+    this._et.addEventListener(r, n, g);
+  }
+  dispatchEvent(r) {
+    return this._et.dispatchEvent(r);
+  }
+  removeEventListener(r, n, g) {
+    this._et.removeEventListener(r, n, g);
+  }
+}
+function te(v, r = 250) {
+  let n = 0, g = null, u, h, d;
+  const l = () => {
+    n = Date.now(), g = null, u = v.apply(h, d), g || (h = null, d = []);
+  };
+  return function(...s) {
+    const f = Date.now(), a = r - (f - n);
+    return h = this, d = s, a <= 0 || a > r ? (g && (clearTimeout(g), g = null), n = f, u = v.apply(h, d), g || (h = null, d = [])) : g || (g = window.setTimeout(l, a)), u;
+  };
+}
+let ee = class Ct extends Zt {
+  constructor(r, n = {}) {
+    super(), this.canvas = r, this._handleMouseDown = (g) => {
+      g.buttons === 1 && (this._drawningStroke = !0, this._strokeBegin(g));
+    }, this._handleMouseMove = (g) => {
+      this._drawningStroke && this._strokeMoveUpdate(g);
+    }, this._handleMouseUp = (g) => {
+      g.buttons === 1 && this._drawningStroke && (this._drawningStroke = !1, this._strokeEnd(g));
+    }, this._handleTouchStart = (g) => {
+      if (g.cancelable && g.preventDefault(), g.targetTouches.length === 1) {
+        const u = g.changedTouches[0];
+        this._strokeBegin(u);
+      }
+    }, this._handleTouchMove = (g) => {
+      g.cancelable && g.preventDefault();
+      const u = g.targetTouches[0];
+      this._strokeMoveUpdate(u);
+    }, this._handleTouchEnd = (g) => {
+      if (g.target === this.canvas) {
+        g.cancelable && g.preventDefault();
+        const h = g.changedTouches[0];
+        this._strokeEnd(h);
+      }
+    }, this._handlePointerStart = (g) => {
+      this._drawningStroke = !0, g.preventDefault(), this._strokeBegin(g);
+    }, this._handlePointerMove = (g) => {
+      this._drawningStroke && (g.preventDefault(), this._strokeMoveUpdate(g));
+    }, this._handlePointerEnd = (g) => {
+      this._drawningStroke && (g.preventDefault(), this._drawningStroke = !1, this._strokeEnd(g));
+    }, this.velocityFilterWeight = n.velocityFilterWeight || 0.7, this.minWidth = n.minWidth || 0.5, this.maxWidth = n.maxWidth || 2.5, this.throttle = "throttle" in n ? n.throttle : 16, this.minDistance = "minDistance" in n ? n.minDistance : 5, this.dotSize = n.dotSize || 0, this.penColor = n.penColor || "black", this.backgroundColor = n.backgroundColor || "rgba(0,0,0,0)", this._strokeMoveUpdate = this.throttle ? te(Ct.prototype._strokeUpdate, this.throttle) : Ct.prototype._strokeUpdate, this._ctx = r.getContext("2d"), this.clear(), this.on();
+  }
+  clear() {
+    const { _ctx: r, canvas: n } = this;
+    r.fillStyle = this.backgroundColor, r.clearRect(0, 0, n.width, n.height), r.fillRect(0, 0, n.width, n.height), this._data = [], this._reset(this._getPointGroupOptions()), this._isEmpty = !0;
+  }
+  fromDataURL(r, n = {}) {
+    return new Promise((g, u) => {
+      const h = new Image(), d = n.ratio || window.devicePixelRatio || 1, l = n.width || this.canvas.width / d, i = n.height || this.canvas.height / d, s = n.xOffset || 0, f = n.yOffset || 0;
+      this._reset(this._getPointGroupOptions()), h.onload = () => {
+        this._ctx.drawImage(h, s, f, l, i), g();
+      }, h.onerror = (a) => {
+        u(a);
+      }, h.crossOrigin = "anonymous", h.src = r, this._isEmpty = !1;
+    });
+  }
+  toDataURL(r = "image/png", n) {
+    switch (r) {
+      case "image/svg+xml":
+        return this._toSVG();
+      default:
+        return this.canvas.toDataURL(r, n);
+    }
+  }
+  on() {
+    this.canvas.style.touchAction = "none", this.canvas.style.msTouchAction = "none", this.canvas.style.userSelect = "none";
+    const r = /Macintosh/.test(navigator.userAgent) && "ontouchstart" in document;
+    window.PointerEvent && !r ? this._handlePointerEvents() : (this._handleMouseEvents(), "ontouchstart" in window && this._handleTouchEvents());
+  }
+  off() {
+    this.canvas.style.touchAction = "auto", this.canvas.style.msTouchAction = "auto", this.canvas.style.userSelect = "auto", this.canvas.removeEventListener("pointerdown", this._handlePointerStart), this.canvas.removeEventListener("pointermove", this._handlePointerMove), this.canvas.ownerDocument.removeEventListener("pointerup", this._handlePointerEnd), this.canvas.removeEventListener("mousedown", this._handleMouseDown), this.canvas.removeEventListener("mousemove", this._handleMouseMove), this.canvas.ownerDocument.removeEventListener("mouseup", this._handleMouseUp), this.canvas.removeEventListener("touchstart", this._handleTouchStart), this.canvas.removeEventListener("touchmove", this._handleTouchMove), this.canvas.removeEventListener("touchend", this._handleTouchEnd);
+  }
+  isEmpty() {
+    return this._isEmpty;
+  }
+  fromData(r, { clear: n = !0 } = {}) {
+    n && this.clear(), this._fromData(r, this._drawCurve.bind(this), this._drawDot.bind(this)), this._data = this._data.concat(r);
+  }
+  toData() {
+    return this._data;
+  }
+  _getPointGroupOptions(r) {
+    return {
+      penColor: r && "penColor" in r ? r.penColor : this.penColor,
+      dotSize: r && "dotSize" in r ? r.dotSize : this.dotSize,
+      minWidth: r && "minWidth" in r ? r.minWidth : this.minWidth,
+      maxWidth: r && "maxWidth" in r ? r.maxWidth : this.maxWidth,
+      velocityFilterWeight: r && "velocityFilterWeight" in r ? r.velocityFilterWeight : this.velocityFilterWeight
+    };
+  }
+  _strokeBegin(r) {
+    this.dispatchEvent(new CustomEvent("beginStroke", { detail: r }));
+    const n = this._getPointGroupOptions(), g = Object.assign(Object.assign({}, n), { points: [] });
+    this._data.push(g), this._reset(n), this._strokeUpdate(r);
+  }
+  _strokeUpdate(r) {
+    if (this._data.length === 0) {
+      this._strokeBegin(r);
+      return;
+    }
+    this.dispatchEvent(new CustomEvent("beforeUpdateStroke", { detail: r }));
+    const n = r.clientX, g = r.clientY, u = r.pressure !== void 0 ? r.pressure : r.force !== void 0 ? r.force : 0, h = this._createPoint(n, g, u), d = this._data[this._data.length - 1], l = d.points, i = l.length > 0 && l[l.length - 1], s = i ? h.distanceTo(i) <= this.minDistance : !1, f = this._getPointGroupOptions(d);
+    if (!i || !(i && s)) {
+      const a = this._addPoint(h, f);
+      i ? a && this._drawCurve(a, f) : this._drawDot(h, f), l.push({
+        time: h.time,
+        x: h.x,
+        y: h.y,
+        pressure: h.pressure
+      });
+    }
+    this.dispatchEvent(new CustomEvent("afterUpdateStroke", { detail: r }));
+  }
+  _strokeEnd(r) {
+    this._strokeUpdate(r), this.dispatchEvent(new CustomEvent("endStroke", { detail: r }));
+  }
+  _handlePointerEvents() {
+    this._drawningStroke = !1, this.canvas.addEventListener("pointerdown", this._handlePointerStart), this.canvas.addEventListener("pointermove", this._handlePointerMove), this.canvas.ownerDocument.addEventListener("pointerup", this._handlePointerEnd);
+  }
+  _handleMouseEvents() {
+    this._drawningStroke = !1, this.canvas.addEventListener("mousedown", this._handleMouseDown), this.canvas.addEventListener("mousemove", this._handleMouseMove), this.canvas.ownerDocument.addEventListener("mouseup", this._handleMouseUp);
+  }
+  _handleTouchEvents() {
+    this.canvas.addEventListener("touchstart", this._handleTouchStart), this.canvas.addEventListener("touchmove", this._handleTouchMove), this.canvas.addEventListener("touchend", this._handleTouchEnd);
+  }
+  _reset(r) {
+    this._lastPoints = [], this._lastVelocity = 0, this._lastWidth = (r.minWidth + r.maxWidth) / 2, this._ctx.fillStyle = r.penColor;
+  }
+  _createPoint(r, n, g) {
+    const u = this.canvas.getBoundingClientRect();
+    return new pt(r - u.left, n - u.top, g, (/* @__PURE__ */ new Date()).getTime());
+  }
+  _addPoint(r, n) {
+    const { _lastPoints: g } = this;
+    if (g.push(r), g.length > 2) {
+      g.length === 3 && g.unshift(g[0]);
+      const u = this._calculateCurveWidths(g[1], g[2], n), h = bt.fromPoints(g, u);
+      return g.shift(), h;
+    }
+    return null;
+  }
+  _calculateCurveWidths(r, n, g) {
+    const u = g.velocityFilterWeight * n.velocityFrom(r) + (1 - g.velocityFilterWeight) * this._lastVelocity, h = this._strokeWidth(u, g), d = {
+      end: h,
+      start: this._lastWidth
+    };
+    return this._lastVelocity = u, this._lastWidth = h, d;
+  }
+  _strokeWidth(r, n) {
+    return Math.max(n.maxWidth / (r + 1), n.minWidth);
+  }
+  _drawCurveSegment(r, n, g) {
+    const u = this._ctx;
+    u.moveTo(r, n), u.arc(r, n, g, 0, 2 * Math.PI, !1), this._isEmpty = !1;
+  }
+  _drawCurve(r, n) {
+    const g = this._ctx, u = r.endWidth - r.startWidth, h = Math.ceil(r.length()) * 2;
+    g.beginPath(), g.fillStyle = n.penColor;
+    for (let d = 0; d < h; d += 1) {
+      const l = d / h, i = l * l, s = i * l, f = 1 - l, a = f * f, y = a * f;
+      let x = y * r.startPoint.x;
+      x += 3 * a * l * r.control1.x, x += 3 * f * i * r.control2.x, x += s * r.endPoint.x;
+      let b = y * r.startPoint.y;
+      b += 3 * a * l * r.control1.y, b += 3 * f * i * r.control2.y, b += s * r.endPoint.y;
+      const A = Math.min(r.startWidth + s * u, n.maxWidth);
+      this._drawCurveSegment(x, b, A);
+    }
+    g.closePath(), g.fill();
+  }
+  _drawDot(r, n) {
+    const g = this._ctx, u = n.dotSize > 0 ? n.dotSize : (n.minWidth + n.maxWidth) / 2;
+    g.beginPath(), this._drawCurveSegment(r.x, r.y, u), g.closePath(), g.fillStyle = n.penColor, g.fill();
+  }
+  _fromData(r, n, g) {
+    for (const u of r) {
+      const { points: h } = u, d = this._getPointGroupOptions(u);
+      if (h.length > 1)
+        for (let l = 0; l < h.length; l += 1) {
+          const i = h[l], s = new pt(i.x, i.y, i.pressure, i.time);
+          l === 0 && this._reset(d);
+          const f = this._addPoint(s, d);
+          f && n(f, d);
+        }
+      else
+        this._reset(d), g(h[0], d);
+    }
+  }
+  _toSVG() {
+    const r = this._data, n = Math.max(window.devicePixelRatio || 1, 1), g = 0, u = 0, h = this.canvas.width / n, d = this.canvas.height / n, l = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    l.setAttribute("width", this.canvas.width.toString()), l.setAttribute("height", this.canvas.height.toString()), this._fromData(r, (x, { penColor: b }) => {
+      const A = document.createElement("path");
+      if (!isNaN(x.control1.x) && !isNaN(x.control1.y) && !isNaN(x.control2.x) && !isNaN(x.control2.y)) {
+        const F = `M ${x.startPoint.x.toFixed(3)},${x.startPoint.y.toFixed(3)} C ${x.control1.x.toFixed(3)},${x.control1.y.toFixed(3)} ${x.control2.x.toFixed(3)},${x.control2.y.toFixed(3)} ${x.endPoint.x.toFixed(3)},${x.endPoint.y.toFixed(3)}`;
+        A.setAttribute("d", F), A.setAttribute("stroke-width", (x.endWidth * 2.25).toFixed(3)), A.setAttribute("stroke", b), A.setAttribute("fill", "none"), A.setAttribute("stroke-linecap", "round"), l.appendChild(A);
+      }
+    }, (x, { penColor: b, dotSize: A, minWidth: F, maxWidth: M }) => {
+      const E = document.createElement("circle"), B = A > 0 ? A : (F + M) / 2;
+      E.setAttribute("r", B.toString()), E.setAttribute("cx", x.x.toString()), E.setAttribute("cy", x.y.toString()), E.setAttribute("fill", b), l.appendChild(E);
+    });
+    const i = "data:image/svg+xml;base64,", s = `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="${g} ${u} ${h} ${d}" width="${h}" height="${d}">`;
+    let f = l.innerHTML;
+    if (f === void 0) {
+      const x = document.createElement("dummy"), b = l.childNodes;
+      x.innerHTML = "";
+      for (let A = 0; A < b.length; A += 1)
+        x.appendChild(b[A].cloneNode(!0));
+      f = x.innerHTML;
+    }
+    const y = s + f + "</svg>";
+    return i + btoa(y);
+  }
+}, re = class extends ee {
+  fromText(r, n = {}) {
+    if (this.clear(), !r)
+      return;
+    const { font: g, x: u = 10, y: h = 50 } = n;
+    let { maxWidth: d } = n;
+    if (!d) {
+      const { clientWidth: l = 300 } = this.canvas;
+      d = Math.floor(l - 2 * u);
+    }
+    this._ctx.font = g, this._ctx.fillText(r, u, h, d), this._isEmpty = !1;
+  }
+};
+const ne = {
+  name: "SignaturePad",
+  props: {
+    type: {
+      type: String,
+      default: "text",
+      validator: (v) => ["text", "draw"].includes(v)
+    },
+    text: {
+      type: String,
+      default: ""
+    },
+    width: {
+      type: String,
+      default: "100%"
+    },
+    height: {
+      type: String,
+      default: "100%"
+    },
+    customStyle: {
+      type: Object,
+      default: () => ({})
+    },
+    options: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Obj on format like {
+        beginStroke: () => {},
+        endStroke: () => {},
+      },
+     */
+    signEvents: {
+      type: Object,
+      default: () => ({})
+    },
+    images: {
+      type: Array,
+      default: () => []
+    }
+  },
+  data() {
+    return {
+      signaturePad: {},
+      onResizeHandler: null,
+      signatureData: "",
+      defaultOptions: {
+        dotSize: 1.5,
+        minWidth: 0.5,
+        maxWidth: 2.5,
+        throttle: 16,
+        minDistance: 3,
+        backgroundColor: "rgba(0,0,0,0)",
+        penColor: "black",
+        velocityFilterWeight: 0.5
+      },
+      validTypes: ["image/png", "image/jpeg", "image/svg+xml"]
+    };
+  },
+  watch: {
+    type() {
+      this.initType();
+    },
+    text(v) {
+      this.drawText(v);
+    }
+  },
+  mounted() {
+    const { options: v, defaultOptions: r } = this, n = this.$refs.signaturePadCanvas;
+    this.signaturePad = new re(n, {
+      ...r,
+      ...v
+    }), this.onResizeHandler = this.resizeCanvas.bind(this), window.addEventListener("resize", this.onResizeHandler, !1), Object.keys(this.signEvents).forEach((g) => {
+      this.signaturePad.addEventListener(g, () => {
+        this.signEvents[g]();
+      });
+    }), this.initType(), this.resizeCanvas();
+  },
+  beforeDestroy() {
+    this.onResizeHandler && window.removeEventListener("resize", this.onResizeHandler, !1);
+  },
+  methods: {
+    initType() {
+      this.type === "draw" ? this.openSignaturePad() : this.lockSignaturePad();
+    },
+    resizeCanvas() {
+      const v = this.$refs.signaturePadCanvas, r = Math.max(window.devicePixelRatio || 1, 1);
+      if (v.width = v.offsetWidth * r, v.height = v.offsetHeight * r, v.getContext("2d").scale(r, r), this.signaturePad.clear(), this.signatureData = "", this.type === "draw") {
+        const n = this.signaturePad.toData();
+        n != null && n.length && this.signaturePad.fromData(n);
+      } else
+        this.type === "text" && this.drawText(this.text);
+    },
+    saveSignature(v = {}) {
+      const { type: r = "image/png", trim: n = !0, encoderOptions: g } = v || {}, u = { isEmpty: !1, data: void 0 };
+      if (!this.validTypes.includes(r)) {
+        const h = this.validTypes.join(", ");
+        throw new Error(
+          `The Image type is incorrect! We only support ${h} types.`
+        );
+      }
+      if (this.signaturePad.isEmpty())
+        return { ...u, isEmpty: !0 };
+      if (n) {
+        const h = this.$refs.signaturePadCanvas, d = h ? this.trimCanvas(h) : null;
+        this.signatureData = d ? d.toDataURL(r, g) : "";
+      } else
+        this.signatureData = this.signaturePad.toDataURL(r, g);
+      return {
+        ...u,
+        data: this.signatureData
+      };
+    },
+    undoSignature() {
+      const { signaturePad: v } = this, r = v.toData();
+      r && v.fromData(r.slice(0, -1));
+    },
+    drawText(v) {
+      this.signaturePad.fromText(v, {
+        font: '40px "Nothing You Could Do"',
+        x: 10,
+        y: 100
+      });
+    },
+    // Extend of module methods
+    fromText(...v) {
+      return this.signaturePad.fromText(...v);
+    },
+    fromDataURL(...v) {
+      return this.signaturePad.fromDataURL(...v);
+    },
+    fromData(...v) {
+      return this.signaturePad.fromData(...v);
+    },
+    toData(...v) {
+      return this.signaturePad.toData(...v);
+    },
+    lockSignaturePad() {
+      return this.signaturePad.off();
+    },
+    openSignaturePad() {
+      return this.signaturePad.on();
+    },
+    isEmpty() {
+      return this.signaturePad.isEmpty();
+    },
+    clearSignature() {
+      return this.signaturePad.clear();
+    },
+    trimCanvas(v) {
+      const r = document.createElement("canvas"), n = r.getContext("2d");
+      r.width = v.width, r.height = v.height, n.drawImage(v, 0, 0);
+      let g = r.width, u = r.height;
+      const h = { x: [], y: [] }, d = n.getImageData(
+        0,
+        0,
+        r.width,
+        r.height
+      );
+      let l = 0;
+      for (let f = 0; f < u; f++)
+        for (let a = 0; a < g; a++)
+          l = (f * g + a) * 4, d.data[l + 3] > 0 && (h.x.push(a), h.y.push(f));
+      h.x.sort((f, a) => f - a), h.y.sort((f, a) => f - a);
+      const i = h.x.length - 1;
+      g = h.x[i] - h.x[0], u = h.y[i] - h.y[0];
+      const s = n.getImageData(h.x[0], h.y[0], g, u);
+      return r.height = u, n.putImageData(s, 0, 0), r;
+    }
+  },
+  render(v) {
+    const { width: r, height: n, customStyle: g } = this;
+    return v(
+      "div",
+      {
+        style: {
+          width: r,
+          height: n,
+          ...g
+        }
+      },
+      [
+        v("canvas", {
+          style: {
+            width: "100%",
+            height: "100%"
+          },
+          ref: "signaturePadCanvas"
+        })
+      ]
+    );
+  }
+}, ie = null, ae = null;
+var oe = /* @__PURE__ */ ot(
+  ne,
+  ie,
+  ae,
+  !1,
+  null,
+  null
+);
+const se = oe.exports;
+function ue({ rel: v, href: r, crossorigin: n = !1 }) {
+  const g = document.createElement("link");
+  g.rel = v, g.href = r, g.crossorigin = n, document.head.appendChild(g);
+}
+const ce = [
+  { rel: "preconnect", href: "https://fonts.googleapis.com" },
+  { rel: "preconnect", href: "https://fonts.gstatic.com", crossorigin: !0 },
+  {
+    rel: "stylesheet",
+    href: "https://fonts.googleapis.com/css2?family=Nothing+You+Could+Do&display=swap"
+  }
+], le = {
+  name: "SignatureAnswer",
+  components: {
+    CField: Lt,
+    SignaturePad: se
+  },
+  mixins: [ft([])],
+  props: {
+    onCompleteFunc: {
+      type: Function,
+      default: null
+    }
+  },
+  data() {
+    return {
+      mode: "text",
+      text: "",
+      isEmpty: !0,
+      penColor: "hsl(220, 100%, 50%)"
+    };
+  },
+  watch: {
+    mode(v) {
+      this.reset(), this.$refs.signaturePad && v === "text" && this.focusName();
+    },
+    text() {
+      this.$refs.signaturePad && this.$nextTick(() => {
+        this.isEmpty = this.$refs.signaturePad.isEmpty();
+      });
+    },
+    isEmpty: {
+      immediate: !0,
+      handler(v) {
+        this.$emit("invalid", v);
+      }
+    }
+  },
+  created() {
+    ce.forEach(ue);
+  },
+  mounted() {
+    this.focusName();
+  },
+  methods: {
+    reset() {
+      this.$refs.signaturePad && (this.$refs.signaturePad.clearSignature(), this.text && (this.text = ""), this.isEmpty = this.$refs.signaturePad.isEmpty());
+    },
+    undo() {
+      this.$refs.signaturePad && (this.mode === "text" && this.text ? this.text = this.text.slice(0, this.text.length - 1) : this.$refs.signaturePad.undoSignature(), this.isEmpty = this.$refs.signaturePad.isEmpty());
+    },
+    getSignatureData() {
+      let v = { type: "image/png", trim: !0 };
+      this.mode === "draw" && (v = { type: "image/svg+xml", trim: !1 });
+      const { isEmpty: r, data: n } = this.$refs.signaturePad ? this.$refs.signaturePad.saveSignature(v) : {};
+      if (r || !n)
+        throw Error("Missing signatureData");
+      return n;
+    },
+    async submit({ answer: v }) {
+      const r = this.getSignatureData();
+      await v({ body: { isAccepted: !0, signatureDataURL: r } }), typeof this.onCompleteFunc == "function" && this.onCompleteFunc();
+    },
+    focusName() {
+      this.$nextTick(
+        () => this.$refs.nameInput ? this.$refs.nameInput.focus() : null
+      );
+    }
+  }
+};
+var he = function() {
+  var r = this, n = r._self._c;
+  return n("div", { staticStyle: { "text-align": "left" } }, [n("div", { staticClass: "flex w-full items-center justify-between", staticStyle: { "font-size": "16px", "padding-bottom": "1em", "font-weight": "500", color: "hsl(0, 0%, 11%)" } }, [n("div", [r._v(r._s(r._document.$t("answerModal.signature.component.subTitle")))]), n("div", { staticClass: "sign-toggle" }, [n("div", { staticClass: "sign-toggle-button", class: { active: r.mode === "text" }, on: { click: function(g) {
+    r.mode = "text";
+  } } }, [r._v(" " + r._s(r._document.$t("answerModal.signature.component.text.tab")) + " ")]), n("div", { staticClass: "sign-toggle-button", class: { active: r.mode === "draw" }, on: { click: function(g) {
+    r.mode = "draw";
+  } } }, [r._v(" " + r._s(r._document.$t("answerModal.signature.component.draw.tab")) + " ")])])]), r.mode === "text" ? n("CField", { attrs: { label: r._document.$t("answerModal.signature.component.text.nameLabel") } }, [n("CInput", { ref: "nameInput", attrs: { placeholder: r._document.$t("answerModal.signature.component.text.namePlaceholder") }, model: { value: r.text, callback: function(g) {
+    r.text = g;
+  }, expression: "text" } })], 1) : r._e(), n("div", { staticClass: "wrapper", staticStyle: { "padding-bottom": "5px" } }, [n("div", { staticClass: "background-image" }, [n("svg", { attrs: { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%" } }, [n("line", { attrs: { x1: "0", y1: "75%", x2: "100%", y2: "75%", stroke: "hsl(0,0%, 70%)", "stroke-width": "1", "stroke-linecap": "round", "stroke-dasharray": "3", "shape-rendering": "crispEdges", "pointer-events": "none" } })])]), n("div", { staticStyle: { position: "absolute", left: "1em", top: "0.75em", "font-size": "12px", color: "hsl(0, 0%, 50%)" } }, [r._v(" " + r._s(r._document.$t(`answerModal.signature.component.${r.mode}.canvasLabel`)) + " ")]), n("span", { staticStyle: { "font-family": "'Nothing You Could Do', cursive" } }), n("SignaturePad", { ref: "signaturePad", staticClass: "signature-pad", attrs: { type: r.mode, text: r.text, options: {
+    penColor: r.penColor
+  }, "sign-events": {
+    endStroke: () => {
+      r.isEmpty = r.$refs.signaturePad ? r.$refs.signaturePad.isEmpty() : !0;
+    }
+  } } })], 1), n("div", { directives: [{ name: "show", rawName: "v-show", value: r.mode === "draw", expression: "mode === 'draw'" }], staticClass: "flex w-full justify-end" }, [n("CButton", { attrs: { disabled: r.isEmpty, type: "text", size: "small", pattern: "tertiary", circle: "", icon: "trash" }, on: { click: r.reset } }), n("CButton", { attrs: { disabled: r.isEmpty, type: "text", size: "small", pattern: "tertiary", circle: "", icon: "rotate-left" }, on: { click: r.undo } })], 1), n("div", { staticClass: "text-center", staticStyle: { "font-size": "12px", color: "hsl(0, 0%, 45%)", "padding-top": "10px" } }, [r._v(" " + r._s(r._document.$t("answerModal.signature.component.terms")) + " ")])], 1);
+}, fe = [], de = /* @__PURE__ */ ot(
+  le,
+  he,
+  fe,
+  !1,
+  null,
+  "e30cd56b"
+);
+const ge = de.exports, pe = () => {
+  const v = window.location.host.split(".");
+  return v && v[0];
+}, me = pe() === "fortnox", ve = [
+  "enjoyedExperience",
+  // boolean value
+  "whatToImprove"
+  // string value
+], we = {
+  mixins: [ft([])],
+  props: {
+    publicId: {
+      type: String,
+      default: ""
+    }
+  },
+  data() {
+    return {
+      page: "start",
+      whatToImprove: ""
+    };
+  },
+  computed: {
+    showFeedback() {
+      return this.$view !== "widget";
+    }
+  },
+  created() {
+    this.$nextTick(() => {
+      this.startAnimation();
+    });
+  },
+  methods: {
+    async submitFeedback({ type: v, data: r }) {
+      if (!this.publicId)
+        throw Error("Missing param publicId");
+      if (!v)
+        throw Error("Missing param type");
+      if (!ve.includes(v))
+        throw Error("Invalid feedback type");
+      if (!r)
+        throw Error("Missing param data");
+      let n = "positive";
+      try {
+        Dt.feedback(this.publicId, { type: v, data: r }), v === "enjoyedExperience" && !r.value && (n = "negative"), v === "whatToImprove" && (n = "negative.success"), me && n !== "negative" && (n = "custom");
+      } catch (g) {
+        Et(g, { showMessage: !1 });
+      } finally {
+        this.goTo(n);
+      }
+    },
+    async goTo(v) {
+      if (this.$emit("page", v), v === "positive" || v === "negative") {
+        this.$refs.start.style.opacity = 0, this.page = "intermediate", setTimeout(() => {
+          this.page = v;
+        }, 2e3);
+        return;
+      }
+      this.page = v;
+    },
+    startAnimation() {
+      const v = this.$refs.feedbackBg;
+      v.gradOneXPos = 0, v.gradOneYPos = 0, v.gradTwoXPos = 80, v.gradTwoYPos = 20, v.gradThreeXPos = 20, v.gradThreeYPos = 80, v.gradFourXPos = 80, v.gradFourYPos = 80, nt({
+        targets: v,
+        duration: 12e3,
+        direction: "alternate",
+        easing: "linear",
+        loop: !0,
+        gradOneXPos: [10, 5, 0, -10],
+        gradOneYPos: [10, 20, 25, 30],
+        gradTwoXPos: [25, 20, 15, 10, 25],
+        gradTwoYPos: [65, 55, 40, 65, 80],
+        gradThreeXPos: [25, 20, 10, 15, 25],
+        gradThreeYPos: [65, 50, 45, 60, 80],
+        gradFourXPos: [85, 80, 75, 70, 95],
+        gradFourYPos: [90, 100, 120, 100, 85],
+        update() {
+          v.style.setProperty(
+            "--gradOneXPos",
+            `${v.gradOneXPos}%`
+          ), v.style.setProperty(
+            "--gradOneYPos",
+            `${v.gradOneYPos}%`
+          ), v.style.setProperty(
+            "--gradTwoXPos",
+            `${v.gradTwoXPos}%`
+          ), v.style.setProperty(
+            "--gradTwoYPos",
+            `${v.gradTwoYPos}%`
+          ), v.style.setProperty(
+            "--gradThreeXPos",
+            `${v.gradThreeXPos}%`
+          ), v.style.setProperty(
+            "--gradThreeYPos",
+            `${v.gradThreeYPos}%`
+          ), v.style.setProperty(
+            "--gradFourXPos",
+            `${v.gradFourXPos}%`
+          ), v.style.setProperty(
+            "--gradFourYPos",
+            `${v.gradFourYPos}%`
+          );
+        }
+      });
+    },
+    // animations
+    leave(v, r) {
+      nt({
+        targets: v,
+        // height: 0,
+        // opacity: [1, 0],
+        opacity: 0,
+        duration: 500,
+        easing: "easeInOutCubic",
+        complete: r
+      });
+    },
+    enter(v, r) {
+      nt({
+        targets: v,
+        delay: this.page === "intermediate" ? 250 : 0,
+        duration: 500,
+        opacity: [0, 1],
+        easing: "easeInOutCubic",
+        complete: r
+      });
+    }
+  }
+};
+var ye = function() {
+  var r = this, n = r._self._c;
+  return n("div", { staticClass: "f-feedback" }, [n("div", { ref: "feedbackBg", staticClass: "f-bg" }), n("div", { staticClass: "f-container" }, [n("transition", { attrs: { css: !1, mode: "out-in" }, on: { enter: r.enter, leave: r.leave } }, [r.page === "start" ? n("div", { key: "start", ref: "start", staticClass: "flex w-full flex-col items-center justify-center", staticStyle: { transition: "opacity 250ms" } }, [n("div", { staticStyle: { "padding-bottom": "calc(1.5 * var(--rem))", "font-size": "14px", "font-weight": "500" }, domProps: { textContent: r._s(r._document.$t("answerFeedback.start.title")) } }), n("div", [n("CButton", { staticClass: "feedback-btn", attrs: { "icon-left": "thumbsdown", size: "small", pattern: "secondary" }, on: { click: function(g) {
+    return r.submitFeedback({
+      type: "enjoyedExperience",
+      data: { value: !1 }
+    });
+  } } }, [r._v(r._s(r._document.$t("answerFeedback.start.no")))]), n("CButton", { staticClass: "feedback-btn", staticStyle: { "margin-left": "calc(0.75 * var(--rem))" }, attrs: { "icon-left": "thumbsup", size: "small", pattern: "secondary" }, on: { click: function(g) {
+    return r.submitFeedback({
+      type: "enjoyedExperience",
+      data: { value: !0 }
+    });
+  } } }, [r._v(r._s(r._document.$t("answerFeedback.start.yes")))])], 1)]) : r.page === "intermediate" ? n("div", { key: "intermediate", staticStyle: { height: "100%", display: "flex", "flex-direction": "column" } }, [n("div", { staticStyle: { flex: "1 1 auto", display: "flex", "flex-direction": "column", "justify-content": "center", "align-items": "center" } }, [n("div", { staticClass: "f-title", domProps: { textContent: r._s(r._document.$t("answerFeedback.intermediate.title")) } })])]) : r.page === "positive" && r.showFeedback ? n("div", { key: "positive", staticStyle: { height: "100%", display: "flex", "flex-direction": "column" } }, [n("div", { staticStyle: { flex: "1 1 auto", display: "flex", "flex-direction": "column", "justify-content": "center", "align-items": "center" } }, [n("div", { staticClass: "f-title", domProps: { textContent: r._s(r._document.$t("answerFeedback.yes.title")) } }), n("div", { domProps: { textContent: r._s(r._document.$t("answerFeedback.yes.text")) } })]), n("CButton", { staticClass: "a-btn", staticStyle: { "margin-bottom": "0.5em" }, attrs: { type: "secondary", wide: "", tag: "a", href: "/register?utm_source=document&utm_medium=feedback-modal&utm_campaign=signup&utm_content=positive-exp", target: "_blank" }, domProps: { textContent: r._s(r._document.$t("answerFeedback.yes.action")) } }), n("CButton", { staticClass: "a-btn", attrs: { wide: "", tag: "a", href: `https://${r.$t(
+    "_common:brand.domain"
+  )}?utm_source=document&utm_medium=feedback-modal&utm_campaign=learn-more&utm_content=positive-exp`, target: "_blank" }, domProps: { textContent: r._s(r._document.$t("answerFeedback.yes.secondary")) } })], 1) : r.page === "negative" ? n("div", { key: "negative", staticStyle: { height: "100%", display: "flex", "flex-direction": "column" } }, [n("div", { staticStyle: { flex: "1 1 auto", display: "flex", "flex-direction": "column", "justify-content": "center", "align-items": "center" } }, [n("div", { staticClass: "f-title", domProps: { textContent: r._s(r._document.$t("answerFeedback.no.start.title")) } }), n("div", { domProps: { textContent: r._s(r._document.$t("answerFeedback.no.start.text")) } }), n("CInput", { staticClass: "input-style", staticStyle: { margin: "2em 0" }, attrs: { placeholder: r._document.$t("answerFeedback.no.start.placeholder"), type: "textarea" }, model: { value: r.whatToImprove, callback: function(g) {
+    r.whatToImprove = g;
+  }, expression: "whatToImprove" } })], 1), n("CButton", { staticClass: "a-btn", attrs: { wide: "" }, domProps: { textContent: r._s(r._document.$t("answerFeedback.no.start.action")) }, on: { click: function(g) {
+    return r.submitFeedback({
+      type: "whatToImprove",
+      data: { value: r.whatToImprove }
+    });
+  } } })], 1) : r.page === "negative.success" ? n("div", { key: "success", staticStyle: { height: "100%", display: "flex", "flex-direction": "column" } }, [n("div", { staticStyle: { flex: "1 1 auto", display: "flex", "flex-direction": "column", "justify-content": "center", "align-items": "center" } }, [n("div", { staticClass: "f-title", domProps: { textContent: r._s(r._document.$t("answerFeedback.no.success.title")) } }), n("div", { domProps: { textContent: r._s(r._document.$t("answerFeedback.no.success.text")) } })]), n("CButton", { staticClass: "a-btn", staticStyle: { "margin-bottom": "0.5em" }, attrs: { tag: "a", href: `https://${r.$t(
+    "_common:brand.domain"
+  )}?utm_source=document&utm_medium=feedback-modal&utm_campaign=learn-more&utm_content=negative-exp`, target: "_blank", wide: "", type: "secondary" }, domProps: { textContent: r._s(r._document.$t("answerFeedback.no.success.action")) } }), n("CButton", { staticClass: "a-btn", attrs: { wide: "" }, domProps: { textContent: r._s(r._document.$t("answerFeedback.no.success.secondary")) }, on: { click: function(g) {
+    return r.$emit("close");
+  } } })], 1) : r.page === "custom" ? n("div", { key: "success", staticStyle: { height: "100%", display: "flex", "flex-direction": "column" } }, [n("div", { staticStyle: { flex: "1 1 auto", display: "flex", "flex-direction": "column", "justify-content": "center", "align-items": "center" } }, [n("div", { staticClass: "f-title", domProps: { textContent: r._s(r._document.$t("answerFeedback.custom.title")) } }), n("div", { domProps: { textContent: r._s(r._document.$t("answerFeedback.custom.text")) } })]), n("CButton", { staticClass: "a-btn", attrs: { type: "secondary", wide: "" }, domProps: { textContent: r._s(r._document.$t("answerFeedback.custom.action")) }, on: { click: function(g) {
+    return r.$emit("close");
+  } } })], 1) : r._e()])], 1)]);
+}, xe = [], _e = /* @__PURE__ */ ot(
+  we,
+  ye,
+  xe,
+  !1,
+  null,
+  "b3b609e2"
+);
+const Ce = _e.exports, Ee = {
+  components: {
+    Feedback: Ce,
+    Signature: ge,
+    BankId: Kt,
+    Deny: qt
+  },
+  mixins: [ft([])],
+  i18nOptions: {
+    namespaces: "temporary",
+    messages: {
+      en: {
+        previewMode: "Preview answer mode"
+      },
+      sv: {
+        previewMode: "Demo - Förhandsgranska"
+      }
+    }
+  },
+  props: {
+    mode: { type: String, default: "accept" },
+    // 'accept', 'decline'
+    isSender: { type: Boolean, default: !1 },
+    fullScreen: { type: Boolean, default: !1 },
+    senderActions: { type: Object, default: () => ({}) },
+    calcHeight: { type: Boolean, default: !1 }
+  },
+  data() {
+    return {
+      page: "start",
+      // start | intermediate | success | versionError
+      isFeedbackInitiated: !1,
+      isPosting: !1,
+      actionInvalid: !1
+    };
+  },
+  computed: {
+    answerComponentName() {
+      return this.mode === "decline" ? "Deny" : this.answerMethod === "bankId" ? "BankId" : "Signature";
+    },
+    answerType() {
+      return this.mode === "decline" ? "decline" : this.answerMethod === "bankId" ? "bankId" : "signature";
+    },
+    signee() {
+      return this.isSender ? this._document.senderClient : this._document.viewer;
+    },
+    answerMethod() {
+      var v;
+      return (v = this.signee.answerMethod) == null ? void 0 : v.accept;
+    },
+    successStrings() {
+      const v = this.signee.email ? this._document.$t(`answerModal.${this.answerType}.success.text`, {
+        email: this.signee.email
+      }) : this._document.$t(
+        `answerModal.${this.answerType}.success.textFallback`
+      ), r = this.signee.email ? this._document.$t("answerModal.successTextSingle", {
+        email: this.signee.email
+      }) : this._document.$t("answerModal.successTextFallbackSingle"), n = this._document.remainingSignatures === 0 ? r : v;
+      return {
+        title: this._document.$t(
+          `answerModal.${this.answerType}.success.title`
+        ),
+        text: n
+      };
+    }
+  },
+  created() {
+    this.calcHeight && this.$nextTick(() => this.setFixedHeight());
+  },
+  methods: {
+    ...Ut({
+      answerCurrentDoc: yt.ANSWER_CURRENT_PUBLIC_DOCUMENT,
+      putCurrentDoc: yt.PUT_CURRENT_PUBLIC_DOCUMENT,
+      reloadCurrentDocument: yt.RELOAD_CURRENT_DOCUMENT
+    }),
+    async onSubmit() {
+      this.setFixedHeight(), await this.submit();
+    },
+    async submit() {
+      if (!this.isPosting) {
+        this.isPosting = !0;
+        try {
+          const { submit: v } = this.$refs.answerComponent;
+          if (typeof v != "function")
+            throw Error("Missing answer type submit method");
+          await v({
+            update: (r) => this.putCurrentDoc({ includeChanges: !0, ...r }),
+            answer: this.answerCurrentDoc,
+            ...this.isSender ? this.senderActions : null
+          });
+        } catch (v) {
+          this.isPosting = !1, v.httpStatusCode === 409 ? this.page = "versionError" : Et(v);
+        }
+      }
+    },
+    onComplete() {
+      return (async () => {
+        var n;
+        if (this.isSender && this.senderActions.send) {
+          this.$emit("close"), await this.senderActions.send();
+          return;
+        }
+        const r = this.mode === "accept";
+        this.mode === "accept" && this.answerMethod === "bankId" ? setTimeout(
+          () => this.reloadCurrentDocument().then(
+            () => {
+              var g;
+              return At.trigger("document:answer", {
+                id: (g = this._document) == null ? void 0 : g.id,
+                didAccept: r
+              });
+            }
+          ),
+          1e3
+        ) : At.trigger("document:answer", {
+          id: (n = this._document) == null ? void 0 : n.id,
+          didAccept: r
+        }), await Bt(800), this.page = "intermediate", await Bt(2e3), this.page = "success", this.isPosting = !1;
+      })();
+    },
+    reload() {
+      window.location.reload();
+    },
+    setFixedHeight() {
+      this.$el.style.minHeight = `${this.$el.offsetHeight}px`;
+    },
+    minimizeHeight(v, r) {
+      nt({
+        targets: v,
+        height: 0,
+        flexGrow: [1, 0],
+        opacity: [1, 0],
+        duration: 900,
+        easing: "easeOutQuint",
+        complete: r
+      }), nt({
+        targets: this.$refs.feedback.$el,
+        height: 0,
+        flexGrow: 1,
+        duration: 900,
+        easing: "easeOutQuint"
+      });
+    },
+    enterAnim(v, r) {
+      nt({
+        targets: v.querySelectorAll(".stagger-anim"),
+        opacity: [0, 1],
+        delay: nt.stagger(180, { start: 800 }),
+        duration: 340,
+        easing: "linear",
+        complete: r
+      });
+    },
+    leaveAnim(v, r) {
+      v.style.position = "absolute", nt({
+        targets: v.querySelectorAll(".stagger-anim"),
+        opacity: 0,
+        delay: nt.stagger(200),
+        duration: 200,
+        easing: "linear",
+        complete: r
+      });
+    }
+  }
+};
+var be = function() {
+  var g;
+  var r = this, n = r._self._c;
+  return n("transition-group", { staticClass: "a-root font-inter", attrs: { tag: "div", css: !1, mode: "out-in" }, on: { enter: r.enterAnim, leave: r.leaveAnim } }, [n("CButton", { key: "btn", staticClass: "text-[hsl(0, 0%, 45%)] absolute right-5 top-5 z-[9]", attrs: { icon: "x", circle: "" }, on: { click: function(u) {
+    r.$parent.$emit("cancel"), r.$emit("close");
+  } } }), r.page === "start" ? n("div", { key: "start", staticClass: "root-padding flex-grow" }, [n("div", { staticClass: "stagger-anim", staticStyle: { "padding-bottom": "40px" } }, [n("div", { staticClass: "a-title", domProps: { textContent: r._s(r._document.$t(`answerModal.${r.answerType}.start.title`)) } }), n("div", { staticStyle: { color: "hsl(0, 0%, 40%)" }, domProps: { textContent: r._s(r._document.$t(`answerModal.${r.answerType}.start.text`)) } })]), n(r.answerComponentName, { ref: "answerComponent", tag: "component", staticClass: "stagger-anim", attrs: { _document: r._document, signee: r.signee, "on-complete-func": r.onComplete }, on: { invalid: function(u) {
+    r.actionInvalid = u;
+  }, loading: function(u) {
+    r.isPosting = u;
+  } } }), n("div", { staticClass: "stagger-anim", staticStyle: { "padding-top": "3em" } }, [n("CButton", { staticClass: "a-btn", attrs: { loading: r.isPosting, disabled: r.actionInvalid, type: r.mode === "decline" ? "text" : "secondary", icon: r.answerType === "bankId" ? "bankId" : "" }, on: { click: r.onSubmit } }, [r._v(" " + r._s(r._document.$t(`answerModal.${r.answerType}.start.action`)) + " ")])], 1)], 1) : r.page === "intermediate" ? n("div", { key: "intermediate", staticClass: "flex w-full flex-grow flex-col items-center justify-center text-center", staticStyle: { height: "100%" } }, [n("div", { staticClass: "a-title stagger-anim", domProps: { textContent: r._s(r._document.$t("answerModal.answerSuccess")) } })]) : r.page === "success" ? n("div", { key: "success", staticClass: "flex w-full flex-grow flex-col", staticStyle: { height: "100%" } }, [n("transition", { attrs: { css: !1 }, on: { leave: r.minimizeHeight } }, [r.isFeedbackInitiated ? r._e() : n("div", { staticClass: "flex w-full flex-grow flex-col items-center justify-center", staticStyle: { overflow: "hidden" } }, [n("div", { staticClass: "root-padding flex w-full flex-col items-center justify-center", staticStyle: { height: "100%" } }, [n("div", { staticClass: "a-title stagger-anim", staticStyle: { padding: "calc(2.5 * var(--rem)) 0 calc(2 * var(--rem))" } }, [n("div", { domProps: { textContent: r._s(r.successStrings.title) } })]), n("div", { staticClass: "stagger-anim", domProps: { textContent: r._s(r.successStrings.text) } })])])]), n("Feedback", { ref: "feedback", staticClass: "stagger-anim", staticStyle: { flex: "0 0", overflow: "hidden", "min-height": "200px" }, attrs: { "public-id": (g = r._document.viewer) == null ? void 0 : g.publicDocumentId, _document: r._document }, on: { page: () => r.isFeedbackInitiated = !0, close: function(u) {
+    return r.$emit("close");
+  } } })], 1) : r.page === "versionError" ? n("div", { key: "versionError", staticClass: "root-padding flex flex-grow flex-col items-center justify-center text-center" }, [n("div", { staticClass: "stagger-anim" }, [n("div", { staticClass: "flex items-center justify-center", staticStyle: { padding: "20px 0" } }, [n("div", { staticClass: "flex items-center justify-center", staticStyle: { width: "52px", height: "52px", "border-radius": "50%" } }, [n("CIcon", { attrs: { size: 30, type: "error" } })], 1)]), n("div", { staticClass: "a-title", domProps: { textContent: r._s(r._document.$t(`answerModal.versionError.${r.mode}.title`)) } }), n("div", { domProps: { textContent: r._s(r._document.$t("answerModal.versionError.text")) } })]), n("div", { staticClass: "stagger-anim", staticStyle: { "padding-top": "3em" } }, [n("CButton", { staticClass: "a-btn", attrs: { loading: r.isPosting, type: "none" }, on: { click: r.reload } }, [r._v(" " + r._s(r._document.$t("answerModal.versionError.btn")) + " ")])], 1)]) : r._e()], 1);
+}, Pe = [], Se = /* @__PURE__ */ ot(
+  Ee,
+  be,
+  Pe,
+  !1,
+  null,
+  "67dcb365"
+);
+const Me = Se.exports;
+export {
+  Me as default
+};