@blukavantui/community 0.0.0-stage → 1.1.0

package/src/runtime/qr-code.js

@@ -0,0 +1,1942 @@
+// ../blu-grid/docs/scripts/modules/qr-encoder.js
+import { global } from "./kernel.js";
+function installEncoder() {
+  if (global.BluUIQRCodeEncoder) return;
+  var qrcode = (function() {
+    var qrcode2 = function(typeNumber, errorCorrectionLevel) {
+      var PAD0 = 236;
+      var PAD1 = 17;
+      var _typeNumber = typeNumber;
+      var _errorCorrectionLevel = QRErrorCorrectionLevel[errorCorrectionLevel];
+      var _modules = null;
+      var _moduleCount = 0;
+      var _dataCache = null;
+      var _dataList = [];
+      var _this = {};
+      var makeImpl = function(test, maskPattern) {
+        _moduleCount = _typeNumber * 4 + 17;
+        _modules = (function(moduleCount) {
+          var modules = new Array(moduleCount);
+          for (var row = 0; row < moduleCount; row += 1) {
+            modules[row] = new Array(moduleCount);
+            for (var col = 0; col < moduleCount; col += 1) {
+              modules[row][col] = null;
+            }
+          }
+          return modules;
+        })(_moduleCount);
+        setupPositionProbePattern(0, 0);
+        setupPositionProbePattern(_moduleCount - 7, 0);
+        setupPositionProbePattern(0, _moduleCount - 7);
+        setupPositionAdjustPattern();
+        setupTimingPattern();
+        setupTypeInfo(test, maskPattern);
+        if (_typeNumber >= 7) {
+          setupTypeNumber(test);
+        }
+        if (_dataCache == null) {
+          _dataCache = createData(_typeNumber, _errorCorrectionLevel, _dataList);
+        }
+        mapData(_dataCache, maskPattern);
+      };
+      var setupPositionProbePattern = function(row, col) {
+        for (var r = -1; r <= 7; r += 1) {
+          if (row + r <= -1 || _moduleCount <= row + r) continue;
+          for (var c = -1; c <= 7; c += 1) {
+            if (col + c <= -1 || _moduleCount <= col + c) continue;
+            if (0 <= r && r <= 6 && (c == 0 || c == 6) || 0 <= c && c <= 6 && (r == 0 || r == 6) || 2 <= r && r <= 4 && 2 <= c && c <= 4) {
+              _modules[row + r][col + c] = true;
+            } else {
+              _modules[row + r][col + c] = false;
+            }
+          }
+        }
+      };
+      var getBestMaskPattern = function() {
+        var minLostPoint = 0;
+        var pattern = 0;
+        for (var i = 0; i < 8; i += 1) {
+          makeImpl(true, i);
+          var lostPoint = QRUtil.getLostPoint(_this);
+          if (i == 0 || minLostPoint > lostPoint) {
+            minLostPoint = lostPoint;
+            pattern = i;
+          }
+        }
+        return pattern;
+      };
+      var setupTimingPattern = function() {
+        for (var r = 8; r < _moduleCount - 8; r += 1) {
+          if (_modules[r][6] != null) {
+            continue;
+          }
+          _modules[r][6] = r % 2 == 0;
+        }
+        for (var c = 8; c < _moduleCount - 8; c += 1) {
+          if (_modules[6][c] != null) {
+            continue;
+          }
+          _modules[6][c] = c % 2 == 0;
+        }
+      };
+      var setupPositionAdjustPattern = function() {
+        var pos = QRUtil.getPatternPosition(_typeNumber);
+        for (var i = 0; i < pos.length; i += 1) {
+          for (var j = 0; j < pos.length; j += 1) {
+            var row = pos[i];
+            var col = pos[j];
+            if (_modules[row][col] != null) {
+              continue;
+            }
+            for (var r = -2; r <= 2; r += 1) {
+              for (var c = -2; c <= 2; c += 1) {
+                if (r == -2 || r == 2 || c == -2 || c == 2 || r == 0 && c == 0) {
+                  _modules[row + r][col + c] = true;
+                } else {
+                  _modules[row + r][col + c] = false;
+                }
+              }
+            }
+          }
+        }
+      };
+      var setupTypeNumber = function(test) {
+        var bits = QRUtil.getBCHTypeNumber(_typeNumber);
+        for (var i = 0; i < 18; i += 1) {
+          var mod = !test && (bits >> i & 1) == 1;
+          _modules[Math.floor(i / 3)][i % 3 + _moduleCount - 8 - 3] = mod;
+        }
+        for (var i = 0; i < 18; i += 1) {
+          var mod = !test && (bits >> i & 1) == 1;
+          _modules[i % 3 + _moduleCount - 8 - 3][Math.floor(i / 3)] = mod;
+        }
+      };
+      var setupTypeInfo = function(test, maskPattern) {
+        var data = _errorCorrectionLevel << 3 | maskPattern;
+        var bits = QRUtil.getBCHTypeInfo(data);
+        for (var i = 0; i < 15; i += 1) {
+          var mod = !test && (bits >> i & 1) == 1;
+          if (i < 6) {
+            _modules[i][8] = mod;
+          } else if (i < 8) {
+            _modules[i + 1][8] = mod;
+          } else {
+            _modules[_moduleCount - 15 + i][8] = mod;
+          }
+        }
+        for (var i = 0; i < 15; i += 1) {
+          var mod = !test && (bits >> i & 1) == 1;
+          if (i < 8) {
+            _modules[8][_moduleCount - i - 1] = mod;
+          } else if (i < 9) {
+            _modules[8][15 - i - 1 + 1] = mod;
+          } else {
+            _modules[8][15 - i - 1] = mod;
+          }
+        }
+        _modules[_moduleCount - 8][8] = !test;
+      };
+      var mapData = function(data, maskPattern) {
+        var inc = -1;
+        var row = _moduleCount - 1;
+        var bitIndex = 7;
+        var byteIndex = 0;
+        var maskFunc = QRUtil.getMaskFunction(maskPattern);
+        for (var col = _moduleCount - 1; col > 0; col -= 2) {
+          if (col == 6) col -= 1;
+          while (true) {
+            for (var c = 0; c < 2; c += 1) {
+              if (_modules[row][col - c] == null) {
+                var dark = false;
+                if (byteIndex < data.length) {
+                  dark = (data[byteIndex] >>> bitIndex & 1) == 1;
+                }
+                var mask = maskFunc(row, col - c);
+                if (mask) {
+                  dark = !dark;
+                }
+                _modules[row][col - c] = dark;
+                bitIndex -= 1;
+                if (bitIndex == -1) {
+                  byteIndex += 1;
+                  bitIndex = 7;
+                }
+              }
+            }
+            row += inc;
+            if (row < 0 || _moduleCount <= row) {
+              row -= inc;
+              inc = -inc;
+              break;
+            }
+          }
+        }
+      };
+      var createBytes = function(buffer, rsBlocks) {
+        var offset = 0;
+        var maxDcCount = 0;
+        var maxEcCount = 0;
+        var dcdata = new Array(rsBlocks.length);
+        var ecdata = new Array(rsBlocks.length);
+        for (var r = 0; r < rsBlocks.length; r += 1) {
+          var dcCount = rsBlocks[r].dataCount;
+          var ecCount = rsBlocks[r].totalCount - dcCount;
+          maxDcCount = Math.max(maxDcCount, dcCount);
+          maxEcCount = Math.max(maxEcCount, ecCount);
+          dcdata[r] = new Array(dcCount);
+          for (var i = 0; i < dcdata[r].length; i += 1) {
+            dcdata[r][i] = 255 & buffer.getBuffer()[i + offset];
+          }
+          offset += dcCount;
+          var rsPoly = QRUtil.getErrorCorrectPolynomial(ecCount);
+          var rawPoly = qrPolynomial(dcdata[r], rsPoly.getLength() - 1);
+          var modPoly = rawPoly.mod(rsPoly);
+          ecdata[r] = new Array(rsPoly.getLength() - 1);
+          for (var i = 0; i < ecdata[r].length; i += 1) {
+            var modIndex = i + modPoly.getLength() - ecdata[r].length;
+            ecdata[r][i] = modIndex >= 0 ? modPoly.getAt(modIndex) : 0;
+          }
+        }
+        var totalCodeCount = 0;
+        for (var i = 0; i < rsBlocks.length; i += 1) {
+          totalCodeCount += rsBlocks[i].totalCount;
+        }
+        var data = new Array(totalCodeCount);
+        var index = 0;
+        for (var i = 0; i < maxDcCount; i += 1) {
+          for (var r = 0; r < rsBlocks.length; r += 1) {
+            if (i < dcdata[r].length) {
+              data[index] = dcdata[r][i];
+              index += 1;
+            }
+          }
+        }
+        for (var i = 0; i < maxEcCount; i += 1) {
+          for (var r = 0; r < rsBlocks.length; r += 1) {
+            if (i < ecdata[r].length) {
+              data[index] = ecdata[r][i];
+              index += 1;
+            }
+          }
+        }
+        return data;
+      };
+      var createData = function(typeNumber2, errorCorrectionLevel2, dataList) {
+        var rsBlocks = QRRSBlock.getRSBlocks(typeNumber2, errorCorrectionLevel2);
+        var buffer = qrBitBuffer();
+        for (var i = 0; i < dataList.length; i += 1) {
+          var data = dataList[i];
+          buffer.put(data.getMode(), 4);
+          buffer.put(data.getLength(), QRUtil.getLengthInBits(data.getMode(), typeNumber2));
+          data.write(buffer);
+        }
+        var totalDataCount = 0;
+        for (var i = 0; i < rsBlocks.length; i += 1) {
+          totalDataCount += rsBlocks[i].dataCount;
+        }
+        if (buffer.getLengthInBits() > totalDataCount * 8) {
+          throw "code length overflow. (" + buffer.getLengthInBits() + ">" + totalDataCount * 8 + ")";
+        }
+        if (buffer.getLengthInBits() + 4 <= totalDataCount * 8) {
+          buffer.put(0, 4);
+        }
+        while (buffer.getLengthInBits() % 8 != 0) {
+          buffer.putBit(false);
+        }
+        while (true) {
+          if (buffer.getLengthInBits() >= totalDataCount * 8) {
+            break;
+          }
+          buffer.put(PAD0, 8);
+          if (buffer.getLengthInBits() >= totalDataCount * 8) {
+            break;
+          }
+          buffer.put(PAD1, 8);
+        }
+        return createBytes(buffer, rsBlocks);
+      };
+      _this.addData = function(data, mode) {
+        mode = mode || "Byte";
+        var newData = null;
+        switch (mode) {
+          case "Numeric":
+            newData = qrNumber(data);
+            break;
+          case "Alphanumeric":
+            newData = qrAlphaNum(data);
+            break;
+          case "Byte":
+            newData = qr8BitByte(data);
+            break;
+          case "Kanji":
+            newData = qrKanji(data);
+            break;
+          default:
+            throw "mode:" + mode;
+        }
+        _dataList.push(newData);
+        _dataCache = null;
+      };
+      _this.isDark = function(row, col) {
+        if (row < 0 || _moduleCount <= row || col < 0 || _moduleCount <= col) {
+          throw row + "," + col;
+        }
+        return _modules[row][col];
+      };
+      _this.getModuleCount = function() {
+        return _moduleCount;
+      };
+      _this.make = function() {
+        if (_typeNumber < 1) {
+          var typeNumber2 = 1;
+          for (; typeNumber2 < 40; typeNumber2++) {
+            var rsBlocks = QRRSBlock.getRSBlocks(typeNumber2, _errorCorrectionLevel);
+            var buffer = qrBitBuffer();
+            for (var i = 0; i < _dataList.length; i++) {
+              var data = _dataList[i];
+              buffer.put(data.getMode(), 4);
+              buffer.put(data.getLength(), QRUtil.getLengthInBits(data.getMode(), typeNumber2));
+              data.write(buffer);
+            }
+            var totalDataCount = 0;
+            for (var i = 0; i < rsBlocks.length; i++) {
+              totalDataCount += rsBlocks[i].dataCount;
+            }
+            if (buffer.getLengthInBits() <= totalDataCount * 8) {
+              break;
+            }
+          }
+          _typeNumber = typeNumber2;
+        }
+        makeImpl(false, getBestMaskPattern());
+      };
+      _this.createTableTag = function(cellSize, margin) {
+        cellSize = cellSize || 2;
+        margin = typeof margin == "undefined" ? cellSize * 4 : margin;
+        var qrHtml = "";
+        qrHtml += '<table style="';
+        qrHtml += " border-width: 0px; border-style: none;";
+        qrHtml += " border-collapse: collapse;";
+        qrHtml += " padding: 0px; margin: " + margin + "px;";
+        qrHtml += '">';
+        qrHtml += "<tbody>";
+        for (var r = 0; r < _this.getModuleCount(); r += 1) {
+          qrHtml += "<tr>";
+          for (var c = 0; c < _this.getModuleCount(); c += 1) {
+            qrHtml += '<td style="';
+            qrHtml += " border-width: 0px; border-style: none;";
+            qrHtml += " border-collapse: collapse;";
+            qrHtml += " padding: 0px; margin: 0px;";
+            qrHtml += " width: " + cellSize + "px;";
+            qrHtml += " height: " + cellSize + "px;";
+            qrHtml += " background-color: ";
+            qrHtml += _this.isDark(r, c) ? "#000000" : "#ffffff";
+            qrHtml += ";";
+            qrHtml += '"/>';
+          }
+          qrHtml += "</tr>";
+        }
+        qrHtml += "</tbody>";
+        qrHtml += "</table>";
+        return qrHtml;
+      };
+      _this.createSvgTag = function(cellSize, margin, alt, title) {
+        var opts = {};
+        if (typeof arguments[0] == "object") {
+          opts = arguments[0];
+          cellSize = opts.cellSize;
+          margin = opts.margin;
+          alt = opts.alt;
+          title = opts.title;
+        }
+        cellSize = cellSize || 2;
+        margin = typeof margin == "undefined" ? cellSize * 4 : margin;
+        alt = typeof alt === "string" ? { text: alt } : alt || {};
+        alt.text = alt.text || null;
+        alt.id = alt.text ? alt.id || "qrcode-description" : null;
+        title = typeof title === "string" ? { text: title } : title || {};
+        title.text = title.text || null;
+        title.id = title.text ? title.id || "qrcode-title" : null;
+        var size = _this.getModuleCount() * cellSize + margin * 2;
+        var c, mc, r, mr, qrSvg = "", rect;
+        rect = "l" + cellSize + ",0 0," + cellSize + " -" + cellSize + ",0 0,-" + cellSize + "z ";
+        qrSvg += '<svg version="1.1" xmlns="http://www.w3.org/2000/svg"';
+        qrSvg += !opts.scalable ? ' width="' + size + 'px" height="' + size + 'px"' : "";
+        qrSvg += ' viewBox="0 0 ' + size + " " + size + '" ';
+        qrSvg += ' preserveAspectRatio="xMinYMin meet"';
+        qrSvg += title.text || alt.text ? ' role="img" aria-labelledby="' + escapeXml([title.id, alt.id].join(" ").trim()) + '"' : "";
+        qrSvg += ">";
+        qrSvg += title.text ? '<title id="' + escapeXml(title.id) + '">' + escapeXml(title.text) + "</title>" : "";
+        qrSvg += alt.text ? '<description id="' + escapeXml(alt.id) + '">' + escapeXml(alt.text) + "</description>" : "";
+        qrSvg += '<rect width="100%" height="100%" fill="white" cx="0" cy="0"/>';
+        qrSvg += '<path d="';
+        for (r = 0; r < _this.getModuleCount(); r += 1) {
+          mr = r * cellSize + margin;
+          for (c = 0; c < _this.getModuleCount(); c += 1) {
+            if (_this.isDark(r, c)) {
+              mc = c * cellSize + margin;
+              qrSvg += "M" + mc + "," + mr + rect;
+            }
+          }
+        }
+        qrSvg += '" stroke="transparent" fill="black"/>';
+        qrSvg += "</svg>";
+        return qrSvg;
+      };
+      _this.createDataURL = function(cellSize, margin) {
+        cellSize = cellSize || 2;
+        margin = typeof margin == "undefined" ? cellSize * 4 : margin;
+        var size = _this.getModuleCount() * cellSize + margin * 2;
+        var min = margin;
+        var max = size - margin;
+        return createDataURL(size, size, function(x, y) {
+          if (min <= x && x < max && min <= y && y < max) {
+            var c = Math.floor((x - min) / cellSize);
+            var r = Math.floor((y - min) / cellSize);
+            return _this.isDark(r, c) ? 0 : 1;
+          } else {
+            return 1;
+          }
+        });
+      };
+      _this.createImgTag = function(cellSize, margin, alt) {
+        cellSize = cellSize || 2;
+        margin = typeof margin == "undefined" ? cellSize * 4 : margin;
+        var size = _this.getModuleCount() * cellSize + margin * 2;
+        var img = "";
+        img += "<img";
+        img += ' src="';
+        img += _this.createDataURL(cellSize, margin);
+        img += '"';
+        img += ' width="';
+        img += size;
+        img += '"';
+        img += ' height="';
+        img += size;
+        img += '"';
+        if (alt) {
+          img += ' alt="';
+          img += escapeXml(alt);
+          img += '"';
+        }
+        img += "/>";
+        return img;
+      };
+      var escapeXml = function(s) {
+        var escaped = "";
+        for (var i = 0; i < s.length; i += 1) {
+          var c = s.charAt(i);
+          switch (c) {
+            case "<":
+              escaped += "&lt;";
+              break;
+            case ">":
+              escaped += "&gt;";
+              break;
+            case "&":
+              escaped += "&amp;";
+              break;
+            case '"':
+              escaped += "&quot;";
+              break;
+            default:
+              escaped += c;
+              break;
+          }
+        }
+        return escaped;
+      };
+      var _createHalfASCII = function(margin) {
+        var cellSize = 1;
+        margin = typeof margin == "undefined" ? cellSize * 2 : margin;
+        var size = _this.getModuleCount() * cellSize + margin * 2;
+        var min = margin;
+        var max = size - margin;
+        var y, x, r1, r2, p;
+        var blocks = {
+          "\u2588\u2588": "\u2588",
+          "\u2588 ": "\u2580",
+          " \u2588": "\u2584",
+          "  ": " "
+        };
+        var blocksLastLineNoMargin = {
+          "\u2588\u2588": "\u2580",
+          "\u2588 ": "\u2580",
+          " \u2588": " ",
+          "  ": " "
+        };
+        var ascii = "";
+        for (y = 0; y < size; y += 2) {
+          r1 = Math.floor((y - min) / cellSize);
+          r2 = Math.floor((y + 1 - min) / cellSize);
+          for (x = 0; x < size; x += 1) {
+            p = "\u2588";
+            if (min <= x && x < max && min <= y && y < max && _this.isDark(r1, Math.floor((x - min) / cellSize))) {
+              p = " ";
+            }
+            if (min <= x && x < max && min <= y + 1 && y + 1 < max && _this.isDark(r2, Math.floor((x - min) / cellSize))) {
+              p += " ";
+            } else {
+              p += "\u2588";
+            }
+            ascii += margin < 1 && y + 1 >= max ? blocksLastLineNoMargin[p] : blocks[p];
+          }
+          ascii += "\n";
+        }
+        if (size % 2 && margin > 0) {
+          return ascii.substring(0, ascii.length - size - 1) + Array(size + 1).join("\u2580");
+        }
+        return ascii.substring(0, ascii.length - 1);
+      };
+      _this.createASCII = function(cellSize, margin) {
+        cellSize = cellSize || 1;
+        if (cellSize < 2) {
+          return _createHalfASCII(margin);
+        }
+        cellSize -= 1;
+        margin = typeof margin == "undefined" ? cellSize * 2 : margin;
+        var size = _this.getModuleCount() * cellSize + margin * 2;
+        var min = margin;
+        var max = size - margin;
+        var y, x, r, p;
+        var white = Array(cellSize + 1).join("\u2588\u2588");
+        var black = Array(cellSize + 1).join("  ");
+        var ascii = "";
+        var line = "";
+        for (y = 0; y < size; y += 1) {
+          r = Math.floor((y - min) / cellSize);
+          line = "";
+          for (x = 0; x < size; x += 1) {
+            p = 1;
+            if (min <= x && x < max && min <= y && y < max && _this.isDark(r, Math.floor((x - min) / cellSize))) {
+              p = 0;
+            }
+            line += p ? white : black;
+          }
+          for (r = 0; r < cellSize; r += 1) {
+            ascii += line + "\n";
+          }
+        }
+        return ascii.substring(0, ascii.length - 1);
+      };
+      _this.renderTo2dContext = function(context, cellSize) {
+        cellSize = cellSize || 2;
+        var length = _this.getModuleCount();
+        for (var row = 0; row < length; row++) {
+          for (var col = 0; col < length; col++) {
+            context.fillStyle = _this.isDark(row, col) ? "black" : "white";
+            context.fillRect(col * cellSize, row * cellSize, cellSize, cellSize);
+          }
+        }
+      };
+      return _this;
+    };
+    qrcode2.stringToBytesFuncs = {
+      "default": function(s) {
+        var bytes = [];
+        for (var i = 0; i < s.length; i += 1) {
+          var c = s.charCodeAt(i);
+          bytes.push(c & 255);
+        }
+        return bytes;
+      }
+    };
+    qrcode2.stringToBytes = qrcode2.stringToBytesFuncs["default"];
+    qrcode2.createStringToBytes = function(unicodeData, numChars) {
+      var unicodeMap = (function() {
+        var bin = base64DecodeInputStream(unicodeData);
+        var read = function() {
+          var b = bin.read();
+          if (b == -1) throw "eof";
+          return b;
+        };
+        var count = 0;
+        var unicodeMap2 = {};
+        while (true) {
+          var b0 = bin.read();
+          if (b0 == -1) break;
+          var b1 = read();
+          var b2 = read();
+          var b3 = read();
+          var k = String.fromCharCode(b0 << 8 | b1);
+          var v = b2 << 8 | b3;
+          unicodeMap2[k] = v;
+          count += 1;
+        }
+        if (count != numChars) {
+          throw count + " != " + numChars;
+        }
+        return unicodeMap2;
+      })();
+      var unknownChar = "?".charCodeAt(0);
+      return function(s) {
+        var bytes = [];
+        for (var i = 0; i < s.length; i += 1) {
+          var c = s.charCodeAt(i);
+          if (c < 128) {
+            bytes.push(c);
+          } else {
+            var b = unicodeMap[s.charAt(i)];
+            if (typeof b == "number") {
+              if ((b & 255) == b) {
+                bytes.push(b);
+              } else {
+                bytes.push(b >>> 8);
+                bytes.push(b & 255);
+              }
+            } else {
+              bytes.push(unknownChar);
+            }
+          }
+        }
+        return bytes;
+      };
+    };
+    var QRMode = {
+      MODE_NUMBER: 1 << 0,
+      MODE_ALPHA_NUM: 1 << 1,
+      MODE_8BIT_BYTE: 1 << 2,
+      MODE_KANJI: 1 << 3
+    };
+    var QRErrorCorrectionLevel = {
+      L: 1,
+      M: 0,
+      Q: 3,
+      H: 2
+    };
+    var QRMaskPattern = {
+      PATTERN000: 0,
+      PATTERN001: 1,
+      PATTERN010: 2,
+      PATTERN011: 3,
+      PATTERN100: 4,
+      PATTERN101: 5,
+      PATTERN110: 6,
+      PATTERN111: 7
+    };
+    var QRUtil = (function() {
+      var PATTERN_POSITION_TABLE = [
+        [],
+        [6, 18],
+        [6, 22],
+        [6, 26],
+        [6, 30],
+        [6, 34],
+        [6, 22, 38],
+        [6, 24, 42],
+        [6, 26, 46],
+        [6, 28, 50],
+        [6, 30, 54],
+        [6, 32, 58],
+        [6, 34, 62],
+        [6, 26, 46, 66],
+        [6, 26, 48, 70],
+        [6, 26, 50, 74],
+        [6, 30, 54, 78],
+        [6, 30, 56, 82],
+        [6, 30, 58, 86],
+        [6, 34, 62, 90],
+        [6, 28, 50, 72, 94],
+        [6, 26, 50, 74, 98],
+        [6, 30, 54, 78, 102],
+        [6, 28, 54, 80, 106],
+        [6, 32, 58, 84, 110],
+        [6, 30, 58, 86, 114],
+        [6, 34, 62, 90, 118],
+        [6, 26, 50, 74, 98, 122],
+        [6, 30, 54, 78, 102, 126],
+        [6, 26, 52, 78, 104, 130],
+        [6, 30, 56, 82, 108, 134],
+        [6, 34, 60, 86, 112, 138],
+        [6, 30, 58, 86, 114, 142],
+        [6, 34, 62, 90, 118, 146],
+        [6, 30, 54, 78, 102, 126, 150],
+        [6, 24, 50, 76, 102, 128, 154],
+        [6, 28, 54, 80, 106, 132, 158],
+        [6, 32, 58, 84, 110, 136, 162],
+        [6, 26, 54, 82, 110, 138, 166],
+        [6, 30, 58, 86, 114, 142, 170]
+      ];
+      var G15 = 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0;
+      var G18 = 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0;
+      var G15_MASK = 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1;
+      var _this = {};
+      var getBCHDigit = function(data) {
+        var digit = 0;
+        while (data != 0) {
+          digit += 1;
+          data >>>= 1;
+        }
+        return digit;
+      };
+      _this.getBCHTypeInfo = function(data) {
+        var d = data << 10;
+        while (getBCHDigit(d) - getBCHDigit(G15) >= 0) {
+          d ^= G15 << getBCHDigit(d) - getBCHDigit(G15);
+        }
+        return (data << 10 | d) ^ G15_MASK;
+      };
+      _this.getBCHTypeNumber = function(data) {
+        var d = data << 12;
+        while (getBCHDigit(d) - getBCHDigit(G18) >= 0) {
+          d ^= G18 << getBCHDigit(d) - getBCHDigit(G18);
+        }
+        return data << 12 | d;
+      };
+      _this.getPatternPosition = function(typeNumber) {
+        return PATTERN_POSITION_TABLE[typeNumber - 1];
+      };
+      _this.getMaskFunction = function(maskPattern) {
+        switch (maskPattern) {
+          case QRMaskPattern.PATTERN000:
+            return function(i, j) {
+              return (i + j) % 2 == 0;
+            };
+          case QRMaskPattern.PATTERN001:
+            return function(i, j) {
+              return i % 2 == 0;
+            };
+          case QRMaskPattern.PATTERN010:
+            return function(i, j) {
+              return j % 3 == 0;
+            };
+          case QRMaskPattern.PATTERN011:
+            return function(i, j) {
+              return (i + j) % 3 == 0;
+            };
+          case QRMaskPattern.PATTERN100:
+            return function(i, j) {
+              return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 == 0;
+            };
+          case QRMaskPattern.PATTERN101:
+            return function(i, j) {
+              return i * j % 2 + i * j % 3 == 0;
+            };
+          case QRMaskPattern.PATTERN110:
+            return function(i, j) {
+              return (i * j % 2 + i * j % 3) % 2 == 0;
+            };
+          case QRMaskPattern.PATTERN111:
+            return function(i, j) {
+              return (i * j % 3 + (i + j) % 2) % 2 == 0;
+            };
+          default:
+            throw "bad maskPattern:" + maskPattern;
+        }
+      };
+      _this.getErrorCorrectPolynomial = function(errorCorrectLength) {
+        var a = qrPolynomial([1], 0);
+        for (var i = 0; i < errorCorrectLength; i += 1) {
+          a = a.multiply(qrPolynomial([1, QRMath.gexp(i)], 0));
+        }
+        return a;
+      };
+      _this.getLengthInBits = function(mode, type) {
+        if (1 <= type && type < 10) {
+          switch (mode) {
+            case QRMode.MODE_NUMBER:
+              return 10;
+            case QRMode.MODE_ALPHA_NUM:
+              return 9;
+            case QRMode.MODE_8BIT_BYTE:
+              return 8;
+            case QRMode.MODE_KANJI:
+              return 8;
+            default:
+              throw "mode:" + mode;
+          }
+        } else if (type < 27) {
+          switch (mode) {
+            case QRMode.MODE_NUMBER:
+              return 12;
+            case QRMode.MODE_ALPHA_NUM:
+              return 11;
+            case QRMode.MODE_8BIT_BYTE:
+              return 16;
+            case QRMode.MODE_KANJI:
+              return 10;
+            default:
+              throw "mode:" + mode;
+          }
+        } else if (type < 41) {
+          switch (mode) {
+            case QRMode.MODE_NUMBER:
+              return 14;
+            case QRMode.MODE_ALPHA_NUM:
+              return 13;
+            case QRMode.MODE_8BIT_BYTE:
+              return 16;
+            case QRMode.MODE_KANJI:
+              return 12;
+            default:
+              throw "mode:" + mode;
+          }
+        } else {
+          throw "type:" + type;
+        }
+      };
+      _this.getLostPoint = function(qrcode3) {
+        var moduleCount = qrcode3.getModuleCount();
+        var lostPoint = 0;
+        for (var row = 0; row < moduleCount; row += 1) {
+          for (var col = 0; col < moduleCount; col += 1) {
+            var sameCount = 0;
+            var dark = qrcode3.isDark(row, col);
+            for (var r = -1; r <= 1; r += 1) {
+              if (row + r < 0 || moduleCount <= row + r) {
+                continue;
+              }
+              for (var c = -1; c <= 1; c += 1) {
+                if (col + c < 0 || moduleCount <= col + c) {
+                  continue;
+                }
+                if (r == 0 && c == 0) {
+                  continue;
+                }
+                if (dark == qrcode3.isDark(row + r, col + c)) {
+                  sameCount += 1;
+                }
+              }
+            }
+            if (sameCount > 5) {
+              lostPoint += 3 + sameCount - 5;
+            }
+          }
+        }
+        ;
+        for (var row = 0; row < moduleCount - 1; row += 1) {
+          for (var col = 0; col < moduleCount - 1; col += 1) {
+            var count = 0;
+            if (qrcode3.isDark(row, col)) count += 1;
+            if (qrcode3.isDark(row + 1, col)) count += 1;
+            if (qrcode3.isDark(row, col + 1)) count += 1;
+            if (qrcode3.isDark(row + 1, col + 1)) count += 1;
+            if (count == 0 || count == 4) {
+              lostPoint += 3;
+            }
+          }
+        }
+        for (var row = 0; row < moduleCount; row += 1) {
+          for (var col = 0; col < moduleCount - 6; col += 1) {
+            if (qrcode3.isDark(row, col) && !qrcode3.isDark(row, col + 1) && qrcode3.isDark(row, col + 2) && qrcode3.isDark(row, col + 3) && qrcode3.isDark(row, col + 4) && !qrcode3.isDark(row, col + 5) && qrcode3.isDark(row, col + 6)) {
+              lostPoint += 40;
+            }
+          }
+        }
+        for (var col = 0; col < moduleCount; col += 1) {
+          for (var row = 0; row < moduleCount - 6; row += 1) {
+            if (qrcode3.isDark(row, col) && !qrcode3.isDark(row + 1, col) && qrcode3.isDark(row + 2, col) && qrcode3.isDark(row + 3, col) && qrcode3.isDark(row + 4, col) && !qrcode3.isDark(row + 5, col) && qrcode3.isDark(row + 6, col)) {
+              lostPoint += 40;
+            }
+          }
+        }
+        var darkCount = 0;
+        for (var col = 0; col < moduleCount; col += 1) {
+          for (var row = 0; row < moduleCount; row += 1) {
+            if (qrcode3.isDark(row, col)) {
+              darkCount += 1;
+            }
+          }
+        }
+        var ratio = Math.abs(100 * darkCount / moduleCount / moduleCount - 50) / 5;
+        lostPoint += ratio * 10;
+        return lostPoint;
+      };
+      return _this;
+    })();
+    var QRMath = (function() {
+      var EXP_TABLE = new Array(256);
+      var LOG_TABLE = new Array(256);
+      for (var i = 0; i < 8; i += 1) {
+        EXP_TABLE[i] = 1 << i;
+      }
+      for (var i = 8; i < 256; i += 1) {
+        EXP_TABLE[i] = EXP_TABLE[i - 4] ^ EXP_TABLE[i - 5] ^ EXP_TABLE[i - 6] ^ EXP_TABLE[i - 8];
+      }
+      for (var i = 0; i < 255; i += 1) {
+        LOG_TABLE[EXP_TABLE[i]] = i;
+      }
+      var _this = {};
+      _this.glog = function(n) {
+        if (n < 1) {
+          throw "glog(" + n + ")";
+        }
+        return LOG_TABLE[n];
+      };
+      _this.gexp = function(n) {
+        while (n < 0) {
+          n += 255;
+        }
+        while (n >= 256) {
+          n -= 255;
+        }
+        return EXP_TABLE[n];
+      };
+      return _this;
+    })();
+    function qrPolynomial(num, shift) {
+      if (typeof num.length == "undefined") {
+        throw num.length + "/" + shift;
+      }
+      var _num = (function() {
+        var offset = 0;
+        while (offset < num.length && num[offset] == 0) {
+          offset += 1;
+        }
+        var _num2 = new Array(num.length - offset + shift);
+        for (var i = 0; i < num.length - offset; i += 1) {
+          _num2[i] = num[i + offset];
+        }
+        return _num2;
+      })();
+      var _this = {};
+      _this.getAt = function(index) {
+        return _num[index];
+      };
+      _this.getLength = function() {
+        return _num.length;
+      };
+      _this.multiply = function(e) {
+        var num2 = new Array(_this.getLength() + e.getLength() - 1);
+        for (var i = 0; i < _this.getLength(); i += 1) {
+          for (var j = 0; j < e.getLength(); j += 1) {
+            num2[i + j] ^= QRMath.gexp(QRMath.glog(_this.getAt(i)) + QRMath.glog(e.getAt(j)));
+          }
+        }
+        return qrPolynomial(num2, 0);
+      };
+      _this.mod = function(e) {
+        if (_this.getLength() - e.getLength() < 0) {
+          return _this;
+        }
+        var ratio = QRMath.glog(_this.getAt(0)) - QRMath.glog(e.getAt(0));
+        var num2 = new Array(_this.getLength());
+        for (var i = 0; i < _this.getLength(); i += 1) {
+          num2[i] = _this.getAt(i);
+        }
+        for (var i = 0; i < e.getLength(); i += 1) {
+          num2[i] ^= QRMath.gexp(QRMath.glog(e.getAt(i)) + ratio);
+        }
+        return qrPolynomial(num2, 0).mod(e);
+      };
+      return _this;
+    }
+    ;
+    var QRRSBlock = (function() {
+      var RS_BLOCK_TABLE = [
+        // L
+        // M
+        // Q
+        // H
+        // 1
+        [1, 26, 19],
+        [1, 26, 16],
+        [1, 26, 13],
+        [1, 26, 9],
+        // 2
+        [1, 44, 34],
+        [1, 44, 28],
+        [1, 44, 22],
+        [1, 44, 16],
+        // 3
+        [1, 70, 55],
+        [1, 70, 44],
+        [2, 35, 17],
+        [2, 35, 13],
+        // 4
+        [1, 100, 80],
+        [2, 50, 32],
+        [2, 50, 24],
+        [4, 25, 9],
+        // 5
+        [1, 134, 108],
+        [2, 67, 43],
+        [2, 33, 15, 2, 34, 16],
+        [2, 33, 11, 2, 34, 12],
+        // 6
+        [2, 86, 68],
+        [4, 43, 27],
+        [4, 43, 19],
+        [4, 43, 15],
+        // 7
+        [2, 98, 78],
+        [4, 49, 31],
+        [2, 32, 14, 4, 33, 15],
+        [4, 39, 13, 1, 40, 14],
+        // 8
+        [2, 121, 97],
+        [2, 60, 38, 2, 61, 39],
+        [4, 40, 18, 2, 41, 19],
+        [4, 40, 14, 2, 41, 15],
+        // 9
+        [2, 146, 116],
+        [3, 58, 36, 2, 59, 37],
+        [4, 36, 16, 4, 37, 17],
+        [4, 36, 12, 4, 37, 13],
+        // 10
+        [2, 86, 68, 2, 87, 69],
+        [4, 69, 43, 1, 70, 44],
+        [6, 43, 19, 2, 44, 20],
+        [6, 43, 15, 2, 44, 16],
+        // 11
+        [4, 101, 81],
+        [1, 80, 50, 4, 81, 51],
+        [4, 50, 22, 4, 51, 23],
+        [3, 36, 12, 8, 37, 13],
+        // 12
+        [2, 116, 92, 2, 117, 93],
+        [6, 58, 36, 2, 59, 37],
+        [4, 46, 20, 6, 47, 21],
+        [7, 42, 14, 4, 43, 15],
+        // 13
+        [4, 133, 107],
+        [8, 59, 37, 1, 60, 38],
+        [8, 44, 20, 4, 45, 21],
+        [12, 33, 11, 4, 34, 12],
+        // 14
+        [3, 145, 115, 1, 146, 116],
+        [4, 64, 40, 5, 65, 41],
+        [11, 36, 16, 5, 37, 17],
+        [11, 36, 12, 5, 37, 13],
+        // 15
+        [5, 109, 87, 1, 110, 88],
+        [5, 65, 41, 5, 66, 42],
+        [5, 54, 24, 7, 55, 25],
+        [11, 36, 12, 7, 37, 13],
+        // 16
+        [5, 122, 98, 1, 123, 99],
+        [7, 73, 45, 3, 74, 46],
+        [15, 43, 19, 2, 44, 20],
+        [3, 45, 15, 13, 46, 16],
+        // 17
+        [1, 135, 107, 5, 136, 108],
+        [10, 74, 46, 1, 75, 47],
+        [1, 50, 22, 15, 51, 23],
+        [2, 42, 14, 17, 43, 15],
+        // 18
+        [5, 150, 120, 1, 151, 121],
+        [9, 69, 43, 4, 70, 44],
+        [17, 50, 22, 1, 51, 23],
+        [2, 42, 14, 19, 43, 15],
+        // 19
+        [3, 141, 113, 4, 142, 114],
+        [3, 70, 44, 11, 71, 45],
+        [17, 47, 21, 4, 48, 22],
+        [9, 39, 13, 16, 40, 14],
+        // 20
+        [3, 135, 107, 5, 136, 108],
+        [3, 67, 41, 13, 68, 42],
+        [15, 54, 24, 5, 55, 25],
+        [15, 43, 15, 10, 44, 16],
+        // 21
+        [4, 144, 116, 4, 145, 117],
+        [17, 68, 42],
+        [17, 50, 22, 6, 51, 23],
+        [19, 46, 16, 6, 47, 17],
+        // 22
+        [2, 139, 111, 7, 140, 112],
+        [17, 74, 46],
+        [7, 54, 24, 16, 55, 25],
+        [34, 37, 13],
+        // 23
+        [4, 151, 121, 5, 152, 122],
+        [4, 75, 47, 14, 76, 48],
+        [11, 54, 24, 14, 55, 25],
+        [16, 45, 15, 14, 46, 16],
+        // 24
+        [6, 147, 117, 4, 148, 118],
+        [6, 73, 45, 14, 74, 46],
+        [11, 54, 24, 16, 55, 25],
+        [30, 46, 16, 2, 47, 17],
+        // 25
+        [8, 132, 106, 4, 133, 107],
+        [8, 75, 47, 13, 76, 48],
+        [7, 54, 24, 22, 55, 25],
+        [22, 45, 15, 13, 46, 16],
+        // 26
+        [10, 142, 114, 2, 143, 115],
+        [19, 74, 46, 4, 75, 47],
+        [28, 50, 22, 6, 51, 23],
+        [33, 46, 16, 4, 47, 17],
+        // 27
+        [8, 152, 122, 4, 153, 123],
+        [22, 73, 45, 3, 74, 46],
+        [8, 53, 23, 26, 54, 24],
+        [12, 45, 15, 28, 46, 16],
+        // 28
+        [3, 147, 117, 10, 148, 118],
+        [3, 73, 45, 23, 74, 46],
+        [4, 54, 24, 31, 55, 25],
+        [11, 45, 15, 31, 46, 16],
+        // 29
+        [7, 146, 116, 7, 147, 117],
+        [21, 73, 45, 7, 74, 46],
+        [1, 53, 23, 37, 54, 24],
+        [19, 45, 15, 26, 46, 16],
+        // 30
+        [5, 145, 115, 10, 146, 116],
+        [19, 75, 47, 10, 76, 48],
+        [15, 54, 24, 25, 55, 25],
+        [23, 45, 15, 25, 46, 16],
+        // 31
+        [13, 145, 115, 3, 146, 116],
+        [2, 74, 46, 29, 75, 47],
+        [42, 54, 24, 1, 55, 25],
+        [23, 45, 15, 28, 46, 16],
+        // 32
+        [17, 145, 115],
+        [10, 74, 46, 23, 75, 47],
+        [10, 54, 24, 35, 55, 25],
+        [19, 45, 15, 35, 46, 16],
+        // 33
+        [17, 145, 115, 1, 146, 116],
+        [14, 74, 46, 21, 75, 47],
+        [29, 54, 24, 19, 55, 25],
+        [11, 45, 15, 46, 46, 16],
+        // 34
+        [13, 145, 115, 6, 146, 116],
+        [14, 74, 46, 23, 75, 47],
+        [44, 54, 24, 7, 55, 25],
+        [59, 46, 16, 1, 47, 17],
+        // 35
+        [12, 151, 121, 7, 152, 122],
+        [12, 75, 47, 26, 76, 48],
+        [39, 54, 24, 14, 55, 25],
+        [22, 45, 15, 41, 46, 16],
+        // 36
+        [6, 151, 121, 14, 152, 122],
+        [6, 75, 47, 34, 76, 48],
+        [46, 54, 24, 10, 55, 25],
+        [2, 45, 15, 64, 46, 16],
+        // 37
+        [17, 152, 122, 4, 153, 123],
+        [29, 74, 46, 14, 75, 47],
+        [49, 54, 24, 10, 55, 25],
+        [24, 45, 15, 46, 46, 16],
+        // 38
+        [4, 152, 122, 18, 153, 123],
+        [13, 74, 46, 32, 75, 47],
+        [48, 54, 24, 14, 55, 25],
+        [42, 45, 15, 32, 46, 16],
+        // 39
+        [20, 147, 117, 4, 148, 118],
+        [40, 75, 47, 7, 76, 48],
+        [43, 54, 24, 22, 55, 25],
+        [10, 45, 15, 67, 46, 16],
+        // 40
+        [19, 148, 118, 6, 149, 119],
+        [18, 75, 47, 31, 76, 48],
+        [34, 54, 24, 34, 55, 25],
+        [20, 45, 15, 61, 46, 16]
+      ];
+      var qrRSBlock = function(totalCount, dataCount) {
+        var _this2 = {};
+        _this2.totalCount = totalCount;
+        _this2.dataCount = dataCount;
+        return _this2;
+      };
+      var _this = {};
+      var getRsBlockTable = function(typeNumber, errorCorrectionLevel) {
+        switch (errorCorrectionLevel) {
+          case QRErrorCorrectionLevel.L:
+            return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 0];
+          case QRErrorCorrectionLevel.M:
+            return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 1];
+          case QRErrorCorrectionLevel.Q:
+            return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 2];
+          case QRErrorCorrectionLevel.H:
+            return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 3];
+          default:
+            return void 0;
+        }
+      };
+      _this.getRSBlocks = function(typeNumber, errorCorrectionLevel) {
+        var rsBlock = getRsBlockTable(typeNumber, errorCorrectionLevel);
+        if (typeof rsBlock == "undefined") {
+          throw "bad rs block @ typeNumber:" + typeNumber + "/errorCorrectionLevel:" + errorCorrectionLevel;
+        }
+        var length = rsBlock.length / 3;
+        var list = [];
+        for (var i = 0; i < length; i += 1) {
+          var count = rsBlock[i * 3 + 0];
+          var totalCount = rsBlock[i * 3 + 1];
+          var dataCount = rsBlock[i * 3 + 2];
+          for (var j = 0; j < count; j += 1) {
+            list.push(qrRSBlock(totalCount, dataCount));
+          }
+        }
+        return list;
+      };
+      return _this;
+    })();
+    var qrBitBuffer = function() {
+      var _buffer = [];
+      var _length = 0;
+      var _this = {};
+      _this.getBuffer = function() {
+        return _buffer;
+      };
+      _this.getAt = function(index) {
+        var bufIndex = Math.floor(index / 8);
+        return (_buffer[bufIndex] >>> 7 - index % 8 & 1) == 1;
+      };
+      _this.put = function(num, length) {
+        for (var i = 0; i < length; i += 1) {
+          _this.putBit((num >>> length - i - 1 & 1) == 1);
+        }
+      };
+      _this.getLengthInBits = function() {
+        return _length;
+      };
+      _this.putBit = function(bit) {
+        var bufIndex = Math.floor(_length / 8);
+        if (_buffer.length <= bufIndex) {
+          _buffer.push(0);
+        }
+        if (bit) {
+          _buffer[bufIndex] |= 128 >>> _length % 8;
+        }
+        _length += 1;
+      };
+      return _this;
+    };
+    var qrNumber = function(data) {
+      var _mode = QRMode.MODE_NUMBER;
+      var _data = data;
+      var _this = {};
+      _this.getMode = function() {
+        return _mode;
+      };
+      _this.getLength = function(buffer) {
+        return _data.length;
+      };
+      _this.write = function(buffer) {
+        var data2 = _data;
+        var i = 0;
+        while (i + 2 < data2.length) {
+          buffer.put(strToNum(data2.substring(i, i + 3)), 10);
+          i += 3;
+        }
+        if (i < data2.length) {
+          if (data2.length - i == 1) {
+            buffer.put(strToNum(data2.substring(i, i + 1)), 4);
+          } else if (data2.length - i == 2) {
+            buffer.put(strToNum(data2.substring(i, i + 2)), 7);
+          }
+        }
+      };
+      var strToNum = function(s) {
+        var num = 0;
+        for (var i = 0; i < s.length; i += 1) {
+          num = num * 10 + chatToNum(s.charAt(i));
+        }
+        return num;
+      };
+      var chatToNum = function(c) {
+        if ("0" <= c && c <= "9") {
+          return c.charCodeAt(0) - "0".charCodeAt(0);
+        }
+        throw "illegal char :" + c;
+      };
+      return _this;
+    };
+    var qrAlphaNum = function(data) {
+      var _mode = QRMode.MODE_ALPHA_NUM;
+      var _data = data;
+      var _this = {};
+      _this.getMode = function() {
+        return _mode;
+      };
+      _this.getLength = function(buffer) {
+        return _data.length;
+      };
+      _this.write = function(buffer) {
+        var s = _data;
+        var i = 0;
+        while (i + 1 < s.length) {
+          buffer.put(
+            getCode(s.charAt(i)) * 45 + getCode(s.charAt(i + 1)),
+            11
+          );
+          i += 2;
+        }
+        if (i < s.length) {
+          buffer.put(getCode(s.charAt(i)), 6);
+        }
+      };
+      var getCode = function(c) {
+        if ("0" <= c && c <= "9") {
+          return c.charCodeAt(0) - "0".charCodeAt(0);
+        } else if ("A" <= c && c <= "Z") {
+          return c.charCodeAt(0) - "A".charCodeAt(0) + 10;
+        } else {
+          switch (c) {
+            case " ":
+              return 36;
+            case "$":
+              return 37;
+            case "%":
+              return 38;
+            case "*":
+              return 39;
+            case "+":
+              return 40;
+            case "-":
+              return 41;
+            case ".":
+              return 42;
+            case "/":
+              return 43;
+            case ":":
+              return 44;
+            default:
+              throw "illegal char :" + c;
+          }
+        }
+      };
+      return _this;
+    };
+    var qr8BitByte = function(data) {
+      var _mode = QRMode.MODE_8BIT_BYTE;
+      var _data = data;
+      var _bytes = qrcode2.stringToBytes(data);
+      var _this = {};
+      _this.getMode = function() {
+        return _mode;
+      };
+      _this.getLength = function(buffer) {
+        return _bytes.length;
+      };
+      _this.write = function(buffer) {
+        for (var i = 0; i < _bytes.length; i += 1) {
+          buffer.put(_bytes[i], 8);
+        }
+      };
+      return _this;
+    };
+    var qrKanji = function(data) {
+      var _mode = QRMode.MODE_KANJI;
+      var _data = data;
+      var stringToBytes = qrcode2.stringToBytesFuncs["SJIS"];
+      if (!stringToBytes) {
+        throw "sjis not supported.";
+      }
+      !(function(c, code) {
+        var test = stringToBytes(c);
+        if (test.length != 2 || (test[0] << 8 | test[1]) != code) {
+          throw "sjis not supported.";
+        }
+      })("\u53CB", 38726);
+      var _bytes = stringToBytes(data);
+      var _this = {};
+      _this.getMode = function() {
+        return _mode;
+      };
+      _this.getLength = function(buffer) {
+        return ~~(_bytes.length / 2);
+      };
+      _this.write = function(buffer) {
+        var data2 = _bytes;
+        var i = 0;
+        while (i + 1 < data2.length) {
+          var c = (255 & data2[i]) << 8 | 255 & data2[i + 1];
+          if (33088 <= c && c <= 40956) {
+            c -= 33088;
+          } else if (57408 <= c && c <= 60351) {
+            c -= 49472;
+          } else {
+            throw "illegal char at " + (i + 1) + "/" + c;
+          }
+          c = (c >>> 8 & 255) * 192 + (c & 255);
+          buffer.put(c, 13);
+          i += 2;
+        }
+        if (i < data2.length) {
+          throw "illegal char at " + (i + 1);
+        }
+      };
+      return _this;
+    };
+    var byteArrayOutputStream = function() {
+      var _bytes = [];
+      var _this = {};
+      _this.writeByte = function(b) {
+        _bytes.push(b & 255);
+      };
+      _this.writeShort = function(i) {
+        _this.writeByte(i);
+        _this.writeByte(i >>> 8);
+      };
+      _this.writeBytes = function(b, off, len) {
+        off = off || 0;
+        len = len || b.length;
+        for (var i = 0; i < len; i += 1) {
+          _this.writeByte(b[i + off]);
+        }
+      };
+      _this.writeString = function(s) {
+        for (var i = 0; i < s.length; i += 1) {
+          _this.writeByte(s.charCodeAt(i));
+        }
+      };
+      _this.toByteArray = function() {
+        return _bytes;
+      };
+      _this.toString = function() {
+        var s = "";
+        s += "[";
+        for (var i = 0; i < _bytes.length; i += 1) {
+          if (i > 0) {
+            s += ",";
+          }
+          s += _bytes[i];
+        }
+        s += "]";
+        return s;
+      };
+      return _this;
+    };
+    var base64EncodeOutputStream = function() {
+      var _buffer = 0;
+      var _buflen = 0;
+      var _length = 0;
+      var _base64 = "";
+      var _this = {};
+      var writeEncoded = function(b) {
+        _base64 += String.fromCharCode(encode(b & 63));
+      };
+      var encode = function(n) {
+        if (n < 0) {
+        } else if (n < 26) {
+          return 65 + n;
+        } else if (n < 52) {
+          return 97 + (n - 26);
+        } else if (n < 62) {
+          return 48 + (n - 52);
+        } else if (n == 62) {
+          return 43;
+        } else if (n == 63) {
+          return 47;
+        }
+        throw "n:" + n;
+      };
+      _this.writeByte = function(n) {
+        _buffer = _buffer << 8 | n & 255;
+        _buflen += 8;
+        _length += 1;
+        while (_buflen >= 6) {
+          writeEncoded(_buffer >>> _buflen - 6);
+          _buflen -= 6;
+        }
+      };
+      _this.flush = function() {
+        if (_buflen > 0) {
+          writeEncoded(_buffer << 6 - _buflen);
+          _buffer = 0;
+          _buflen = 0;
+        }
+        if (_length % 3 != 0) {
+          var padlen = 3 - _length % 3;
+          for (var i = 0; i < padlen; i += 1) {
+            _base64 += "=";
+          }
+        }
+      };
+      _this.toString = function() {
+        return _base64;
+      };
+      return _this;
+    };
+    var base64DecodeInputStream = function(str) {
+      var _str = str;
+      var _pos = 0;
+      var _buffer = 0;
+      var _buflen = 0;
+      var _this = {};
+      _this.read = function() {
+        while (_buflen < 8) {
+          if (_pos >= _str.length) {
+            if (_buflen == 0) {
+              return -1;
+            }
+            throw "unexpected end of file./" + _buflen;
+          }
+          var c = _str.charAt(_pos);
+          _pos += 1;
+          if (c == "=") {
+            _buflen = 0;
+            return -1;
+          } else if (c.match(/^\s$/)) {
+            continue;
+          }
+          _buffer = _buffer << 6 | decode(c.charCodeAt(0));
+          _buflen += 6;
+        }
+        var n = _buffer >>> _buflen - 8 & 255;
+        _buflen -= 8;
+        return n;
+      };
+      var decode = function(c) {
+        if (65 <= c && c <= 90) {
+          return c - 65;
+        } else if (97 <= c && c <= 122) {
+          return c - 97 + 26;
+        } else if (48 <= c && c <= 57) {
+          return c - 48 + 52;
+        } else if (c == 43) {
+          return 62;
+        } else if (c == 47) {
+          return 63;
+        } else {
+          throw "c:" + c;
+        }
+      };
+      return _this;
+    };
+    var gifImage = function(width, height) {
+      var _width = width;
+      var _height = height;
+      var _data = new Array(width * height);
+      var _this = {};
+      _this.setPixel = function(x, y, pixel) {
+        _data[y * _width + x] = pixel;
+      };
+      _this.write = function(out) {
+        out.writeString("GIF87a");
+        out.writeShort(_width);
+        out.writeShort(_height);
+        out.writeByte(128);
+        out.writeByte(0);
+        out.writeByte(0);
+        out.writeByte(0);
+        out.writeByte(0);
+        out.writeByte(0);
+        out.writeByte(255);
+        out.writeByte(255);
+        out.writeByte(255);
+        out.writeString(",");
+        out.writeShort(0);
+        out.writeShort(0);
+        out.writeShort(_width);
+        out.writeShort(_height);
+        out.writeByte(0);
+        var lzwMinCodeSize = 2;
+        var raster = getLZWRaster(lzwMinCodeSize);
+        out.writeByte(lzwMinCodeSize);
+        var offset = 0;
+        while (raster.length - offset > 255) {
+          out.writeByte(255);
+          out.writeBytes(raster, offset, 255);
+          offset += 255;
+        }
+        out.writeByte(raster.length - offset);
+        out.writeBytes(raster, offset, raster.length - offset);
+        out.writeByte(0);
+        out.writeString(";");
+      };
+      var bitOutputStream = function(out) {
+        var _out = out;
+        var _bitLength = 0;
+        var _bitBuffer = 0;
+        var _this2 = {};
+        _this2.write = function(data, length) {
+          if (data >>> length != 0) {
+            throw "length over";
+          }
+          while (_bitLength + length >= 8) {
+            _out.writeByte(255 & (data << _bitLength | _bitBuffer));
+            length -= 8 - _bitLength;
+            data >>>= 8 - _bitLength;
+            _bitBuffer = 0;
+            _bitLength = 0;
+          }
+          _bitBuffer = data << _bitLength | _bitBuffer;
+          _bitLength = _bitLength + length;
+        };
+        _this2.flush = function() {
+          if (_bitLength > 0) {
+            _out.writeByte(_bitBuffer);
+          }
+        };
+        return _this2;
+      };
+      var getLZWRaster = function(lzwMinCodeSize) {
+        var clearCode = 1 << lzwMinCodeSize;
+        var endCode = (1 << lzwMinCodeSize) + 1;
+        var bitLength = lzwMinCodeSize + 1;
+        var table = lzwTable();
+        for (var i = 0; i < clearCode; i += 1) {
+          table.add(String.fromCharCode(i));
+        }
+        table.add(String.fromCharCode(clearCode));
+        table.add(String.fromCharCode(endCode));
+        var byteOut = byteArrayOutputStream();
+        var bitOut = bitOutputStream(byteOut);
+        bitOut.write(clearCode, bitLength);
+        var dataIndex = 0;
+        var s = String.fromCharCode(_data[dataIndex]);
+        dataIndex += 1;
+        while (dataIndex < _data.length) {
+          var c = String.fromCharCode(_data[dataIndex]);
+          dataIndex += 1;
+          if (table.contains(s + c)) {
+            s = s + c;
+          } else {
+            bitOut.write(table.indexOf(s), bitLength);
+            if (table.size() < 4095) {
+              if (table.size() == 1 << bitLength) {
+                bitLength += 1;
+              }
+              table.add(s + c);
+            }
+            s = c;
+          }
+        }
+        bitOut.write(table.indexOf(s), bitLength);
+        bitOut.write(endCode, bitLength);
+        bitOut.flush();
+        return byteOut.toByteArray();
+      };
+      var lzwTable = function() {
+        var _map = {};
+        var _size = 0;
+        var _this2 = {};
+        _this2.add = function(key) {
+          if (_this2.contains(key)) {
+            throw "dup key:" + key;
+          }
+          _map[key] = _size;
+          _size += 1;
+        };
+        _this2.size = function() {
+          return _size;
+        };
+        _this2.indexOf = function(key) {
+          return _map[key];
+        };
+        _this2.contains = function(key) {
+          return typeof _map[key] != "undefined";
+        };
+        return _this2;
+      };
+      return _this;
+    };
+    var createDataURL = function(width, height, getPixel) {
+      var gif = gifImage(width, height);
+      for (var y = 0; y < height; y += 1) {
+        for (var x = 0; x < width; x += 1) {
+          gif.setPixel(x, y, getPixel(x, y));
+        }
+      }
+      var b = byteArrayOutputStream();
+      gif.write(b);
+      var base64 = base64EncodeOutputStream();
+      var bytes = b.toByteArray();
+      for (var i = 0; i < bytes.length; i += 1) {
+        base64.writeByte(bytes[i]);
+      }
+      base64.flush();
+      return "data:image/gif;base64," + base64;
+    };
+    return qrcode2;
+  })();
+  !(function() {
+    qrcode.stringToBytesFuncs["UTF-8"] = function(s) {
+      function toUTF8Array(str) {
+        var utf8 = [];
+        for (var i = 0; i < str.length; i++) {
+          var charcode = str.charCodeAt(i);
+          if (charcode < 128) utf8.push(charcode);
+          else if (charcode < 2048) {
+            utf8.push(
+              192 | charcode >> 6,
+              128 | charcode & 63
+            );
+          } else if (charcode < 55296 || charcode >= 57344) {
+            utf8.push(
+              224 | charcode >> 12,
+              128 | charcode >> 6 & 63,
+              128 | charcode & 63
+            );
+          } else {
+            i++;
+            charcode = 65536 + ((charcode & 1023) << 10 | str.charCodeAt(i) & 1023);
+            utf8.push(
+              240 | charcode >> 18,
+              128 | charcode >> 12 & 63,
+              128 | charcode >> 6 & 63,
+              128 | charcode & 63
+            );
+          }
+        }
+        return utf8;
+      }
+      return toUTF8Array(s);
+    };
+  })();
+  global.BluUIQRCodeEncoder = qrcode;
+}
+
+// ../blu-grid/docs/scripts/modules/common.js
+import { global as global2, runtime, state, register } from "./kernel.js";
+var shared = /* @__PURE__ */ state("common", () => ({ instances: /* @__PURE__ */ new Map(), hosts: /* @__PURE__ */ new Map(), serial: 0, overlays: [], inertState: /* @__PURE__ */ new Map(), oldOverflow: void 0 }));
+function el(tag, cls, text) {
+  var n = document.createElement(tag);
+  if (cls) n.className = cls;
+  if (text !== void 0) n.textContent = text;
+  return n;
+}
+function at(n, key, value) {
+  n.setAttribute(key, String(value));
+  return n;
+}
+function clear(n) {
+  while (n.firstChild) n.removeChild(n.firstChild);
+}
+function btn(text, fn, primary) {
+  var n = el("button", "blu-common-button" + (primary ? " blu-common-button--primary" : ""), text);
+  n.type = "button";
+  n.addEventListener("click", fn);
+  return n;
+}
+function int(v, fallback, min, max) {
+  v = v === void 0 ? fallback : Number(v);
+  if (!Number.isInteger(v) || v < min || v > max) throw Error("Expected an integer between " + min + " and " + max + ".");
+  return v;
+}
+function choice(v, values, fallback) {
+  v = v || fallback;
+  if (values.indexOf(v) < 0) throw Error("Expected one of: " + values.join(", ") + ".");
+  return v;
+}
+function emit(s, name) {
+  if (s.dead || s.host._bluCommonOwner !== s.key || !s.events[name]) return;
+  var args = Array.prototype.slice.call(arguments, 2);
+  try {
+    Promise.resolve(s.events[name].apply(null, args)).catch(function(e) {
+      if (name !== "Error") error(s, e.message || String(e));
+    });
+  } catch (e) {
+    if (name !== "Error") error(s, e.message || String(e));
+  }
+}
+function error(s, message) {
+  if (!s.error) {
+    s.error = at(el("p", "blu-common-error"), "role", "alert");
+    s.host.append(s.error);
+  }
+  s.error.textContent = message;
+  s.error.hidden = !message;
+  if (message && message !== s.lastError) emit(s, "Error", message);
+  s.lastError = message;
+}
+function begin(id, options, events, key, kind) {
+  var host = document.getElementById(id);
+  if (!host) return null;
+  key = key || id;
+  var s = shared.instances.get(key);
+  if (s && s.host !== host) {
+    destroy(key);
+    s = null;
+  }
+  if (host._bluCommonOwner && host._bluCommonOwner !== key) destroy(host._bluCommonOwner);
+  if (!s) {
+    s = { host, key, kind, uid: "blu-common-" + ++shared.serial, cleanup: [], events: {}, options: {} };
+    shared.instances.set(key, s);
+  }
+  host._bluCommonOwner = key;
+  s.options = options || {};
+  s.events = events || {};
+  at(host, "data-blu-ready", "true");
+  return s;
+}
+function destroy(key) {
+  var s = shared.instances.get(key);
+  if (!s) return;
+  s.dead = true;
+  closeOverlay(s);
+  if (s.dispose) s.dispose();
+  s.cleanup.forEach(function(f) {
+    f();
+  });
+  if (s.host._bluCommonOwner === key) {
+    delete s.host._bluCommonOwner;
+    s.host.removeAttribute("data-blu-ready");
+    if (!s.preserve) clear(s.host);
+  }
+  shared.instances.delete(key);
+}
+function body(s, cls) {
+  if (!s.body) {
+    s.body = el("div", cls);
+    s.host.append(s.body);
+  }
+  return s.body;
+}
+function refreshInert() {
+  shared.inertState.forEach(function(v, n) {
+    n.inert = v;
+  });
+  shared.inertState.clear();
+  var top = shared.overlays[shared.overlays.length - 1];
+  if (!top) {
+    if (shared.oldOverflow !== void 0) document.body.style.overflow = shared.oldOverflow;
+    shared.oldOverflow = void 0;
+    return;
+  }
+  if (shared.oldOverflow === void 0) shared.oldOverflow = document.body.style.overflow;
+  document.body.style.overflow = "hidden";
+  var node = top.layer;
+  while (node && node.parentElement) {
+    Array.from(node.parentElement.children).forEach(function(sibling) {
+      if (sibling !== node && sibling instanceof HTMLElement) {
+        shared.inertState.set(sibling, sibling.inert);
+        sibling.inert = true;
+      }
+    });
+    node = node.parentElement;
+    if (node === document.body) break;
+  }
+}
+function closeOverlay(s) {
+  if (s.stopTracking) s.stopTracking();
+  if (!s.overlayOpen) return;
+  s.overlayOpen = false;
+  var wasTop = shared.overlays[shared.overlays.length - 1] === s;
+  shared.overlays = shared.overlays.filter(function(x) {
+    return x !== s;
+  });
+  document.removeEventListener("keydown", s.overlayKey, true);
+  document.removeEventListener("focusin", s.overlayFocus, true);
+  if (s.layer.hidePopover) {
+    try {
+      s.layer.hidePopover();
+    } catch (_) {
+    }
+  }
+  s.layer.hidden = true;
+  refreshInert();
+  if (wasTop && s.returnFocus && s.returnFocus.isConnected && !s.returnFocus.closest("[inert],[hidden]")) s.returnFocus.focus();
+}
+function syncQR(s) {
+  var o = s.options, size = int(o.Size, 192, 96, 512), level = choice(o.ErrorCorrection, ["L", "M", "Q", "H"], "M"), status = choice(o.Status, ["Active", "Loading", "Expired"], "Active"), root = body(s, "blu-qr-code");
+  clear(root);
+  if (!o.Value) {
+    root.append(el("p", "blu-common-muted", "Enter text or a URL to generate a QR code."));
+    return;
+  }
+  if (status === "Loading") {
+    at(root, "aria-busy", "true");
+    root.append(el("div", "blu-qr-code__loading", "Generating code\u2026"));
+    return;
+  }
+  at(root, "aria-busy", "false");
+  var encodingKey = JSON.stringify([String(o.Value), level]);
+  if (s.encodingKey !== encodingKey) {
+    if (!global2.BluUIQRCodeEncoder) throw Error("QR encoder is unavailable.");
+    var encoder = global2.BluUIQRCodeEncoder;
+    encoder.stringToBytes = encoder.stringToBytesFuncs["UTF-8"];
+    var encoded = encoder(0, level);
+    encoded.addData(String(o.Value));
+    encoded.make();
+    var pathData = "", count = encoded.getModuleCount();
+    for (var y = 0; y < count; y++) for (var x = 0; x < count; x++) if (encoded.isDark(y, x)) pathData += "M" + (x + 4) + " " + (y + 4) + "h1v1h-1z";
+    s.matrix = encoded;
+    s.qrPath = pathData;
+    s.encodingKey = encodingKey;
+  }
+  var qr = s.matrix, modules = qr.getModuleCount() + 8, ns = "http://www.w3.org/2000/svg", svg = document.createElementNS(ns, "svg");
+  svg.setAttribute("xmlns", ns);
+  svg.setAttribute("viewBox", "0 0 " + modules + " " + modules);
+  svg.setAttribute("width", size);
+  svg.setAttribute("height", size);
+  svg.setAttribute("shape-rendering", "crispEdges");
+  at(svg, "role", "img");
+  at(svg, "aria-label", (o.AccessibleLabel || "QR code") + ": " + String(o.Value));
+  var bg = document.createElementNS(ns, "rect");
+  at(bg, "width", modules);
+  at(bg, "height", modules);
+  at(bg, "fill", "#ffffff");
+  svg.append(bg);
+  var path = document.createElementNS(ns, "path");
+  at(path, "d", s.qrPath);
+  at(path, "fill", "#000000");
+  svg.append(path);
+  var frame = el("div", "blu-qr-code__frame");
+  frame.append(svg);
+  root.append(frame);
+  root.append(el("p", "blu-qr-code__value", String(o.Value)));
+  if (status === "Expired") {
+    frame.classList.add("blu-qr-code--expired");
+    at(svg, "aria-hidden", "true");
+    var overlay = el("div", "blu-qr-code__expired");
+    overlay.append(el("strong", "", "Code expired"), btn("Refresh code", function() {
+      emit(s, "Refresh", "");
+    }, true));
+    frame.append(overlay);
+  } else if (o.ShowDownload !== false) {
+    var actions = el("div", "blu-qr-code__actions");
+    actions.append(btn("Download SVG", function() {
+      downloadQR(s, svg, "svg");
+    }), btn("Download PNG", function() {
+      downloadQR(s, svg, "png");
+    }));
+    root.append(actions);
+  }
+}
+function downloadBlob(blob, name) {
+  var url = URL.createObjectURL(blob), a = el("a");
+  a.href = url;
+  a.download = name;
+  document.body.append(a);
+  a.click();
+  a.remove();
+  setTimeout(function() {
+    URL.revokeObjectURL(url);
+  }, 1e3);
+}
+function downloadQR(s, svg, format) {
+  var filename = String(s.options.FileName || "bluui-qr").replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80) || "bluui-qr";
+  if (format === "svg") downloadBlob(new Blob([new XMLSerializer().serializeToString(svg)], { type: "image/svg+xml" }), filename + ".svg");
+  else {
+    var q = s.matrix, n = q.getModuleCount(), scale = Math.max(4, Math.ceil((s.options.Size || 192) / (n + 8))), canvas = el("canvas");
+    canvas.width = canvas.height = (n + 8) * scale;
+    var ctx = canvas.getContext("2d");
+    ctx.fillStyle = "#fff";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    ctx.fillStyle = "#000";
+    for (var y = 0; y < n; y++) for (var x = 0; x < n; x++) if (q.isDark(y, x)) ctx.fillRect((x + 4) * scale, (y + 4) * scale, scale, scale);
+    canvas.toBlob(function(blob) {
+      if (blob) downloadBlob(blob, filename + ".png");
+      else error(s, "PNG download could not be generated.");
+    }, "image/png");
+  }
+}
+function api(kind, render, cached) {
+  return { sync: function(id, options, events, key) {
+    var s = begin(id, options, events, key, kind);
+    if (!s) return;
+    try {
+      var signature = cached ? JSON.stringify(s.options) : null;
+      if (!cached || s.renderSignature !== signature) {
+        render(s);
+        s.renderSignature = signature;
+      }
+      error(s, "");
+      return "";
+    } catch (e) {
+      s.renderSignature = void 0;
+      s.cascaderSignature = null;
+      closeOverlay(s);
+      error(s, e.message || String(e));
+      return e.message || String(e);
+    }
+  }, destroy };
+}
+function installQRCode() {
+  installEncoder();
+  return register("QRCode", () => api("QRCode", syncQR, true));
+}
+export {
+  installQRCode
+};