@atooyu/uxto-ui 1.1.37 → 1.1.39

package/src/components/u-qrcode/u-qrcode.vue

@@ -45,60 +45,30 @@ const cellSize = computed(() => {
 })
 
 //---------------------------------------------------------------------------
-// QR Code Generator - Inlined from qrcode-generator by kazuhikoarase
+// QR Code Generator - Based on qrcode-generator by kazuhikoarase
 // https://github.com/kazuhikoarase/qrcode-generator
 // License: MIT
 //---------------------------------------------------------------------------
 
-// Error correction levels
-const QRErrorCorrectionLevel = { L: 1, M: 0, Q: 3, H: 2 }
+// Error correction levels: L=1, M=0, Q=3, H=2
+const QRErrorCorrectionLevel: Record<string, number> = { L: 1, M: 0, Q: 3, H: 2 }
 
 // Padding bytes
 const PAD0 = 0xEC
 const PAD1 = 0x11
 
-// Pattern position table (alignment patterns)
+// Pattern position table (alignment patterns) - index is typeNumber - 1
 const PATTERN_POSITION_TABLE: number[][] = [
-  [],
-  [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]
+  [], [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]
 ]
 
 // BCH codes
@@ -106,7 +76,7 @@ const G15 = (1 << 10) | (1 << 8) | (1 << 5) | (1 << 4) | (1 << 2) | (1 << 1) | (
 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)
 
-// RS Block table
+// RS Block table - each entry is for one typeNumber, 4 error levels
 const RS_BLOCK_TABLE: number[][] = [
   [1, 26, 19], [1, 26, 16], [1, 26, 13], [1, 26, 9],
   [1, 44, 34], [1, 44, 28], [1, 44, 22], [1, 44, 16],
@@ -127,44 +97,18 @@ const RS_BLOCK_TABLE: number[][] = [
   [1, 135, 107, 5, 136, 108], [10, 74, 46, 1, 75, 47], [1, 50, 22, 15, 51, 23], [2, 42, 14, 17, 43, 15],
   [5, 150, 120, 1, 151, 121], [9, 69, 43, 4, 70, 44], [17, 50, 22, 1, 51, 23], [2, 42, 14, 19, 43, 15],
   [3, 141, 113, 4, 142, 114], [3, 70, 44, 11, 71, 45], [17, 47, 21, 4, 48, 22], [9, 39, 13, 16, 40, 14],
-  [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]
+  [3, 135, 107, 5, 136, 108], [3, 67, 41, 13, 68, 42], [15, 54, 24, 5, 55, 25], [15, 43, 15, 10, 44, 16]
 ]
 
-// QR Math - Galois Field operations
-const EXP_TABLE: number[] = new Array(256)
-const LOG_TABLE: number[] = new Array(256)
+// Galois Field tables
+const EXP_TABLE: number[] = []
+const LOG_TABLE: number[] = []
 
-// Initialize EXP_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]
-}
-// Initialize LOG_TABLE
-for (let i = 0; i < 255; i++) {
-  LOG_TABLE[EXP_TABLE[i]] = i
-}
+// Initialize GF tables
+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: number): number {
   if (n < 1) throw new Error('glog(' + n + ')')
@@ -177,80 +121,23 @@ function gexp(n: number): number {
   return EXP_TABLE[n]
 }
 
-// Polynomial operations
-interface Polynomial {
-  getAt(index: number): number
-  getLength(): number
-  multiply(e: Polynomial): Polynomial
-  mod(e: Polynomial): Polynomial
-}
-
-function createPolynomial(num: number[], shift: number): Polynomial {
-  // Remove leading zeros
-  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: number) => _num[index],
-    getLength: () => _num.length,
-    multiply: (e: Polynomial): Polynomial => {
-      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: Polynomial): Polynomial => {
-      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)
-    }
-  }
-}
-
 // Get BCH digit count
 function getBCHDigit(data: number): number {
   let digit = 0
-  while (data !== 0) {
-    digit++
-    data >>>= 1
-  }
+  while (data !== 0) { digit++; data >>>= 1 }
   return digit
 }
 
 // Get BCH type info
 function getBCHTypeInfo(data: number): number {
   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
 }
 
