@core-ease/telegram-kit 3.0.1

package/dist/qr/index.js

@@ -0,0 +1,983 @@
+'use strict';
+
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/_internal/qr/bitBuffer.ts
+var BitBuffer = class {
+  constructor() {
+    this.bits = [];
+  }
+  push(value, len) {
+    for (let i = len - 1; i >= 0; i--) {
+      this.bits.push(value >>> i & 1);
+    }
+  }
+  get length() {
+    return this.bits.length;
+  }
+  toCodewords() {
+    var _a;
+    const codewords = [];
+    for (let i = 0; i < this.bits.length; i += 8) {
+      let byte = 0;
+      for (let j = 0; j < 8; j++) {
+        byte = byte << 1 | ((_a = this.bits[i + j]) != null ? _a : 0);
+      }
+      codewords.push(byte);
+    }
+    return codewords;
+  }
+};
+
+// src/_internal/qr/galoisField.ts
+var EXP = new Uint8Array(512);
+var LOG = new Uint8Array(256);
+(function initTables() {
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    EXP[i] = x;
+    LOG[x] = i;
+    x <<= 1;
+    if (x & 256) x ^= 285;
+  }
+  for (let i = 255; i < 512; i++) EXP[i] = EXP[i - 255];
+})();
+function gfMultiply(a, b) {
+  if (a === 0 || b === 0) return 0;
+  return EXP[LOG[a] + LOG[b]];
+}
+function generatorPolynomial(degree) {
+  let poly = [1];
+  for (let i = 0; i < degree; i++) {
+    const next = new Array(poly.length + 1).fill(0);
+    for (let j = 0; j < poly.length; j++) {
+      next[j] ^= poly[j];
+      next[j + 1] ^= gfMultiply(poly[j], EXP[i]);
+    }
+    poly = next;
+  }
+  return poly;
+}
+
+// src/_internal/qr/reedSolomon.ts
+function reedSolomonEncode(dataCodewords, eccLength) {
+  const generator = generatorPolynomial(eccLength);
+  const result = dataCodewords.slice();
+  for (let i = 0; i < eccLength; i++) result.push(0);
+  for (let i = 0; i < dataCodewords.length; i++) {
+    const factor = result[i];
+    if (factor === 0) continue;
+    for (let j = 0; j < generator.length; j++) {
+      result[i + j] ^= gfMultiply(generator[j], factor);
+    }
+  }
+  return result.slice(dataCodewords.length);
+}
+
+// src/_internal/qr/tables.ts
+var ERROR_CORRECTION_LEVELS = ["L", "M", "Q", "H"];
+var FORMAT_EC_BITS = {
+  L: 1,
+  M: 0,
+  Q: 3,
+  H: 2
+};
+var ECC_CODEWORDS_PER_BLOCK = [
+  [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+  [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
+  [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+  [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]
+];
+var NUM_ERROR_CORRECTION_BLOCKS = [
+  [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],
+  [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
+  [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
+  [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81]
+];
+function levelIndex(level) {
+  return ERROR_CORRECTION_LEVELS.indexOf(level);
+}
+function symbolSize(version) {
+  return version * 4 + 17;
+}
+function getNumRawDataModules(version) {
+  let result = (16 * version + 128) * version + 64;
+  if (version >= 2) {
+    const numAlign = Math.floor(version / 7) + 2;
+    result -= (25 * numAlign - 10) * numAlign - 55;
+    if (version >= 7) result -= 36;
+  }
+  return result;
+}
+function getTotalCodewords(version) {
+  return Math.floor(getNumRawDataModules(version) / 8);
+}
+function getNumDataCodewords(version, level) {
+  const idx = levelIndex(level);
+  const eccLen = ECC_CODEWORDS_PER_BLOCK[idx][version];
+  const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[idx][version];
+  return getTotalCodewords(version) - eccLen * numBlocks;
+}
+function getBlockStructure(version, level) {
+  const idx = levelIndex(level);
+  return {
+    eccLength: ECC_CODEWORDS_PER_BLOCK[idx][version],
+    numBlocks: NUM_ERROR_CORRECTION_BLOCKS[idx][version]
+  };
+}
+function getAlignmentPatternPositions(version) {
+  if (version === 1) return [];
+  const numAlign = Math.floor(version / 7) + 2;
+  const step = Math.floor((version * 8 + numAlign * 3 + 5) / (numAlign * 4 - 4)) * 2;
+  const result = new Array(numAlign);
+  let pos = version * 4 + 10;
+  for (let i = numAlign - 1; i >= 1; i--, pos -= step) {
+    result[i] = pos;
+  }
+  result[0] = 6;
+  return result;
+}
+
+// src/_internal/qr/segments.ts
+var QR_MODE = {
+  NUMERIC: 1,
+  ALPHANUMERIC: 2,
+  BYTE: 4
+};
+var ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+function isNumeric(text) {
+  return /^[0-9]*$/.test(text);
+}
+function isAlphanumeric(text) {
+  for (const ch of text) {
+    if (ALPHANUMERIC_CHARSET.indexOf(ch) === -1) return false;
+  }
+  return true;
+}
+function chooseMode(text) {
+  if (isNumeric(text)) return QR_MODE.NUMERIC;
+  if (isAlphanumeric(text)) return QR_MODE.ALPHANUMERIC;
+  return QR_MODE.BYTE;
+}
+function toUtf8Bytes(text) {
+  return Array.from(new TextEncoder().encode(text));
+}
+function charCountBitLength(mode, version) {
+  if (version <= 9) {
+    return mode === QR_MODE.NUMERIC ? 10 : mode === QR_MODE.ALPHANUMERIC ? 9 : 8;
+  }
+  if (version <= 26) {
+    return mode === QR_MODE.NUMERIC ? 12 : mode === QR_MODE.ALPHANUMERIC ? 11 : 16;
+  }
+  return mode === QR_MODE.NUMERIC ? 14 : mode === QR_MODE.ALPHANUMERIC ? 13 : 16;
+}
+function segmentCharacterCount(mode, text) {
+  return mode === QR_MODE.BYTE ? toUtf8Bytes(text).length : text.length;
+}
+function encodeSegmentBits(mode, text, bb) {
+  if (mode === QR_MODE.NUMERIC) {
+    for (let i = 0; i < text.length; i += 3) {
+      const chunk = text.substring(i, i + 3);
+      const bitsForLen = chunk.length === 3 ? 10 : chunk.length === 2 ? 7 : 4;
+      bb.push(parseInt(chunk, 10), bitsForLen);
+    }
+  } else if (mode === QR_MODE.ALPHANUMERIC) {
+    for (let i = 0; i < text.length; i += 2) {
+      if (i + 1 < text.length) {
+        const value = ALPHANUMERIC_CHARSET.indexOf(text[i]) * 45 + ALPHANUMERIC_CHARSET.indexOf(text[i + 1]);
+        bb.push(value, 11);
+      } else {
+        bb.push(ALPHANUMERIC_CHARSET.indexOf(text[i]), 6);
+      }
+    }
+  } else {
+    for (const byte of toUtf8Bytes(text)) bb.push(byte, 8);
+  }
+}
+
+// src/_internal/qr/dataCodewords.ts
+function buildDataCodewords(text, version, level, mode) {
+  const bb = new BitBuffer();
+  bb.push(mode, 4);
+  bb.push(segmentCharacterCount(mode, text), charCountBitLength(mode, version));
+  encodeSegmentBits(mode, text, bb);
+  const capacityBits = getNumDataCodewords(version, level) * 8;
+  if (bb.length > capacityBits) return null;
+  const terminatorLen = Math.min(4, capacityBits - bb.length);
+  bb.push(0, terminatorLen);
+  while (bb.length % 8 !== 0) bb.bits.push(0);
+  const padBytes = [236, 17];
+  let padIndex = 0;
+  while (bb.length < capacityBits) {
+    bb.push(padBytes[padIndex % 2], 8);
+    padIndex++;
+  }
+  return bb.toCodewords();
+}
+function splitIntoBlocksWithEcc(dataCodewords, version, level) {
+  const { eccLength, numBlocks } = getBlockStructure(version, level);
+  const totalData = dataCodewords.length;
+  const shortBlockLen = Math.floor(totalData / numBlocks);
+  const numLongBlocks = totalData % numBlocks;
+  const numShortBlocks = numBlocks - numLongBlocks;
+  const dataBlocks = [];
+  let offset = 0;
+  for (let i = 0; i < numShortBlocks; i++) {
+    dataBlocks.push(dataCodewords.slice(offset, offset + shortBlockLen));
+    offset += shortBlockLen;
+  }
+  for (let i = 0; i < numLongBlocks; i++) {
+    dataBlocks.push(dataCodewords.slice(offset, offset + shortBlockLen + 1));
+    offset += shortBlockLen + 1;
+  }
+  const eccBlocks = dataBlocks.map((block) => reedSolomonEncode(block, eccLength));
+  return { dataBlocks, eccBlocks };
+}
+function interleaveBlocks({ dataBlocks, eccBlocks }) {
+  const result = [];
+  const maxDataLen = Math.max(...dataBlocks.map((b) => b.length));
+  for (let i = 0; i < maxDataLen; i++) {
+    for (const block of dataBlocks) {
+      if (i < block.length) result.push(block[i]);
+    }
+  }
+  const eccLen = eccBlocks[0].length;
+  for (let i = 0; i < eccLen; i++) {
+    for (const block of eccBlocks) result.push(block[i]);
+  }
+  return result;
+}
+
+// src/_internal/qr/matrix.ts
+function createGrid(size) {
+  return Array.from({ length: size }, () => new Array(size).fill(false));
+}
+function drawFinderPattern(modules, isFunction, cx, cy) {
+  for (let dy = -3; dy <= 3; dy++) {
+    for (let dx = -3; dx <= 3; dx++) {
+      const x = cx + dx;
+      const y = cy + dy;
+      const ring = Math.max(Math.abs(dx), Math.abs(dy));
+      modules[y][x] = ring !== 2;
+      isFunction[y][x] = true;
+    }
+  }
+}
+function drawAlignmentPattern(modules, isFunction, cx, cy) {
+  for (let dy = -2; dy <= 2; dy++) {
+    for (let dx = -2; dx <= 2; dx++) {
+      const x = cx + dx;
+      const y = cy + dy;
+      const ring = Math.max(Math.abs(dx), Math.abs(dy));
+      modules[y][x] = ring !== 1;
+      isFunction[y][x] = true;
+    }
+  }
+}
+function drawFunctionPatterns(modules, isFunction, version) {
+  const size = modules.length;
+  drawFinderPattern(modules, isFunction, 3, 3);
+  drawFinderPattern(modules, isFunction, size - 4, 3);
+  drawFinderPattern(modules, isFunction, 3, size - 4);
+  const markSeparator = (x, y) => {
+    if (x >= 0 && x < size && y >= 0 && y < size) isFunction[y][x] = true;
+  };
+  for (let i = 0; i < 8; i++) {
+    markSeparator(7, i);
+    markSeparator(i, 7);
+    markSeparator(size - 8, i);
+    markSeparator(size - 1 - i, 7);
+    markSeparator(7, size - 1 - i);
+    markSeparator(i, size - 8);
+  }
+  for (let i = 8; i < size - 8; i++) {
+    modules[6][i] = i % 2 === 0;
+    isFunction[6][i] = true;
+    modules[i][6] = i % 2 === 0;
+    isFunction[i][6] = true;
+  }
+  const positions = getAlignmentPatternPositions(version);
+  for (const cy of positions) {
+    for (const cx of positions) {
+      const overlapsFinder = cx <= 8 && cy <= 8 || cx >= size - 9 && cy <= 8 || cx <= 8 && cy >= size - 9;
+      if (overlapsFinder) continue;
+      drawAlignmentPattern(modules, isFunction, cx, cy);
+    }
+  }
+  modules[size - 8][8] = true;
+  isFunction[size - 8][8] = true;
+  for (let i = 0; i < 9; i++) {
+    if (i !== 6) {
+      isFunction[8][i] = true;
+      isFunction[i][8] = true;
+    }
+  }
+  for (let i = 0; i < 8; i++) {
+    isFunction[8][size - 1 - i] = true;
+    isFunction[size - 1 - i][8] = true;
+  }
+  if (version >= 7) {
+    for (let i = 0; i < 6; i++) {
+      for (let j = 0; j < 3; j++) {
+        isFunction[size - 11 + j][i] = true;
+        isFunction[i][size - 11 + j] = true;
+      }
+    }
+  }
+}
+function placeDataBits(modules, isFunction, dataBits) {
+  const size = modules.length;
+  let bitIndex = 0;
+  let upward = true;
+  for (let right = size - 1; right >= 1; right -= 2) {
+    if (right === 6) right = 5;
+    for (let vert = 0; vert < size; vert++) {
+      const y = upward ? size - 1 - vert : vert;
+      for (let j = 0; j < 2; j++) {
+        const x = right - j;
+        if (isFunction[y][x]) continue;
+        if (bitIndex < dataBits.length) {
+          modules[y][x] = dataBits[bitIndex] === 1;
+          bitIndex++;
+        }
+      }
+    }
+    upward = !upward;
+  }
+}
+function applyMask(modules, isFunction, maskId) {
+  const size = modules.length;
+  const out = createGrid(size);
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      out[y][x] = modules[y][x];
+      if (isFunction[y][x]) continue;
+      let invert;
+      switch (maskId) {
+        case 0:
+          invert = (x + y) % 2 === 0;
+          break;
+        case 1:
+          invert = y % 2 === 0;
+          break;
+        case 2:
+          invert = x % 3 === 0;
+          break;
+        case 3:
+          invert = (x + y) % 3 === 0;
+          break;
+        case 4:
+          invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
+          break;
+        case 5:
+          invert = x * y % 2 + x * y % 3 === 0;
+          break;
+        case 6:
+          invert = (x * y % 2 + x * y % 3) % 2 === 0;
+          break;
+        case 7:
+          invert = ((x + y) % 2 + x * y % 3) % 2 === 0;
+          break;
+        default:
+          invert = false;
+      }
+      if (invert) out[y][x] = !out[y][x];
+    }
+  }
+  return out;
+}
+var FINDER_PENALTY_PATTERN_A = [true, false, true, true, true, false, true, false, false, false, false];
+var FINDER_PENALTY_PATTERN_B = [false, false, false, false, true, false, true, true, true, false, true];
+function matchesFinderPenaltyPattern(bits) {
+  const eq = (pattern) => pattern.every((v, i) => v === bits[i]);
+  return eq(FINDER_PENALTY_PATTERN_A) || eq(FINDER_PENALTY_PATTERN_B);
+}
+function computeMaskPenalty(modules) {
+  const size = modules.length;
+  let penalty = 0;
+  const runPenalty = (getCell) => {
+    let p = 0;
+    for (let i = 0; i < size; i++) {
+      let runColor = null;
+      let runLen = 0;
+      for (let j = 0; j < size; j++) {
+        const c = getCell(i, j);
+        if (c === runColor) {
+          runLen++;
+        } else {
+          if (runLen >= 5) p += 3 + (runLen - 5);
+          runColor = c;
+          runLen = 1;
+        }
+      }
+      if (runLen >= 5) p += 3 + (runLen - 5);
+    }
+    return p;
+  };
+  penalty += runPenalty((r, c) => modules[r][c]);
+  penalty += runPenalty((r, c) => modules[c][r]);
+  for (let y = 0; y < size - 1; y++) {
+    for (let x = 0; x < size - 1; x++) {
+      const v = modules[y][x];
+      if (v === modules[y][x + 1] && v === modules[y + 1][x] && v === modules[y + 1][x + 1]) {
+        penalty += 3;
+      }
+    }
+  }
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x <= size - 11; x++) {
+      const bits = [];
+      for (let k = 0; k < 11; k++) bits.push(modules[y][x + k]);
+      if (matchesFinderPenaltyPattern(bits)) penalty += 40;
+    }
+  }
+  for (let x = 0; x < size; x++) {
+    for (let y = 0; y <= size - 11; y++) {
+      const bits = [];
+      for (let k = 0; k < 11; k++) bits.push(modules[y + k][x]);
+      if (matchesFinderPenaltyPattern(bits)) penalty += 40;
+    }
+  }
+  let dark = 0;
+  for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) if (modules[y][x]) dark++;
+  const percentDark = dark * 100 / (size * size);
+  penalty += Math.floor(Math.abs(percentDark - 50) / 5) * 10;
+  return penalty;
+}
+function computeFormatBits(level, maskId) {
+  const data = FORMAT_EC_BITS[level] << 3 | maskId;
+  const GENERATOR = 1335;
+  let remainder = data << 10;
+  for (let i = 14; i >= 10; i--) {
+    if ((remainder & 1 << i) !== 0) remainder ^= GENERATOR << i - 10;
+  }
+  return (data << 10 | remainder) ^ 21522;
+}
+function computeVersionBits(version) {
+  const GENERATOR = 7973;
+  let remainder = version << 12;
+  for (let i = 17; i >= 12; i--) {
+    if ((remainder & 1 << i) !== 0) remainder ^= GENERATOR << i - 12;
+  }
+  return version << 12 | remainder;
+}
+function drawFormatInfo(modules, level, maskId) {
+  const size = modules.length;
+  const bits = computeFormatBits(level, maskId);
+  const bitAt = (k) => (bits >> k & 1) === 1;
+  const group1 = [
+    [8, 0],
+    [8, 1],
+    [8, 2],
+    [8, 3],
+    [8, 4],
+    [8, 5],
+    [8, 7],
+    [8, 8],
+    [7, 8],
+    [5, 8],
+    [4, 8],
+    [3, 8],
+    [2, 8],
+    [1, 8],
+    [0, 8]
+  ];
+  for (let k = 0; k < 15; k++) {
+    const [r, c] = group1[k];
+    modules[r][c] = bitAt(14 - k);
+  }
+  const group2 = [
+    [size - 1, 8],
+    [size - 2, 8],
+    [size - 3, 8],
+    [size - 4, 8],
+    [size - 5, 8],
+    [size - 6, 8],
+    [size - 7, 8],
+    [8, size - 8],
+    [8, size - 7],
+    [8, size - 6],
+    [8, size - 5],
+    [8, size - 4],
+    [8, size - 3],
+    [8, size - 2],
+    [8, size - 1]
+  ];
+  for (let k = 0; k < 15; k++) {
+    const [r, c] = group2[k];
+    modules[r][c] = bitAt(14 - k);
+  }
+  modules[size - 8][8] = true;
+}
+function drawVersionInfo(modules, version) {
+  if (version < 7) return;
+  const size = modules.length;
+  const bits = computeVersionBits(version);
+  for (let i = 0; i < 18; i++) {
+    const bit = (bits >> i & 1) === 1;
+    const a = Math.floor(i / 3);
+    const b = i % 3;
+    modules[size - 11 + b][a] = bit;
+    modules[a][size - 11 + b] = bit;
+  }
+}
+
+// src/_internal/qr/encoder.ts
+var MIN_VERSION = 1;
+var MAX_VERSION = 40;
+function encodeQrMatrix(text, options = {}) {
+  var _a, _b, _c, _d, _e;
+  const level = (_a = options.errorCorrectionLevel) != null ? _a : "M";
+  const mode = chooseMode(text);
+  const minVersion = (_c = (_b = options.version) != null ? _b : options.minVersion) != null ? _c : MIN_VERSION;
+  const maxVersion = (_e = (_d = options.version) != null ? _d : options.maxVersion) != null ? _e : MAX_VERSION;
+  let version = null;
+  let dataCodewords = null;
+  for (let v = minVersion; v <= maxVersion; v++) {
+    const codewords = buildDataCodewords(text, v, level, mode);
+    if (codewords) {
+      version = v;
+      dataCodewords = codewords;
+      break;
+    }
+  }
+  if (version === null || dataCodewords === null) {
+    throw new Error(
+      `[@core-ease/telegram-kit] Unable to encode a QR code: the input is too long for error correction level "${level}"` + (options.version ? ` at version ${options.version}.` : " within the allowed version range.")
+    );
+  }
+  const blocked = splitIntoBlocksWithEcc(dataCodewords, version, level);
+  const allCodewords = interleaveBlocks(blocked);
+  const dataBits = [];
+  for (const codeword of allCodewords) {
+    for (let i = 7; i >= 0; i--) dataBits.push(codeword >> i & 1);
+  }
+  const size = symbolSize(version);
+  const modules = createGrid(size);
+  const isFunction = createGrid(size);
+  drawFunctionPatterns(modules, isFunction, version);
+  placeDataBits(modules, isFunction, dataBits);
+  let bestMask = 0;
+  let bestModules = modules;
+  if (typeof options.maskPattern === "number") {
+    bestMask = options.maskPattern;
+    bestModules = applyMask(modules, isFunction, bestMask);
+  } else {
+    let bestPenalty = Infinity;
+    for (let maskId = 0; maskId < 8; maskId++) {
+      const masked = applyMask(modules, isFunction, maskId);
+      const penalty = computeMaskPenalty(masked);
+      if (penalty < bestPenalty) {
+        bestPenalty = penalty;
+        bestMask = maskId;
+        bestModules = masked;
+      }
+    }
+  }
+  drawFormatInfo(bestModules, level, bestMask);
+  drawVersionInfo(bestModules, version);
+  return {
+    modules: bestModules,
+    size,
+    version,
+    errorCorrectionLevel: level,
+    maskPattern: bestMask
+  };
+}
+
+// src/_internal/qr/Qr.ts
+function encodeQRCode(text, options) {
+  return encodeQrMatrix(text, options);
+}
+function qrCodeToSVG(text, options = {}) {
+  const _a = options, { size = 512, color = "#000000", background = "#ffffff", quietZone = 4 } = _a, encodeOptions = __objRest(_a, ["size", "color", "background", "quietZone"]);
+  const { modules } = encodeQrMatrix(text, encodeOptions);
+  const dimension = modules.length + quietZone * 2;
+  const cell = size / dimension;
+  let path = "";
+  for (let y = 0; y < modules.length; y++) {
+    for (let x = 0; x < modules.length; x++) {
+      if (!modules[y][x]) continue;
+      const px = (x + quietZone) * cell;
+      const py = (y + quietZone) * cell;
+      path += `M${px} ${py}h${cell}v${cell}h${-cell}z`;
+    }
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}"><rect width="${size}" height="${size}" fill="${background}"/><path d="${path}" fill="${color}"/></svg>`;
+}
+function roundedRectPath(cx, cy, halfSize, radii) {
+  const x = cx - halfSize;
+  const y = cy - halfSize;
+  const w = halfSize * 2;
+  const h = halfSize * 2;
+  const { tl, tr, br, bl } = radii;
+  return [
+    `M${x + tl},${y}`,
+    `L${x + w - tr},${y}`,
+    tr > 0 ? `A${tr},${tr} 0 0 1 ${x + w},${y + tr}` : "",
+    `L${x + w},${y + h - br}`,
+    br > 0 ? `A${br},${br} 0 0 1 ${x + w - br},${y + h}` : "",
+    `L${x + bl},${y + h}`,
+    bl > 0 ? `A${bl},${bl} 0 0 1 ${x},${y + h - bl}` : "",
+    `L${x},${y + tl}`,
+    tl > 0 ? `A${tl},${tl} 0 0 1 ${x + tl},${y}` : "",
+    "Z"
+  ].filter(Boolean).join("");
+}
+function dotPath(cx, cy, cellSize, shape, neighbors) {
+  const half = cellSize / 2;
+  if (shape === "square") {
+    return { d: roundedRectPath(cx, cy, half * 0.98, { tl: 0, tr: 0, br: 0, bl: 0 }) };
+  }
+  if (shape === "dots") {
+    return { circle: true };
+  }
+  const isolatedCorner = (a, b) => (a ? 0 : 1) + (b ? 0 : 1) === 2;
+  if (shape === "rounded" || shape === "extra-rounded") {
+    const r2 = half * (shape === "extra-rounded" ? 0.7 : 0.5);
+    return {
+      d: roundedRectPath(cx, cy, half * 0.98, {
+        tl: isolatedCorner(neighbors.top, neighbors.left) ? r2 : 0,
+        tr: isolatedCorner(neighbors.top, neighbors.right) ? r2 : 0,
+        br: isolatedCorner(neighbors.bottom, neighbors.right) ? r2 : 0,
+        bl: isolatedCorner(neighbors.bottom, neighbors.left) ? r2 : 0
+      })
+    };
+  }
+  const r = half * (shape === "classy-rounded" ? 0.65 : 0.4);
+  return {
+    d: roundedRectPath(cx, cy, half * 0.98, {
+      tl: isolatedCorner(neighbors.top, neighbors.left) ? r : 0,
+      br: isolatedCorner(neighbors.bottom, neighbors.right) ? r : 0,
+      tr: 0,
+      bl: 0
+    })
+  };
+}
+var QRCode = React__default.default.forwardRef(function QRCode2({
+  value,
+  size = 256,
+  errorCorrectionLevel,
+  dotsOptions,
+  cornersSquareOptions,
+  cornersDotOptions,
+  dotColor = "#000",
+  eyeColor,
+  backgroundColor = "transparent",
+  logo,
+  logoSize,
+  logoPadding = 8,
+  logoShape = "circle",
+  logoBackgroundColor,
+  onLogoSizeClamped,
+  quietZone = 4,
+  borderRadius = 0,
+  className = "",
+  style = {}
+}, ref) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const resolvedDotColor = (_a = dotsOptions == null ? void 0 : dotsOptions.color) != null ? _a : dotColor;
+  const resolvedDotShape = (_b = dotsOptions == null ? void 0 : dotsOptions.style) != null ? _b : "square";
+  const resolvedCornerSquareColor = (_d = (_c = cornersSquareOptions == null ? void 0 : cornersSquareOptions.color) != null ? _c : eyeColor) != null ? _d : resolvedDotColor;
+  const resolvedCornerSquareShape = (_e = cornersSquareOptions == null ? void 0 : cornersSquareOptions.style) != null ? _e : "square";
+  const resolvedCornerDotColor = (_f = cornersDotOptions == null ? void 0 : cornersDotOptions.color) != null ? _f : resolvedCornerSquareColor;
+  const resolvedCornerDotShape = (_g = cornersDotOptions == null ? void 0 : cornersDotOptions.style) != null ? _g : "square";
+  const isStylized = resolvedDotShape !== "square" || resolvedCornerSquareShape !== "square" || resolvedCornerDotShape !== "square";
+  const resolvedLevel = errorCorrectionLevel != null ? errorCorrectionLevel : logo ? "H" : isStylized ? "Q" : "M";
+  const requestedLogoSize = logoSize != null ? logoSize : size * 0.2;
+  const result = React.useMemo(() => {
+    if (!value) return null;
+    try {
+      return encodeQRCode(value, { errorCorrectionLevel: resolvedLevel });
+    } catch (e) {
+      return null;
+    }
+  }, [value, resolvedLevel]);
+  if (!result) return null;
+  const { modules } = result;
+  const matrixSize = modules.length;
+  const dimension = matrixSize + quietZone * 2;
+  const cellSize = size / dimension;
+  const isEyeModule = (r, c) => r < 7 && c < 7 || r < 7 && c >= matrixSize - 7 || r >= matrixSize - 7 && c < 7;
+  const MAX_SAFE_LOGO_AREA_RATIO = {
+    L: 0.06,
+    M: 0.13,
+    Q: 0.2,
+    H: 0.27
+  };
+  let logoClearRadiusPx = 0;
+  let effectiveLogoImageSize = 0;
+  if (logo) {
+    const requestedRadiusPx = requestedLogoSize / 2 + logoPadding;
+    const requestedRadiusModules = requestedRadiusPx / cellSize;
+    const requestedAreaRatio = Math.PI * requestedRadiusModules ** 2 / (matrixSize * matrixSize);
+    let clearRadiusModules = requestedRadiusModules;
+    const maxAreaRatio = MAX_SAFE_LOGO_AREA_RATIO[resolvedLevel];
+    if (requestedAreaRatio > maxAreaRatio) {
+      clearRadiusModules = Math.sqrt(maxAreaRatio * matrixSize * matrixSize / Math.PI);
+    }
+    const maxRadiusByBorder = Math.max(matrixSize / 2 - 8, 0);
+    clearRadiusModules = Math.min(clearRadiusModules, maxRadiusByBorder);
+    logoClearRadiusPx = clearRadiusModules * cellSize;
+    effectiveLogoImageSize = Math.max(0, logoClearRadiusPx * 2 - logoPadding * 2);
+    const requestedTotalSize = requestedLogoSize + logoPadding * 2;
+    const effectiveTotalSize = logoClearRadiusPx * 2;
+    if (onLogoSizeClamped && effectiveTotalSize < requestedTotalSize - 0.5) {
+      onLogoSizeClamped(effectiveTotalSize, requestedTotalSize);
+    }
+  }
+  const centerModule = matrixSize / 2;
+  const isInLogoClearZone = (r, c) => {
+    if (!logo || logoClearRadiusPx <= 0) return false;
+    const dx = c + 0.5 - centerModule;
+    const dy = r + 0.5 - centerModule;
+    const radiusModules = logoClearRadiusPx / cellSize;
+    if (logoShape === "circle" || logoShape === "none") {
+      return Math.sqrt(dx * dx + dy * dy) < radiusModules;
+    }
+    const half = radiusModules;
+    return Math.abs(dx) < half && Math.abs(dy) < half;
+  };
+  const isRenderable = (r, c) => {
+    var _a2;
+    return ((_a2 = modules[r]) == null ? void 0 : _a2[c]) === true && !isEyeModule(r, c) && !isInLogoClearZone(r, c);
+  };
+  const renderDots = () => {
+    const elements = [];
+    for (let r = 0; r < matrixSize; r++) {
+      for (let c = 0; c < matrixSize; c++) {
+        if (!isRenderable(r, c)) continue;
+        const cx = (c + quietZone + 0.5) * cellSize;
+        const cy = (r + quietZone + 0.5) * cellSize;
+        const neighbors = {
+          top: isRenderable(r - 1, c),
+          right: isRenderable(r, c + 1),
+          bottom: isRenderable(r + 1, c),
+          left: isRenderable(r, c - 1)
+        };
+        const shape = dotPath(cx, cy, cellSize, resolvedDotShape, neighbors);
+        if (shape.circle) {
+          elements.push(
+            /* @__PURE__ */ jsxRuntime.jsx("circle", { cx, cy, r: cellSize * 0.46, fill: resolvedDotColor }, `${r}-${c}`)
+          );
+        } else if (shape.d) {
+          elements.push(/* @__PURE__ */ jsxRuntime.jsx("path", { d: shape.d, fill: resolvedDotColor }, `${r}-${c}`));
+        }
+      }
+    }
+    return elements;
+  };
+  const renderCornerSquare = (cx, cy, key) => {
+    const outerHalf = cellSize * 3.5;
+    const innerHalf = cellSize * 2.5;
+    const strokeMid = (outerHalf + innerHalf) / 2;
+    const strokeWidth = outerHalf - innerHalf;
+    if (resolvedCornerSquareShape === "dot") {
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "circle",
+        {
+          cx,
+          cy,
+          r: strokeMid,
+          fill: "none",
+          stroke: resolvedCornerSquareColor,
+          strokeWidth
+        },
+        key
+      );
+    }
+    if (resolvedCornerSquareShape === "square") {
+      const d2 = `${roundedRectPath(cx, cy, outerHalf, { tl: 0, tr: 0, br: 0, bl: 0 })}${roundedRectPath(
+        cx,
+        cy,
+        innerHalf,
+        { tl: 0, tr: 0, br: 0, bl: 0 }
+      )}`;
+      return /* @__PURE__ */ jsxRuntime.jsx("path", { d: d2, fill: resolvedCornerSquareColor, fillRule: "evenodd" }, key);
+    }
+    const radius = resolvedCornerSquareShape === "classy" ? outerHalf * 0.35 : outerHalf * 0.3;
+    const outerRadii = resolvedCornerSquareShape === "classy" ? { tl: radius, tr: 0, br: radius, bl: 0 } : { tl: radius, tr: radius, br: radius, bl: radius };
+    const d = `${roundedRectPath(cx, cy, outerHalf, outerRadii)}${roundedRectPath(cx, cy, innerHalf, outerRadii)}`;
+    return /* @__PURE__ */ jsxRuntime.jsx("path", { d, fill: resolvedCornerSquareColor, fillRule: "evenodd" }, key);
+  };
+  const renderCornerDot = (cx, cy, key) => {
+    const half = cellSize * 1.5;
+    if (resolvedCornerDotShape === "dot") {
+      return /* @__PURE__ */ jsxRuntime.jsx("circle", { cx, cy, r: half, fill: resolvedCornerDotColor }, key);
+    }
+    const radius = resolvedCornerDotShape === "rounded" ? half * 0.4 : 0;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "path",
+      {
+        d: roundedRectPath(cx, cy, half, { tl: radius, tr: radius, br: radius, bl: radius }),
+        fill: resolvedCornerDotColor
+      },
+      key
+    );
+  };
+  const renderEyes = () => {
+    const positions = [
+      { x: 0, y: 0 },
+      { x: matrixSize - 7, y: 0 },
+      { x: 0, y: matrixSize - 7 }
+    ];
+    return positions.map((pos, i) => {
+      const cx = (pos.x + quietZone + 3.5) * cellSize;
+      const cy = (pos.y + quietZone + 3.5) * cellSize;
+      return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+        renderCornerSquare(cx, cy, `eye-square-${i}`),
+        renderCornerDot(cx, cy, `eye-dot-${i}`)
+      ] }, `eye-${i}`);
+    });
+  };
+  const renderLogo = () => {
+    if (!logo || logoClearRadiusPx <= 0) return null;
+    const center = size / 2;
+    const backdropColor = logoBackgroundColor != null ? logoBackgroundColor : backgroundColor === "transparent" ? "#ffffff" : backgroundColor;
+    let backdrop = null;
+    if (logoShape === "circle") {
+      backdrop = /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: center, cy: center, r: logoClearRadiusPx, fill: backdropColor });
+    } else if (logoShape === "square" || logoShape === "rounded") {
+      const radii = logoShape === "rounded" ? { tl: logoClearRadiusPx * 0.25, tr: logoClearRadiusPx * 0.25, br: logoClearRadiusPx * 0.25, bl: logoClearRadiusPx * 0.25 } : { tl: 0, tr: 0, br: 0, bl: 0 };
+      backdrop = /* @__PURE__ */ jsxRuntime.jsx("path", { d: roundedRectPath(center, center, logoClearRadiusPx, radii), fill: backdropColor });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+      backdrop,
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "image",
+        {
+          href: logo,
+          x: center - effectiveLogoImageSize / 2,
+          y: center - effectiveLogoImageSize / 2,
+          width: effectiveLogoImageSize,
+          height: effectiveLogoImageSize,
+          preserveAspectRatio: "xMidYMid meet"
+        }
+      )
+    ] });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      ref,
+      width: size,
+      height: size,
+      viewBox: `0 0 ${size} ${size}`,
+      className,
+      style: __spreadValues({
+        borderRadius: `${borderRadius}px`,
+        overflow: borderRadius ? "hidden" : void 0
+      }, style),
+      children: [
+        backgroundColor !== "transparent" && /* @__PURE__ */ jsxRuntime.jsx("rect", { x: 0, y: 0, width: size, height: size, fill: backgroundColor }),
+        renderDots(),
+        renderEyes(),
+        renderLogo()
+      ]
+    }
+  );
+});
+QRCode.displayName = "QRCode";
+function triggerBlobDownload(blob, fileName) {
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = fileName;
+  link.click();
+  URL.revokeObjectURL(url);
+}
+function rasterizeSvgToPngBlob(svgString, widthPx, heightPx, scale, backgroundColor) {
+  return new Promise((resolve, reject) => {
+    const svgBlob = new Blob([svgString], { type: "image/svg+xml;charset=utf-8" });
+    const svgUrl = URL.createObjectURL(svgBlob);
+    const image = new Image();
+    image.onload = () => {
+      const canvas = document.createElement("canvas");
+      canvas.width = Math.max(1, Math.round(widthPx * scale));
+      canvas.height = Math.max(1, Math.round(heightPx * scale));
+      const ctx = canvas.getContext("2d");
+      URL.revokeObjectURL(svgUrl);
+      if (!ctx) {
+        reject(new Error("[@core-ease/telegram-kit] Canvas 2D context is not available in this environment."));
+        return;
+      }
+      ctx.fillStyle = backgroundColor;
+      ctx.fillRect(0, 0, canvas.width, canvas.height);
+      ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+      canvas.toBlob((blob) => {
+        if (blob) {
+          resolve(blob);
+        } else {
+          reject(
+            new Error(
+              "[@core-ease/telegram-kit] Failed to export PNG. If you set a `logo`, this usually means it is a cross-origin image without CORS headers, which taints the canvas. Use a same-origin image, an image served with CORS enabled, or a data URI logo instead."
+            )
+          );
+        }
+      }, "image/png");
+    };
+    image.onerror = () => {
+      URL.revokeObjectURL(svgUrl);
+      reject(new Error("[@core-ease/telegram-kit] Failed to rasterize the QR code SVG for PNG export."));
+    };
+    image.src = svgUrl;
+  });
+}
+async function downloadQRCode(svgElement, options = {}) {
+  const { format = "svg", fileName = "qrcode", scale = 2, pngBackgroundColor = "#ffffff" } = options;
+  if (!svgElement) {
+    throw new Error("[@core-ease/telegram-kit] downloadQRCode: no <svg> element was provided (is the ref attached yet?).");
+  }
+  if (typeof document === "undefined") {
+    throw new Error("[@core-ease/telegram-kit] downloadQRCode can only run in a browser environment.");
+  }
+  const svgString = new XMLSerializer().serializeToString(svgElement);
+  if (format === "svg") {
+    const blob = new Blob([svgString], { type: "image/svg+xml" });
+    triggerBlobDownload(blob, `${fileName}.svg`);
+    return;
+  }
+  const width = svgElement.width.baseVal.value || svgElement.clientWidth || 512;
+  const height = svgElement.height.baseVal.value || svgElement.clientHeight || 512;
+  const pngBlob = await rasterizeSvgToPngBlob(svgString, width, height, scale, pngBackgroundColor);
+  triggerBlobDownload(pngBlob, `${fileName}.png`);
+}
+
+exports.QRCode = QRCode;
+exports.downloadQRCode = downloadQRCode;
+exports.encodeQRCode = encodeQRCode;
+exports.qrCodeToSVG = qrCodeToSVG;