@atooyu/uxto-ui 1.1.37 → 1.1.39

package/dist/index.mjs

@@ -4999,7 +4999,7 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
             createElementVNode("view", {
               class: normalizeClass(["u-tabbar__center-btn", {
                 "u-tabbar__center-btn--active": __props.modelValue === __props.centerTab.value,
-                "u-tabbar__center-btn--left-active": __props.modelValue === __props.leftTab.value
+                "u-tabbar__center-btn--side-active": __props.modelValue === __props.leftTab.value || __props.modelValue === __props.rightTab.value
               }]),
               onClick: _cache[1] || (_cache[1] = ($event) => switchTab(__props.centerTab.value))
             }, [
@@ -5027,7 +5027,7 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const uTabbar = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-10cb84bc"]]);
+const uTabbar = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-a344a18d"]]);
 const __default__$1 = {
   options: {
     virtualHost: true,
@@ -5098,7 +5098,6 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
       [6, 30, 58, 86, 114, 142, 170]
     ];
     const G15 = 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0;
-    const G18 = 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0;
     const G15_MASK = 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1;
     const RS_BLOCK_TABLE = [
       [1, 26, 19],
@@ -5180,99 +5179,14 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
       [3, 135, 107, 5, 136, 108],
       [3, 67, 41, 13, 68, 42],
       [15, 54, 24, 5, 55, 25],
-      [15, 43, 15, 10, 44, 16],
-      [4, 144, 116, 4, 145, 117],
-      [17, 68, 42],
-      [17, 50, 22, 6, 51, 23],
-      [19, 46, 16, 6, 47, 17],
-      [2, 139, 111, 7, 140, 112],
-      [17, 74, 46],
-      [7, 54, 24, 16, 55, 25],
-      [34, 37, 13],
-      [4, 151, 121, 5, 152, 122],
-      [4, 75, 47, 14, 76, 48],
-      [11, 54, 24, 14, 55, 25],
-      [16, 45, 15, 14, 46, 16],
-      [6, 147, 117, 4, 148, 118],
-      [6, 73, 45, 14, 74, 46],
-      [11, 54, 24, 16, 55, 25],
-      [30, 46, 16, 2, 47, 17],
-      [8, 132, 106, 4, 133, 107],
-      [8, 75, 47, 13, 76, 48],
-      [7, 54, 24, 22, 55, 25],
-      [22, 45, 15, 13, 46, 16],
-      [10, 142, 114, 2, 143, 115],
-      [19, 74, 46, 4, 75, 47],
-      [28, 50, 22, 6, 51, 23],
-      [33, 46, 16, 4, 47, 17],
-      [8, 152, 122, 4, 153, 123],
-      [22, 73, 45, 3, 74, 46],
-      [8, 53, 23, 26, 54, 24],
-      [12, 45, 15, 28, 46, 16],
-      [3, 147, 117, 10, 148, 118],
-      [3, 73, 45, 23, 74, 46],
-      [4, 54, 24, 31, 55, 25],
-      [11, 45, 15, 31, 46, 16],
-      [7, 146, 116, 7, 147, 117],
-      [21, 73, 45, 7, 74, 46],
-      [1, 53, 23, 37, 54, 24],
-      [19, 45, 15, 26, 46, 16],
-      [5, 145, 115, 10, 146, 116],
-      [19, 75, 47, 10, 76, 48],
-      [15, 54, 24, 25, 55, 25],
-      [23, 45, 15, 25, 46, 16],
-      [13, 145, 115, 3, 146, 116],
-      [2, 74, 46, 29, 75, 47],
-      [42, 54, 24, 1, 55, 25],
-      [23, 45, 15, 28, 46, 16],
-      [17, 145, 115],
-      [10, 74, 46, 23, 75, 47],
-      [10, 54, 24, 35, 55, 25],
-      [19, 45, 15, 35, 46, 16],
-      [17, 145, 115, 1, 146, 116],
-      [14, 74, 46, 21, 75, 47],
-      [29, 54, 24, 19, 55, 25],
-      [11, 45, 15, 46, 46, 16],
-      [13, 145, 115, 6, 146, 116],
-      [14, 74, 46, 23, 75, 47],
-      [44, 54, 24, 7, 55, 25],
-      [59, 46, 16, 1, 47, 17],
-      [12, 151, 121, 7, 152, 122],
-      [12, 75, 47, 26, 76, 48],
-      [39, 54, 24, 14, 55, 25],
-      [22, 45, 15, 41, 46, 16],
-      [6, 151, 121, 14, 152, 122],
-      [6, 75, 47, 34, 76, 48],
-      [46, 54, 24, 10, 55, 25],
-      [2, 45, 15, 64, 46, 16],
-      [17, 152, 122, 4, 153, 123],
-      [29, 74, 46, 14, 75, 47],
-      [49, 54, 24, 10, 55, 25],
-      [24, 45, 15, 46, 46, 16],
-      [4, 152, 122, 18, 153, 123],
-      [13, 74, 46, 32, 75, 47],
-      [48, 54, 24, 14, 55, 25],
-      [42, 45, 15, 32, 46, 16],
-      [20, 147, 117, 4, 148, 118],
-      [40, 75, 47, 7, 76, 48],
-      [43, 54, 24, 22, 55, 25],
-      [10, 45, 15, 67, 46, 16],
-      [19, 148, 118, 6, 149, 119],
-      [18, 75, 47, 31, 76, 48],
-      [34, 54, 24, 34, 55, 25],
-      [20, 45, 15, 61, 46, 16]
+      [15, 43, 15, 10, 44, 16]
     ];
-    const EXP_TABLE = new Array(256);
-    const LOG_TABLE = new Array(256);
-    for (let i = 0; i < 8; i++) {
-      EXP_TABLE[i] = 1 << i;
-    }
-    for (let i = 8; i < 256; i++) {
-      EXP_TABLE[i] = EXP_TABLE[i - 4] ^ EXP_TABLE[i - 5] ^ EXP_TABLE[i - 6] ^ EXP_TABLE[i - 8];
-    }
-    for (let i = 0; i < 255; i++) {
-      LOG_TABLE[EXP_TABLE[i]] = i;
-    }
+    const EXP_TABLE = [];
+    const LOG_TABLE = [];
+    for (let i = 0; i < 8; i++) EXP_TABLE[i] = 1 << i;
+    for (let i = 8; i < 256; i++) EXP_TABLE[i] = EXP_TABLE[i - 4] ^ EXP_TABLE[i - 5] ^ EXP_TABLE[i - 6] ^ EXP_TABLE[i - 8];
+    for (let i = 0; i < 255; i++) LOG_TABLE[EXP_TABLE[i]] = i;
+    for (let i = 255; i < 512; i++) EXP_TABLE[i] = EXP_TABLE[i - 255];
     function glog(n) {
       if (n < 1) throw new Error("glog(" + n + ")");
       return LOG_TABLE[n];
@@ -5282,37 +5196,6 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
       while (n >= 256) n -= 255;
       return EXP_TABLE[n];
     }
-    function createPolynomial(num, shift) {
-      let offset = 0;
-      while (offset < num.length && num[offset] === 0) offset++;
-      const _num = new Array(num.length - offset + shift).fill(0);
-      for (let i = 0; i < num.length - offset; i++) {
-        _num[i] = num[i + offset];
-      }
-      return {
-        getAt: (index) => _num[index],
-        getLength: () => _num.length,
-        multiply: (e) => {
-          const result = new Array(_num.length + e.getLength() - 1).fill(0);
-          for (let i = 0; i < _num.length; i++) {
-            for (let j = 0; j < e.getLength(); j++) {
-              result[i + j] ^= gexp(glog(_num[i]) + glog(e.getAt(j)));
-            }
-          }
-          return createPolynomial(result, 0);
-        },
-        mod: (e) => {
-          const lenDiff = _num.length - e.getLength();
-          if (lenDiff < 0) return createPolynomial(_num, 0);
-          const ratio = glog(_num[0]) - glog(e.getAt(0));
-          const result = [..._num];
-          for (let i = 0; i < e.getLength(); i++) {
-            result[i] ^= gexp(glog(e.getAt(i)) + ratio);
-          }
-          return createPolynomial(result, 0).mod(e);
-        }
-      };
-    }
     function getBCHDigit(data) {
       let digit = 0;
       while (data !== 0) {
@@ -5323,20 +5206,11 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
     }
     function getBCHTypeInfo(data) {
       let d = data << 10;
-      while (getBCHDigit(d) - getBCHDigit(G15) >= 0) {
-        d ^= G15 << getBCHDigit(d) - getBCHDigit(G15);
-      }
+      while (getBCHDigit(d) - getBCHDigit(G15) >= 0) d ^= G15 << getBCHDigit(d) - getBCHDigit(G15);
       return (data << 10 | d) ^ G15_MASK;
     }
-    function getBCHTypeNumber(data) {
-      let d = data << 12;
-      while (getBCHDigit(d) - getBCHDigit(G18) >= 0) {
-        d ^= G18 << getBCHDigit(d) - getBCHDigit(G18);
-      }
-      return data << 12 | d;
-    }
     function getPatternPosition(typeNumber) {
-      return PATTERN_POSITION_TABLE[typeNumber - 1];
+      return PATTERN_POSITION_TABLE[typeNumber - 1] || [];
     }
     function getMaskFunction(maskPattern) {
       switch (maskPattern) {
@@ -5357,72 +5231,20 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
         case 7:
           return (i, j) => (i * j % 3 + (i + j) % 2) % 2 === 0;
         default:
-          throw new Error("bad maskPattern:" + maskPattern);
-      }
-    }
-    function getErrorCorrectPolynomial(errorCorrectLength) {
-      let a = createPolynomial([1], 0);
-      for (let i = 0; i < errorCorrectLength; i++) {
-        a = a.multiply(createPolynomial([1, gexp(i)], 0));
-      }
-      return a;
-    }
-    function getLengthInBits(mode, type) {
-      if (1 <= type && type < 10) {
-        switch (mode) {
-          case 1:
-            return 10;
-          case 2:
-            return 9;
-          case 4:
-            return 8;
-          case 8:
-            return 8;
-          default:
-            throw new Error("mode:" + mode);
-        }
-      } else if (type < 27) {
-        switch (mode) {
-          case 1:
-            return 12;
-          case 2:
-            return 11;
-          case 4:
-            return 16;
-          case 8:
-            return 10;
-          default:
-            throw new Error("mode:" + mode);
-        }
-      } else if (type < 41) {
-        switch (mode) {
-          case 1:
-            return 14;
-          case 2:
-            return 13;
-          case 4:
-            return 16;
-          case 8:
-            return 12;
-          default:
-            throw new Error("mode:" + mode);
-        }
-      } else {
-        throw new Error("type:" + type);
+          return () => false;
       }
     }
     function getRSBlocks(typeNumber, errorCorrectionLevel) {
-      const rsBlock = RS_BLOCK_TABLE[(typeNumber - 1) * 4 + errorCorrectionLevel];
-      if (!rsBlock) throw new Error("bad rs block");
-      const length = rsBlock.length / 3;
+      const index = (typeNumber - 1) * 4 + errorCorrectionLevel;
+      const block = RS_BLOCK_TABLE[index];
+      if (!block) throw new Error("bad rs block");
       const list2 = [];
+      const length = Math.floor(block.length / 3);
       for (let i = 0; i < length; i++) {
-        const count = rsBlock[i * 3 + 0];
-        const totalCount = rsBlock[i * 3 + 1];
-        const dataCount = rsBlock[i * 3 + 2];
-        for (let j = 0; j < count; j++) {
-          list2.push({ totalCount, dataCount });
-        }
+        const count = block[i * 3];
+        const totalCount = block[i * 3 + 1];
+        const dataCount = block[i * 3 + 2];
+        for (let j = 0; j < count; j++) list2.push({ totalCount, dataCount });
       }
       return list2;
     }
@@ -5438,335 +5260,252 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
         return this.length;
       }
       put(num, len) {
-        for (let i = 0; i < len; i++) {
-          this.putBit((num >>> len - i - 1 & 1) === 1);
-        }
+        for (let i = 0; i < len; i++) this.putBit((num >>> len - i - 1 & 1) === 1);
       }
       putBit(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;
-        }
+        if (this.buffer.length <= bufIndex) this.buffer.push(0);
+        if (bit) this.buffer[bufIndex] |= 128 >>> this.length % 8;
         this.length++;
       }
     }
     function stringToBytes(s) {
       const bytes = [];
-      for (let i = 0; i < s.length; i++) {
-        const c = s.charCodeAt(i);
-        bytes.push(c & 255);
-      }
+      for (let i = 0; i < s.length; i++) bytes.push(s.charCodeAt(i) & 255);
       return bytes;
     }
-    function createData(typeNumber, errorCorrectionLevel, dataList) {
-      const rsBlocks = getRSBlocks(typeNumber, errorCorrectionLevel);
-      const buffer = new BitBuffer();
-      for (const data of dataList) {
-        buffer.put(data.mode, 4);
-        buffer.put(stringToBytes(data.data).length, getLengthInBits(data.mode, typeNumber));
-        for (const byte of stringToBytes(data.data)) {
-          buffer.put(byte, 8);
+    function getLengthInBits(mode, type) {
+      if (type < 10) return mode === 4 ? 8 : 8;
+      if (type < 27) return mode === 4 ? 16 : 10;
+      return mode === 4 ? 16 : 12;
+    }
+    function multiplyPolynomials(a, b) {
+      const result = new Array(a.length + b.length - 1).fill(0);
+      for (let i = 0; i < a.length; i++) {
+        for (let j = 0; j < b.length; j++) {
+          result[i + j] ^= gexp(glog(a[i]) + glog(b[j]));
         }
       }
-      let totalDataCount = 0;
-      for (const block of rsBlocks) {
-        totalDataCount += block.dataCount;
-      }
-      if (buffer.getLengthInBits() > totalDataCount * 8) {
-        throw new Error("code length overflow");
-      }
-      if (buffer.getLengthInBits() + 4 <= totalDataCount * 8) {
-        buffer.put(0, 4);
-      }
-      while (buffer.getLengthInBits() % 8 !== 0) {
-        buffer.putBit(false);
+      return result;
+    }
+    function modPolynomial(a, b) {
+      let result = [...a];
+      while (result.length >= b.length) {
+        const ratio = glog(result[0]) - glog(b[0]);
+        for (let i = 0; i < b.length; i++) {
+          result[i] ^= gexp(glog(b[i]) + ratio);
+        }
+        while (result.length > 0 && result[0] === 0) result.shift();
       }
-      while (true) {
-        if (buffer.getLengthInBits() >= totalDataCount * 8) break;
-        buffer.put(PAD0, 8);
-        if (buffer.getLengthInBits() >= totalDataCount * 8) break;
-        buffer.put(PAD1, 8);
+      return result;
+    }
+    function getErrorCorrectPolynomial(errorCorrectLength) {
+      let poly = [1];
+      for (let i = 0; i < errorCorrectLength; i++) {
+        poly = multiplyPolynomials(poly, [1, gexp(i)]);
       }
-      return createBytes(buffer, rsBlocks);
+      return poly;
     }
-    function createBytes(buffer, rsBlocks) {
-      let offset = 0;
-      let maxDcCount = 0;
-      let maxEcCount = 0;
-      const dcdata = [];
-      const ecdata = [];
+    function createData(typeNumber, errorCorrectionLevel, data) {
+      const rsBlocks = getRSBlocks(typeNumber, errorCorrectionLevel);
+      let totalDataCount = 0;
+      for (const block of rsBlocks) totalDataCount += block.dataCount;
+      const buffer = new BitBuffer();
+      buffer.put(4, 4);
+      const bytes = stringToBytes(data);
+      buffer.put(bytes.length, getLengthInBits(4, typeNumber));
+      for (const byte of bytes) buffer.put(byte, 8);
+      if (buffer.getLengthInBits() + 4 <= totalDataCount * 8) buffer.put(0, 4);
+      while (buffer.getLengthInBits() % 8 !== 0) buffer.putBit(false);
+      let padIndex = 0;
+      const padBytes = [PAD0, PAD1];
+      while (buffer.getLengthInBits() < totalDataCount * 8) {
+        buffer.put(padBytes[padIndex], 8);
+        padIndex = (padIndex + 1) % 2;
+      }
+      const dataBuffer = buffer.getBuffer();
+      let dataIndex = 0;
+      const dcData = [];
+      const ecData = [];
       for (const block of rsBlocks) {
-        const dcCount = block.dataCount;
-        const ecCount = block.totalCount - dcCount;
-        maxDcCount = Math.max(maxDcCount, dcCount);
-        maxEcCount = Math.max(maxEcCount, ecCount);
-        const dc = [];
-        for (let i = 0; i < dcCount; i++) {
-          dc.push(255 & buffer.getBuffer()[i + offset]);
-        }
-        dcdata.push(dc);
-        offset += dcCount;
+        const dc = dataBuffer.slice(dataIndex, dataIndex + block.dataCount);
+        dataIndex += block.dataCount;
+        dcData.push(dc);
+        const ecCount = block.totalCount - block.dataCount;
         const rsPoly = getErrorCorrectPolynomial(ecCount);
-        const rawPoly = createPolynomial(dc, rsPoly.getLength() - 1);
-        const modPoly = rawPoly.mod(rsPoly);
-        const ec = new Array(rsPoly.getLength() - 1).fill(0);
-        for (let i = 0; i < ec.length; i++) {
-          const modIndex = i + modPoly.getLength() - ec.length;
-          ec[i] = modIndex >= 0 ? modPoly.getAt(modIndex) : 0;
-        }
-        ecdata.push(ec);
+        const dataPoly = [...dc, ...new Array(ecCount).fill(0)];
+        const ec = modPolynomial(dataPoly, rsPoly);
+        ecData.push(ec.slice(-ecCount));
       }
       const result = [];
+      let maxDcCount = 0;
+      let maxEcCount = 0;
+      for (const block of rsBlocks) {
+        maxDcCount = Math.max(maxDcCount, block.dataCount);
+        maxEcCount = Math.max(maxEcCount, block.totalCount - block.dataCount);
+      }
       for (let i = 0; i < maxDcCount; i++) {
-        for (let j = 0; j < dcdata.length; j++) {
-          if (i < dcdata[j].length) result.push(dcdata[j][i]);
+        for (const dc of dcData) {
+          if (i < dc.length) result.push(dc[i]);
         }
       }
       for (let i = 0; i < maxEcCount; i++) {
-        for (let j = 0; j < ecdata.length; j++) {
-          if (i < ecdata[j].length) result.push(ecdata[j][i]);
+        for (const ec of ecData) {
+          if (i < ec.length) result.push(ec[i]);
         }
       }
       return result;
     }
-    class QRCode {
-      constructor(typeNumber, errorCorrectionLevel) {
-        __publicField(this, "typeNumber");
-        __publicField(this, "errorCorrectionLevel");
-        __publicField(this, "modules", []);
-        __publicField(this, "moduleCount", 0);
-        __publicField(this, "dataCache", null);
-        this.typeNumber = typeNumber;
-        this.errorCorrectionLevel = QRErrorCorrectionLevel[errorCorrectionLevel];
-      }
-      addData(data) {
-        const dataList = [{ mode: 4, data }];
-        this.dataCache = createData(this.typeNumber, this.errorCorrectionLevel, dataList);
-      }
-      make() {
-        if (this.typeNumber < 1) {
-          let typeNumber = 1;
-          for (; typeNumber < 40; typeNumber++) {
-            try {
-              const testData = createData(typeNumber, this.errorCorrectionLevel, [{ mode: 4, data: "test" }]);
-              this.dataCache = createData(typeNumber, this.errorCorrectionLevel, [{ mode: 4, data: "" }]);
-              break;
-            } catch {
-              continue;
-            }
-          }
-          this.typeNumber = typeNumber;
-        }
-        this.makeImpl(false, this.getBestMaskPattern());
-      }
-      getBestMaskPattern() {
-        let minLostPoint = 0;
-        let pattern = 0;
-        for (let i = 0; i < 8; i++) {
-          this.makeImpl(true, i);
-          const lostPoint = this.getLostPoint();
-          if (i === 0 || minLostPoint > lostPoint) {
-            minLostPoint = lostPoint;
-            pattern = i;
-          }
-        }
-        return pattern;
-      }
-      makeImpl(test, maskPattern) {
-        this.moduleCount = this.typeNumber * 4 + 17;
-        this.modules = [];
-        for (let row = 0; row < this.moduleCount; row++) {
-          this.modules[row] = new Array(this.moduleCount).fill(null);
-        }
-        this.setupPositionProbePattern(0, 0);
-        this.setupPositionProbePattern(this.moduleCount - 7, 0);
-        this.setupPositionProbePattern(0, this.moduleCount - 7);
-        this.setupPositionAdjustPattern();
-        this.setupTimingPattern();
-        this.setupTypeInfo(test, maskPattern);
-        if (this.typeNumber >= 7) {
-          this.setupTypeNumber(test);
-        }
-        if (this.dataCache === null) {
-          throw new Error("dataCache is null");
-        }
-        this.mapData(this.dataCache, maskPattern);
-      }
-      setupPositionProbePattern(row, col) {
+    function generateQRCode(text, errorLevel) {
+      const ecl = QRErrorCorrectionLevel[errorLevel] ?? 0;
+      let typeNumber = 1;
+      for (; typeNumber <= 40; typeNumber++) {
+        const rsBlocks = getRSBlocks(typeNumber, ecl);
+        let totalDataCount = 0;
+        for (const block of rsBlocks) totalDataCount += block.dataCount;
+        const lengthBits = typeNumber < 10 ? 8 : 16;
+        const totalBits = 4 + lengthBits + stringToBytes(text).length * 8;
+        if (totalBits <= totalDataCount * 8) break;
+      }
+      const size = typeNumber * 4 + 17;
+      const data = createData(typeNumber, ecl, text);
+      const mod = [];
+      for (let i = 0; i < size; i++) mod[i] = new Array(size).fill(null);
+      const setupFinderPattern = (row, col) => {
         for (let r = -1; r <= 7; r++) {
-          if (row + r <= -1 || this.moduleCount <= row + r) continue;
           for (let c = -1; c <= 7; c++) {
-            if (col + c <= -1 || this.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) {
-              this.modules[row + r][col + c] = true;
+            const nr = row + r, nc = col + c;
+            if (nr < 0 || nr >= size || nc < 0 || nc >= size) continue;
+            if (r >= 0 && r <= 6 && (c === 0 || c === 6) || c >= 0 && c <= 6 && (r === 0 || r === 6) || r >= 2 && r <= 4 && c >= 2 && c <= 4) {
+              mod[nr][nc] = true;
             } else {
-              this.modules[row + r][col + c] = false;
+              mod[nr][nc] = false;
             }
           }
         }
-      }
-      setupTimingPattern() {
-        for (let r = 8; r < this.moduleCount - 8; r++) {
-          if (this.modules[r][6] !== null) continue;
-          this.modules[r][6] = r % 2 === 0;
-        }
-        for (let c = 8; c < this.moduleCount - 8; c++) {
-          if (this.modules[6][c] !== null) continue;
-          this.modules[6][c] = c % 2 === 0;
-        }
-      }
-      setupPositionAdjustPattern() {
-        const pos = getPatternPosition(this.typeNumber);
-        for (let i = 0; i < pos.length; i++) {
-          for (let j = 0; j < pos.length; j++) {
-            const row = pos[i];
-            const col = pos[j];
-            if (this.modules[row][col] !== null) continue;
-            for (let r = -2; r <= 2; r++) {
-              for (let c = -2; c <= 2; c++) {
-                if (r === -2 || r === 2 || c === -2 || c === 2 || r === 0 && c === 0) {
-                  this.modules[row + r][col + c] = true;
-                } else {
-                  this.modules[row + r][col + c] = false;
-                }
-              }
+      };
+      setupFinderPattern(0, 0);
+      setupFinderPattern(size - 7, 0);
+      setupFinderPattern(0, size - 7);
+      for (let i = 8; i < size - 8; i++) {
+        if (mod[i][6] === null) mod[i][6] = i % 2 === 0;
+        if (mod[6][i] === null) mod[6][i] = i % 2 === 0;
+      }
+      const alignPos = getPatternPosition(typeNumber);
+      for (const row of alignPos) {
+        for (const col of alignPos) {
+          if (mod[row][col] !== null) continue;
+          for (let r = -2; r <= 2; r++) {
+            for (let c = -2; c <= 2; c++) {
+              mod[row + r][col + c] = r === -2 || r === 2 || c === -2 || c === 2 || r === 0 && c === 0;
             }
           }
         }
       }
-      setupTypeNumber(test) {
-        const bits = getBCHTypeNumber(this.typeNumber);
-        for (let i = 0; i < 18; i++) {
-          const mod = !test && (bits >> i & 1) === 1;
-          this.modules[Math.floor(i / 3)][i % 3 + this.moduleCount - 8 - 3] = mod;
-        }
-        for (let i = 0; i < 18; i++) {
-          const mod = !test && (bits >> i & 1) === 1;
-          this.modules[i % 3 + this.moduleCount - 8 - 3][Math.floor(i / 3)] = mod;
-        }
-      }
-      setupTypeInfo(test, maskPattern) {
-        const data = this.errorCorrectionLevel << 3 | maskPattern;
-        const bits = getBCHTypeInfo(data);
-        for (let i = 0; i < 15; i++) {
-          const mod = !test && (bits >> i & 1) === 1;
-          if (i < 6) {
-            this.modules[i][8] = mod;
-          } else if (i < 8) {
-            this.modules[i + 1][8] = mod;
-          } else {
-            this.modules[this.moduleCount - 15 + i][8] = mod;
+      for (let i = 0; i < 9; i++) {
+        if (mod[8][i] === null) mod[8][i] = false;
+        if (mod[i][8] === null) mod[i][8] = false;
+      }
+      for (let i = 0; i < 8; i++) {
+        if (mod[8][size - 1 - i] === null) mod[8][size - 1 - i] = false;
+        if (mod[size - 1 - i][8] === null) mod[size - 1 - i][8] = false;
+      }
+      mod[size - 8][8] = true;
+      if (typeNumber >= 7) {
+        const bits = typeNumber;
+        for (let i = 0; i < 6; i++) {
+          for (let j = 0; j < 3; j++) {
+            mod[i][size - 11 + j] = (bits >> i * 3 + j & 1) === 1;
+            mod[size - 11 + j][i] = (bits >> i * 3 + j & 1) === 1;
           }
         }
-        for (let i = 0; i < 15; i++) {
-          const mod = !test && (bits >> i & 1) === 1;
-          if (i < 8) {
-            this.modules[8][this.moduleCount - i - 1] = mod;
-          } else if (i < 9) {
-            this.modules[8][15 - i - 1 + 1] = mod;
-          } else {
-            this.modules[8][15 - i - 1] = mod;
-          }
+      }
+      let bestMask = 0;
+      let bestPenalty = Infinity;
+      for (let mask = 0; mask < 8; mask++) {
+        const testMod = mod.map((row) => [...row]);
+        mapData(testMod, size, data, mask);
+        const penalty = calculatePenalty(testMod, size);
+        if (penalty < bestPenalty) {
+          bestPenalty = penalty;
+          bestMask = mask;
         }
-        this.modules[this.moduleCount - 8][8] = !test;
-      }
-      mapData(data, maskPattern) {
-        let inc = -1;
-        let row = this.moduleCount - 1;
-        let bitIndex = 7;
-        let byteIndex = 0;
-        const maskFunc = getMaskFunction(maskPattern);
-        for (let col = this.moduleCount - 1; col > 0; col -= 2) {
-          if (col === 6) col -= 1;
-          while (true) {
-            for (let c = 0; c < 2; c++) {
-              if (this.modules[row][col - c] === null) {
-                let dark = false;
-                if (byteIndex < data.length) {
-                  dark = (data[byteIndex] >>> bitIndex & 1) === 1;
-                }
-                const mask = maskFunc(row, col - c);
-                if (mask) dark = !dark;
-                this.modules[row][col - c] = dark;
-                bitIndex--;
-                if (bitIndex === -1) {
-                  byteIndex++;
-                  bitIndex = 7;
-                }
-              }
-            }
-            row += inc;
-            if (row < 0 || this.moduleCount <= row) {
-              row -= inc;
-              inc = -inc;
-              break;
-            }
-          }
+      }
+      mapData(mod, size, data, bestMask);
+      const formatData = ecl << 3 | bestMask;
+      const formatBits = getBCHTypeInfo(formatData);
+      for (let i = 0; i < 6; i++) mod[8][i] = (formatBits >> i & 1) === 1;
+      mod[8][7] = (formatBits >> 6 & 1) === 1;
+      mod[8][8] = (formatBits >> 7 & 1) === 1;
+      mod[7][8] = (formatBits >> 8 & 1) === 1;
+      for (let i = 9; i < 15; i++) mod[14 - i][8] = (formatBits >> i & 1) === 1;
+      for (let i = 0; i < 8; i++) mod[8][size - 1 - i] = (formatBits >> i & 1) === 1;
+      for (let i = 8; i < 15; i++) mod[size - 15 + i][8] = (formatBits >> i & 1) === 1;
+      const result = [];
+      for (let r = 0; r < size; r++) {
+        result[r] = [];
+        for (let c = 0; c < size; c++) {
+          result[r][c] = mod[r][c] === true;
         }
       }
-      getLostPoint() {
-        let lostPoint = 0;
-        for (let row = 0; row < this.moduleCount; row++) {
-          for (let col = 0; col < this.moduleCount; col++) {
-            let sameCount = 0;
-            const dark = this.modules[row][col];
-            for (let r = -1; r <= 1; r++) {
-              if (row + r < 0 || this.moduleCount <= row + r) continue;
-              for (let c = -1; c <= 1; c++) {
-                if (col + c < 0 || this.moduleCount <= col + c) continue;
-                if (r === 0 && c === 0) continue;
-                if (dark === this.modules[row + r][col + c]) sameCount++;
+      return { modules: result, moduleCount: size };
+    }
+    function mapData(mod, size, data, maskPattern) {
+      const maskFunc = getMaskFunction(maskPattern);
+      let bitIndex = 0;
+      let inc = -1;
+      let row = size - 1;
+      for (let col = size - 1; col > 0; col -= 2) {
+        if (col === 6) col = 5;
+        while (true) {
+          for (let c = 0; c < 2; c++) {
+            const tc = col - c;
+            if (mod[row][tc] === null) {
+              let dark = false;
+              if (bitIndex < data.length * 8) {
+                dark = (data[Math.floor(bitIndex / 8)] >>> 7 - bitIndex % 8 & 1) === 1;
               }
+              if (maskFunc(row, tc)) dark = !dark;
+              mod[row][tc] = dark;
+              bitIndex++;
             }
-            if (sameCount > 5) lostPoint += 3 + sameCount - 5;
           }
-        }
-        for (let row = 0; row < this.moduleCount - 1; row++) {
-          for (let col = 0; col < this.moduleCount - 1; col++) {
-            let count = 0;
-            if (this.modules[row][col]) count++;
-            if (this.modules[row + 1][col]) count++;
-            if (this.modules[row][col + 1]) count++;
-            if (this.modules[row + 1][col + 1]) count++;
-            if (count === 0 || count === 4) lostPoint += 3;
+          row += inc;
+          if (row < 0 || row >= size) {
+            row -= inc;
+            inc = -inc;
+            break;
           }
         }
-        for (let row = 0; row < this.moduleCount; row++) {
-          for (let col = 0; col < this.moduleCount - 6; col++) {
-            if (this.modules[row][col] && !this.modules[row][col + 1] && this.modules[row][col + 2] && this.modules[row][col + 3] && this.modules[row][col + 4] && !this.modules[row][col + 5] && this.modules[row][col + 6]) {
-              lostPoint += 40;
-            }
-          }
-        }
-        for (let col = 0; col < this.moduleCount; col++) {
-          for (let row = 0; row < this.moduleCount - 6; row++) {
-            if (this.modules[row][col] && !this.modules[row + 1][col] && this.modules[row + 2][col] && this.modules[row + 3][col] && this.modules[row + 4][col] && !this.modules[row + 5][col] && this.modules[row + 6][col]) {
-              lostPoint += 40;
-            }
-          }
-        }
-        let darkCount = 0;
-        for (let col = 0; col < this.moduleCount; col++) {
-          for (let row = 0; row < this.moduleCount; row++) {
-            if (this.modules[row][col]) darkCount++;
+      }
+    }
+    function calculatePenalty(mod, size) {
+      let penalty = 0;
+      for (let row = 0; row < size; row++) {
+        let count = 1;
+        for (let col = 1; col < size; col++) {
+          if (mod[row][col] === mod[row][col - 1]) {
+            count++;
+          } else {
+            if (count >= 5) penalty += 3 + (count - 5);
+            count = 1;
           }
         }
-        const ratio = Math.abs(100 * darkCount / this.moduleCount / this.moduleCount - 50) / 5;
-        lostPoint += ratio * 10;
-        return lostPoint;
-      }
-      getModuleCount() {
-        return this.moduleCount;
+        if (count >= 5) penalty += 3 + (count - 5);
       }
-      isDark(row, col) {
-        if (row < 0 || this.moduleCount <= row || col < 0 || this.moduleCount <= col) {
-          throw new Error(row + "," + col);
+      for (let col = 0; col < size; col++) {
+        let count = 1;
+        for (let row = 1; row < size; row++) {
+          if (mod[row][col] === mod[row - 1][col]) {
+            count++;
+          } else {
+            if (count >= 5) penalty += 3 + (count - 5);
+            count = 1;
+          }
         }
-        return this.modules[row][col] === true;
+        if (count >= 5) penalty += 3 + (count - 5);
       }
+      return penalty;
     }
     const generate = () => {
       if (!props.value) {
@@ -5775,19 +5514,9 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
         return;
       }
       try {
-        const qr = new QRCode(0, props.errorCorrectLevel);
-        qr.addData(props.value);
-        qr.make();
-        const count = qr.getModuleCount();
-        moduleCount.value = count;
-        const result = [];
-        for (let row = 0; row < count; row++) {
-          result[row] = [];
-          for (let col = 0; col < count; col++) {
-            result[row][col] = qr.isDark(row, col);
-          }
-        }
-        modules.value = result;
+        const qr = generateQRCode(props.value, props.errorCorrectLevel);
+        modules.value = qr.modules;
+        moduleCount.value = qr.moduleCount;
       } catch (e) {
         console.error("QR Code generation failed:", e);
         modules.value = [];
@@ -5829,7 +5558,7 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const uQrcode = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-e3d52c6f"]]);
+const uQrcode = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-a6ae1830"]]);
 const _hoisted_1 = { class: "u-barcode" };
 const _hoisted_2 = ["canvas-id"];
 const _hoisted_3 = ["src"];