-// Get BCH type number
-function getBCHTypeNumber(data: number): number {
-  let d = data << 12
-  while (getBCHDigit(d) - getBCHDigit(G18) >= 0) {
-    d ^= G18 << (getBCHDigit(d) - getBCHDigit(G18))
-  }
-  return (data << 12) | d
-}
-
 // Get pattern position
 function getPatternPosition(typeNumber: number): number[] {
-  return PATTERN_POSITION_TABLE[typeNumber - 1]
+  return PATTERN_POSITION_TABLE[typeNumber - 1] || []
 }
 
 // Get mask function
@@ -264,507 +151,372 @@ function getMaskFunction(maskPattern: number): (i: number, j: number) => boolean
     case 5: return (i, j) => (i * j) % 2 + (i * j) % 3 === 0
     case 6: return (i, j) => ((i * j) % 2 + (i * j) % 3) % 2 === 0
     case 7: return (i, j) => ((i * j) % 3 + (i + j) % 2) % 2 === 0
-    default: throw new Error('bad maskPattern:' + maskPattern)
-  }
-}
-
-// Get error correct polynomial
-function getErrorCorrectPolynomial(errorCorrectLength: number): Polynomial {
-  let a = createPolynomial([1], 0)
-  for (let i = 0; i < errorCorrectLength; i++) {
-    a = a.multiply(createPolynomial([1, gexp(i)], 0))
-  }
-  return a
-}
-
-// Get length in bits for mode
-function getLengthInBits(mode: number, type: number): number {
-  if (1 <= type && type < 10) {
-    switch (mode) {
-      case 1: return 10  // NUMBER
-      case 2: return 9   // ALPHA_NUM
-      case 4: return 8   // 8BIT_BYTE
-      case 8: return 8   // KANJI
-      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)
+    default: return () => false
   }
 }
 
 // Get RS blocks
 function getRSBlocks(typeNumber: number, errorCorrectionLevel: number): { totalCount: number; dataCount: number }[] {
-  const rsBlock = RS_BLOCK_TABLE[(typeNumber - 1) * 4 + errorCorrectionLevel]
-  if (!rsBlock) throw new Error('bad rs block')
+  const index = (typeNumber - 1) * 4 + errorCorrectionLevel
+  const block = RS_BLOCK_TABLE[index]
+  if (!block) throw new Error('bad rs block')
 
-  const length = rsBlock.length / 3
   const list: { totalCount: number; dataCount: number }[] = []
+  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++) {
-      list.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++) list.push({ totalCount, dataCount })
   }
   return list
 }
 
-// Bit buffer
+// Bit buffer class
 class BitBuffer {
-  private buffer: number[] = []
-  private length = 0
+  buffer: number[] = []
+  length = 0
 
-  getBuffer(): number[] { return this.buffer }
-  getLengthInBits(): number { return this.length }
+  getBuffer() { return this.buffer }
+  getLengthInBits() { return this.length }
 
   put(num: number, len: number) {
-    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: boolean) {
     const bufIndex = Math.floor(this.length / 8)
-    if (this.buffer.length <= bufIndex) {
-      this.buffer.push(0)
-    }
-    if (bit) {
-      this.buffer[bufIndex] |= (0x80 >>> (this.length % 8))
-    }
+    if (this.buffer.length <= bufIndex) this.buffer.push(0)
+    if (bit) this.buffer[bufIndex] |= 0x80 >>> (this.length % 8)
     this.length++
   }
 }
 
-// String to bytes (UTF-8)
+// String to bytes
 function stringToBytes(s: string): number[] {
   const bytes: number[] = []
-  for (let i = 0; i < s.length; i++) {
-    const c = s.charCodeAt(i)
-    bytes.push(c & 0xff)
-  }
+  for (let i = 0; i < s.length; i++) bytes.push(s.charCodeAt(i) & 0xff)
   return bytes
 }
 
