@qr-render/qrcode-cli 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OctaEDLP00
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# QRCodeCLI

package/dist/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OctaEDLP00
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/README.md

@@ -0,0 +1 @@
+# QRCodeCLI

package/dist/cli.js

@@ -0,0 +1,839 @@
+#!/usr/bin/env node
+
+// src/libs/QRMath.ts
+var QRMath = {
+  /**
+   *
+   * @param n
+   * @returns number
+   */
+  glog: (n) => {
+    if (n < 1) throw new Error(`glog(${n}): ${QRMath.glog(n)}`);
+    return LOG_TABLE[n];
+  },
+  /**
+   *
+   * @param n
+   * @returns number
+   */
+  gexp: (n) => {
+    while (n < 0) n += 255;
+    while (n >= 256) n -= 255;
+    return EXP_TABLE[n];
+  }
+};
+var EXP_TABLE = new Array(256);
+var LOG_TABLE = new Array(256);
+(function initTables() {
+  let x = 1;
+  for (let i = 0; i < 256; i++) {
+    EXP_TABLE[i] = x;
+    LOG_TABLE[x] = i;
+    x <<= 1;
+    if (x & 256) x ^= 285;
+  }
+})();
+
+// src/libs/QRPolynomial.ts
+var QRPolynomial = class _QRPolynomial {
+  num;
+  /**
+   *
+   * @param num
+   * @param shift
+   */
+  constructor(num, shift) {
+    let offset = 0;
+    while (offset < num.length && num[offset] === 0) {
+      offset++;
+    }
+    this.num = new Array(num.length - offset + shift).fill(0);
+    for (let i = 0; i < num.length - offset; i++) {
+      this.num[i] = num[i + offset];
+    }
+  }
+  /**
+   *
+   * @param index
+   * @returns number
+   */
+  get(index) {
+    return this.num[index];
+  }
+  /**
+   *
+   * @returns number
+   */
+  getLength() {
+    return this.num.length;
+  }
+  /**
+   * Multiply the current polynomial by another.
+   * @param e
+   * @returns QRPolynomial
+   */
+  multiply(e) {
+    const num = new Array(this.getLength() + e.getLength() - 1).fill(0);
+    for (let i = 0; i < this.getLength(); i++) {
+      for (let j = 0; j < e.getLength(); j++) {
+        num[i + j] ^= QRMath.gexp(QRMath.glog(this.get(i)) + QRMath.glog(e.get(j)));
+      }
+    }
+    return new _QRPolynomial(num, 0);
+  }
+  /**
+   * Calculate the remainder of the division (modulo) to obtain the correction bytes.
+   * @returns QRPolynomial
+   */
+  mod(e) {
+    if (this.getLength() - e.getLength() < 0) {
+      return this;
+    }
+    const ratio = QRMath.glog(this.get(0)) - QRMath.glog(e.get(0));
+    const num = [...this.num];
+    for (let i = 0; i < e.getLength(); i++) {
+      num[i] ^= QRMath.gexp(QRMath.glog(e.get(i)) + ratio);
+    }
+    return new _QRPolynomial(num, 0).mod(e);
+  }
+};
+
+// src/core/QRBitBuffer.ts
+var QRBitBuffer = class {
+  buffer = [];
+  length = 0;
+  /**
+   *
+   * @param index
+   * @returns
+   */
+  get(index) {
+    const bufIndex = Math.floor(index / 8);
+    return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) === 1;
+  }
+  /**
+   *
+   * @param num
+   * @param length
+   */
+  put(num, length) {
+    for (let i = 0; i < length; i++) {
+      this.putBit((num >>> length - i - 1 & 1) === 1);
+    }
+  }
+  /**
+   *
+   * @param bit
+   * @returns
+   */
+  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;
+    }
+    this.length++;
+  }
+  /**
+   *
+   * @returns
+   */
+  getLengthInBits() {
+    return this.length;
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+};
+
+// src/core/QRRSBlock.ts
+var QRRSBlock = class _QRRSBlock {
+  /**
+   *
+   * @param totalCount
+   * @param dataCount
+   */
+  constructor(totalCount, dataCount) {
+    this.totalCount = totalCount;
+    this.dataCount = dataCount;
+  }
+  /**
+   *
+   * @param typeNumber
+   * @param errorCorrectLevel
+   * @returns
+   */
+  static getRSBlocks(typeNumber, errorCorrectLevel) {
+    const rsBlock = _QRRSBlock.getRsBlockTable(typeNumber, errorCorrectLevel);
+    if (!rsBlock)
+      throw new Error(
+        `bad rs block @ typeNumber:${typeNumber}/errorCorrectLevel:${errorCorrectLevel}`
+      );
+    const length = rsBlock.length / 3;
+    const list = [];
+    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(new _QRRSBlock(totalCount, dataCount));
+      }
+    }
+    return list;
+  }
+  /**
+   *
+   * @param typeNumber
+   * @param errorCorrectLevel
+   * @returns
+   */
+  static getRsBlockTable(typeNumber, errorCorrectLevel) {
+    switch (errorCorrectLevel) {
+      case 1:
+        return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 0];
+      // L
+      case 0:
+        return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 1];
+      // M
+      case 3:
+        return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 2];
+      // Q
+      case 2:
+        return RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 3];
+    }
+    return void 0;
+  }
+};
+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 RS_BLOCK_TABLE = [
+  // Version 1
+  [1, 26, 19],
+  [1, 26, 16],
+  [1, 26, 13],
+  [1, 26, 9],
+  // Version 2
+  [1, 44, 34],
+  [1, 44, 28],
+  [1, 44, 22],
+  [1, 44, 16],
+  // Version 3
+  [1, 70, 55],
+  [1, 70, 44],
+  [2, 35, 17],
+  [2, 35, 13],
+  // Version 4
+  [1, 100, 80],
+  [2, 50, 32],
+  [2, 50, 24],
+  [4, 25, 9],
+  // Version 5
+  [1, 134, 108],
+  [2, 67, 43],
+  [2, 33, 15, 2, 34, 16],
+  [2, 33, 11, 2, 34, 12],
+  // Version 6
+  [2, 86, 68],
+  [4, 43, 27],
+  [4, 43, 19],
+  [4, 43, 15],
+  // Version 7
+  [2, 98, 78],
+  [4, 49, 31],
+  [2, 32, 14, 4, 33, 15],
+  [4, 39, 13, 1, 40, 14],
+  // Version 8
+  [2, 121, 97],
+  [2, 60, 38, 2, 61, 39],
+  [4, 40, 18, 2, 41, 19],
+  [4, 40, 14, 2, 41, 15],
+  // Version 9
+  [2, 146, 116],
+  [3, 58, 36, 2, 59, 37],
+  [4, 36, 16, 4, 37, 17],
+  [4, 36, 12, 4, 37, 13],
+  // Version 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]
+  // ... Para un soporte completo hasta V40, esta tabla continua, pero V1-10 cubre el 99% de usos web.
+];
+
+// src/core/QRCodeModel.ts
+var QRCodeModel = class {
+  /**
+   *
+   * @param typeNumber
+   * @param errorCorrectLevel
+   */
+  constructor(typeNumber, errorCorrectLevel) {
+    this.typeNumber = typeNumber;
+    this.errorCorrectLevel = errorCorrectLevel;
+    this.moduleCount = 0;
+  }
+  moduleCount;
+  modules = [];
+  dataCache = null;
+  dataList = [];
+  /**
+   *
+   * @param data
+   */
+  addData(data) {
+    this.dataList.push(data);
+    this.dataCache = null;
+  }
+  /**
+   *
+   * @param row
+   * @param col
+   * @returns
+   */
+  isDark(row, col) {
+    if (row < 0 || this.moduleCount <= row || col < 0 || this.moduleCount <= col) {
+      throw new Error(`Coordinates out of bounds: ${row},${col}`);
+    }
+    return this.modules[row][col] === true;
+  }
+  /**
+   *
+   * @returns
+   */
+  getModuleCount() {
+    return this.moduleCount;
+  }
+  /**
+   *
+   */
+  make() {
+    this.makeImpl(false, this.getBestMaskPattern());
+  }
+  /**
+   *
+   * @param test
+   * @param maskPattern
+   */
+  makeImpl(test, maskPattern) {
+    this.moduleCount = this.typeNumber * 4 + 17;
+    this.modules = Array.from(
+      { length: this.moduleCount },
+      () => 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) {
+      this.dataCache = this.createData(this.typeNumber, this.errorCorrectLevel, this.dataList);
+    }
+    this.mapData(this.dataCache, maskPattern);
+  }
+  /**
+   *
+   * @returns
+   */
+  getBestMaskPattern() {
+    let minPenalty = 0;
+    let bestPattern = 0;
+    for (let i = 0; i < 8; i++) {
+      this.makeImpl(true, i);
+      const penalty = this.getPenaltyScore();
+      if (i === 0 || penalty < minPenalty) {
+        minPenalty = penalty;
+        bestPattern = i;
+      }
+    }
+    return bestPattern;
+  }
+  /**
+   *
+   * @param row
+   * @param col
+   */
+  setupPositionProbePattern(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;
+        } else {
+          this.modules[row + r][col + c] = 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 = QRUtil.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;
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   *
+   * @param test
+   */
+  setupTypeNumber(test) {
+    const bits = QRUtil.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;
+      this.modules[i % 3 + this.moduleCount - 8 - 3][Math.floor(i / 3)] = mod;
+    }
+  }
+  /**
+   *
+   * @param test
+   * @param maskPattern
+   */
+  setupTypeInfo(test, maskPattern) {
+    const data = this.errorCorrectLevel << 3 | maskPattern;
+    const bits = QRUtil.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;
+      }
+      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;
+      }
+    }
+    this.modules[this.moduleCount - 8][8] = !test;
+  }
+  /**
+   *
+   * @param data
+   * @param maskPattern
+   */
+  mapData(data, maskPattern) {
+    let inc = -1;
+    let row = this.moduleCount - 1;
+    let bitIndex = 7;
+    let byteIndex = 0;
+    for (let col = this.moduleCount - 1; col > 0; col -= 2) {
+      if (col === 6) col--;
+      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 = QRUtil.getMask(maskPattern, 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;
+        }
+      }
+    }
+  }
+  /**
+   *
+   * @param typeNumber
+   * @param errorCorrectLevel
+   * @param dataList
+   * @returns
+   */
+  createData(typeNumber, errorCorrectLevel, dataList) {
+    const rsBlocks = QRRSBlock.getRSBlocks(typeNumber, errorCorrectLevel);
+    const buffer = new QRBitBuffer();
+    for (const data of dataList) {
+      buffer.put(4, 4);
+      buffer.put(data.length, QRUtil.getLengthInBits(4, typeNumber) || 8);
+      for (let i = 0; i < data.length; i++) {
+        buffer.put(data.charCodeAt(i), 8);
+      }
+    }
+    let totalDataCount = 0;
+    for (const block of rsBlocks) {
+      totalDataCount += block.dataCount;
+    }
+    if (buffer.getLengthInBits() > totalDataCount * 8) {
+      throw new Error(`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(236, 8);
+      if (buffer.getLengthInBits() >= totalDataCount * 8) break;
+      buffer.put(17, 8);
+    }
+    return this.createBytes(buffer, rsBlocks);
+  }
+  /**
+   *
+   * @param buffer
+   * @param rsBlocks
+   * @returns
+   */
+  createBytes(buffer, rsBlocks) {
+    let offset = 0;
+    let maxDcCount = 0;
+    let maxEcCount = 0;
+    const dcdata = new Array(rsBlocks.length);
+    const ecdata = new Array(rsBlocks.length);
+    for (let r = 0; r < rsBlocks.length; r++) {
+      const dcCount = rsBlocks[r].dataCount;
+      const ecCount = rsBlocks[r].totalCount - dcCount;
+      maxDcCount = Math.max(maxDcCount, dcCount);
+      maxEcCount = Math.max(maxEcCount, ecCount);
+      dcdata[r] = new Array(dcCount);
+      for (let i = 0; i < dcdata[r].length; i++) {
+        dcdata[r][i] = 255 & buffer.getBuffer()[i + offset];
+      }
+      offset += dcCount;
+      const rsPoly = QRUtil.getErrorCorrectPolynomial(ecCount);
+      const rawPoly = new QRPolynomial(dcdata[r], rsPoly.getLength() - 1);
+      const modPoly = rawPoly.mod(rsPoly);
+      ecdata[r] = new Array(rsPoly.getLength() - 1);
+      for (let i = 0; i < ecdata[r].length; i++) {
+        const modIndex = i + modPoly.getLength() - ecdata[r].length;
+        ecdata[r][i] = modIndex >= 0 ? modPoly.get(modIndex) : 0;
+      }
+    }
+    let totalCodeCount = 0;
+    for (const block of rsBlocks) {
+      totalCodeCount += block.totalCount;
+    }
+    const data = new Array(totalCodeCount);
+    let index = 0;
+    for (let i = 0; i < maxDcCount; i++) {
+      for (let r = 0; r < rsBlocks.length; r++) {
+        if (i < dcdata[r].length) {
+          data[index++] = dcdata[r][i];
+        }
+      }
+    }
+    for (let i = 0; i < maxEcCount; i++) {
+      for (let r = 0; r < rsBlocks.length; r++) {
+        if (i < ecdata[r].length) {
+          data[index++] = ecdata[r][i];
+        }
+      }
+    }
+    return data;
+  }
+  /**
+   *
+   * @returns number
+   */
+  getPenaltyScore() {
+    let score = 0;
+    for (let row = 0; row < this.moduleCount; row++) {
+      for (let col = 0; col < this.moduleCount; col++) {
+        let sameCount = 0;
+        let dark = this.isDark(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.isDark(row + r, col + c)) sameCount++;
+          }
+        }
+        if (sameCount > 5) score += 3 + sameCount - 5;
+      }
+    }
+    for (let row = 0; row < this.moduleCount - 1; row++) {
+      for (let col = 0; col < this.moduleCount - 1; col++) {
+        const count = (this.isDark(row, col) ? 1 : 0) + (this.isDark(row + 1, col) ? 1 : 0) + (this.isDark(row, col + 1) ? 1 : 0) + (this.isDark(row + 1, col + 1) ? 1 : 0);
+        if (count === 0 || count === 4) score += 3;
+      }
+    }
+    let darkCount = 0;
+    for (let row = 0; row < this.moduleCount; row++) {
+      for (let col = 0; col < this.moduleCount; col++) {
+        if (this.isDark(row, col)) darkCount++;
+      }
+    }
+    const ratio = Math.abs(100 * darkCount / this.moduleCount / this.moduleCount - 50) / 5;
+    score += ratio * 10;
+    return score;
+  }
+};
+var QRUtil = {
+  getBCHTypeInfo(data) {
+    let d = data << 10;
+    while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(1335) >= 0) {
+      d ^= 1335 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(1335);
+    }
+    return (data << 10 | d) ^ 21522;
+  },
+  getBCHTypeNumber(data) {
+    let d = data << 12;
+    while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(7973) >= 0) {
+      d ^= 7973 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(7973);
+    }
+    return data << 12 | d;
+  },
+  getBCHDigit(data) {
+    let digit = 0;
+    while (data !== 0) {
+      digit++;
+      data >>>= 1;
+    }
+    return digit;
+  },
+  getPatternPosition(typeNumber) {
+    return PATTERN_POSITION_TABLE[typeNumber - 1];
+  },
+  getMask(maskPattern, i, j) {
+    switch (maskPattern) {
+      case 0:
+        return (i + j) % 2 === 0;
+      case 1:
+        return i % 2 === 0;
+      case 2:
+        return j % 3 === 0;
+      case 3:
+        return (i + j) % 3 === 0;
+      case 4:
+        return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;
+      case 5:
+        return i * j % 2 + i * j % 3 === 0;
+      case 6:
+        return (i * j % 2 + i * j % 3) % 2 === 0;
+      case 7:
+        return (i * j % 3 + (i + j) % 2) % 2 === 0;
+      default:
+        throw new Error(`bad maskPattern: ${maskPattern}`);
+    }
+  },
+  getErrorCorrectPolynomial(errorCorrectLength) {
+    let a = new QRPolynomial([1], 0);
+    for (let i = 0; i < errorCorrectLength; i++) {
+      a = a.multiply(new QRPolynomial([1, QRMath.gexp(i)], 0));
+    }
+    return a;
+  },
+  getLengthInBits(mode, type) {
+    if (1 <= type && type < 10) return 8;
+    if (type < 27) return 16;
+    if (type < 41) return 16;
+    return 0;
+  }
+};
+
+// src/renderer/ConsoleDrawing.ts
+var ConsoleDrawing = class {
+  _options;
+  /**
+   * @param {Required<QRCodeOptionCLI>} vOption
+   */
+  constructor(vOption) {
+    this._options = vOption;
+  }
+  /**
+   * Draws the QR Code in the terminal using Unicode blocks.
+   * @param model
+   */
+  draw(model) {
+    const moduleCount = model.getModuleCount();
+    const { quietZone } = this._options;
+    const BG_BLACK = "\x1B[40m";
+    const BG_WHITE = "\x1B[47m";
+    const RESET = "\x1B[0m";
+    let output = "\n";
+    for (let r = -quietZone; r < moduleCount + quietZone; r++) {
+      let line = "";
+      for (let c = -quietZone; c < moduleCount + quietZone; c++) {
+        const isInside = r >= 0 && r < moduleCount && c >= 0 && c < moduleCount;
+        const isDark = isInside && model.isDark(r, c);
+        if (isDark) {
+          line += `${BG_BLACK}  ${RESET}`;
+        } else {
+          line += `${BG_WHITE}  ${RESET}`;
+        }
+      }
+      output += line + "\n";
+    }
+    process.stdout.write(output + "\n");
+  }
+  /**
+   * Clears the terminal screen.
+   */
+  clear() {
+    process.stdout.write("\x1B[2J\x1B[0f");
+  }
+};
+
+// src/types/index.d.ts
+var QrErrorCorrectLevel = {
+  /**
+   * Low error correction.
+   * Allows up to ~7% data recovery.
+   */
+  L: 0,
+  /**
+   * Medium error correction.
+   * Allows up to ~15% data recovery.
+   */
+  M: 1,
+  /**
+   * Quartile error correction.
+   * Allows up to ~25% data recovery.
+   */
+  Q: 2,
+  /**
+   * High error correction.
+   * Allows up to ~30% data recovery.
+   */
+  H: 3
+};
+
+// src/cli.ts
+import { Command } from "commander";
+var getOptimalVersion = (data, level) => {
+  for (let v = 1; v <= 40; v++) {
+    try {
+      const testModel = new QRCodeModel(v, level);
+      testModel.addData(data);
+      testModel.make();
+      return v;
+    } catch (e) {
+      if (v === 40) throw new Error("Data too long for a standard QR Code.");
+      continue;
+    }
+  }
+  return 4;
+};
+var program = new Command();
+program.name("qrx").description("Professional QR Code generation in your terminal").version("1.0.0");
+program.argument("<text>", "Text or URL to encode").option("-s, --size <number>", "Scale factor (1, 2, 3...)", (v) => parseInt(v, 10), 1).option("-q, --quiet-zone <number>", "Quiet zone (padding)", (v) => parseInt(v, 10), 4).option("-l, --level <type>", "Error correction level (L, M, Q, H)", "M").option("--dark <color>", "ANSI for dark modules", "\x1B[40m  \x1B[0m").option("--light <color>", "ANSI for light modules", "\x1B[47m  \x1B[0m").action((text, options) => {
+  try {
+    const levelMap = {
+      L: QrErrorCorrectLevel.L,
+      M: QrErrorCorrectLevel.M,
+      Q: QrErrorCorrectLevel.Q,
+      H: QrErrorCorrectLevel.H
+    };
+    const selectedLevel = options.level.toUpperCase();
+    if (!(selectedLevel in levelMap)) {
+      throw new Error(`Invalid error level: ${options.level}. Use L, M, Q, or H.`);
+    }
+    const correctLevel = levelMap[selectedLevel] ?? "M";
+    const cliOptions = {
+      text,
+      quietZone: options.quietZone ?? 4,
+      correctLevel,
+      colorDark: options.dark,
+      colorLight: options.light,
+      size: options.size
+    };
+    const optimalVersion = getOptimalVersion(text, correctLevel);
+    const model = new QRCodeModel(optimalVersion, correctLevel);
+    model.addData(text);
+    model.make();
+    const terminal = new ConsoleDrawing(cliOptions);
+    terminal.draw(model);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : "Unknown error";
+    process.stderr.write(`\x1B[31m[ERROR]\x1B[0m ${msg}
+`);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@qr-render/qrcode-cli",
+  "version": "0.0.3",
+  "description": "",
+  "keywords": [
+    "builder",
+    "cli",
+    "installer",
+    "readline",
+    "typescript"
+  ],
+  "homepage": "https://github.com/OctaEDLP00/QrCodeCLI#readme",
+  "bugs": {
+    "url": "https://github.com/OctaEDLP00/QrCodeCLI/issues"
+  },
+  "license": "MIT",
+  "author": "OctaEDLP00",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OctaEDLP00/QrCodeCLI.git"
+  },
+  "bin": "dist/cli.js",
+  "files": [
+    "dist/cli.js",
+    "dist/README.md",
+    "dist/LICENSE",
+    "dist/package.json",
+    "dist/tsconfig.json"
+  ],
+  "type": "module",
+  "types": "./index.d.ts",
+  "scripts": {
+    "build": "tsup",
+    "lint": "oxlint src/**/*.ts",
+    "lint:fix": "oxlint src/**/*.ts --fix",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check",
+    "prepublishOnly": "pnpm run build && pnpm run test:run && pnpm run lint",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:run": "vitest run",
+    "test:ui": "vitest --ui",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "14.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "25.0.10",
+    "@vitest/coverage-v8": "4.0.18",
+    "@vitest/ui": "4.0.18",
+    "oxfmt": "^0.27.0",
+    "oxlint": "1.42.0",
+    "tsup": "8.5.1",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3",
+    "vitest": "4.0.18"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@qr-render/qrcode-cli",
+  "version": "0.0.3",
+  "description": "",
+  "keywords": [
+    "builder",
+    "cli",
+    "installer",
+    "readline",
+    "typescript"
+  ],
+  "homepage": "https://github.com/OctaEDLP00/QrCodeCLI#readme",
+  "bugs": {
+    "url": "https://github.com/OctaEDLP00/QrCodeCLI/issues"
+  },
+  "license": "MIT",
+  "author": "OctaEDLP00",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OctaEDLP00/QrCodeCLI.git"
+  },
+  "bin": "dist/cli.js",
+  "files": [
+    "dist/cli.js",
+    "dist/README.md",
+    "dist/LICENSE",
+    "dist/package.json",
+    "dist/tsconfig.json"
+  ],
+  "type": "module",
+  "types": "./index.d.ts",
+  "dependencies": {
+    "commander": "14.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "25.0.10",
+    "@vitest/coverage-v8": "4.0.18",
+    "@vitest/ui": "4.0.18",
+    "oxfmt": "^0.27.0",
+    "oxlint": "1.42.0",
+    "tsup": "8.5.1",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3",
+    "vitest": "4.0.18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "lint": "oxlint src/**/*.ts",
+    "lint:fix": "oxlint src/**/*.ts --fix",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:run": "vitest run",
+    "test:ui": "vitest --ui",
+    "type-check": "tsc --noEmit"
+  }
+}