@paykka/card-checkout-ui 0.8.0 → 0.9.2

package/dist/es/core.js

@@ -57,7 +57,7 @@ function M$3() {
     n2.__d && (u2 = i$2.length, o2 = void 0, e2 = (r2 = (t2 = n2).__v).__e, c2 = [], s2 = [], t2.__P && ((o2 = d$3({}, r2)).__v = r2.__v + 1, l$3.vnode && l$3.vnode(o2), O(t2.__P, o2, r2, t2.__n, t2.__P.namespaceURI, 32 & r2.__u ? [e2] : null, c2, null == e2 ? x$2(r2) : e2, !!(32 & r2.__u), s2), o2.__v = r2.__v, o2.__.__k[o2.__i] = o2, j$2(c2, o2, s2), o2.__e != e2 && C$1(o2)), i$2.length > u2 && i$2.sort(f$3));
   M$3.__r = 0;
 }
-function P(n2, l2, u2, t2, i2, o2, r2, f2, e2, c2, s2) {
+function P$1(n2, l2, u2, t2, i2, o2, r2, f2, e2, c2, s2) {
   var a2, p2, y2, d2, w2, _2 = t2 && t2.__k || v$2, g2 = l2.length;
   for (u2.__d = e2, $(u2, l2, _2), e2 = u2.__d, a2 = 0; a2 < g2; a2++)
     null != (y2 = u2.__k[a2]) && (p2 = -1 === y2.__i ? h$2 : _2[y2.__i] || h$2, y2.__i = a2, O(n2, y2, p2, i2, o2, r2, f2, e2, c2, s2), d2 = y2.__e, y2.ref && p2.ref != y2.ref && (p2.ref && N$1(p2.ref, null, y2), s2.push(y2.ref, y2.__c || d2, y2)), null == w2 && null != d2 && (w2 = d2), 65536 & y2.__u || p2.__k === y2.__k ? e2 = I(y2, e2, n2) : "function" == typeof y2.type && void 0 !== y2.__d ? e2 = y2.__d : d2 && (e2 = d2.nextSibling), y2.__d = void 0, y2.__u &= -196609);
@@ -69,7 +69,7 @@ function $(n2, l2, u2) {
     null != (i2 = l2[t2]) && "boolean" != typeof i2 && "function" != typeof i2 ? (r2 = t2 + a2, (i2 = n2.__k[t2] = "string" == typeof i2 || "number" == typeof i2 || "bigint" == typeof i2 || i2.constructor == String ? g$2(null, i2, null, null, null) : y$2(i2) ? g$2(b$1, { children: i2 }, null, null, null) : void 0 === i2.constructor && i2.__b > 0 ? g$2(i2.type, i2.props, i2.key, i2.ref ? i2.ref : null, i2.__v) : i2).__ = n2, i2.__b = n2.__b + 1, o2 = null, -1 !== (f2 = i2.__i = L$1(i2, u2, r2, s2)) && (s2--, (o2 = u2[f2]) && (o2.__u |= 131072)), null == o2 || null === o2.__v ? (-1 == f2 && a2--, "function" != typeof i2.type && (i2.__u |= 65536)) : f2 !== r2 && (f2 == r2 - 1 ? a2-- : f2 == r2 + 1 ? a2++ : (f2 > r2 ? a2-- : a2++, i2.__u |= 65536))) : i2 = n2.__k[t2] = null;
   if (s2)
     for (t2 = 0; t2 < c2; t2++)
-      null != (o2 = u2[t2]) && 0 == (131072 & o2.__u) && (o2.__e == n2.__d && (n2.__d = x$2(o2)), V(o2, o2));
+      null != (o2 = u2[t2]) && 0 == (131072 & o2.__u) && (o2.__e == n2.__d && (n2.__d = x$2(o2)), V$1(o2, o2));
 }
 function I(n2, l2, u2) {
   var t2, i2;
@@ -182,7 +182,7 @@ function O(n2, u2, t2, i2, o2, r2, f2, e2, c2, s2) {
           do {
             h2.__d = false, $2 && $2(u2), a2 = h2.render(h2.props, h2.state, h2.context), h2.state = h2.__s;
           } while (h2.__d && ++I2 < 25);
-        h2.state = h2.__s, null != h2.getChildContext && (i2 = d$3(d$3({}, i2), h2.getChildContext())), x2 && !v2 && null != h2.getSnapshotBeforeUpdate && (_2 = h2.getSnapshotBeforeUpdate(p2, w2)), P(n2, y$2(L2 = null != a2 && a2.type === b$1 && null == a2.key ? a2.props.children : a2) ? L2 : [L2], u2, t2, i2, o2, r2, f2, e2, c2, s2), h2.base = u2.__e, u2.__u &= -161, h2.__h.length && f2.push(h2), g2 && (h2.__E = h2.__ = null);
+        h2.state = h2.__s, null != h2.getChildContext && (i2 = d$3(d$3({}, i2), h2.getChildContext())), x2 && !v2 && null != h2.getSnapshotBeforeUpdate && (_2 = h2.getSnapshotBeforeUpdate(p2, w2)), P$1(n2, y$2(L2 = null != a2 && a2.type === b$1 && null == a2.key ? a2.props.children : a2) ? L2 : [L2], u2, t2, i2, o2, r2, f2, e2, c2, s2), h2.base = u2.__e, u2.__u &= -161, h2.__h.length && f2.push(h2), g2 && (h2.__E = h2.__ = null);
       } catch (n3) {
         if (u2.__v = null, c2 || null != r2) {
           for (u2.__u |= c2 ? 160 : 128; e2 && 8 === e2.nodeType && e2.nextSibling; )
@@ -244,7 +244,7 @@ function z$2(u2, t2, i2, o2, r2, f2, e2, c2, s2) {
       _2 = k2[a2], "children" == a2 ? d2 = _2 : "dangerouslySetInnerHTML" == a2 ? v2 = _2 : "value" == a2 ? g2 = _2 : "checked" == a2 ? m2 = _2 : c2 && "function" != typeof _2 || b2[a2] === _2 || A$2(u2, a2, _2, b2[a2], r2);
     if (v2)
       c2 || p2 && (v2.__html === p2.__html || v2.__html === u2.innerHTML) || (u2.innerHTML = v2.__html), t2.__k = [];
-    else if (p2 && (u2.innerHTML = ""), P(u2, y$2(d2) ? d2 : [d2], t2, i2, o2, "foreignObject" === C3 ? "http://www.w3.org/1999/xhtml" : r2, f2, e2, f2 ? f2[0] : i2.__k && x$2(i2, 0), c2, s2), null != f2)
+    else if (p2 && (u2.innerHTML = ""), P$1(u2, y$2(d2) ? d2 : [d2], t2, i2, o2, "foreignObject" === C3 ? "http://www.w3.org/1999/xhtml" : r2, f2, e2, f2 ? f2[0] : i2.__k && x$2(i2, 0), c2, s2), null != f2)
       for (a2 = f2.length; a2--; )
         w$3(f2[a2]);
     c2 || (a2 = "value", "progress" === C3 && null == g2 ? u2.removeAttribute("value") : void 0 !== g2 && (g2 !== u2[a2] || "progress" === C3 && !g2 || "option" === C3 && g2 !== b2[a2]) && A$2(u2, a2, g2, b2[a2], r2), a2 = "checked", void 0 !== m2 && m2 !== u2[a2] && A$2(u2, a2, m2, b2[a2], r2));
@@ -262,7 +262,7 @@ function N$1(n2, u2, t2) {
     l$3.__e(n3, t2);
   }
 }
-function V(n2, u2, t2) {
+function V$1(n2, u2, t2) {
   var i2, o2;
   if (l$3.unmount && l$3.unmount(n2), (i2 = n2.ref) && (i2.current && i2.current !== n2.__e || N$1(i2, null, u2)), null != (i2 = n2.__c)) {
     if (i2.componentWillUnmount)
@@ -275,7 +275,7 @@ function V(n2, u2, t2) {
   }
   if (i2 = n2.__k)
     for (o2 = 0; o2 < i2.length; o2++)
-      i2[o2] && V(i2[o2], u2, t2 || "function" != typeof n2.type);
+      i2[o2] && V$1(i2[o2], u2, t2 || "function" != typeof n2.type);
   t2 || w$3(n2.__e), n2.__c = n2.__ = n2.__e = n2.__d = void 0;
 }
 function q$1(n2, l2, u2) {
@@ -602,6 +602,29 @@ var U = function(n2, t2, e2) {
       n2.u = e2 = e2[2];
     }
 };
+function V(n2) {
+  return this.getChildContext = function() {
+    return n2.context;
+  }, n2.children;
+}
+function W(n2) {
+  var e2 = this, r2 = n2.i;
+  e2.componentWillUnmount = function() {
+    B$2(null, e2.l), e2.l = null, e2.i = null;
+  }, e2.i && e2.i !== r2 && e2.componentWillUnmount(), e2.l || (e2.i = r2, e2.l = { nodeType: 1, parentNode: r2, childNodes: [], contains: function() {
+    return true;
+  }, appendChild: function(n3) {
+    this.childNodes.push(n3), e2.i.appendChild(n3);
+  }, insertBefore: function(n3, t2) {
+    this.childNodes.push(n3), e2.i.appendChild(n3);
+  }, removeChild: function(n3) {
+    this.childNodes.splice(this.childNodes.indexOf(n3) >>> 1, 1), e2.i.removeChild(n3);
+  } }), B$2(_$3(V, { context: e2.context }, n2.__v), e2.l);
+}
+function P(n2, e2) {
+  var r2 = _$3(W, { __v: n2, i: e2 });
+  return r2.containerInfo = e2, r2;
+}
 (F.prototype = new k$1()).__a = function(n2) {
   var t2 = this, e2 = L(t2.__v), r2 = t2.o.get(n2);
   return r2[0]++, function(u2) {
@@ -675,6 +698,36 @@ l$3.diffed = function(n2) {
   var t2 = n2.props, e2 = n2.__e;
   null != e2 && "textarea" === n2.type && "value" in t2 && t2.value !== e2.value && (e2.value = null == t2.value ? "" : t2.value);
 };
+function e$1(e2, n2) {
+  return n2 = n2 || {}, new Promise(function(t2, r2) {
+    var s2 = new XMLHttpRequest(), o2 = [], u2 = {}, a2 = function e3() {
+      return { ok: 2 == (s2.status / 100 | 0), statusText: s2.statusText, status: s2.status, url: s2.responseURL, text: function() {
+        return Promise.resolve(s2.responseText);
+      }, json: function() {
+        return Promise.resolve(s2.responseText).then(JSON.parse);
+      }, blob: function() {
+        return Promise.resolve(new Blob([s2.response]));
+      }, clone: e3, headers: { keys: function() {
+        return o2;
+      }, entries: function() {
+        return o2.map(function(e4) {
+          return [e4, s2.getResponseHeader(e4)];
+        });
+      }, get: function(e4) {
+        return s2.getResponseHeader(e4);
+      }, has: function(e4) {
+        return null != s2.getResponseHeader(e4);
+      } } };
+    };
+    for (var i2 in s2.open(n2.method || "get", e2, true), s2.onload = function() {
+      s2.getAllResponseHeaders().toLowerCase().replace(/^(.+?):/gm, function(e3, n3) {
+        u2[n3] || o2.push(u2[n3] = n3);
+      }), t2(a2());
+    }, s2.onerror = r2, s2.withCredentials = "include" == n2.credentials, n2.headers)
+      s2.setRequestHeader(i2, n2.headers[i2]);
+    s2.send(n2.body || null);
+  });
+}
 var __assign = function() {
   __assign = Object.assign || function __assign2(t2) {
     for (var s2, i2 = 1, n2 = arguments.length; i2 < n2; i2++) {
@@ -805,7 +858,7 @@ typeof SuppressedError === "function" ? SuppressedError : function(error, suppre
   var e2 = new Error(message);
   return e2.name = "SuppressedError", e2.error = error, e2.suppressed = suppressed, e2;
 };
-var version = "4.3.0";
+var version$1 = "4.3.0";
 function wait(durationMs, resolveWith) {
   return new Promise(function(resolve) {
     return setTimeout(resolve, durationMs, resolveWith);
@@ -1934,14 +1987,14 @@ function getCanvasFingerprint() {
 }
 function getUnstableCanvasFingerprint(skipImages) {
   return __awaiter(this, void 0, void 0, function() {
-    var winding, geometry, text, _a, canvas, context;
+    var winding, geometry, text, _a, canvas2, context;
     var _b;
     return __generator(this, function(_c) {
       switch (_c.label) {
         case 0:
           winding = false;
-          _a = makeCanvasContext(), canvas = _a[0], context = _a[1];
-          if (!!isSupported(canvas, context))
+          _a = makeCanvasContext(), canvas2 = _a[0], context = _a[1];
+          if (!!isSupported(canvas2, context))
             return [3, 1];
           geometry = text = "unsupported";
           return [3, 4];
@@ -1952,7 +2005,7 @@ function getUnstableCanvasFingerprint(skipImages) {
           geometry = text = "skipped";
           return [3, 4];
         case 2:
-          return [4, renderImages(canvas, context)];
+          return [4, renderImages(canvas2, context)];
         case 3:
           _b = _c.sent(), geometry = _b[0], text = _b[1];
           _c.label = 4;
@@ -1963,31 +2016,31 @@ function getUnstableCanvasFingerprint(skipImages) {
   });
 }
 function makeCanvasContext() {
-  var canvas = document.createElement("canvas");
-  canvas.width = 1;
-  canvas.height = 1;
-  return [canvas, canvas.getContext("2d")];
+  var canvas2 = document.createElement("canvas");
+  canvas2.width = 1;
+  canvas2.height = 1;
+  return [canvas2, canvas2.getContext("2d")];
 }
-function isSupported(canvas, context) {
-  return !!(context && canvas.toDataURL);
+function isSupported(canvas2, context) {
+  return !!(context && canvas2.toDataURL);
 }
 function doesSupportWinding(context) {
   context.rect(0, 0, 10, 10);
   context.rect(2, 2, 6, 6);
   return !context.isPointInPath(5, 5, "evenodd");
 }
-function renderImages(canvas, context) {
+function renderImages(canvas2, context) {
   return __awaiter(this, void 0, void 0, function() {
     var textImage1, textImage2, geometryImage;
     return __generator(this, function(_a) {
       switch (_a.label) {
         case 0:
-          renderTextImage(canvas, context);
+          renderTextImage(canvas2, context);
           return [4, releaseEventLoop()];
         case 1:
           _a.sent();
-          textImage1 = canvasToString(canvas);
-          textImage2 = canvasToString(canvas);
+          textImage1 = canvasToString(canvas2);
+          textImage2 = canvasToString(canvas2);
           if (textImage1 !== textImage2) {
             return [2, [
               "unstable",
@@ -1995,19 +2048,19 @@ function renderImages(canvas, context) {
               /* ImageStatus.Unstable */
             ]];
           }
-          renderGeometryImage(canvas, context);
+          renderGeometryImage(canvas2, context);
           return [4, releaseEventLoop()];
         case 2:
           _a.sent();
-          geometryImage = canvasToString(canvas);
+          geometryImage = canvasToString(canvas2);
           return [2, [geometryImage, textImage1]];
       }
     });
   });
 }
-function renderTextImage(canvas, context) {
-  canvas.width = 240;
-  canvas.height = 60;
+function renderTextImage(canvas2, context) {
+  canvas2.width = 240;
+  canvas2.height = 60;
   context.textBaseline = "alphabetic";
   context.fillStyle = "#f60";
   context.fillRect(100, 1, 62, 20);
@@ -2022,9 +2075,9 @@ function renderTextImage(canvas, context) {
   context.font = "18pt Arial";
   context.fillText(printedText, 4, 45);
 }
-function renderGeometryImage(canvas, context) {
-  canvas.width = 122;
-  canvas.height = 110;
+function renderGeometryImage(canvas2, context) {
+  canvas2.width = 122;
+  canvas2.height = 110;
   context.globalCompositeOperation = "multiply";
   for (var _i = 0, _a = [
     ["#f2f", 40, 40],
@@ -2043,8 +2096,8 @@ function renderGeometryImage(canvas, context) {
   context.arc(60, 60, 20, 0, Math.PI * 2, true);
   context.fill("evenodd");
 }
-function canvasToString(canvas) {
-  return canvas.toDataURL();
+function canvasToString(canvas2) {
+  return canvas2.toDataURL();
 }
 function doesBrowserPerformAntifingerprinting() {
   return isWebKit() && isWebKit616OrNewer() && isSafariWebKit();
@@ -2807,7 +2860,7 @@ function getMathFingerprint() {
   var cosh = M.cosh || fallbackFn;
   var tan = M.tan || fallbackFn;
   var tanh = M.tanh || fallbackFn;
-  var exp = M.exp || fallbackFn;
+  var exp2 = M.exp || fallbackFn;
   var expm1 = M.expm1 || fallbackFn;
   var log1p = M.log1p || fallbackFn;
   var powPI = function(value) {
@@ -2856,7 +2909,7 @@ function getMathFingerprint() {
     tan: tan(-1e300),
     tanh: tanh(1),
     tanhPf: tanhPf(1),
-    exp: exp(1),
+    exp: exp2(1),
     expm1: expm1(1),
     expm1Pf: expm1Pf(1),
     log1p: log1p(10),
@@ -3172,15 +3225,15 @@ function getWebGLContext(cache) {
   if (cache.webgl) {
     return cache.webgl.context;
   }
-  var canvas = document.createElement("canvas");
+  var canvas2 = document.createElement("canvas");
   var context;
-  canvas.addEventListener("webglCreateContextError", function() {
+  canvas2.addEventListener("webglCreateContextError", function() {
     return context = void 0;
   });
   for (var _i = 0, _a = ["webgl", "experimental-webgl"]; _i < _a.length; _i++) {
     var type = _a[_i];
     try {
-      context = canvas.getContext(type);
+      context = canvas2.getContext(type);
     } catch (_b) {
     }
     if (context) {
@@ -3322,7 +3375,7 @@ function makeLazyGetResult(components) {
     },
     confidence,
     components,
-    version
+    version: version$1
   };
 }
 function prepareForSources(delayFallback) {
@@ -3361,7 +3414,7 @@ function monitor() {
   }
   try {
     var request = new XMLHttpRequest();
-    request.open("get", "https://m1.openfpcdn.io/fingerprintjs/v".concat(version, "/npm-monitoring"), true);
+    request.open("get", "https://m1.openfpcdn.io/fingerprintjs/v".concat(version$1, "/npm-monitoring"), true);
     request.send();
   } catch (error) {
     console.error(error);
@@ -3887,7 +3940,7 @@ function t() {
 }
 var o = void 0;
 var h = void 0, s$1 = 0, f = 0, v = 0;
-function e$1(i2) {
+function e(i2) {
   if (void 0 !== o) {
     var t2 = i2.n;
     if (void 0 === t2 || t2.t !== o) {
@@ -3978,7 +4031,7 @@ u.prototype.peek = function() {
   }
 };
 Object.defineProperty(u.prototype, "value", { get: function() {
-  var i2 = e$1(this);
+  var i2 = e(this);
   if (void 0 !== i2)
     i2.i = this.i;
   return this.v;
@@ -4109,7 +4162,7 @@ y.prototype.N = function() {
 Object.defineProperty(y.prototype, "value", { get: function() {
   if (1 & this.f)
     throw new Error("Cycle detected");
-  var i2 = e$1(this);
+  var i2 = e(this);
   this.h();
   if (void 0 !== i2)
     i2.i = this.i;
@@ -4392,46 +4445,2005 @@ function useSignal(n2) {
     return d$1(n2);
   }, []);
 }
-function e(e2, n2) {
-  return n2 = n2 || {}, new Promise(function(t2, r2) {
-    var s2 = new XMLHttpRequest(), o2 = [], u2 = {}, a2 = function e3() {
-      return { ok: 2 == (s2.status / 100 | 0), statusText: s2.statusText, status: s2.status, url: s2.responseURL, text: function() {
-        return Promise.resolve(s2.responseText);
-      }, json: function() {
-        return Promise.resolve(s2.responseText).then(JSON.parse);
-      }, blob: function() {
-        return Promise.resolve(new Blob([s2.response]));
-      }, clone: e3, headers: { keys: function() {
-        return o2;
-      }, entries: function() {
-        return o2.map(function(e4) {
-          return [e4, s2.getResponseHeader(e4)];
-        });
-      }, get: function(e4) {
-        return s2.getResponseHeader(e4);
-      }, has: function(e4) {
-        return null != s2.getResponseHeader(e4);
-      } } };
-    };
-    for (var i2 in s2.open(n2.method || "get", e2, true), s2.onload = function() {
-      s2.getAllResponseHeaders().toLowerCase().replace(/^(.+?):/gm, function(e3, n3) {
-        u2[n3] || o2.push(u2[n3] = n3);
-      }), t2(a2());
-    }, s2.onerror = r2, s2.withCredentials = "include" == n2.credentials, n2.headers)
-      s2.setRequestHeader(i2, n2.headers[i2]);
-    s2.send(n2.body || null);
+var browser = {};
+var canPromise$1 = function() {
+  return typeof Promise === "function" && Promise.prototype && Promise.prototype.then;
+};
+var qrcode = {};
+var utils$1 = {};
+let toSJISFunction;
+const CODEWORDS_COUNT = [
+  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
+];
+utils$1.getSymbolSize = function getSymbolSize(version2) {
+  if (!version2)
+    throw new Error('"version" cannot be null or undefined');
+  if (version2 < 1 || version2 > 40)
+    throw new Error('"version" should be in range from 1 to 40');
+  return version2 * 4 + 17;
+};
+utils$1.getSymbolTotalCodewords = function getSymbolTotalCodewords(version2) {
+  return CODEWORDS_COUNT[version2];
+};
+utils$1.getBCHDigit = function(data) {
+  let digit = 0;
+  while (data !== 0) {
+    digit++;
+    data >>>= 1;
+  }
+  return digit;
+};
+utils$1.setToSJISFunction = function setToSJISFunction(f2) {
+  if (typeof f2 !== "function") {
+    throw new Error('"toSJISFunc" is not a valid function.');
+  }
+  toSJISFunction = f2;
+};
+utils$1.isKanjiModeEnabled = function() {
+  return typeof toSJISFunction !== "undefined";
+};
+utils$1.toSJIS = function toSJIS(kanji2) {
+  return toSJISFunction(kanji2);
+};
+var errorCorrectionLevel = {};
+(function(exports) {
+  exports.L = { bit: 1 };
+  exports.M = { bit: 0 };
+  exports.Q = { bit: 3 };
+  exports.H = { bit: 2 };
+  function fromString(string) {
+    if (typeof string !== "string") {
+      throw new Error("Param is not a string");
+    }
+    const lcStr = string.toLowerCase();
+    switch (lcStr) {
+      case "l":
+      case "low":
+        return exports.L;
+      case "m":
+      case "medium":
+        return exports.M;
+      case "q":
+      case "quartile":
+        return exports.Q;
+      case "h":
+      case "high":
+        return exports.H;
+      default:
+        throw new Error("Unknown EC Level: " + string);
+    }
+  }
+  exports.isValid = function isValid2(level) {
+    return level && typeof level.bit !== "undefined" && level.bit >= 0 && level.bit < 4;
+  };
+  exports.from = function from(value, defaultValue) {
+    if (exports.isValid(value)) {
+      return value;
+    }
+    try {
+      return fromString(value);
+    } catch (e2) {
+      return defaultValue;
+    }
+  };
+})(errorCorrectionLevel);
+function BitBuffer$1() {
+  this.buffer = [];
+  this.length = 0;
+}
+BitBuffer$1.prototype = {
+  get: function(index2) {
+    const bufIndex = Math.floor(index2 / 8);
+    return (this.buffer[bufIndex] >>> 7 - index2 % 8 & 1) === 1;
+  },
+  put: function(num, length) {
+    for (let i2 = 0; i2 < length; i2++) {
+      this.putBit((num >>> length - i2 - 1 & 1) === 1);
+    }
+  },
+  getLengthInBits: function() {
+    return this.length;
+  },
+  putBit: function(bit) {
+    const bufIndex = Math.floor(this.length / 8);
+    if (this.buffer.length <= bufIndex) {
+      this.buffer.push(0);
+    }
+    if (bit) {
+      this.buffer[bufIndex] |= 128 >>> this.length % 8;
+    }
+    this.length++;
+  }
+};
+var bitBuffer = BitBuffer$1;
+function BitMatrix$1(size) {
+  if (!size || size < 1) {
+    throw new Error("BitMatrix size must be defined and greater than 0");
+  }
+  this.size = size;
+  this.data = new Uint8Array(size * size);
+  this.reservedBit = new Uint8Array(size * size);
+}
+BitMatrix$1.prototype.set = function(row, col, value, reserved) {
+  const index2 = row * this.size + col;
+  this.data[index2] = value;
+  if (reserved)
+    this.reservedBit[index2] = true;
+};
+BitMatrix$1.prototype.get = function(row, col) {
+  return this.data[row * this.size + col];
+};
+BitMatrix$1.prototype.xor = function(row, col, value) {
+  this.data[row * this.size + col] ^= value;
+};
+BitMatrix$1.prototype.isReserved = function(row, col) {
+  return this.reservedBit[row * this.size + col];
+};
+var bitMatrix = BitMatrix$1;
+var alignmentPattern = {};
+(function(exports) {
+  const getSymbolSize3 = utils$1.getSymbolSize;
+  exports.getRowColCoords = function getRowColCoords(version2) {
+    if (version2 === 1)
+      return [];
+    const posCount = Math.floor(version2 / 7) + 2;
+    const size = getSymbolSize3(version2);
+    const intervals = size === 145 ? 26 : Math.ceil((size - 13) / (2 * posCount - 2)) * 2;
+    const positions = [size - 7];
+    for (let i2 = 1; i2 < posCount - 1; i2++) {
+      positions[i2] = positions[i2 - 1] - intervals;
+    }
+    positions.push(6);
+    return positions.reverse();
+  };
+  exports.getPositions = function getPositions2(version2) {
+    const coords = [];
+    const pos = exports.getRowColCoords(version2);
+    const posLength = pos.length;
+    for (let i2 = 0; i2 < posLength; i2++) {
+      for (let j2 = 0; j2 < posLength; j2++) {
+        if (i2 === 0 && j2 === 0 || // top-left
+        i2 === 0 && j2 === posLength - 1 || // bottom-left
+        i2 === posLength - 1 && j2 === 0) {
+          continue;
+        }
+        coords.push([pos[i2], pos[j2]]);
+      }
+    }
+    return coords;
+  };
+})(alignmentPattern);
+var finderPattern = {};
+const getSymbolSize2 = utils$1.getSymbolSize;
+const FINDER_PATTERN_SIZE = 7;
+finderPattern.getPositions = function getPositions(version2) {
+  const size = getSymbolSize2(version2);
+  return [
+    // top-left
+    [0, 0],
+    // top-right
+    [size - FINDER_PATTERN_SIZE, 0],
+    // bottom-left
+    [0, size - FINDER_PATTERN_SIZE]
+  ];
+};
+var maskPattern = {};
+(function(exports) {
+  exports.Patterns = {
+    PATTERN000: 0,
+    PATTERN001: 1,
+    PATTERN010: 2,
+    PATTERN011: 3,
+    PATTERN100: 4,
+    PATTERN101: 5,
+    PATTERN110: 6,
+    PATTERN111: 7
+  };
+  const PenaltyScores = {
+    N1: 3,
+    N2: 3,
+    N3: 40,
+    N4: 10
+  };
+  exports.isValid = function isValid2(mask) {
+    return mask != null && mask !== "" && !isNaN(mask) && mask >= 0 && mask <= 7;
+  };
+  exports.from = function from(value) {
+    return exports.isValid(value) ? parseInt(value, 10) : void 0;
+  };
+  exports.getPenaltyN1 = function getPenaltyN1(data) {
+    const size = data.size;
+    let points = 0;
+    let sameCountCol = 0;
+    let sameCountRow = 0;
+    let lastCol = null;
+    let lastRow = null;
+    for (let row = 0; row < size; row++) {
+      sameCountCol = sameCountRow = 0;
+      lastCol = lastRow = null;
+      for (let col = 0; col < size; col++) {
+        let module = data.get(row, col);
+        if (module === lastCol) {
+          sameCountCol++;
+        } else {
+          if (sameCountCol >= 5)
+            points += PenaltyScores.N1 + (sameCountCol - 5);
+          lastCol = module;
+          sameCountCol = 1;
+        }
+        module = data.get(col, row);
+        if (module === lastRow) {
+          sameCountRow++;
+        } else {
+          if (sameCountRow >= 5)
+            points += PenaltyScores.N1 + (sameCountRow - 5);
+          lastRow = module;
+          sameCountRow = 1;
+        }
+      }
+      if (sameCountCol >= 5)
+        points += PenaltyScores.N1 + (sameCountCol - 5);
+      if (sameCountRow >= 5)
+        points += PenaltyScores.N1 + (sameCountRow - 5);
+    }
+    return points;
+  };
+  exports.getPenaltyN2 = function getPenaltyN2(data) {
+    const size = data.size;
+    let points = 0;
+    for (let row = 0; row < size - 1; row++) {
+      for (let col = 0; col < size - 1; col++) {
+        const last = data.get(row, col) + data.get(row, col + 1) + data.get(row + 1, col) + data.get(row + 1, col + 1);
+        if (last === 4 || last === 0)
+          points++;
+      }
+    }
+    return points * PenaltyScores.N2;
+  };
+  exports.getPenaltyN3 = function getPenaltyN3(data) {
+    const size = data.size;
+    let points = 0;
+    let bitsCol = 0;
+    let bitsRow = 0;
+    for (let row = 0; row < size; row++) {
+      bitsCol = bitsRow = 0;
+      for (let col = 0; col < size; col++) {
+        bitsCol = bitsCol << 1 & 2047 | data.get(row, col);
+        if (col >= 10 && (bitsCol === 1488 || bitsCol === 93))
+          points++;
+        bitsRow = bitsRow << 1 & 2047 | data.get(col, row);
+        if (col >= 10 && (bitsRow === 1488 || bitsRow === 93))
+          points++;
+      }
+    }
+    return points * PenaltyScores.N3;
+  };
+  exports.getPenaltyN4 = function getPenaltyN4(data) {
+    let darkCount = 0;
+    const modulesCount = data.data.length;
+    for (let i2 = 0; i2 < modulesCount; i2++)
+      darkCount += data.data[i2];
+    const k2 = Math.abs(Math.ceil(darkCount * 100 / modulesCount / 5) - 10);
+    return k2 * PenaltyScores.N4;
+  };
+  function getMaskAt(maskPattern2, i2, j2) {
+    switch (maskPattern2) {
+      case exports.Patterns.PATTERN000:
+        return (i2 + j2) % 2 === 0;
+      case exports.Patterns.PATTERN001:
+        return i2 % 2 === 0;
+      case exports.Patterns.PATTERN010:
+        return j2 % 3 === 0;
+      case exports.Patterns.PATTERN011:
+        return (i2 + j2) % 3 === 0;
+      case exports.Patterns.PATTERN100:
+        return (Math.floor(i2 / 2) + Math.floor(j2 / 3)) % 2 === 0;
+      case exports.Patterns.PATTERN101:
+        return i2 * j2 % 2 + i2 * j2 % 3 === 0;
+      case exports.Patterns.PATTERN110:
+        return (i2 * j2 % 2 + i2 * j2 % 3) % 2 === 0;
+      case exports.Patterns.PATTERN111:
+        return (i2 * j2 % 3 + (i2 + j2) % 2) % 2 === 0;
+      default:
+        throw new Error("bad maskPattern:" + maskPattern2);
+    }
+  }
+  exports.applyMask = function applyMask(pattern, data) {
+    const size = data.size;
+    for (let col = 0; col < size; col++) {
+      for (let row = 0; row < size; row++) {
+        if (data.isReserved(row, col))
+          continue;
+        data.xor(row, col, getMaskAt(pattern, row, col));
+      }
+    }
+  };
+  exports.getBestMask = function getBestMask(data, setupFormatFunc) {
+    const numPatterns = Object.keys(exports.Patterns).length;
+    let bestPattern = 0;
+    let lowerPenalty = Infinity;
+    for (let p2 = 0; p2 < numPatterns; p2++) {
+      setupFormatFunc(p2);
+      exports.applyMask(p2, data);
+      const penalty = exports.getPenaltyN1(data) + exports.getPenaltyN2(data) + exports.getPenaltyN3(data) + exports.getPenaltyN4(data);
+      exports.applyMask(p2, data);
+      if (penalty < lowerPenalty) {
+        lowerPenalty = penalty;
+        bestPattern = p2;
+      }
+    }
+    return bestPattern;
+  };
+})(maskPattern);
+var errorCorrectionCode = {};
+const ECLevel$1 = errorCorrectionLevel;
+const EC_BLOCKS_TABLE = [
+  // 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
+];
+const EC_CODEWORDS_TABLE = [
+  // 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
+];
+errorCorrectionCode.getBlocksCount = function getBlocksCount(version2, errorCorrectionLevel2) {
+  switch (errorCorrectionLevel2) {
+    case ECLevel$1.L:
+      return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 0];
+    case ECLevel$1.M:
+      return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 1];
+    case ECLevel$1.Q:
+      return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 2];
+    case ECLevel$1.H:
+      return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 3];
+    default:
+      return void 0;
+  }
+};
+errorCorrectionCode.getTotalCodewordsCount = function getTotalCodewordsCount(version2, errorCorrectionLevel2) {
+  switch (errorCorrectionLevel2) {
+    case ECLevel$1.L:
+      return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 0];
+    case ECLevel$1.M:
+      return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 1];
+    case ECLevel$1.Q:
+      return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 2];
+    case ECLevel$1.H:
+      return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 3];
+    default:
+      return void 0;
+  }
+};
+var polynomial = {};
+var galoisField = {};
+const EXP_TABLE = new Uint8Array(512);
+const LOG_TABLE = new Uint8Array(256);
+(function initTables() {
+  let x2 = 1;
+  for (let i2 = 0; i2 < 255; i2++) {
+    EXP_TABLE[i2] = x2;
+    LOG_TABLE[x2] = i2;
+    x2 <<= 1;
+    if (x2 & 256) {
+      x2 ^= 285;
+    }
+  }
+  for (let i2 = 255; i2 < 512; i2++) {
+    EXP_TABLE[i2] = EXP_TABLE[i2 - 255];
+  }
+})();
+galoisField.log = function log(n2) {
+  if (n2 < 1)
+    throw new Error("log(" + n2 + ")");
+  return LOG_TABLE[n2];
+};
+galoisField.exp = function exp(n2) {
+  return EXP_TABLE[n2];
+};
+galoisField.mul = function mul(x2, y2) {
+  if (x2 === 0 || y2 === 0)
+    return 0;
+  return EXP_TABLE[LOG_TABLE[x2] + LOG_TABLE[y2]];
+};
+(function(exports) {
+  const GF = galoisField;
+  exports.mul = function mul2(p1, p2) {
+    const coeff = new Uint8Array(p1.length + p2.length - 1);
+    for (let i2 = 0; i2 < p1.length; i2++) {
+      for (let j2 = 0; j2 < p2.length; j2++) {
+        coeff[i2 + j2] ^= GF.mul(p1[i2], p2[j2]);
+      }
+    }
+    return coeff;
+  };
+  exports.mod = function mod(divident, divisor) {
+    let result = new Uint8Array(divident);
+    while (result.length - divisor.length >= 0) {
+      const coeff = result[0];
+      for (let i2 = 0; i2 < divisor.length; i2++) {
+        result[i2] ^= GF.mul(divisor[i2], coeff);
+      }
+      let offset = 0;
+      while (offset < result.length && result[offset] === 0)
+        offset++;
+      result = result.slice(offset);
+    }
+    return result;
+  };
+  exports.generateECPolynomial = function generateECPolynomial(degree) {
+    let poly = new Uint8Array([1]);
+    for (let i2 = 0; i2 < degree; i2++) {
+      poly = exports.mul(poly, new Uint8Array([1, GF.exp(i2)]));
+    }
+    return poly;
+  };
+})(polynomial);
+const Polynomial = polynomial;
+function ReedSolomonEncoder$1(degree) {
+  this.genPoly = void 0;
+  this.degree = degree;
+  if (this.degree)
+    this.initialize(this.degree);
+}
+ReedSolomonEncoder$1.prototype.initialize = function initialize(degree) {
+  this.degree = degree;
+  this.genPoly = Polynomial.generateECPolynomial(this.degree);
+};
+ReedSolomonEncoder$1.prototype.encode = function encode(data) {
+  if (!this.genPoly) {
+    throw new Error("Encoder not initialized");
+  }
+  const paddedData = new Uint8Array(data.length + this.degree);
+  paddedData.set(data);
+  const remainder = Polynomial.mod(paddedData, this.genPoly);
+  const start = this.degree - remainder.length;
+  if (start > 0) {
+    const buff = new Uint8Array(this.degree);
+    buff.set(remainder, start);
+    return buff;
+  }
+  return remainder;
+};
+var reedSolomonEncoder = ReedSolomonEncoder$1;
+var version = {};
+var mode = {};
+var versionCheck = {};
+versionCheck.isValid = function isValid(version2) {
+  return !isNaN(version2) && version2 >= 1 && version2 <= 40;
+};
+var regex = {};
+const numeric = "[0-9]+";
+const alphanumeric = "[A-Z $%*+\\-./:]+";
+let kanji = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
+kanji = kanji.replace(/u/g, "\\u");
+const byte = "(?:(?![A-Z0-9 $%*+\\-./:]|" + kanji + ")(?:.|[\r\n]))+";
+regex.KANJI = new RegExp(kanji, "g");
+regex.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g");
+regex.BYTE = new RegExp(byte, "g");
+regex.NUMERIC = new RegExp(numeric, "g");
+regex.ALPHANUMERIC = new RegExp(alphanumeric, "g");
+const TEST_KANJI = new RegExp("^" + kanji + "$");
+const TEST_NUMERIC = new RegExp("^" + numeric + "$");
+const TEST_ALPHANUMERIC = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+regex.testKanji = function testKanji(str) {
+  return TEST_KANJI.test(str);
+};
+regex.testNumeric = function testNumeric(str) {
+  return TEST_NUMERIC.test(str);
+};
+regex.testAlphanumeric = function testAlphanumeric(str) {
+  return TEST_ALPHANUMERIC.test(str);
+};
+(function(exports) {
+  const VersionCheck = versionCheck;
+  const Regex = regex;
+  exports.NUMERIC = {
+    id: "Numeric",
+    bit: 1 << 0,
+    ccBits: [10, 12, 14]
+  };
+  exports.ALPHANUMERIC = {
+    id: "Alphanumeric",
+    bit: 1 << 1,
+    ccBits: [9, 11, 13]
+  };
+  exports.BYTE = {
+    id: "Byte",
+    bit: 1 << 2,
+    ccBits: [8, 16, 16]
+  };
+  exports.KANJI = {
+    id: "Kanji",
+    bit: 1 << 3,
+    ccBits: [8, 10, 12]
+  };
+  exports.MIXED = {
+    bit: -1
+  };
+  exports.getCharCountIndicator = function getCharCountIndicator(mode2, version2) {
+    if (!mode2.ccBits)
+      throw new Error("Invalid mode: " + mode2);
+    if (!VersionCheck.isValid(version2)) {
+      throw new Error("Invalid version: " + version2);
+    }
+    if (version2 >= 1 && version2 < 10)
+      return mode2.ccBits[0];
+    else if (version2 < 27)
+      return mode2.ccBits[1];
+    return mode2.ccBits[2];
+  };
+  exports.getBestModeForData = function getBestModeForData(dataStr) {
+    if (Regex.testNumeric(dataStr))
+      return exports.NUMERIC;
+    else if (Regex.testAlphanumeric(dataStr))
+      return exports.ALPHANUMERIC;
+    else if (Regex.testKanji(dataStr))
+      return exports.KANJI;
+    else
+      return exports.BYTE;
+  };
+  exports.toString = function toString(mode2) {
+    if (mode2 && mode2.id)
+      return mode2.id;
+    throw new Error("Invalid mode");
+  };
+  exports.isValid = function isValid2(mode2) {
+    return mode2 && mode2.bit && mode2.ccBits;
+  };
+  function fromString(string) {
+    if (typeof string !== "string") {
+      throw new Error("Param is not a string");
+    }
+    const lcStr = string.toLowerCase();
+    switch (lcStr) {
+      case "numeric":
+        return exports.NUMERIC;
+      case "alphanumeric":
+        return exports.ALPHANUMERIC;
+      case "kanji":
+        return exports.KANJI;
+      case "byte":
+        return exports.BYTE;
+      default:
+        throw new Error("Unknown mode: " + string);
+    }
+  }
+  exports.from = function from(value, defaultValue) {
+    if (exports.isValid(value)) {
+      return value;
+    }
+    try {
+      return fromString(value);
+    } catch (e2) {
+      return defaultValue;
+    }
+  };
+})(mode);
+(function(exports) {
+  const Utils2 = utils$1;
+  const ECCode2 = errorCorrectionCode;
+  const ECLevel2 = errorCorrectionLevel;
+  const Mode2 = mode;
+  const VersionCheck = versionCheck;
+  const G18 = 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0;
+  const G18_BCH = Utils2.getBCHDigit(G18);
+  function getBestVersionForDataLength(mode2, length, errorCorrectionLevel2) {
+    for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
+      if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel2, mode2)) {
+        return currentVersion;
+      }
+    }
+    return void 0;
+  }
+  function getReservedBitsCount(mode2, version2) {
+    return Mode2.getCharCountIndicator(mode2, version2) + 4;
+  }
+  function getTotalBitsFromDataArray(segments2, version2) {
+    let totalBits = 0;
+    segments2.forEach(function(data) {
+      const reservedBits = getReservedBitsCount(data.mode, version2);
+      totalBits += reservedBits + data.getBitsLength();
+    });
+    return totalBits;
+  }
+  function getBestVersionForMixedData(segments2, errorCorrectionLevel2) {
+    for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
+      const length = getTotalBitsFromDataArray(segments2, currentVersion);
+      if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel2, Mode2.MIXED)) {
+        return currentVersion;
+      }
+    }
+    return void 0;
+  }
+  exports.from = function from(value, defaultValue) {
+    if (VersionCheck.isValid(value)) {
+      return parseInt(value, 10);
+    }
+    return defaultValue;
+  };
+  exports.getCapacity = function getCapacity(version2, errorCorrectionLevel2, mode2) {
+    if (!VersionCheck.isValid(version2)) {
+      throw new Error("Invalid QR Code version");
+    }
+    if (typeof mode2 === "undefined")
+      mode2 = Mode2.BYTE;
+    const totalCodewords = Utils2.getSymbolTotalCodewords(version2);
+    const ecTotalCodewords = ECCode2.getTotalCodewordsCount(version2, errorCorrectionLevel2);
+    const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
+    if (mode2 === Mode2.MIXED)
+      return dataTotalCodewordsBits;
+    const usableBits = dataTotalCodewordsBits - getReservedBitsCount(mode2, version2);
+    switch (mode2) {
+      case Mode2.NUMERIC:
+        return Math.floor(usableBits / 10 * 3);
+      case Mode2.ALPHANUMERIC:
+        return Math.floor(usableBits / 11 * 2);
+      case Mode2.KANJI:
+        return Math.floor(usableBits / 13);
+      case Mode2.BYTE:
+      default:
+        return Math.floor(usableBits / 8);
+    }
+  };
+  exports.getBestVersionForData = function getBestVersionForData(data, errorCorrectionLevel2) {
+    let seg;
+    const ecl = ECLevel2.from(errorCorrectionLevel2, ECLevel2.M);
+    if (Array.isArray(data)) {
+      if (data.length > 1) {
+        return getBestVersionForMixedData(data, ecl);
+      }
+      if (data.length === 0) {
+        return 1;
+      }
+      seg = data[0];
+    } else {
+      seg = data;
+    }
+    return getBestVersionForDataLength(seg.mode, seg.getLength(), ecl);
+  };
+  exports.getEncodedBits = function getEncodedBits2(version2) {
+    if (!VersionCheck.isValid(version2) || version2 < 7) {
+      throw new Error("Invalid QR Code version");
+    }
+    let d2 = version2 << 12;
+    while (Utils2.getBCHDigit(d2) - G18_BCH >= 0) {
+      d2 ^= G18 << Utils2.getBCHDigit(d2) - G18_BCH;
+    }
+    return version2 << 12 | d2;
+  };
+})(version);
+var formatInfo = {};
+const Utils$3 = utils$1;
+const G15 = 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0;
+const G15_MASK = 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1;
+const G15_BCH = Utils$3.getBCHDigit(G15);
+formatInfo.getEncodedBits = function getEncodedBits(errorCorrectionLevel2, mask) {
+  const data = errorCorrectionLevel2.bit << 3 | mask;
+  let d2 = data << 10;
+  while (Utils$3.getBCHDigit(d2) - G15_BCH >= 0) {
+    d2 ^= G15 << Utils$3.getBCHDigit(d2) - G15_BCH;
+  }
+  return (data << 10 | d2) ^ G15_MASK;
+};
+var segments = {};
+const Mode$4 = mode;
+function NumericData(data) {
+  this.mode = Mode$4.NUMERIC;
+  this.data = data.toString();
+}
+NumericData.getBitsLength = function getBitsLength(length) {
+  return 10 * Math.floor(length / 3) + (length % 3 ? length % 3 * 3 + 1 : 0);
+};
+NumericData.prototype.getLength = function getLength() {
+  return this.data.length;
+};
+NumericData.prototype.getBitsLength = function getBitsLength2() {
+  return NumericData.getBitsLength(this.data.length);
+};
+NumericData.prototype.write = function write(bitBuffer2) {
+  let i2, group, value;
+  for (i2 = 0; i2 + 3 <= this.data.length; i2 += 3) {
+    group = this.data.substr(i2, 3);
+    value = parseInt(group, 10);
+    bitBuffer2.put(value, 10);
+  }
+  const remainingNum = this.data.length - i2;
+  if (remainingNum > 0) {
+    group = this.data.substr(i2);
+    value = parseInt(group, 10);
+    bitBuffer2.put(value, remainingNum * 3 + 1);
+  }
+};
+var numericData = NumericData;
+const Mode$3 = mode;
+const ALPHA_NUM_CHARS = [
+  "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 AlphanumericData(data) {
+  this.mode = Mode$3.ALPHANUMERIC;
+  this.data = data;
+}
+AlphanumericData.getBitsLength = function getBitsLength3(length) {
+  return 11 * Math.floor(length / 2) + 6 * (length % 2);
+};
+AlphanumericData.prototype.getLength = function getLength2() {
+  return this.data.length;
+};
+AlphanumericData.prototype.getBitsLength = function getBitsLength4() {
+  return AlphanumericData.getBitsLength(this.data.length);
+};
+AlphanumericData.prototype.write = function write2(bitBuffer2) {
+  let i2;
+  for (i2 = 0; i2 + 2 <= this.data.length; i2 += 2) {
+    let value = ALPHA_NUM_CHARS.indexOf(this.data[i2]) * 45;
+    value += ALPHA_NUM_CHARS.indexOf(this.data[i2 + 1]);
+    bitBuffer2.put(value, 11);
+  }
+  if (this.data.length % 2) {
+    bitBuffer2.put(ALPHA_NUM_CHARS.indexOf(this.data[i2]), 6);
+  }
+};
+var alphanumericData = AlphanumericData;
+const Mode$2 = mode;
+function ByteData(data) {
+  this.mode = Mode$2.BYTE;
+  if (typeof data === "string") {
+    this.data = new TextEncoder().encode(data);
+  } else {
+    this.data = new Uint8Array(data);
+  }
+}
+ByteData.getBitsLength = function getBitsLength5(length) {
+  return length * 8;
+};
+ByteData.prototype.getLength = function getLength3() {
+  return this.data.length;
+};
+ByteData.prototype.getBitsLength = function getBitsLength6() {
+  return ByteData.getBitsLength(this.data.length);
+};
+ByteData.prototype.write = function(bitBuffer2) {
+  for (let i2 = 0, l2 = this.data.length; i2 < l2; i2++) {
+    bitBuffer2.put(this.data[i2], 8);
+  }
+};
+var byteData = ByteData;
+const Mode$1 = mode;
+const Utils$2 = utils$1;
+function KanjiData(data) {
+  this.mode = Mode$1.KANJI;
+  this.data = data;
+}
+KanjiData.getBitsLength = function getBitsLength7(length) {
+  return length * 13;
+};
+KanjiData.prototype.getLength = function getLength4() {
+  return this.data.length;
+};
+KanjiData.prototype.getBitsLength = function getBitsLength8() {
+  return KanjiData.getBitsLength(this.data.length);
+};
+KanjiData.prototype.write = function(bitBuffer2) {
+  let i2;
+  for (i2 = 0; i2 < this.data.length; i2++) {
+    let value = Utils$2.toSJIS(this.data[i2]);
+    if (value >= 33088 && value <= 40956) {
+      value -= 33088;
+    } else if (value >= 57408 && value <= 60351) {
+      value -= 49472;
+    } else {
+      throw new Error(
+        "Invalid SJIS character: " + this.data[i2] + "\nMake sure your charset is UTF-8"
+      );
+    }
+    value = (value >>> 8 & 255) * 192 + (value & 255);
+    bitBuffer2.put(value, 13);
+  }
+};
+var kanjiData = KanjiData;
+var dijkstra = { exports: {} };
+(function(module) {
+  var dijkstra2 = {
+    single_source_shortest_paths: function(graph, s2, d2) {
+      var predecessors = {};
+      var costs = {};
+      costs[s2] = 0;
+      var open = dijkstra2.PriorityQueue.make();
+      open.push(s2, 0);
+      var closest, u2, v2, cost_of_s_to_u, adjacent_nodes, cost_of_e, cost_of_s_to_u_plus_cost_of_e, cost_of_s_to_v, first_visit;
+      while (!open.empty()) {
+        closest = open.pop();
+        u2 = closest.value;
+        cost_of_s_to_u = closest.cost;
+        adjacent_nodes = graph[u2] || {};
+        for (v2 in adjacent_nodes) {
+          if (adjacent_nodes.hasOwnProperty(v2)) {
+            cost_of_e = adjacent_nodes[v2];
+            cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;
+            cost_of_s_to_v = costs[v2];
+            first_visit = typeof costs[v2] === "undefined";
+            if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {
+              costs[v2] = cost_of_s_to_u_plus_cost_of_e;
+              open.push(v2, cost_of_s_to_u_plus_cost_of_e);
+              predecessors[v2] = u2;
+            }
+          }
+        }
+      }
+      if (typeof d2 !== "undefined" && typeof costs[d2] === "undefined") {
+        var msg = ["Could not find a path from ", s2, " to ", d2, "."].join("");
+        throw new Error(msg);
+      }
+      return predecessors;
+    },
+    extract_shortest_path_from_predecessor_list: function(predecessors, d2) {
+      var nodes = [];
+      var u2 = d2;
+      while (u2) {
+        nodes.push(u2);
+        predecessors[u2];
+        u2 = predecessors[u2];
+      }
+      nodes.reverse();
+      return nodes;
+    },
+    find_path: function(graph, s2, d2) {
+      var predecessors = dijkstra2.single_source_shortest_paths(graph, s2, d2);
+      return dijkstra2.extract_shortest_path_from_predecessor_list(
+        predecessors,
+        d2
+      );
+    },
+    /**
+     * A very naive priority queue implementation.
+     */
+    PriorityQueue: {
+      make: function(opts) {
+        var T2 = dijkstra2.PriorityQueue, t2 = {}, key;
+        opts = opts || {};
+        for (key in T2) {
+          if (T2.hasOwnProperty(key)) {
+            t2[key] = T2[key];
+          }
+        }
+        t2.queue = [];
+        t2.sorter = opts.sorter || T2.default_sorter;
+        return t2;
+      },
+      default_sorter: function(a2, b2) {
+        return a2.cost - b2.cost;
+      },
+      /**
+       * Add a new item to the queue and ensure the highest priority element
+       * is at the front of the queue.
+       */
+      push: function(value, cost) {
+        var item = { value, cost };
+        this.queue.push(item);
+        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;
+      }
+    }
+  };
+  {
+    module.exports = dijkstra2;
+  }
+})(dijkstra);
+var dijkstraExports = dijkstra.exports;
+(function(exports) {
+  const Mode2 = mode;
+  const NumericData2 = numericData;
+  const AlphanumericData2 = alphanumericData;
+  const ByteData2 = byteData;
+  const KanjiData2 = kanjiData;
+  const Regex = regex;
+  const Utils2 = utils$1;
+  const dijkstra2 = dijkstraExports;
+  function getStringByteLength(str) {
+    return unescape(encodeURIComponent(str)).length;
+  }
+  function getSegments(regex2, mode2, str) {
+    const segments2 = [];
+    let result;
+    while ((result = regex2.exec(str)) !== null) {
+      segments2.push({
+        data: result[0],
+        index: result.index,
+        mode: mode2,
+        length: result[0].length
+      });
+    }
+    return segments2;
+  }
+  function getSegmentsFromString(dataStr) {
+    const numSegs = getSegments(Regex.NUMERIC, Mode2.NUMERIC, dataStr);
+    const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode2.ALPHANUMERIC, dataStr);
+    let byteSegs;
+    let kanjiSegs;
+    if (Utils2.isKanjiModeEnabled()) {
+      byteSegs = getSegments(Regex.BYTE, Mode2.BYTE, dataStr);
+      kanjiSegs = getSegments(Regex.KANJI, Mode2.KANJI, dataStr);
+    } else {
+      byteSegs = getSegments(Regex.BYTE_KANJI, Mode2.BYTE, dataStr);
+      kanjiSegs = [];
+    }
+    const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs);
+    return segs.sort(function(s1, s2) {
+      return s1.index - s2.index;
+    }).map(function(obj) {
+      return {
+        data: obj.data,
+        mode: obj.mode,
+        length: obj.length
+      };
+    });
+  }
+  function getSegmentBitsLength(length, mode2) {
+    switch (mode2) {
+      case Mode2.NUMERIC:
+        return NumericData2.getBitsLength(length);
+      case Mode2.ALPHANUMERIC:
+        return AlphanumericData2.getBitsLength(length);
+      case Mode2.KANJI:
+        return KanjiData2.getBitsLength(length);
+      case Mode2.BYTE:
+        return ByteData2.getBitsLength(length);
+    }
+  }
+  function mergeSegments(segs) {
+    return segs.reduce(function(acc, curr) {
+      const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null;
+      if (prevSeg && prevSeg.mode === curr.mode) {
+        acc[acc.length - 1].data += curr.data;
+        return acc;
+      }
+      acc.push(curr);
+      return acc;
+    }, []);
+  }
+  function buildNodes(segs) {
+    const nodes = [];
+    for (let i2 = 0; i2 < segs.length; i2++) {
+      const seg = segs[i2];
+      switch (seg.mode) {
+        case Mode2.NUMERIC:
+          nodes.push([
+            seg,
+            { data: seg.data, mode: Mode2.ALPHANUMERIC, length: seg.length },
+            { data: seg.data, mode: Mode2.BYTE, length: seg.length }
+          ]);
+          break;
+        case Mode2.ALPHANUMERIC:
+          nodes.push([
+            seg,
+            { data: seg.data, mode: Mode2.BYTE, length: seg.length }
+          ]);
+          break;
+        case Mode2.KANJI:
+          nodes.push([
+            seg,
+            { data: seg.data, mode: Mode2.BYTE, length: getStringByteLength(seg.data) }
+          ]);
+          break;
+        case Mode2.BYTE:
+          nodes.push([
+            { data: seg.data, mode: Mode2.BYTE, length: getStringByteLength(seg.data) }
+          ]);
+      }
+    }
+    return nodes;
+  }
+  function buildGraph(nodes, version2) {
+    const table = {};
+    const graph = { start: {} };
+    let prevNodeIds = ["start"];
+    for (let i2 = 0; i2 < nodes.length; i2++) {
+      const nodeGroup = nodes[i2];
+      const currentNodeIds = [];
+      for (let j2 = 0; j2 < nodeGroup.length; j2++) {
+        const node = nodeGroup[j2];
+        const key = "" + i2 + j2;
+        currentNodeIds.push(key);
+        table[key] = { node, lastCount: 0 };
+        graph[key] = {};
+        for (let n2 = 0; n2 < prevNodeIds.length; n2++) {
+          const prevNodeId = prevNodeIds[n2];
+          if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {
+            graph[prevNodeId][key] = getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) - getSegmentBitsLength(table[prevNodeId].lastCount, node.mode);
+            table[prevNodeId].lastCount += node.length;
+          } else {
+            if (table[prevNodeId])
+              table[prevNodeId].lastCount = node.length;
+            graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) + 4 + Mode2.getCharCountIndicator(node.mode, version2);
+          }
+        }
+      }
+      prevNodeIds = currentNodeIds;
+    }
+    for (let n2 = 0; n2 < prevNodeIds.length; n2++) {
+      graph[prevNodeIds[n2]].end = 0;
+    }
+    return { map: graph, table };
+  }
+  function buildSingleSegment(data, modesHint) {
+    let mode2;
+    const bestMode = Mode2.getBestModeForData(data);
+    mode2 = Mode2.from(modesHint, bestMode);
+    if (mode2 !== Mode2.BYTE && mode2.bit < bestMode.bit) {
+      throw new Error('"' + data + '" cannot be encoded with mode ' + Mode2.toString(mode2) + ".\n Suggested mode is: " + Mode2.toString(bestMode));
+    }
+    if (mode2 === Mode2.KANJI && !Utils2.isKanjiModeEnabled()) {
+      mode2 = Mode2.BYTE;
+    }
+    switch (mode2) {
+      case Mode2.NUMERIC:
+        return new NumericData2(data);
+      case Mode2.ALPHANUMERIC:
+        return new AlphanumericData2(data);
+      case Mode2.KANJI:
+        return new KanjiData2(data);
+      case Mode2.BYTE:
+        return new ByteData2(data);
+    }
+  }
+  exports.fromArray = function fromArray(array) {
+    return array.reduce(function(acc, seg) {
+      if (typeof seg === "string") {
+        acc.push(buildSingleSegment(seg, null));
+      } else if (seg.data) {
+        acc.push(buildSingleSegment(seg.data, seg.mode));
+      }
+      return acc;
+    }, []);
+  };
+  exports.fromString = function fromString(data, version2) {
+    const segs = getSegmentsFromString(data, Utils2.isKanjiModeEnabled());
+    const nodes = buildNodes(segs);
+    const graph = buildGraph(nodes, version2);
+    const path = dijkstra2.find_path(graph.map, "start", "end");
+    const optimizedSegs = [];
+    for (let i2 = 1; i2 < path.length - 1; i2++) {
+      optimizedSegs.push(graph.table[path[i2]].node);
+    }
+    return exports.fromArray(mergeSegments(optimizedSegs));
+  };
+  exports.rawSplit = function rawSplit(data) {
+    return exports.fromArray(
+      getSegmentsFromString(data, Utils2.isKanjiModeEnabled())
+    );
+  };
+})(segments);
+const Utils$1 = utils$1;
+const ECLevel = errorCorrectionLevel;
+const BitBuffer = bitBuffer;
+const BitMatrix = bitMatrix;
+const AlignmentPattern = alignmentPattern;
+const FinderPattern = finderPattern;
+const MaskPattern = maskPattern;
+const ECCode = errorCorrectionCode;
+const ReedSolomonEncoder = reedSolomonEncoder;
+const Version = version;
+const FormatInfo = formatInfo;
+const Mode = mode;
+const Segments = segments;
+function setupFinderPattern(matrix, version2) {
+  const size = matrix.size;
+  const pos = FinderPattern.getPositions(version2);
+  for (let i2 = 0; i2 < pos.length; i2++) {
+    const row = pos[i2][0];
+    const col = pos[i2][1];
+    for (let r2 = -1; r2 <= 7; r2++) {
+      if (row + r2 <= -1 || size <= row + r2)
+        continue;
+      for (let c2 = -1; c2 <= 7; c2++) {
+        if (col + c2 <= -1 || size <= col + c2)
+          continue;
+        if (r2 >= 0 && r2 <= 6 && (c2 === 0 || c2 === 6) || c2 >= 0 && c2 <= 6 && (r2 === 0 || r2 === 6) || r2 >= 2 && r2 <= 4 && c2 >= 2 && c2 <= 4) {
+          matrix.set(row + r2, col + c2, true, true);
+        } else {
+          matrix.set(row + r2, col + c2, false, true);
+        }
+      }
+    }
+  }
+}
+function setupTimingPattern(matrix) {
+  const size = matrix.size;
+  for (let r2 = 8; r2 < size - 8; r2++) {
+    const value = r2 % 2 === 0;
+    matrix.set(r2, 6, value, true);
+    matrix.set(6, r2, value, true);
+  }
+}
+function setupAlignmentPattern(matrix, version2) {
+  const pos = AlignmentPattern.getPositions(version2);
+  for (let i2 = 0; i2 < pos.length; i2++) {
+    const row = pos[i2][0];
+    const col = pos[i2][1];
+    for (let r2 = -2; r2 <= 2; r2++) {
+      for (let c2 = -2; c2 <= 2; c2++) {
+        if (r2 === -2 || r2 === 2 || c2 === -2 || c2 === 2 || r2 === 0 && c2 === 0) {
+          matrix.set(row + r2, col + c2, true, true);
+        } else {
+          matrix.set(row + r2, col + c2, false, true);
+        }
+      }
+    }
+  }
+}
+function setupVersionInfo(matrix, version2) {
+  const size = matrix.size;
+  const bits = Version.getEncodedBits(version2);
+  let row, col, mod;
+  for (let i2 = 0; i2 < 18; i2++) {
+    row = Math.floor(i2 / 3);
+    col = i2 % 3 + size - 8 - 3;
+    mod = (bits >> i2 & 1) === 1;
+    matrix.set(row, col, mod, true);
+    matrix.set(col, row, mod, true);
+  }
+}
+function setupFormatInfo(matrix, errorCorrectionLevel2, maskPattern2) {
+  const size = matrix.size;
+  const bits = FormatInfo.getEncodedBits(errorCorrectionLevel2, maskPattern2);
+  let i2, mod;
+  for (i2 = 0; i2 < 15; i2++) {
+    mod = (bits >> i2 & 1) === 1;
+    if (i2 < 6) {
+      matrix.set(i2, 8, mod, true);
+    } else if (i2 < 8) {
+      matrix.set(i2 + 1, 8, mod, true);
+    } else {
+      matrix.set(size - 15 + i2, 8, mod, true);
+    }
+    if (i2 < 8) {
+      matrix.set(8, size - i2 - 1, mod, true);
+    } else if (i2 < 9) {
+      matrix.set(8, 15 - i2 - 1 + 1, mod, true);
+    } else {
+      matrix.set(8, 15 - i2 - 1, mod, true);
+    }
+  }
+  matrix.set(size - 8, 8, 1, true);
+}
+function setupData(matrix, data) {
+  const size = matrix.size;
+  let inc = -1;
+  let row = size - 1;
+  let bitIndex = 7;
+  let byteIndex = 0;
+  for (let col = size - 1; col > 0; col -= 2) {
+    if (col === 6)
+      col--;
+    while (true) {
+      for (let c2 = 0; c2 < 2; c2++) {
+        if (!matrix.isReserved(row, col - c2)) {
+          let dark = false;
+          if (byteIndex < data.length) {
+            dark = (data[byteIndex] >>> bitIndex & 1) === 1;
+          }
+          matrix.set(row, col - c2, dark);
+          bitIndex--;
+          if (bitIndex === -1) {
+            byteIndex++;
+            bitIndex = 7;
+          }
+        }
+      }
+      row += inc;
+      if (row < 0 || size <= row) {
+        row -= inc;
+        inc = -inc;
+        break;
+      }
+    }
+  }
+}
+function createData(version2, errorCorrectionLevel2, segments2) {
+  const buffer = new BitBuffer();
+  segments2.forEach(function(data) {
+    buffer.put(data.mode.bit, 4);
+    buffer.put(data.getLength(), Mode.getCharCountIndicator(data.mode, version2));
+    data.write(buffer);
   });
+  const totalCodewords = Utils$1.getSymbolTotalCodewords(version2);
+  const ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
+  const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
+  if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {
+    buffer.put(0, 4);
+  }
+  while (buffer.getLengthInBits() % 8 !== 0) {
+    buffer.putBit(0);
+  }
+  const remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8;
+  for (let i2 = 0; i2 < remainingByte; i2++) {
+    buffer.put(i2 % 2 ? 17 : 236, 8);
+  }
+  return createCodewords(buffer, version2, errorCorrectionLevel2);
+}
+function createCodewords(bitBuffer2, version2, errorCorrectionLevel2) {
+  const totalCodewords = Utils$1.getSymbolTotalCodewords(version2);
+  const ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
+  const dataTotalCodewords = totalCodewords - ecTotalCodewords;
+  const ecTotalBlocks = ECCode.getBlocksCount(version2, errorCorrectionLevel2);
+  const blocksInGroup2 = totalCodewords % ecTotalBlocks;
+  const blocksInGroup1 = ecTotalBlocks - blocksInGroup2;
+  const totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks);
+  const dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks);
+  const dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1;
+  const ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1;
+  const rs = new ReedSolomonEncoder(ecCount);
+  let offset = 0;
+  const dcData = new Array(ecTotalBlocks);
+  const ecData = new Array(ecTotalBlocks);
+  let maxDataSize = 0;
+  const buffer = new Uint8Array(bitBuffer2.buffer);
+  for (let b2 = 0; b2 < ecTotalBlocks; b2++) {
+    const dataSize = b2 < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2;
+    dcData[b2] = buffer.slice(offset, offset + dataSize);
+    ecData[b2] = rs.encode(dcData[b2]);
+    offset += dataSize;
+    maxDataSize = Math.max(maxDataSize, dataSize);
+  }
+  const data = new Uint8Array(totalCodewords);
+  let index2 = 0;
+  let i2, r2;
+  for (i2 = 0; i2 < maxDataSize; i2++) {
+    for (r2 = 0; r2 < ecTotalBlocks; r2++) {
+      if (i2 < dcData[r2].length) {
+        data[index2++] = dcData[r2][i2];
+      }
+    }
+  }
+  for (i2 = 0; i2 < ecCount; i2++) {
+    for (r2 = 0; r2 < ecTotalBlocks; r2++) {
+      data[index2++] = ecData[r2][i2];
+    }
+  }
+  return data;
+}
+function createSymbol(data, version2, errorCorrectionLevel2, maskPattern2) {
+  let segments2;
+  if (Array.isArray(data)) {
+    segments2 = Segments.fromArray(data);
+  } else if (typeof data === "string") {
+    let estimatedVersion = version2;
+    if (!estimatedVersion) {
+      const rawSegments = Segments.rawSplit(data);
+      estimatedVersion = Version.getBestVersionForData(rawSegments, errorCorrectionLevel2);
+    }
+    segments2 = Segments.fromString(data, estimatedVersion || 40);
+  } else {
+    throw new Error("Invalid data");
+  }
+  const bestVersion = Version.getBestVersionForData(segments2, errorCorrectionLevel2);
+  if (!bestVersion) {
+    throw new Error("The amount of data is too big to be stored in a QR Code");
+  }
+  if (!version2) {
+    version2 = bestVersion;
+  } else if (version2 < bestVersion) {
+    throw new Error(
+      "\nThe chosen QR Code version cannot contain this amount of data.\nMinimum version required to store current data is: " + bestVersion + ".\n"
+    );
+  }
+  const dataBits = createData(version2, errorCorrectionLevel2, segments2);
+  const moduleCount = Utils$1.getSymbolSize(version2);
+  const modules = new BitMatrix(moduleCount);
+  setupFinderPattern(modules, version2);
+  setupTimingPattern(modules);
+  setupAlignmentPattern(modules, version2);
+  setupFormatInfo(modules, errorCorrectionLevel2, 0);
+  if (version2 >= 7) {
+    setupVersionInfo(modules, version2);
+  }
+  setupData(modules, dataBits);
+  if (isNaN(maskPattern2)) {
+    maskPattern2 = MaskPattern.getBestMask(
+      modules,
+      setupFormatInfo.bind(null, modules, errorCorrectionLevel2)
+    );
+  }
+  MaskPattern.applyMask(maskPattern2, modules);
+  setupFormatInfo(modules, errorCorrectionLevel2, maskPattern2);
+  return {
+    modules,
+    version: version2,
+    errorCorrectionLevel: errorCorrectionLevel2,
+    maskPattern: maskPattern2,
+    segments: segments2
+  };
+}
+qrcode.create = function create(data, options) {
+  if (typeof data === "undefined" || data === "") {
+    throw new Error("No input text");
+  }
+  let errorCorrectionLevel2 = ECLevel.M;
+  let version2;
+  let mask;
+  if (typeof options !== "undefined") {
+    errorCorrectionLevel2 = ECLevel.from(options.errorCorrectionLevel, ECLevel.M);
+    version2 = Version.from(options.version);
+    mask = MaskPattern.from(options.maskPattern);
+    if (options.toSJISFunc) {
+      Utils$1.setToSJISFunction(options.toSJISFunc);
+    }
+  }
+  return createSymbol(data, version2, errorCorrectionLevel2, mask);
+};
+var canvas = {};
+var utils = {};
+(function(exports) {
+  function hex2rgba(hex) {
+    if (typeof hex === "number") {
+      hex = hex.toString();
+    }
+    if (typeof hex !== "string") {
+      throw new Error("Color should be defined as hex string");
+    }
+    let hexCode = hex.slice().replace("#", "").split("");
+    if (hexCode.length < 3 || hexCode.length === 5 || hexCode.length > 8) {
+      throw new Error("Invalid hex color: " + hex);
+    }
+    if (hexCode.length === 3 || hexCode.length === 4) {
+      hexCode = Array.prototype.concat.apply([], hexCode.map(function(c2) {
+        return [c2, c2];
+      }));
+    }
+    if (hexCode.length === 6)
+      hexCode.push("F", "F");
+    const hexValue = parseInt(hexCode.join(""), 16);
+    return {
+      r: hexValue >> 24 & 255,
+      g: hexValue >> 16 & 255,
+      b: hexValue >> 8 & 255,
+      a: hexValue & 255,
+      hex: "#" + hexCode.slice(0, 6).join("")
+    };
+  }
+  exports.getOptions = function getOptions(options) {
+    if (!options)
+      options = {};
+    if (!options.color)
+      options.color = {};
+    const margin = typeof options.margin === "undefined" || options.margin === null || options.margin < 0 ? 4 : options.margin;
+    const width = options.width && options.width >= 21 ? options.width : void 0;
+    const scale = options.scale || 4;
+    return {
+      width,
+      scale: width ? 4 : scale,
+      margin,
+      color: {
+        dark: hex2rgba(options.color.dark || "#000000ff"),
+        light: hex2rgba(options.color.light || "#ffffffff")
+      },
+      type: options.type,
+      rendererOpts: options.rendererOpts || {}
+    };
+  };
+  exports.getScale = function getScale(qrSize, opts) {
+    return opts.width && opts.width >= qrSize + opts.margin * 2 ? opts.width / (qrSize + opts.margin * 2) : opts.scale;
+  };
+  exports.getImageWidth = function getImageWidth(qrSize, opts) {
+    const scale = exports.getScale(qrSize, opts);
+    return Math.floor((qrSize + opts.margin * 2) * scale);
+  };
+  exports.qrToImageData = function qrToImageData(imgData, qr, opts) {
+    const size = qr.modules.size;
+    const data = qr.modules.data;
+    const scale = exports.getScale(size, opts);
+    const symbolSize = Math.floor((size + opts.margin * 2) * scale);
+    const scaledMargin = opts.margin * scale;
+    const palette = [opts.color.light, opts.color.dark];
+    for (let i2 = 0; i2 < symbolSize; i2++) {
+      for (let j2 = 0; j2 < symbolSize; j2++) {
+        let posDst = (i2 * symbolSize + j2) * 4;
+        let pxColor = opts.color.light;
+        if (i2 >= scaledMargin && j2 >= scaledMargin && i2 < symbolSize - scaledMargin && j2 < symbolSize - scaledMargin) {
+          const iSrc = Math.floor((i2 - scaledMargin) / scale);
+          const jSrc = Math.floor((j2 - scaledMargin) / scale);
+          pxColor = palette[data[iSrc * size + jSrc] ? 1 : 0];
+        }
+        imgData[posDst++] = pxColor.r;
+        imgData[posDst++] = pxColor.g;
+        imgData[posDst++] = pxColor.b;
+        imgData[posDst] = pxColor.a;
+      }
+    }
+  };
+})(utils);
+(function(exports) {
+  const Utils2 = utils;
+  function clearCanvas(ctx, canvas2, size) {
+    ctx.clearRect(0, 0, canvas2.width, canvas2.height);
+    if (!canvas2.style)
+      canvas2.style = {};
+    canvas2.height = size;
+    canvas2.width = size;
+    canvas2.style.height = size + "px";
+    canvas2.style.width = size + "px";
+  }
+  function getCanvasElement() {
+    try {
+      return document.createElement("canvas");
+    } catch (e2) {
+      throw new Error("You need to specify a canvas element");
+    }
+  }
+  exports.render = function render2(qrData, canvas2, options) {
+    let opts = options;
+    let canvasEl = canvas2;
+    if (typeof opts === "undefined" && (!canvas2 || !canvas2.getContext)) {
+      opts = canvas2;
+      canvas2 = void 0;
+    }
+    if (!canvas2) {
+      canvasEl = getCanvasElement();
+    }
+    opts = Utils2.getOptions(opts);
+    const size = Utils2.getImageWidth(qrData.modules.size, opts);
+    const ctx = canvasEl.getContext("2d");
+    const image = ctx.createImageData(size, size);
+    Utils2.qrToImageData(image.data, qrData, opts);
+    clearCanvas(ctx, canvasEl, size);
+    ctx.putImageData(image, 0, 0);
+    return canvasEl;
+  };
+  exports.renderToDataURL = function renderToDataURL(qrData, canvas2, options) {
+    let opts = options;
+    if (typeof opts === "undefined" && (!canvas2 || !canvas2.getContext)) {
+      opts = canvas2;
+      canvas2 = void 0;
+    }
+    if (!opts)
+      opts = {};
+    const canvasEl = exports.render(qrData, canvas2, opts);
+    const type = opts.type || "image/png";
+    const rendererOpts = opts.rendererOpts || {};
+    return canvasEl.toDataURL(type, rendererOpts.quality);
+  };
+})(canvas);
+var svgTag = {};
+const Utils = utils;
+function getColorAttrib(color, attrib) {
+  const alpha = color.a / 255;
+  const str = attrib + '="' + color.hex + '"';
+  return alpha < 1 ? str + " " + attrib + '-opacity="' + alpha.toFixed(2).slice(1) + '"' : str;
+}
+function svgCmd(cmd, x2, y2) {
+  let str = cmd + x2;
+  if (typeof y2 !== "undefined")
+    str += " " + y2;
+  return str;
+}
+function qrToPath(data, size, margin) {
+  let path = "";
+  let moveBy = 0;
+  let newRow = false;
+  let lineLength = 0;
+  for (let i2 = 0; i2 < data.length; i2++) {
+    const col = Math.floor(i2 % size);
+    const row = Math.floor(i2 / size);
+    if (!col && !newRow)
+      newRow = true;
+    if (data[i2]) {
+      lineLength++;
+      if (!(i2 > 0 && col > 0 && data[i2 - 1])) {
+        path += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
+        moveBy = 0;
+        newRow = false;
+      }
+      if (!(col + 1 < size && data[i2 + 1])) {
+        path += svgCmd("h", lineLength);
+        lineLength = 0;
+      }
+    } else {
+      moveBy++;
+    }
+  }
+  return path;
+}
+svgTag.render = function render(qrData, options, cb) {
+  const opts = Utils.getOptions(options);
+  const size = qrData.modules.size;
+  const data = qrData.modules.data;
+  const qrcodesize = size + opts.margin * 2;
+  const bg = !opts.color.light.a ? "" : "<path " + getColorAttrib(opts.color.light, "fill") + ' d="M0 0h' + qrcodesize + "v" + qrcodesize + 'H0z"/>';
+  const path = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
+  const viewBox = 'viewBox="0 0 ' + qrcodesize + " " + qrcodesize + '"';
+  const width = !opts.width ? "" : 'width="' + opts.width + '" height="' + opts.width + '" ';
+  const svgTag2 = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path + "</svg>\n";
+  if (typeof cb === "function") {
+    cb(null, svgTag2);
+  }
+  return svgTag2;
+};
+const canPromise = canPromise$1;
+const QRCode = qrcode;
+const CanvasRenderer = canvas;
+const SvgRenderer = svgTag;
+function renderCanvas(renderFunc, canvas2, text, opts, cb) {
+  const args = [].slice.call(arguments, 1);
+  const argsNum = args.length;
+  const isLastArgCb = typeof args[argsNum - 1] === "function";
+  if (!isLastArgCb && !canPromise()) {
+    throw new Error("Callback required as last argument");
+  }
+  if (isLastArgCb) {
+    if (argsNum < 2) {
+      throw new Error("Too few arguments provided");
+    }
+    if (argsNum === 2) {
+      cb = text;
+      text = canvas2;
+      canvas2 = opts = void 0;
+    } else if (argsNum === 3) {
+      if (canvas2.getContext && typeof cb === "undefined") {
+        cb = opts;
+        opts = void 0;
+      } else {
+        cb = opts;
+        opts = text;
+        text = canvas2;
+        canvas2 = void 0;
+      }
+    }
+  } else {
+    if (argsNum < 1) {
+      throw new Error("Too few arguments provided");
+    }
+    if (argsNum === 1) {
+      text = canvas2;
+      canvas2 = opts = void 0;
+    } else if (argsNum === 2 && !canvas2.getContext) {
+      opts = text;
+      text = canvas2;
+      canvas2 = void 0;
+    }
+    return new Promise(function(resolve, reject) {
+      try {
+        const data = QRCode.create(text, opts);
+        resolve(renderFunc(data, canvas2, opts));
+      } catch (e2) {
+        reject(e2);
+      }
+    });
+  }
+  try {
+    const data = QRCode.create(text, opts);
+    cb(null, renderFunc(data, canvas2, opts));
+  } catch (e2) {
+    cb(e2);
+  }
 }
+browser.create = QRCode.create;
+browser.toCanvas = renderCanvas.bind(null, CanvasRenderer.render);
+browser.toDataURL = renderCanvas.bind(null, CanvasRenderer.renderToDataURL);
+browser.toString = renderCanvas.bind(null, function(data, _2, opts) {
+  return SvgRenderer.render(data, opts);
+});
 export {
   A$1 as A,
   B$2 as B,
   F$1 as F,
   G$1 as G,
+  P,
   T$1 as T,
   _$3 as _,
   b$1 as b,
+  browser,
   d$1 as d,
-  e,
+  e$1 as e,
   h$1 as h,
   index,
   inputToRGB,