-// Create data bytes
-function createData(typeNumber: number, errorCorrectionLevel: number, dataList: { mode: number; data: string }[]): number[] {
-  const rsBlocks = getRSBlocks(typeNumber, errorCorrectionLevel)
-  const buffer = new BitBuffer()
+// Get length in bits for mode
+function getLengthInBits(mode: number, type: number): number {
+  if (type < 10) return mode === 4 ? 8 : 8
+  if (type < 27) return mode === 4 ? 16 : 10
+  return mode === 4 ? 16 : 12
+}
 
-  // Add data
-  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)
+// Polynomial multiplication
+function multiplyPolynomials(a: number[], b: number[]): number[] {
+  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]))
     }
   }
+  return result
+}
 
-  // Calc total data count
-  let totalDataCount = 0
-  for (const block of rsBlocks) {
-    totalDataCount += block.dataCount
+// Polynomial modulo
+function modPolynomial(a: number[], b: number[]): number[] {
+  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()
   }
+  return result
+}
 
-  if (buffer.getLengthInBits() > totalDataCount * 8) {
-    throw new Error('code length overflow')
+// Get error correction codewords
+function getErrorCorrectPolynomial(errorCorrectLength: number): number[] {
+  let poly = [1]
+  for (let i = 0; i < errorCorrectLength; i++) {
+    poly = multiplyPolynomials(poly, [1, gexp(i)])
   }
+  return poly
+}
 
-  // End code
-  if (buffer.getLengthInBits() + 4 <= totalDataCount * 8) {
-    buffer.put(0, 4)
-  }
+// Create data bytes with error correction
+function createData(typeNumber: number, errorCorrectionLevel: number, data: string): number[] {
+  const rsBlocks = getRSBlocks(typeNumber, errorCorrectionLevel)
 
-  // Padding to byte boundary
-  while (buffer.getLengthInBits() % 8 !== 0) {
-    buffer.putBit(false)
-  }
+  // Calculate total data count
+  let totalDataCount = 0
+  for (const block of rsBlocks) totalDataCount += block.dataCount
 
-  // Padding bytes
-  while (true) {
-    if (buffer.getLengthInBits() >= totalDataCount * 8) break
-    buffer.put(PAD0, 8)
-    if (buffer.getLengthInBits() >= totalDataCount * 8) break
-    buffer.put(PAD1, 8)
-  }
+  const buffer = new BitBuffer()
 
-  return createBytes(buffer, rsBlocks)
-}
+  // Mode indicator (4 = byte mode)
+  buffer.put(4, 4)
 
-// Create bytes with error correction
-function createBytes(buffer: BitBuffer, rsBlocks: { totalCount: number; dataCount: number }[]): number[] {
-  let offset = 0
-  let maxDcCount = 0
-  let maxEcCount = 0
+  // Character count
+  const bytes = stringToBytes(data)
+  buffer.put(bytes.length, getLengthInBits(4, typeNumber))
 
-  const dcdata: number[][] = []
-  const ecdata: number[][] = []
+  // Data
+  for (const byte of bytes) buffer.put(byte, 8)
 
-  for (const block of rsBlocks) {
-    const dcCount = block.dataCount
-    const ecCount = block.totalCount - dcCount
+  // Terminator
+  if (buffer.getLengthInBits() + 4 <= totalDataCount * 8) buffer.put(0, 4)
 
-    maxDcCount = Math.max(maxDcCount, dcCount)
-    maxEcCount = Math.max(maxEcCount, ecCount)
+  // Pad to byte boundary
+  while (buffer.getLengthInBits() % 8 !== 0) buffer.putBit(false)
 
-    const dc: number[] = []
-    for (let i = 0; i < dcCount; i++) {
-      dc.push(0xff & buffer.getBuffer()[i + offset])
-    }
-    dcdata.push(dc)
-    offset += dcCount
+  // Padding bytes
+  let padIndex = 0
+  const padBytes = [PAD0, PAD1]
+  while (buffer.getLengthInBits() < totalDataCount * 8) {
+    buffer.put(padBytes[padIndex], 8)
+    padIndex = (padIndex + 1) % 2
+  }
+
+  // Create data and EC codewords
+  const dataBuffer = buffer.getBuffer()
+  let dataIndex = 0
+  const dcData: number[][] = []
+  const ecData: number[][] = []
+
+  for (const block of rsBlocks) {
+    const dc = dataBuffer.slice(dataIndex, dataIndex + block.dataCount)
+    dataIndex += block.dataCount
+    dcData.push(dc)
 
-    // Generate error correction
+    const ecCount = block.totalCount - block.dataCount
     const rsPoly = getErrorCorrectPolynomial(ecCount)
-    const rawPoly = createPolynomial(dc, rsPoly.getLength() - 1)
-    const modPoly = rawPoly.mod(rsPoly)
 
-    const ec: number[] = 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)
+    // Pad data polynomial
+    const dataPoly = [...dc, ...new Array(ecCount).fill(0)]
+    const ec = modPolynomial(dataPoly, rsPoly)
+
+    ecData.push(ec.slice(-ecCount))
   }
 
-  // Interleave
+  // Interleave data codewords
   const result: number[] = []
+  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
 }
 
-// QR Code class
-class QRCode {
-  private typeNumber: number
-  private errorCorrectionLevel: number
-  private modules: (boolean | null)[][] = []
-  private moduleCount = 0
-  private dataCache: number[] | null = null
-
-  constructor(typeNumber: number, errorCorrectionLevel: string) {
-    this.typeNumber = typeNumber
-    this.errorCorrectionLevel = QRErrorCorrectionLevel[errorCorrectionLevel]
-  }
+// Main QR Code generator
+function generateQRCode(text: string, errorLevel: string): { modules: boolean[][]; moduleCount: number } {
+  const ecl = QRErrorCorrectionLevel[errorLevel] ?? 0
 
-  addData(data: string) {
-    const dataList = [{ mode: 4, data }] // 4 = 8BIT_BYTE mode
-    this.dataCache = createData(this.typeNumber, this.errorCorrectionLevel, dataList)
-  }
-
-  make() {
-    if (this.typeNumber < 1) {
-      // Auto detect type number
-      let typeNumber = 1
-      for (; typeNumber < 40; typeNumber++) {
-        try {
-          const testData = createData(typeNumber, this.errorCorrectionLevel, [{ mode: 4, data: 'test' }])
-          // Just check if it works
-          this.dataCache = createData(typeNumber, this.errorCorrectionLevel, [{ mode: 4, data: '' }])
-          break
-        } catch {
-          continue
-        }
-      }
-      this.typeNumber = typeNumber
-      // Recreate data cache with correct type number
-      const dataList = [{ mode: 4, data: '' }]
-      // We'll set data again below
-    }
-
-    this.makeImpl(false, this.getBestMaskPattern())
-  }
+  // Find minimum version
+  let typeNumber = 1
+  for (; typeNumber <= 40; typeNumber++) {
+    const rsBlocks = getRSBlocks(typeNumber, ecl)
+    let totalDataCount = 0
+    for (const block of rsBlocks) totalDataCount += block.dataCount
 
-  private getBestMaskPattern(): number {
-    let minLostPoint = 0
-    let pattern = 0
+    // Byte mode: 4 (mode) + length bits + data bits
+    const lengthBits = typeNumber < 10 ? 8 : 16
+    const totalBits = 4 + lengthBits + (stringToBytes(text).length * 8)
 
-    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
+    if (totalBits <= totalDataCount * 8) break
   }
 
-  private makeImpl(test: boolean, maskPattern: number) {
-    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)
-    }
+  const size = typeNumber * 4 + 17
+  const data = createData(typeNumber, ecl, text)
 
-    this.setupPositionProbePattern(0, 0)
-    this.setupPositionProbePattern(this.moduleCount - 7, 0)
-    this.setupPositionProbePattern(0, this.moduleCount - 7)
-    this.setupPositionAdjustPattern()
-    this.setupTimingPattern()
-    this.setupTypeInfo(test, maskPattern)
+  // Initialize modules
+  const mod: (boolean | null)[][] = []
+  for (let i = 0; i < size; i++) mod[i] = new Array(size).fill(null)
 
-    if (this.typeNumber >= 7) {
-      this.setupTypeNumber(test)
-    }
-
-    if (this.dataCache === null) {
-      throw new Error('dataCache is null')
-    }
-
-    this.mapData(this.dataCache, maskPattern)
-  }
-
-  private setupPositionProbePattern(row: number, col: number) {
+  // Setup finder patterns
+  const setupFinderPattern = (row: number, col: number) => {
     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
         }
       }
     }
   }
 
-  private 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
-    }
+  setupFinderPattern(0, 0)
+  setupFinderPattern(size - 7, 0)
+  setupFinderPattern(0, size - 7)
+
+  // Setup timing patterns
+  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
   }
 
-  private 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
-            }
-          }
+  // Setup alignment patterns
+  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)
         }
       }
     }
   }
 
-  private setupTypeNumber(test: boolean) {
-    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
-    }
+  // Setup format info area (reserved)
+  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
+  }
+  // Dark module
+  mod[size - 8][8] = true
 
-  private setupTypeInfo(test: boolean, maskPattern: number) {
-    const data = (this.errorCorrectionLevel << 3) | maskPattern
-    const bits = getBCHTypeInfo(data)
-
-    // Vertical
-    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
+  // Setup type number (version 7+)
+  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
       }
     }
+  }
 
-    // Horizontal
-    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
-      }
-    }
+  // Map data with best mask
+  let bestMask = 0
+  let bestPenalty = Infinity
 
-    // Fixed module
-    this.modules[this.moduleCount - 8][8] = !test
+  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
+    }
   }
 
-  private mapData(data: number[], maskPattern: number) {
-    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
-            }
-          }
-        }
+  // Apply best mask
+  mapData(mod, size, data, bestMask)
 
-        row += inc
-        if (row < 0 || this.moduleCount <= row) {
-          row -= inc
-          inc = -inc
-          break
-        }
-      }
+  // Write format info
+  const formatData = (ecl << 3) | bestMask
+  const formatBits = getBCHTypeInfo(formatData)
+
+  // Write format bits
+  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
+
+  // Convert to boolean matrix
+  const result: boolean[][] = []
+  for (let r = 0; r < size; r++) {
+    result[r] = []
+    for (let c = 0; c < size; c++) {
+      result[r][c] = mod[r][c] === true
     }
   }
 
-  private getLostPoint(): number {
-    let lostPoint = 0
-
-    // LEVEL1
-    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 }
+}
+
+// Map data to modules
+function mapData(mod: (boolean | null)[][], size: number, data: number[], maskPattern: number) {
+  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
       }
-    }
 
-    // LEVEL2
-    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
       }
     }
+  }
+}
 
-    // LEVEL3
-    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
-        }
-      }
-    }
+// Calculate penalty score
+function calculatePenalty(mod: (boolean | null)[][], size: number): number {
+  let penalty = 0
 
-    // LEVEL4
-    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++
+  // Rule 1: Adjacent modules in row/column
+  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
+    if (count >= 5) penalty += 3 + (count - 5)
   }
 
-  getModuleCount(): number {
-    return this.moduleCount
-  }
-
-  isDark(row: number, col: number): boolean {
-    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
 }
 
 // Generate QR code
@@ -776,22 +528,9 @@ const generate = () => {
   }
 
   try {
-    const qr = new QRCode(0, props.errorCorrectLevel)
-    qr.addData(props.value)
-    qr.make()
-
-    const count = qr.getModuleCount()
-    moduleCount.value = count
-
-    const result: boolean[][] = []
-    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 = []